pubid 2.0.0.pre.alpha.11 → 2.0.0.pre.alpha.13

data/lib/pubid/jis/identifier.rb

@@ -7,6 +7,11 @@ module Pubid
     # Pubid::Jis::Identifiers descend from this class, so a parsed JIS id is an
     # instance of Pubid::Jis::Identifier.
     class Identifier < ::Pubid::Identifier
+      # JIS prints its own all-parts suffix, "（規格群）".
+      def self.all_parts_class
+        Identifiers::AllParts
+      end
+
       # JIS keeps its number flat at the top level (string, to preserve leading
       # zeros like "0205"), with the division letter in `series` and any
       # multi-level part numbers in `parts`. Supplements override `number` with
@@ -16,9 +21,6 @@ module Pubid
       attribute :parts, :string, collection: true # Optional multi-level parts
       attribute :year, :integer
       attribute :language, :string # "E" or "J"
-      # Boolean flags carry no default, so they stay nil (and are omitted from
-      # the serialized hash) unless actually set true.
-      attribute :all_parts, :boolean
       # Reaffirmation (再確認): a trailing "R" on the year marks an edition
       # that was reaffirmed without revision (e.g. ":2019R").
       attribute :reaffirmed, :boolean
@@ -50,7 +52,6 @@ module Pubid
         map "parts", to: :parts
         map "year", to: :year
         map "language", to: :language
-        map "all_parts", to: :all_parts
         map "reaffirmed", to: :reaffirmed
         # render_empty keeps a bare "SYMBOL" (empty-string value) in the hash so
         # it round-trips distinctly from "no symbol" (nil).
@@ -62,10 +63,6 @@ module Pubid
       # would otherwise fail serialization type validation.
       PUBLISHER = "JIS"
 
-      def all_parts?
-        all_parts == true
-      end
-
       def reaffirmed?
         reaffirmed == true
       end
@@ -91,23 +88,14 @@ module Pubid
         result
       end
 
-      # Comparison with all_parts logic
-      # When either identifier has all_parts=true, compare only series and number
       def ==(other)
         return false unless other.is_a?(Identifier)
 
-        if all_parts? || other.all_parts?
-          # Compare only series and number, ignore year, parts, all_parts
-          return series == other.series && number == other.number
-        end
-
-        # Normal full comparison
         series == other.series &&
           number == other.number &&
           (parts || []) == (other.parts || []) &&
           year == other.year &&
           language == other.language &&
-          all_parts? == other.all_parts? &&
           reaffirmed? == other.reaffirmed? &&
           symbol == other.symbol
       end

data/lib/pubid/jis/identifiers/all_parts.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # Every part of one JIS document: "JIS C 0617（規格群）".
+      class AllParts < ::Pubid::Jis::Identifier
+        include ::Pubid::AllParts
+
+        SUFFIX = "（規格群）"
+
+        # The URN of the document plus the "all" slot.
+        def to_urn
+          "#{identity.to_urn}:all"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jis/identifiers.rb

@@ -3,6 +3,7 @@
 module Pubid
   module Jis
     module Identifiers
+      autoload :AllParts, "#{__dir__}/identifiers/all_parts"
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :Explanation, "#{__dir__}/identifiers/explanation"

data/lib/pubid/jis/renderer.rb

@@ -38,7 +38,6 @@ module Pubid
         result = "#{PUBLISHER} #{id.code}"
         result += ":#{id.year_with_reaffirmation}" if id.year
         result += "(#{id.language})" if id.language
-        result += "（規格群）" if id.all_parts?
         result + id.symbol_suffix
       end
 
@@ -52,7 +51,6 @@ module Pubid
         result += id.code.to_s
         result += ":#{id.year_with_reaffirmation}" if id.year
         result += "(#{id.language})" if id.language
-        result += "（規格群）" if id.all_parts?
         result += id.symbol_suffix
         result
       end

data/lib/pubid/jis/urn_generator.rb

@@ -12,7 +12,6 @@ module Pubid
 
         parts << identifier.language.to_s.downcase if identifier.language
 
-        parts << "all" if identifier.all_parts?
 
         if identifier.is_a?(SupplementIdentifier) && identifier.supplement_notation
           parts << identifier.supplement_notation.to_s.downcase

data/lib/pubid/nist/CLAUDE.md

