lutaml-model 0.8.32 → 0.8.34

data/spec/lutaml/model/schema/xsd_schema_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 require "lutaml/model/schema"
-require "nokogiri"
+require "bigdecimal"
 
 module SchemaGeneration
   class Glaze < Lutaml::Model::Serializable
@@ -14,6 +14,136 @@ module SchemaGeneration
     attribute :glaze, Glaze
     attribute :materials, Lutaml::Model::Type::String, collection: true
   end
+
+  class Percent < Lutaml::Model::Type::Integer
+    inclusive min: 0, max: 100
+  end
+
+  class Money < Lutaml::Model::Type::Decimal
+    exclusive min: BigDecimal("1.5")
+    total_digits 5
+    fraction_digits 2
+  end
+
+  class Code < Lutaml::Model::Type::String
+    length min: 2, max: 8
+    enumeration "AB", "CD"
+    white_space :collapse
+    pattern(/[A-Z]+/)
+  end
+
+  class Tag < Lutaml::Model::Type::String
+    length min: 1, max: 3
+  end
+
+  # Two accumulated patterns are conjunctive (a value must match BOTH). XSD has
+  # no way to express that in one restriction (sibling <xs:pattern> is OR), so
+  # exporting it must fail fast rather than silently emit a weaker OR schema.
+  class MultiPattern < Lutaml::Model::Type::String
+    pattern(/\A\d+\z/)
+    pattern(/\A.{4}\z/)
+  end
+
+  class MultiPatternHolder < Lutaml::Model::Serializable
+    attribute :field, MultiPattern
+    xml do
+      root "MultiPatternHolder"
+      map_element "field", to: :field
+    end
+  end
+
+  # XSD patterns are implicitly whole-string anchored, so the Ruby \A...\z
+  # anchors must be stripped on export or Nokogiri rejects the pattern.
+  class Anchored < Lutaml::Model::Type::String
+    pattern(/\A[A-Z]{3}\z/)
+  end
+
+  class AnchoredHolder < Lutaml::Model::Serializable
+    attribute :field, Anchored
+    xml do
+      root "AnchoredHolder"
+      map_element "field", to: :field
+    end
+  end
+
+  # A lookahead is not expressible in XSD's regexp subset; export must raise
+  # rather than emit invalid XSD.
+  class Lookahead < Lutaml::Model::Type::String
+    pattern(/(?=.*[0-9])[a-z0-9]+/)
+  end
+
+  class LookaheadHolder < Lutaml::Model::Serializable
+    attribute :field, Lookahead
+    xml do
+      root "LookaheadHolder"
+      map_element "field", to: :field
+    end
+  end
+
+  # A case-insensitive flag cannot be expressed in XSD; export must raise
+  # rather than silently emit a case-sensitive pattern.
+  class FlaggedPattern < Lutaml::Model::Type::String
+    pattern(/[a-z]+/i)
+  end
+
+  class FlaggedHolder < Lutaml::Model::Serializable
+    attribute :field, FlaggedPattern
+    xml do
+      root "FlaggedHolder"
+      map_element "field", to: :field
+    end
+  end
+
+  # Layer-1 attribute facets (no Layer-2 constrained type) must still emit an
+  # inline xs:restriction so the schema matches what the model enforces.
+  class Layered < Lutaml::Model::Serializable
+    attribute :age, :integer, min: 0, max: 120
+    attribute :code, :string, min_length: 2, max_length: 8
+    xml do
+      root "Layered"
+      map_element "age", to: :age
+      map_element "code", to: :code
+    end
+  end
+
+  # The pre-#191 values:/pattern: options are enforced at runtime and must also
+  # reach the exported schema.
+  class LegacyOptions < Lutaml::Model::Serializable
+    attribute :state, :string, values: %w[on off]
+    attribute :ref, :string, pattern: /[A-Z]{2}/
+    xml do
+      root "LegacyOptions"
+      map_element "state", to: :state
+      map_element "ref", to: :ref
+    end
+  end
+
+  # A Layer-1 option (max: 50) that tightens a Layer-2 type (Percent, max 100):
+  # the merge is consistent, so export must emit the tighter bound, not raise.
+  class MergedLayers < Lutaml::Model::Serializable
+    attribute :n, Percent, max: 50
+    xml do
+      root "MergedLayers"
+      map_element "n", to: :n
+    end
+  end
+
+  class Record < Lutaml::Model::Serializable
+    attribute :code, Code
+    attribute :percent, Percent
+    attribute :money, Money
+    attribute :tags, Tag, collection: true
+    attribute :note, Lutaml::Model::Type::String
+
+    xml do
+      root "Record"
+      map_attribute "code", to: :code
+      map_element "percent", to: :percent
+      map_element "money", to: :money
+      map_element "tags", to: :tags
+      map_element "note", to: :note
+    end
+  end
 end
 
 RSpec.describe Lutaml::Xml::Schema::XsdSchema do
