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

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

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # IHO Bibliographic Publication (B series).
       # Example: IHO B-4 2.19.0.
-      class Bibliographic < Base
+      class Bibliographic < Identifier
         def self.type
           { key: :bibliographic, title: "Bibliographic Publication",
             short: "B" }

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

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # IHO Circular Letter (C series).
       # Example: IHO C-13 1.0.0.
-      class CircularLetter < Base
+      class CircularLetter < Identifier
         def self.type
           { key: :circular_letter, title: "Circular Letter", short: "C" }
         end

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

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # IHO Miscellaneous Publication (M series).
       # Example: IHO M-3 2.0.0.
-      class Miscellaneous < Base
+      class Miscellaneous < Identifier
         def self.type
           { key: :miscellaneous, title: "Miscellaneous Publication",
             short: "M" }

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

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # IHO Publication (P series).
       # Examples: IHO P-1 1.0.0, IHO P-1/21 1.0.0, IHO P-6-3 1.0.0.
-      class Publication < Base
+      class Publication < Identifier
         def self.type
           { key: :publication, title: "Publication", short: "P" }
         end

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

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # IHO Standards and Specifications (S series).
       # Examples: IHO S-44 5.0.0, IHO S-100 Part 4a 1.0.0, IHO S-65 Ap. A 1.0.0.
-      class Standard < Base
+      class Standard < Identifier
         def self.type
           { key: :standard, title: "Standards and Specifications", short: "S" }
         end

data/lib/pubid/iho/identifiers.rb

@@ -3,7 +3,6 @@
 module Pubid
   module Iho
     module Identifiers
-      autoload :Base,           "#{__dir__}/identifiers/base"
       autoload :Bibliographic,  "#{__dir__}/identifiers/bibliographic"
       autoload :CircularLetter, "#{__dir__}/identifiers/circular_letter"
       autoload :Miscellaneous,  "#{__dir__}/identifiers/miscellaneous"

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
@@ -8,7 +9,7 @@ module Pubid
     PREFIXES = ["IHO"].freeze
 
     autoload :Builder,      "#{__dir__}/iho/builder"
-    autoload :Identifier,   "#{__dir__}/iho/identifier"
+    autoload :Identifier, "#{__dir__}/iho/identifiers/base"
     autoload :Identifiers,  "#{__dir__}/iho/identifiers"
     autoload :Parser,       "#{__dir__}/iho/parser"
     autoload :Renderer,     "#{__dir__}/iho/renderer"
@@ -17,14 +18,14 @@ module Pubid
 
     # Parse an IHO identifier string into an identifier object
     # @param identifier [String] The IHO identifier string to parse
-    # @return [Pubid::Iho::Identifiers::Base] The appropriate identifier object
+    # @return [Pubid::Iho::Identifier] The appropriate identifier object
     def self.parse(identifier)
       Identifier.parse(identifier)
     end
 
     # Per-flavor format registry: inherits global formats, overrides :human
-    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifiers::Base.format_registry.register(:human, renderer: Iho::Renderer)
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Iho::Renderer)
 
     # Auto-discover all identifier types from the Identifiers namespace.
     # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
@@ -32,9 +33,9 @@ module Pubid
       @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 }
-        # Exclude the flavor base itself by identity (Identifiers::Base is now an
+        # Exclude the flavor base itself by identity (Identifier is now an
         # alias for Pubid::Iho::Identifier, so name-based matching misses it).
-        .reject { |c| c == Identifiers::Base }
+        .reject { |c| c == Identifier }
     end
 
     # Build typed stage index from identifier types
@@ -66,7 +67,7 @@ module Pubid
 
     # Look up an identifier class by its IHO series letter (S/P/M/B/C).
     # @param letter [String]
-    # @return [Class<Identifiers::Base>]
+    # @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)

