pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.11

data/lib/pubid/ieee/urn_generator.rb

@@ -17,7 +17,8 @@ module Pubid
         cc = code_component
         parts << cc if cc
 
-        parts << identifier.year if identifier.year
+        yc = year_component
+        parts << yc if yc
 
         dc = draft_component
         parts << dc if dc
@@ -126,8 +127,7 @@ module Pubid
       end
 
       def publisher_component
-        pub = identifier.publisher || "IEEE"
-        pub = pub.to_s.downcase
+        pub = normalized_publisher
 
         if identifier.copublisher&.any?
           copubs = identifier.copublisher.map(&:to_s).map(&:downcase)
@@ -137,6 +137,18 @@ module Pubid
         pub
       end
 
+      # A dual-published document has TWO publishers, and
+      # DualPublished#publisher returns them as an Array — which `to_s`
+      # rendered into the URN as a literal Ruby array literal, brackets and
+      # quotes included: `urn:ieee:["ieee", "asme"]`. Join them the same way a
+      # copublisher list is joined above.
+      def normalized_publisher
+        names = Array(identifier.publisher)
+          .map { |p| p.to_s.downcase }.reject(&:empty?)
+
+        names.empty? ? "ieee" : names.join("-")
+      end
+
       def type_component
         return nil unless identifier.type
 
@@ -152,6 +164,23 @@ module Pubid
         identifier.code_obj.to_s
       end
 
+      # A multi-designation wrapper (AdoptedStandard, DualPublished,
+      # MultiNumberedIdentifier) carries no year of its own — the year sits on
+      # the designation it wraps — so the URN dropped it and two editions of
+      # one document produced the SAME urn: "AIEE No 15-1944" and
+      # "AIEE No 15-1959" both gave urn:ieee:aiee:15.
+      #
+      # Fixed here, in the one place that reads the year, rather than by
+      # defining a `#year` method on each wrapper: `year` is a lutaml attribute
+      # on the base and a method of that name would shadow its generated
+      # accessor. `#root` already walks to the wrapped designation.
+      def year_component
+        return identifier.year if identifier.year
+
+        root = identifier.root
+        root.equal?(identifier) ? nil : root.year
+      end
+
       def draft_component
         return nil unless identifier.draft_obj
 

data/lib/pubid/ieee.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Ieee
     extend Pubid::PrefixesSupport
@@ -42,8 +43,13 @@ module Pubid
 
     class << self
       def parse(input)
+        unless input.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if input.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         Identifier.parse(input)

data/lib/pubid/ieee_debug.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Ieee
     autoload :Aiee, "#{__dir__}/aiee"

data/lib/pubid/ietf/builder.rb

@@ -28,28 +28,44 @@ module Pubid
       private
 
       def build_rfc(data)
-        Identifiers::Rfc.new(number: data[:number].to_s)
+        Identifiers::Rfc.new(number: unpad(data[:number]))
       end
 
+      # The series token only selects the class: it is derived back from the
+      # class (Identifiers::Std::SERIES) rather than stored, since `_type`
+      # already carries it.
       def build_subseries(data)
-        series = data[:series].to_s
-        klass = Identifiers.const_get(SUBSERIES_CLASSES.fetch(series))
-        klass.new(series: series, number: data[:number].to_s)
+        klass = Identifiers.const_get(
+          SUBSERIES_CLASSES.fetch(data[:series].to_s),
+        )
+        klass.new(number: unpad(data[:number]))
+      end
+
+      # Strip the zero-padding the RFC editor's rfc-index.xml writes ("STD0066",
+      # "RFC0001") so the canonical printed form is the unpadded one. The
+      # look-ahead keeps the last digit, so an all-zero number stays "0" rather
+      # than becoming empty.
+      def unpad(number)
+        number.to_s.sub(/\A0+(?=\d)/, "")
       end
 
       def build_draft(data)
         full = "draft-#{data[:draft_rest]}"
-        name, version = split_draft_version(full)
-        Identifiers::InternetDraft.new(name: name, version: version)
+        slug, version = split_draft_version(full)
+        Identifiers::InternetDraft.new(number: slug, version: version)
       end
 
       # An Internet-Draft version is a trailing "-NN" of *exactly* two digits at
       # the very end of the slug. A three-digit topic tail (e.g. "...-256") is
       # NOT a version: there the char before the last two digits is itself a
-      # digit, not "-", so the guard below leaves it in the name. This also
+      # digit, not "-", so the guard below leaves it in the slug. This also
       # means a (non-existent in practice) revision >= 100 would be read as part
-      # of the name — IETF drafts are always two-digit-versioned, so that case
+      # of the slug — IETF drafts are always two-digit-versioned, so that case
       # never arises. Either way the printed string round-trips exactly.
+      #
+      # Dotted slugs need no special handling here: only the final three
+      # characters are inspected, so "draft-ietf-pilc-2.5g3g-12" splits into
+      # ("draft-ietf-pilc-2.5g3g", "12").
       def split_draft_version(full)
         if full.length > 3 && full[-3] == "-" && full[-2..].match?(/\A\d\d\z/)
           [full[0...-3], full[-2..]]

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

@@ -7,22 +7,13 @@ module Pubid
     # 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:
