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

data/lib/pubid/nist/scheme.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    # Scheme class for NIST identifier registry
+    # Single Responsibility: Identifier class registry and series-to-class mapping
+    class Scheme < Pubid::Scheme
+      class << self
+        # Aggregate TYPED_STAGES from all identifier classes
+        # @return [Array<Components::TypedStage>] all typed stages
+        def typed_stages
+          @typed_stages ||= identifiers
+            .reject { |klass| klass == Identifiers::Base } # Skip Base fallback class
+            .flat_map(&:typed_stages)
+            .freeze
+        end
+
+        # Locate TypedStage by abbreviation
+        # @param abbr [String, Symbol] the type abbreviation
+        # @return [Components::TypedStage] the matching typed stage
+        # @raise [ArgumentError] if abbreviation not found
+        def locate_typed_stage_by_abbr(abbr)
+          abbr_str = abbr.to_s.upcase
+          typed_stages.find do |ts|
+            ts.abbr.any? { |a| a.to_s.upcase == abbr_str }
+          end || raise(ArgumentError, "Unknown type abbreviation: #{abbr}")
+        end
+
+        # Locate identifier class by type code
+        # @param type_code [String, Symbol] the type code
+        # @return [Class] the identifier class
+        # @raise [ArgumentError] if type code not found
+        def locate_identifier_klass_by_type_code(type_code)
+          type_str = type_code.to_s
+          identifiers
+            .reject { |klass| klass == Identifiers::Base } # Skip Base fallback class
+            .find do |klass|
+              klass.typed_stages.any? { |ts| ts.type_code.to_s == type_str }
+            end || raise(ArgumentError, "Unknown type code: #{type_code}")
+        end
+
+        # Locate identifier class by series and pattern
+        # @param parsed_hash [Hash] the parsed identifier data
+        # @return [Class] the identifier class
+        def locate_identifier_klass(parsed_hash)
+          series = parsed_hash[:series]&.to_s
+
+          # Handle compound series that include publisher (both space and dot separated)
+          if series&.start_with?("NBS ")
+            simple_series = series.sub("NBS ", "")
+
+            # Check for CIRC supplement
+            if simple_series == "CIRC"
+              if has_supplement?(parsed_hash)
+                return Identifiers::CircularSupplement
+              else
+                return Identifiers::Circular
+              end
+            end
+
+            # Use simple series for lookup (TYPED_STAGES abbr handles compound forms)
+            series = simple_series
+          elsif series&.start_with?("NBS.")
+            # Handle dot-separated patterns (e.g., "NBS.LCIRC" after preprocessing)
+            simple_series = series.sub("NBS.", "")
+
+            # Check for LCIRC supplement (dot-separated variant)
+            if simple_series == "LCIRC"
+              if has_supplement?(parsed_hash)
+                return Identifiers::CircularSupplement
+              else
+                return Identifiers::LetterCircular
+              end
+            end
+
+            # Check for CIRC supplement (dot-separated variant)
+            if simple_series == "CIRC"
+              if has_supplement?(parsed_hash)
+                return Identifiers::CircularSupplement
+              else
+                return Identifiers::Circular
+              end
+            end
+
+            # Use simple series for lookup
+            series = simple_series
+          elsif series&.start_with?("NIST.")
+            # Handle dot-separated NIST patterns
+            simple_series = series.sub("NIST.", "")
+
+            # Check for LCIRC supplement (dot-separated variant)
+            if simple_series == "LCIRC"
+              if has_supplement?(parsed_hash)
+                return Identifiers::CircularSupplement
+              else
+                return Identifiers::LetterCircular
+              end
+            end
+
+            # Use simple series for lookup
+            series = simple_series
+          end
+
+          # Check for CS variants (works for both compound "NBS CS" and simple "CS")
+          if series == "CS"
+            first_num = parsed_hash[:first_number]
+
+            # Check for CSM (monthly) - v#n# pattern inside first_number hash
+            if first_num.is_a?(Hash) && first_num[:volume_number] && first_num[:issue_number]
+              return Identifiers::CommercialStandardsMonthly
+            end
+
+            # Check for CS-E (emergency) - e-prefix with 3+ digits
+            # Handle Parslet::Slice by converting to string
+            first_num_str = first_num.is_a?(String) ? first_num.to_str : first_num.to_s
+
+            # Match e104 or e104 (when "e104-43" is split into first+second)
+            if /^e\d{3,}/.match?(first_num_str)
+              return Identifiers::CommercialStandardEmergency
+            end
+          end
+
+          # Look up using TYPED_STAGES registry (replaces series_to_class_map)
+          # This handles simple series, compound series (via abbr array), and all variants
+          begin
+            typed_stage = locate_typed_stage_by_abbr(series)
+            type_code = typed_stage.type_code
+            locate_identifier_klass_by_type_code(type_code)
+          rescue ArgumentError
+            # Fallback to Base for unmapped series (e.g., "AMS", "VTS")
+            Identifiers::Base
+          end
+        end
+
+        # Check if parsed hash has supplement indicators
+        def has_supplement?(parsed_hash)
+          parsed_hash[:supplement] ||
+            parsed_hash[:supplement_date_range] ||
+            parsed_hash[:supplement_date] ||
+            parsed_hash[:supplement_slash_year] ||
+            parsed_hash[:supplement_with_rev]
+        end
+
+        # All identifier classes
+        # @return [Array<Class>] list of all identifier classes
+        def identifiers
+          @identifiers ||= [
+            Identifiers::SpecialPublication,
+            Identifiers::FederalInformationProcessingStandards,
+            Identifiers::InteragencyReport,
+            Identifiers::Handbook,
+            Identifiers::TechnicalNote,
+            Identifiers::Circular,
+            Identifiers::CircularSupplement,
+            Identifiers::CrplReport,
+            Identifiers::Report,
+            Identifiers::Monograph,
+            Identifiers::MiscellaneousPublication,
+            Identifiers::GrantContractorReport,
+            Identifiers::Ncstar,
+            Identifiers::Owmwp,
+            Identifiers::Nsrds,
+            Identifiers::LetterCircular,
+            Identifiers::CommercialStandard,
+            Identifiers::CommercialStandardEmergency,
+            Identifiers::CommercialStandardsMonthly,
+            Identifiers::Base, # Fallback for unmapped series
+          ].freeze
+        end
+
+        # Check if series is valid
+        # @param series_code [String] the series code
+        # @return [Boolean] true if series is valid
+        def valid_series?(series_code)
+          VALID_SERIES.include?(series_code)
+        end
+
+        # All valid series codes (comprehensive list)
+        VALID_SERIES = [
+          # Major series with dedicated classes
+          "SP", "FIPS", "IR", "HB", "TN",
+          # Specialized series with dedicated classes
+          "CIRC", "CRPL", "CS", "CSM",
+          # Other series (use Base class)
+          "GCR", "AMS", "BSS", "BMS", "BH", "MONO", "MP",
+          "NCSTAR", "NSRDS", "CSWP", "VTS", "AI", "OWMWP",
+          "PC", "RPT", "SIBS", "TIBM", "TTB", "EAB",
+          "JPCRD", "JRES", "CIS", "HR", "IRPL", "IP",
+          "LC", "PS", "LCIRC",
+          # Compound series
+          "BRPD-CRPL-D", "CRPL-F-A", "CRPL-F-B", "CS-E",
+          "CSRC Building Block", "CSRC Use Case", "CSRC Book",
+          "ITL Bulletin", "NIST LC", "NIST PS", "NIST DCI",
+          "NIST Other", "NSRDS-NBS"
+        ].freeze
+      end
+    end
+  end
+end

