pubid 2.0.0.pre.alpha.11 → 2.0.0.pre.alpha.12

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

@@ -6,18 +6,15 @@ module Pubid
       # Technical Committee Document
       # Format: TC 184/SC 4/WG 3 N 123, JTC 1 N 456, TC 184 N 100
       class TcDocument < Identifier
-        # TC type (TC, JTC, PC, IT, etc.)
-        attribute :tc_type, ::Pubid::Components::Code
-        # TC number
-        attribute :tc_number, ::Pubid::Components::Code
-        # SC type
-        attribute :sc_type, ::Pubid::Components::Code
-        # SC number
-        attribute :sc_number, ::Pubid::Components::Code
-        # WG type
-        attribute :wg_type, ::Pubid::Components::Code
-        # WG number
-        attribute :wg_number, ::Pubid::Components::Code
+        # The committee structure: plain strings ("TC", "184", "SC", "4").
+        # Each held a Components::Code carrying nothing but `value`, and the
+        # serialized form was already the bare scalar.
+        attribute :tc_type, :string
+        attribute :tc_number, :string
+        attribute :sc_type, :string
+        attribute :sc_number, :string
+        attribute :wg_type, :string
+        attribute :wg_number, :string
 
         # TC types from ISO system
         TC_TYPES = %w[TC JTC PC IT CAB CASCO COPOLCO COUNCIL CPSG CS DEVCO GA
@@ -33,33 +30,21 @@ module Pubid
         # TC documents don't use typed stages like other identifiers
         TYPED_STAGES = [].freeze
 
-        # Serialize the committee structure (all plain-string Codes) on top of
-        # the inherited ISO mapping; TC documents have no stage.
+        # Serialize the committee structure on top of the inherited ISO
+        # mapping; TC documents have no stage. The attributes are plain
+        # strings, so lutaml needs no converter (the ETSI/OIML shape).
         key_value do
-          map "tc_type", with: { to: :tc_type_to_kv, from: :tc_type_from_kv }
-          map "tc_number", with: { to: :tc_number_to_kv, from: :tc_number_from_kv }
-          map "sc_type", with: { to: :sc_type_to_kv, from: :sc_type_from_kv }
-          map "sc_number", with: { to: :sc_number_to_kv, from: :sc_number_from_kv }
-          map "wg_type", with: { to: :wg_type_to_kv, from: :wg_type_from_kv }
-          map "wg_number", with: { to: :wg_number_to_kv, from: :wg_number_from_kv }
+          map "tc_type", to: :tc_type
+          map "tc_number", to: :tc_number
+          map "sc_type", to: :sc_type
+          map "sc_number", to: :sc_number
+          map "wg_type", to: :wg_type
+          map "wg_number", to: :wg_number
         end
 
         # TC documents have no stage; suppress the inherited stage emission.
         def stage_to_kv(_model, _doc); end
 
-        def tc_type_to_kv(m, doc) = emit_code(doc, "tc_type", m.tc_type)
-        def tc_type_from_kv(m, v) = m.tc_type = build_code(v)
-        def tc_number_to_kv(m, doc) = emit_code(doc, "tc_number", m.tc_number)
-        def tc_number_from_kv(m, v) = m.tc_number = build_code(v)
-        def sc_type_to_kv(m, doc) = emit_code(doc, "sc_type", m.sc_type)
-        def sc_type_from_kv(m, v) = m.sc_type = build_code(v)
-        def sc_number_to_kv(m, doc) = emit_code(doc, "sc_number", m.sc_number)
-        def sc_number_from_kv(m, v) = m.sc_number = build_code(v)
-        def wg_type_to_kv(m, doc) = emit_code(doc, "wg_type", m.wg_type)
-        def wg_type_from_kv(m, v) = m.wg_type = build_code(v)
-        def wg_number_to_kv(m, doc) = emit_code(doc, "wg_number", m.wg_number)
-        def wg_number_from_kv(m, v) = m.wg_number = build_code(v)
-
         def self.type
           { key: :tc,
             web: :tc_document, title: "Technical Committee Document", short: "TC" }
@@ -73,23 +58,23 @@ module Pubid
           result = publisher.to_s if publisher
 
           # Add TC type and number
-          result += "/#{tc_type.render} " if tc_type&.value
-          result += tc_number.render.to_s if tc_number&.value
+          result += "/#{tc_type} " unless tc_type.to_s.empty?
+          result += tc_number.to_s unless tc_number.to_s.empty?
 
           # Add SC type and number
-          if sc_type&.value && sc_number&.value
-            result += "/#{sc_type.render} "
-            result += sc_number.render.to_s
+          unless sc_type.to_s.empty? || sc_number.to_s.empty?
+            result += "/#{sc_type} "
+            result += sc_number.to_s
           end
 
           # Add WG type and number
-          if wg_type&.value && wg_number&.value
-            result += "/#{wg_type.render} "
-            result += wg_number.render.to_s
+          unless wg_type.to_s.empty? || wg_number.to_s.empty?
+            result += "/#{wg_type} "
+            result += wg_number.to_s
           end
 
           # Add document number
-          result += " N #{number.render}" if number&.value
+          result += " N #{number}" unless number.to_s.empty?
 
           # Add year if present
           result += ":#{date.render}" if date&.year
@@ -105,16 +90,16 @@ module Pubid
           parts << publisher.render(context: urn_ctx) if publisher
 
           # Add TC
-          parts << "tc:#{tc_number.render(context: urn_ctx)}" if tc_number&.value
+          parts << "tc:#{tc_number}" unless tc_number.to_s.empty?
 
           # Add SC
-          parts << "sc-#{sc_number.render(context: urn_ctx)}" if sc_number&.value
+          parts << "sc-#{sc_number}" unless sc_number.to_s.empty?
 
           # Add WG
-          parts << "wg-#{wg_number.render(context: urn_ctx)}" if wg_number&.value
+          parts << "wg-#{wg_number}" unless wg_number.to_s.empty?
 
           # Add document number
-          parts << number.render(context: urn_ctx) if number&.value
+          parts << number.to_s unless number.to_s.empty?
 
           parts.join(":")
         end

data/lib/pubid/iso/normalizer.rb

@@ -73,7 +73,7 @@ module Pubid
 
           addendum = Identifiers::Addendum.new
           addendum.base = base
-          addendum.number = Iso::Components::Code.new(value: supplement_number)
+          addendum.number = supplement_number
           addendum.date = Pubid::Components::Date.new(year: supplement_year) if supplement_year
 
           typed_stage = Pubid::Iso.locate_stage(stage_abbr)

data/lib/pubid/iso/urn_generator.rb

@@ -63,7 +63,7 @@ module Pubid
         parts << originator_component
         type_comp = type_component
         parts << type_comp if type_comp
-        parts << identifier.number.render(context: URN_CONTEXT) if identifier.number
+        parts << identifier.number.to_s if identifier.number
         part_comp = part_component
         parts << part_comp if part_comp
         stage_comp = stage_component
@@ -95,7 +95,7 @@ module Pubid
           parts << base_gen.originator_component
           type_comp = base_gen.type_component
           parts << type_comp if type_comp
-          parts << base_id.number.render(context: URN_CONTEXT) if base_id.number
+          parts << base_id.number.to_s if base_id.number
           part_comp = base_gen.part_component
           parts << part_comp if part_comp
 
@@ -138,13 +138,13 @@ module Pubid
             parts << supp.date.render(context: URN_CONTEXT)
             if supp.number
               if supp.stage_iteration && !supp.is_a?(Pubid::Iso::Identifiers::Supplement)
-                parts << "v#{supp.number.render(context: URN_CONTEXT)}.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
+                parts << "v#{supp.number}.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
               else
-                parts << "v#{supp.number.render(context: URN_CONTEXT)}"
+                parts << "v#{supp.number}"
               end
             end
           else
-            parts << supp.number.render(context: URN_CONTEXT) if supp.number
+            parts << supp.number.to_s if supp.number
             if supp.stage_iteration && !supp.is_a?(Pubid::Iso::Identifiers::Supplement)
               parts << "v1.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
             else
@@ -197,8 +197,8 @@ module Pubid
       def part_component
         return nil unless identifier.part
 
-        result = "-#{identifier.part.render(context: URN_CONTEXT)}"
-        result += "-#{identifier.subpart.render(context: URN_CONTEXT)}" if identifier.subpart
+        result = "-#{identifier.part}"
+        result += "-#{identifier.subpart}" if identifier.subpart
         result
       end
 
@@ -292,13 +292,13 @@ module Pubid
           parts << identifier.date.render(context: URN_CONTEXT)
           if identifier.number
             parts << if identifier.stage_iteration
-                       "v#{identifier.number.render(context: URN_CONTEXT)}.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
+                       "v#{identifier.number}.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
                      else
-                       "v#{identifier.number.render(context: URN_CONTEXT)}"
+                       "v#{identifier.number}"
                      end
           end
         else
-          parts << identifier.number.render(context: URN_CONTEXT) if identifier.number
+          parts << identifier.number.to_s if identifier.number
           parts << if identifier.stage_iteration
                      "v1.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
                    else

data/lib/pubid/iso.rb

@@ -66,7 +66,7 @@ module Pubid
     # @param type [Symbol] the type key (e.g. :is, :tr, :ts, :guide)
     # @param publisher [String, Pubid::Iso::Components::Publisher] primary publisher
     # @param copublishers [Array<String>, Array<Pubid::Components::Publisher>]
-    # @param number [String, Integer, Pubid::Iso::Components::Code]
+    # @param number [String, Integer]
     # @param year [String, Integer, Pubid::Components::Date, nil]
     # @param attrs [Hash] additional identifier attributes
     # @return [Pubid::Iso::Identifier]
@@ -106,10 +106,11 @@ module Pubid
     private_class_method :build_copublishers
 
     # @!visibility private
+    # number/part/subpart are plain strings. A caller that still passes a
+    # Components::Code (another flavor's builder, a hand-built id) is read
+    # through its own #to_s rather than refused.
     def self.build_code(value)
-      return value if value.is_a?(Components::Code)
-
-      Components::Code.new(value: value.to_s)
+      value.to_s
     end
     private_class_method :build_code
 

data/lib/pubid/itu/builder.rb

@@ -68,6 +68,16 @@ module Pubid
           return build_question(data)
         end
 
+        # Contribution (Temporary Document) — "ITU-R SG17-C1000" (pubid#340).
+        if data[:contribution_marker]
+          return Identifiers::Contribution.new(
+            sector: Components::Sector.new(sector: data[:sector].to_s),
+            series: Components::Series.new(series: data[:series].to_s),
+            code: build_code(data),
+            language: data[:language]&.to_s,
+          )
+        end
+
         # Build basic recommendation or combined identifier
         sector = Components::Sector.new(sector: data[:sector].to_s)
         series = Components::Series.new(series: data[:series].to_s) if data[:series]

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

@@ -37,6 +37,16 @@ module Pubid
       end
       private_class_method :normalize_whitespace
 
+      # The type key used by Pubid::Itu.locate_type — the class name
+      # ("Contribution" => :contribution). No ITU leaf ever defined a
+      # `type` hash, so locate_type raised NoMethodError on every call;
+      # the derived default gives every concrete leaf a key for free
+      # (pubid#340's ask). metanorma-itu constructs via this lookup.
+      def self.type
+        leaf = name.split("::").last
+        { key: leaf.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym }
+      end
+
       # Long-form ↔ ITU single-letter language code map. The parser produces
       # single-letter codes (E/F/S/R/A/C); API callers (e.g. metanorma-itu)
       # pass long-form (en/fr/es/ru/ar/zh). Storage is normalized to the

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

@@ -0,0 +1,31 @@
+# frozen_string: true
+
+module Pubid
+  module Itu
+    module Identifiers
+      # ITU Contribution (Temporary Document) — the working documents a study
+      # group circulates, numbered per study group.
+      #
+      # Format: ITU-{SECTOR} {SERIES}-C{NUMBER}    e.g. ITU-R SG17-C1000
+      #
+      # Mirrors pubid-itu 1.15's Pubid::Itu::Identifier::Contribution
+      # ("%{series}-C%{number}"), which metanorma-itu builds from
+      # `:doctype: contribution` documents (pubid#340).
+      class Contribution < Identifier
+        include StandardSerialization
+
+        def render_base(**_opts)
+          "#{publisher}-#{sector} #{series}-C#{code&.number}"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Contribution)
+
+          sector == other.sector &&
+            series == other.series &&
+            code == other.code
+        end
+      end
+    end
+  end
+end

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

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

