pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.12

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/identifiers.rb

@@ -11,6 +11,7 @@ module Pubid
       autoload :AppendixOfRecommendation,
                "#{__dir__}/identifiers/appendix_of_recommendation"
       autoload :CombinedIdentifier, "#{__dir__}/identifiers/combined_identifier"
+      autoload :Contribution, "#{__dir__}/identifiers/contribution"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :Errata, "#{__dir__}/identifiers/errata"
       autoload :Handbook, "#{__dir__}/identifiers/handbook"

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) }
@@ -323,6 +323,22 @@ module Pubid
           (digits | letter.repeat(1)).as(:number) >> parts
       end
 
+      # ITU Contribution (Temporary Document) — "ITU-R SG17-C1000" (pubid#340).
+      # The "-C" marker before the number distinguishes it from every
+      # neighbouring shape: a series-code document's post-dash number starts
+      # with digits or is all letters (never "C"+digits), and with_series
+      # requires a dot after the series.
+      rule(:contribution) do
+        itu_prefix >>
+          sector >>
+          space >>
+          series >>
+          str("-C").as(:contribution_marker) >>
+          number >>
+          parts >>
+          language.maybe
+      end
+
       rule(:base_series_code) do
         itu_prefix >>
           sector >>
@@ -656,9 +672,10 @@ module Pubid
           numeric_question |
           letter_question |
           with_series |
+          contribution |
           # Unreachable earlier: special_publication needs the literal "OB",
-          # handbook/numeric_question need leading digits, and letter_question
-          # needs series >> dot. Before without_series, whose code needs digits.
+          # handbook/numeric_question need leading digits, letter_question
+          # needs series >> dot, and contribution needs "-C" after the series.
           series_code_identifier |
           without_series
       end

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

data/lib/pubid/jcgm/urn_parser.rb

@@ -4,31 +4,173 @@ module Pubid
   module Jcgm
     # Parses JCGM URNs back into identifiers.
     #
-    # UrnGenerator emits `urn:jcgm:{number}:{year}` for guides and
-    # `urn:jcgm:meeting:{number}:{year}` for committee/meeting records.
+    # Identifiers are rebuilt **directly from the URN segments** rather than
+    # rendered to a human-readable string and re-parsed (the BIPM UrnParser
+    # pattern). Round-tripping through the grammar flattened the segments into
+    # one string and silently lost everything the string form could not carry:
+    # a GUM guide (`urn:jcgm:gum.6:2020`) raised, and the language and
+    # supplement segments were dropped, so a corrigendum read back as the
+    # standard it amends — a different document, with no error.
     #
-    # Examples:
-    # - urn:jcgm:200:2012 → JCGM 200:2012
-    # - urn:jcgm:100:2008 → JCGM 100:2008
-    # - urn:jcgm:meeting:17:2012 → JCGM 17th Meeting (2012)
+    # Shapes emitted by UrnGenerator, and read back here:
+    #   urn:jcgm:200:2008                        → JCGM 200:2008
+    #   urn:jcgm:100:2008:en                     → JCGM 100:2008(E)
+    #   urn:jcgm:200:2012:en,fr                  → JCGM 200:2012(E/F)
+    #   urn:jcgm:GUM                             → JCGM GUM
+    #   urn:jcgm:gum.6:2020                      → JCGM GUM-6:2020
+    #   urn:jcgm:200:2008:corrigendum            → JCGM 200:2008 Corrigendum
+    #   urn:jcgm:101:2008:corrigendum:1:2009     → JCGM 101:2008/Cor 1:2009
+    #   urn:jcgm:100:2008:amendment:1:2023       → JCGM 100:2008/Amd 1:2023
+    #   urn:jcgm:meeting:17:2012                 → JCGM 17th Meeting (2012)
+    #   urn:jcgm:meeting:11                      → JCGM 11st Meeting
+    #
+    # KNOWN GAP, on the generator side and unchanged here: a full date is
+    # rendered as its year alone (`JCGM GUM-1:2022-11-28` →
+    # `urn:jcgm:gum.1:2022`), so a URN cannot restore the month and day.
+    # Widening it would change already-published URNs.
     class UrnParser < Pubid::UrnParser::Base
