pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

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

@@ -6,6 +6,13 @@ module Pubid
       # Base NIST/NBS identifier class
       # Each series type inherits from this and overrides series_code
       class Base < Pubid::Identifier
+        # Mark every NIST identifier as a member of the Pubid::Nist::Identifier
+        # facade module so `id.is_a?(Pubid::Nist::Identifier)` and
+        # `Pubid::Nist::Identifier === id` hold. The module carries only
+        # singleton methods (parse/from_hash), so this adds ancestry for the
+        # identity check without injecting any instance behavior.
+        include Pubid::Nist::Identifier
+
         # Default: no typed stages. Subclasses override as needed.
         def self.typed_stages
           []
@@ -15,7 +22,11 @@ module Pubid
         #
         # @return [String] URN representation
 
-        attribute :publisher, Components::Publisher
+        # Plain string ("NIST"/"NBS"), not a Components::Publisher wrapper: the
+        # value is a single token, so a string serializes flat
+        # (`publisher: NBS`, not `publisher: {publisher: NBS}`) and accepts the
+        # raw string the circular/supplement builders pass straight through.
+        attribute :publisher, :string
         attribute :series, Components::Code # Set by Builder from parsed data
         attribute :number, Components::Code
 
@@ -30,7 +41,13 @@ module Pubid
         attribute :translation_component, Components::Translation
         attribute :issue_number, Components::IssueNumber
         attribute :parsed_format, :string  # :mr, :short, :long, :abbrev
-        attribute :publisher_was_parsed, :boolean, default: -> { false }
+        # Whether the publisher prefix (NIST/NBS) should be rendered. Defaults
+        # to true so the common publisher-bearing id need not serialize the
+        # flag at all — the Builder only assigns it (false) for prefix-less
+        # inputs, so `to_hash` carries `publisher_was_parsed: false` only in
+        # that case and omits it otherwise. (lutaml emits a boolean iff it was
+        # explicitly assigned; an omitted key loads as this default.)
+        attribute :publisher_was_parsed, :boolean, default: -> { true }
 
         # LEGACY attributes (keep for backward compatibility during migration)
         attribute :parts, Components::Code, collection: true
@@ -50,10 +67,13 @@ module Pubid
         attribute :update_year, :string
         attribute :addendum, :string
         attribute :addendum_number, :string
-        attribute :supplement, :string
-        attribute :supplement_date_range_start, :string # For date ranges like Jan1924-Jan1926
-        attribute :supplement_date_range_end, :string
-        attribute :supplement_has_revision, :boolean, default: -> { false }
+        # Single source of truth for the supplement: a structured component with
+        # isolated parts (number / year / month / date-range / revision), so a
+        # supplement's year is queryable independently of its number. Presence
+        # (non-nil) means "is a supplement"; an all-empty component is a bare
+        # "sup" marker. Replaces the former flat :supplement string plus the
+        # separate date-range/has_revision fields.
+        attribute :supplement, Components::Supplement
         attribute :errata, :string
         attribute :index, :string
         attribute :insert, :string
@@ -84,6 +104,91 @@ module Pubid
           # See lib/pubid/nist/builder.rb lines 368-472 for compound number logic
         end
 
