pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/nist/circular_supplement_builder.rb

@@ -1,293 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    # Builder dedicated to CIRC/LCIRC supplement identifier construction.
-    #
-    # Extracted from Builder.build_circular_supplement* methods to keep the
-    # main Builder focused on orchestration. The circular supplement
-    # construction pipeline is a self-contained sub-flow that:
-    #
-    # 1. Decides between the wrapper class (CircularSupplement) for V1-compat
-    #    update forms (slash-year "118supp3/1926" -> ".../Upd1-192603";
-    #    implicit revision "145r11/1925") and the normal Circular /
-    #    LetterCircular classes for everything else.
-    # 2. Builds the base identifier recursively via Builder#build.
-    # 3. Attaches the supplement as either an isolated component on the normal
-    #    class, or a structured edition/update on the wrapper.
-    #
-    # Single Responsibility: Construct CIRC/LCIRC supplement identifier
-    # objects from parsed data, calling back to the parent Builder for base
-    # identifier construction.
-    class CircularSupplementBuilder
-      # @param builder [Builder] the parent builder (for recursive base build)
-      def initialize(builder)
-        @builder = builder
-      end
-
-      # Build CircularSupplement with base wrapping
-      # @param parsed_hash [Hash] the parsed supplement data
-      # Build a CIRC/LCIRC supplement. Most forms collapse onto the base
-      # identifier's normal class (Circular / LetterCircular) with isolated
-      # supplement attributes, so they share one model with every other series
-      # and are queryable by part. The V1-compat update forms (slash-year
-      # "118supp3/1926" -> ".../Upd1-192603"; implicit revision "145r11/1925")
-      # render through an Update component the flat supplement model can't
-      # express, so they stay on the CircularSupplement wrapper for now.
-      def build_circular_supplement(parsed_hash)
-        if parsed_hash[:supplement_slash_year].is_a?(Hash) ||
-            parsed_hash[:implicit_supplement].is_a?(Hash)
-          return build_circular_supplement_wrapper(parsed_hash)
-        end
-
-        series_value = if parsed_hash[:circ_series].is_a?(Hash)
-                         parsed_hash[:circ_series][:series]
-                       else
-                         parsed_hash[:series]
-                       end
-
-        # Date-range supplement (no base document): a plain base identifier with
-        # no number, carrying the range. parsed_format is left at the default so
-        # a dotted MR input still normalizes to the spaced short form.
-        if parsed_hash[:supplement_date_range].is_a?(Hash)
-          range = parsed_hash[:supplement_date_range]
-          identifier = @builder.build({ series: series_value })
-          ms = range[:supp_month_start]&.to_s
-          ys = range[:supp_year_start]&.to_s
-          me = range[:supp_month_end]&.to_s
-          ye = range[:supp_year_end]&.to_s
-          # Month is optional: a year-only range ("sup1925-1926") passes just the
-          # bare year, which supplement_from parses into year/year_end.
-          identifier.supplement = @builder.supplement_from(
-            value: nil, has_revision: false,
-            range_start: (ys ? "#{ms}#{ys}" : nil),
-            range_end: (ye ? "#{me}#{ye}" : nil)
-          )
-          return identifier
-        end
-
-        # Based supplement: build the base, then attach the supplement as an
-        # isolated component on that normal class.
-        identifier = build_circular_supplement_base(parsed_hash, series_value)
-        raw = if parsed_hash[:supplement_month_year]
-                parsed_hash[:supplement_month_year].to_s
-              elsif parsed_hash[:supplement_year]
-                parsed_hash[:supplement_year].to_s
-              else
-                "" # supplement_empty or bare marker
-              end
-        identifier.supplement = Components::Supplement.from_raw(raw)
-        identifier
-      end
-
-      # Build just the base identifier for a based CIRC/LCIRC supplement, from
-      # base_portion (number, optional edition "101e2" or letter suffix "378G")
-      # or the merged first_number fallback. Returns the normal class.
-      def build_circular_supplement_base(parsed_hash, series_value)
-        base_portion = parsed_hash[:base_portion]
-        unless base_portion
-          return @builder.build({
-                                  publisher: parsed_hash[:publisher],
-                                  series: series_value || parsed_hash[:series],
-                                  first_number: parsed_hash[:first_number],
-                                  parsed_format: parsed_hash[:parsed_format],
-                                })
-        end
-
-        base_number = if base_portion.is_a?(Hash)
-                        base_portion[:simple_number] || base_portion[:base_number]
-                      else
-                        base_portion
-                      end
-
-        letter_suffix = nil
-        if base_portion.is_a?(Hash) && base_portion[:letter_suffix]
-          letter_suffix = base_portion[:letter_suffix].to_s.upcase
-        end
-
-        publisher_value = nil
-        if parsed_hash[:circ_series].is_a?(Hash) && parsed_hash[:circ_series][:series]
-          series_str = parsed_hash[:circ_series][:series].to_s
-          publisher_value = series_str.split.first if series_str.include?(" ")
-        end
-
-        has_edition = base_portion.is_a?(Hash) && base_portion[:edition_number]
-
-        base_number_with_suffix = base_number.to_s
-        base_number_with_suffix += letter_suffix if letter_suffix
-        if has_edition
-          base_number_with_suffix += "e#{base_portion[:edition_number]}"
-        end
-
-        base_hash = {
-          series: series_value,
-          first_number: base_number_with_suffix,
-          parsed_format: parsed_hash[:parsed_format],
-        }
-        base_hash[:publisher] = publisher_value if publisher_value
-        base_hash[:edition_e] =
-          { edition_id: base_portion[:edition_number] } if has_edition
-
-        @builder.build(base_hash)
-      end
-
-      # @return [Identifiers::CircularSupplement] the supplement identifier
-      def build_circular_supplement_wrapper(parsed_hash)
-        supplement = Identifiers::CircularSupplement.new
-
-        # Extract series from circ_series if present (nested structure from parser)
-        series_value = nil
-        if parsed_hash[:circ_series].is_a?(Hash)
-          series_value = parsed_hash[:circ_series][:series]
-        elsif parsed_hash[:series]
-          series_value = parsed_hash[:series]
-        end
-
-        # Handle date range supplement (no base)
-        if parsed_hash[:supplement_date_range].is_a?(Hash)
-          range = parsed_hash[:supplement_date_range]
-          month_start = range[:supp_month_start]&.to_s
-          year_start = range[:supp_year_start]&.to_s
-          month_end = range[:supp_month_end]&.to_s
-          year_end = range[:supp_year_end]&.to_s
-
-          supplement.supplement_date_range_start = "#{month_start}#{year_start}" if month_start && year_start
-          supplement.supplement_date_range_end = "#{month_end}#{year_end}" if month_end && year_end
-
-          return supplement
-        end
-
-        # Build base identifier from base_portion (if present)
-        # If not present (because it was merged during parsing), use first_number
-        if parsed_hash[:base_portion]
-          # Extract the actual number value from base_portion hash
-          # base_portion can be: {:simple_number=>"118"}, {:base_number=>"145", :revision_letter=>"r", :revision_number=>"11"}, etc.
-          base_portion = parsed_hash[:base_portion]
-          base_number = if base_portion.is_a?(Hash)
-                          # Extract the value from whichever key is present
-                          base_portion[:simple_number] || base_portion[:base_number]
-                        else
-                          base_portion
-                        end
-
-          # Check for letter suffix in base_portion (e.g., "378G")
-          letter_suffix = nil
-          if base_portion.is_a?(Hash) && base_portion[:letter_suffix]
-            letter_suffix = base_portion[:letter_suffix].to_s.upcase
-          end
-
-          # Extract publisher from circ_series if present
-          publisher_value = nil
-          if parsed_hash[:circ_series].is_a?(Hash) && parsed_hash[:circ_series][:series]
-            series_str = parsed_hash[:circ_series][:series].to_s
-            # Extract publisher from series (e.g., "NBS LCIRC" -> "NBS")
-            publisher_value = series_str.split.first if series_str.include?(" ")
-          end
-
-          # Check if base_portion has revision (for patterns like "145r11/1925")
-          has_revision = base_portion.is_a?(Hash) && base_portion[:revision_letter] && base_portion[:revision_number]
-
-          # NEW: Check if base_portion has edition_number (for patterns like "101e2")
-          has_edition = base_portion.is_a?(Hash) && base_portion[:edition_number]
-
-          # Include letter suffix in base_number if present
-          # Also include edition_number if present (for "101e2" pattern)
-          base_number_with_suffix = base_number.to_s
-          if letter_suffix
-            base_number_with_suffix += letter_suffix
-          end
-          if has_edition
-            base_number_with_suffix += "e#{base_portion[:edition_number]}"
-          end
-
-          # Reconstruct parse hash for base identifier
-          base_hash = {
-            series: series_value,
-            first_number: base_number_with_suffix,
-            parsed_format: parsed_hash[:parsed_format],
-          }
-          base_hash[:publisher] = publisher_value if publisher_value
-
-          # NEW: Add edition_number to base_hash for patterns like "101e2"
-          # This will be processed by the normal build() logic to create Edition component
-          if has_edition
-            # Create edition_e hash that will be converted to Edition with type="e"
-            base_hash[:edition_e] =
-              { edition_id: base_portion[:edition_number] }
-          end
-
-          # Recursively build base identifier
-          # This will go through normal build() process which extracts edition from "101e2"
-          supplement.base = @builder.build(base_hash)
-
-          # NEW: Handle revision + implicit supplement pattern (e.g., "145r11/1925")
-          # Create update format: "Upd1-{year}{revision_number}"
-          if has_revision && parsed_hash[:implicit_supplement].is_a?(Hash)
-            revision_number = base_portion[:revision_number].to_s
-            supplement_year = parsed_hash[:implicit_supplement][:implicit_supplement_year].to_s
-
-            # Create Update component for revision+supplement pattern.
-            # Renders "/Upd1-{year}{revision_number}" via Update#to_s(:short).
-            # The year+revision are fused into the year field (month left nil) so
-            # the revision is NOT zero-padded (e.g. "145r6/1925" -> "Upd1-19256",
-            # not "192506"). Must be a Components::Update (not a String) so
-            # :update serializes.
-            supplement.update = Components::Update.new(
-              number: "1", year: "#{supplement_year}#{revision_number}",
-              prefix: "slash"
-            )
-            supplement.implicit_supplement = true # Mark as implicit supplement for rendering
-          end
-        elsif parsed_hash[:first_number]
-          # base_portion was lost during merge, use first_number to build base identifier
-          base_hash = {
-            publisher: parsed_hash[:publisher],
-            series: series_value || parsed_hash[:series],
-            first_number: parsed_hash[:first_number],
-            parsed_format: parsed_hash[:parsed_format],
-          }
-
-          # Recursively build base identifier
-          supplement.base = @builder.build(base_hash)
-        end
-
-        # Build supplement edition from captured data
-        if parsed_hash[:supplement_month_year]
-          # Parse month+year format like "Jan1924"
-          month_year = parsed_hash[:supplement_month_year].to_s
-          supplement.edition = Components::Edition.new(type: "s",
-                                                       id: month_year)
-        elsif parsed_hash[:supplement_year]
-          # Just year: 1924
-          supplement.edition = Components::Edition.new(type: "s",
-                                                       id: parsed_hash[:supplement_year].to_s)
-        elsif parsed_hash[:supplement_slash_year].is_a?(Hash)
-          # NEW: Handle supplement_slash_year pattern (e.g., "sup12/1926", "sup1/1927")
-          # V1 format: "Upd1-192612" where "1" is fixed and "192612" is year+number concatenated
-          # Single digit numbers are zero-padded: "sup1/1927" -> "Upd1-192701"
-          supp_hash = parsed_hash[:supplement_slash_year]
-          supp_number = supp_hash[:supp_number]&.to_s
-          supp_year = supp_hash[:supp_year]&.to_s
-
-          # Pad supplement number to 2 digits for single-digit numbers
-          supp_number_padded = supp_number.rjust(2, "0")
-
-          # Create Update component for supplement (V1 compatibility uses Update for supplements).
-          # Renders "/Upd1-{year}{padded_number}" via Update#to_s(:short). The
-          # year and already-padded number are fused into the year field (month
-          # left nil) so rendering reproduces the V1 string exactly. Must be a
-          # Components::Update (not a String) so :update serializes.
-          supplement.update = Components::Update.new(
-            number: "1", year: "#{supp_year}#{supp_number_padded}",
-            prefix: "slash"
-          )
-        elsif parsed_hash[:supplement_empty]
-          # Empty supplement - no edition
-          # supplement.edition remains nil
-        end
-
-        supplement
-      end
-    end
-  end
-end