@@ -52,764 +182,279 @@ RSpec.describe Lutaml::Xml::Schema::XsdSchema do
 
       expect(schema).to eq(expected_schema)
     end
-  end
 
-  # Regression guard for issue #717: the generated XSD bound the XSD namespace
-  # only as the default xmlns while referencing built-in types with an
-  # undeclared "xs:" prefix, so no XSD processor could load the output.
-  describe "generated XSD validity (issue #717)" do
-    it "produces a schema Nokogiri can load (no target namespace)" do
-      klass = Class.new(Lutaml::Model::Serializable) do
-        attribute :id, :string
-        xml do
-          root "address"
-          map_element "id", to: :id
-        end
+    context "with constrained value types (issue #191)" do
+      subject(:schema) do
+        described_class.generate(SchemaGeneration::Record, pretty: true)
+      end
+
+      # Indentation depends on nesting depth; compare with leading whitespace
+      # stripped so the assertions pin structure and order, not column counts.
+      let(:unindented) { schema.gsub(/^ +/, "") }
+
+      it "inlines an xs:restriction with facets in canonical order for an attribute" do
+        expect(unindented).to include(<<~XSD.chomp)
+          <xs:attribute name="code">
+          <xs:simpleType>
+          <xs:restriction base="xs:string">
+          <xs:minLength value="2"/>
+          <xs:maxLength value="8"/>
+          <xs:enumeration value="AB"/>
+          <xs:enumeration value="CD"/>
+          <xs:whiteSpace value="collapse"/>
+          <xs:pattern value="[A-Z]+"/>
+          </xs:restriction>
+          </xs:simpleType>
+          </xs:attribute>
+        XSD
+      end
+
+      it "emits integer inclusive bounds on a simple element" do
+        expect(unindented).to include(<<~XSD.chomp)
+          <xs:element name="percent">
+          <xs:simpleType>
+          <xs:restriction base="xs:integer">
+          <xs:minInclusive value="0"/>
+          <xs:maxInclusive value="100"/>
+          </xs:restriction>
+          </xs:simpleType>
+          </xs:element>
+        XSD
       end
 
-      xsd = Lutaml::Model::Schema.to_xsd(klass)
-
-      expect(xsd).to include('<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"')
-      expect(xsd).to include('type="xs:string"')
-      expect { Nokogiri::XML::Schema(xsd) }.not_to raise_error
-    end
-
-    it "produces a schema Nokogiri can load (with target namespace)" do
-      ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://example.com/addr"
-        prefix_default "ex"
-        element_form_default :qualified
-      end
-      klass = Class.new(Lutaml::Model::Serializable) do
-        attribute :street, :string
-        xml do
-          root "address"
-          namespace ns
-          map_element "street", to: :street
-        end
+      it "renders decimal bounds and digit facets with exact lexical values" do
+        expect(schema).to include('<xs:restriction base="xs:decimal">')
+        expect(schema).to include('<xs:minExclusive value="1.5"/>')
+        expect(schema).to include('<xs:totalDigits value="5"/>')
+        expect(schema).to include('<xs:fractionDigits value="2"/>')
       end
 
-      xsd = Lutaml::Model::Schema.to_xsd(klass)
-
-      expect(xsd).to include('xmlns:xs="http://www.w3.org/2001/XMLSchema"')
-      expect(xsd).to include('targetNamespace="http://example.com/addr"')
-      expect { Nokogiri::XML::Schema(xsd) }.not_to raise_error
-    end
-
-    # The hole #717 fell through: a nested named-type reference under a target
-    # namespace must be prefixed, or it resolves to no-namespace and fails.
-    it "qualifies named-type references under a target namespace" do
-      ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://example.com/addr"
-        prefix_default "ex"
-        element_form_default :qualified
-      end
-      widget = Class.new(Lutaml::Model::Serializable) do
-        attribute :label, :string
-        xml do
-          root "widget"
-          type_name "WidgetType"
-          map_element "label", to: :label
-        end
-      end
-      doc = Class.new(Lutaml::Model::Serializable) do
-        attribute :widget, widget
-        attribute :title, :string
-        xml do
-          root "doc"
-          namespace ns
-          map_element "widget", to: :widget
-          map_element "title", to: :title
-        end
+      it "inlines the restriction on the item of a constrained collection" do
+        expect(unindented).to include(<<~XSD.chomp)
+          <xs:element name="item">
+          <xs:simpleType>
+          <xs:restriction base="xs:string">
+          <xs:minLength value="1"/>
+          <xs:maxLength value="3"/>
+          </xs:restriction>
+          </xs:simpleType>
+          </xs:element>
+        XSD
       end
 
