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

data/lib/pubid/ietf/identifiers/base.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    # Base class for every IETF identifier AND the flavor's parse/create entry
+    # point (mirrors Pubid::Jis::Identifier). Concrete identifiers under
+    # Pubid::Ietf::Identifiers descend from this class, so a parsed IETF id is
+    # an instance of Pubid::Ietf::Identifier.
+    #
+    # All families are flat, supplement-free, and use plain string attributes.
+    # Those attributes are declared on the LEAVES by Identifiers::Serialization
+    # (see the determinism note there — never re-add `attribute :number` here):
+    #   * Rfc            -> number ("2119")
+    #   * Bcp/Std/Fyi    -> number ("3") + a derived `series` reader
+    #   * InternetDraft  -> number ("draft-giuliano-treedn") + optional version
+    class Identifier < ::Pubid::Identifier
+      # 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 the shared from_hash dispatch.
+      IETF_TYPE_MAP = {
+        "pubid:ietf:rfc" => "Pubid::Ietf::Identifiers::Rfc",
+        "pubid:ietf:bcp" => "Pubid::Ietf::Identifiers::Bcp",
+        "pubid:ietf:std" => "Pubid::Ietf::Identifiers::Std",
+        "pubid:ietf:fyi" => "Pubid::Ietf::Identifiers::Fyi",
+        "pubid:ietf:internet-draft" =>
+          "Pubid::Ietf::Identifiers::InternetDraft",
+      }.freeze
+
+      # NOTE: no `key_value` block here on purpose. The mapping lives on the
+      # leaves (Identifiers::Serialization); a block on this shared parent would
+      # be inherited-and-merged by every leaf and re-emit keys the leaf did not
+      # declare.
+
+      # Publisher is always "IETF". 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 = "IETF"
+
+      # Basic string representation. Delegates to the flavor renderer.
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier; the
+      # IETF_TYPE_MAP above serves as its key_value polymorphic_map.
+
+      # Parse an IETF identifier string into the appropriate identifier object.
+      # @param identifier [String] the IETF identifier string to parse
+      # @return [Identifier] the concrete identifier object
+      # @raise [Pubid::Errors::InvalidInputError] if the input exceeds
+      #   Pubid::MAX_INPUT_LENGTH
+      # @raise [Pubid::Errors::ParseError] if parsing fails
+      def self.parse(identifier)
+        # Inline length guard (CodeQL rb/polynomial-redos barrier) — must be
+        # the first statement. This class-level funnel is what relaton reaches
+        # directly through `pubid_class: ::Pubid::Ietf::Identifier`, so it
+        # cannot rely on the guard in Pubid::Ietf.parse.
+        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/ietf/identifiers/bcp.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # A BCP (Best Current Practice) sub-series id, e.g. "BCP 3".
+      class Bcp < Identifier
+        include Serialization
+
+        # The series token is derived from the class, not stored:
+        # `_type` already encodes it, so serializing `series` would
+        # duplicate the type in every index row.
+        SERIES = "BCP"
+
+        def series
+          SERIES
+        end
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :bcp,
+            stage_code: :published,
+            type_code: :bcp,
+            abbr: ["BCP"],
+            name: "Best Current Practice",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :bcp, web: :bcp, title: "Best Current Practice", short: "BCP" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/identifiers/fyi.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # An FYI (For Your Information) sub-series id, e.g. "FYI 1".
+      class Fyi < Identifier
+        include Serialization
+
+        # The series token is derived from the class, not stored:
+        # `_type` already encodes it, so serializing `series` would
+        # duplicate the type in every index row.
+        SERIES = "FYI"
+
+        def series
+          SERIES
+        end
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :fyi,
+            stage_code: :published,
+            type_code: :fyi,
+            abbr: ["FYI"],
+            name: "For Your Information",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :fyi, web: :fyi, title: "For Your Information", short: "FYI" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/identifiers/internet_draft.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # An Internet-Draft, e.g. "draft-giuliano-treedn-02" (versioned) or
+      # "draft-giuliano-treedn" (the unversioned "latest" sibling). The full
+      # slug (including the leading "draft-") is stored in `number` — it is the
+      # relaton-index narrowing key, shared by a draft's unversioned aggregator
+      # row and all of its versions; the optional trailing two-digit version is
+      # in `version`.
+      class InternetDraft < Identifier
+        include Serialization
+
+        # Two-digit version string, zero-pad preserved ("02"); nil for the
+        # unversioned "latest" sibling, in which case the canonical to_hash
+        # drops the key entirely.
+        attribute :version, :string
+
+        # Merged with the block Serialization installs (lutaml combines a
+        # mixin-installed key_value with a second in-class one), so the
+        # serialized shape is {_type, number} plus `version` when set.
+        key_value do
+          map "version", to: :version
+        end
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :internet_draft,
+            stage_code: :draft,
+            type_code: :internet_draft,
+            abbr: ["I-D", "Internet-Draft"],
+            name: "Internet-Draft",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :internet_draft, web: :internet_draft,
+            title: "Internet-Draft", short: "I-D" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/identifiers/rfc.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # An RFC (Request for Comments), e.g. "RFC 2119".
+      class Rfc < Identifier
+        include Serialization
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :rfc,
+            stage_code: :published,
+            type_code: :rfc,
+            abbr: ["RFC"],
+            name: "Request for Comments",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :rfc, web: :rfc, title: "Request for Comments", short: "RFC" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/identifiers/serialization.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # Installs the flat, index-friendly attribute set and the shared
+      # `key_value` block on the five concrete IETF leaves (Rfc, Bcp, Std, Fyi,
+      # InternetDraft).
+      #
+      # Why the leaves and not the shared Pubid::Ietf::Identifier base:
+      # `number` redefines the parent ::Pubid::Identifier's
+      # `attribute :number, Components::Code` as a plain :string. Declaring that
+      # on a class the concrete types INHERIT from resolves against the parent
+      # definition nondeterministically under multi-flavor load — it passes an
+      # IETF-only run and can flip `root.number` to "" under the full suite (the
+      # IEEE lesson; see lib/pubid/ieee/identifiers/code_number.rb and
+      # CLAUDE.md). Declaring `number` directly on each leaf removes the
+      # ambiguity at the point of use.
+      #
+      # This matters because relaton-index bsearches on `id.root.number.to_s`,
+      # and every IETF identifier is its own root (the flavor has no wrapper or
+      # supplement types), so an empty key silently defeats the search for every
+      # row. spec/pubid/ietf/root_number_spec.rb guards it and must run under
+      # the FULL suite to be meaningful.
+      #
+      # `series` is deliberately NOT an attribute here: `_type` already encodes
+      # it, so storing it would duplicate the type in every sub-series row. The
+      # three sub-series leaves expose it as a derived reader instead.
+      module Serialization
+        def self.included(base)
+          # Document number of an RFC or sub-series id ("2119", "66"), kept as
+          # a string so the printed form carries no zero-pad; for an
+          # Internet-Draft, the version-less slug INCLUDING the leading
+          # "draft-" ("draft-ietf-quic-transport"). The slug is the right index
+          # key for the same reason the number is for an RFC: a draft's
+          # unversioned aggregator row and every one of its versions share it,
+          # so a document and its variants cluster into one bucket.
+          base.attribute :number, :string
+
+          # Only these keys serialize; the inherited Pubid::Identifier
+          # attributes are intentionally dropped. InternetDraft merges its own
+          # `version` mapping on top of this block.
+          base.key_value do
+            map "_type", to: :_type, polymorphic_map: Identifier::IETF_TYPE_MAP
+            map "number", to: :number
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/identifiers/std.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # An STD (Internet Standard) sub-series id, e.g. "STD 66".
+      class Std < Identifier
+        include Serialization
+
+        # The series token is derived from the class, not stored:
+        # `_type` already encodes it, so serializing `series` would
+        # duplicate the type in every index row.
+        SERIES = "STD"
+
+        def series
+          SERIES
+        end
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :std,
+            stage_code: :published,
+            type_code: :std,
+            abbr: ["STD"],
+            name: "Internet Standard",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :std, web: :std, title: "Internet Standard", short: "STD" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/identifiers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      autoload :Serialization, "#{__dir__}/identifiers/serialization"
+      autoload :Rfc, "#{__dir__}/identifiers/rfc"
+      autoload :Bcp, "#{__dir__}/identifiers/bcp"
+      autoload :Std, "#{__dir__}/identifiers/std"
+      autoload :Fyi, "#{__dir__}/identifiers/fyi"
+      autoload :InternetDraft, "#{__dir__}/identifiers/internet_draft"
+    end
+  end
+end