data/lib/pubid/nist/supplement_identifier.rb

@@ -6,66 +6,65 @@ module Pubid
     # Supplements wrap a base identifier with additional edition information
     #
     # Architecture follows ISO pattern:
-    # - base: The base document being supplemented
+    # - base_identifier: The base document being supplemented
     # - edition: Edition information for the supplement
     #
     # Examples:
     # - "NBS CIRC 101e2supp" → CircularSupplement(base: "NBS CIRC 101", edition: e2)
     # - "NBS CIRC 25supp-1924" → CircularSupplement(base: "NBS CIRC 25", edition: 1924)
-    class SupplementIdentifier < Identifier
-      attribute :base, Identifier, polymorphic: true
+    class SupplementIdentifier < Identifiers::Base
+      attribute :base_identifier, Identifiers::Base, polymorphic: true
 
-      # Delegate publisher to base
+      # Delegate publisher to base_identifier
       def publisher
-        base&.publisher
+        base_identifier&.publisher
       end
 
-      # Delegate series to base
+      # Delegate series to base_identifier
       def series
-        base&.series
+        base_identifier&.series
       end
 
-      # Four exits — a date range, a base-less delegation, an update form and
-      # the canonical one — so the composition stays whole in its own method
-      # and `to_s` wraps its single result. `super` is not reachable from a
-      # private method, so it is handed in as a block.
       def to_s(format = :short)
