pubid 1.15.21 → 2.0.0.alpha.10

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NBS Circular Identifier
+      # Examples:
+      # - "NBS CIRC 13e2revJune1908" = Circular 13, edition 2, revised June 1908
+      # - "NBS CIRC 13" = Circular 13
+      class Circular < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["CIRC", "NBS CIRC"],
+            stage_code: "published",
+            type_code: "circ",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :circ,
+            web: :circular, title: "NBS Circular", short: "CIRC" }
+          end
+        end
+
+        attribute :revised_date, :string # For revJune1908 notation
+
+        def default_publisher
+          "NBS"
+        end
+
+        def series_code
+          "CIRC"
+        end
+
+        # Convenience methods for tests that expect string values
+        def publisher
+          super&.to_s || default_publisher
+        end
+
+        # Return the stored Code, or a default Code built from series_code when
+        # unset. Must return Components::Code (not a String): the lutaml-model
+        # key-value serializer reads attributes through this public getter, so a
+        # String here breaks to_hash for the Code-typed :series attribute.
+        def series
+          super || Components::Code.new(value: series_code)
+        end
+
+        # Override to_s for CIRC-specific edition+year rendering
+        # CIRC uses dot notation: "NBS CIRC 11e2.1915" instead of "NBS CIRC 11e2-1915"
+        def to_s(format = nil)
+          # The rewrite below is `$`-anchored, so it has to run on the PLAIN
+          # string: with the flag set, `super` returns a string ending in
+          # "</span>" and the anchor no longer matches. Render plain, rewrite,
+          # then annotate.
+          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          format = format[:format] if format.is_a?(Hash)
+
+          result = super(format)
+
+          # For CIRC edition patterns with additional_text (year), render with dot notation
+          # "11e2-1915" format: edition.id="2", additional_text="1915" → render as "11e2.1915"
+          if edition && edition.type == "e" && edition.additional_text&.match?(/^\d{4}$/)
+            # Replace "11e1915" with "11e2.1915" format
+            # Pattern: number + "e" + year (where year was stored in edition.id)
+            # Need to reconstruct: number + "e" + edition.id + "." + additional_text
+            result = result.gsub(/e(\d{4})$/,
+                                 "e#{edition.id || '?'}.#{edition.additional_text}")
+          end
+
+          annotate_plain_render(result, annotated: annotated)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NBS Circular Supplement Identifier
+      # Wraps a base Circular identifier with supplement information
+      #
+      # Examples:
+      # - "NBS CIRC 101e2supp" → CircularSupplement(base: Circular(101, e2))
+      # - "NBS CIRC 25supp-1924" → CircularSupplement(base: Circular(25), edition: 1924)
+      # - "NBS CIRC suppJun1925-Jun1926" → CircularSupplement(edition with date range)
+      class CircularSupplement < SupplementIdentifier
+        # NOTE: CircularSupplement uses same TYPED_STAGES as Circular
+        # It's a variant edition pattern, not a separate series type
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["CIRC", "NBS CIRC"],
+            stage_code: "published",
+            type_code: "circ",
+          ),
+        ].freeze
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :circ_supp,
+            web: :circular_supplement, title: "NBS Circular Supplement", short: "CIRC" }
+          end
+        end
+
+        attribute :supplement_date_range_start, :string  # Jun1925
+        attribute :supplement_date_range_end, :string    # Jun1926
+        attribute :implicit_supplement, :boolean # true for implicit supplements (e.g., "145r11/1925")
+
+        def to_s(format = :short)
+          # A caller passing `annotated:` reaches this positional parameter as a
+          # Hash. Normalise it away before `super`, so the annotation is applied
+          # once, here, and covers the date-range branch too — that branch
+          # returns a hand-composed string and never reached `super` at all.
+          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          format = format[:format] || :short if format.is_a?(Hash)
+
+          # Handle date range supplements (no base identifier)
+          result = if supplement_date_range_start && supplement_date_range_end
+                     "NBS CIRC sup#{supplement_date_range_start}-#{supplement_date_range_end}"
+                   else
+                     # Use parent's rendering for base + supplement
+                     super(format)
+                   end
+
+          annotate_plain_render(result, annotated: annotated)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# 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 < Identifier
+        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,
+            web: :commercial_standard, 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,58 @@
+# 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 < Identifier
+        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,
+            web: :commercial_standard_emergency, title: "NBS Commercial Standard Emergency",
+              short: "CS-E" }
+          end
+        end
+
+        def series_code
+          "CS-E"
+        end
+
+        public
+
+        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) plus any other component the
+          # parser attached (volume, supplement, version, ...).
+          result += append_short_components
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# 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 < Identifier
+        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,
+            web: :commercial_standards_monthly, title: "Commercial Standards Monthly", short: "CSM" }
+          end
+        end
+
+        def publisher
+          "NBS"
+        end
+
+        # Always the normalized "CSM" code, regardless of the parsed series
+        # (CS vNnN variants are routed here and stored with series "CS", but
+        # must still render/serialize as CSM). Returns a Components::Code (not a
+        # bare String): the lutaml-model key-value serializer reads attributes
+        # through this public getter, so a String breaks to_hash for the
+        # Code-typed :series attribute.
+        def series
+          Components::Code.new(value: "CSM")
+        end
+
+        def to_s(format = nil)
+          # A caller passing `annotated:` reaches this positional parameter as
+          # a Hash — Ruby converts keywords for a method that accepts none.
+          # The same idiom `Identifiers::Base#to_s` uses. This renderer
+          # ignores `format`, so only the flag is read.
+          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+
+          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
+
+          annotate_plain_render(result, annotated: annotated)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# 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 < Identifier
+        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,
+            web: :crpl_report, 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(value: num_value)
+        end
+
+        def to_s(format = nil)
+          # A caller passing `annotated:` reaches this positional parameter as
+          # a Hash — Ruby converts keywords for a method that accepts none.
+          # The same idiom `Identifiers::Base#to_s` uses. This renderer
+          # ignores `format`, so only the flag is read.
+          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+
+          # 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
+
+          # Append the shared component tail (part, supplement, edition,
+          # index, section, ...) so distinct CRPL reports do not collide.
+          # range_notation is CRPL-specific and always trails the identifier.
+          result += append_short_components
+
+          result += range_notation if range_notation
+          annotate_plain_render(result, annotated: annotated)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    module Identifiers
+      # NIST date-style identifier with no series.
+      # Examples:
+      # - "NIST 2022-04-15 001" (short) / "NIST.2022-04-15.001" (mr/doi)
+      #   DOI 10.6028/NIST.2022-04-15.001
+      class DatedDocument < Identifier
+        # Empty so the bare "NIST" abbr never shadows a series lookup; the
+        # Router guard (parsed_hash[:dated_date] && :dated_seq) is the dispatch path.
+        TYPED_STAGES = [].freeze
+
+        attribute :date_year, :string
+        attribute :date_month, :string
+        attribute :date_day, :string
+        attribute :dated_seq, :string
+
+        class << self
+          def typed_stages
+            TYPED_STAGES
+          end
+
+          def type
+            { key: :dated, title: "NIST Dated Document" }
+          end
+        end
+
+        def to_short_style
+          "#{publisher || 'NIST'} #{date_year}-#{date_month}-#{date_day} #{dated_seq}"
+        end
+
+        def to_mr_style
+          "#{publisher || 'NIST'}.#{date_year}-#{date_month}-#{date_day}.#{dated_seq}"
+        end
+
+        # No series/number to expand; non-default formats fall back to short.
+        def to_full_style
+          to_short_style
+        end
+
+        def to_abbreviated_style
+          to_short_style
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# 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 < Identifier
+        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,
+            web: :federal_information_processing_standards, 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
+          result += ".#{number}" if number
+
+          # FIPS uses dash notation for parts; render here and skip the generic
+          # part rendering in the shared tail (which appends volume, edition,
+          # supplement, version, update, etc.).
+          result += "-#{part.value}" if part.is_a?(Components::Part)
+          result += parts.map { |p| "-#{p}" }.join if parts&.any?
+
+          result += append_mr_components(skip_part: true)
+
+          result
+        end
+
+        public
+
+        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),
+          # so render the part here and skip the generic part rendering in the
+          # shared tail. The tail still appends volume, edition, version,
+          # supplement, update, etc. — components FIPS previously dropped.
+          if part.is_a?(Components::Part)
+            result += "-#{part.value}"
+          end
+
+          result += append_short_components(skip_part: true)
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# 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 < Identifier
+        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,
+            web: :grant_contractor_report, 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,58 @@
+# 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 < Identifier
+        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,
+            web: :handbook, 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)
+          # The rewrite below is `$`-anchored, so it has to run on the PLAIN
+          # string: with the flag set, `super` returns a string ending in
+          # "</span>" and the anchor no longer matches. Render plain, rewrite,
+          # then annotate.
+          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          format = format[:format] if format.is_a?(Hash)
+
+          # Use the base to_s method first
+          result = super(format)
+
+          # 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
+
+          annotate_plain_render(result, annotated: annotated)
+        end
+      end
+    end
+  end
+end