data/lib/pubid/nist/identifier.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-# The NIST flavor base class is Pubid::Nist::Identifier — a real
-# Pubid::Identifier subclass that every concrete NIST identifier descends from,
-# so `id.is_a?(Pubid::Nist::Identifier)` and the shared polymorphic `from_hash`
-# work natively (no facade needed). Its full body and `.parse` are defined in identifiers/base.rb to keep
-# that large body in one place; this file just ensures it is loaded when a
-# consumer references Pubid::Nist::Identifier directly.

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    module Identifiers
-      # NIST date-style identifier with no series.
-      # Examples:
-      # - "NIST 2022-04-15 001" (short) / "NIST.2022-04-15.001" (mr/doi)
-      #   DOI 10.6028/NIST.2022-04-15.001
-      class DatedDocument < Identifier
-        # Empty so the bare "NIST" abbr never shadows a series lookup; the
-        # Router guard (parsed_hash[:dated_date] && :dated_seq) is the dispatch path.
-        TYPED_STAGES = [].freeze
-
-        attribute :date_year, :string
-        attribute :date_month, :string
-        attribute :date_day, :string
-        attribute :dated_seq, :string
-
-        class << self
-          def typed_stages
-            TYPED_STAGES
-          end
-
-          def type
-            { key: :dated, title: "NIST Dated Document" }
-          end
-        end
-
-        def to_short_style
-          "#{publisher || 'NIST'} #{date_year}-#{date_month}-#{date_day} #{dated_seq}"
-        end
-
-        def to_mr_style
-          "#{publisher || 'NIST'}.#{date_year}-#{date_month}-#{date_day}.#{dated_seq}"
-        end
-
-        # No series/number to expand; non-default formats fall back to short.
-        def to_full_style
-          to_short_style
-        end
-
-        def to_abbreviated_style
-          to_short_style
-        end
-      end
-    end
-  end
-end