@@ -0,0 +1,56 @@
+# NIST flavor notes
+
+NIST rendering formats and annotated output.
+
+Read this before you change `lib/pubid/nist/` or `spec/pubid/nist/`. The root
+`CLAUDE.md` keeps the cross-flavor contract that every flavor obeys.
+
+- **Six NIST types rendered plain under `to_s(annotated: true)`, and two
+  more carried a latent corruption.** NIST's `to_s` takes a **positional**
+  `format`, which Ruby fills with a Hash when a caller passes `annotated:`;
+  `Identifiers::Base#to_s` already handles that and annotates. The six that
+  did not — `CommercialStandardsMonthly`, `CrplReport`, `InteragencyReport`,
+  `MiscellaneousPublication`, `Monograph`, `Report` — either compose their
+  own string or hand `super` a **Symbol**, which drops the flag. Each now
+  pulls `annotated` out of the Hash itself and wraps its result.
+
+  **`Circular` and `Handbook` are the interesting half.** Both did
+  `result = super` — which annotates — and then rewrote the edition with a
+  **`$`-anchored** regex. Once the string ends in `</span>` the anchor
+  cannot match, so the rewrite silently stops applying. Both now strip the
+  flag before `super`, rewrite, then annotate.
+
+  **An output assertion cannot catch that**, and this is the lesson: for
+  both fixture references (`NBS CIRC 11e2-1915`, `NBS HB 44e2-1955`) the
+  annotator matches only the leading publisher, so the tail is bare and the
+  wrong order still produces the right string. The spec asserts the
+  **ordering** instead — it wraps `annotate_plain_render` and checks the
+  string handed to it is already rewritten and carries no span — and that
+  assertion was verified to fail when the order is reverted.
+
+  `CircularSupplement` and `SupplementIdentifier` were also normalised:
+  both had a date-range branch that returned a hand-composed string without
+  ever reaching `super`. `SupplementIdentifier` has four exits, so its
+  composition moved into a private `render_plain`; **`super` is not
+  reachable from a private method**, so `to_s` hands it in as a block —
+  `render_plain(format) { super(format) }`.
+
+- **`all_parts_edition_keys` needed `update`/`update_component`, not
+  `edition_year`.** `Identifier.all_parts_edition_keys` defaults to
+  `%i[date year edition version]`; NIST's primary edition carrier
+  (`edition`, a `Components::Edition`) is already covered, but the Letter
+  Circular / Circular "rJun1992"-style revision (`Builder` around the
+  "Convert revision with month+year to update component" comment) parses
+  into a **separate** attribute, `update`/`update_component`
+  (`Components::Update`: number+year+month), which the default list
+  missed entirely — `"NBS LC 800 rJun1992"` and `"NBS LC 800 rJul1995"`
+  failed to collapse under `#to_all_parts`/`#===`. Fixed with
+  `Pubid::Nist::Identifier.all_parts_edition_keys` (`super + %i[update
+  update_component]`). **`edition_year` and `revision_year`/
+  `revision_month` were investigated and are NOT added**: `Builder` only
+  ever sets `edition_year` alongside the real `edition` component (never
+  as its sole carrier, e.g. the TechnicalNote "date IS edition" branch),
+  and `revision_year`/`revision_month` are transient — converted into
+  `update`/`update_component` and cleared to `nil` before the object is
+  returned. Neither carries live information `edition`/`update` doesn't
+  already cover. Locked by `spec/pubid/all_parts_edition_keys_audit_spec.rb`.

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
 
@@ -479,3 +479,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Nist::Builder.prepend(Pubid::Builder::AllPartsWrap)

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

@@ -28,6 +28,8 @@ module Pubid
       #   Edition.new(type: "r", id: "5").to_s                              # => "r5"
       #   Edition.new(type: "r", id: "5", original_prefix: " Rev. ").to_s    # => "Rev. 5"
       class Edition < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :type, :string            # "-", "e", or "r"
         attribute :id, :string              # Edition ID (number or year)
         attribute :additional_text, :string # Text after "rev" (WITHOUT "rev" prefix)

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

@@ -8,6 +8,8 @@ module Pubid
       # IssueNumber component for NIST identifiers
       # Represents the issue/number designation (e.g., "No. 12" in "Vol. 6, No. 12")
       class IssueNumber < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :number, :string
 
         # Short form rendering: "n12"

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

@@ -23,6 +23,8 @@ module Pubid
       #   - SP: Part number (pt1)
       #   - Letter suffixes (A, B, C, etc.)
       class Part < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :type, :string   # "pt" for part notation, "n" for issue, "" for letter suffix
         attribute :value, :string  # Part number or letter (1, 2, A, B, etc.)
 

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

@@ -13,6 +13,8 @@ module Pubid
       #   Stage.new(id: "i", type: "pd").to_s(:short) # => "ipd"
       #   Stage.new(id: "f", type: "pd").to_s(:long)  # => "(Final Public Draft)"
       class Stage < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :id, :string          # i, f, 1-9
         attribute :type, :string        # pd, wd, prd
 

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

@@ -15,6 +15,8 @@ module Pubid
       #   Supplement.new(month: "Jan", year: "1924").to_s(:short) # => "supJan1924"
       #   Supplement.new(has_revision: true).to_s(:short)        # => "suprev"
       class Supplement < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :number, :string           # Supplement number (e.g., "2" in "supp2")
         attribute :year, :string             # Year (4 digits); range START year
         attribute :month, :string            # Month abbreviation; range START month

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