+        # Attributes that are build artifacts or rendering aliases, not part
+        # of an identifier's logical identity. They diverge between equally-
+        # valid spellings of the same id (e.g. long "Rev. 1" vs short "r1"):
+        #   - edition_component: redundant alias of :edition
+        #   - first_number/second_number: decomposed parts of the canonical
+        #     :number, retained from the parse for building
+        #   - parsed_format: records the input format for round-trip rendering
+        EQUALITY_IGNORED_ATTRS = %i[
+          edition_component first_number second_number parsed_format
+        ].freeze
+
+        # Logical identity comparison: equal when every attribute except the
+        # build artifacts/aliases above matches. (Edition#== already ignores
+        # its rendering-only original_prefix.)
+        def ==(other)
+          return false unless other.instance_of?(self.class)
+
+          self.class.attributes.each_key.all? do |name|
+            EQUALITY_IGNORED_ATTRS.include?(name) || public_send(name) == other.public_send(name)
+          end
+        end
+
+        alias eql? ==
+
+        def hash
+          vals = self.class.attributes.each_key.reject do |name|
+            EQUALITY_IGNORED_ATTRS.include?(name)
+          end.map { |name| public_send(name) }
+          [self.class, *vals].hash
+        end
+
+        # Wildcard / partial-identifier match. Treats +self+ as a QUERY pattern
+        # and +candidate+ as a concrete document: every ID part SET on the query
+        # must equal the candidate's, while parts left unset (nil/empty) are
+        # wildcards that match any value. So a query carrying no edition and no
+        # supplement matches that document across ALL editions, years, and
+        # supplements — the basis for "select docs by ID parts".
+        #
+        # Asymmetric (unlike ==): "NBS CIRC 25".matches?("NBS CIRC 25sup1924")
+        # is true, but not the reverse. The candidate must be the same class or
+        # a subclass so series-level identity still holds.
+        def matches?(candidate)
+          return false unless candidate.is_a?(self.class)
+
+          self.class.attributes.each_key.all? do |name|
+            next true if EQUALITY_IGNORED_ATTRS.include?(name)
+
+            query_val = public_send(name)
+            next true if query_val.nil?
+            next true if query_val.is_a?(String) && query_val.empty?
+            next true if query_val.is_a?(Array) && query_val.empty?
+
+            query_val == candidate.public_send(name)
+          end
+        end
+
+        # Return a copy with the named attributes nil'd. Overrides
+        # Pubid::Identifier#exclude because NIST's initialize is keyword-only
+        # (initialize(**attributes)) while the inherited exclude rebuilds via
+        # the positional self.class.new(attrs) form — passing a positional
+        # hash to a keyword-only initializer raises ArgumentError. Rebuild
+        # with the keyword splat instead.
+        def exclude(*args)
+          excluded_args = args.dup
+          excluded_args << :date if excluded_args.delete(:year)
+
+          attrs = self.class.attributes.each_with_object({}) do |(name, _), h|
+            h[name] = excluded_args.include?(name) ? nil : public_send(name)
+          end
+          self.class.new(**attrs)
+        end
+
+        # Short-form supplement fragment ("sup", "sup1924", "supJan1924",
+        # "suprev", " supJun1925-Jun1926"), rendered from the structured
+        # component. A present-but-empty component is the bare "sup" marker; a
+        # number-less date range gets the leading space the number would have
+        # supplied. Shared by base and the per-series to_short_style overrides.
+        def supplement_short
+          return "" unless supplement
+
+          prefix = supplement.range? && !number ? " " : ""
+          rendered = supplement.to_s(:short)
+          prefix + (rendered.empty? ? "sup" : rendered)
+        end
+
         # Compute revision from edition component for backward compatibility
         # @return [String, nil] revision string (e.g., "r5") or nil
         def revision
@@ -107,6 +212,23 @@ module Pubid
           translation_component
         end
 
+        # Override parent render to pass NIST-specific format option through
+        # to the renderer. Pubid::Identifier#render only forwards
+        # :with_edition; NIST needs :nist_format for multi-format support.
+        def render(format: :human, **opts)
+          registry = self.class.format_registry
+          unless registry
+            raise ArgumentError, "No format registry configured on #{self.class}"
+          end
+
+          renderer = registry.renderer_for(format)
+          unless renderer
+            raise ArgumentError, "No renderer registered for format: #{format}"
+          end
+
+          renderer.new(self).render(**opts)
+        end
+
         # Generate identifier string in specified format
         # @param format [:full, :long, :abbreviated, :short, :mr] output format
         def to_s(format = nil)
@@ -116,20 +238,7 @@ module Pubid
           # Default to parsed_format if available (preserves input format on round-trip)
           # Falls back to :short format for output (normalization)
           # Explicit format parameter always overrides parsed_format
-          effective_format = format || parsed_format&.to_sym || :short
-          effective_format = effective_format.to_sym if effective_format.is_a?(String)
-          case effective_format
-          when :full, :long
-            to_full_style
-          when :abbreviated, :abbrev
-            to_abbreviated_style
-          when :short
-            to_short_style
-          when :mr
-            to_mr_style
-          else
-            to_short_style
-          end
+          render(format: :human, nist_format: format || parsed_format&.to_sym || :short)
         end
 
         # Returns weight based on amount of defined attributes