data/lib/pubid/ietf/parser.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Ietf
+    # Parslet grammar for the three IETF families. The top-level alternation is
+    # keyed by leading token, and each alternative captures the raw fields the
+    # Builder needs:
+    #   * RFC        -> { number: }
+    #   * sub-series -> { series:, number: }
+    #   * draft      -> { draft_rest: }  (everything after "draft-"; the version
+    #                    split is done in the Builder to keep the digit-tail
+    #                    heuristic in one place)
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:space) { str(" ") }
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+
+      # "RFC 2119", and the zero-padded, space-less spelling the RFC editor's
+      # rfc-index.xml emits ("RFC0001"). See #subseries for why.
+      rule(:rfc) { str("RFC") >> space.maybe >> digits.as(:number) }
+
+      # "BCP 3" / "STD 66" / "FYI 1".
+      #
+      # The space is optional and leading zeros are allowed because
+      # rfc-index.xml writes the sub-series membership of an RFC in the padded,
+      # space-less form -- <is-also><doc-id>STD0066</doc-id></is-also> -- and
+      # relaton builds the STD/BCP/FYI <-> RFC cross-references from exactly
+      # those elements without normalizing them itself. The Builder strips the
+      # pad, so the printed form stays the canonical "STD 66".
+      rule(:subseries) do
+        (str("BCP") | str("STD") | str("FYI")).as(:series) >>
+          space.maybe >> digits.as(:number)
+      end
+
+      # Internet-Draft slug characters: lowercase, digits and the "-", "+", "_"
+      # separators, plus two historical shapes the published corpus carries --
+      # a dot inside a topic token ("draft-ietf-pilc-2.5g3g-12") and uppercase
+      # letters in protocol/organisation names ("draft-chapin-clnp-ISO8473-00").
+      # 50 of the 166,740 relaton-data-ids identifiers need those two
+      # characters; nothing else outside [a-z0-9-] occurs in the corpus.
+      #
+      # Widening the tail is unambiguous: the top-level alternation is keyed on
+      # the leading token (RFC / BCP|STD|FYI / draft-), so a wider draft tail
+      # cannot make another branch match.
+      #
+      # The whole remainder after "draft-" is captured; the Builder anchors the
+      # optional trailing "-NN" version.
+      rule(:draft_rest) { match['a-zA-Z0-9+_.\-'].repeat(1).as(:draft_rest) }
+      rule(:draft) { str("draft-") >> draft_rest }
+
+      rule(:identifier) { rfc | subseries | draft }
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/ietf/renderer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    # Human-readable renderer for IETF identifiers.
+    #
+    # Produces strings like:
+    #   "RFC 2119"
+    #   "BCP 3" / "STD 66" / "FYI 1"
+    #   "draft-giuliano-treedn-02" / "draft-giuliano-treedn"
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        require_number!(@id)
+        render_identifier(@id)
+      end
+
+      private
+
+      # For an Internet-Draft, `number` holds the version-less slug including
+      # the leading "draft-"; for the sub-series, `series` is derived from the
+      # class rather than stored. The sub-series arm names its three classes
+      # explicitly instead of being a catch-all `else`, because a bare
+      # Pubid::Ietf::Identifier has no `series` reader at all.
+      def render_identifier(id)
+        case id
+        when Identifiers::Rfc then "RFC #{id.number}"
+        when Identifiers::InternetDraft then render_draft(id)
+        when Identifiers::Bcp, Identifiers::Std, Identifiers::Fyi
+          "#{id.series} #{id.number}"
+        else unsupported!(id)
+        end
+      end
+
+      def render_draft(id)
+        id.version ? "#{id.number}-#{id.version}" : id.number
+      end
+
+      # Fail loudly rather than render a nil/partial string. `number` carries
+      # the whole document identity for every IETF type, so a nil one means the
+      # object was built from something that is not a current IETF hash — most
+      # likely a pre-`number` index row, which stored an Internet-Draft slug
+      # under `name` (a key nothing reads any more; lutaml ignores it
+      # silently). Such a row would otherwise deserialize into an identifier
+      # that renders "" or "-02" and keys the index under "", with no error
+      # anywhere — exactly the silent-wrong-lookup failure this flavor's
+      # round-trip specs exist to prevent. Regenerate the
+      # relaton-data-{rfcs,rfcsubseries,ids} indexes instead.
+      def require_number!(id)
+        return unless id.respond_to?(:number)
+        return unless id.number.nil? || id.number.empty?
+
+        raise ArgumentError,
+              "Cannot render #{id.class} with an empty number " \
+              "(a pre-`number` index row stored the draft slug under `name`; " \
+              "regenerate the index)"
+      end
+
+      def unsupported!(id)
+        raise ArgumentError,
+              "Cannot render #{id.class}: not a concrete IETF identifier"
+      end
+    end
+  end
+end

