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

data/lib/pubid/isbn/identifier.rb

@@ -44,20 +44,38 @@ module Pubid
       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 ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          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 Parslet::ParseFailed => e
-        raise "Failed to parse ISBN '#{identifier}': #{e.message}"
       rescue ArgumentError => e
-        # Builder validates length/check-digit; surface as a parse error so
-        # the error contract matches other flavors (always raises a string
-        # beginning with "Failed to parse").
-        raise "Failed to parse ISBN '#{identifier}': #{e.message}"
+        # 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/parser.rb

@@ -12,7 +12,7 @@ module Pubid
     # 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 < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:space)   { str(" ") }
       rule(:colon)   { str(":") }
       rule(:hyphen)  { str("-") }

data/lib/pubid/isbn.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   # ISBN flavor — bibliographic book identifier per ISO 2108.
   #

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

@@ -9,11 +9,13 @@ module Pubid
                 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.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

@@ -166,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
@@ -283,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
@@ -296,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

data/lib/pubid/iso/identifiers/directives_supplement.rb

@@ -68,12 +68,12 @@ module Pubid
         # end
 
         def to_s(lang: :en, lang_single: false, with_edition: false,
-format: nil, stage_format_long: nil, with_date: nil)
+format: nil, stage_format_long: nil, with_date: nil, **opts)
           if base
             # Full rendering with base identifier
             [
               base.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),
               " #{supplement_publisher.render}",
               " SUP", # Always render as "SUP" even though typed_stage.abbreviation is "DIR SUP"
               (date ? ":#{date.render}" : ""),
@@ -81,13 +81,13 @@ format: nil, stage_format_long: nil, with_date: nil)
             ].join
           else
             # Simplified rendering for bundled identifiers (just the supplement part)
-            to_supplement_s(lang: lang, lang_single: lang_single)
+            to_supplement_s(lang: lang, lang_single: lang_single, **opts)
           end
         end
 
         # Render just the supplement part (for use in bundled identifiers)
         def to_supplement_s(lang: :en, lang_single: false, with_edition: false,
-format: nil, stage_format_long: nil, with_date: nil)
+format: nil, stage_format_long: nil, with_date: nil, **_opts)
           date_str = if date
                        month_part = date.month ? "-#{date.month}" : ""
                        ":#{date.render}#{month_part}"

data/lib/pubid/iso/parser.rb

@@ -3,7 +3,7 @@ require "parslet"
 
 module Pubid
   module Iso
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 

data/lib/pubid/iso.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 require "lutaml/model"
 
 module Pubid
@@ -31,8 +32,13 @@ module Pubid
     # @param format [Symbol] :auto, :human, :mr_string, or :urn
     # @return [Identifier] the parsed identifier
     def self.parse(identifier, format: :auto)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
       if identifier.length > Pubid::MAX_INPUT_LENGTH
-        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
       format = Pubid::FormatDetector.detect(identifier) if format == :auto

data/lib/pubid/itu/identifiers/addendum.rb

@@ -6,8 +6,8 @@ module Pubid
       # Addendum identifier (Add.)
       # Pattern: "ITU-T I.363 (1993) Add. 1 (11/1993)"
       class Addendum < Supplement
-        def to_s
-          render_supplement("Add.")
+        def to_s(**opts)
+          annotate_plain_render(render_supplement("Add."), **opts)
         end
       end
     end

data/lib/pubid/itu/identifiers/amendment.rb

@@ -10,8 +10,8 @@ module Pubid
         # supplement types (Cor./Err./Suppl./Add.). The parser accepts both
         # spellings (see Parser#supplement_type), so the period-less input form
         # still round-trips through parse — it just normalizes here.
-        def to_s
-          render_supplement("Amd.")
+        def to_s(**opts)
+          annotate_plain_render(render_supplement("Amd."), **opts)
         end
       end
     end

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

@@ -6,18 +6,29 @@ module Pubid
     class Identifier < ::Pubid::Identifier
       # Parse an ITU identifier string into an 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(normalize_whitespace(identifier))
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse ITU identifier '#{identifier}': #{e.message}"
       end
 
       # ITU's own listings occasionally carry a doubled space
       # ("ITU-T D.271  (10/2016)"). Whitespace is never significant in an ITU
       # identifier, so collapse runs of it rather than teaching every rule to
       # tolerate them. Any string over the shared input-length guard is left
-      # untouched — `Pubid.parse` rejects it before this point, and the guard
-      # exists precisely to keep long inputs away from regexes.
+      # untouched: `self.parse` above rejects it before this point, and the
+      # guard exists precisely to keep long inputs away from regexes. (This
+      # note used to credit `Pubid.parse` with the rejection, which was wrong
+      # in both directions — `Pubid.parse` never routes a human-readable ITU
+      # string to a flavor, and ITU carried no raising guard of its own until
+      # one was added to `self.parse`, so an over-long string did reach here.)
       def self.normalize_whitespace(identifier)
         return identifier unless identifier.is_a?(String)
         return identifier if identifier.length > ::Pubid::MAX_INPUT_LENGTH
