pubid 1.15.19 → 2.0.0.pre.alpha.2

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NBS/NIST CS (Commercial Standard)
+      # Distinct from CS-E (emergency) and CSM (monthly)
+      # Examples:
+      # - "NBS CS 102" - Basic commercial standard
+      # - "NBS CS 102E-42" - With letter suffix and number
+      # - "CS 190-58" - With year
+      class CommercialStandard < Base
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["CS", "NBS CS"],
+            stage_code: "published",
+            type_code: "cs",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :cs, title: "Commercial Standard", short: "CS" }
+          end
+        end
+
+        def default_publisher
+          "NBS"
+        end
+
+        def series_code
+          "CS"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NBS Commercial Standard (Emergency) Identifier
+      # Format: NBS CS eNNN-YY where NNN is edition number, YY is 2-digit year
+      # Example: "NBS CS e104-43" = Commercial Standard Emergency edition 104, year 1943
+      class CommercialStandardEmergency < Base
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["CS-E", "NBS CS-E"],
+            stage_code: "published",
+            type_code: "cse",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :cse, title: "NBS Commercial Standard Emergency",
+              short: "CS-E" }
+          end
+        end
+
+        def series_code
+          "CS-E"
+        end
+
+        private
+
+        def to_short_style
+          result = ""
+
+          # Publisher
+          effective_publisher = publisher ? publisher.to_s : "NBS"
+          result += effective_publisher
+
+          # Series as CS-E
+          result += " CS-E"
+
+          # Number (already extracted from e104 → 104 in builder)
+          result += " #{number.value}" if number
+
+          # Edition (e1943 for e104-43 pattern)
+          result += edition.to_s if edition
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NBS Commercial Standards Monthly Identifier
+      # Format: NBS CSM N where N is simple number
+      # Example: "NBS CSM 1", "NBS CSM 40"
+      class CommercialStandardsMonthly < Base
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["CSM", "NBS CSM"],
+            stage_code: "published",
+            type_code: "csm",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :csm, title: "Commercial Standards Monthly", short: "CSM" }
+          end
+        end
+
+        def publisher
+          "NBS"
+        end
+
+        def series
+          "CSM"
+        end
+
+        def to_s
+          result = "#{publisher} #{series}"
+
+          # Proper Volume and Part components
+          if volume && part
+            result += " #{volume}#{part.to_s(:n_notation)}"
+          # Legacy: Code-based number (fallback)
+          elsif number
+            result += " #{number}"
+          # Legacy: Handle old volume+issue_number format
+          elsif volume && issue_number
+            vol_str = volume.is_a?(Pubid::Nist::Components::Volume) ? volume.to_s : "v#{volume}"
+            result += " #{vol_str}n#{issue_number.number}"
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NBS CRPL (Central Radio Propagation Laboratory) Report Identifier
+      # Examples:
+      # - "NBS CRPL 1-2_3-1" = Reports 1-2 and 3-1 jointly
+      # - "NBS CRPL 4-m-5" = Report 4, month m, issue 5
+      # - "NBS CRPL c4-4" = Report c4, issue 4
+      class CrplReport < Base
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["CRPL", "NBS CRPL", "CRPL-F-B", "CRPL-F-A", "NBS CRPL-F-B",
+                   "NBS CRPL-F-A"],
+            stage_code: "published",
+            type_code: "crpl",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :crpl, title: "NBS CRPL Report", short: "CRPL" }
+          end
+        end
+
+        attribute :range_notation, :string # For underscore ranges like "1-2_3-1"
+        attribute :prefix, :string # For "c" or "m" prefixes
+
+        def default_publisher
+          "NBS"
+        end
+
+        def series_code
+          "CRPL"
+        end
+
+        # Return normalized number value for tests
+        # - c4-4 → 4-4 (remove 'c' prefix)
+        # - 4-m-5 → 4-M-5 (uppercase 'm')
+        def normalized_number
+          return nil unless number
+
+          num_value = number.value.to_s
+
+          # Pattern: c4-4 → 4-4 (hide 'c' prefix)
+          case num_value
+          when /^c(\d+.*)$/
+            num_value = $1
+          # Pattern: 4-m-5 → 4-M-5 (uppercase 'm')
+          when /-m-/
+            num_value = num_value.gsub("-m-", "-M-")
+          # Pattern: m-5 → M-5 (uppercase 'm' at start)
+          when /^m-/
+            num_value = num_value.gsub(/^m-/, "M-")
+          end
+
+          num_value
+        end
+
+        # Override number to return normalized value
+        # Tests expect number.value to be normalized (c4-4 → 4-4, 4-m-5 → 4-M-5)
+        def number
+          num = super
+          return num unless num
+
+          num_value = num.value.to_s
+
+          # Pattern: c4-4 → 4-4 (hide 'c' prefix)
+          case num_value
+          when /^c(\d+.*)$/
+            num_value = $1
+          # Pattern: 4-m-5 → 4-M-5 (uppercase 'm')
+          when /-m-/
+            num_value = num_value.gsub("-m-", "-M-")
+          # Pattern: m-5 → M-5 (uppercase 'm' at start)
+          when /^m-/
+            num_value = num_value.gsub(/^m-/, "M-")
+          end
+
+          # Return new Code object with normalized value
+          Components::Code.new(number: num_value)
+        end
+
+        def to_s
+          # Use actual series attribute if it contains subseries (e.g., "CRPL-F-B")
+          # Otherwise use default series_code ("CRPL")
+          series_to_render = if series&.value&.include?("CRPL-F-")
+                               series.value.sub("NBS ", "") # Remove publisher prefix if present
+                             else
+                               series_code
+                             end
+
+          result = "#{default_publisher} #{series_to_render}"
+
+          if number
+            # Normalize number value for CRPL patterns
+            num_value = number.value.to_s
+
+            # Pattern: c4-4 → 4-4 (hide 'c' prefix)
+            case num_value
+            when /^c(\d+.*)$/
+              num_value = $1
+            # Pattern: 4-m-5 → 4-M-5 (uppercase 'm')
+            when /-m-/
+              num_value = num_value.gsub("-m-", "-M-")
+            # Pattern: m-5 → M-5 (uppercase 'm' at start)
+            when /^m-/
+              num_value = num_value.gsub(/^m-/, "M-")
+            end
+
+            result += " #{prefix}" if prefix
+            result += " #{num_value}"
+          end
+
+          # Add part component (pt3-1)
+          result += part.to_s if part
+
+          # Add supplement with "sup" prefix for CRPL identifiers
+          result += supplement_short
+
+          result += range_notation if range_notation
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NIST Federal Information Processing Standards (FIPS)
+      # Examples:
+      # - "FIPS 140-3" (no NIST prefix)
+      # - "NIST FIPS 140-3" (also accepted, normalizes to FIPS 140-3)
+      class FederalInformationProcessingStandards < Base
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["FIPS", "NIST FIPS"],
+            stage_code: "published",
+            type_code: "fips",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :fips, title: "Federal Information Processing Standards",
+              short: "FIPS" }
+          end
+        end
+
+        def series_code
+          "FIPS"
+        end
+
+        # FIPS identifiers default to no publisher prefix
+        def default_publisher
+          ""
+        end
+
+        # Override to_mr_style to not add "NIST" prefix for FIPS
+        def to_mr_style
+          # "FIPS.46e1977" (machine-readable with dots, no publisher prefix)
+          # Note: edition is appended directly to number without dot for FIPS
+          result = series_code
+
+          if number
+            result += ".#{number}"
+            # Append edition directly to number (no dot) for FIPS MR format
+            if edition
+              result += edition.to_s
+            end
+          end
+
+          result += parts.map { |p| "-#{p}" }.join if parts&.any?
+
+          result
+        end
+
+        private
+
+        def to_short_style
+          # FIPS format: "FIPS 14e1971" or "NIST FIPS 140-3" (preserve publisher if set)
+          result = publisher ? "#{publisher} " : ""
+          result += series_code
+
+          if number
+            # Convert dash-year patterns to edition format for FIPS
+            # Pattern: "14-1971" → "14e1971" (edition year format)
+            # But preserve dash for parts: "140-3" stays as-is
+            if number.value =~ /^(\d{1,3})-(\d{4})$/
+              # This is a number-year pattern (e.g., "14-1971")
+              # Convert to edition format: "14e1971"
+              number_part = $1
+              year_part = $2
+              result += " #{number_part}e#{year_part}"
+            else
+              result += " #{number.value}"
+            end
+          end
+
+          # FIPS uses dash notation for parts: -1, -2, -3 (not pt1, pt2, pt3)
+          if part.is_a?(Components::Part)
+            result += "-#{part.value}"
+          end
+          # Render edition for FIPS
+          # FIPS editions use "e" prefix: e1971, e198503, e19770930
+          if edition
+            result += "#{edition.type}#{edition.id}"
+          end
+
+          # Mirror Base#to_short_style update rendering — FIPS overrides
+          # to_short_style entirely, so update (e.g. /Upd2) would otherwise
+          # be dropped.
+          if update_component
+            result += update_component.to_s(:short)
+          elsif update
+            result += "-upd#{update}"
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NIST Grant/Contractor Report (GCR)
+      # Examples:
+      # - "NIST GCR 17-917-45" - Basic 3-part number
+      # - "NIST GCR 21-917-48v3B" - With volume and letter suffix
+      class GrantContractorReport < Base
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["GCR", "NIST GCR"],
+            stage_code: "published",
+            type_code: "gcr",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :gcr, title: "NIST Grant/Contractor Report", short: "GCR" }
+          end
+        end
+
+        def series_code
+          "GCR"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NIST Handbook (HB)
+      # Examples:
+      # - "NIST HB 130" = Handbook 130
+      # - "NBS HB 133" = NBS Handbook 133
+      class Handbook < Base
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["HB", "NIST HB", "NBS HB"],
+            stage_code: "published",
+            type_code: "hb",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :hb, title: "NIST Handbook", short: "HB" }
+          end
+        end
+
+        def series_code
+          "HB"
+        end
+
+        # Override to_s to handle edition+year pattern with dash instead of dot
+        # Pattern: "44e2-1955" (dash separator) not "44e2.1955" (dot separator)
+        def to_s(format = nil)
+          # Use the base to_s method first
+          result = super
+
+          # If edition has additional_text (year), replace dot with dash
+          if edition&.additional_text && !edition.additional_text.empty?
+            result = result.gsub(/#{Regexp.escape(edition.type)}#{Regexp.escape(edition.id)}\.#{Regexp.escape(edition.additional_text)}/,
+                                 "#{edition.type}#{edition.id}-#{edition.additional_text}")
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NIST Interagency Report (IR) / NISTIR
+      # Examples:
+      # - "NIST IR 8115" = Interagency Report 8115
+      # - "NIST IR 8115r1" = Interagency Report 8115 revision 1
+      # - "NBS IR 73-197" = NBS Interagency Report 73-197
+      class InteragencyReport < Base
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["IR", "NIST IR", "NBS IR"],
+            stage_code: "published",
+            type_code: "ir",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :ir, title: "NIST Interagency Report", short: "IR" }
+          end
+        end
+
+        def series_code
+          "IR"
+        end
+
+        # Override to_s to normalize MR input to short format by default
+        # But allow explicit format requests (e.g., format: :mr)
+        # @param format [Symbol, Hash, nil] output format
+        # @return [String] formatted identifier
+        def to_s(format = nil)
+          # Handle both keyword argument (hash) and positional argument (symbol/string)
+          effective_format = if format.is_a?(Hash)
+                               format[:format]
+                             else
+                               format
+                             end
+
+          # If explicit format is specified, use it. Otherwise, default to short.
+          if effective_format.nil?
+            super(:short)
+          else
+            super(effective_format)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NBS LC (Letter Circular)
+      # Examples:
+      # - "NBS LC 378" - Basic letter circular
+      # - "NBS LCIRC 378g" - With LCIRC variant, letter suffix
+      # - "NBS LC 378G" - Letter suffix uppercase
+      # - "NBS LC 378sup12/1926" - With supplement date
+      # - "NBS LC 378r11/1925" - With revision date
+      # - "NBS LC 378(sp)" - With language code
+      class LetterCircular < Base
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["LCIRC"], # Single definition of truth
+            stage_code: "published",
+            type_code: "lc",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :lc, title: "Letter Circular", short: "LCIRC" }
+          end
+        end
+
+        def default_publisher
+          "NBS"
+        end
+
+        # series_code returns the normalized series name for rendering
+        # LCIRC normalizes to LC for standard rendering
+        def series_code
+          "LC"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NBS MP (Miscellaneous Publication) Identifier
+      # Examples:
+      # - "NBS MP 39e1" - Edition with "e" notation
+      # - "NBS MP 260e1965" - Edition with year as edition ID
+      # NOTE: Parenthetical edition format (e.g., "39(1)") does NOT exist for MP identifiers
+      class MiscellaneousPublication < Base
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["MP", "NBS MP"],
+            stage_code: "published",
+            type_code: "mp",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :mp, title: "Miscellaneous Publication", short: "MP" }
+          end
+        end
+
+        def default_publisher
+          "NBS"
+        end
+
+        def series_code
+          "MP"
+        end
+
+        def to_s(format = :short)
+          case format
+          when :mr
+            to_mr_style
+          else
+            to_short_style
+          end
+        end
+
+        private
+
+        def to_short_style
+          result = "#{default_publisher} #{series_code}"
+          result += " #{number.value}" if number
+          result += edition.to_s if edition
+          result
+        end
+
+        def to_mr_style
+          result = "#{default_publisher}.#{series_code}"
+          result += ".#{number.value}" if number
+          result += edition.to_s if edition
+          result
+        end
+      end
+    end
+  end
+end