pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/w3c/parser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module W3c
+    # Parslet grammar for printed W3C identifiers, e.g.
+    #   "W3C WD-charmod-19991129"   (type + code + date)
+    #   "W3C NOTE-xml-names"        (type + code)
+    #   "W3C 2dcontext"             (bare code)
+    #
+    # The grammar only splits off the leading maturity token; the code/date
+    # boundary is resolved in the Builder, because a PEG `code` rule would
+    # greedily consume the trailing date and make a `.maybe` date rule
+    # unreliable. This is safe: no real W3C code ends in a same-width (4/6/8)
+    # digit run, so the Builder's fixed-width trailing-date test never collides.
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:prefix) { str("W3C") >> str(" ") }
+
+      # Known W3C maturity tokens. Order matters for shared prefixes: CRD before
+      # CR, PER before PR, DNOTE before NOTE.
+      rule(:type_token) do
+        str("DNOTE") | str("NOTE") | str("WD") | str("CRD") | str("CR") |
+          str("REC") | str("PER") | str("PR") | str("SPSD") | str("OBSL")
+      end
+
+      # A leading token is only a type when immediately followed by "-".
+      rule(:type_part) { type_token.as(:type) >> str("-") }
+
+      # The remainder: code plus an optional trailing date. Captured whole and
+      # split in the Builder.
+      rule(:rest) { any.repeat(1).as(:rest) }
+
+      rule(:identifier) { prefix >> type_part.maybe >> rest }
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/w3c/renderer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module W3c
+    # Human-readable renderer for W3C identifiers.
+    #
+    # Produces strings like:
+    #   "W3C WD-charmod-19991129"
+    #   "W3C NOTE-xml-names"
+    #   "W3C 2dcontext"
+    #
+    # Registered as the :human format in the W3C format registry and invoked via
+    # `render(format: :human)`. When `id.with_publisher == false` the leading
+    # "W3C " publisher token is dropped.
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "W3C"
+
+      def render(context: nil, **opts)
+        id = @id
+        body = +""
+        body << "#{id.type_prefix}-" if id.type_prefix
+        body << id.number.to_s
+        body << "-#{id.date}" if id.date
+
+        with_publisher?(id) ? "#{PUBLISHER} #{body}" : body
+      end
+
+      private
+
+      def with_publisher?(id)
+        id.with_publisher != false
+      end
+    end
+  end
+end

data/lib/pubid/w3c/urn_generator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module W3c
+    # Emits `urn:w3c:<type-down>:<slug>[:<date>]`, e.g.
+    #   "W3C WD-charmod-19991129" -> "urn:w3c:wd:charmod:19991129"
+    #   "W3C 2dcontext"           -> "urn:w3c:2dcontext"
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "w3c"]
+        parts << identifier.type_prefix.downcase if identifier.type_prefix
+        parts << identifier.number.to_s
+        parts << identifier.date.to_s if identifier.date
+        parts.join(":")
+      end
+    end
+  end
+end

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,68 @@
+# frozen_string_literal: true
+
+require "pubid"
+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,66 @@
+# 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 [Pubid::Errors::InvalidInputError]
+      #   If the input exceeds the maximum length
+      # @raise [Pubid::Errors::ParseError] If parsing fails
+      def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      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,38 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Xsf
+    # Parslet grammar for XSF identifiers. Two shapes: "XEP NNNN", and the two
+    # named documents in SPECIAL_NUMBERS.
+    class Parser < ::Pubid::Parser::Grammar
+      # The XMPP extensions repository publishes two documents whose name is
+      # not a number: the editor README and the `xep-xxxx` template. Both reach
+      # pubid as real primary docids ("XEP README", "XEP xxxx"), so the number
+      # rule admits these two literals beside the digits. Exact case, and no
+      # other word: the flavor still rejects "XEP foo".
+      SPECIAL_NUMBERS = %w[README xxxx].freeze
+
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+
+      rule(:special_number) do
+        SPECIAL_NUMBERS.map { |name| str(name) }.reduce(:|)
+      end
+
+      # "XEP 0001" — publisher token, a single space, then the number kept as
+      # a string of digits (leading zeros preserved by the builder), or the
+      # name of one of the two named documents.
+      rule(:identifier) do
+        str("XEP") >> str(" ") >> (digits | special_number).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,82 @@
+# frozen_string_literal: true
+
+require "pubid"
+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)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, 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)