moxml 0.5.167 → 0.5.169

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfb972cf79eaf0a41c6764ceed1ce1739f6c6e639bf753120418bbf8ef5c3082
-  data.tar.gz: fb1759136a3091e0e998708489ef4849c5cea4e2df6009a9a319cf26ed8540bf
+  metadata.gz: c6d162a122e231644310d60b9f27eef7f3fa89728a6c135a9eb855d56952af5d
+  data.tar.gz: 7c3c92e7ffe80f35484e364d75808d1a74f4c62db7c1e2222b0d1d2921d3ccac
 SHA512:
-  metadata.gz: 0c0da22a0e0d37ec5db5b3e76845bc042583c005964cfa7499be07227618125b65e04b8d8ed7b11c7754c8403a0d6ceecbb9dffa07cf683bed7e037c72b125c4
-  data.tar.gz: ef0ff906785959fe2f93719df3d3deb49e8b27f6097ecd836d8ab296200cb8b2ef24aabb60ef3924b5fbc54c6da517c44bd18d5bb213d8b0042546b1d65cfe7a
+  metadata.gz: 4872ca2eb4456ee02a511196840379610f6c66b590d64ba1a4715b6107c33a912056bd6fe48055d1270c274e9aec62193f88778180f57ebe32da3f27961f871c
+  data.tar.gz: 4811ea416c2ebd77ff2cbedf4f640a755424e5ae67d3590c63220fd182eff8ad2fb0c58335ea82f90bb8b9c5bca9f408cb4989256a9c74bb6af5b568ecfc457b

data/docs/_pages/model-coverage.adoc

@@ -44,6 +44,7 @@ Generated by `bundle exec rake docs:coverage` from the coverage matrix and the d
 | validation version reporting | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
 | validation engine metadata | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
 | validation regex dismissal | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
+| validation builtin lexical table | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
 | validation substitution dismissal | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
 | loud capability contracts | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
 |===

data/docs/_references/processing-model.adoc

@@ -255,11 +255,18 @@ semantics.
 
 === Validation
 
-Pins:: `spec/moxml/xsd_engine_meta_spec.rb`, `spec/moxml/xsd_regex_spec.rb`, `spec/moxml/xsd_spec.rb`, `spec/moxml/xsd_substitution_spec.rb`, `spec/moxml/xsd_underdetection_spec.rb`, `spec/moxml/xsd_version_spec.rb`
+Pins:: `spec/moxml/xsd_builtin_lexical_spec.rb`, `spec/moxml/xsd_engine_meta_spec.rb`, `spec/moxml/xsd_regex_spec.rb`, `spec/moxml/xsd_spec.rb`, `spec/moxml/xsd_substitution_spec.rb`, `spec/moxml/xsd_underdetection_spec.rb`, `spec/moxml/xsd_version_spec.rb`
 
 XSD validation through engines that ship a validator (libxml2;
 leptris tier-1: recognized roots, one-level content descent, lexical
-checks). `validate` returns accumulated `ValidationError` entries —
+checks). The built-in lexical answer is facade-owned:
+`Moxml::XSD.builtin_valid?` evaluates the Datatypes Part 2 lexical
+spaces (collapse for the token family, the unbounded integer family
+with bignum bounds, calendar and duration grammars, binary, QName
+with the reserved `xmlns` prefix) from the facade's own table on
+every adapter — an engine table converges to it, never the reverse;
+an unknown name raises `ArgumentError`. `validate` returns
+accumulated `ValidationError` entries —
 message always; line/column/path where the engine reports them, nil
 where it does not; `[]` means valid. Documents outside the engine's
 scope validate laxly, except that strict `xs:any` /

data/lib/moxml/adapter/base.rb

@@ -373,11 +373,6 @@ module Moxml
                 "XSD validation requires an adapter with an XSD engine"
         end
 
-        def xsd_builtin_valid?(_builtin, _lexical)
-          raise Moxml::NotImplementedError,
-                "XSD validation requires an adapter with an XSD engine"
-        end
-
         def xsd_declarations(_xsd_handle); end
 
         def xsd_compile_error(_xsd_handle); end

data/lib/moxml/adapter/leptris.rb

@@ -406,15 +406,6 @@ module Moxml
           handle.valid?(to_binding(document))
         end
 