+      MEETING_MARKER = "meeting"
+
+      # The GUM-guide number is written "gum.<n>" by UrnGenerator.
+      GUM_PREFIX = "gum."
+
+      # The supplement marker UrnGenerator writes is the typed stage's
+      # `type_code`; the abbreviation is what `Jcgm.locate_stage` matches on.
+      SUPPLEMENT_ABBRS = {
+        "corrigendum" => "Cor",
+        "amendment" => "Amd",
+      }.freeze
+
+      MEETING_ABBR = "Meeting"
+
+      # Mirrors `year_digits` in the shared parser rules.
+      YEAR_PATTERN = /\A(?:19|20)\d{2}\z/
+
+      # A language segment is one or more comma-joined ISO codes.
+      LANGUAGES_PATTERN = /\A[a-z]{2}(?:,[a-z]{2})*\z/
+
+      # Language codes back to the single-letter form the identifier prints;
+      # the builder maps the other way when parsing "(E)" / "(E/F)".
+      LANGUAGE_LETTERS = Pubid::Builder::Base::LANG_CHAR_MAP.invert.freeze
+
       def parse_urn(urn)
         parts = split_parts(strip_namespace(urn))
-        return parse_meeting_urn(parts) if parts.first == "meeting"
+        return parse_meeting_urn(parts) if parts.first == MEETING_MARKER
 
-        number, year = parts
-        text = "JCGM #{number}"
-        text += ":#{year}" if year
-        flavor_parse(text)
+        parse_document_urn(parts)
       end
 
       private
 
-      # urn:jcgm:meeting:<number>:<year> -> "JCGM <ordinal> Meeting (<year>)"
+      # urn:jcgm:meeting:<number>[:<year>] -> Identifiers::Meeting
+      #
+      # The reconstruction must agree with a parsed identifier attribute for
+      # attribute, so `typed_stage` comes from the same registry lookup
+      # `Builder#locate_typed_stage` uses. (The attribute default now agrees
+      # too — it no longer sets `original_abbr` — so this mirrors the builder
+      # for clarity rather than out of necessity.)
       def parse_meeting_urn(parts)
         _, number, year = parts
-        ordinal = Identifiers::Meeting.ordinal(number)
-        flavor_parse("JCGM #{ordinal} Meeting (#{year})")
+
+        Identifiers::Meeting.new(
+          number: meeting_number(number),
+          date: urn_date(year),
+          typed_stage: Jcgm.locate_stage(MEETING_ABBR),
+        )
+      end
+
+      # A guide, a GUM guide, or a supplement wrapping one of those. The
+      # supplement marker splits the segments: everything before it describes
+      # the base document, everything after is the supplement's own number and
+      # date.
+      def parse_document_urn(parts)
+        marker_at = parts.index { |segment| SUPPLEMENT_ABBRS.key?(segment) }
+        return build_document(parts) unless marker_at
+
+        build_supplement(
+          parts[marker_at],
+          build_document(parts[0...marker_at]),
+          parts[(marker_at + 1)..] || [],
+        )
+      end
+
+      # The class comes from the same registry the builder uses, so a URN and a
+      # parsed reference resolve to one class and one typed_stage.
+      def build_supplement(marker, base, tail)
+        typed_stage = Jcgm.locate_stage(SUPPLEMENT_ABBRS.fetch(marker))
+        number, year = tail
+
+        Jcgm.locate_type(typed_stage.type_code).new(
+          base: base,
+          number: (number.nil? || number.empty? ? nil : number.to_s),
+          date: urn_date(year),
+          typed_stage: typed_stage,
+        )
+      end
+
+      # <number>[:<year>][:<languages>] — the number segment carries the
+      # "gum." prefix for a GUM guide, which is what selects the class.
+      #
+      # Guide and GumGuide deliberately take their `typed_stage` from the
+      # attribute default: the grammar emits no type token for them, so
+      # `Builder#build` fills it from `published_typed_stage` too, and both
+      # paths agree.
+      def build_document(parts)
+        number, *rest = parts
+        require_number!(number)
+        gum = number.start_with?(GUM_PREFIX)
+
+        (gum ? Identifiers::GumGuide : Identifiers::Guide).new(
+          number: (gum ? number.delete_prefix(GUM_PREFIX) : number).to_s,
+          date: urn_date(segment_matching(rest, YEAR_PATTERN)),
+          languages: urn_languages(segment_matching(rest, LANGUAGES_PATTERN)),
+        )
+      end
+
+      def require_number!(segment)
+        return unless segment.nil? || segment.empty?
+
+        raise Pubid::UrnParser::Errors::ParseError,
+              "JCGM URN has no document number"
+      end
+
+      def segment_matching(segments, pattern)
+        segments.find { |segment| segment.match?(pattern) }
+      end
+
+      # The ordinal, normalized the way `Identifiers::Meeting.ordinal` does it
+      # (`number.to_i`), so "011" reads back as "11" and a missing or
+      # non-numeric segment as "0" — the behaviour of the previous
+      # render-and-re-parse implementation.
+      def meeting_number(segment)
+        segment.to_i.to_s
+      end
+
+      # nil for an absent year; a Date for a well-formed one. The grammar
+      # accepts only a 19xx/20xx year, so anything else is a malformed URN and
+      # must still be rejected now that no re-parse validates it.
+      def urn_date(segment)
+        return nil if segment.nil? || segment.empty?
+
+        unless segment.match?(YEAR_PATTERN)
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid year in JCGM URN: #{segment.inspect}"
+        end
+
+        Pubid::Components::Date.new(year: segment)
+      end
+
+      # "en" -> (E), "en,fr" -> (E/F). `original_code` is what the renderer
+      # prints, so it is restored from the code rather than left nil.
+      def urn_languages(segment)
+        return nil if segment.nil? || segment.empty?
+
+        segment.split(",").map do |code|
+          Pubid::Components::Language.new(
+            code: code,
+            original_code: LANGUAGE_LETTERS.fetch(code, code),
+          )
+        end
       end
     end
   end