data/lib/pubid/isbn/builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    # Builds a Pubid::Isbn::Identifier from a parse tree.
+    #
+    # Validates the check digit; raises if invalid. Stores both the
+    # hyphenated form (for round-trip rendering) and the bare digits
+    # (for queries).
+    class Builder
+      INVALID_LENGTH = /^(?:\d{9}[\dX]|\d{13})$/.freeze
+
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        hyphenated = data[:body].to_s
+        raw = hyphenated.delete("-")
+
+        validate_length!(raw)
+        validate_check_digit!(raw)
+
+        Identifiers::Book.new(raw: raw, hyphenated: hyphenated.include?("-") ? hyphenated : nil)
+      end
+
+      private
+
+      def validate_length!(raw)
+        return if raw.match?(INVALID_LENGTH)
+
+        raise ArgumentError,
+              "ISBN must be 10 or 13 digits (got #{raw.length})"
+      end
+
+      def validate_check_digit!(raw)
+        return if CheckDigit.valid?(raw)
+
+        raise ArgumentError,
+              "ISBN check digit invalid for #{raw}"
+      end
+    end
+  end
+end

data/lib/pubid/isbn/check_digit.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    # Pure-functional check digit math for ISBN-10 and ISBN-13 per ISO 2108.
+    #
+    # ISBN-10: weighted sum with weights 10..1, mod 11. Check digit 10 is
+    # rendered as "X".
+    # ISBN-13: weighted sum with alternating weights 1/3, mod 10. Check digit
+    # is 0-9.
+    class CheckDigit
+      # Compute the correct ISBN-10 check digit for a 9-digit payload.
+      # @return [String] "0".."9" or "X"
+      def self.compute_isbn10(payload)
+        raise ArgumentError, "ISBN-10 payload must be 9 digits" unless payload.to_s.match?(/\A\d{9}\z/)
+
+        sum = payload.to_s.each_char.with_index.sum { |c, i| c.to_i * (10 - i) }
+        digit = (11 - sum % 11) % 11
+        digit == 10 ? "X" : digit.to_s
+      end
+
+      # Compute the correct ISBN-13 check digit for a 12-digit payload.
+      # @return [String] "0".."9"
+      def self.compute_isbn13(payload)
+        raise ArgumentError, "ISBN-13 payload must be 12 digits" unless payload.to_s.match?(/\A\d{12}\z/)
+
+        sum = payload.to_s.each_char.with_index.sum do |c, i|
+          c.to_i * (i.even? ? 1 : 3)
+        end
+        ((10 - sum % 10) % 10).to_s
+      end
+
+      # Verify the check digit on a full 10- or 13-digit ISBN string.
+      # @param full [String] 10 or 13 chars; ISBN-10 may end with X.
+      # @return [Boolean]
+      def self.valid?(full)
+        digits = full.to_s.upcase.delete("^0-9X")
+        case digits.length
+        when 10
+          payload = digits[0, 9]
+          actual = digits[9]
+          compute_isbn10(payload) == actual
+        when 13
+          payload = digits[0, 12]
+          actual = digits[12]
+          compute_isbn13(payload) == actual
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/pubid/isbn/identifier.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    class Identifier < ::Pubid::Identifier
+      # The digits-only ISBN (no hyphens), including check digit. 10 or 13 chars.
+      attribute :raw, :string
+
+      # Original hyphenated form (may be nil when the input had no hyphens).
+      # Preserved for round-trip rendering; not queryable semantics.
+      attribute :hyphenated, :string
+
+      ISBN_TYPE_MAP = {
+        "pubid:isbn:book" => "Pubid::Isbn::Identifiers::Book",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: ISBN_TYPE_MAP
+        map "raw", to: :raw
+        map "hyphenated", to: :hyphenated
+      end
+
+      PUBLISHER = "ISBN"
+
+      # Returns :isbn10 or :isbn13.
+      def form
+        case raw.to_s.length
+        when 10 then :isbn10
+        when 13 then :isbn13
+        else raise "Invalid ISBN length: #{raw.inspect}"
+        end
+      end
+
+      def check_digit
+        raw.to_s[-1]
+      end
+
+      def valid?
+        CheckDigit.valid?(raw)
+      end
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      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
+
+        # The two guards above must stay OUTSIDE build_identifier: this method
+        # rescues ArgumentError to convert the Builder's check-digit and
+        # length validation into a parse failure, and that rescue used to
+        # swallow the guards' own ArgumentError and re-raise it as a
+        # RuntimeError - so ISBN was the one guarded flavor where an over-long
+        # input did not surface as ArgumentError.
+        build_identifier(identifier)
+      end
+
+      # @raise [Pubid::Errors::ParseError] if the string is not a valid ISBN
+      def self.build_identifier(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue ArgumentError => e
+        # The Builder validates length and check digit. Surface that as a parse
+        # failure, so every ISBN rejection reaches the caller as the same class
+        # a grammar rejection does.
+        raise Pubid::Errors::ParseError.new(
+          "invalid ISBN '#{identifier}': #{e.message}",
+          input: identifier, flavor: "isbn",
+        )
+      end
+      private_class_method :build_identifier
+    end
+  end
+end

data/lib/pubid/isbn/identifiers/book.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    module Identifiers
+      # ISBN book identifier — supports both ISBN-10 and ISBN-13.
+      #
+      # Examples:
+      #   ISBN 978-3-16-148410-0
+      #   ISBN 0-306-40615-2
+      #   9783161484100
+      class Book < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubisbn,
+            stage_code: :published,
+            type_code: :isbn,
+            abbr: ["ISBN"],
+            name: "ISBN",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :isbn, web: :book, title: "ISBN", short: "ISBN" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/isbn/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    module Identifiers
+      autoload :Book, "#{__dir__}/identifiers/book"
+    end
+  end
+end

data/lib/pubid/isbn/parser.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Isbn
+    # Parslet grammar for ISBN identifiers per ISO 2108.
+    #
+    # Accepts:
+    #   [ISBN[ |:]] {10 or 13 digits with optional hyphens}
+    #
+    # ISBN-10 final digit may be "X" (check digit value 10). Hyphens are
+    # optional and may appear in any group position; they are preserved
+    # for round-trip rendering.
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:space)   { str(" ") }
+      rule(:colon)   { str(":") }
+      rule(:hyphen)  { str("-") }
+      rule(:digit)   { match("[0-9]") }
+      rule(:x_digit) { digit | str("X") }
+
+      rule(:isbn_prefix) do
+        (str("ISBN") >> (space | (space.maybe >> colon >> space.maybe))).maybe
+      end
+
+      rule(:digit_group) { digit.repeat(1) }
+      rule(:x_group)     { x_digit.repeat(1) }
+
+      # Loose "ISBN-ish" token: digits or final X, separated by hyphens.
+      rule(:isbn_body) do
+        (digit_group >> (hyphen >> digit_group).repeat >>
+          (hyphen >> x_digit).maybe).as(:body) |
+          (digit.repeat(9, 12) >> x_digit.maybe).as(:body)
+      end
+
+      rule(:identifier) { isbn_prefix >> isbn_body }
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/isbn/renderer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    # Human-readable renderer for ISBN identifiers.
+    #
+    # Preserves the original hyphenation when present; otherwise emits the
+    # bare digits. Always emits the "ISBN " prefix.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        body = @id.hyphenated || @id.raw
+        "ISBN #{body}"
+      end
+    end
+  end
+end

data/lib/pubid/isbn.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  # ISBN flavor — bibliographic book identifier per ISO 2108.
+  #
+  # Parses both 10-digit (ISBN-10) and 13-digit (ISBN-13) forms with
+  # optional hyphenation. The check digit is validated; an invalid check
+  # digit raises on parse.
+  module Isbn
+    extend Pubid::PrefixesSupport
+
+    PREFIXES = ["ISBN"].freeze
+
+    autoload :CheckDigit, "#{__dir__}/isbn/check_digit"
+    autoload :Builder, "#{__dir__}/isbn/builder"
+    autoload :Identifier, "#{__dir__}/isbn/identifier"
+    autoload :Identifiers, "#{__dir__}/isbn/identifiers"
+    autoload :Parser, "#{__dir__}/isbn/parser"
+    autoload :Renderer, "#{__dir__}/isbn/renderer"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Isbn::Renderer)
+
+    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
+
+    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
+
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    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
+
+Pubid::Registry.register(:isbn, Pubid::Isbn)

