pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

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,148 @@
+# 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",
+        "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) || Identifiers::Base
+        else
+          # Fallback to Base for unmapped series (e.g., "AMS", "VTS")
+          Identifiers::Base
+        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,60 @@
+# 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
+          identifier.edition_component = edition_obj
+          identifier.revision = "r1"
+          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
+          identifier.edition_component = 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

@@ -42,7 +42,9 @@ module Pubid
           # (relaton-data-nist uses "sup" across all series).
           is_implicit = self.class.attributes.key?(:implicit_supplement) && implicit_supplement == true
           result += "sup" unless is_implicit
-          result += "/#{update}"
+          # 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
 

data/lib/pubid/nist/urn_parser.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    # Parses NIST URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:nist:{type}:{code}[.{revision}].supp
+    #
+    # type is the lowercase series (sp, fips, ir, nistcir, …). code is the
+    # alphanumeric designation. revision is `r{N}` when present. The `.supp`
+    # suffix marks the series as supplementable.
+    #
+    # Examples:
+    # - urn:nist:sp:800-53.supp        → NIST SP 800-53
+    # - urn:nist:sp:800-53.r5.supp     → NIST SP 800-53r5
+    # - urn:nist:fips:199.supp         → NIST FIPS 199
+    class UrnParser < Pubid::UrnParser::Base
+      TYPE_UPCASE = {
+        "sp" => "SP",
+        "fips" => "FIPS",
+        "ir" => "IR",
+        "nistcir" => "NISTCIR",
+        "nbs" => "NBS",
+        "nistir" => "NISTIR",
+        "csf" => "CSF",
+        "gcr" => "GCR",
+        "itl" => "ITL",
+        "jres" => "JRES",
+        "lcirc" => "LCIRC",
+        "mon" => "MONO",
+        "ms" => "MS",
+        "nsrds" => "NSRDS",
+        "tn" => "TN",
+        "wp" => "WP",
+      }.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        type_token, payload = parts
+        code, revision = parse_payload(payload)
+
+        text = "NIST #{type_label(type_token)} #{code}"
+        text += revision if revision
+        flavor_parse(text)
+      end
+
+      private
+
+      def parse_payload(payload)
+        # Strip the trailing ".supp" supplement marker.
+        stripped = payload.sub(/\.supp\z/, "")
+        # Split revision suffix from code (e.g., "800-53.r5" → ["800-53", "r5"]).
+        match = stripped.match(/^(.*)\.(r\d+)$/i)
+        return [stripped, nil] unless match
+
+        [match[1], match[2]]
+      end
+
+      def type_label(token)
+        TYPE_UPCASE.fetch(token.downcase) { token.upcase }
+      end
+    end
+  end
+end

data/lib/pubid/nist.rb

@@ -3,14 +3,51 @@
 module Pubid
   module Nist
     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/identifier"
     autoload :Identifiers, "#{__dir__}/nist/identifiers"
     autoload :Parser, "#{__dir__}/nist/parser"
-    autoload :Scheme, "#{__dir__}/nist/scheme"
+    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 :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.
+    # Identifiers::Base 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,
+      Identifiers::Base, # Fallback for unmapped series
+    ].freeze
 
     # Parse a NIST identifier string
     # @param identifier [String] the identifier string to parse
@@ -20,9 +57,8 @@ module Pubid
       # Note: We call the class method directly to ensure preprocessing is applied
       parsed = Parser.class_parse_with_preprocessing(identifier)
 
-      # Use Scheme and Builder for clean architecture
-      # ONE CLASS PER SERIES TYPE (like ISO)
-      builder = Builder.new(Scheme)
+      # Builder is stateless — lookups go through this module (Pubid::Nist)
+      builder = Builder.new
       builder.build(parsed)
     end
 
@@ -31,6 +67,48 @@ module Pubid
     def self.configuration
       @configuration ||= Configuration.new
     end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifiers::Base.format_registry.register(:human, renderer: Nist::Renderer)
+
+    # All identifier classes for external consumption (export, website).
+    # Identifiers::Base 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 == Identifiers::Base }
+    end
+
+    # Aggregate TYPED_STAGES from all identifier classes.
+    # Identifiers::Base 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 == Identifiers::Base }
+        .flat_map(&:typed_stages)
+        .freeze
+    end
+
+    # Lookup: type code -> identifier class.
+    # Identifiers::Base 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 == Identifiers::Base }
+        .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/components/code.rb

@@ -3,6 +3,12 @@
 module Pubid
   module Oiml
     module Components
+      # Code component for OIML identifiers.
+      #
+      # Stays independent of Pubid::Components::Code because OIML uses
+      # +number+ as the primary field (shared Code uses +value+). The
+      # shape is otherwise compatible; a future rename of +number+ →
+      # +value+ would let this become a subclass.
       class Code < Lutaml::Model::Serializable
         attribute :number, :string
         attribute :part, :string
@@ -14,6 +20,10 @@ module Pubid
           result += "-#{subpart}" if subpart
           result
         end
+
+        def render(context: nil)
+          to_s
+        end
       end
     end
   end