pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/iala/parser.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Iala
+    # Parslet grammar for IALA identifiers.
+    #
+    # Accepts every shape that appears on the IALA website or cover page:
+    #
+    #   S1070
+    #   S1070 Ed 2.0
+    #   IALA S1070 Ed 2.0
+    #   S1070 Ed 2.0 (F)
+    #   R1016:ed2.0(F)
+    #   C0103-1
+    #   C0103-1 Ed 3.0
+    class Parser < ::Pubid::Parser::Grammar
+      include ::Pubid::Parser::CommonParseRules
+
+      root :identifier
+
+      rule(:space)  { str(" ") }
+      rule(:space?) { space.maybe }
+      rule(:dash)   { str("-") }
+      rule(:colon)  { str(":") }
+      rule(:dot)    { str(".") }
+      rule(:lparen) { str("(") }
+      rule(:rparen) { str(")") }
+
+      # Type prefix — IALA document classes. GA must be tried before G so it
+      # isn't left with a dangling "A". Captured to route to the right
+      # Identifiers::* subclass.
+      rule(:type_letter) do
+        (str("GA") | str("S") | str("R") | str("G") | str("M") |
+         str("C") | str("A") | str("L") | str("X") | str("P")).as(:type_letter)
+      end
+
+      # Document number — one or more decimal digits. The dataset historically
+      # zero-pads to 4 (S1070, R0126, M0001) but the canonical form going
+      # forward is unpadded (M1, GA1.1). Accept any length so both shapes
+      # round-trip; the number attribute preserves whatever was parsed.
+      rule(:doc_number) do
+        match("[0-9]").repeat(1).as(:doc_number)
+      end
+
+      # Dotted continuation that some prefixes use as part of the number:
+      # GA01.01 (series.index), L2.1.11 (series.sub.item). Captured into the
+      # same :doc_number atom so the number attribute stays a single string
+      # (e.g. "01.01", "2.1.11") and the existing builder needs no changes.
+      rule(:dotted_number) do
+        dot >> match("[0-9]").repeat(1)
+      end
+
+      rule(:number_with_dots) do
+        doc_number >> dotted_number.repeat.as(:doc_number_dots)
+      end
+
+      # Numeric sub-part suffix(es): "-1", "-9-10", "-11". The catalogue
+      # uses ranges like R0124-9-10 & 11 — that compound is captured
+      # verbatim and resolved by the caller, not here.
+      rule(:subpart) do
+        (dash >> digits.as(:subpart_number)).repeat(1).as(:subpart)
+      end
+
+      rule(:code) do
+        type_letter >> number_with_dots >> subpart.maybe
+      end
+
+      # Edition forms observed on covers and listing pages:
+      #   " Ed 2.0"      — cover-page human form
+      #   ":ed2.0"       — listing-page compact form
+      rule(:edition_human) do
+        (space >> str("Ed") >> space >> edition_value).as(:edition)
+      end
+
+      rule(:edition_compact) do
+        (colon >> str("ed") >> edition_value).as(:edition)
+      end
+
+      rule(:edition_value) do
+        (digits >> (dot >> digits).repeat).as(:edition_value)
+      end
+
+      rule(:edition) do
+        edition_human | edition_compact
+      end
+
+      # Language is a single uppercase letter inside parens: (E), (F), …
+      rule(:language) do
+        (space? >> lparen >>
+          (str("E") | str("F") | str("S") | str("C") | str("A") | str("R")).as(:language) >>
+          rparen).as(:language_group)
+      end
+
+      # Optional "IALA " prefix.
+      rule(:publisher) do
+        (str("IALA") >> space).maybe
+      end
+
+      rule(:identifier) do
+        annex_identifier | (publisher >> code >> edition.maybe >> language.maybe)
+      end
+
+      # Annex to a base publication. Wraps the base code and adds an
+      # "Annex" / "ANNEX" marker (case preserved verbatim), an optional
+      # single-letter suffix (A/B/C/D), then the usual edition + language.
+      # Tried before the flat `identifier` so the annex marker isn't left
+      # dangling after a successful base-code match.
+      #
+      # The letter suffix uses a negative lookahead for a following lowercase
+      # letter so the "E" in "Ed 1" isn't mis-captured as annex letter "E".
+      rule(:annex_identifier) do
+        (publisher >> type_letter >> number_with_dots >> subpart.maybe).as(:base) >>
+          space >> (str("Annex") | str("ANNEX")).as(:annex_marker) >>
+          (space >> match("[A-Z]").as(:annex_letter) >> match("[a-z]").absent?).maybe >>
+          edition.maybe >> language.maybe
+      end
+
+      # Parse a string and return the raw parslet tree.
+      # @param string [String]
+      # @return [Hash]
+      def self.parse(string)
+        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
+    end
+  end
+end

