pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.12

data/lib/pubid/gb/identifier.rb

@@ -7,9 +7,11 @@ module Pubid
     # descend from this class, so a parsed GB id is always an instance of
     # Pubid::Gb::Identifier.
     class Identifier < ::Pubid::Identifier
-      # The issuing body code as printed, e.g. "GB", "JB", "T/GZAEPI".
-      # Always non-empty for a valid identifier.
-      attribute :publisher_code, :string
+      # The issuing body code as printed — "GB", "JB", "GBn", "T/GZAEPI" —
+      # lives in the `publisher` attribute inherited from ::Pubid::Identifier.
+      # The flat-scalar hooks below serialize it as a bare string, and the
+      # shared URN generator renders it lowercase, so the series is part of
+      # the URN identity (GB 20223 and GBn 20223 are two documents).
 
       # Mandate category: "T" (recommended), "Z" (guideline), or nil
       # (mandatory). Carried after the "/" in the printed form.
@@ -31,17 +33,34 @@ module Pubid
         "pubid:gb:standard" => "Pubid::Gb::Identifiers::Standard",
       }.freeze
 
+      # This block REPLACES the maps of ::Pubid::Identifier, so every
+      # attribute the flavor uses must appear here — "date" included, or the
+      # publication year is lost in to_hash. The shared flat-scalar rules
+      # (Identifier#to_hash / .from_hash) write it as a bare "year" scalar.
       key_value do
         map "_type", to: :_type, polymorphic_map: GB_TYPE_MAP
-        map "publisher_code", to: :publisher_code
+        map "publisher", to: :publisher
         map "mandate", to: :mandate
         map "number", to: :number
         map "part", to: :part
+        map "date", to: :date
         map "all_parts", to: :all_parts, render_default: false
       end
 
       PUBLISHER = "CN"
 
+      # Serialize `publisher` as a bare string instead of a nested
+      # {"body" => "GB"}, the CEN/CENELEC precedent. The entry is added for
+      # GB's own classes only: a shared entry would change the wire format of
+      # every flavor that publishes an index.
+      def self.flat_scalar_components
+        super.merge(publisher: "publisher")
+      end
+
+      def self.flat_scalar_fields
+        super.merge(publisher: :body)
+      end
+
       def to_s(**opts)
         render(format: :human, **opts)
       end
@@ -50,14 +69,17 @@ module Pubid
       # @param identifier [String]
       # @return [Pubid::Gb::Identifier]
       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 ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse Chinese Standard identifier '#{identifier}': #{e.message}"
       end
     end
   end

data/lib/pubid/gb/parser.rb

@@ -14,7 +14,7 @@ module Pubid
     # T/GZAEPI, ...). TYPE is T (recommended), Z (guideline), or omitted.
     # YEAR is 4 digits, separated by either ASCII dash or em-dash (Chinese
     # typography uses the em-dash form).
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:space)  { str(" ") }
       rule(:dot)    { str(".") }
       rule(:dash)   { str("-") | str("—") }
@@ -25,6 +25,10 @@ module Pubid
       rule(:publisher_code) do
         # Social-group form: "T/" then 2+ uppercase letters/digits.
         (str("T/") >> match("[A-Z0-9]").repeat(1)).as(:publisher_code) |
+          # Confidential national series. The lowercase "n" is part of the
+          # code, so it comes before the uppercase-only rule below: a PEG
+          # takes the first branch that matches and does not backtrack.
+          (str("GBn") >> (str("/T") | str("/Z")).maybe).as(:publisher_code) |
           # Standard form: 1-3 letters, optional slash-T-or-Z.
           (match("[A-Z]").repeat(1, 3) >>
             (str("/T") | str("/Z")).maybe).as(:publisher_code)

data/lib/pubid/gb/renderer.rb

@@ -8,7 +8,8 @@ module Pubid
     #   "GB/T 20223-2006"
     #   "GB/T 5606.1-2004"
     #   "GB/T 5606 (all parts)"
-    #   "T/GZAEPI 001—2018"     (social-group form, em-dash year)
+    #   "T/GZAEPI 001-2018"     (social-group form; an em-dash year
+    #                            separator in the input renders as a hyphen)
     class Renderer < ::Pubid::Renderers::Base
       def render(**_opts)
         parts = [publisher_portion, " #{number_portion}"]
