fix missing sequence within choice

src/Schema/Element/Choice.php

@@ -9,28 +9,5 @@
 class Choice extends AbstractNamedGroupItem implements ElementItem, ElementContainer, InterfaceSetMinMax
 {
     use ElementContainerTrait;
-
-    protected int $min = 1;
-
-    protected int $max = 1;
-
-    public function getMin(): int
-    {
-        return $this->min;
-    }
-
-    public function setMin(int $min): void
-    {
-        $this->min = $min;
-    }
-
-    public function getMax(): int
-    {
-        return $this->max;
-    }
-
-    public function setMax(int $max): void
-    {
-        $this->max = $max;
-    }
+    use MinMaxTrait;
 }

src/Schema/Element/MinMaxTrait.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GoetasWebservices\XML\XSDReader\Schema\Element;
+
+trait MinMaxTrait
+{
+    protected int $min = 1;
+
+    protected int $max = 1;
+
+    public function getMin(): int
+    {
+        return $this->min;
+    }
+
+    public function setMin(int $min): void
+    {
+        $this->min = $min;
+    }
+
+    public function getMax(): int
+    {
+        return $this->max;
+    }
+
+    public function setMax(int $max): void
+    {
+        $this->max = $max;
+    }
+}

src/Schema/Element/Sequence.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GoetasWebservices\XML\XSDReader\Schema\Element;
+
+use GoetasWebservices\XML\XSDReader\Schema\AbstractNamedGroupItem;
+
+class Sequence extends AbstractNamedGroupItem implements ElementItem, ElementContainer, InterfaceSetMinMax
+{
+    use ElementContainerTrait;
+    use MinMaxTrait;
+}

src/SchemaReader.php

@@ -27,6 +27,7 @@
 use GoetasWebservices\XML\XSDReader\Schema\Element\InterfaceSetDefault;
 use GoetasWebservices\XML\XSDReader\Schema\Element\InterfaceSetFixed;
 use GoetasWebservices\XML\XSDReader\Schema\Element\InterfaceSetMinMax;
+use GoetasWebservices\XML\XSDReader\Schema\Element\Sequence;
 use GoetasWebservices\XML\XSDReader\Schema\Exception\TypeNotFoundException;
 use GoetasWebservices\XML\XSDReader\Schema\Inheritance\Base;
 use GoetasWebservices\XML\XSDReader\Schema\Inheritance\Extension;