-        def xsd_builtin_valid?(builtin, lexical)
-          unless XSD_SUPPORTED
-            raise Moxml::NotImplementedError,
-                  "XSD validation requires an adapter with an XSD engine"
-          end
-
-          ::Leptris::XML::XSD.builtin_valid?(builtin, lexical)
-        end
-
         def xsd_declarations(xsd_handle)
           xsd_handle.declaration_count
         end
@@ -939,9 +930,20 @@ module Moxml
           # Protocol-level node equality: one engine can hand out
           # two wrapper classes over the same C node (native layer +
           # binding), so raw == is not identity across the seam.
+          # Attributes are (name, value, element) triples without a
+          # node pointer; identity is the owning element plus the
+          # attribute name.
           def same_node?(one, other)
             return true if one.equal?(other)
 
+            if one.is_a?(::Leptris::XML::Attr) ||
+                other.is_a?(::Leptris::XML::Attr)
+              return one.is_a?(::Leptris::XML::Attr) &&
+                  other.is_a?(::Leptris::XML::Attr) &&
+                  one.name == other.name &&
+                  same_node?(one.element, other.element)
+            end
+
             if NATIVE_READ_LAYER
               native_one = one.is_a?(::Leptris::XML::NativeNode)
               native_other = other.is_a?(::Leptris::XML::NativeNode)

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.167"
+  VERSION = "0.5.169"
 end

data/lib/moxml/xpath/ordering.rb

@@ -75,7 +75,18 @@ module Moxml
         [kind_rank, ancestry_path(node)]
       end
 
+      # Attributes are not children of their element, so their
+      # document position is the parent's; same-parent attributes
+      # keep their relative order (stable sort). A parentless
+      # attribute stays unplaceable.
       def ancestry_path(node)
+        if node.is_a?(Moxml::Attribute)
+          parent = node.parent
+          return [2_000_000] unless parent
+
+          return ancestry_path(parent)
+        end
+
         path = []
         current = node
         while current && !current.is_a?(Moxml::Document)