-      xsd = Lutaml::Model::Schema.to_xsd(doc)
-
-      expect(xsd).to include('xmlns:ex="http://example.com/addr"')
-      expect(xsd).to include('type="ex:WidgetType"')
-      expect(xsd).to include('<xs:complexType name="WidgetType">')
-      expect(xsd).not_to include("<xs:import")
-      expect { Nokogiri::XML::Schema(xsd) }.not_to raise_error
-    end
-
-    # Guard against over-eager prefixing: with no namespace, named-type refs
-    # must stay unqualified (they resolve to no-namespace, which is valid).
-    it "leaves named-type references unqualified when there is no namespace" do
-      inner = Class.new(Lutaml::Model::Serializable) do
-        attribute :city, :string
-        xml do
-          root "address"
-          type_name "AddressType"
-          map_element "city", to: :city
-        end
-      end
-      outer = Class.new(Lutaml::Model::Serializable) do
-        attribute :address, inner
-        xml do
-          root "person"
-          map_element "address", to: :address
-        end
+      it "leaves an unconstrained type as a flat type reference" do
+        expect(schema).to include('<xs:element name="note" type="xs:string"/>')
+        expect(schema).not_to match(/name="code"[^>]*type=/)
       end
 
-      xsd = Lutaml::Model::Schema.to_xsd(outer)
-
-      expect(xsd).to include('type="AddressType"')
-      expect(xsd).not_to include('type=":AddressType"')
-      expect { Nokogiri::XML::Schema(xsd) }.not_to raise_error
-    end
-
-    it "qualifies named-type references for collections under a target namespace" do
-      ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://example.com/addr"
-        prefix_default "ex"
-        element_form_default :qualified
-      end
-      item = Class.new(Lutaml::Model::Serializable) do
-        attribute :label, :string
-        xml do
-          root "item"
-          type_name "ItemType"
-          map_element "label", to: :label
-        end
+      it "fails fast on conjunctive patterns rather than emitting OR siblings" do
+        expect do
+          described_class.generate(SchemaGeneration::MultiPatternHolder)
+        end.to raise_error(Lutaml::Model::Error, /conjunctive pattern/)
       end
-      doc = Class.new(Lutaml::Model::Serializable) do
-        attribute :items, item, collection: true
-        xml do
-          root "doc"
-          namespace ns
-          map_element "item", to: :items
-        end
-      end
-
-      xsd = Lutaml::Model::Schema.to_xsd(doc)
-
-      expect(xsd).to include('type="ex:ItemType"')
-      expect { Nokogiri::XML::Schema(xsd) }.not_to raise_error
     end
 
-    # A nested model in its OWN (different) namespace is imported and referenced
-    # by its own prefix, NOT folded into the root namespace. (A schema document
-    # has a single targetNamespace, so its type lives in its own schema.)
-    it "imports and prefixes a nested model that declares a different namespace" do
-      w_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://w.example/w"
-        prefix_default "w"
-        element_form_default :qualified
-        schema_location "widget.xsd"
-      end
-      ex_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://ex.example/ex"
-        prefix_default "ex"
-        element_form_default :qualified
-      end
-      widget = Class.new(Lutaml::Model::Serializable) do
-        attribute :label, :string
-        xml do
-          root "widget"
-          namespace w_ns
-          type_name "WidgetType"
-          map_element "label", to: :label
-        end
-      end
-      doc = Class.new(Lutaml::Model::Serializable) do
-        attribute :widget, widget
-        xml do
-          root "doc"
-          namespace ex_ns
-          map_element "widget", to: :widget
-        end
-      end
+    context "with a Ruby pattern exported to XSD (issue #191)" do
+      it "strips the Ruby whole-string anchors" do
+        schema = described_class.generate(SchemaGeneration::AnchoredHolder)
 
-      xsd = Lutaml::Model::Schema.to_xsd(doc)
-
-      # both namespaces declared, foreign one imported, ref uses its own prefix
-      expect(xsd).to include('xmlns:w="http://w.example/w"')
-      expect(xsd).to include('targetNamespace="http://ex.example/ex"')
-      expect(xsd).to include('<xs:import namespace="http://w.example/w" schemaLocation="widget.xsd"/>')
-      expect(xsd).to include('type="w:WidgetType"')
-      # the foreign type is NOT defined in this document
-      expect(xsd).not_to include('<xs:complexType name="WidgetType">')
-    end
-
-    # A target namespace whose class declares no prefix_default still needs a
-    # usable prefix for named-type QNames; one is synthesised (tns).
-    it "synthesises a prefix for a target namespace with no prefix_default" do
-      ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://example.com/np"
-        element_form_default :qualified
+        expect(schema).to include('<xs:pattern value="[A-Z]{3}"/>')
       end
-      klass = Class.new(Lutaml::Model::Serializable) do
-        attribute :id, :string
-        xml do
-          root "root"
-          namespace ns
-          type_name "RootType"
-          map_element "id", to: :id
-        end
-      end
-
-      xsd = Lutaml::Model::Schema.to_xsd(klass)
 
