pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.9

data/lib/pubid/w3c/urn_parser.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module W3c
+    # Parses W3C URNs back into identifiers by reconstructing the printed form
+    # and delegating to the flavor's text parser.
+    #
+    # UrnGenerator emits `urn:w3c:<type-down>:<code>[:<date>]`. The first body
+    # segment is the maturity token only when it is one of the known tokens AND
+    # a code segment follows it (a typed URN always has ≥2 segments); a
+    # single-segment body is always a bare code — even one that happens to spell
+    # a token, e.g. `urn:w3c:rec` -> `W3C rec` (a Standard, not a REC).
+    #
+    # Examples:
+    # - urn:w3c:wd:charmod:19991129 -> W3C WD-charmod-19991129
+    # - urn:w3c:note:xml-names      -> W3C NOTE-xml-names
+    # - urn:w3c:2dcontext           -> W3C 2dcontext
+    class UrnParser < Pubid::UrnParser::Base
+      KNOWN_TOKENS = %w[note dnote wd cr crd rec pr per spsd obsl].freeze
+
+      def parse_urn(urn)
+        parts = split_parts(strip_namespace(urn))
+
+        if parts.size > 1 && KNOWN_TOKENS.include?(parts.first)
+          token = parts.shift.upcase
+          text = "W3C #{token}-#{parts.shift}"
+        else
+          text = "W3C #{parts.shift}"
+        end
+        text += "-#{parts.shift}" unless parts.empty?
+
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/w3c.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module W3c
+    extend Pubid::PrefixesSupport
+
+    # Sole W3C publisher token (see the parser's `prefix` rule). Document-type
+    # tokens (WD/NOTE/REC/…) follow the "W3C " prefix and are excluded.
+    PREFIXES = ["W3C"].freeze
+
+    autoload :Builder, "#{__dir__}/w3c/builder"
+    autoload :Identifier, "#{__dir__}/w3c/identifier"
+    autoload :Identifiers, "#{__dir__}/w3c/identifiers"
+    autoload :Parser, "#{__dir__}/w3c/parser"
+    autoload :Renderer, "#{__dir__}/w3c/renderer"
+    autoload :UrnGenerator, "#{__dir__}/w3c/urn_generator"
+    autoload :UrnParser, "#{__dir__}/w3c/urn_parser"
+
+    # Parse a W3C identifier string
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: W3c::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+# Register W3C flavor with the registry
+Pubid::Registry.register(:w3c, Pubid::W3c)

data/lib/pubid/xsf/builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Xsf
+    # Builds an identifier object from the Parslet parse tree. XSF has a single
+    # concrete type, so the builder always produces an Identifiers::Xep.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        Identifiers::Xep.new(number: data[:number].to_s)
+      end
+    end
+  end
+end