data/lib/pubid/ietf/urn_generator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    # Emits the canonical IETF URNs:
+    #   RFC            -> urn:ietf:rfc:2119
+    #   BCP/STD/FYI    -> urn:ietf:bcp:3 / urn:ietf:std:66 / urn:ietf:fyi:1
+    #   Internet-Draft -> urn:ietf:id:draft-giuliano-treedn[:02]
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      # The sub-series arm names its three classes explicitly rather than being
+      # a catch-all `else`, because a bare Pubid::Ietf::Identifier has no
+      # `series` reader at all — `series` is derived from the concrete class.
+      def generate
+        case identifier
+        when Identifiers::Rfc then "urn:ietf:rfc:#{identifier.number}"
+        when Identifiers::InternetDraft then draft_urn
+        when Identifiers::Bcp, Identifiers::Std, Identifiers::Fyi
+          "urn:ietf:#{identifier.series.downcase}:#{identifier.number}"
+        else unsupported!
+        end
+      end
+
+      private
+
+      def draft_urn
+        base = "urn:ietf:id:#{identifier.number}"
+        identifier.version ? "#{base}:#{identifier.version}" : base
+      end
+
+      def unsupported!
+        raise ArgumentError,
+              "Cannot build a URN for #{identifier.class}: " \
+              "not a concrete IETF identifier"
+      end
+    end
+  end
+end