@@ -198,7 +307,7 @@ module Pubid
           match ? match[1].to_i : nil
         end
 
-        private
+        public
 
         def to_full_style
           # "National Institute of Standards and Technology Special Publication 800-27, Revision A"
@@ -300,15 +409,37 @@ module Pubid
           result += " #{number}" if number
           result += parts.map { |p| "-#{p}" }.join if parts&.any?
 
-          # NEW: Use Volume and Part components (v6n1 notation for CSM, pt1 for SP)
-          if volume.is_a?(Components::Volume) && part.is_a?(Components::Part)
+          # Append every optional component the parser may have attached
+          # (volume, part, edition, version, supplement, update, stage, ...).
+          # Shared with the lossy subclasses so they cannot silently drop a
+          # distinguishing component and collide with another document.
+          result += append_short_components
+
+          result
+        end
+
+        # Render the optional component "tail" that follows
+        # publisher/series/number in short (human) form. Extracted from
+        # #to_short_style so subclasses that build a series-specific prefix can
+        # reuse it instead of hand-listing components (and forgetting some).
+        #
+        # skip_part: true lets a series that renders its part differently
+        # (e.g. FIPS uses dash "-1", not "pt1") emit the part itself and skip
+        # the generic part rendering here, while still getting volume/edition/
+        # supplement/etc.
+        def append_short_components(skip_part: false)
+          result = ""
+          effective_part = skip_part ? nil : part
+
+          # Volume and Part components (v6n1 notation for CSM, pt1 for SP)
+          if volume.is_a?(Components::Volume) && effective_part.is_a?(Components::Part)
             # CSM series: v#n# notation
-            result += " #{volume}#{part}"
-          elsif part.is_a?(Components::Part)
+            result += " #{volume}#{effective_part}"
+          elsif effective_part.is_a?(Components::Part)
             # SP and other series: use Part.type to determine format
-            result += part.to_s
+            result += effective_part.to_s
           # Legacy: Render standalone volume (not part of v#n#)
-          elsif volume && !issue_number && !part
+          elsif volume && !issue_number && !effective_part
             vol_str = volume.is_a?(Components::Volume) ? volume.to_s : "v#{volume}"
             result += vol_str
           elsif volume && issue_number
@@ -317,7 +448,7 @@ module Pubid
             result += "#{vol_str}n#{issue_number.number}"
           end
 
-          # NEW: Use edition component properly (e2, e2021, r5, -3)
+          # Use edition component properly (e2, e2021, r5, -3)
           # NO space before edition when number present (per NIST spec)
           # Only add space for bare edition (no number case) or if original_prefix has specific format
           if edition
@@ -333,30 +464,22 @@ module Pubid
             end
           end
 
-          # V2: Use version_component if available, else use version string
+          # Use version_component if available, else use version string.
+          # Attach directly (no leading space) to match edition rendering
+          # (e.g. "800-53r5"), so version reads "800-45ver2" not
+          # "800-45 ver2".
           if version_component
-            result += " #{version_component.to_s(:short)}"
+            result += version_component.to_s(:short)
           elsif version
-            result += " Ver. #{version}"
+            result += "ver#{version}"
           end
 
-          # Add supplement with date range support - FIX: proper spacing
-          if supplement_date_range_start && supplement_date_range_end
-            result += "supp#{supplement_date_range_start}-#{supplement_date_range_end}"
-          elsif supplement_has_revision
-            result += "supprev"
-          elsif supplement && !supplement.empty?
-            # Smart dash logic:
-            # - If supplement starts with letter (month like "Jan1924"), NO dash
-            # - If supplement is digits only (year like "1924"), WITH dash
-            result += if supplement.match?(/^[A-Z]/)
-                        "supp#{supplement}"
-                      else
-                        "supp-#{supplement}"
-                      end
-          elsif supplement
-            result += "supp"
-          end
+          # Add supplement. NIST/NBS canonical short form is single-p "sup"
+          # with the suffix attached directly, no dash (relaton-data-nist
+          # uses "sup2", "sup1940", "supA"); date-range keeps its inner dash.
+          # Rendered from the structured component; a present-but-empty
+          # component is the bare "sup" marker.
+          result += supplement_short
 
           # Add other attributes
           result += errata.to_s if errata
