pubid 2.0.0.pre.alpha.1 → 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

@@ -28,7 +28,7 @@ module Pubid
       def to_s(format = :short)
         # Handle date range supplements (no base identifier)
         if supplement_date_range_start && supplement_date_range_end
-          return "NBS CIRC supp#{supplement_date_range_start}-#{supplement_date_range_end}"
+          return "NBS CIRC sup#{supplement_date_range_start}-#{supplement_date_range_end}"
         end
 
         return super unless base_identifier
@@ -37,34 +37,20 @@ module Pubid
 
         # NEW: Handle update attribute (e.g., "Upd12-1926" for supplement patterns)
         if update
-          # 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
+          # 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
-
-          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}"
+          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
 
-        # 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
+        # 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

data/lib/pubid/nist/urn_generator.rb

@@ -61,18 +61,24 @@ 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 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
+        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.empty?
-          identifier_parts << if supp.match?(/^[A-Z]/)
-                                "supp#{supp}"
+        elsif supp && !supp.value_string.empty?
+          value = supp.value_string
+          identifier_parts << if value.match?(/^[A-Z]/)
+                                "supp#{value}"
                               else
-                                "supp-#{supp}"
+                                "supp-#{value}"
                               end
-        elsif !supp
+        elsif supp.nil?
           identifier_parts << "supp"
         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