pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/nist/scheme.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    # Scheme class for NIST identifier registry
+    # Single Responsibility: Identifier class registry and series-to-class mapping
+    class Scheme < Pubid::Scheme
+      class << self
+        # Aggregate TYPED_STAGES from all identifier classes
+        # @return [Array<Components::TypedStage>] all typed stages
+        def typed_stages
+          @typed_stages ||= identifiers
+            .reject { |klass| klass == Identifiers::Base } # Skip Base fallback class
+            .flat_map(&:typed_stages)
+            .freeze
+        end
+
+        # Locate TypedStage by abbreviation
+        # @param abbr [String, Symbol] the type abbreviation
+        # @return [Components::TypedStage] the matching typed stage
+        # @raise [ArgumentError] if abbreviation not found
+        def locate_typed_stage_by_abbr(abbr)
+          abbr_str = abbr.to_s.upcase
+          typed_stages.find do |ts|
+            ts.abbr.any? { |a| a.to_s.upcase == abbr_str }
+          end || raise(ArgumentError, "Unknown type abbreviation: #{abbr}")
+        end
+
+        # Locate identifier class by type code
+        # @param type_code [String, Symbol] the type code
+        # @return [Class] the identifier class
+        # @raise [ArgumentError] if type code not found
+        def locate_identifier_klass_by_type_code(type_code)
+          type_str = type_code.to_s
+          identifiers
+            .reject { |klass| klass == Identifiers::Base } # Skip Base fallback class
+            .find do |klass|
+              klass.typed_stages.any? { |ts| ts.type_code.to_s == type_str }
+            end || raise(ArgumentError, "Unknown type code: #{type_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)
+          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
+          begin
+            typed_stage = locate_typed_stage_by_abbr(series)
+            type_code = typed_stage.type_code
+            locate_identifier_klass_by_type_code(type_code)
+          rescue ArgumentError
+            # Fallback to Base for unmapped series (e.g., "AMS", "VTS")
+            Identifiers::Base
+          end
+        end
+
+        # Check if parsed hash has supplement indicators
+        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
+
+        # All identifier classes
+        # @return [Array<Class>] list of all identifier classes
+        def identifiers
+          @identifiers ||= [
+            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::Base, # Fallback for unmapped series
+          ].freeze
+        end
+
+        # 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
+
+        # 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
+      end
+    end
+  end
+end

data/lib/pubid/nist/supplement_identifier.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    # Base class for NIST supplement identifiers
+    # Supplements wrap a base identifier with additional edition information
+    #
+    # Architecture follows ISO pattern:
+    # - base_identifier: The base document being supplemented
+    # - edition: Edition information for the supplement
+    #
+    # Examples:
+    # - "NBS CIRC 101e2supp" → CircularSupplement(base: "NBS CIRC 101", edition: e2)
+    # - "NBS CIRC 25supp-1924" → CircularSupplement(base: "NBS CIRC 25", edition: 1924)
+    class SupplementIdentifier < Identifiers::Base
+      attribute :base_identifier, Identifiers::Base, polymorphic: true
+
+      # Delegate publisher to base_identifier
+      def publisher
+        base_identifier&.publisher
+      end
+
+      # Delegate series to base_identifier
+      def series
+        base_identifier&.series
+      end
+
+      def to_s(format = :short)
+        # Handle date range supplements (no base identifier)
+        if 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
+
+        result = base_identifier.to_s(format)
+
+        # NEW: Handle update attribute (e.g., "Upd12-1926" for supplement patterns)
+        if 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
+          result += "sup" unless is_implicit
+          result += "/#{update}"
+          return result
+        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
+          # Smart dash logic: month=no dash, year=dash
+          result += if edition.id.match?(/^[A-Z]/)
+                      edition.id
+                    else
+                      "-#{edition.id}"
+                    end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/pubid/nist/urn_generator.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "nist"]
+
+        if identifier.series
+          series = identifier.series.to_s
+          parts << series.downcase
+        elsif (sc = maybe(:series_code))
+          parts << sc.downcase
+        else
+          parts << "sp"
+        end
+
+        identifier_parts = []
+
+        if identifier.number
+          number = identifier.number.to_s
+          identifier_parts << number
+        end
+
+        if identifier.parts&.any?
+          identifier_parts += identifier.parts.map { |p| "-#{p}" }
+        end
+
+        if identifier.edition
+          identifier_parts << identifier.edition.to_s
+        end
+
+        if identifier.volume
+          vol = identifier.volume.to_s
+          identifier_parts << vol
+        end
+
+        if identifier.part && identifier.part
+          identifier_parts << identifier.part.to_s
+        end
+
+        if identifier.volume && identifier.issue_number
+          vol_str = identifier.volume.to_s
+          issue_str = identifier.issue_number.to_s
+          identifier_parts << "#{vol_str}n#{issue_str}"
+        end
+
+        if identifier.version_component
+          identifier_parts << identifier.version_component.to_s
+        elsif identifier.version
+          identifier_parts << "ver.#{identifier.version}"
+        end
+
+        if identifier.update_component
+          identifier_parts << identifier.update_component.to_s
+        elsif identifier.update
+          identifier_parts << "-upd#{identifier.update}"
+        end
+
+        if identifier.stage
+          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 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.value_string.empty?
+          value = supp.value_string
+          identifier_parts << if value.match?(/^[A-Z]/)
+                                "supp#{value}"
+                              else
+                                "supp-#{value}"
+                              end
+        elsif supp.nil?
+          identifier_parts << "supp"
+        end
+
+        if identifier.errata
+          identifier_parts << identifier.errata
+        end
+
+        if identifier.addendum || identifier.addendum_number
+          identifier_parts << "add."
+        end
+
+        if identifier.draft_number
+          identifier_parts << "#{identifier.draft_number}pd"
+        elsif identifier.draft&.to_s&.include?("draft")
+          identifier_parts << "-draft"
+        end
+
+        if identifier.index
+          identifier_parts << "index"
+        end
+
+        if identifier.insert
+          identifier_parts << "insert"
+        end
+
+        if identifier.section
+          identifier_parts << "sec#{identifier.section}"
+        end
+
+        if identifier.appendix
+          identifier_parts << "app"
+        end
+
+        parts << identifier_parts.join(".") unless identifier_parts.empty?
+
+        if identifier.translation_component
+          trans = identifier.translation_component
+          lang = if trans&.language
+                   trans.language
+                 elsif trans.is_a?(String)
+                   trans
+                 end
+          parts << lang.downcase if lang
+        elsif identifier.translation
+          parts << identifier.translation.downcase
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/nist.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    autoload :Builder, "#{__dir__}/nist/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 :SupplementIdentifier, "#{__dir__}/nist/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/nist/urn_generator"
+
+    # Parse a NIST identifier string
+    # @param identifier [String] the identifier string to parse
+    # @return [Identifiers::Base] the parsed identifier
+    def self.parse(identifier)
+      # Use the Parser class's preprocessing method
+      # 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.build(parsed)
+    end
+
+    # Get the configuration instance
+    # @return [Configuration] the configuration instance
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+  end
+end
+
+Pubid::Registry.register(:nist, Pubid::Nist)