@@ -19,8 +20,8 @@ module Pubid
       private
 
       def publisher_portion
-        code = @id.publisher_code.to_s
-        code += "/#{@id.mandate}" if @id.mandate && !@id.publisher_code.include?("/")
+        code = @id.publisher.to_s
+        code += "/#{@id.mandate}" if @id.mandate && !code.include?("/")
         code
       end
 

data/lib/pubid/gb.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   # Chinese Standard (GB) flavor.
   #
@@ -16,6 +17,7 @@ module Pubid
     # "GB" comes first so PrefixesSupport's longest-match wins.
     PREFIXES = %w[
       GB GB/T GB/Z
+      GBn GBn/T GBn/Z
       DB DB/T DB/Z
       QB QB/T
       ZB ZB/T

data/lib/pubid/gost/builder.rb

@@ -120,23 +120,60 @@ module Pubid
         [m[1], m[2]]
       end
 
-      # Try every registered flavor (other than GOST itself) as a parser
-      # for a foreign adopted identifier. Returns the first successful
-      # parse, or nil if none recognize the string.
+      # Route a foreign adopted identifier to its owning flavor, then
+      # fall back to trying every other flavor as a parser. Returns the
+      # first successful parse, or nil if none recognize the string.
+      #
+      # The prefix route is what makes this deterministic: Registry
+      # insertion order is module-load order, which belongs to the host
+      # application (a script that references Pubid::Ieee before
+      # Pubid::Astm registers IEEE first, and IEEE's grammar accepts
+      # "ASTM D129-18" as a publisher token plus an IEEE code), so a
+      # first-success loop over insertion order routed the same GOST
+      # adoption to different flavors per process. The fallback loop
+      # iterates sorted flavor names for the same reason.
       def parse_foreign(raw)
         ::Pubid.eager_load_flavors!
-        ::Pubid::Registry.flavors.each_value do |mod|
+
+        owner = prefix_owner(raw)
+        parsed = owner && parse_quietly(owner, raw)
+        return parsed if parsed
+
+        try_each_flavor(raw)
+      end
+
+      def parse_quietly(mod, raw)
+        mod.parse(raw)
+      rescue StandardError
+        nil
+      end
+
+      def try_each_flavor(raw)
+        ::Pubid::Registry.flavor_names.sort.each do |name|
+          mod = ::Pubid::Registry.get(name)
           next if mod == ::Pubid::Gost
 
-          begin
-            return mod.parse(raw)
-          rescue StandardError
-            next
-          end
+          parsed = parse_quietly(mod, raw)
+          return parsed if parsed
         end
         nil
       end
 
+      # The single flavor owning the longest registered prefix that the
+      # string starts with; nil when no prefix matches or the prefix is
+      # jointly owned (joint forms go through the fallback loop, where
+      # every owner parses them correctly).
+      def prefix_owner(raw)
+        index = ::Pubid.prefix_flavors
+        match = index.keys
+                   .select { |p| raw.start_with?("#{p} ") || raw == p }
+                   .max_by(&:length)
+        return nil unless match
+
+        owners = index[match]
+        owners.one? ? ::Pubid::Registry.get(owners.first) : nil
+      end
+
       def stringify(value)
         return nil if value.nil?
 

data/lib/pubid/gost/identifier.rb

@@ -15,8 +15,6 @@ module Pubid
       def self.parse(identifier)
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse GOST identifier '#{identifier}': #{e.message}"
       end
 
       attribute :publisher,   :string, default: "GOST"

data/lib/pubid/gost/identifiers/foreign_reference.rb

@@ -16,7 +16,7 @@ module Pubid
           { key: :"foreign-reference", title: "Foreign Reference", short: nil }
         end
 
-        def to_s
+        def to_s(**_opts)
           raw.to_s
         end
       end

data/lib/pubid/gost/parser.rb

@@ -26,7 +26,7 @@ module Pubid
     #
     # The builder interprets prefix_text (splits copublisher vs subtype,
     # normalizes Cyrillic to Latin) and raw (splits number vs year).
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
 
       root :identifier
@@ -88,7 +88,15 @@ module Pubid
       end
 
       def self.parse(string)
-        raise ArgumentError, ::Pubid::INPUT_TOO_LONG_MESSAGE if string.length > ::Pubid::MAX_INPUT_LENGTH
+        unless string.is_a?(String)
+          raise ::Pubid::Errors::InvalidInputError,
+                ::Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if string.length > ::Pubid::MAX_INPUT_LENGTH
+          raise ::Pubid::Errors::InvalidInputError,
+                ::Pubid::INPUT_TOO_LONG_MESSAGE
+        end
 
         new.parse(string.strip)
       end

data/lib/pubid/gost.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Gost
     extend Pubid::PrefixesSupport

data/lib/pubid/iala/identifier.rb

@@ -15,15 +15,18 @@ module Pubid
     #   R1016:ed2.0(F)
     #   C0103-1 Ed 3.0
     class Identifier < ::Pubid::Identifier
-      # Parse an IALA identifier string into an identifier object.
+      # Parse an IALA identifier — human form ("IALA G1199 Ed 1.0") or
+      # MRN URN ("urn:mrn:iala:pub:g1199:ed1.0") — into an identifier.
       # @param identifier [String]
       # @return [Pubid::Iala::Identifier]
-      # @raise [Parslet::ParseFailed] If parsing fails
+      # @raise [Pubid::Errors::ParseError] If parsing fails
       def self.parse(identifier)
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse IALA identifier '#{identifier}': #{e.message}"
+        if FormatDetector.detect(identifier) == :urn
+          UrnParser.parse(identifier)
+        else
+          parsed = Parser.parse(identifier)
+          Builder.build(parsed)
+        end
       end
 
       attribute :publisher, :string, default: "IALA"

data/lib/pubid/iala/parser.rb

@@ -15,7 +15,7 @@ module Pubid
     #   R1016:ed2.0(F)
     #   C0103-1
     #   C0103-1 Ed 3.0
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
 
       root :identifier
@@ -121,7 +121,15 @@ module Pubid
       # @param string [String]
       # @return [Hash]
       def self.parse(string)
-        raise ArgumentError, "IALA identifier string exceeds maximum length" if string.length > ::Pubid::MAX_INPUT_LENGTH
+        unless string.is_a?(String)
+          raise ::Pubid::Errors::InvalidInputError,
+                ::Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if string.length > ::Pubid::MAX_INPUT_LENGTH
+          raise ::Pubid::Errors::InvalidInputError,
+                ::Pubid::INPUT_TOO_LONG_MESSAGE
+        end
 
         new.parse(string.strip)
       end

data/lib/pubid/iala/urn_parser.rb

@@ -37,8 +37,12 @@ module Pubid
             # generator's casing so URN round-trip is exact.
             annex_letter = Regexp.last_match(2)&.upcase
             annex_form = annex_letter ? "ANNEX" : "Annex"
-          when /\Aed/
-            edition = seg.sub(/\Aed/, "")
+          # Edition marker: case-insensitive with an optional separator dot.
+          # Both variants occur in published documents (R1026 prints
+          # "Ed1.0" and "ed.1.0"); each parses to the canonical edition
+          # value and re-renders as lowercase "ed<x.x>".
+          when /\Aed\.?/i
+            edition = seg.sub(/\Aed\.?/i, "")
           when /\A[a-z]\z/i
             language = seg.upcase
           end

data/lib/pubid/iala.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Iala
     extend Pubid::PrefixesSupport

data/lib/pubid/iana/builder.rb

@@ -10,8 +10,10 @@ module Pubid
       end
 
       def build(data)
+        # The top-level slug is stored as `number` — it is the relaton-index
+        # key; `Identifier#registry` reads it back.
         Identifiers::Registry.new(
-          registry: data[:registry].to_s,
+          number: data[:registry].to_s,
           sub_registry: data[:sub_registry]&.to_s,
         )
       end

data/lib/pubid/iana/identifier.rb

@@ -9,9 +9,12 @@ module Pubid
     # IANA entries are protocol registries, not numbered standards: the value is
     # a hierarchical registry slug (`registry` before the single "/", optional
     # `sub_registry` after it). Both are kept verbatim.
+    #
+    # The top-level slug is stored as `number` on the concrete leaf
+    # (Identifiers::Registry) so it can serve as the relaton-index key; see the
+    # long comment there for why the attribute lives on the leaf. `registry` is
+    # a derived reader over it, so it is NOT a serialized key.
     class Identifier < ::Pubid::Identifier
-      # The registry slug (e.g. "_6lowpan-parameters"). Required.
-      attribute :registry, :string
       # The sub-registry slug (e.g. "lowpan_nhc"). nil for top registries; a nil
       # default means it is dropped from the serialized hash when absent.
       attribute :sub_registry, :string
@@ -23,9 +26,12 @@ module Pubid
         "pubid:iana:registry" => "Pubid::Iana::Identifiers::Registry",
       }.freeze
 