data/lib/pubid/ietf/urn_parser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    # Parses IETF URNs back into identifiers by reconstructing the printed form
+    # and delegating to the flavor's text parser. Inverts UrnGenerator:
+    #   urn:ietf:rfc:2119                     -> "RFC 2119"
+    #   urn:ietf:bcp:3                        -> "BCP 3"
+    #   urn:ietf:id:draft-giuliano-treedn:02  -> "draft-giuliano-treedn-02"
+    #   urn:ietf:id:draft-giuliano-treedn     -> "draft-giuliano-treedn"
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        parts = split_parts(strip_namespace(urn))
+        flavor_parse(human_text(parts.shift, parts))
+      end
+
+      private
+
+      def human_text(type, parts)
+        case type
+        when "rfc" then "RFC #{parts[0]}"
+        when "bcp", "std", "fyi" then "#{type.upcase} #{parts[0]}"
+        when "id" then draft_text(parts)
+        else invalid_type!(type)
+        end
+      end
+
+      # `Errors` is defined under Pubid::UrnParser (the module), which is
+      # neither in this class's lexical scope nor an ancestor of Base, so the
+      # constant must be fully qualified — a bare `Errors::ParseError` raises
+      # NameError instead of the intended error.
+      def invalid_type!(type)
+        raise Pubid::UrnParser::Errors::ParseError,
+              "Invalid IETF URN type: #{type.inspect}"
+      end
+
+      def draft_text(parts)
+        name, version = parts
+        version ? "#{name}-#{version}" : name
+      end
+    end
+  end
+end

