pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/nist/renderer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    # Human-readable renderer for NIST identifiers.
+    #
+    # NIST supports multiple output formats (:full, :long, :abbreviated,
+    # :short, :mr). Each series class defines public style methods
+    # (to_short_style, to_mr_style, etc.) with series-specific formatting
+    # logic, so this renderer delegates to those methods rather than
+    # reimplementing them.
+    #
+    # Registered as the `:human` format in the NIST format registry and
+    # invoked via `render(format: :human, nist_format: :short)`.
+    class Renderer < ::Pubid::Renderers::Base
+      # Render the identifier in the requested NIST format.
+      #
+      # @param context [Object, nil] rendering context (unused by NIST)
+      # @param nist_format [Symbol, nil] NIST output format (:full, :long,
+      #   :abbreviated, :abbrev, :short, :mr). Defaults to :short.
+      # @return [String] formatted identifier string
+      def render(context: nil, nist_format: nil, **_opts)
+        id = @id
+
+        effective_format = nist_format || :short
+        effective_format = effective_format.to_sym if effective_format.is_a?(String)
+
+        case effective_format
+        when :full, :long
+          id.public_send(:to_full_style)
+        when :abbreviated, :abbrev
+          id.public_send(:to_abbreviated_style)
+        when :short
+          id.public_send(:to_short_style)
+        when :mr
+          id.public_send(:to_mr_style)
+        else
+          id.public_send(:to_short_style)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/nist/router.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    # Router class for NIST series-to-class mapping
+    # Single Responsibility: Resolve parsed data to the correct identifier class
+    #
+    # Delegates to Pubid::Nist.locate_stage / Pubid::Nist.locate_type
+    # for series-to-class resolution.
+    class Router
+      # 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",
+        "CHIPS", "NWIRP", "RB",
+        "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
+
+      # 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
+
+      # 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)
+        # Date-style identifier (no series) dispatches here, not via series lookup.
+        if parsed_hash[:dated_date] && parsed_hash[:dated_seq]
+          return Identifiers::DatedDocument
+        end
+
+        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
+        # Delegates to Pubid::Nist.locate_stage / Pubid::Nist.locate_type
+        # instead of an injected dependency.
+        typed_stage = Pubid::Nist.locate_stage(series)
+        if typed_stage
+          Pubid::Nist.locate_type(typed_stage.type_code) || Identifier
+        else
+          # Fallback to Base for unmapped series (e.g., "AMS", "VTS")
+          Identifier
+        end
+      end
+
+      # Check if parsed hash has supplement indicators
+      # @param parsed_hash [Hash] the parsed identifier data
+      # @return [Boolean] true if supplement indicators are present
+      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
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Series
+      # Default series behavior. All hooks return the "generic" answer so a
+      # series bug can be fixed by overriding the relevant hook in a subclass.
+      class Base
+        # Whether an uppercase letter at the end of `first_number` stays in the
+        # number (true) or is extracted as a separate Part component (false).
+        def self.preserve_letter_suffix?(parsed_hash)
+          parsed_hash[:parsed_format] == :mr
+        end
+
+        # Cast a `:letter_number` parser hash (e.g., from "800-56A").
+        # Return a cast hash, or nil to skip assignment.
+        # Default: split letter suffix into a Part component.
+        def self.cast_letter_number(value, _parsed_hash)
+          full = combine_letter_suffix(value)
+          return nil if full.nil? || full.empty?
+
+          { part: Components::Part.new(type: "", value: full.upcase) }
+        end
+
+        # Whether the edition-year cast should use modern (numeric) date format
+        # instead of preserving historical month names. FIPS uses modern.
+        def self.modern_edition_date?
+          false
+        end
+
+        # Whether `part_num` alongside `second_num` becomes a Part component
+        # (true) or is folded into the compound number (false). IR uses Part.
+        def self.part_num_as_component?
+          false
+        end
+
+        # Hook: build compound number when `letter_num` is present.
+        # Return true if the series handled it; false to fall back to default.
+        def self.handle_letter_num_compound?(_identifier,
+                                              first_num:, letter_base:,
+                                              letter_suffix:)
+          false
+        end
+
+        # Hook: post-process the identifier after compound number is assigned.
+        # Override to reverse series-specific preprocessing side effects.
+        def self.finalize_identifier(_identifier, _parsed_hash); end
+
+        # Combine `:letter_suffix` and `:letter_suffix_extra` (e.g., "U" + "r").
+        def self.combine_letter_suffix(value)
+          suffix = value[:letter_suffix].to_s.strip
+          extra = value[:letter_suffix_extra].to_s.strip
+          extra.empty? ? suffix : "#{suffix}#{extra}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Series
+      # CRPL series: letter suffix preserved in first_number.
+      # Range parsing ("2_3-1") is handled by the dedicated :crpl_range case
+      # in the caster; this class only carries the letter-suffix policy.
+      class Crpl < LetterPreserving
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Series
+      # FIPS series: letter suffix preserved; edition dates use modern format.
+      class Fips < LetterPreserving
+        def self.modern_edition_date?
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Series
+      # IR (Interagency Report) series carries the most series-specific logic:
+      #
+      # - "R" or "Ur" letter suffix becomes revision "r1" (e.g., "79-1786R").
+      # - part_num alongside second_num becomes a Part component (type "pt").
+      # - Preprocessing converts "84-2946" → "84e2946"; this class reverses
+      #   that side effect so IR keeps the compound number form.
+      class Ir < LetterPreserving
+        def self.cast_letter_number(value, _parsed_hash)
+          full = combine_letter_suffix(value)
+          return nil if full.nil? || full.empty?
+
+          if ["R", "Ur"].include?(full)
+            value[:letter_suffix] = full
+            value
+          else
+            super
+          end
+        end
+
+        def self.part_num_as_component?
+          true
+        end
+
+        def self.handle_letter_num_compound?(identifier,
+                                             first_num:, letter_base:,
+                                             letter_suffix:)
+          return false unless letter_suffix == "R"
+
+          identifier.number = Components::Code.new(
+            value: "#{first_num.value}-#{letter_base}",
+          )
+          edition_obj = Components::Edition.new(type: "r", id: "1")
+          identifier.edition = edition_obj
+          true
+        end
+
+        def self.finalize_identifier(identifier, _parsed_hash)
+          return unless identifier.number
+
+          value = identifier.number.value.to_s
+          match = value.match(/^(\d+)e(\d{4})$/)
+          return unless match
+
+          identifier.number = Components::Code.new(
+            value: "#{match[1]}-#{match[2]}",
+          )
+          identifier.edition = nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Series
+      # Series where the letter suffix on `first_number` stays in the number.
+      # Used for: RPT, MP, LC, CRPL, MONO, FIPS, IR (subclasses refine further).
+      class LetterPreserving < Base
+        def self.preserve_letter_suffix?(_parsed_hash)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Series
+      # MONO series: letter suffix preserved in first_number AND in
+      # letter_number (e.g., "NBS MONO 1A" — letter stays in the number).
+      class Mono < LetterPreserving
+        def self.cast_letter_number(value, _parsed_hash)
+          full = combine_letter_suffix(value)
+          return nil if full.nil? || full.empty?
+
+          value[:letter_suffix] = full
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Series
+      # NCSTAR series: letter suffix in letter_number stays in the number
+      # (e.g., "NIST NCSTAR 1-1A" — "1A" remains the compound suffix).
+      # Unlike MONO, first_number letter suffix is NOT preserved.
+      class Ncstar < Base
+        def self.cast_letter_number(value, _parsed_hash)
+          full = combine_letter_suffix(value)
+          return nil if full.nil? || full.empty?
+
+          value[:letter_suffix] = full
+          value
+        end
+      end
+    end
+  end
+end