+      # Identifiers::Registry merges its own block mapping `number` on top of
+      # this one. `number` is intentionally absent here: mapping it on the class
+      # the leaf inherits from would re-declare the parent's Components::Code
+      # attribute (see Identifiers::Registry).
       key_value do
         map "_type", to: :_type, polymorphic_map: IANA_TYPE_MAP
-        map "registry", to: :registry
         map "sub_registry", to: :sub_registry
       end
 
@@ -38,6 +44,14 @@ module Pubid
       # dropped so callers can recover the bare index-key slug.
       attr_reader :with_publisher
 
+      # The top-level registry slug. Derived from `number`, which is where it is
+      # stored — a plain method is safe because `registry` is no longer a lutaml
+      # attribute, so no generated accessor competes with it (the same shape as
+      # Pubid::Ietf::Identifiers::Bcp#series).
+      def registry
+        number
+      end
+
       # The rendered registry code, e.g. "_6lowpan-parameters/lowpan_nhc".
       def code
         sub_registry ? "#{registry}/#{sub_registry}" : registry
@@ -51,6 +65,57 @@ module Pubid
         render(format: :human, **opts)
       end
 
+      # --- Machine-readable slug -------------------------------------------
+      # The shared MrString renderer composes publisher/type/number/... from the
+      # inherited attributes, none of which IANA populates: `publisher` is a
+      # constant rather than an attribute (see PUBLISHER above) and the builder
+      # sets no typed_stage. Without these two overrides every IANA identifier
+      # rendered the empty MR string, so all of them collided on `to_mr_string`
+      # and `to_slug` (issue #142) — and `to_slug` is used as a filename.
+      #
+      # Verified over the 3405 published relaton-data-iana rows: the resulting
+      # slugs are all distinct and stay inside the documented [a-z0-9._-] MR
+      # charset. Note that IANA slugs legitimately contain "_", which is MR's
+      # supplement separator, so an IANA MR is not re-parseable by
+      # Pubid::Parsers::MrString; uniqueness and filename-safety are what these
+      # buy, not MR round-tripping.
+      def mr_publisher
+        PUBLISHER.downcase
+      end
+
+      def mr_number_with_part
+        [number, sub_registry].compact.join(".").downcase
+      end
+
+      # The guard below has to cover this surface too: without it a nil number
+      # renders the bare publisher token "iana" for every affected row, i.e. one
+      # filename shared by all of them.
+      def to_mr_string
+        require_number!
+        super
+      end
+
+      # The top-level slug moved from a `registry` key into `number` with no
+      # alias, so a row serialized before that change deserializes with a nil
+      # number and NO error: lutaml ignores unknown keys, and relaton's
+      # Index::FileIO#id_supported? skips its round-trip check for concrete
+      # subclasses (every IANA id is an Identifiers::Registry). Failing loudly
+      # at render time is the only thing that surfaces a stale index.
+      #
+      # It is called from all three identity surfaces — to_s (via Renderer),
+      # to_urn (via UrnGenerator) and to_mr_string — because guarding only one
+      # still lets every stale row collide on the other two ("urn:iana:",
+      # "iana"), which is the silent overwrite this whole change exists to
+      # prevent.
+      def require_number!
+        return unless number.nil? || number.to_s.empty?
+
+        raise ArgumentError,
+              "Cannot render #{self.class} with an empty number " \
+              "(a pre-`number` index row stored the registry slug under " \
+              "`registry`; regenerate the index)"
+      end
+
       # from_hash is the shared polymorphic dispatch on Pubid::Identifier;
       # IANA_TYPE_MAP remains as the key_value polymorphic_map.
 
