pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/nist/components/code.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Nist
+    module Components
+      # Code component for NIST identifiers
+      # Handles number codes like series, volume, etc.
+      class Code < Lutaml::Model::Serializable
+        attribute :number, :string
+        attribute :subpart, :string
+
+        def to_s
+          result = number.to_s
+          result += ".#{subpart}" if subpart
+          result
+        end
+
+        # Alias for compatibility
+        def value
+          to_s
+        end
+
+        # Backward compatibility: extract part from compound numbers like "140-2"
+        # Returns the part number if the value contains a dash, nil otherwise
+        def part
+          return nil unless number&.include?("-")
+
+          # Split by last dash to handle patterns like "4-4" (just number-part)
+          # and "4-M-5" (which would return "M-5" as part)
+          parts = number.to_s.split("-")
+          parts.last if parts.length > 1
+        end
+      end
+    end
+  end
+end

data/lib/pubid/nist/components/edition.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Nist
+    module Components
+      # Edition component for NIST publications per nist-pubid-spec.md
+      # Format: <edition-type><edition-id>[.<additional-text>]
+      # Types: "-" (historical), "e" (edition), "r" (revision)
+      # Edition ID can be: number ("2") OR year ("2021")
+      # Additional text: Text AFTER "rev" prefix (WITHOUT "rev")
+      #
+      # SEMANTICS:
+      # - "e" or "edition" = edition (can be number or year or month+year)
+      # - "r" or "rev" or "revision" or "v" or "version" = revision (can be number or year or month+year)
+      # - If BOTH edition AND revision in same identifier:
+      #   * Type is "e" (edition takes precedence)
+      #   * ID is the edition value
+      #   * additional_text is the revision part (WITHOUT "rev" prefix)
+      #   * Renders with DOT separator: e2.June1908
+      #
+      # Examples:
+      #   Edition.new(type: "e", id: "2").to_s                              # => "e2"
+      #   Edition.new(type: "e", id: "2", additional_text: "June1908").to_s # => "e2.June1908"
+      #   Edition.new(type: "e", id: "2", additional_text: "1908").to_s     # => "e2.1908"
+      #   Edition.new(type: "r", id: "1963").to_s                           # => "r1963"
+      #   Edition.new(type: "r", id: "5").to_s                              # => "r5"
+      #   Edition.new(type: "r", id: "5", original_prefix: " Rev. ").to_s    # => "Rev. 5"
+      class Edition < Lutaml::Model::Serializable
+        attribute :type, :string            # "-", "e", or "r"
+        attribute :id, :string              # Edition ID (number or year)
+        attribute :additional_text, :string # Text after "rev" (WITHOUT "rev" prefix)
+        attribute :original_prefix, :string # Original format prefix for preservation (e.g., " Rev. ", " rev ", " r")
+
+        # Render edition in specified format
+        # @param format [:short, :mr, :long, :abbrev] The output format
+        # @return [String] The formatted edition representation
+        def to_s(format = :short)
+          case format
+          when :short, :mr
+            build_short_format
+          when :long
+            build_long_format
+          when :abbrev
+            build_short_format
+          else
+            build_short_format
+          end
+        end
+
+        # Identity ignores original_prefix: it records how the edition was
+        # spelled in the source ("Rev. " vs "r") for round-trip rendering
+        # only. "r1" and "Rev. 1" are the same edition.
+        def ==(other)
+          return false unless other.is_a?(self.class)
+
+          type == other.type && id == other.id &&
+            additional_text == other.additional_text
+        end
+
+        alias eql? ==
+
+        def hash
+          [self.class, type, id, additional_text].hash
+        end
+
+        private
+
+        # Build short format: "e2", "e2.June1908", "e2.1908", "e2.50", "r1963", "-April1909", "r1a"
+        # If original_prefix is set, preserves original format (e.g., "Rev. 5" not "r5")
+        def build_short_format
+          # For revision type, use original prefix if available (format preservation)
+          if type == "r" && original_prefix && !original_prefix.empty?
+            # Build base format with original prefix
+            result = "#{original_prefix}#{id}"
+            # Add additional text (letter suffix) if present, preserve UPPERCASE
+            if additional_text && !additional_text.empty?
+              # For letter suffixes, append uppercase letter directly: " r5A" or "r5A"
+              if additional_text.match?(/^[A-Za-z]$/)
+                result += additional_text.upcase
+              else
+                # For other additional text (years, etc.), use dot separator
+                result += ".#{additional_text}"
+              end
+            end
+            return result
+          end
+
+          # For dash-year editions (type "e" with original_prefix "-"), preserve dash format
+          # Example: "-1979" for patterns like "NBS HB 130-1979"
+          if type == "e" && original_prefix == "-" && id.match?(/^\d{4}$/)
+            return "-#{id}"
+          end
+
+          result = "#{type}#{id}"
+
+          if additional_text && !additional_text.empty?
+            # For historical editions ("-") with month names, NO dot separator
+            # Pattern: "-April1909" not "-.April1909"
+            if type == "-" && additional_text.match?(/^[A-Z][a-z]+\d{4}$/)
+              result = "-#{additional_text}"
+            # For letter suffixes (single letter like "a", "A", "b", "B", etc.), NO dot separator
+            # Use UPPERCASE for consistency: "r5A" for SP patterns like 800-53r5a
+            elsif additional_text.match?(/^[A-Za-z]$/)
+              result += additional_text.upcase # Normalize to UPPERCASE: r5A
+            else
+              # For ALL years (2-digit or 4-digit) and month+year, use DOT separator
+              # Examples: e2.50, e2.1915, e2.June1908
+              result += ".#{additional_text}"
+            end
+          end
+
+          result
+        end
+
+        # Build long format: "Edition 2021", "Revision 5", etc.
+        def build_long_format
+          case type
+          when "e"
+            "Edition #{id}"
+          when "r"
+            "Revision #{id}"
+          when "-"
+            # Historical precedent - render as dash-number
+            "-#{id}"
+          else
+            "#{type}#{id}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/nist/components/issue_number.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Nist
+    module Components
+      # IssueNumber component for NIST identifiers
+      # Represents the issue/number designation (e.g., "No. 12" in "Vol. 6, No. 12")
+      class IssueNumber < Lutaml::Model::Serializable
+        attribute :number, :string
+
+        # Short form rendering: "n12"
+        # Long form rendering: "No. 12"
+        def to_s(format = :short)
+          case format
+          when :long, :full
+            "No. #{number}"
+          when :short, :mr
+            "n#{number}"
+          else
+            "n#{number}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/nist/components/part.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Nist
+    module Components
+      # Part component for NIST publications
+      # Format: n{NUMBER}, pt{NUMBER}, or just letter depending on type
+      #
+      # Type attribute determines rendering:
+      #   - "pt" => "pt1" (SP part notation)
+      #   - "n" => "n1" (CSM issue notation)
+      #   - "" => "A" (letter suffix - just the letter)
+      #
+      # Examples:
+      #   Part.new(type: "pt", value: "1").to_s => "pt1"
+      #   Part.new(type: "n", value: "1").to_s => "n1"
+      #   Part.new(type: "", value: "A").to_s => "A"
+      #
+      # Used in:
+      #   - CSM: Issue number (n1)
+      #   - SP: Part number (pt1)
+      #   - Letter suffixes (A, B, C, etc.)
+      class Part < Lutaml::Model::Serializable
+        attribute :type, :string   # "pt" for part notation, "n" for issue, "" for letter suffix
+        attribute :value, :string  # Part number or letter (1, 2, A, B, etc.)
+
+        # Render part with type-specific notation
+        # @param notation [Symbol, String, nil] Optional notation override
+        #   - :n_notation or "n" → use "n" prefix
+        #   - :pt_notation or "pt" → use "pt" prefix
+        #   - :letter_notation or "" → just the value (letter suffix)
+        # @return [String] The formatted part representation
+        def to_s(notation = nil)
+          # Handle symbol notation parameters
+          notation_to_use = if notation.is_a?(Symbol)
+                              case notation
+                              when :n_notation then "n"
+                              when :pt_notation then "pt"
+                              when :letter_notation then ""
+                              else notation.to_s
+                              end
+                            else
+                              notation
+                            end
+
+          # If notation explicitly provided, use it
+          if notation_to_use
+            return "#{notation_to_use}#{value}" unless notation_to_use.empty?
+
+            return value
+          end
+
+          # Otherwise use type attribute
+          case type
+          when "pt"
+            "pt#{value}"
+          when "n"
+            "n#{value}"
+          when ""
+            # Letter suffix - just the letter
+            value
+          else
+            # Fallback for nil or unknown types - default to "n" notation (CSM issue number)
+            "n#{value}"
+          end
+        end
+
+        # Alias for numeric comparison
+        def to_i
+          value.to_i
+        end
+      end
+    end
+  end
+end