@@ -13,6 +13,8 @@ module Pubid
       #   Translation.new(code: "por").to_s(:mr)    # => ".por"
       #   Translation.new(code: "ind").to_s(:short) # => " ind"
       class Translation < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :code, :string # 3-letter ISO 639-2 code: spa, por, ind, etc.
 
         # Backward compatibility: language method returns code

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

@@ -15,6 +15,8 @@ module Pubid
       #   Update.new(number: 1, year: 2021, month: 2).to_s(:mr)    # => "-upd1-202102"
       #   Update.new(number: 1, prefix: "dash").to_s(:short)       # => "-upd1" (preserves original prefix)
       class Update < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :number, :string   # Update number as string
         attribute :year, :string     # Year (4 digits as string)
         attribute :month, :string    # Month (01-12 as string, optional)

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

@@ -12,6 +12,8 @@ module Pubid
       #   Version.new(value: "1.0.2").to_s(:short) # => "ver1.0.2"
       #   Version.new(value: "2.0").to_s(:long)    # => "Version 2.0"
       class Version < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :value, :string # Dotted notation: "1.0.2"
 
         # Render version in specified format

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

@@ -16,6 +16,8 @@ module Pubid
       #   - CSM (Commercial Standards Monthly): Volume 6, Issue 1
       #   - CIRC (Circular): Volume 539
       class Volume < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :value, :string
 
         def to_s

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
@@ -216,6 +223,30 @@ module Pubid
 
       alias eql? ==
 
+      # A subset match skips the same attributes: `to_hash` drops the build
+      # artifacts, so an index row rebuilt by `from_hash` never has them.
+      def self.subset_ignored_attributes
+        EQUALITY_IGNORED_ATTRS
+      end
+
+      # `edition` is the primary edition/revision carrier and is already in
+      # the default %i[date year edition version] list. `update`/
+      # `update_component` (Components::Update: number+year+month) is a
+      # SEPARATE, currently-live discriminator the default list misses — the
+      # Letter Circular / Circular "rJun1992"-style revision parses into it,
+      # not into `edition` (see Builder#build_dated_identifier), so e.g.
+      # "NBS LC 800 rJun1992" and "NBS LC 800 rJul1995" failed to collapse
+      # under #to_all_parts/#=== before this override. (`edition_year` and
+      # `revision_year`/`revision_month` are NOT added here: the builder
+      # always sets `edition_year` alongside the real `edition` component
+      # (never alone), and `revision_year`/`revision_month` are transient —
+      # converted into `update`/`update_component` and cleared to nil before
+      # the object is returned — so neither carries live information outside
+      # what `edition`/`update` already do.)
+      def self.all_parts_edition_keys
+        super + %i[update update_component]
+      end
+
       def hash
         vals = self.class.attributes.each_key.reject do |name|
           EQUALITY_IGNORED_ATTRS.include?(name)
@@ -406,13 +437,11 @@ module Pubid
         match ? match[1].to_i : nil
       end
 
-      public
-
       def to_full_style
         # "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"
@@ -739,6 +768,5 @@ module Pubid
         "NIST"
       end
     end
-
   end
 end

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

@@ -13,8 +13,20 @@ module Pubid
       # feeds the cleaned string to the Parslet grammar and stamps the
       # detected format onto the parse tree.
       def self.class_parse_with_preprocessing(input)
+        # The shared Grammar strips a trailing "(all parts)", but the NIST
+        # preprocessor runs first and would swallow it — strip before it and
+        # carry the marker to the tree like Grammar#parse does.
+        all_parts = input.is_a?(String) && input.match?(::Pubid::Parser::Grammar::ALL_PARTS_SUFFIX)
+        input = input.sub(::Pubid::Parser::Grammar::ALL_PARTS_SUFFIX, "") if all_parts
         result = Preprocessor.new(input).call
         parsed = new.parse(result.cleaned)
+        if all_parts
+          parsed = case parsed
+                   when Hash then parsed.merge(all_parts: true)
+                   when Array then parsed.map { |h| h.merge(all_parts: true) }
+                   else parsed
+                   end
+        end
 
         if parsed.is_a?(Hash)
           parsed.merge(parsed_format: result.format)
@@ -651,8 +663,9 @@ module Pubid
       rule(:mr_identifier) do
         hash_prefix.maybe >>
           publisher >> dot >>
-          simple_series >> dot >>
-          report_number >>
+          # The catalogue also lists bare series identities with no
+          # report number ("NBS.CIRC").
+          simple_series >> dot.maybe >> report_number.maybe >>
           # Edition with underscore separator (MR format: 1648_2009)
           (str("_") >> digits.as(:edition_year)).maybe >>
           # Support letter suffix before update (e.g., 8286C-upd1) - Session 219