-      expect(xsd).to include('xmlns:tns="http://example.com/np"')
-      expect(xsd).to include('type="tns:RootType"')
-      expect { Nokogiri::XML::Schema(xsd) }.not_to raise_error
-    end
+      it "emits a pattern Nokogiri accepts as valid XSD" do
+        schema = described_class.generate(SchemaGeneration::AnchoredHolder)
+        value = schema[/<xs:pattern value="([^"]*)"/, 1]
+        wrapped = <<~XSD
+          <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+            <xs:simpleType name="T">
+              <xs:restriction base="xs:string">
+                <xs:pattern value="#{value}"/>
+              </xs:restriction>
+            </xs:simpleType>
+          </xs:schema>
+        XSD
 
-    # Two different namespaces bound to the same prefix are unresolvable; the
-    # generator raises rather than emit a silently-wrong QName.
-    it "raises when two namespaces share a prefix" do
-      a_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://a.example"
-        prefix_default "p"
-      end
-      b_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://b.example"
-        prefix_default "p"
-      end
-      child = Class.new(Lutaml::Model::Serializable) do
-        attribute :v, :string
-        xml do
-          root "child"
-          namespace b_ns
-          type_name "BType"
-          map_element "v", to: :v
-        end
-      end
-      parent = Class.new(Lutaml::Model::Serializable) do
-        attribute :child, child
-        xml do
-          root "parent"
-          namespace a_ns
-          map_element "child", to: :child
-        end
+        expect { Nokogiri::XML::Schema(wrapped) }.not_to raise_error
       end
 
-      expect { Lutaml::Model::Schema.to_xsd(parent) }
-        .to raise_error(Lutaml::Model::Error, /prefix 'p' is bound to two/)
-    end
-
-    # A recursive model (A -> B -> A) must terminate and define both types.
-    it "handles recursive model references without overflowing" do
-      rec_a = Class.new(Lutaml::Model::Serializable)
-      rec_b = Class.new(Lutaml::Model::Serializable) do
-        attribute :a, rec_a
-        xml do
-          root "b"
-          type_name "BType"
-          map_element "a", to: :a
-        end
-      end
-      rec_a.class_eval do
-        attribute :b, rec_b
-        xml do
-          root "a"
-          type_name "AType"
-          map_element "b", to: :b
-        end
+      it "raises for a construct XSD cannot express" do
+        expect do
+          described_class.generate(SchemaGeneration::LookaheadHolder)
+        end.to raise_error(Lutaml::Model::Error, /not expressible/)
       end
 
-      xsd = nil
-      expect { xsd = Lutaml::Model::Schema.to_xsd(rec_a) }.not_to raise_error
-      expect(xsd).to include('<xs:complexType name="AType">')
-      expect(xsd).to include('<xs:complexType name="BType">')
-    end
+      it "raises for a regexp flag XSD cannot express" do
+        expect do
+          described_class.generate(SchemaGeneration::FlaggedHolder)
+        end.to raise_error(Lutaml::Model::Error, /i\/m\/x flags/)
+      end
 
-    # A foreign namespace with no usable prefix (nil, empty, or the reserved
-    # "xs") cannot be referenced by a prefixed QName and must not borrow the
-    # target prefix — raise instead.
-    [nil, "", "xs"].each do |bad_prefix|
-      it "raises for a foreign namespace with unusable prefix #{bad_prefix.inspect}" do
-        foreign = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-          uri "http://foreign.example"
-          prefix_default bad_prefix unless bad_prefix.nil?
-          element_form_default :qualified
-        end
-        ex_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-          uri "http://ex.example/ex"
-          prefix_default "ex"
-        end
-        child = Class.new(Lutaml::Model::Serializable) do
-          attribute :v, :string
+      it "raises for a lazy quantifier XSD cannot express" do
+        holder = Class.new(Lutaml::Model::Serializable) do
+          attribute :field, Class.new(Lutaml::Model::Type::String) {
+            pattern(/a+?/)
+          }
           xml do
-            root "child"
-            namespace foreign
-            type_name "ForeignType"
-            map_element "v", to: :v
+            root "LazyHolder"
+            map_element "field", to: :field
           end
         end
-        parent = Class.new(Lutaml::Model::Serializable) do
-          attribute :child, child
+
+        expect { described_class.generate(holder) }
+          .to raise_error(Lutaml::Model::Error, /not expressible in XSD/)
+      end
+
+      # Backslash-run parity: `\\z` is an escaped backslash + literal "z", not
+      # the `\z` anchor, so it must survive stripping (and be valid XSD) rather
+      # than being truncated to a dangling backslash and spuriously rejected.
+      it "keeps a literal escaped-backslash before z (even run)" do
+        holder = Class.new(Lutaml::Model::Serializable) do
+          attribute :field, Class.new(Lutaml::Model::Type::String) {
+            pattern(/\\z/)
+          }
           xml do