+    # 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    -> series ("BCP"/"STD"/"FYI") + number ("3")
-    #   * InternetDraft  -> name ("draft-giuliano-treedn") + optional version
+    #   * Bcp/Std/Fyi    -> number ("3") + a derived `series` reader
+    #   * InternetDraft  -> number ("draft-giuliano-treedn") + optional version
     class Identifier < ::Pubid::Identifier
-      # Numeric part of an RFC or sub-series id, kept as a string (no zero-pad
-      # in the printed form, so "2119" not "02119").
-      attribute :number, :string
-      # Sub-series token for BCP/STD/FYI ("BCP"/"STD"/"FYI"); nil otherwise.
-      attribute :series, :string
-      # Full Internet-Draft slug including the leading "draft-"; nil otherwise.
-      attribute :name, :string
-      # Internet-Draft version, a two-digit string preserving zero-pad ("02");
-      # nil for the unversioned "latest" sibling.
-      attribute :version, :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 the shared from_hash dispatch.
@@ -35,16 +26,10 @@ module Pubid
           "Pubid::Ietf::Identifiers::InternetDraft",
       }.freeze
 
-      # Only these keys serialize; the inherited Pubid::Identifier attributes
-      # are intentionally dropped. nil-valued attributes are stripped by the
-      # base canonicalizer, so each family serializes just the keys it uses.
-      key_value do
-        map "_type", to: :_type, polymorphic_map: IETF_TYPE_MAP
-        map "number", to: :number
-        map "series", to: :series
-        map "name", to: :name
-        map "version", to: :version
-      end
+      # 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
@@ -62,14 +47,26 @@ module Pubid
       # 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 [RuntimeError] if parsing fails
+      # @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)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse IETF identifier '#{identifier}': #{e.message}"
       end
     end
-
   end
 end

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

@@ -5,6 +5,17 @@ module Pubid
     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,

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

@@ -5,6 +5,17 @@ module Pubid
     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,

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

@@ -5,9 +5,25 @@ module Pubid
     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 `name`; the optional
-      # trailing two-digit version in `version`.
+      # 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,

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

@@ -5,6 +5,8 @@ module Pubid
     module Identifiers
       # An RFC (Request for Comments), e.g. "RFC 2119".
       class Rfc < Identifier
+        include Serialization
+
         TYPED_STAGES = [
           Pubid::Components::TypedStage.new(
             code: :rfc,

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

@@ -5,6 +5,17 @@ module Pubid
     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,

data/lib/pubid/ietf/identifiers.rb

@@ -3,6 +3,7 @@
 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"

data/lib/pubid/ietf/parser.rb

@@ -12,24 +12,42 @@ module Pubid
     #   * 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 < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:space) { str(" ") }
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }
 
-      # "RFC 2119"
-      rule(:rfc) { str("RFC") >> space >> digits.as(:number) }
+      # "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"
+      # "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 >> digits.as(:number)
+          space.maybe >> digits.as(:number)
       end
 
-      # Internet-Draft slug characters (lowercase, digits, and the "-", "+", "_"
-      # separators seen in the corpus). The whole remainder after "draft-" is
-      # captured; the Builder anchors the optional trailing "-NN" version.
-      rule(:draft_rest) { match['a-z0-9+_\-'].repeat(1).as(:draft_rest) }
+      # 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 }

data/lib/pubid/ietf/renderer.rb

@@ -10,17 +10,55 @@ module Pubid
     #   "draft-giuliano-treedn-02" / "draft-giuliano-treedn"
     class Renderer < ::Pubid::Renderers::Base
       def render(context: nil, **_opts)
-        id = @id
+        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
-          "RFC #{id.number}"
-        when Identifiers::InternetDraft
-          id.version ? "#{id.name}-#{id.version}" : id.name
-        else # Bcp/Std/Fyi sub-series
+        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

@@ -7,17 +7,31 @@ module Pubid
     #   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
-          "urn:ietf:rfc:#{identifier.number}"
-        when Identifiers::InternetDraft
-          base = "urn:ietf:id:#{identifier.name}"
-          identifier.version ? "#{base}:#{identifier.version}" : base
-        else # Bcp/Std/Fyi sub-series
+        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

@@ -21,11 +21,19 @@ module Pubid
         when "rfc" then "RFC #{parts[0]}"
         when "bcp", "std", "fyi" then "#{type.upcase} #{parts[0]}"
         when "id" then draft_text(parts)
-        else
-          raise Errors::ParseError, "Invalid IETF URN type: #{type.inspect}"
+        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

data/lib/pubid/ietf.rb

@@ -1,5 +1,6 @@
 # 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 —
@@ -24,8 +25,17 @@ module Pubid
     # Parse an IETF identifier string
     def self.parse(identifier)
       # Inline length guard (CodeQL rb/polynomial-redos barrier) before the
-      # normalization/parse path — must be the first statement.
-      raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE if identifier.length > Pubid::MAX_INPUT_LENGTH
+      # 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

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

@@ -14,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

data/lib/pubid/iho/parser.rb

@@ -5,7 +5,7 @@ require "parslet"
 module Pubid
   module Iho
     # Parser class for IHO identifiers
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:space)  { str(" ") }
       rule(:dash)   { str("-") }
       rule(:dot)    { str(".") }

data/lib/pubid/iho.rb

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