@@ -27,7 +27,7 @@ module Pubid
       #     bare { "value" => … } with no part;
       #   - drop the redundant build artifacts, decomposed pieces of the
       #     canonical number that identity/rendering never read.
-      COMPACT_FLAT_CODES = %w[series number subseries].freeze
+      COMPACT_FLAT_CODES = %w[series subseries].freeze
       COMPACT_FLAT_VALUES = %w[volume].freeze
       COMPACT_DROP_ATTRS = %w[first_number second_number].freeze
 
@@ -105,7 +105,14 @@ module Pubid
       # equality so a manually-built id (without subseries set) still equals a
       # parsed one.
       attribute :subseries, Components::Code
-      attribute :number, Components::Code
+      # Plain :string. NIST never populated the Code beyond `value`: `subpart`
+      # is set nowhere, and `part` was a reader splitting `value` on "-" that
+      # no library code called. `series`, `subseries`, `first_number`,
+      # `second_number` and `parts` keep the component.
+      attribute :number, :string
+      # NIST never uses `subpart`; declare it so the inherited Components::Code
+      # does not disagree with this class (the determinism landmine).
+      attribute :subpart, :string
 
       # V2 COMPONENTS (Lutaml::Model objects) - PROPER SEPARATION
       # `edition` (Components::Edition: type + id + additional_text) is the