-            root "parent"
-            namespace ex_ns
-            map_element "child", to: :child
+            root "BackslashZ"
+            map_element "field", to: :field
           end
         end
 
-        expect { Lutaml::Model::Schema.to_xsd(parent) }
-          .to raise_error(Lutaml::Model::Error, /foreign namespace .* usable prefix/)
+        expect(described_class.generate(holder))
+          .to include('<xs:pattern value="\\\\z"/>')
       end
-    end
 
-    # Namespaces used only INSIDE an imported foreign type belong to that
-    # type's own schema document — they must not be declared, imported, or
-    # validated here.
-    it "ignores namespaces nested inside an imported foreign subtree" do
-      inner_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://c.example" # deliberately no prefix_default
-      end
-      w_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://w.example/w"
-        prefix_default "w"
-        schema_location "widget.xsd"
-      end
-      ex_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://ex.example/ex"
-        prefix_default "ex"
-      end
-      inner = Class.new(Lutaml::Model::Serializable) do
-        attribute :v, :string
-        xml do
-          root "inner"
-          namespace inner_ns
-          type_name "InnerType"
-          map_element "v", to: :v
-        end
-      end
-      widget = Class.new(Lutaml::Model::Serializable) do
-        attribute :inner, inner
-        xml do
-          root "widget"
-          namespace w_ns
-          type_name "WidgetType"
-          map_element "inner", to: :inner
-        end
-      end
-      doc = Class.new(Lutaml::Model::Serializable) do
-        attribute :widget, widget
-        xml do
-          root "doc"
-          namespace ex_ns
-          map_element "widget", to: :widget
+      # `\\$` is an escaped backslash followed by the end anchor `$` (even run
+      # before `$`), so the anchor strips, leaving the literal backslash.
+      it "strips a trailing $ anchor after an escaped backslash" do
+        holder = Class.new(Lutaml::Model::Serializable) do
+          attribute :field, Class.new(Lutaml::Model::Type::String) {
+            pattern(/\\$/)
+          }
+          xml do
+            root "BackslashDollar"
+            map_element "field", to: :field
+          end
         end
-      end
-
-      xsd = Lutaml::Model::Schema.to_xsd(doc)
-
-      expect(xsd).to include('type="w:WidgetType"')
-      expect(xsd).not_to include("http://c.example")
-    end
 
-    it "raises when a foreign namespace has no schema_location" do
-      w_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://w-noloc.example/w"
-        prefix_default "w" # no schema_location
+        expect(described_class.generate(holder))
+          .to include('<xs:pattern value="\\\\"/>')
       end
-      ex_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://ex.example/ex"
-        prefix_default "ex"
-      end
-      widget = Class.new(Lutaml::Model::Serializable) do
-        attribute :label, :string
-        xml do
-          root "widget"
-          namespace w_ns
-          type_name "WidgetType"
-          map_element "label", to: :label
-        end
-      end
-      doc = Class.new(Lutaml::Model::Serializable) do
-        attribute :widget, widget
-        xml do
-          root "doc"
-          namespace ex_ns
-          map_element "widget", to: :widget
-        end
-      end
-
-      expect { Lutaml::Model::Schema.to_xsd(doc) }
-        .to raise_error(Lutaml::Model::Error, /schema_location/)
-    end
 
-    it "downgrades foreign-namespace errors to warnings under skip_validation" do
-      w_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://w-warn.example/w"
-        prefix_default "w" # no schema_location -> error without skip_validation
-      end
-      ex_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://ex.example/ex"
-        prefix_default "ex"
-      end
-      widget = Class.new(Lutaml::Model::Serializable) do
-        attribute :label, :string
-        xml do
-          root "widget"
-          namespace w_ns
-          type_name "WidgetType"
-          map_element "label", to: :label
-        end
-      end
-      doc = Class.new(Lutaml::Model::Serializable) do
-        attribute :widget, widget
-        xml do
-          root "doc"
-          namespace ex_ns
-          map_element "widget", to: :widget
+      # A long run of backslashes must be counted correctly (and in linear time,
+      # not the polynomial backtracking a run-quantifier regex would incur). An
+      # even run before `z` is all escaped pairs -> literal, kept verbatim.
+      it "handles a long even backslash run in linear time" do
+        holder = Class.new(Lutaml::Model::Serializable) do
+          attribute :field, Class.new(Lutaml::Model::Type::String) {
+            pattern(/\\\\\\\\z/) # 8 source backslashes -> 4 literal, then z
+          }
+          xml do
+            root "LongBackslash"
+            map_element "field", to: :field
+          end
         end
-      end
-
-      xsd = nil
-      expect { xsd = Lutaml::Model::Schema.to_xsd(doc, skip_validation: true) }
-        .to output(/schema_location/).to_stderr
-
-      # Best-effort output still declares the usable prefix its QNames use,
-      # and imports the namespace (location-less).
-      expect(xsd).to include('xmlns:w="http://w-warn.example/w"')
-      expect(xsd).to include('type="w:WidgetType"')
-      expect(xsd).to include('<xs:import namespace="http://w-warn.example/w"/>')
-    end
 