data/lib/pubid/jcgm.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Jcgm
     extend Pubid::PrefixesSupport
@@ -22,6 +23,15 @@ module Pubid
     # @param identifier [String] the identifier string to parse
     # @return [Identifier] the parsed identifier
     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
+
       parser = Parser.new
       builder = Builder.new
 

data/lib/pubid/jis/identifier.rb

@@ -175,12 +175,19 @@ module Pubid
       # Parse a JIS identifier string into an identifier object
       # @param identifier [String] The JIS identifier string to parse
       # @return [Identifier] The appropriate identifier object
-      # @raise [RuntimeError] 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 JIS identifier '#{identifier}': #{e.message}"
       end
     end
   end

data/lib/pubid/jis/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Jis
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Japanese character normalization
       rule(:jp_dash) { str("ｰ") } # Full-width dash
       rule(:jp_space) { str("　") }  # Full-width space

data/lib/pubid/jis.rb

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

data/lib/pubid/nist/builder.rb

@@ -253,7 +253,7 @@ module Pubid
           elsif decimal_num
             decimal_base = decimal_num[:decimal_base].to_s
             decimal_suffix = decimal_num[:decimal_suffix].to_s
-            identifier.number = Components::Code.new(value: "#{first_num.value}-#{decimal_base}.#{decimal_suffix}")
+            identifier.number = "#{first_num.value}-#{decimal_base}.#{decimal_suffix}"
           # NEW: Handle letter number pattern (e.g., 1-1A, 1-3B for NCSTAR identifiers)
           # letter_num is {:letter_base => "1", :letter_suffix => "A"}
           # Also handles IR series "R" suffix: "79-1786R" -> "79-1786r1"
@@ -268,10 +268,10 @@ module Pubid
               # Series-specific handler took ownership (e.g., IR "R" → r1)
             elsif identifier.part
               # SpecialPublication pattern: letter_suffix is separate Part component
-              identifier.number = Components::Code.new(value: "#{first_num.value}-#{letter_base}")
+              identifier.number = "#{first_num.value}-#{letter_base}"
             else
               # NCSTAR pattern: letter_suffix is part of the number