@@ -412,7 +419,7 @@ module Pubid
         # "National Institute of Standards and Technology Special Publication 800-27, Revision A"
         result = publisher_full_name
         result += " #{series_full_name}" if series
-        result += " #{number.value}" if number
+        result += " #{number}" if number
         result += parts.map { |p| "-#{p}" }.join if parts&.any?
 
         # Render volume and issue number in long form: "Vol. 6, No. 12"

data/lib/pubid/nist/identifiers/commercial_standard_emergency.rb

@@ -44,7 +44,7 @@ module Pubid
           result += " CS-E"
 
           # Number (already extracted from e104 → 104 in builder)
-          result += " #{number.value}" if number
+          result += " #{number}" if number
 
           # Edition (e1943 for e104-43 pattern) plus any other component the
           # parser attached (volume, supplement, version, ...).

data/lib/pubid/nist/identifiers/crpl_report.rb

@@ -46,7 +46,7 @@ module Pubid
         def normalized_number
           return nil unless number
 
-          num_value = number.value.to_s
+          num_value = number.to_s
 
           # Pattern: c4-4 → 4-4 (hide 'c' prefix)
           case num_value
@@ -64,12 +64,12 @@ module Pubid
         end
 
         # Override number to return normalized value
-        # Tests expect number.value to be normalized (c4-4 → 4-4, 4-m-5 → 4-M-5)
+        # Tests expect number to be normalized (c4-4 → 4-4, 4-m-5 → 4-M-5)
         def number
           num = super
           return num unless num
 