data/lib/moxml/xsd/builtin_lexical.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module Moxml
+  module XSD
+    # Facade-owned lexical validation for the XSD built-in simple
+    # types (Datatypes Part 2). One committed answer for every
+    # adapter: engines with their own tables converge to this one,
+    # never the reverse (#482). The check is lexical only — pattern,
+    # enumeration and other constraining facets belong to the
+    # schema, not to the built-in's own space.
+    module BuiltinLexical
+      module_function
+
+      # Answers for the "xs:NAME" reference spelling. Unknown names
+      # raise ArgumentError — the facade never guesses.
+      def valid?(builtin, lexical)
+        checker = CHECKERS.fetch(builtin) do
+          raise ArgumentError, "unknown built-in type #{builtin.inspect}"
+        end
+
+        checker.call(lexical.to_s)
+      end
+
+      # XML 1.0 5th ed. name productions. NCName excludes ":";
+      # xs:Name and xs:NMTOKEN admit it.
+      NCNAME_START_CLASS =
+        "A-Z_a-z\u{C0}-\u{D6}\u{D8}-\u{F6}\u{F8}-\u{2FF}\u{370}-\u{37D}" \
+        "\u{37F}-\u{1FFF}\u{200C}-\u{200D}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}" \
+        "\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}\u{FDF0}-\u{FFFD}"
+      NCNAME_CHAR_CLASS =
+        "#{NCNAME_START_CLASS}0-9.\\-\u{B7}\u{300}-\u{36F}\u{203F}-\u{2040}".freeze
+
+      NCNAME = /\A[#{NCNAME_START_CLASS}][#{NCNAME_CHAR_CLASS}]*\z/
+      NAME = /\A[:#{NCNAME_START_CLASS}][:#{NCNAME_CHAR_CLASS}]*\z/
+      NMTOKEN = /\A[:#{NCNAME_CHAR_CLASS}]+\z/
+
+      INTEGER_LEXICAL = /\A[+-]?[0-9]+\z/
+      DECIMAL_LEXICAL = /\A[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)\z/
+      FLOAT_LEXICAL = /\A(?:[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[Ee][+-]?[0-9]+)?|[+-]?INF|NaN)\z/
+      BOOLEAN_LEXICAL = /\A(?:true|false|0|1)\z/
+      LANGUAGE_LEXICAL = /\A[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*\z/
+      HEX_LEXICAL = /\A(?:[0-9A-Fa-f]{2})*\z/
+      BASE64_LEXICAL = /\A(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?\z/
+
+      DATE_PART = /-?(?:[1-9][0-9]{3,}|0[0-9]{3})-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])/
+      TIME_PART = /(?:[01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\.[0-9]+)?/
+      ZONE = /(?:Z|[+-](?:0[0-9]|1[0-3]):[0-5][0-9]|14:00)/
+      DATE_LEXICAL = /\A#{DATE_PART}#{ZONE}?\z/
+      TIME_LEXICAL = /\A#{TIME_PART}#{ZONE}?\z/
+      DATE_TIME_LEXICAL = /\A#{DATE_PART}T#{TIME_PART}#{ZONE}?\z/
+      DATE_TIME_STAMP_LEXICAL = /\A#{DATE_PART}T#{TIME_PART}#{ZONE}\z/
+      G_YEAR_LEXICAL = /\A-?(?:[1-9][0-9]{3,}|0[0-9]{3})#{ZONE}?\z/
+      G_YEAR_MONTH_LEXICAL = /\A-?(?:[1-9][0-9]{3,}|0[0-9]{3})-(?:0[1-9]|1[0-2])#{ZONE}?\z/
+      G_MONTH_LEXICAL = /\A--(?:0[1-9]|1[0-2])#{ZONE}?\z/
+      G_DAY_LEXICAL = /\A---(?:0[1-9]|[12][0-9]|3[01])#{ZONE}?\z/
+      G_MONTH_DAY_LEXICAL = /\A--(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])#{ZONE}?\z/
+      DURATION_LEXICAL = /\A-?P(?:[0-9]+Y)?(?:[0-9]+M)?(?:[0-9]+D)?(?:T(?:[0-9]+H)?(?:[0-9]+M)?(?:[0-9]+(?:\.[0-9]+)?S)?)?\z/
+
+      MONTH_DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31].freeze
+
+      private_constant :NCNAME_START_CLASS, :NCNAME_CHAR_CLASS, :NCNAME,
+                       :NAME, :NMTOKEN, :INTEGER_LEXICAL, :DECIMAL_LEXICAL,
+                       :FLOAT_LEXICAL, :BOOLEAN_LEXICAL, :LANGUAGE_LEXICAL,
+                       :HEX_LEXICAL, :BASE64_LEXICAL, :DATE_PART,
+                       :TIME_PART, :ZONE, :DATE_LEXICAL, :TIME_LEXICAL,
+                       :DATE_TIME_LEXICAL, :DATE_TIME_STAMP_LEXICAL,
+                       :G_YEAR_LEXICAL, :G_YEAR_MONTH_LEXICAL,
+                       :G_MONTH_LEXICAL, :G_DAY_LEXICAL,
+                       :G_MONTH_DAY_LEXICAL, :DURATION_LEXICAL, :MONTH_DAYS
+
+      # whiteSpace=collapse, shared by token and its derivatives.
+      def collapsed(lexical)
+        lexical.gsub(/[ \t\r\n]+/, " ").strip
+      end
+
+      def ncname?(lexical)
+        NCNAME.match?(lexical)
+      end
+
+      # A QName is an optional NCName prefix, a colon, and an NCName
+      # local part. The "xmlns" prefix is reserved (Namespaces in
+      # XML) and never a legal QName prefix.
+      def qname?(lexical)
+        prefix, colon, local = lexical.partition(":")
+        return ncname?(lexical) if colon.empty?
+
+        return false if prefix == "xmlns"
+
+        ncname?(prefix) && ncname?(local)
+      end
+
+      # List lexical spaces are whitespace-separated items, at least
+      # one; every item must be a valid item-type lexical.
+      def list?(lexical, &block)
+        items = lexical.split(/[ \t\r\n]+/).reject(&:empty?)
+        !items.empty? && items.all?(&block)
+      end
+
+      # The grammar admits a bare "T" and the empty body; the
+      # lexical space requires at least one component, and a "T"
+      # must be followed by one.
+      def duration?(lexical)
+        return false unless DURATION_LEXICAL.match?(lexical)
+
+        body = lexical.sub(/\A-?P/, "")
+        if (time_at = body.index("T"))
+          /[0-9]/.match?(body[(time_at + 1)..].to_s)
+        else
+          /[0-9]/.match?(body)
+        end
+      end
+
+      def day_time_duration?(lexical)
+        return false unless duration?(lexical)
+
+        head = lexical.split("T", 2).first.to_s
+        !/[0-9]+[YM]/.match?(head)
+      end
+
+      def year_month_duration?(lexical)
+        duration?(lexical) && !/[0-9]+D/.match?(lexical) &&
+          !lexical.include?("T")
+      end
+
+      def leap_year?(year)
+        ((year % 4).zero? && !(year % 100).zero?) || (year % 400).zero?
+      end
+
+      # Dates carry calendar validity in their lexical space: the
+      # day must exist for the month and year (Gregorian, leap
+      # rules on the absolute year).
+      def calendar_date?(year, month, day)
+        return false unless month.between?(1, 12)
+
+        limit = MONTH_DAYS[month - 1]
+        limit += 1 if month == 2 && leap_year?(year.abs)
+        day.between?(1, limit)
+      end
+
+      def date_fields(lexical)
+        match = /\A(-?[0-9]{4,})-([0-9]{2})-([0-9]{2})/.match(lexical)
+        return unless match
+
+        match.captures.map { |field| Integer(field) }
+      end
+
+      # The answer is total: a lexical whose date part does not
+      # parse is invalid (false), never nil — consumers pin strict
+      # booleans on this face (#485 follow-up).
+      def with_date_fields(lexical)
+        year, month, day = date_fields(lexical)
+        return false unless year
+
+        yield(year, month, day)
+      end
+
+      # The supported "xs:NAME" spellings (the CHECKERS keys).
+      def names
+        CHECKERS.keys
+      end
+
+      def integer?(lexical, range: nil)
+        return false unless INTEGER_LEXICAL.match?(lexical)
+
+        range.nil? || range.cover?(Integer(lexical))
+      end
+
+      def signed(range)
+        ->(lexical) { integer?(lexical, range: range) }
+      end
+
+      private_class_method :collapsed, :ncname?, :qname?, :list?,
+                           :duration?, :day_time_duration?,
+                           :year_month_duration?, :leap_year?,
+                           :calendar_date?, :date_fields,
+                           :with_date_fields, :integer?, :signed
+
+      CHECKERS = {
+        "xs:anySimpleType" => ->(_lexical) { true },
+        "xs:anyAtomicType" => ->(_lexical) { true },
+        "xs:anyType" => ->(_lexical) { true },
+        "xs:string" => ->(_lexical) { true },
+        "xs:normalizedString" => ->(_lexical) { true },
+        "xs:token" => ->(_lexical) { true },
+        "xs:language" => ->(lexical) { LANGUAGE_LEXICAL.match?(collapsed(lexical)) },
+        "xs:Name" => ->(lexical) { NAME.match?(collapsed(lexical)) },
+        "xs:NCName" => ->(lexical) { ncname?(collapsed(lexical)) },
+        "xs:ID" => ->(lexical) { ncname?(collapsed(lexical)) },
+        "xs:IDREF" => ->(lexical) { ncname?(collapsed(lexical)) },
+        "xs:ENTITY" => ->(lexical) { ncname?(collapsed(lexical)) },
+        "xs:NMTOKEN" => ->(lexical) { NMTOKEN.match?(collapsed(lexical)) },
+        "xs:IDREFS" => ->(lexical) { list?(lexical) { |item| ncname?(item) } },
+        "xs:ENTITIES" => ->(lexical) { list?(lexical) { |item| ncname?(item) } },
+        "xs:NMTOKENS" => ->(lexical) { list?(lexical) { |item| NMTOKEN.match?(item) } },
+        "xs:boolean" => ->(lexical) { BOOLEAN_LEXICAL.match?(lexical) },
+        "xs:decimal" => ->(lexical) { DECIMAL_LEXICAL.match?(lexical) },
+        "xs:precisionDecimal" => ->(lexical) { FLOAT_LEXICAL.match?(lexical) },
+        "xs:float" => ->(lexical) { FLOAT_LEXICAL.match?(lexical) },
+        "xs:double" => ->(lexical) { FLOAT_LEXICAL.match?(lexical) },
+        "xs:integer" => ->(lexical) { integer?(lexical) },
+        "xs:nonPositiveInteger" => signed(-Float::INFINITY..0),
+        "xs:negativeInteger" => signed(-Float::INFINITY...0),
+        "xs:long" => signed(-(2**63)..((2**63) - 1)),
+        "xs:int" => signed(-(2**31)..((2**31) - 1)),
+        "xs:short" => signed(-32_768..32_767),
+        "xs:byte" => signed(-128..127),
+        "xs:nonNegativeInteger" => signed(0..Float::INFINITY),
+        "xs:positiveInteger" => signed(1..Float::INFINITY),
+        "xs:unsignedLong" => signed(0..((2**64) - 1)),
+        "xs:unsignedInt" => signed(0..((2**32) - 1)),
+        "xs:unsignedShort" => signed(0..65_535),
+        "xs:unsignedByte" => signed(0..255),
+        "xs:duration" => ->(lexical) { duration?(lexical) },
+        "xs:dayTimeDuration" => ->(lexical) { day_time_duration?(lexical) },
+        "xs:yearMonthDuration" => ->(lexical) { year_month_duration?(lexical) },
+        "xs:dateTime" => ->(lexical) do
+          with_date_fields(lexical) do |y, m, d|
+            DATE_TIME_LEXICAL.match?(lexical) && calendar_date?(y, m, d)
+          end
+        end,
+        "xs:dateTimeStamp" => ->(lexical) do
+          with_date_fields(lexical) do |y, m, d|
+            DATE_TIME_STAMP_LEXICAL.match?(lexical) && calendar_date?(y, m, d)
+          end
+        end,
+        "xs:time" => ->(lexical) { TIME_LEXICAL.match?(lexical) },
+        "xs:date" => ->(lexical) do
+          with_date_fields(lexical) do |y, m, d|
+            DATE_LEXICAL.match?(lexical) && calendar_date?(y, m, d)
+          end
+        end,
+        "xs:gYear" => ->(lexical) { G_YEAR_LEXICAL.match?(lexical) },
+        "xs:gYearMonth" => ->(lexical) do
+          G_YEAR_MONTH_LEXICAL.match?(lexical) &&
+            with_date_fields("#{lexical.sub(/(?:Z|[+-][0-9]{2}:[0-9]{2})\z/, '')}-01") do |y, m, d|
+              calendar_date?(y, m, d)
+            end
+        end,
+        "xs:gMonth" => ->(lexical) { G_MONTH_LEXICAL.match?(lexical) },
+        "xs:gDay" => ->(lexical) { G_DAY_LEXICAL.match?(lexical) },
+        "xs:gMonthDay" => ->(lexical) do
+          match = /\A--([0-9]{2})-([0-9]{2})/.match(lexical)
+          next false unless match
+
+          month = Integer(match[1])
+          limit = MONTH_DAYS[month - 1]
+          limit += 1 if month == 2
+          G_MONTH_DAY_LEXICAL.match?(lexical) &&
+            Integer(match[2]).between?(1, limit)
+        end,
+        "xs:hexBinary" => ->(lexical) { HEX_LEXICAL.match?(lexical) },
+        "xs:base64Binary" => ->(lexical) { BASE64_LEXICAL.match?(lexical.delete(" \t\r\n")) },
+        "xs:anyURI" => ->(_lexical) { true },
+        "xs:QName" => ->(lexical) { qname?(collapsed(lexical)) },
+        "xs:NOTATION" => ->(lexical) { qname?(collapsed(lexical)) },
+      }.freeze
+
+      private_constant :CHECKERS
+    end
+  end
+end

data/lib/moxml/xsd.rb

@@ -33,6 +33,7 @@ module Moxml
     SUPPORTED_ADAPTERS = %i[leptris nokogiri].freeze
 
     autoload :SchemaRules, "moxml/xsd/schema_rules"
+    autoload :BuiltinLexical, "moxml/xsd/builtin_lexical"
 
     # One validation finding, harmonized across adapters (#362.2):
     # +message+ always present; +line+ / +column+ when the engine
@@ -76,12 +77,12 @@ module Moxml
           adapter.const_get(:XSD_SUPPORTED)
       end
 
-      # Lexical validation against the built-in type table (the
-      # "xs:NAME" reference spelling). Raises ArgumentError when the
-      # name is not in the table; NotImplementedError on adapters
-      # without an engine.
-      def builtin_valid?(context, builtin, lexical)
-        context.config.adapter.xsd_builtin_valid?(builtin, lexical)
+      # Lexical validation against the facade-owned built-in type
+      # table (the "xs:NAME" reference spelling). One committed
+      # answer on every adapter (#482); raises ArgumentError when
+      # the name is not in the table.
+      def builtin_valid?(_context, builtin, lexical)
+        BuiltinLexical.valid?(builtin, lexical)
       end
     end
 

data/spec/consistency/xpath_idioms_spec.rb

@@ -149,6 +149,34 @@ RSpec.describe "XPath idioms across adapters" do
         expect(doc.xpath("//c").map(&:name)).to eq(["c"])
         expect(doc.at_xpath("count(//c)")).to eq(1.0)
       end
+
+      # Attribute wrappers participate in node equality and document
+      # ordering: standoc's svg cleanup compares and sorts result
+      # sets that carry parent-wired attributes. Equality across an
+      # attribute and a node must answer (false), never raise, and
+      # two wrappers over one attribute are the same node.
+      it "compares attribute identity and orders attribute results" do
+        doc = ctx.parse("<r><svg id='a'><p>x</p></svg><svg id='b'/></r>")
+
+        attr_a = doc.xpath("//*[@id='a']").first.attributes.to_a.first
+        attr_b = doc.xpath("//*[@id='b']").first.attributes.to_a.first
+        expect(doc.root.children.to_a.first == attr_a).to be(false)
+        expect(
+          attr_a == doc.xpath("//*[@id='a']").first.attributes.to_a.first,
+        ).to be(true)
+        expect(attr_a == attr_b).to be(false)
+
+        expect(doc.xpath("//@id").map(&:value)).to eq(%w[a b])
+
+        # XPath document order: an attribute sorts after its owner
+        # element and before the element's children.
+        svg = doc.xpath("//*[@id='a']").first
+        expect(
+          svg.xpath("./@* | ./p").map do |node|
+            node.is_a?(Moxml::Attribute) ? "@#{node.name}" : node.name
+          end,
+        ).to eq(%w[@id p])
+      end
     end
   end
 end

data/spec/moxml/xsd_builtin_lexical_spec.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# Processing model §Validation (normative): pinned here.
+
+require "spec_helper"
+
+RSpec.describe Moxml::XSD do
+  let(:ctx) { Moxml.new(:leptris) }
+
+  def valid_lexical?(type, lexical)
+    described_class.builtin_valid?(ctx, type, lexical)
+  end
+
+  describe ".builtin_valid?" do
+    it "answers the facade-owned table identically without an engine" do
+      expect(valid_lexical?("xs:integer", "3")).to be(true)
+      expect(valid_lexical?("xs:integer", "x")).to be(false)
+      expect do
+        described_class.builtin_valid?(ctx, "xs:nope", "3")
+      end.to raise_error(ArgumentError)
+    end
+
+    it "applies whiteSpace=collapse before token-family checks" do
+      expect(valid_lexical?("xs:token", "a  b")).to be(true)
+      expect(valid_lexical?("xs:ID", " id ")).to be(true)
+      expect(valid_lexical?("xs:NMTOKEN", "\tx ")).to be(true)
+      expect(valid_lexical?("xs:ID", "1d")).to be(false)
+    end
+
+    it "keeps unbounded integers unbounded" do
+      big = "1" * 29
+      expect(valid_lexical?("xs:integer", big)).to be(true)
+      expect(valid_lexical?("xs:positiveInteger", big)).to be(true)
+      expect(valid_lexical?("xs:nonNegativeInteger", big)).to be(true)
+      expect(valid_lexical?("xs:negativeInteger", "-1#{'0' * 20}")).to be(true)
+      expect(valid_lexical?("xs:nonPositiveInteger", "0")).to be(true)
+      expect(valid_lexical?("xs:nonPositiveInteger", "-0")).to be(true)
+    end
+
+    it "stops bounded integers at their own bounds" do
+      expect(valid_lexical?("xs:long", "9223372036854775807")).to be(true)
+      expect(valid_lexical?("xs:long", "9223372036854775808")).to be(false)
+      expect(valid_lexical?("xs:unsignedLong", "18446744073709551615")).to be(true)
+      expect(valid_lexical?("xs:unsignedLong", "18446744073709551616")).to be(false)
+      expect(valid_lexical?("xs:byte", "128")).to be(false)
+      expect(valid_lexical?("xs:unsignedByte", "256")).to be(false)
+    end
+
+    it "admits the float spellings the datatype spec defines" do
+      expect(valid_lexical?("xs:float", "+INF")).to be(true)
+      expect(valid_lexical?("xs:double", "-INF")).to be(true)
+      expect(valid_lexical?("xs:float", "NaN")).to be(true)
+      expect(valid_lexical?("xs:float", "1.5E-3")).to be(true)
+      expect(valid_lexical?("xs:decimal", "5.")).to be(true)
+      expect(valid_lexical?("xs:decimal", ".5")).to be(true)
+      expect(valid_lexical?("xs:decimal", "1e3")).to be(false)
+    end
+
+    it "checks date lexicals against the Gregorian rules" do
+      expect(valid_lexical?("xs:date", "2024-02-29")).to be(true)
+      expect(valid_lexical?("xs:date", "1999-02-29")).to be(false)
+      expect(valid_lexical?("xs:date", "2024-04-31")).to be(false)
+      expect(valid_lexical?("xs:date", "2024-13-01")).to be(false)
+    end
+
+    it "checks dateTime and time lexicals" do
+      expect(valid_lexical?("xs:dateTime", "2024-02-29T23:59:59Z")).to be(true)
+      expect(valid_lexical?("xs:dateTime", "1999-02-29T00:00:00")).to be(false)
+      expect(valid_lexical?("xs:time", "23:59:59.999+05:30")).to be(true)
+      expect(valid_lexical?("xs:time", "24:00:00")).to be(false)
+      expect(valid_lexical?("xs:time", "25:20:00")).to be(false)
+      expect(valid_lexical?("xs:time", "13:20:60")).to be(false)
+    end
+
+    it "checks the gregorian-day lexicals" do
+      expect(valid_lexical?("xs:gYearMonth", "2024-02Z")).to be(true)
+      expect(valid_lexical?("xs:gYearMonth", "2024-13")).to be(false)
+      expect(valid_lexical?("xs:gMonthDay", "--02-29")).to be(true)
+      expect(valid_lexical?("xs:gMonthDay", "--02-30")).to be(false)
+      expect(valid_lexical?("xs:gDay", "---31")).to be(true)
+      expect(valid_lexical?("xs:gDay", "---32")).to be(false)
+    end
+
+    it "enforces the duration component rules" do
+      expect(valid_lexical?("xs:duration", "P1Y2M3DT4H5M6.5S")).to be(true)
+      expect(valid_lexical?("xs:duration", "PT0S")).to be(true)
+      expect(valid_lexical?("xs:duration", "-P1D")).to be(true)
+      expect(valid_lexical?("xs:duration", "P")).to be(false)
+      expect(valid_lexical?("xs:duration", "PT")).to be(false)
+      expect(valid_lexical?("xs:duration", "P1Y2MT")).to be(false)
+      expect(valid_lexical?("xs:duration", "P200.5Y")).to be(false)
+    end
+
+    it "restricts the duration subtypes to their components" do
+      expect(valid_lexical?("xs:dayTimeDuration", "P1DT2H")).to be(true)
+      expect(valid_lexical?("xs:dayTimeDuration", "P1Y")).to be(false)
+      expect(valid_lexical?("xs:yearMonthDuration", "P1Y2M")).to be(true)
+      expect(valid_lexical?("xs:yearMonthDuration", "P1D")).to be(false)
+      expect(valid_lexical?("xs:yearMonthDuration", "P1YT1H")).to be(false)
+    end
+
+    it "checks binary lexical spaces" do
+      expect(valid_lexical?("xs:base64Binary", "aGVsbG8=")).to be(true)
+      expect(valid_lexical?("xs:base64Binary", "abcd")).to be(true)
+      expect(valid_lexical?("xs:base64Binary", "abcde")).to be(false)
+      expect(valid_lexical?("xs:base64Binary", "a b")).to be(false)
+      expect(valid_lexical?("xs:hexBinary", "0A")).to be(true)
+      expect(valid_lexical?("xs:hexBinary", "0AB")).to be(false)
+    end
+
+    it "rejects the reserved xmlns prefix in QName-family lexicals" do
+      expect(valid_lexical?("xs:QName", "foo")).to be(true)
+      expect(valid_lexical?("xs:QName", "ns:foo")).to be(true)
+      expect(valid_lexical?("xs:QName", "xmlns:xsi")).to be(false)
+      expect(valid_lexical?("xs:QName", ":foo")).to be(false)
+      expect(valid_lexical?("xs:QName", "a:b:c")).to be(false)
+      expect(valid_lexical?("xs:NOTATION", "foo")).to be(true)
+    end
+
+    it "counts list items, not characters" do
+      expect(valid_lexical?("xs:IDREFS", "a b")).to be(true)
+      expect(valid_lexical?("xs:IDREFS", "a")).to be(true)
+      expect(valid_lexical?("xs:IDREFS", "")).to be(false)
+      expect(valid_lexical?("xs:NMTOKENS", "a.b-c:d e")).to be(true)
+      expect(valid_lexical?("xs:ENTITIES", "a 1")).to be(false)
+    end
+
+    it "keeps the open lexical spaces open" do
+      expect(valid_lexical?("xs:string", "anything <>&")).to be(true)
+      expect(valid_lexical?("xs:anyURI", "http://example.com/a b")).to be(true)
+      expect(valid_lexical?("xs:boolean", "true")).to be(true)
+      expect(valid_lexical?("xs:boolean", "TRUE")).to be(false)
+      expect(valid_lexical?("xs:language", "en-US")).to be(true)
+      expect(valid_lexical?("xs:language", "en_US")).to be(false)
+      expect(valid_lexical?("xs:Name", "a:b")).to be(true)
+      expect(valid_lexical?("xs:NCName", "a:b")).to be(false)
+    end
+
+    # lutaml-xsd's engine context pins strict booleans on this face:
+    # a grammar-invalid calendar lexical must answer false, never nil
+    # (the with_date_fields short-circuit used to leak nil).
+    it "answers a strict boolean for every supported name" do
+      garbage = ["not-a-date", "", "   ", "12x", "9999-99-99Tzz"]
+
+      Moxml::XSD::BuiltinLexical.names.each do |name|
+        garbage.each do |lexical|
+          answer = valid_lexical?(name, lexical)
+          expect(answer.eql?(true) || answer.eql?(false)).to be(true),
+                                                             "#{name} #{lexical.inspect} answered " \
+                                                             "#{answer.inspect}, want a boolean"
+        end
+      end
+    end
+
+    it "answers false for the calendar faces the engine context pins" do
+      expect(valid_lexical?("xs:date", "not-a-date")).to be(false)
+      expect(valid_lexical?("xs:dateTime", "not-a-date")).to be(false)
+      expect(valid_lexical?("xs:dateTimeStamp", "not-a-date")).to be(false)
+      expect(valid_lexical?("xs:dateTimeStamp", "2024-02-29T00:00:00")).to be(false)
+      expect(valid_lexical?("xs:dateTimeStamp", "2024-02-29T00:00:00Z")).to be(true)
+    end
+  end
+end

data/spec/support/model_coverage.rb

@@ -97,6 +97,10 @@ module ModelCoverage
       section: "Validation",
       pin: "spec/moxml/xsd_regex_spec.rb",
     },
+    "validation builtin lexical table" => {
+      section: "Validation",
+      pin: "spec/moxml/xsd_builtin_lexical_spec.rb",
+    },
     "validation substitution dismissal" => {
       section: "Validation",
       pin: "spec/moxml/xsd_substitution_spec.rb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.167
+  version: 0.5.169
 platform: ruby
 authors:
 - Ribose Inc.
@@ -318,6 +318,7 @@ files:
 - lib/moxml/xpath/ruby/generator.rb
 - lib/moxml/xpath/ruby/node.rb
 - lib/moxml/xsd.rb
+- lib/moxml/xsd/builtin_lexical.rb
 - lib/moxml/xsd/schema_rules.rb
 - lib/moxml/xslt.rb
 - lib/moxml/xslt/stylesheet.rb
@@ -631,6 +632,7 @@ files:
 - spec/moxml/xpath/union_spec.rb
 - spec/moxml/xpath_capabilities_spec.rb
 - spec/moxml/xpath_spec.rb
+- spec/moxml/xsd_builtin_lexical_spec.rb
 - spec/moxml/xsd_engine_meta_spec.rb
 - spec/moxml/xsd_error_contract_spec.rb
 - spec/moxml/xsd_handle_mismatch_spec.rb