data/lib/pubid/nist/series.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    # Per-series behavior policies for the NIST caster and builder.
+    #
+    # Series-specific casting decisions (letter-suffix preservation, IR revision
+    # handling, FIPS date format, etc.) live behind this interface so the
+    # caster and builder never read `parsed_hash[:series]` directly. A series
+    # bug now lives in exactly one file.
+    module Series
+      autoload :Base, "#{__dir__}/series/base"
+      autoload :LetterPreserving, "#{__dir__}/series/letter_preserving"
+      autoload :Crpl, "#{__dir__}/series/crpl"
+      autoload :Fips, "#{__dir__}/series/fips"
+      autoload :Ir, "#{__dir__}/series/ir"
+      autoload :Mono, "#{__dir__}/series/mono"
+      autoload :Ncstar, "#{__dir__}/series/ncstar"
+
+      # Order matters: longer / more-specific codes first so that substrings
+      # do not shadow them (e.g., LCIRC must be matched before IR, since
+      # "LCIRC" contains "IR").
+      REGISTRY = [
+        ["LCIRC", LetterPreserving],
+        ["FIPS",  Fips],
+        ["CRPL",  Crpl],
+        ["NCSTAR", Ncstar],
+        ["MONO",  Mono],
+        ["IR",    Ir],
+        ["MP",    LetterPreserving],
+        ["RPT",   LetterPreserving],
+        ["LC",    LetterPreserving],
+      ].freeze
+
+      def self.for(parsed_hash)
+        return Base if parsed_hash.nil?
+
+        series_code = parsed_hash[:series]
+        return Base if series_code.nil?
+
+        series_str = series_code.to_s.upcase
+        REGISTRY.each do |code, klass|
+          return klass if series_str.include?(code)
+        end
+        Base
+      end
+    end
+  end
+end