-        annotated = format.is_a?(Hash) ? format[:annotated] : nil
-        format = format[:format] || :short if format.is_a?(Hash)
-
-        rendered = render_plain(format) { super(format) }
-
-        annotate_plain_render(rendered, annotated: annotated)
-      end
-
-      private
-
-      def render_plain(format)
         # Handle date range supplements (no base identifier)
         if supplement_date_range_start && supplement_date_range_end
-          return "NBS CIRC sup#{supplement_date_range_start}-#{supplement_date_range_end}"
+          return "NBS CIRC supp#{supplement_date_range_start}-#{supplement_date_range_end}"
         end
 
-        return yield unless base
+        return super unless base_identifier
 
-        result = base.to_s(format)
+        result = base_identifier.to_s(format)
 
         # NEW: Handle update attribute (e.g., "Upd12-1926" for supplement patterns)
         if update
-          # Implicit supplements (e.g. "145r11/1925") have no explicit marker;
-          # everything else uses the canonical single-p "sup" marker
-          # (relaton-data-nist uses "sup" across all series).
+          # Check if this is an implicit supplement (no explicit "sup/supp" marker, just update)
+          # For implicit supplements like "145r11/1925", don't add "sup" before the update
           is_implicit = self.class.attributes.key?(:implicit_supplement) && implicit_supplement == true
-          result += "sup" unless is_implicit
-          # Update#to_s emits its own leading separator (/Upd… short, -upd… mr),
-          # so append it directly instead of hardcoding the slash.
-          result += update.to_s(format)
+
+          if is_implicit
+            # Implicit supplement: "{base}/{update}" (e.g., "145/Upd1-192511")
+          else
+            # Explicit supplement: "{base}sup/{update}" (e.g., "118sup/Upd12-1926")
+            is_circ_supplement = ["LCIRC", "CIRC"].include?(series.to_s)
+            result += is_circ_supplement ? "sup" : "supp"
+          end
+          result += "/#{update}"
           return result
         end
 
-        # Canonical supplement marker is single-p "sup" across all NIST/NBS
-        # series (relaton-data-nist: SP/CIRC/HB/RPT/LC/IR/MONO/BMS all use "sup").
-        result += "sup"
+        # Original supplement rendering
+        # For LCIRC/CIRC supplements with update, use "sup"
+        # For LCIRC/CIRC supplements without update, normalize "sup" to "supp" for consistency
+        is_circ_supplement = ["LCIRC", "CIRC"].include?(series.to_s)
+        # When update is present, use "sup" (e.g., "118sup/Upd1-192612")
+        # When update is not present, use "supp" (e.g., "378Gsupp" - normalized from "sup")
+        result += if is_circ_supplement && !update
+                    "supp"
+                  elsif is_circ_supplement
+                    "sup"
+                  else
+                    "supp"
+                  end
 
         # Add edition information if present (just ID, not type prefix)
         if edition&.id

data/lib/pubid/nist/urn_generator.rb

@@ -61,24 +61,18 @@ module Pubid
           identifier_parts << identifier.stage.to_s
         end
 
-        # Supplement is now a structured component. Preserve the existing URN
-        # branching exactly: range → "supp{start}-{end}", revision → "supprev",
-        # a valued supplement → "suppX"/"supp-X" (dash unless it starts with an
-        # uppercase letter), and — quirk retained — a nil (absent) supplement
-        # still emits "supp", while a present-but-empty one emits nothing.
         supp = identifier.supplement
-        if supp&.range?
-          identifier_parts << "supp#{supp.month}#{supp.year}-#{supp.month_end}#{supp.year_end}"
-        elsif supp&.has_revision
+        if identifier.supplement_date_range_start && identifier.supplement_date_range_end
+          identifier_parts << "supp#{identifier.supplement_date_range_start}-#{identifier.supplement_date_range_end}"
+        elsif identifier.supplement_has_revision
           identifier_parts << "supprev"
-        elsif supp && !supp.value_string.empty?
-          value = supp.value_string
-          identifier_parts << if value.match?(/^[A-Z]/)
-                                "supp#{value}"
+        elsif supp && !supp.empty?
+          identifier_parts << if supp.match?(/^[A-Z]/)
+                                "supp#{supp}"
                               else