-    # Prefix errors emit QNames that resolve to the WRONG namespace, so they
-    # stay hard errors even under skip_validation.
-    it "does not downgrade prefix errors under skip_validation" do
-      no_pfx = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://p-hard.example" # no prefix_default
-      end
-      ex_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://ex.example/ex"
-        prefix_default "ex"
-      end
-      child = Class.new(Lutaml::Model::Serializable) do
-        attribute :v, :string
-        xml do
-          root "child"
-          namespace no_pfx
-          type_name "PType"
-          map_element "v", to: :v
-        end
+        expect(described_class.generate(holder))
+          .to include('<xs:pattern value="\\\\\\\\\\\\\\\\z"/>')
       end
-      parent = Class.new(Lutaml::Model::Serializable) do
-        attribute :child, child
-        xml do
-          root "parent"
-          namespace ex_ns
-          map_element "child", to: :child
-        end
-      end
-
-      expect do
-        Lutaml::Model::Schema.to_xsd(parent, skip_validation: true)
-      end.to raise_error(Lutaml::Model::Error, /usable prefix/)
     end
 
-    # A Type::Value attribute type that declares its own namespace resolves
-    # through that namespace's imported schema.
-    it "declares and imports a Type::Value attribute type's namespace" do
-      gml_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://www.opengis.net/gml"
-        prefix_default "gml"
-        schema_location "gml.xsd"
-      end
-      measure = Class.new(Lutaml::Model::Type::String) do
-        xml { namespace gml_ns }
-        xsd_type "gml:MeasureType"
-      end
-      doc = Class.new(Lutaml::Model::Serializable) do
-        attribute :measure, measure
-        xml do
-          root "doc"
-          map_element "measure", to: :measure
-        end
+    context "with Layer-1 attribute facets (issue #191)" do
+      subject(:schema) do
+        described_class.generate(SchemaGeneration::Layered, pretty: true)
       end
 
-      # skip_validation matches main's behavior for namespaced custom types;
-      # accepting them in validation is a deferred follow-up.
-      xsd = Lutaml::Model::Schema.to_xsd(doc, skip_validation: true)
+      let(:unindented) { schema.gsub(/^ +/, "") }
 
-      expect(xsd).to include('xmlns:gml="http://www.opengis.net/gml"')
-      expect(xsd).to include('<xs:import namespace="http://www.opengis.net/gml" schemaLocation="gml.xsd"/>')
-      expect(xsd).to include('type="gml:MeasureType"')
-    end
-
-    it "synthesizes a non-colliding prefix when a foreign namespace claims tns" do
-      no_pfx_target = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://example.com/np" # no prefix_default -> synthesized
-      end
-      tns_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://t.example"
-        prefix_default "tns"
-        schema_location "t.xsd"
-      end
-      child = Class.new(Lutaml::Model::Serializable) do
-        attribute :v, :string
-        xml do
-          root "child"
-          namespace tns_ns
-          type_name "TType"
-          map_element "v", to: :v
-        end
-      end
-      doc = Class.new(Lutaml::Model::Serializable) do
-        attribute :child, child
-        attribute :id, :string
-        xml do
-          root "doc"
-          namespace no_pfx_target
-          type_name "DocType"
-          map_element "child", to: :child
-          map_element "id", to: :id
-        end
+      it "inlines an xs:restriction for attribute min/max bounds" do
+        expect(unindented).to include(<<~XSD.chomp)
+          <xs:element name="age">
+          <xs:simpleType>
+          <xs:restriction base="xs:integer">
+          <xs:minInclusive value="0"/>
+          <xs:maxInclusive value="120"/>
+          </xs:restriction>
+          </xs:simpleType>
+          </xs:element>
+        XSD
+      end
+
+      it "inlines an xs:restriction for attribute length bounds" do
+        expect(unindented).to include(<<~XSD.chomp)
+          <xs:element name="code">
+          <xs:simpleType>
+          <xs:restriction base="xs:string">
+          <xs:minLength value="2"/>
+          <xs:maxLength value="8"/>
+          </xs:restriction>
+          </xs:simpleType>
+          </xs:element>
+        XSD
       end
 
-      xsd = Lutaml::Model::Schema.to_xsd(doc)
+      it "emits the tighter merged bound without a spurious raise" do
+        schema = described_class.generate(SchemaGeneration::MergedLayers)
 