data/lib/pubid/iso/builder.rb

@@ -16,7 +16,7 @@ module Pubid
 
       def locate_identifier_klass(parsed_hash)
         # If there is a joint_identifier, we need to use a CombinedIdentifier
-        # which takes `base_identifier` and `additional_identifiers`
+        # which takes `base` and `additional_identifiers`
         if parsed_hash[:joint_identifier]
           return CombinedIdentifier
         end
@@ -47,7 +47,7 @@ module Pubid
         # a) It is an IS.
         # b) It is a Directive Supplements. The "SUP" keyword may be entirely missing, and hence nil. If the base type_with_stage is a directive, then if the type_with_stage is blank, it is a directive supplement.
 
-        if parsed_hash[:type_with_stage].nil? && parsed_hash[:base_identifier] && parsed_hash[:base_identifier][:type_with_stage] == "DIR"
+        if parsed_hash[:type_with_stage].nil? && parsed_hash[:base] && parsed_hash[:base][:type_with_stage] == "DIR"
           # Directive Supplement without "SUP" keyword
           parsed_hash[:type_with_stage] = "SUP"
         end
@@ -150,12 +150,12 @@ module Pubid
 
       def cast(type, value)
         case type
-        when :base_identifier
+        when :base
           # If it has a base identifier, we need to build a supplement
           # We assume that the base identifier is already a valid Identifier object
           build(value)
 