-                                "supp-#{value}"
+                                "supp-#{supp}"
                               end
-        elsif supp.nil?
+        elsif !supp
           identifier_parts << "supp"
         end
 

data/lib/pubid/nist.rb

@@ -2,86 +2,26 @@
 
 module Pubid
   module Nist
-    extend Pubid::PrefixesSupport
-
-    # Publisher prefixes (NBS/NIST) plus the "simple series" tokens that can
-    # *begin* a printed reference on their own — mirrors the parser's
-    # `publisher` and `simple_series` rules (lib/pubid/nist/parser.rb). Compound
-    # series that only appear glued to a publisher (e.g. "NBS CRPL-F-A") are
-    # excluded because they never lead a routable reference by themselves.
-    PREFIXES = %w[
-      NIST NBS
-      AMS VTS BSS BMS BH FIPS GCR HB MONO MP NCSTAR NSRDS IR SP TN CSWP
-      AI CIRC CS CSM CRPL LCIRC OWMWP PC RPT SIBS TIBM TTB EAB JPCRD JRES
-      CHIPS NWIRP RB
-    ].freeze
-
     autoload :Builder, "#{__dir__}/nist/builder"
-    autoload :Caster, "#{__dir__}/nist/caster"
-    autoload :CircularSupplementBuilder, "#{__dir__}/nist/circular_supplement_builder"
     autoload :Components, "#{__dir__}/nist/components"
     autoload :Configuration, "#{__dir__}/nist/configuration"
-    autoload :Identifier, "#{__dir__}/nist/identifiers/base"
     autoload :Identifiers, "#{__dir__}/nist/identifiers"
     autoload :Parser, "#{__dir__}/nist/parser"
-    autoload :ParserOutputNormalizer, "#{__dir__}/nist/parser_output_normalizer"
-    autoload :Preprocessor, "#{__dir__}/nist/preprocessor"
-    autoload :Renderer, "#{__dir__}/nist/renderer"
-    autoload :Router, "#{__dir__}/nist/router"
-    autoload :Series, "#{__dir__}/nist/series"
+    autoload :Scheme, "#{__dir__}/nist/scheme"
     autoload :SupplementIdentifier, "#{__dir__}/nist/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/nist/urn_generator"
-    autoload :UrnParser, "#{__dir__}/nist/urn_parser"
-
-    # Explicit registry of NIST identifier classes.
-    #
-    # NIST identifier classes use `typed_stages` (not the `self.type` Hash
-    # pattern used by CEN/JCGM/ANSI), so they cannot be auto-discovered.
-    # Identifier is the fallback for unmapped series (e.g. AMS, VTS)
-    # and must be excluded from typed-stage aggregation.
-    IDENTIFIER_TYPES = [
-      Identifiers::SpecialPublication,
-      Identifiers::FederalInformationProcessingStandards,
-      Identifiers::InteragencyReport,
-      Identifiers::Handbook,
-      Identifiers::TechnicalNote,
-      Identifiers::Circular,
-      Identifiers::CircularSupplement,
-      Identifiers::CrplReport,
-      Identifiers::Report,
-      Identifiers::Monograph,
-      Identifiers::MiscellaneousPublication,
-      Identifiers::GrantContractorReport,
-      Identifiers::Ncstar,
-      Identifiers::Owmwp,
-      Identifiers::Nsrds,
-      Identifiers::LetterCircular,
-      Identifiers::CommercialStandard,
-      Identifiers::CommercialStandardEmergency,
-      Identifiers::CommercialStandardsMonthly,
-      Identifiers::DatedDocument,
-      Identifier, # Fallback for unmapped series
-    ].freeze
 
     # Parse a NIST identifier string
     # @param identifier [String] the identifier string to parse
-    # @return [Identifier] the parsed identifier
+    # @return [Identifiers::Base] 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
-
       # Use the Parser class's preprocessing method
       # Note: We call the class method directly to ensure preprocessing is applied
       parsed = Parser.class_parse_with_preprocessing(identifier)
 
-      # Builder is stateless — lookups go through this module (Pubid::Nist)
-      builder = Builder.new
+      # Use Scheme and Builder for clean architecture
+      # ONE CLASS PER SERIES TYPE (like ISO)
+      builder = Builder.new(Scheme)
       builder.build(parsed)
     end
 