@@ -184,10 +195,13 @@ module Pubid
       # @param format [Symbol] :long for title-style rendering of supported
       #   identifiers, otherwise the default short form.
       def to_s(**opts)
+        annotated = opts[:annotated]
         opts = self.class.normalize_to_s_opts(opts)
         result = render_base(**opts) + render_language_suffix
         result += " | #{common_text_twin}" if common_text_twin
-        result
+        # ITU composes its own string rather than going through `render`, so it
+        # never reaches the shared annotation hook. Apply it here.
+        annotate_plain_render(result, annotated: annotated)
       end
 
       def render_base(**_opts)

data/lib/pubid/itu/identifiers/corrigendum.rb

@@ -19,8 +19,8 @@ module Pubid
           map "technical", to: :technical
         end
 
-        def to_s
-          render_supplement(technical ? "Technical Cor." : "Cor.")
+        def to_s(**opts)
+          annotate_plain_render(render_supplement(technical ? "Technical Cor." : "Cor."), **opts)
         end
 
         # `super` already enforces instance_of?(self.class), so this only has

data/lib/pubid/itu/identifiers/errata.rb

@@ -6,8 +6,8 @@ module Pubid
       # Errata identifier (Err.)
       # Pattern: "ITU-T G.9701 (2014) Err. 1 (07/2016)"
       class Errata < Supplement
-        def to_s
-          render_supplement("Err.")
+        def to_s(**opts)
+          annotate_plain_render(render_supplement("Err."), **opts)
         end
       end
     end

data/lib/pubid/itu/identifiers/supplement.rb

@@ -115,8 +115,8 @@ module Pubid
           result
         end
 
-        def to_s
-          render_supplement("Suppl.")
+        def to_s(**opts)
+          annotate_plain_render(render_supplement("Suppl."), **opts)
         end
 
         # Shared by Amendment / Corrigendum / Errata.

data/lib/pubid/itu/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Itu
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Basic elements
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }

data/lib/pubid/itu.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 require "lutaml/model"
 
 module Pubid

data/lib/pubid/jcgm/builder.rb

@@ -69,7 +69,7 @@ module Pubid
         when :publisher
           Jcgm::Components::Publisher.new(publisher: value.to_s)
         when :number
-          Pubid::Components::Code.new(value: value.to_s)
+          value.to_s
         when :date
           date_str = value.to_s
           if date_str.include?("-")

data/lib/pubid/jcgm/identifier.rb

@@ -3,6 +3,16 @@
 module Pubid
   module Jcgm
     class Identifier < ::Pubid::Identifier
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: JCGM stores a bare string in `number` and uses neither
+      # of the other two. Declaring on this class is safe because its body lives
+      # in this one file and is never reopened, so every subclass body opens
+      # after it has run (lutaml deep-dups the parent attribute table at
+      # class-definition time).
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
+
       def self.parse(string)
         Pubid::Jcgm.parse(string)
       end

data/lib/pubid/jcgm/identifiers/meeting.rb

@@ -39,7 +39,7 @@ module Pubid
         end
 
         def ordinal
-          self.class.ordinal(number&.value)
+          self.class.ordinal(number)
         end
       end
     end

data/lib/pubid/jcgm/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Jcgm
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 
@@ -53,10 +53,17 @@ module Pubid
       # wants the ordinal suffix), so ordered choice is unambiguous. Emits the
       # same tokens as a guide plus type_with_stage "Meeting", so the generic
       # builder path resolves it to Identifiers::Meeting (like "Amd").
+      #
+      # The trailing " (YYYY)" group is optional, so the partial reference
+      # "JCGM 11st Meeting" parses with `date` left nil. JCGM numbers its
+      # meetings in one sequence, so the ordinal alone names the event and the
+      # year is redundant detail. The whole group is `.maybe` (not the year
+      # inside it), so a dangling "(" or a truncated year still fails —
+      # the same shape as `date_portion.maybe` in `rule(:base)`.
       rule(:meeting_identifier) do
         publisher >> space >> digits.as(:number) >> ordinal_suffix >>
-          space >> str("Meeting").as(:type_with_stage) >> space >>
-          str("(") >> year_digits.as(:date) >> str(")")
+          space >> str("Meeting").as(:type_with_stage) >>
+          (space >> str("(") >> year_digits.as(:date) >> str(")")).maybe
       end
 
       rule(:ordinal_suffix) do

data/lib/pubid/jcgm/renderer.rb

@@ -37,8 +37,15 @@ module Pubid
         id.date ? ":#{id.date}" : ""
       end
 
+      # Two surface forms:
+      #   "JCGM 17th Meeting (2012)"  — date present (published records)
+      #   "JCGM 17th Meeting"         — date absent (partial reference)
+      # The ordinal alone names the meeting, so the dateless form is a valid
+      # identifier and must stay re-parseable (the parser makes the " (YYYY)"
+      # group optional to match).
       def render_meeting(id)
-        "JCGM #{id.ordinal} Meeting (#{id.date.year})"
+        base = "JCGM #{id.ordinal} Meeting"
+        id.date ? "#{base} (#{id.date.year})" : base
       end
 
       def render_single(id)