-      expect(xsd).to include('xmlns:tns="http://t.example"')
-      expect(xsd).to include('xmlns:tns1="http://example.com/np"')
-      expect(xsd).to include('type="tns1:DocType"')
-      expect(xsd).to include('type="tns:TType"')
-    end
-
-    # A foreign-namespaced nested model with NO type_name is inlined into this
-    # document (like a same-namespace model), not imported — so its namespace
-    # must not trigger the foreign-import schema_location requirement. The
-    # namespace walk and the element walk must agree that it is not a boundary.
-    it "does not require schema_location for an inlined (type_name-less) foreign model" do
-      inner_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://inner.example/in"
-        prefix_default "in" # no schema_location, no type_name below
-      end
-      outer_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://outer.example/out"
-        prefix_default "out"
-      end
-      inner = Class.new(Lutaml::Model::Serializable) do
-        attribute :label, :string
-        xml do
-          root "inner"
-          namespace inner_ns
-          map_element "label", to: :label
-        end
-      end
-      outer = Class.new(Lutaml::Model::Serializable) do
-        attribute :inner, inner
-        xml do
-          root "outer"
-          namespace outer_ns
-          map_element "inner", to: :inner
-        end
+        expect(schema).to include('<xs:minInclusive value="0"/>')
+        expect(schema).to include('<xs:maxInclusive value="50"/>')
       end
 
-      xsd = Lutaml::Model::Schema.to_xsd(outer)
+      it "emits the pre-#191 values:/pattern: options as facets" do
+        schema = described_class.generate(SchemaGeneration::LegacyOptions)
 
-      # Inlined, not imported: its content appears here, no <xs:import> for it.
-      expect(xsd).to include('name="label"')
-      expect(xsd).not_to include("http://inner.example/in")
-    end
-
-    it "does not emit a spurious import for an inlined foreign model with a schema_location" do
-      inner_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://inner2.example/in"
-        prefix_default "in"
-        schema_location "inner.xsd" # present, but model has no type_name
-      end
-      outer_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://outer2.example/out"
-        prefix_default "out"
+        expect(schema).to include('<xs:enumeration value="on"/>')
+        expect(schema).to include('<xs:enumeration value="off"/>')
+        expect(schema).to include('<xs:pattern value="[A-Z]{2}"/>')
       end
-      inner = Class.new(Lutaml::Model::Serializable) do
-        attribute :label, :string
-        xml do
-          root "inner"
-          namespace inner_ns
-          map_element "label", to: :label
-        end
-      end
-      outer = Class.new(Lutaml::Model::Serializable) do
-        attribute :inner, inner
-        xml do
-          root "outer"
-          namespace outer_ns
-          map_element "inner", to: :inner
-        end
-      end
-
-      xsd = Lutaml::Model::Schema.to_xsd(outer)
 
-      expect(xsd).to include('name="label"')
-      expect(xsd).not_to include("<xs:import")
-    end
-
-    # A prefix bound to two different namespaces — a foreign model vs a
-    # Type::Value type sharing a prefix_default — is unresolvable and must
-    # raise, not silently keep the first binding.
-    it "raises when a foreign model and a Type::Value share a prefix for different namespaces" do
-      model_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://model.example/gml"
-        prefix_default "gml"
-        schema_location "model.xsd"
-      end
-      type_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://type.example/gml"
-        prefix_default "gml"
-        schema_location "type.xsd"
-      end
-      measure = Class.new(Lutaml::Model::Type::String) do
-        xml { namespace type_ns }
-        xsd_type "gml:MeasureType"
-      end
-      widget = Class.new(Lutaml::Model::Serializable) do
-        attribute :label, :string
-        xml do
-          root "widget"
-          namespace model_ns
-          type_name "WidgetType"
-          map_element "label", to: :label
+      it "intersects a values: option with a Layer-2 enumeration" do
+        enum_type = Class.new(Lutaml::Model::Type::String) do
+          enumeration "a", "b", "c"
         end
-      end
-      target_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://doc.example/doc"
-        prefix_default "doc"
-      end
-      doc = Class.new(Lutaml::Model::Serializable) do
-        attribute :size, measure
-        attribute :widget, widget
-        xml do
-          root "doc"
-          namespace target_ns
-          map_element "size", to: :size
-          map_element "widget", to: :widget
+        model = Class.new(Lutaml::Model::Serializable) do
+          attribute :s, enum_type, values: %w[a b]
+          xml do
+            root "R"
+            map_element "s", to: :s
+          end
         end
-      end
+        schema = described_class.generate(model)
 