-              identifier.number = Components::Code.new(value: "#{first_num.value}-#{letter_base}#{letter_suffix}")
+              identifier.number = "#{first_num.value}-#{letter_base}#{letter_suffix}"
             end
           elsif second_num
             # Check for special patterns first
@@ -285,7 +285,7 @@ module Pubid
               # Create Edition component
               edition_obj = Components::Edition.new(type: "r", id: edition_id)
 
-              identifier.number = Components::Code.new(value: "#{first_num.value}-#{number_part}")
+              identifier.number = "#{first_num.value}-#{number_part}"
               identifier.edition = edition_obj
             # CS Emergency pattern: e104-43 -> number=104, edition_year=1943
             # Logic: e104-43 means "emergency 104 from 1943" (43 = 1943)
@@ -300,7 +300,7 @@ module Pubid
               # Create Edition component
               edition_obj = Components::Edition.new(type: "e", id: edition_year)
 
-              identifier.number = Components::Code.new(value: number_part)
+              identifier.number = number_part
               identifier.edition = edition_obj
             elsif first_num.value.to_s.match?(/^(\d+)e(\d+)$/) &&
                 second_num.value.to_s.match?(/^\d{2,4}$/)
@@ -314,7 +314,7 @@ module Pubid
               # Expand 2-digit year to 4-digit (50 -> 1950)
               year_part = "19#{year_part}" if year_part.length == 2
 
-              identifier.number = Components::Code.new(value: number_part)
+              identifier.number = number_part
 
               # For edition+year patterns, handling depends on identifier type:
               # - CIRC: edition number + year as additional_text, rendered with dot ("11e2-1915" -> "11e2.1915")
@@ -329,7 +329,7 @@ module Pubid
               number_part = first_num.value.to_s.match(/^(\d+)supp?$/)[1]
               year_part = second_num.value.to_s
 
-              identifier.number = Components::Code.new(value: number_part)
+              identifier.number = number_part
               supp[:value] = year_part
               supp[:present] = true
             elsif second_num.value.to_s.match?(/^(\d+)supp?$/)
@@ -337,14 +337,14 @@ module Pubid
               # second number. Strip it and isolate as supplement="" (single-p).
               second_part = second_num.value.to_s.match(/^(\d+)supp?$/)[1]
               compound = "#{first_num.value}-#{second_part}"
-              identifier.number = Components::Code.new(value: compound)
+              identifier.number = compound
               supp[:value] = ""
               supp[:present] = true
             elsif identifier.is_a?(Identifiers::TechnicalNote) &&
                 second_num.value.to_s.match?(/^(19|20)\d{2}$/)
               # SPECIAL CASE FOR TN: second_num is edition year
               # Following "date IS edition" rule: -1993 becomes Edition(type: "e", id: "1993")
-              identifier.number = first_num
+              identifier.number = first_num.value.to_s
               edition_obj = Components::Edition.new(type: "e",
                                                     id: second_num.value.to_s)
               identifier.edition = edition_obj
@@ -354,16 +354,16 @@ module Pubid
               # not folded into the compound number.
               identifier.part = Components::Part.new(type: "pt",
                                                      value: part_num)
-              identifier.number = Components::Code.new(value: "#{first_num.value}-#{second_num.value}")
+              identifier.number = "#{first_num.value}-#{second_num.value}"
             else
               # For GCR and others, include part number in compound number
               compound_value = "#{first_num.value}-#{second_num.value}"
               compound_value += "-#{part_num}" if part_num
-              identifier.number = Components::Code.new(value: compound_value)
+              identifier.number = compound_value
             end
           else
             # No second_num, use first_num directly
-            identifier.number = first_num
+            identifier.number = first_num.value.to_s
           end
         end
 

data/lib/pubid/nist/components/stage.rb

@@ -16,10 +16,10 @@ module Pubid
         attribute :id, :string          # i, f, 1-9
         attribute :type, :string        # pd, wd, prd
 
-        # Load stages from V1 YAML config
+        # Load stages from data/nist/stages.yaml
         STAGES = YAML.load_file(
           File.join(File.dirname(__FILE__),
-                    "../../../../archived-gems/pubid-nist/stages.yaml"),
+                    "../../../../data/nist/stages.yaml"),
         ).freeze
 
         # Render stage in specified format