@@ -90,48 +30,6 @@ module Pubid
     def self.configuration
       @configuration ||= Configuration.new
     end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Nist::Renderer)
-
-    # All identifier classes for external consumption (export, website).
-    # Identifier is the fallback for unmapped series and is excluded
-    # from external type listings.
-    # @return [Array<Class>] identifier classes
-    def self.identifier_types
-      IDENTIFIER_TYPES.reject { |klass| klass == Identifier }
-    end
-
-    # Aggregate TYPED_STAGES from all identifier classes.
-    # Identifier is excluded because it has no typed stages and acts
-    # as the fallback for unmapped series.
-    # @return [Array<Pubid::Components::TypedStage>] all typed stages
-    def self.all_typed_stages
-      @all_typed_stages ||= identifier_types
-        .reject { |klass| klass == Identifier }
-        .flat_map(&:typed_stages)
-        .freeze
-    end
-
-    # Lookup: type code -> identifier class.
-    # Identifier is excluded so it never gets selected by type code.
-    # @param code [String, Symbol] the type code to find
-    # @return [Class, nil] the matching identifier class, or nil
-    def self.locate_type(code)
-      type_str = code.to_s
-      identifier_types
-        .reject { |klass| klass == Identifier }
-        .find { |klass| klass.typed_stages.any? { |ts| ts.type_code.to_s == type_str } }
-    end
-
-    # Lookup: abbreviation -> typed stage
-    # @param abbr [String, Symbol] the abbreviation to find
-    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
-    def self.locate_stage(abbr)
-      abbr_str = abbr.to_s.upcase
-      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
-    end
   end
 end
 

data/lib/pubid/oiml/builder.rb