data/lib/pubid/iala/renderer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Human-readable renderer for IALA identifiers.
+    #
+    # Produces strings like:
+    #   "IALA S1070"
+    #   "IALA S1070 Ed 2.0"
+    #   "IALA R1016 Ed 2.0 (F)"
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        id = @id
+
+        return render_annex(id) if id.is_a?(Identifiers::Annex)
+
+        rendered = "#{id.publisher} #{id.type_letter}#{id.number}"
+        rendered << " Ed #{id.edition}" if id.edition
+        rendered << " (#{id.language})" if id.language
+        rendered
+      end
+
+      # Render an Annex wrapper. The base identifier is rendered first, then
+      # the marker form is preserved verbatim ("Annex" vs "ANNEX"), then the
+      # optional letter, edition, and language.
+      def render_annex(id)
+        base_str = id.base.to_s
+        rendered = "#{base_str} #{id.annex_form}"
+        rendered << " #{id.letter}" if id.letter
+        rendered << " Ed #{id.edition}" if id.edition
+        rendered << " (#{id.language})" if id.language
+        rendered
+      end
+    end
+  end
+end

data/lib/pubid/iala/urn_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Generates URN strings for IALA identifiers using the Maritime Resource
+    # Name (MRN) namespace that IALA prints on its cover pages.
+    #
+    # Format: urn:mrn:iala:pub:<type-lower><number>[:ed<edition>][:<lang-lower>]
+    # Example: urn:mrn:iala:pub:s1070:ed2.0
+    #          urn:mrn:iala:pub:r1016:ed2.0:f
+    class UrnGenerator
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        return generate_annex if identifier.is_a?(Identifiers::Annex)
+
+        parts = ["urn:mrn:iala:pub", code_segment]
+        parts << "ed#{identifier.edition}" if identifier.edition
+        parts << identifier.language.downcase if identifier.language
+        parts.join(":")
+      end
+
+      private
+
+      # URN for an Annex: embeds the base's code, then an "annex" segment
+      # (with optional letter suffix), then the annex's own edition/lang.
+      #   G1045 Annex Ed 1           → urn:mrn:iala:pub:g1045:annex:ed1
+      #   G1128 ANNEX A Ed 1.6 (E)    → urn:mrn:iala:pub:g1128:annex-a:ed1.6:e
+      def generate_annex
+        base = identifier.base
+        parts = ["urn:mrn:iala:pub",
+                 "#{base.type_letter.downcase}#{base.number}"]
+        annex_seg = identifier.letter ? "annex-#{identifier.letter.downcase}" : "annex"
+        parts << annex_seg
+        parts << "ed#{identifier.edition}" if identifier.edition
+        parts << identifier.language.downcase if identifier.language
+        parts.join(":")
+      end
+
+      def code_segment
+        "#{identifier.type_letter.downcase}#{identifier.number}"
+      end
+    end
+  end
+end

data/lib/pubid/iala/urn_parser.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Parses IALA MRN URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:mrn:iala:pub:<type-lower><number>[:ed<edition>][:<lang-lower>]
+    # and for Annex identifiers:
+    #   urn:mrn:iala:pub:<base-code>:annex[-<letter>][:ed<edition>][:<lang>]
+    #
+    # Examples:
+    #   urn:mrn:iala:pub:s1070:ed2.0          → IALA S1070 Ed 2.0
+    #   urn:mrn:iala:pub:r1016:ed2.0:f        → IALA R1016 Ed 2.0 (F)
+    #   urn:mrn:iala:pub:c0103-1              → IALA C0103-1
+    #   urn:mrn:iala:pub:g1045:annex:ed1      → IALA G1045 Annex Ed 1
+    #   urn:mrn:iala:pub:g1128:annex-a:ed1.6  → IALA G1128 ANNEX A Ed 1.6
+    class UrnParser < Pubid::UrnParser::Base
+      PREFIX = "urn:mrn:iala:pub:".freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        code = parts.fetch(0)
+
+        edition = nil
+        language = nil
+        annex_form = nil
+        annex_letter = nil
+
+        parts.drop(1).each do |seg|
+          case seg
+          when /\Aannex(-([a-z]))?\z/i
+            # UrnGenerator emits "annex" (bare) for the Annex-without-letter
+            # form and "annex-X" (lettered) for the uppercase ANNEX form.
+            # The human parser accepts both "Annex" and "ANNEX"; mirror the
+            # 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/, "")
+          when /\A[a-z]\z/i
+            language = seg.upcase
+          end
+        end
+
+        text = "IALA #{code.upcase}"
+        text += " #{annex_form}" if annex_form
+        text += " #{annex_letter}" if annex_letter
+        text += " Ed #{edition}" if edition
+        text += " (#{language})" if language
+        flavor_parse(text)
+      end
+
+      private
+
+      def strip_namespace(urn)
+        unless urn.downcase.start_with?(PREFIX)
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid IALA URN: #{urn.inspect}"
+        end
+
+        urn[PREFIX.length..]
+      end
+    end
+  end
+end