-          num_value = num.value.to_s
+          num_value = num.to_s
 
           # Pattern: c4-4 → 4-4 (hide 'c' prefix)
           case num_value
@@ -83,8 +83,7 @@ module Pubid
             num_value = num_value.gsub(/^m-/, "M-")
           end
 
-          # Return new Code object with normalized value
-          Components::Code.new(value: num_value)
+          num_value
         end
 
         def to_s(format = nil)
@@ -106,7 +105,7 @@ module Pubid
 
           if number
             # Normalize number value for CRPL patterns
-            num_value = number.value.to_s
+            num_value = number.to_s
 
             # Pattern: c4-4 → 4-4 (hide 'c' prefix)
             case num_value

data/lib/pubid/nist/identifiers/federal_information_processing_standards.rb

@@ -66,14 +66,14 @@ module Pubid
             # Convert dash-year patterns to edition format for FIPS
             # Pattern: "14-1971" → "14e1971" (edition year format)
             # But preserve dash for parts: "140-3" stays as-is
-            if number.value =~ /^(\d{1,3})-(\d{4})$/
+            if number =~ /^(\d{1,3})-(\d{4})$/
               # This is a number-year pattern (e.g., "14-1971")
               # Convert to edition format: "14e1971"
               number_part = $1
               year_part = $2
               result += " #{number_part}e#{year_part}"
             else