data/lib/pubid/oiml/builder.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    class Builder
+      # Type to identifier class mapping (MECE)
+      TYPE_CLASS_MAP = {
+        "B" => "BasicPublication",
+        "D" => "Document",
+        "E" => "ExpertReport",
+        "G" => "Guide",
+        "R" => "Recommendation",
+        "S" => "SeminarReport",
+        "V" => "Vocabulary",
+      }.freeze
+
+      def build(parsed_hash)
+        # Check for short amendment format (has amd_marker)
+        if parsed_hash[:amd_marker]
+          return build_short_amendment(parsed_hash)
+        end
+
+        # Check for supplements first (have base_identifier)
+        if parsed_hash[:base_identifier]
+          return build_supplement(parsed_hash)
+        end
+
+        # Build base document
+        build_base_document(parsed_hash)
+      end
+
+      private
+
+      def build_short_amendment(parsed_hash)
+        # Build base identifier from the code and type
+        base_hash = {
+          publisher: parsed_hash[:publisher],
+          type: parsed_hash[:type],
+        }
+
+        # Copy number/part/subpart from base_code
+        if parsed_hash[:base_code]
+          base_hash[:number] = parsed_hash[:base_code][:number]
+          if parsed_hash[:base_code][:part]
+            base_hash[:part] =
+              parsed_hash[:base_code][:part]
+          end
+          if parsed_hash[:base_code][:subpart]
+            base_hash[:subpart] =
+              parsed_hash[:base_code][:subpart]
+          end
+        end
+
+        # Build the base document
+        base_identifier = build_base_document(base_hash)
+
+        # Create amendment
+        amendment = Identifiers::Amendment.new
+        amendment.base_identifier = base_identifier
+
+        # Extract year from edition_format if present, otherwise from year directly
+        year_value = if parsed_hash[:edition_format].is_a?(Hash)
+                       parsed_hash[:edition_format][:year]
+                     else
+                       parsed_hash[:year]
+                     end
+
+        amendment.year = year_value.to_s if year_value
+        amendment.language = extract_language(parsed_hash[:language]) if parsed_hash[:language]
+
+        # Track if amendment itself was parsed with Edition format
+        if parsed_hash[:edition_format]
+          amendment.parsed_format = "long"
+        end
+
+        amendment
+      end
+
+      def build_supplement(parsed_hash)
+        # Determine supplement type
+        supplement_class = if parsed_hash[:annex_letter] || parsed_hash[:annex_marker]
+                             Identifiers::Annex
+                           else
+                             Identifiers::Amendment
+                           end
+
+        supplement = supplement_class.new
+
+        # Recursively parse base identifier
+        if parsed_hash[:base_identifier]
+          supplement.base_identifier = build(parsed_hash[:base_identifier])
+        end
+
+        # Extract year from edition_format if present, otherwise from year directly
+        year_value = if parsed_hash[:edition_format].is_a?(Hash)
+                       parsed_hash[:edition_format][:year]
+                     else
+                       parsed_hash[:year]
+                     end
+
+        # Set supplement-specific attributes
+        supplement.year = year_value.to_s if year_value
+        supplement.language = extract_language(parsed_hash[:language]) if parsed_hash[:language]
+        supplement.letter = parsed_hash[:annex_letter].to_s if parsed_hash[:annex_letter]
+
+        # Track if supplement itself was parsed with Edition format
+        if parsed_hash[:edition_format]
+          supplement.parsed_format = "long"
+        end
+
+        supplement
+      end
+
+      def build_base_document(parsed_hash)
+        # Determine identifier class from type
+        type = parsed_hash[:type].to_s
+        class_name = TYPE_CLASS_MAP[type] || "Recommendation" # Default to R
+        identifier_class = Identifiers.const_get(class_name)
+
+        identifier = identifier_class.new
+
+        # Handle code (number-part-subpart) specially
+        if parsed_hash[:number] || parsed_hash[:part] || parsed_hash[:subpart]
+          code_attrs = {}
+          if parsed_hash[:number]
+            code_attrs[:number] =
+              parsed_hash[:number].to_s
+          end
+          code_attrs[:part] = parsed_hash[:part].to_s if parsed_hash[:part]
+          if parsed_hash[:subpart]
+            code_attrs[:subpart] =
+              parsed_hash[:subpart].to_s
+          end
+          identifier.code = Components::Code.new(**code_attrs)
+        end
+
+        # Handle other attributes
+        identifier.publisher = parsed_hash[:publisher].to_s if parsed_hash[:publisher]
+
+        # Handle edition attribute
+        identifier.edition = parsed_hash[:edition].to_s if parsed_hash[:edition]
+
+        # Handle year -> date conversion
+        # Year could be in edition_format hash or directly
+        year_value = nil
+        if parsed_hash[:edition_format].is_a?(Hash)
+          year_value = parsed_hash[:edition_format][:year]
+          # Also extract edition if present
+          identifier.edition = parsed_hash[:edition_format][:edition].to_s if parsed_hash[:edition_format][:edition]
+        elsif parsed_hash[:year]
+          year_value = parsed_hash[:year]
+        end
+
+        if year_value
+          identifier.date = Pubid::Components::Date.new(year: year_value.to_s)
+        end
+
+        # Determine parsed format for round-trip fidelity
+        # If edition_format was captured, it means "Edition" text was present
+        identifier.parsed_format = if parsed_hash[:edition_format]
+                                     "long"
+                                   elsif parsed_hash[:space_before_lang]
+                                     "short_with_space"
+                                   else
+                                     "short"
+                                   end
+
+        # Handle stage attributes
+        identifier.stage = parsed_hash[:stage].to_s if parsed_hash[:stage]
+        identifier.iteration = parsed_hash[:iteration].to_s if parsed_hash[:iteration]
+
+        # Handle language
+        identifier.language = extract_language(parsed_hash[:language]) if parsed_hash[:language]
+
+        identifier
+      end
+
+      def extract_language(lang_data)
+        # Handle both direct string and nested hash from parser
+        case lang_data
+        when Hash
+          lang_data[:language].to_s
+        else
+          lang_data.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Components
+      class Code < Lutaml::Model::Serializable
+        attribute :number, :string
+        attribute :part, :string
+        attribute :subpart, :string
+
+        def to_s
+          result = number.to_s
+          result += "-#{part}" if part
+          result += "-#{subpart}" if subpart
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/components.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Components
+      autoload :Code, "#{__dir__}/components/code"
+    end
+  end
+end