@@ -370,7 +493,7 @@ module Pubid
             result += " Add."
           end
 
-          # V2: Use update_component if available, else use update string
+          # Use update_component if available, else use update string
           if update_component
             result += update_component.to_s(:short)
           elsif update
@@ -384,12 +507,12 @@ module Pubid
             result += "-draft"
           end
 
-          # V2: Add stage component (at end, before translation)
+          # Add stage component (at end, before translation)
           if stage
             result += " #{stage.to_s(:short)}"
           end
 
-          # V2: Use translation_component if available, else use translation string
+          # Use translation_component if available, else use translation string
           # Note: translation_component.to_s already includes the space prefix
           if translation_component
             result += translation_component.to_s(:short)
@@ -416,25 +539,44 @@ module Pubid
           result += ".#{number}" if number
           result += parts.map { |p| "-#{p}" }.join if parts&.any?
 
-          # Part component (pt1, v6n1, etc.)
-          result += part.to_s if part.is_a?(Components::Part)
+          result += append_mr_components
 
-          # NEW: Use edition component - NO space before edition in MR format (per NIST spec)
-          if edition
-            # If edition has original_prefix set (e.g., verbose " Rev. "), use it as-is
-            # Otherwise, no space needed in MR format: ".800-53r5"
-            if edition.original_prefix && !edition.original_prefix.empty?
-            end
-            result += edition.to_s
+          result
+        end
+
+        # Render the optional component tail for machine-readable (MR) form.
+        # Mirrors #append_short_components so the MR output is just as lossless;
+        # subclasses that override #to_mr_style reuse this instead of
+        # hand-listing components. skip_part: behaves as in the short helper.
+        def append_mr_components(skip_part: false)
+          result = ""
+          effective_part = skip_part ? nil : part
+
+          # Volume / Part components (pt1, v6n1, etc.)
+          if volume.is_a?(Components::Volume) && effective_part.is_a?(Components::Part)
+            result += "#{volume}#{effective_part}"
+          elsif effective_part.is_a?(Components::Part)
+            result += effective_part.to_s
+          elsif volume && !issue_number && !effective_part
+            result += (volume.is_a?(Components::Volume) ? volume.to_s : "v#{volume}")
+          elsif volume && issue_number
+            vol_str = volume.is_a?(Components::Volume) ? volume.to_s : "v#{volume}"
+            result += "#{vol_str}n#{issue_number.number}"
           end
 
-          # V2: Use version_component
+          # Use edition component - NO space before edition in MR format (per NIST spec)
+          result += edition.to_s if edition
+
+          # Use version_component
           result += version_component.to_s(:mr) if version_component
 
-          # V2: Use update_component
+          # Supplement (e.g. ".9981sup7") - keep distinct documents distinct
+          result += supplement_short
+
+          # Use update_component
           result += update_component.to_s(:mr) if update_component
 
-          # V2: Use stage
+          # Use stage
           result += ".#{stage.to_s(:mr)}" if stage
 
           # Add addendum - render as ".Add." suffix in MR format
@@ -442,7 +584,7 @@ module Pubid
             result += ".Add."
           end
 
-          # V2: Use translation_component
+          # Use translation_component
           result += translation_component.to_s(:mr) if translation_component
 
           result

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

@@ -22,7 +22,8 @@ module Pubid
           end
 
           def type
-            { key: :circ, title: "NBS Circular", short: "CIRC" }
+            { key: :circ,
+            web: :circular, title: "NBS Circular", short: "CIRC" }
           end
         end
 
@@ -41,8 +42,12 @@ module Pubid
           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&.to_s || series_code
+          super || Components::Code.new(value: series_code)
         end
 
         # Override to_s for CIRC-specific edition+year rendering

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

@@ -27,7 +27,8 @@ module Pubid
           end
 
           def type
-            { key: :circ_supp, title: "NBS Circular Supplement", short: "CIRC" }
+            { key: :circ_supp,
+            web: :circular_supplement, title: "NBS Circular Supplement", short: "CIRC" }
           end
         end
 