-          # If there is a base_identifier, and it has a joint_identifier, we need to use a CombinedIdentifier.
+          # If there is a base, and it has a joint_identifier, we need to use a CombinedIdentifier.
 
         when :publisher, :directives_supplement_body, :supplement_publisher
           # value can be either a string OR a hash with publisher + copublisher
@@ -230,6 +230,11 @@ module Pubid
         when :date
           parse_date(value)
 
+        when :undated_marker
+          # ISO/IEC undated reference (e.g. "ISO 16634:--") — explicit
+          # publication-date slot with no year; round-trips via date.render.
+          { date: Pubid::Components::Date.new(undated: true) }
+
         when :edition
           # value can be "Ed.2", "Ed 2", "ED1", "Edition 13", or just "Ed"
           original_text = value.to_s

data/lib/pubid/iso/bundled_identifier.rb

@@ -86,15 +86,17 @@ module Pubid
         base_document&.copublishers
       end
 
+      # See the note on Pubid::BundledIdentifier#to_s: `**opts` carries flags
+      # this list does not name, `annotated:` above all.
       def to_s(lang: :en, lang_single: false, with_edition: false, format: nil,
-stage_format_long: nil, with_date: nil)
+stage_format_long: nil, with_date: nil, **opts)
         parts = [base_document.to_s(lang: lang, lang_single: lang_single,
-                                    with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)]
+                                    with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)]
 
         # Add each supplement with "+" separator
         supplements.each do |supplement|
           supplement_str = supplement.to_supplement_s(lang: lang, lang_single: lang_single,
-                                                      with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)
+                                                      with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)
           parts << "+ #{supplement_str}"
         end
 

data/lib/pubid/iso/combined_identifier.rb

@@ -4,16 +4,18 @@ module Pubid
   module Iso
     # Identifier that represents a supplement to a base identifier.
     class CombinedIdentifier < Identifier
-      attribute :base_identifier, Identifier, polymorphic: true
+      attribute :base, Identifier, polymorphic: true
       attribute :additional_identifiers, ::Pubid::Identifier,
                 polymorphic: true, collection: true
       attribute :type, :string, default: -> { "combined_identifier" }
 