data/lib/pubid/nist/supplement_identifier.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    # Base class for NIST supplement identifiers
+    # Supplements wrap a base identifier with additional edition information
+    #
+    # Architecture follows ISO pattern:
+    # - base: 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
+
+      # Delegate publisher to base
+      def publisher
+        base&.publisher
+      end
+
+      # Delegate series to base
+      def series
+        base&.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}"
+        end
+
+        return yield unless base
+
+        result = base.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).
+          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)
+          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"
+
+        # Add edition information if present (just ID, not type prefix)
+        if edition&.id
+          # Smart dash logic: month=no dash, year=dash
+          result += if edition.id.match?(/^[A-Z]/)
+                      edition.id
+                    else
+                      "-#{edition.id}"
+                    end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/pubid/nist/urn_generator.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "nist"]
+
+        if identifier.series
+          series = identifier.series.to_s
+          parts << series.downcase
+        elsif (sc = maybe(:series_code))
+          parts << sc.downcase
+        else
+          parts << "sp"
+        end
+
+        identifier_parts = []
+
+        if identifier.number
+          number = identifier.number.to_s
+          identifier_parts << number
+        end
+
+        if identifier.parts&.any?
+          identifier_parts += identifier.parts.map { |p| "-#{p}" }
+        end
+
+        if identifier.edition
+          identifier_parts << identifier.edition.to_s
+        end
+
+        if identifier.volume
+          vol = identifier.volume.to_s
+          identifier_parts << vol
+        end
+
+        if identifier.part && identifier.part
+          identifier_parts << identifier.part.to_s
+        end
+
+        if identifier.volume && identifier.issue_number
+          vol_str = identifier.volume.to_s
+          issue_str = identifier.issue_number.to_s
+          identifier_parts << "#{vol_str}n#{issue_str}"
+        end
+
+        if identifier.version_component
+          identifier_parts << identifier.version_component.to_s
+        elsif identifier.version
+          identifier_parts << "ver.#{identifier.version}"
+        end
+
+        if identifier.update_component
+          identifier_parts << identifier.update_component.to_s
+        elsif identifier.update
+          identifier_parts << "-upd#{identifier.update}"
+        end
+
+        if identifier.stage
+          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
+          identifier_parts << "supprev"
+        elsif supp && !supp.value_string.empty?
+          value = supp.value_string
+          identifier_parts << if value.match?(/^[A-Z]/)
+                                "supp#{value}"
+                              else
+                                "supp-#{value}"
+                              end
+        elsif supp.nil?
+          identifier_parts << "supp"
+        end
+
+        if identifier.errata
+          identifier_parts << identifier.errata
+        end
+
+        if identifier.addendum || identifier.addendum_number
+          identifier_parts << "add."
+        end
+
+        if identifier.draft_number
+          identifier_parts << "#{identifier.draft_number}pd"
+        elsif identifier.draft&.to_s&.include?("draft")
+          identifier_parts << "-draft"
+        end
+
+        if identifier.index
+          identifier_parts << "index"
+        end
+
+        if identifier.insert
+          identifier_parts << "insert"
+        end
+
+        if identifier.section
+          identifier_parts << "sec#{identifier.section}"
+        end
+
+        if identifier.appendix
+          identifier_parts << "app"
+        end
+
+        parts << identifier_parts.join(".") unless identifier_parts.empty?
+
+        if identifier.translation_component
+          trans = identifier.translation_component
+          lang = if trans&.language
+                   trans.language
+                 elsif trans.is_a?(String)
+                   trans
+                 end
+          parts << lang.downcase if lang
+        elsif identifier.translation
+          parts << identifier.translation.downcase
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end