@@ -52,7 +59,7 @@ module Pubid
       def render_amendment(id, context)
         result = id.base.to_s if id.base
         result += "/Amd"
-        result += " #{id.number.render(context:)}" if id.number
+        result += " #{id.number}" if id.number
         result += ":#{id.date}" if id.date
         result
       end
@@ -60,7 +67,7 @@ module Pubid
       def render_gum_guide(id, context)
         parts = []
         parts << id.publisher.publisher if id.publisher
-        parts << "GUM-#{id.number.render(context:)}" if id.number
+        parts << "GUM-#{id.number}" if id.number
 
         result = parts.join(" ")
         result += ":#{id.date}" if id.date

data/lib/pubid/jcgm/single_identifier.rb

@@ -7,7 +7,6 @@ module Pubid
                 default: -> { self.class.default_publisher }
       attribute :typed_stage, Pubid::Components::TypedStage,
                 default: -> { self.class.published_typed_stage }
-      attribute :number, Pubid::Components::Code
       attribute :date, Pubid::Components::Date
       attribute :languages, Pubid::Components::Language, collection: true
       attribute :stage, Pubid::Components::Stage
@@ -18,7 +17,7 @@ module Pubid
       # (fully determined by the class, i.e. `_type`) are intentionally NOT
       # mapped — they are reconstructed from the class on load via the
       # attribute defaults above. Components collapse to bare scalars:
-      # number -> "100" (not {value: "100"}); date -> year/month/day scalars.
+      # number is already a bare :string; date -> year/month/day scalars.
       # Mirrors ISO (lib/pubid/iso/identifier.rb) and OIML.
       key_value do
         map "_type", to: :_type
@@ -37,15 +36,29 @@ module Pubid
       # The class's published typed_stage (canonical surface form). Each JCGM
       # class registers exactly one, all :published; `_type` fixes the class,
       # so an omitted typed_stage reconstructs deterministically on from_hash.
+      #
+      # `original_abbr` is deliberately LEFT NIL. It records the spelling the
+      # input used and is not serialized, so it cannot survive a round trip —
+      # and this method is one of the two paths that fill `typed_stage`. The
+      # other is the parse path (`Builder#locate_typed_stage` ->
+      # `Jcgm.locate_stage`), which returns the registry entry untouched.
+      # Setting it here made the two disagree, so `from_hash(to_hash) != parse`
+      # for every type the grammar tags (Meeting, Corrigendum, Amendment) —
+      # and because `#matches?` is `exclude(...) == other.exclude(...)`, a
+      # relaton index lookup then silently matched nothing. Nothing in JCGM
+      # reads the field: the renderer hardcodes its surface words, the URN
+      # generator reads only `type_code`, and `TypedStage#abbreviation` chooses
+      # among long_abbr/short_abbr/abbr.first. Recording the *matched* token
+      # instead would not work either — "/Cor 1" would store "Cor" where
+      # from_hash rebuilds "Corrigendum".
       def self.published_typed_stage
         return nil unless const_defined?(:TYPED_STAGES)
 
         ts = self::TYPED_STAGES.find { |t| t.stage_code.to_s == "published" }
-        return nil unless ts
-
-        ts = ts.dup
-        ts.original_abbr = ts.canonical_abbreviation
-        ts
+        # dup: locate_stage hands out the shared object from the frozen
+        # TYPED_STAGES array (the array is frozen, its elements are not), so a
+        # future in-place mutation would otherwise leak globally.
+        ts&.dup
       end
 
       # type and stage are derived from typed_stage, never stored — so the
@@ -58,13 +71,9 @@ module Pubid
         typed_stage&.to_stage
       end
 
-      # --- number (Code) flattened to a bare string ---
-      def number_to_kv(model, doc) = emit_kv(doc, "number", model.number&.value)
-      def number_from_kv(model, value) = model.number = build_code(value)
-
-      def build_code(value)
-        Pubid::Components::Code.new(value: value.to_s)
-      end
+      # --- number ---
+      def number_to_kv(model, doc) = emit_kv(doc, "number", model.number)
+      def number_from_kv(model, value) = model.number = value.to_s
 
       # --- date flattened to top-level year/month/day scalars ---
       def year_to_kv(model, doc) = emit_kv(doc, "year", model.date&.year)
@@ -90,7 +99,7 @@ module Pubid
 
       def number_portion
         parts = []
-        parts << number.value if number
+        parts << number if number
         parts << ":#{date.year}" if date
         parts.join
       end

data/lib/pubid/jcgm/urn_generator.rb

@@ -18,7 +18,7 @@ module Pubid
       # urn:jcgm:meeting:<number>:<year>, e.g. urn:jcgm:meeting:17:2012
       def generate_meeting_urn
         parts = ["urn", "jcgm", "meeting"]
-        parts << identifier.number.value if identifier.number
+        parts << identifier.number if identifier.number
         parts << identifier.date.year if identifier.date
         parts.join(":")
       end