-      # Raises even under skip_validation — a wrong-namespace QName is never
-      # recoverable, matching the foreign prefix-collision behavior.
-      expect do
-        Lutaml::Model::Schema.to_xsd(doc, skip_validation: true)
-      end.to raise_error(Lutaml::Model::Error, /two different namespaces/)
-    end
-
-    # A collection of a type_name-less model renders as a placeholder `item`
-    # element, so nothing inside it is emitted — the namespace walk must not
-    # descend into it and import a foreign type the schema never references.
-    it "does not import namespaces reachable only through a placeholder collection" do
-      child_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://child.example/ch"
-        prefix_default "ch" # foreign + type_name + NO schema_location
-      end
-      inner_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://binner.example/b"
-        prefix_default "bin"
-      end
-      child = Class.new(Lutaml::Model::Serializable) do
-        attribute :v, :string
-        xml do
-          root "child"
-          namespace child_ns
-          type_name "ChildType"
-          map_element "v", to: :v
-        end
-      end
-      inner = Class.new(Lutaml::Model::Serializable) do
-        attribute :child, child
-        xml do
-          root "inner"
-          namespace inner_ns
-          map_element "child", to: :child
-        end
-      end
-      root_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://root.example/r"
-        prefix_default "r"
-      end
-      root = Class.new(Lutaml::Model::Serializable) do
-        attribute :inners, inner, collection: true
-        xml do
-          root "root"
-          namespace root_ns
-          map_element "inner", to: :inners
-        end
+        expect(schema).to include('<xs:enumeration value="a"/>')
+        expect(schema).to include('<xs:enumeration value="b"/>')
+        expect(schema).not_to include('<xs:enumeration value="c"/>')
       end
 
-      xsd = Lutaml::Model::Schema.to_xsd(root)
-
-      # No spurious import/raise for the foreign child reachable only through
-      # the placeholder collection.
-      expect(xsd).not_to include("http://child.example/ch")
-      expect(xsd).not_to include("http://binner.example/b")
-    end
-
-    # Locks the deliberate skip-before-cycle-guard ordering: a model referenced
-    # BOTH as a placeholder collection and as a single inlined attribute must
-    # still be inlined via the single path — the placeholder reference must not
-    # consume the model's cycle-guard slot and mask the emitted one. Regardless
-    # of attribute order, the inlined model's nested named type stays defined.
-    %i[collection_first single_first].each do |order|
-      it "defines a nested type of a model also referenced as a placeholder collection (#{order})" do
-        child = Class.new(Lutaml::Model::Serializable) do
-          attribute :v, :string
-          xml do
-            root "child"
-            type_name "CType"
-            map_element "v", to: :v
-          end
+      it "raises when values: is disjoint from the Layer-2 enumeration" do
+        enum_type = Class.new(Lutaml::Model::Type::String) do
+          enumeration "a", "b"
         end
-        mid = Class.new(Lutaml::Model::Serializable) do
-          attribute :child, child
+        model = Class.new(Lutaml::Model::Serializable) do
+          attribute :s, enum_type, values: %w[c d]
           xml do
-            root "mid"
-            map_element "child", to: :child
-          end
-        end
-        root = Class.new(Lutaml::Model::Serializable) do
-          if order == :collection_first
-            attribute :many, mid, collection: true
-            attribute :one, mid
-          else
-            attribute :one, mid
-            attribute :many, mid, collection: true
-          end
-          xml do
-            root "root"
-            map_element "many", to: :many
-            map_element "one", to: :one
+            root "R"
+            map_element "s", to: :s
           end
         end
 
-        xsd = Lutaml::Model::Schema.to_xsd(root)
-
-        # The single-inline path references CType, so CType must be defined —
-        # even when the placeholder collection references `mid` first.
-        expect(xsd).to include('<xs:complexType name="CType">')
-        expect { Nokogiri::XML::Schema(xsd) }.not_to raise_error
+        expect { described_class.generate(model) }
+          .to raise_error(ArgumentError, /enumeration allows no values/)
       end
-    end
 
-    # When the root schema has no targetNamespace, the foreign-prefix error must
-    # not interpolate a nil target into a confusing "'' schema" string.
-    it "reports the no-namespace schema clearly in the foreign-prefix error" do
-      foreign_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
-        uri "http://foreign.example/f"
-        prefix_default "xs" # reserved -> unusable prefix, triggers the error
-      end
-      child = Class.new(Lutaml::Model::Serializable) do
-        attribute :v, :string
-        xml do
-          root "child"
-          namespace foreign_ns
-          type_name "ChildType"
-          map_element "v", to: :v
-        end
-      end
-      root = Class.new(Lutaml::Model::Serializable) do
-        attribute :child, child
-        xml do
-          root "root" # no namespace -> target_uri is nil
-          map_element "child", to: :child
+      # An explicit `min: nil` means "no bound"; it must not leave a nil facet
+      # that emits an empty <xs:restriction> around the element.
+      it "treats an explicit nil bound as absent (no empty restriction)" do
+        model = Class.new(Lutaml::Model::Serializable) do
+          attribute :x, :integer, min: nil
+          xml do
+            root "R"
+            map_element "x", to: :x
+          end
         end
-      end
+        schema = described_class.generate(model)
 
-      expect { Lutaml::Model::Schema.to_xsd(root) }
-        .to raise_error(Lutaml::Model::Error, /this no-namespace schema/)
+        expect(schema).to include('<xs:element name="x" type="xs:integer"/>')
+        expect(schema).not_to include("<restriction")
+      end
     end
   end
 end