@@ -38,7 +39,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
 
           # Use parent's rendering for base + supplement

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

@@ -24,7 +24,8 @@ module Pubid
           end
 
           def type
-            { key: :cs, title: "Commercial Standard", short: "CS" }
+            { key: :cs,
+            web: :commercial_standard, title: "Commercial Standard", short: "CS" }
           end
         end
 

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

@@ -21,7 +21,8 @@ module Pubid
           end
 
           def type
-            { key: :cse, title: "NBS Commercial Standard Emergency",
+            { key: :cse,
+            web: :commercial_standard_emergency, title: "NBS Commercial Standard Emergency",
               short: "CS-E" }
           end
         end
@@ -30,7 +31,7 @@ module Pubid
           "CS-E"
         end
 
-        private
+        public
 
         def to_short_style
           result = ""
@@ -45,8 +46,9 @@ module Pubid
           # 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
+          # Edition (e1943 for e104-43 pattern) plus any other component the
+          # parser attached (volume, supplement, version, ...).
+          result += append_short_components
 
           result
         end

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

@@ -21,7 +21,8 @@ module Pubid
           end
 
           def type
-            { key: :csm, title: "Commercial Standards Monthly", short: "CSM" }
+            { key: :csm,
+            web: :commercial_standards_monthly, title: "Commercial Standards Monthly", short: "CSM" }
           end
         end
 
@@ -29,11 +30,17 @@ module Pubid
           "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
-          "CSM"
+          Components::Code.new(value: "CSM")
         end
 
-        def to_s
+        def to_s(format = nil)
           result = "#{publisher} #{series}"
 
           # Proper Volume and Part components

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

@@ -24,7 +24,8 @@ module Pubid
           end
 
           def type
-            { key: :crpl, title: "NBS CRPL Report", short: "CRPL" }
+            { key: :crpl,
+            web: :crpl_report, title: "NBS CRPL Report", short: "CRPL" }
           end
         end
 
@@ -83,10 +84,10 @@ module Pubid
           end
 
           # Return new Code object with normalized value
-          Components::Code.new(number: num_value)
+          Components::Code.new(value: num_value)
         end
 
-        def to_s
+        def to_s(format = 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-")
@@ -117,14 +118,10 @@ module Pubid
             result += " #{num_value}"
           end
 
-          # Add part component (pt3-1)
-          result += part.to_s if part
-
-          # Add supplement with "sup" prefix for CRPL identifiers
-          if supplement
-            # Check if supplement already has "sup" prefix (for backward compatibility)
-            result += (supplement.start_with?("sup") ? supplement : "sup#{supplement}")
-          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
           result

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 < Base
+        # 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

@@ -22,7 +22,8 @@ module Pubid
           end
 
           def type
-            { key: :fips, title: "Federal Information Processing Standards",
+            { key: :fips,
+            web: :federal_information_processing_standards, title: "Federal Information Processing Standards",
               short: "FIPS" }
           end
         end
@@ -41,21 +42,20 @@ module Pubid
           # "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
 
-          if number
-            result += ".#{number}"
-            # Append edition directly to number (no dot) for FIPS MR format
-            if edition
-              result += edition.to_s
-            end
-          end
-
+          # 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
 
-        private
+        public
 
         def to_short_style
           # FIPS format: "FIPS 14e1971" or "NIST FIPS 140-3" (preserve publisher if set)
@@ -77,15 +77,16 @@ module Pubid
             end
           end
 
-          # FIPS uses dash notation for parts: -1, -2, -3 (not pt1, pt2, pt3)
+          # 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
-          # Render edition for FIPS
-          # FIPS editions use "e" prefix: e1971, e198503, e19770930
-          if edition
-            result += "#{edition.type}#{edition.id}"
-          end
+
+          result += append_short_components(skip_part: true)
+
           result
         end
       end

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

@@ -22,7 +22,8 @@ module Pubid
           end
 
           def type
-            { key: :gcr, title: "NIST Grant/Contractor Report", short: "GCR" }
+            { key: :gcr,
+            web: :grant_contractor_report, title: "NIST Grant/Contractor Report", short: "GCR" }
           end
         end