@@ -6,7 +6,6 @@ module Pubid
       # Type to identifier class mapping (MECE)
       TYPE_CLASS_MAP = {
         "B" => "BasicPublication",
-        "Bulletin" => "Bulletin",
         "D" => "Document",
         "E" => "ExpertReport",
         "G" => "Guide",
@@ -21,8 +20,8 @@ module Pubid
           return build_short_amendment(parsed_hash)
         end
 
-        # Check for supplements first (have base)
-        if parsed_hash[:base]
+        # Check for supplements first (have base_identifier)
+        if parsed_hash[:base_identifier]
           return build_supplement(parsed_hash)
         end
 
@@ -53,11 +52,11 @@ module Pubid
         end
 
         # Build the base document
-        base = build_base_document(base_hash)
+        base_identifier = build_base_document(base_hash)
 
         # Create amendment
         amendment = Identifiers::Amendment.new
-        amendment.base = base
+        amendment.base_identifier = base_identifier
 
         # Extract year from edition_format if present, otherwise from year directly
         year_value = if parsed_hash[:edition_format].is_a?(Hash)
@@ -78,27 +77,18 @@ module Pubid
       end
 
       def build_supplement(parsed_hash)
-        marker = parsed_hash[:trailing_marker].to_s if parsed_hash[:trailing_marker]
-        plus_marker = parsed_hash[:plus_marker].to_s if parsed_hash[:plus_marker]
-
-        # Determine supplement type. The trailing word ("Amendment"/"Errata")
-        # selects the class; the concrete class then carries the word via
-        # #supplement_type, so only the `trailing` flag needs storing.
+        # Determine supplement type
         supplement_class = if parsed_hash[:annex_letter] || parsed_hash[:annex_marker]
                              Identifiers::Annex
-                           elsif marker == "Errata" || plus_marker == "Errata"
-                             Identifiers::Errata
                            else
                              Identifiers::Amendment
                            end
 
         supplement = supplement_class.new
-        supplement.trailing = true if marker
-        supplement.joined = true if plus_marker
 
         # Recursively parse base identifier
-        if parsed_hash[:base]
-          supplement.base = build(parsed_hash[:base])
+        if parsed_hash[:base_identifier]
+          supplement.base_identifier = build(parsed_hash[:base_identifier])
         end
 
         # Extract year from edition_format if present, otherwise from year directly
@@ -113,13 +103,6 @@ module Pubid
         supplement.language = extract_language(parsed_hash[:language]) if parsed_hash[:language]
         supplement.letter = parsed_hash[:annex_letter].to_s if parsed_hash[:annex_letter]
 
-        # Annex with no year of its own but a dated base ("R 60:2017 Annexes"):
-        # the year belongs to the base and must render glued to it.
-        if supplement.is_a?(Identifiers::Annex) && !year_value &&
-            supplement.base&.date
-          supplement.year_on_base = true
-        end
-
         # Track if supplement itself was parsed with Edition format
         if parsed_hash[:edition_format]
           supplement.parsed_format = "long"
@@ -136,8 +119,8 @@ module Pubid
 
         identifier = identifier_class.new
 
-        # Handle code (number-part-subpart-suffix) specially
-        if parsed_hash[:number] || parsed_hash[:part] || parsed_hash[:subpart] || parsed_hash[:code_suffix]
+        # Handle code (number-part-subpart) specially
+        if parsed_hash[:number] || parsed_hash[:part] || parsed_hash[:subpart]
           code_attrs = {}
           if parsed_hash[:number]
             code_attrs[:number] =
@@ -148,15 +131,7 @@ module Pubid
             code_attrs[:subpart] =
               parsed_hash[:subpart].to_s
           end
-          if parsed_hash[:code_suffix]
-            code_attrs[:suffix] = parsed_hash[:code_suffix].to_s
-            code_attrs[:space_suffix] = true if parsed_hash.key?(:space_suffix)
-          end
-          # The code fields are flat index columns on the leaf (see
-          # Identifiers::CodeNumber) — `number` is what relaton-index keys on —
-          # so they are assigned individually rather than as a Code object.
-          # Bulletin has no code columns and never reaches this branch.
-          code_attrs.each { |name, value| identifier.public_send(:"#{name}=", value) }
+          identifier.code = Components::Code.new(**code_attrs)
         end
 
         # Handle other attributes
@@ -180,26 +155,12 @@ module Pubid
           identifier.date = Pubid::Components::Date.new(year: year_value.to_s)
         end
 
-        # Bulletin-specific locator fields. The structured form captures
-        # issue/sequence directly; the citation form captures volume/issue/
-        # article_id, which we decode to the same (year, issue, sequence)
-        # tuple. Year comes from either the date rule (structured) or the
-        # article_id (citation).
-        if identifier.is_a?(Identifiers::Bulletin)
-          apply_bulletin_locator(identifier, parsed_hash)
-        end
-
         # Determine parsed format for round-trip fidelity
         # If edition_format was captured, it means "Edition" text was present
         identifier.parsed_format = if parsed_hash[:edition_format]
                                      "long"
                                    elsif parsed_hash[:space_before_lang]
                                      "short_with_space"
-                                   elsif parsed_hash[:article_id]
-                                     # Bulletin citation form — preserve on
-                                     # the identifier so default to_s gives
-                                     # back the citation string verbatim.
-                                     "citation"
                                    else
                                      "short"
                                    end
@@ -214,48 +175,6 @@ module Pubid
         identifier
       end
 
-      # Populate issue/sequence on a Bulletin from either parse shape.
-      # Structured: :issue and :sequence captured directly as zero-padded
-      # strings. Citation: :volume_roman, :issue_arabic, :article_id —
-      # decode the 8-digit article_id to recover year+issue+sequence.
-      #
-      # For the citation form, the parsed roman volume is cross-checked
-      # against the year decoded from the article_id; a mismatch warns but
-      # does not raise (the article_id is the source of truth — the roman
-      # volume is redundant display).
-      def apply_bulletin_locator(identifier, parsed_hash)
-        if parsed_hash[:article_id]
-          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.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.sequence = parsed_hash[:sequence].to_s if parsed_hash[:sequence]
-      end
-
-      # Citation form carries the volume in two places: spelled out as a
-      # roman numeral ("LXVII") and encoded in the 8-digit article_id
-      # (year+issue+sequence, where year - 1959 = volume). They should
-      # agree; if they don't, the input was malformed. Warn loudly so the
-      # user sees the discrepancy, but continue using the article_id
-      # (deterministic) rather than the roman (possibly mistyped).
-      def warn_on_volume_mismatch(identifier, parsed_volume_roman)
-        return unless parsed_volume_roman && identifier.date&.year
-
-        declared = parsed_volume_roman.to_s
-        computed = Identifiers::Bulletin.to_roman(identifier.date.year.to_i -
-                                                  Identifiers::Bulletin::BASE_YEAR_OFFSET)
-        return if declared == computed
-
-        warn "OIML Bulletin citation volume mismatch: parsed '#{declared}' " \
-             "but article_id year #{identifier.date.year} implies '#{computed}'"
-      end
-
       def extract_language(lang_data)
         # Handle both direct string and nested hash from parser
         case lang_data