@@ -379,16 +380,16 @@ private function loadSequence(ElementContainer $elementContainer, \DOMElement $n
     {
         $max =
             (
-                (is_int($max) && (bool) $max) ||
-                'unbounded' === $node->getAttribute('maxOccurs') ||
-                1 < $node->getAttribute('maxOccurs')
+                (is_int($max) && (bool) $max)
+                || 'unbounded' === $node->getAttribute('maxOccurs')
+                || 1 < $node->getAttribute('maxOccurs')
             )
                 ? 2
                 : null;
         $min =
             (
-                null === $min &&
-                !$node->hasAttribute('minOccurs')
+                null === $min
+                && !$node->hasAttribute('minOccurs')
             )
                 ? null
                 : (int) max((int) $min, $node->getAttribute('minOccurs'));
@@ -417,8 +418,14 @@ private function loadSequenceChildNode(
         switch ($childNode->localName) {
             case 'sequence':
             case 'all':
+                $sequence = null;
+                if ($elementContainer instanceof Choice) {
+                    // add sequence explicitly to avoid competing sequences within the choice
+                    $sequence = $this->createSequence($elementContainer->getSchema(), $node);
+                    $elementContainer->addElement($sequence);
+                }
                 $this->loadSequence(
-                    $elementContainer,
+                    $sequence ?? $elementContainer,
                     $childNode,
                     $max,
                     $min
@@ -590,6 +597,16 @@ private function createChoice(Schema $schema, \DOMElement $node): Choice
         return $choice;
     }
 
+    private function createSequence(Schema $schema, \DOMElement $node): Sequence
+    {
+        $sequence = new Sequence($schema, '');
+        $sequence->setDoc($this->getDocumentation($node));
+        self::maybeSetMax($sequence, $node);
+        self::maybeSetMin($sequence, $node);
+
+        return $sequence;
+    }
+
     private function loadComplexType(Schema $schema, \DOMElement $node, ?\Closure $callback = null): \Closure
     {
         /**
@@ -1063,8 +1080,8 @@ private function fillItem(Item $element, \DOMElement $node, ?\DOMElement $parent
             $node,
             function (\DOMElement $node, \DOMElement $childNode) use ($element, &$skip): void {
                 if (
-                    !$skip &&
-                    in_array(
+                    !$skip
+                    && in_array(
                         $childNode->localName,
                         [
                             'complexType',

tests/ChoiceTest.php

@@ -5,7 +5,9 @@
 namespace GoetasWebservices\XML\XSDReader\Tests;
 
 use GoetasWebservices\XML\XSDReader\Schema\Element\Choice;
+use GoetasWebservices\XML\XSDReader\Schema\Element\Sequence;
 use GoetasWebservices\XML\XSDReader\Schema\Type\ComplexType;
+use GoetasWebservices\XML\XSDReader\Schema\Type\SimpleType;
 
 class ChoiceTest extends BaseTest
 {
@@ -278,4 +280,73 @@ public function testChoiceNested(): void
         self::assertEquals(0, $dessertChoice->getMin());
         self::assertEquals(-1, $dessertChoice->getMax());
     }
+
+    public function testChoiceWithSequences(): void
+    {
+        $schema = $this->reader->readString(
+            '
+            <xs:schema targetNamespace="http://www.example.com" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+                <xs:element name="root">
+                    <xs:complexType>
+                      <xs:sequence>
+                        <xs:element minOccurs="1" name="Intro" type="xs:string"/>
+                        <xs:choice>
+                          <xs:sequence>
+                            <xs:choice>
+                              <xs:element name="Red" type="xs:string"/>
+                              <xs:element name="Green" type="xs:string"/>
+                              <xs:element name="Blue" type="xs:string"/>
+                            </xs:choice>
+                            <xs:element name="Outro1" type="xs:string"/>
+                          </xs:sequence>
+                          <xs:sequence>
+                            <xs:element name="AlternateElement"/>
+                            <xs:element name="Outro2" type="xs:string"/>
+                          </xs:sequence>
+                        </xs:choice>
+                      </xs:sequence>
+                    </xs:complexType>
+                </xs:element>
+
+            </xs:schema>
+        ');
+
+        $rootType = $schema->getElements()['root']->getType();
+        self::assertInstanceOf(ComplexType::class, $rootType);
+
+        $elements = $rootType->getElements();
+        self::assertCount(2, $elements);
+
+        self::assertEquals('Intro', $elements[0]->getName());
+        self::assertInstanceOf(SimpleType::class, $elements[0]->getType());
+
+        $choice = $elements[1];
+        self::assertInstanceOf(Choice::class, $choice);
+        self::assertEquals(1, $choice->getMin());
+        self::assertEquals(1, $choice->getMax());
+
+        $choiceElements = $choice->getElements();
+        self::assertCount(2, $choiceElements);
+
+        $sequence1 = $choiceElements[0];
+        self::assertInstanceOf(Sequence::class, $sequence1);
+        $sequence2 = $choiceElements[1];
+        self::assertInstanceOf(Sequence::class, $sequence2);
+
+        $sequence1Elements = $sequence1->getElements();
+        $innerChoice = $sequence1Elements[0];
+        self::assertInstanceOf(Choice::class, $innerChoice);
+        $innerChoiceElements = $innerChoice->getElements();
+        self::assertCount(3, $innerChoiceElements);
+        self::assertEquals('Red', $innerChoiceElements[0]->getName());
+        self::assertEquals('Green', $innerChoiceElements[1]->getName());
+        self::assertEquals('Blue', $innerChoiceElements[2]->getName());
+        self::assertEquals('Outro1', $sequence1Elements[1]->getName());
+
+        $sequence2Elements = $sequence2->getElements();
+        self::assertCount(2, $sequence2Elements);
+        self::assertEquals('AlternateElement', $sequence2Elements[0]->getName());
+        self::assertEquals('Outro2', $sequence2Elements[1]->getName());
+    }
 }