data/lib/pubid/ietf.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  # IETF flavor: one module covering the three IETF document families that share
+  # the IETF publisher and the `urn:ietf:` namespace —
+  #   * RFC              (e.g. "RFC 2119")     -> Identifiers::Rfc
+  #   * RFC sub-series   (BCP/STD/FYI)         -> Identifiers::Bcp/Std/Fyi
+  #   * Internet-Drafts  (e.g. "draft-...-02") -> Identifiers::InternetDraft
+  module Ietf
+    extend Pubid::PrefixesSupport
+
+    # Leading tokens a printed IETF id can begin with. "draft" covers the
+    # "draft-<slug>" Internet-Draft form. No joint/co-publication prefixes.
+    PREFIXES = ["RFC", "BCP", "STD", "FYI", "draft"].freeze
+
+    autoload :Builder, "#{__dir__}/ietf/builder"
+    autoload :Identifier, "#{__dir__}/ietf/identifiers/base"
+    autoload :Identifiers, "#{__dir__}/ietf/identifiers"
+    autoload :Parser, "#{__dir__}/ietf/parser"
+    autoload :Renderer, "#{__dir__}/ietf/renderer"
+    autoload :UrnGenerator, "#{__dir__}/ietf/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ietf/urn_parser"
+
+    # Parse an IETF identifier string
+    def self.parse(identifier)
+      # Inline length guard (CodeQL rb/polynomial-redos barrier) before the
+      # normalization/parse path. The type check goes above it because it is
+      # what makes `.length` safe to call; the length check itself must still
+      # be the first thing the input string meets.
+      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: Ietf::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 IETF flavor with the registry
+Pubid::Registry.register(:ietf, Pubid::Ietf)

data/lib/pubid/iho/identifier.rb

@@ -3,7 +3,5 @@
 # The IHO flavor base class is Pubid::Iho::Identifier — a real Pubid::Identifier
 # subclass that every concrete IHO identifier descends from, so `is_a?` identity
 # and the shared polymorphic `from_hash` work natively (no facade needed). Its
-# body, `.parse`, and the Identifiers::Base back-compat alias live in
-# identifiers/base.rb; this file just ensures it is loaded when a consumer
+# body and `.parse` live in identifiers/base.rb; this file just ensures it is loaded when a consumer
 # references Pubid::Iho::Identifier directly.
-require_relative "identifiers/base"

data/lib/pubid/iho/identifiers/base.rb

@@ -3,8 +3,7 @@
 module Pubid
   module Iho
     # Base class for all IHO identifiers. Canonical name Pubid::Iho::Identifier;
-    # every concrete IHO identifier (Identifiers::*) descends from it, and
-    # Identifiers::Base — aliased at the foot of this file — points back to it.
+    # every concrete IHO identifier (Identifiers::*) descends from it.
     #
     # IHO identifiers have the form:
     #   IHO {S|P|M|B|C}-{number}[ Ap. {appendix}][ Part {part}][ Annex {annex}][ Suppl {supplement}][ {version}]
@@ -15,12 +14,19 @@ module Pubid
       # Parse an IHO identifier string into an identifier object
       # @param identifier [String] The IHO identifier string to parse
       # @return [Pubid::Iho::Identifier] The appropriate identifier object
-      # @raise [Parslet::ParseFailed] If parsing fails
+      # @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)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse IHO identifier '#{identifier}': #{e.message}"
       end
 
       # `number` overrides the generic Components::Code attribute with a plain
@@ -65,10 +71,5 @@ module Pubid
       # IHO_TYPE_MAP remains as the key_value polymorphic_map.
     end
 
-    module Identifiers
-      # Backward-compatible alias: IHO's base class used to be
-      # Pubid::Iho::Identifiers::Base. It is now Pubid::Iho::Identifier.
-      Base = Pubid::Iho::Identifier
-    end
   end
 end