data/lib/pubid/nist/components/publisher.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Nist
+    module Components
+      # Publisher component for NIST identifiers
+      # Handles NIST and NBS publishers
+      class Publisher < Lutaml::Model::Serializable
+        attribute :publisher, :string
+
+        def to_s
+          publisher
+        end
+
+        # Alias for compatibility
+        def body
+          publisher
+        end
+      end
+    end
+  end
+end

data/lib/pubid/nist/components/stage.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require "yaml"
+
+module Pubid
+  module Nist
+    module Components
+      # Stage component for NIST draft identifiers
+      # Combines id (i/f/1-9) with type (pd/wd/prd)
+      #
+      # Examples:
+      #   Stage.new(id: "i", type: "pd").to_s(:short) # => "ipd"
+      #   Stage.new(id: "f", type: "pd").to_s(:long)  # => "(Final Public Draft)"
+      class Stage < Lutaml::Model::Serializable
+        attribute :id, :string          # i, f, 1-9
+        attribute :type, :string        # pd, wd, prd
+
+        # Load stages from V1 YAML config
+        STAGES = YAML.load_file(
+          File.join(File.dirname(__FILE__),
+                    "../../../../archived-gems/pubid-nist/stages.yaml"),
+        ).freeze
+
+        # Render stage in specified format
+        # @param format [:short, :mr, :long] The output format
+        # @return [String] The formatted stage representation
+        def to_s(format = :short)
+          return "" if id.nil? || type.nil?
+
+          case format
+          when :short, :mr
+            "#{id}#{type}"
+          when :long
+            "(#{STAGES['id'][id]} #{STAGES['type'][type]})"
+          else
+            "#{id}#{type}"
+          end
+        end
+
+        # Validate stage id and type against YAML config
+        def validate!
+          unless STAGES["id"].key?(id.to_s)
+            raise ArgumentError, "Invalid stage id: #{id.inspect}"
+          end
+          unless STAGES["type"].key?(type.to_s)
+            raise ArgumentError, "Invalid stage type: #{type.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/nist/components/supplement.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Nist
+    module Components
+      # Supplement component for NIST publications
+      # Represents supplement notation with number, year, month, or revision
+      #
+      # Examples:
+      #   Supplement.new(number: "2").to_s(:short)              # => "sup2"
+      #   Supplement.new(year: "1925").to_s(:short)              # => "sup1925"
+      #   Supplement.new(number: "3", year: "1926").to_s(:short) # => "sup3/1926"
+      #   Supplement.new(month: "Jan", year: "1924").to_s(:short) # => "supJan1924"
+      #   Supplement.new(has_revision: true).to_s(:short)        # => "suprev"
+      class Supplement < Lutaml::Model::Serializable
+        attribute :number, :string           # Supplement number (e.g., "2" in "supp2")
+        attribute :year, :string             # Year (4 digits); range START year
+        attribute :month, :string            # Month abbreviation; range START month
+        # Date ranges reuse :month/:year as the start and add the end below. A
+        # present :month_end/:year_end is what marks a value as a range, so a
+        # lone month-year supplement is just a range with no end — and :year is
+        # the single field to filter on for both.
+        attribute :month_end, :string         # Date range end month
+        attribute :year_end, :string          # Date range end year
+        attribute :has_revision, :boolean, default: -> {
+          false
+        } # "supprev" pattern
+        attribute :suffix, :string # General suffix for other patterns
+
+        # Build a Supplement from the flat string the parser/builder produces
+        # ("1924" year, "Jan1924" month+year, "1" number, "A" suffix, "" bare).
+        # has_revision is supplied separately. Returns a present-but-empty
+        # Supplement for an empty/nil value so callers can distinguish a bare
+        # supplement ("sup") from no supplement (nil).
+        def self.from_raw(value, has_revision: false)
+          supp = new
+          if has_revision
+            supp.has_revision = true
+          elsif value.nil? || value.to_s.empty?
+            # bare marker: present but no isolated parts
+          elsif (m = value.to_s.match(/\A([A-Za-z]{3,9})(\d{4})\z/))
+            supp.month = m[1]
+            supp.year = m[2]
+          elsif value.to_s.match?(/\A(?:18|19|20)\d{2}\z/)
+            supp.year = value.to_s
+          elsif value.to_s.match?(/\A\d+\z/)
+            supp.number = value.to_s
+          else
+            supp.suffix = value.to_s
+          end
+          supp
+        end
+
+        # Render supplement in specified format
+        # @param format [:short, :mr, :long] The output format
+        # @return [String] The formatted supplement representation
+        def to_s(format = :short)
+          return "" if number.nil? && year.nil? && month.nil? && !has_revision &&
+            suffix.nil? && month_end.nil? && year_end.nil?
+
+          case format
+          when :short, :mr
+            build_short_format
+          when :long
+            build_long_format
+          else
+            build_short_format
+          end
+        end
+
+        # True when this supplement is a date range (start reuses month/year).
+        def range?
+          date_range?
+        end
+
+        # The text after the "sup" marker for the simple (non-range, non-rev)
+        # forms: "1924" / "Jan1924" / "1" / "A"; "" for a bare supplement. Used
+        # by URN rendering, which handles range/revision separately.
+        def value_string
+          return "" if has_revision || date_range?
+          return suffix.to_s if suffix
+          return "#{month}#{year}" if month && year
+          return "#{number}/#{year}" if number && year
+          return year.to_s if year
+          return number.to_s if number
+
+          ""
+        end
+
+        # Value equality over the isolated parts, so a structured supplement
+        # participates correctly in Identifier#== and #matches? (two supplements
+        # with the same number/year/month/range/revision are the same).
+        IDENTITY_FIELDS = %i[
+          number year month month_end year_end has_revision suffix
+        ].freeze
+
+        def ==(other)
+          return false unless other.is_a?(self.class)
+
+          IDENTITY_FIELDS.all? { |f| send(f) == other.send(f) }
+        end
+
+        alias eql? ==
+
+        def hash
+          [self.class, *IDENTITY_FIELDS.map { |f| send(f) }].hash
+        end
+
+        private
+
+        # Build short format: "sup2", "sup1925", "sup3/1926", "supJan1924", "suprev"
+        # NIST/NBS canonical short form is single-p "sup" with the suffix
+        # attached directly (relaton-data-nist uses "sup2", "sup1940", "supA").
+        def build_short_format
+          return "suprev" if has_revision
+          return "sup#{suffix}" if suffix
+          return build_date_range_format if date_range?
+          return build_month_year_format if month && year
+          return build_number_year_format if number && year
+          return build_year_format if year
+          return build_number_format if number
+
+          ""
+        end
+
+        # Build long format: "Supplement 2", "Supplement 1925", etc.
+        def build_long_format
+          return "Supplement with Revision" if has_revision
+          return "Supplement #{suffix}" if suffix
+          return build_long_date_range_format if date_range?
+          return build_long_month_year_format if month && year
+          return build_long_number_year_format if number && year
+          return build_long_year_format if year
+          return build_long_number_format if number
+
+          ""
+        end
+
+        # A range is marked by the presence of an END; START reuses month/year.
+        def date_range?
+          month && year && month_end && year_end
+        end
+
+        def build_date_range_format
+          "sup#{month}#{year}-#{month_end}#{year_end}"
+        end
+
+        def build_month_year_format
+          "sup#{month}#{year}"
+        end
+
+        def build_number_year_format
+          "sup#{number}/#{year}"
+        end
+
+        def build_year_format
+          "sup#{year}"
+        end
+
+        def build_number_format
+          "sup#{number}"
+        end
+
+        def build_long_date_range_format
+          "Supplement #{month} #{year}-#{month_end} #{year_end}"
+        end
+
+        def build_long_month_year_format
+          "Supplement #{month} #{year}"
+        end
+
+        def build_long_number_year_format
+          "Supplement #{number}/#{year}"
+        end
+
+        def build_long_year_format
+          "Supplement #{year}"
+        end
+
+        def build_long_number_format
+          "Supplement #{number}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/nist/components/translation.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Nist
+    module Components
+      # Translation component for NIST publications
+      # Uses 3-letter ISO 639-2 language codes
+      #
+      # Examples:
+      #   Translation.new(code: "spa").to_s(:short) # => " spa"
+      #   Translation.new(code: "por").to_s(:mr)    # => ".por"
+      #   Translation.new(code: "ind").to_s(:short) # => " ind"
+      class Translation < Lutaml::Model::Serializable
+        attribute :code, :string # 3-letter ISO 639-2 code: spa, por, ind, etc.
+
+        # Backward compatibility: language method returns code
+        # @return [String, nil] language code
+        def language
+          code
+        end
+
+        # Render translation in specified format
+        # @param format [:short, :mr, :long] The output format
+        # @return [String] The formatted translation representation
+        def to_s(format = :short)
+          return "" if code.nil?
+
+          case format
+          when :short, :long
+            " #{code}"
+          when :mr
+            ".#{code}"
+          else
+            " #{code}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/nist/components/update.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require "date"
+
+module Pubid
+  module Nist
+    module Components
+      # Update component for NIST publications
+      # Represents errata updates with number, year, and optional month
+      #
+      # Examples:
+      #   Update.new(number: 1, year: 2021, month: 2).to_s(:short) # => "/Upd1-202102"
+      #   Update.new(number: 3, year: 2015).to_s(:short)           # => "/Upd3-2015"
+      #   Update.new(number: 1, year: 2021, month: 2).to_s(:mr)    # => "-upd1-202102"
+      #   Update.new(number: 1, prefix: "dash").to_s(:short)       # => "-upd1" (preserves original prefix)
+      class Update < Lutaml::Model::Serializable
+        attribute :number, :string   # Update number as string
+        attribute :year, :string     # Year (4 digits as string)
+        attribute :month, :string    # Month (01-12 as string, optional)
+        attribute :prefix, :string   # Original prefix: "dash" for -upd, "slash" for /Upd (default: "slash")
+
+        # Render update in specified format
+        # @param format [:short, :mr, :long] The output format
+        # @return [String] The formatted update representation
+        def to_s(format = :short)
+          # For MR format, render -upd even without number
+          return "-upd" if format == :mr && number.nil? && year.nil?
+          # For other formats, return empty string if no number
+          return "" if number.nil?
+
+          # Use prefix attribute to determine which prefix to use
+          # If prefix is "dash", always use dash prefix regardless of format
+          # This preserves original input format (e.g., -upd vs /Upd)
+          return build_dash_format if prefix == "dash"
+
+          case format
+          when :short
+            build_short_format
+          when :mr
+            build_mr_format
+          when :long
+            build_long_format
+          else
+            build_short_format
+          end
+        end
+
+        private
+
+        # Build dash format: "-upd1-202102" or "-upd3-2015" or "-upd1" (no year)
+        # Used when original input used dash prefix (-upd) to preserve format
+        def build_dash_format
+          if year
+            year_month = build_year_month_string
+            "-upd#{number}-#{year_month}"
+          else
+            "-upd#{number}"
+          end
+        end
+
+        # Build short format: "/Upd1-202102" or "/Upd3-2015" or "/Upd1" (no year)
+        def build_short_format
+          if year
+            year_month = build_year_month_string
+            "/Upd#{number}-#{year_month}"
+          else
+            "/Upd#{number}"
+          end
+        end
+
+        # Build machine-readable format: "-upd1-202102" or "-upd3-2015" or "-upd1" (no year)
+        def build_mr_format
+          if year
+            year_month = build_year_month_string
+            "-upd#{number}-#{year_month}"
+          else
+            "-upd#{number}"
+          end
+        end
+
+        # Build long format: "Update 1-2021 February" or "Update 3-2015"
+        def build_long_format
+          return "Update #{number}" unless year
+
+          month_str = month ? " #{Date::MONTHNAMES[month.to_i]}" : ""
+          "Update #{number}-#{year}#{month_str}"
+        end
+
+        # Build year-month string: "202102" or "2015"
+        def build_year_month_string
+          return "" unless year
+
+          if month
+            "#{year}#{month.to_s.rjust(2, '0')}"
+          else
+            year.to_s
+          end
+        end
+      end
+    end
+  end
+end