data/lib/pubid/iala.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    extend Pubid::PrefixesSupport
+
+    # Sole IALA publisher token (see the parser's `publisher` rule).
+    PREFIXES = ["IALA"].freeze
+
+    autoload :Builder,      "#{__dir__}/iala/builder"
+    autoload :Identifier,   "#{__dir__}/iala/identifier"
+    autoload :Identifiers,  "#{__dir__}/iala/identifiers"
+    autoload :Parser,       "#{__dir__}/iala/parser"
+    autoload :Renderer,     "#{__dir__}/iala/renderer"
+    autoload :UrnGenerator, "#{__dir__}/iala/urn_generator"
+    autoload :UrnParser,    "#{__dir__}/iala/urn_parser"
+
+    # Parse an IALA identifier string into an identifier object.
+    # @param identifier [String] The IALA identifier string to parse
+    # @return [Pubid::Iala::Identifier]
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Iala::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
+    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 < Pubid::Identifier }
+        .reject { |c| c == Identifier }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>]
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol]
+    # @return [Class, nil]
+    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]
+    # @return [Pubid::Components::TypedStage, nil]
+    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
+
+    # Look up an identifier class by its IALA type letter (S, R, G, M, C, X, P).
+    # @param letter [String]
+    # @return [Class<Identifier>]
+    def self.identifier_klass_for_type_letter(letter)
+      @by_letter ||= identifier_types.to_h { |klass| [klass.type[:short], klass] }
+      @by_letter.fetch(letter.to_s.upcase)
+    end
+  end
+end
+
+Pubid::Registry.register(:iala, Pubid::Iala)

data/lib/pubid/iana/builder.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    # Builds an IANA identifier object from a parse tree. There is a single
+    # concrete type (Registry), so the builder just extracts the slug fields.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      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(
+          number: data[:registry].to_s,
+          sub_registry: data[:sub_registry]&.to_s,
+        )
+      end
+    end
+  end
+end

data/lib/pubid/iana/identifier.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    # Base class for every IANA identifier AND the flavor's parse/create entry
+    # point. Concrete identifiers under Pubid::Iana::Identifiers descend from
+    # this class, so a parsed IANA id is an instance of Pubid::Iana::Identifier.
+    #
+    # 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 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
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization: maps
+      # the single Registry subclass's polymorphic_name to its class name so a
+      # stored hash rebuilds the correct identifier type via from_hash.
+      IANA_TYPE_MAP = {
+        "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 "sub_registry", to: :sub_registry
+      end
+
+      # Publisher is always "IANA". A plain constant (not a `publisher` method)
+      # so it doesn't shadow the inherited lutaml `publisher` attribute, which
+      # would otherwise fail serialization type validation.
+      PUBLISHER = "IANA"
+
+      # Render-time flag stashed by #to_s; when false, the "IANA " token is
+      # 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
+      end
+
+      # Basic string representation. Delegates to the renderer. Always emits the
+      # "IANA " token (the authoritative printed form) unless with_publisher is
+      # false, in which case the bare slug is rendered.
+      def to_s(with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        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.
+
+      # Parse an IANA identifier string into an identifier object
+      # @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 Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    module Identifiers
+      # The sole IANA identifier type: a protocol registry (optionally with a
+      # sub-registry). Its class name yields the polymorphic `_type` tag
+      # "pubid:iana:registry".
+      #
+      # Examples:
+      #   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 = [
+          Pubid::Components::TypedStage.new(
+            code: :pubiana,
+            stage_code: :published,
+            type_code: :iana,
+            abbr: ["IANA"],
+            name: "IANA Registry",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :iana, web: :registry, title: "IANA Registry", short: "IANA" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iana/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    module Identifiers
+      autoload :Registry, "#{__dir__}/identifiers/registry"
+    end
+  end
+end

data/lib/pubid/iana/parser.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Iana
+    # Parslet grammar for IANA registry identifiers.
+    #
+    # Accepts the authoritative printed form "IANA <slug>[/<sub-slug>]" as well
+    # as a bare index-key slug (no "IANA " prefix). The optional prefix is
+    # consumed and discarded — the renderer always re-emits it.
+    #
+    # 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 < ::Pubid::Parser::Grammar
+      # A single registry slug: letters, digits, dot, underscore, hyphen.
+      rule(:slug) { match['a-zA-Z0-9._\-'].repeat(1) }
+
+      # Optional publisher prefix. The trailing space is required, so a
+      # space-free slug never triggers it; PEG `.maybe` backtracks the whole
+      # sequence if the space is absent (e.g. a slug that happens to start
+      # "IANA...").
+      rule(:iana_prefix) { (str("IANA") >> str(" ")).maybe }
+
+      rule(:identifier) do
+        iana_prefix >>
+          slug.as(:registry) >>
+          (str("/") >> slug.as(:sub_registry)).maybe
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/iana/renderer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    # Human-readable renderer for IANA registry identifiers.
+    #
+    # Produces the authoritative printed form:
+    #   "IANA _6lowpan-parameters"
+    #   "IANA _6lowpan-parameters/lowpan_nhc"
+    #
+    # With `with_publisher: false` on the identifier it renders the bare
+    # index-key slug instead (no "IANA " token).
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "IANA"
+
+      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
+
+      private
+
+      def with_publisher?(id)
+        id.with_publisher != false
+      end
+    end
+  end
+end