-              result += " #{number.value}"
+              result += " #{number}"
             end
           end
 

data/lib/pubid/nist/identifiers/miscellaneous_publication.rb

@@ -57,14 +57,14 @@ module Pubid
 
         def to_short_style
           result = "#{default_publisher} #{series_code}"
-          result += " #{number.value}" if number
+          result += " #{number}" if number
           result += append_short_components
           result
         end
 
         def to_mr_style
           result = "#{default_publisher}.#{series_code}"
-          result += ".#{number.value}" if number
+          result += ".#{number}" if number
           result += append_mr_components
           result
         end

data/lib/pubid/nist/series/ir.rb

@@ -31,9 +31,7 @@ module Pubid
                                              letter_suffix:)
           return false unless letter_suffix == "R"
 
-          identifier.number = Components::Code.new(
-            value: "#{first_num.value}-#{letter_base}",
-          )
+          identifier.number = "#{first_num.value}-#{letter_base}"
           edition_obj = Components::Edition.new(type: "r", id: "1")
           identifier.edition = edition_obj
           true
@@ -42,13 +40,11 @@ module Pubid
         def self.finalize_identifier(identifier, _parsed_hash)
           return unless identifier.number
 
-          value = identifier.number.value.to_s
+          value = identifier.number.to_s
           match = value.match(/^(\d+)e(\d{4})$/)
           return unless match
 
-          identifier.number = Components::Code.new(
-            value: "#{match[1]}-#{match[2]}",
-          )
+          identifier.number = "#{match[1]}-#{match[2]}"
           identifier.edition = nil
         end
       end

data/lib/pubid/oiml/builder.rb

@@ -228,13 +228,13 @@ module Pubid
           article_id = parsed_hash[:article_id].to_s
           identifier.date ||= Pubid::Components::Date.new
           identifier.date.year = article_id[0, 4]
-          identifier.issue = article_id[4, 2]
+          identifier.number = article_id[4, 2]
           identifier.sequence = article_id[6, 2]
           warn_on_volume_mismatch(identifier, parsed_hash[:volume_roman])
           return
         end
 
-        identifier.issue = parsed_hash[:issue].to_s if parsed_hash[:issue]
+        identifier.number = parsed_hash[:issue].to_s if parsed_hash[:issue]
         identifier.sequence = parsed_hash[:sequence].to_s if parsed_hash[:sequence]
       end