@@ -58,14 +123,17 @@ module Pubid
       # @param identifier [String] The IANA identifier string to parse
       # @return [Identifier] The appropriate identifier object
       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 ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse IANA identifier '#{identifier}': #{e.message}"
       end
     end
   end

data/lib/pubid/iana/identifiers/registry.rb

@@ -11,6 +11,42 @@ module Pubid
       #   IANA _6lowpan-parameters
       #   IANA _6lowpan-parameters/lowpan_nhc
       class Registry < Identifier
+        # The top-level registry slug ("_6lowpan-parameters"), and the index
+        # key: relaton-index bsearches on `id.root.number.to_s`, and every IANA
+        # identifier is its own root (the flavor has no wrapper or supplement
+        # types), so an empty key silently defeats the search for every row.
+        #
+        # An IANA identifier carries no numeric document number — digits only
+        # ever appear glued inside a slug token (`sip-parameters-13`,
+        # `idna-tables-11.0.0`), never as a separable component — so the slug
+        # itself is the key, exactly as an Internet-Draft's slug is
+        # (lib/pubid/ietf/identifiers/serialization.rb). Keying on the TOP-LEVEL
+        # slug rather than the full `registry/sub_registry` code means a
+        # registry and all of its sub-registries cluster into one bucket, the
+        # analogue of a draft clustering with its versions.
+        #
+        # WHY THIS IS DECLARED HERE AND NOT ON Pubid::Iana::Identifier:
+        # it redefines the parent ::Pubid::Identifier's
+        # `attribute :number, Components::Code` as a plain :string. Declaring
+        # that on a class the concrete type INHERITS from resolves against the
+        # parent definition nondeterministically under multi-flavor load — it
+        # passes an IANA-only run and can flip `root.number` to "" under the
+        # full suite (the IEEE/IETF lesson; see
+        # lib/pubid/ieee/identifiers/code_number.rb and CLAUDE.md). Declaring it
+        # directly on the leaf removes the ambiguity at the point of use.
+        # For the same reason, never define a `#number` *method* — it would
+        # collide with lutaml's generated accessor.
+        # spec/pubid/iana/root_number_spec.rb guards this and must run under the
+        # FULL suite to be meaningful.
+        attribute :number, :string
+
+        # Merged by lutaml with the base's key_value block, which maps `_type`
+        # and `sub_registry`. `registry` is deliberately NOT stored — it is the
+        # same string as `number`, and the base exposes it as a derived reader.
+        key_value do
+          map "number", to: :number
+        end
+
         # IANA registries carry no revision/stage lifecycle; a single published
         # typed stage keeps parity with the other flavors' type registries.
         TYPED_STAGES = [

data/lib/pubid/iana/parser.rb

@@ -12,7 +12,7 @@ module Pubid
     #
     # Slugs use only [a-zA-Z0-9._-] and contain at most one "/", so a plain
     # character-class repeat parses them; there is no ReDoS surface.
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # A single registry slug: letters, digits, dot, underscore, hyphen.
       rule(:slug) { match['a-zA-Z0-9._\-'].repeat(1) }
 

data/lib/pubid/iana/renderer.rb

@@ -15,6 +15,9 @@ module Pubid
 
       def render(**_opts)
         id = @id
+        # A stale (pre-`number`) row must not render as a bare "IANA " or
+        # "IANA /lowpan_nhc"; see Identifier#require_number!.
+        id.require_number!
         code = id.code
         with_publisher?(id) ? "#{PUBLISHER} #{code}" : code
       end

data/lib/pubid/iana/urn_generator.rb

@@ -6,7 +6,11 @@ module Pubid
     # (charset is [a-zA-Z0-9._-]), so the two levels split unambiguously.
     class UrnGenerator < Pubid::UrnGenerator::Base
       def generate
-        parts = ["urn", "iana", identifier.registry]
+        # A stale (pre-`number`) row would otherwise emit the bare "urn:iana:"
+        # for every affected id; see Identifier#require_number!.
+        identifier.require_number!
+        # `number` holds the top-level registry slug (Identifiers::Registry).
+        parts = ["urn", "iana", identifier.number]
         parts << identifier.sub_registry if identifier.sub_registry
         parts.join(":")
       end

data/lib/pubid/iana.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Iana
     extend Pubid::PrefixesSupport