data/lib/pubid/xsf/identifier.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Xsf
+    # Base class for every XSF identifier AND the flavor's parse/create entry
+    # point — mirrors Pubid::Jis::Identifier. The single concrete type
+    # (Pubid::Xsf::Identifiers::Xep) descends from this class, so a parsed XSF
+    # id is an instance of Pubid::Xsf::Identifier.
+    class Identifier < ::Pubid::Identifier
+      # XEP number kept as a string to preserve the 4-digit zero padding
+      # ("0001", not 1). No default → it is dropped from the serialized hash
+      # only when nil, and always present for a real identifier.
+      attribute :number, :string
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization:
+      # maps each subclass's polymorphic_name to its class name so a stored
+      # hash rebuilds the correct identifier type via from_hash.
+      XSF_TYPE_MAP = {
+        "pubid:xsf:xep" => "Pubid::Xsf::Identifiers::Xep",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: XSF_TYPE_MAP
+        map "number", to: :number
+      end
+
+      # Publisher name. A plain constant (not a `publisher` method) so it does
+      # not shadow the inherited lutaml `publisher` attribute, which would
+      # otherwise fail serialization type validation. XSF never prints its
+      # publisher name in an identifier — the leading token is "XEP".
+      PUBLISHER = "XSF"
+
+      attr_reader :with_publisher
+
+      # Basic string representation. Delegates to renderer; `with_publisher:
+      # false` yields the bare number.
+      def to_s(with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        render(format: :human, **opts)
+      end
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier;
+      # XSF_TYPE_MAP remains as the key_value polymorphic_map.
+
+      # Parse an XSF identifier string into an identifier object
+      # @param identifier [String] The XSF identifier string to parse
+      # @return [Identifier] The appropriate identifier object
+      # @raise [ArgumentError] If the input exceeds the maximum length
+      # @raise [RuntimeError] If parsing fails
+      def self.parse(identifier)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse XSF identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

data/lib/pubid/xsf/identifiers/xep.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Xsf
+    module Identifiers
+      # XMPP Extension Protocol — the sole XSF identifier type.
+      # Format: "XEP NNNN" (e.g. XEP 0001, XEP 0218).
+      #
+      # `polymorphic_name` auto-derives "pubid:xsf:xep" from the class name,
+      # which is what serializes into the `_type` tag and drives from_hash
+      # dispatch (see XSF_TYPE_MAP on the base Identifier).
+      class Xep < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :xep,
+            stage_code: :published,
+            type_code: :xep,
+            abbr: ["XEP"],
+            name: "XMPP Extension Protocol",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :xep,
+            web: :xep, title: "XMPP Extension Protocol", short: "XEP" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/xsf/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Xsf
+    module Identifiers
+      autoload :Xep, "#{__dir__}/identifiers/xep"
+    end
+  end
+end

data/lib/pubid/xsf/parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Xsf
+    # Parslet grammar for XSF identifiers. One fixed shape: "XEP NNNN".
+    class Parser < Parslet::Parser
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+
+      # "XEP 0001" — publisher token, a single space, then the number kept as
+      # a string of digits (leading zeros preserved by the builder).
+      rule(:identifier) do
+        str("XEP") >> str(" ") >> digits.as(:number)
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/xsf/renderer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Xsf
+    # Human-readable renderer for XSF identifiers.
+    #
+    # Produces strings like "XEP 0001". With `with_publisher: false` it emits
+    # just the bare number ("0001").
+    #
+    # Registered as the `:human` format in the XSF format registry and invoked
+    # via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "XEP"
+
+      def render(context: nil, **opts)
+        id = @id
+        return id.number.to_s if id.with_publisher == false
+
+        "#{PUBLISHER} #{id.number}"
+      end
+    end
+  end
+end

data/lib/pubid/xsf/urn_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Xsf
+    # Emits `urn:xsf:xep:<number>` (e.g. urn:xsf:xep:0001). The number keeps its
+    # zero padding so the URN round-trips back to the printed identifier.
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        ["urn", "xsf", "xep", identifier.number.to_s].join(":")
+      end
+    end
+  end
+end

data/lib/pubid/xsf/urn_parser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Xsf
+    # Parses XSF URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:xsf:xep:<number>` (e.g. urn:xsf:xep:0001).
+    # This inverts it by reconstructing the printed "XEP <number>" string and
+    # delegating to the flavor's text parser.
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        _type, number = split_parts(body)
+        flavor_parse("XEP #{number}")
+      end
+    end
+  end
+end

data/lib/pubid/xsf.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Pubid
+  # XSF (XMPP Standards Foundation) flavor. Its documents are XEPs — XMPP
+  # Extension Protocols — printed as "XEP NNNN" with a 4-digit zero-padded
+  # number (e.g. "XEP 0001"). The simplest full flavor: a single identifier
+  # type, one string attribute.
+  module Xsf
+    extend Pubid::PrefixesSupport
+
+    # Sole leading token an XSF identifier can start with (see the parser's
+    # `str("XEP")`). "XSF" is the publisher name but never appears in a printed
+    # identifier, so it is not a prefix.
+    PREFIXES = ["XEP"].freeze
+
+    autoload :Builder, "#{__dir__}/xsf/builder"
+    autoload :Identifier, "#{__dir__}/xsf/identifier"
+    autoload :Identifiers, "#{__dir__}/xsf/identifiers"
+    autoload :Parser, "#{__dir__}/xsf/parser"
+    autoload :Renderer, "#{__dir__}/xsf/renderer"
+    autoload :UrnGenerator, "#{__dir__}/xsf/urn_generator"
+    autoload :UrnParser, "#{__dir__}/xsf/urn_parser"
+
+    # Parse an XSF identifier string
+    def self.parse(identifier)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Xsf::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+# Register XSF flavor with the registry
+Pubid::Registry.register(:xsf, Pubid::Xsf)

data/lib/pubid.rb

@@ -97,35 +97,54 @@ module Pubid
   autoload :Utils, "pubid/utils"
   autoload :Version, "pubid/version"
   autoload :Core, "pubid/core"
+  autoload :TypeResolver, "pubid/type_resolver"
 
 
   # Require all flavor modules
+  autoload :Adobe, "pubid/adobe"
   autoload :Amca, "pubid/amca"
   autoload :Ansi, "pubid/ansi"
   autoload :Api, "pubid/api"
   autoload :Ashrae, "pubid/ashrae"
   autoload :Asme, "pubid/asme"
+  autoload :Doi, "pubid/doi"
+  autoload :Easc, "pubid/easc"
   autoload :Astm, "pubid/astm"
+  autoload :Bipm, "pubid/bipm"
   autoload :Bsi, "pubid/bsi"
+  autoload :Calconnect, "pubid/calconnect"
   autoload :Ccsds, "pubid/ccsds"
   autoload :CenCenelec, "pubid/cen_cenelec"
   autoload :Cie, "pubid/cie"
   autoload :Csa, "pubid/csa"
+  autoload :Ecma, "pubid/ecma"
   autoload :Etsi, "pubid/etsi"
+  autoload :Gost, "pubid/gost"
+  autoload :Gb, "pubid/gb"
   autoload :Idf, "pubid/idf"
   autoload :Iec, "pubid/iec"
   autoload :Ieee, "pubid/ieee"
+  autoload :Ietf, "pubid/ietf"
+  autoload :Isbn, "pubid/isbn"
   autoload :Iala, "pubid/iala"
+  autoload :Iana, "pubid/iana"
   autoload :Iho, "pubid/iho"
   autoload :Iso, "pubid/iso"
   autoload :Itu, "pubid/itu"
   autoload :Jcgm, "pubid/jcgm"
   autoload :Jis, "pubid/jis"
   autoload :Nist, "pubid/nist"
+  autoload :Oasis, "pubid/oasis"
+  autoload :Ogc, "pubid/ogc"
   autoload :Oiml, "pubid/oiml"
+  autoload :Omg, "pubid/omg"
   autoload :Plateau, "pubid/plateau"
   autoload :Export, "pubid/export"
   autoload :Sae, "pubid/sae"
+  autoload :Tgpp, "pubid/tgpp"
+  autoload :Un, "pubid/un"
+  autoload :Xsf, "pubid/xsf"
+  autoload :W3c, "pubid/w3c"
 
   # Format infrastructure (loaded eagerly so Pubid::Renderers / Pubid::Parsers are always available)
   require "pubid/renderers/base"
@@ -181,11 +200,16 @@ module Pubid
   # Trigger autoloads for every declared flavor module so that
   # Registry is populated before URN dispatch needs it. Safe to call
   # repeatedly; no-op after the first invocation.
+  #
+  # The constant filter allows a digit inside the name (the +0-9+ in the regex)
+  # so digit-bearing flavor modules such as +W3c+ are loaded/registered too —
+  # without it +W3c+ is silently dropped from the registry enumeration and thus
+  # from every registry-driven cross-flavor spec.
   def self.eager_load_flavors!
     return if @flavors_loaded
 
     constants.each do |c|
-      next unless c.to_s.match?(/\A[A-Z][a-zA-Z]+\z/)
+      next unless c.to_s.match?(/\A[A-Z][a-zA-Z0-9]+\z/)
 
       begin
         const_get(c)