-      def to_s(lang: :en, lang_single: false)
+      # `**opts` carries render flags this list does not name (`annotated:`),
+      # which the closed signature used to reject outright.
+      def to_s(lang: :en, lang_single: false, **opts)
         [
-          base_identifier.to_s(lang: lang, lang_single: lang_single),
+          base.to_s(lang: lang, lang_single: lang_single, **opts),
           additional_identifiers.map do |id|
-            id.to_s(lang: lang, lang_single: lang_single)
+            id.to_s(lang: lang, lang_single: lang_single, **opts)
           end,
         ].flatten.join(" | ")
       end

data/lib/pubid/iso/identifier.rb

@@ -103,7 +103,7 @@ module Pubid
       # The base Pubid::Identifier no longer auto-maps attributes, so each
       # flavor's top class must declare its own key_value mapping. Subclasses
       # merge their own blocks on top of this one (e.g. SupplementIdentifier
-      # adds base_identifier; Directives adds subgroup), so list every base
+      # adds base; Directives adds subgroup), so list every base
       # attribute ISO serializes here once.
       key_value do
         map "_type", to: :_type, polymorphic_map: ISO_TYPE_MAP
@@ -117,6 +117,9 @@ module Pubid
         map "year", with: { to: :year_to_kv, from: :year_from_kv }
         map "month", with: { to: :month_to_kv, from: :month_from_kv }
         map "day", with: { to: :day_to_kv, from: :day_from_kv }
+        # ISO/IEC undated reference (e.g. ISO 16634:--). The `false` default
+        # is omitted; only the meaningful `true` round-trips via to_hash.
+        map "undated", with: { to: :undated_to_kv, from: :undated_from_kv }
         map "edition", to: :edition
         map "languages", to: :languages
         # publisher emitted only when the primary isn't the type default;
@@ -163,9 +166,14 @@ module Pubid
       def stage_from_kv(model, value)
         return if value.nil? || value.to_s.empty?
 
+        # The fallback consults the flavor-wide table. It used to call
+        # `Pubid::Iso::Scheme`, a class removed repo-wide in e3c19ea1 — so any
+        # code absent from the class's own TYPED_STAGES raised NameError
+        # instead of falling back. The IEC twin (iec/identifier.rb) was
+        # migrated at the time; ISO was missed.
         ts = (model.class.const_defined?(:TYPED_STAGES) &&
               model.class::TYPED_STAGES.find { |t| t.code.to_s == value.to_s }) ||
-             Pubid::Iso::Scheme.locate_typed_stage_by_code(value)
+             Pubid::Iso.locate_stage_by_code(value)
         return unless ts
 
         # The renderer prefers `original_abbr` (the parsed surface form); without
@@ -217,6 +225,19 @@ module Pubid
       def day_to_kv(model, doc) = emit_date_part(doc, "day", model.date&.day)
       def day_from_kv(model, value) = date_for(model).day = value.to_s
 
+      # --- date undated flag (ISO/IEC undated reference, e.g. ISO 16634:--) ---
+      # The `false` default is omitted; only the meaningful `true` round-trips
+      # via to_hash / from_hash.
+      def undated_to_kv(model, doc)
+        return unless model.date&.undated?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("undated", true))
+      end
+
+      def undated_from_kv(model, value)
+        date_for(model).undated = value.to_s == "true"
+      end
+
       def emit_date_part(doc, key, val)
         return if val.nil? || val.to_s.empty?
 
@@ -267,8 +288,13 @@ module Pubid
       end
 
       def self.parse(string, format: :auto)
+        unless string.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if string.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         format = Pubid::FormatDetector.detect(string) if format == :auto
@@ -280,11 +306,6 @@ module Pubid
           Pubid::Parsers::MrString.parse(string)
         else
           parsed = Pubid::Iso::Parser.new.parse(string)
-          if parsed.nil? || parsed.empty?
-            raise Pubid::Iso::Parser::ParseError,
-                  "Invalid identifier format"
-          end
-
           Pubid::Iso::Builder.new.build(parsed)
         end
       end