data/lib/pubid/nist/parser_output_normalizer.rb

@@ -1,233 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    # Normalizes the raw hash produced by the NIST parser before the Builder
-    # constructs the identifier object.
-    #
-    # The parser emits a flat hash with keys like :first_number, :second_number,
-    # :edition_dash_year, :update_prefix, etc. Many of those keys are
-    # *incompatible shapes* — e.g. parser captures a year as :edition_dash_year
-    # when it is actually a second_number, or a letter+digits suffix lives
-    # inside :first_number when it should become a Part component.
-    #
-    # Each `normalize_*` method here performs one such shape correction,
-    # mutating the hash in place. The Normalizer is intentionally
-    # *side-effect-only*: it never reads from the Builder, the Caster, or the
-    # identifier classes, so it can be tested in isolation.
-    #
-    # Pre-processing blocks that need to surface extracted components to the
-    # Builder (e.g. letter-suffix Part components, embedded-edition objects)
-    # remain in Builder#build because they create local variables that flow
-    # into the construction phase. All other normalizations live here.
-    class ParserOutputNormalizer
-      # Range of years we treat as "looks like a calendar year" when
-      # disambiguating :edition_dash_year from :second_number.
-      VALID_YEAR_RANGE = (1901..2026).freeze
-
-      # Series that treat :edition_dash_year as a year-only edition when the
-      # dash year falls in VALID_YEAR_RANGE. For other series with a dash-year
-      # in this range, the dash-year is interpreted differently (or kept as
-      # a compound number, depending on the branch).
-      DASH_YEAR_AS_EDITION_SERIES = %w[HB CS FIPS].freeze
-
-      # Apply all normalizations to the parsed hash in the correct order.
-      # @param parsed_hash [Hash] parser output (mutated in place)
-      # @return [Hash] the same hash, normalized
-      def normalize(parsed_hash)
-        merge_edition_e_into_update(parsed_hash)
-        extract_embedded_edition_with_year(parsed_hash)
-        extract_embedded_edition_without_dash_year(parsed_hash)
-        split_second_number_edition_year(parsed_hash)
-        split_fips_month_year_after_part(parsed_hash)
-        disambiguate_ir_compound_vs_edition(parsed_hash)
-        disambiguate_dash_year(parsed_hash)
-        parsed_hash
-      end
-
-      private
-
-      # Pattern: "800-53r4/Upd3-2015"
-      # Parser captures "-2015" as :edition_e but it belongs on :update.
-      def merge_edition_e_into_update(parsed_hash)
-        return unless parsed_hash[:update_prefix] && parsed_hash[:update] && parsed_hash[:edition_e]
-
-        edition_id = parsed_hash[:edition_e][:edition_id]
-        parsed_hash[:update] = parsed_hash[:update].merge(update_year: edition_id)
-        parsed_hash.delete(:edition_e)
-      end
-
-      # Pattern: "44e2-1955"
-      # first_number="44e2", edition_dash_year="1955"
-      # Result: first_number="44", edition(type:"e", id:"2", additional_text:"1955")
-      def extract_embedded_edition_with_year(parsed_hash)
-        return unless parsed_hash[:first_number]&.to_s&.match?(/^[0-9]+[a-zA-Z]\d+$/) &&
-                      parsed_hash[:edition_dash_year]
-
-        number_str = parsed_hash[:first_number].to_s
-        return unless (match_data = number_str.match(/^(\d+)([a-zA-Z])(\d+)$/))
-
-        base_number, edition_type, edition_id = match_data[1], match_data[2].downcase, match_data[3]
-
-        parsed_hash[:first_number] = Components::Code.new(value: base_number)
-        parsed_hash[:edition_with_year] = Components::Edition.new(
-          type: edition_type,
-          id: edition_id,
-          additional_text: parsed_hash[:edition_dash_year][:dash_year],
-        )
-        parsed_hash.delete(:edition_dash_year)
-      end
-
-      # Pattern: "8115r1" (with no edition_dash_year)
-      # first_number="8115r1", no second_number
-      # Result: first_number="8115", edition(type:"r", id:"1")
-      #
-      # CRITICAL: Only when no :second_number is present, otherwise the
-      # compound-number logic in the Builder handles the pattern.
-      def extract_embedded_edition_without_dash_year(parsed_hash)
-        return if parsed_hash[:second_number]
-        return unless parsed_hash[:first_number]&.to_s&.match?(/^[0-9]+[a-zA-Z]\d+$/)
-        return if parsed_hash[:edition_dash_year]
-
-        number_str = parsed_hash[:first_number].to_s
-        return unless (match_data = number_str.match(/^(\d+)([a-zA-Z])(\d+)$/))
-
-        base_number, edition_type, edition_id = match_data[1], match_data[2].downcase, match_data[3]
-
-        parsed_hash[:first_number] = Components::Code.new(value: base_number)
-        parsed_hash[:edition_with_year] = Components::Edition.new(
-          type: edition_type,
-          id: edition_id,
-        )
-      end
-
-      # Pattern: "105-1-1990"
-      # Parser returns second_number_edition_year={second_number:"1", dash_year:"1990"}
-      # Result: :second_number="1", plus either :edition_from_year (HB series)
-      # or :edition_dash_year (other series) for further downstream processing.
-      def split_second_number_edition_year(parsed_hash)
-        return unless parsed_hash[:second_number_edition_year]
-
-        combined = parsed_hash[:second_number_edition_year]
-        parsed_hash[:second_number] = combined[:second_number]
-        dash_year = combined[:dash_year]
-
-        is_handbook = safely_to_s(parsed_hash[:series]) == "HB"
-        if is_handbook && dash_year.to_s.match?(/^\d{4}$/)
-          parsed_hash[:edition_from_year] = Components::Edition.new(type: "e", id: dash_year)
-        else
-          parsed_hash[:edition_dash_year] = { dash_year: dash_year }
-        end
-
-        parsed_hash.delete(:second_number_edition_year)
-      end
-
-      # Pattern: "11-1-Sep1977"
-      # Parser returns fips_month_year_after_part={second_number:"1", edition_month:"Sep", edition_year:"1977"}
-      # Result: :second_number="1", :edition_from_year(type:"e", id:"197709")
-      def split_fips_month_year_after_part(parsed_hash)
-        return unless parsed_hash[:fips_month_year_after_part]
-
-        combined = parsed_hash[:fips_month_year_after_part]
-        parsed_hash[:second_number] = combined[:second_number]
-        month_str = combined[:edition_month]
-        year_str = combined[:edition_year]
-
-        month_num = month_to_number(month_str)
-        edition_id = month_num&.positive? ? "#{year_str}#{format('%02d', month_num)}" : year_str
-
-        parsed_hash[:edition_from_year] = Components::Edition.new(type: "e", id: edition_id)
-        parsed_hash.delete(:fips_month_year_after_part)
-      end
-
-      # Pattern: "84-2946" with series=IR
-      # For IR (Interagency Report), a 2-digit first_number followed by a
-      # 4-digit dash-year is *almost* always a year-only edition (e.g.
-      # "76e1100") — except when the 4-digit number is clearly not a year
-      # (>= 2700) or there is an embedded :edition_e (compound number).
-      def disambiguate_ir_compound_vs_edition(parsed_hash)
-        return unless safely_to_s(parsed_hash[:series]) == "IR"
-        return unless parsed_hash[:first_number] && parsed_hash[:edition_dash_year]
-
-        first_num = parsed_hash[:first_number].to_s
-        dash_year = parsed_hash[:edition_dash_year][:dash_year].to_s
-        return unless first_num.match?(/^\d{2}$/) && dash_year.match?(/^\d{4}$/)
-
-        dash_year_num = dash_year.to_i
-        is_valid_year = VALID_YEAR_RANGE.cover?(dash_year_num)
-        has_embedded_edition = parsed_hash[:edition_e]
-
-        if is_valid_year && !has_embedded_edition
-          parsed_hash[:first_number] = Components::Code.new(value: first_num)
-          parsed_hash[:edition] = Components::Edition.new(type: "e", id: dash_year)
-        else
-          parsed_hash[:first_number] = Components::Code.new(value: "#{first_num}-#{dash_year}")
-        end
-        parsed_hash.delete(:edition_dash_year)
-      end
-
-      # Pattern: "250-1039" or "15-1000" or "1946-1947" (RPT)
-      # When the parser captures a :first_number plus :edition_dash_year, the
-      # dash year is interpreted differently per series:
-      # - RPT: always join into a compound (date range), regardless of year
-      # - GCR: always convert dash-year to year-only edition
-      # - IR: convert dash-year to year-only edition only if it is a valid year
-      # - HB/CS/FIPS: convert dash-year to year-only edition only if valid year
-      # - others: drop :edition_dash_year, or stash as :second_number if < 1900
-      def disambiguate_dash_year(parsed_hash)
-        return unless parsed_hash[:first_number] && parsed_hash[:edition_dash_year]
-        return if parsed_hash[:first_number].to_s.match?(/^[0-9]+[a-zA-Z]\d+$/)
-
-        dash_year = parsed_hash[:edition_dash_year][:dash_year].to_s
-        series = safely_to_s(parsed_hash[:series])
-        dash_year_num = dash_year.to_i
-        is_valid_year = VALID_YEAR_RANGE.cover?(dash_year_num)
-
-        if series == "RPT"
-          # RPT date ranges: "1946-1947" -> "1946-1947"
-          parsed_hash[:first_number] =
-            Components::Code.new(value: "#{parsed_hash[:first_number]}-#{dash_year}")
-          parsed_hash.delete(:edition_dash_year)
-        elsif series == "GCR"
-          # GCR always converts dash-year to edition
-          stash_edition_from_year(parsed_hash, dash_year)
-        elsif series == "IR" && is_valid_year
-          # IR converts valid years to edition
-          stash_edition_from_year(parsed_hash, dash_year)
-        elsif DASH_YEAR_AS_EDITION_SERIES.include?(series) && is_valid_year
-          # HB/CS/FIPS: convert dash-year to edition only if valid year
-          stash_edition_from_year(parsed_hash, dash_year)
-        elsif dash_year_num < 1900
-          # For other series, dash-year < 1900 is a second_number
-          parsed_hash[:second_number] = dash_year
-          parsed_hash.delete(:edition_dash_year)
-        end
-        # Other cases (non-HB/CS/FIPS with a valid year): leave the keys alone
-        # so downstream Builder logic can handle them.
-      end
-
-      # Convert dash-year into a year-only Edition and stash for the Builder
-      # to assign after construction.
-      def stash_edition_from_year(parsed_hash, dash_year)
-        parsed_hash[:edition_from_year] = Components::Edition.new(type: "e", id: dash_year)
-        parsed_hash.delete(:edition_dash_year)
-      end
-
-      # Safely coerce arbitrary values to strings (parsers can hand us Parslet
-      # nodes that raise on #to_s in some scenarios).
-      def safely_to_s(value)
-        value.to_s
-      rescue StandardError
-        ""
-      end
-
-      # Convert a month abbreviation or name to a 1-based month number.
-      # Returns nil when the value is not a recognizable month.
-      def month_to_number(month_str)
-        Date::ABBR_MONTHNAMES.index(month_str) ||
-          Date::MONTHNAMES.index(month_str) ||
-          month_str.to_i
-      end
-    end
-  end
-end