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

data/lib/pubid/components/supplement.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Components
+    # Supplement component — a structured value-object representing the
+    # supplement-specific data (number, date, stage, iteration, type) of a
+    # supplement identifier.
+    #
+    # Union shape across flavors:
+    # - type:    "amd" (amendment), "cor" (corrigendum), "err" (errata),
+    #            "sup" (supplement), or a flavor-specific marker.
+    # - number:  bare sequence number (string preserves leading zeros, "1A"
+    #            combos, etc.).
+    # - date:    publication date of the supplement (Components::Date).
+    # - range_end_date: end of a date range; presence of this marks the
+    #            supplement as a range. (NIST/NBS uses supJan1924-Jun1925.)
+    # - stage:   the stage the supplement is in (e.g., WD Amd, CD Amd).
+    # - iteration: stage iteration (e.g., the ".2" in "WD.2 Amd").
+    # - has_revision: "suprev" marker — supplement that itself carries a
+    #            revision. (NIST-specific.)
+    # - suffix:  escape hatch for patterns not yet modeled.
+    #
+    # Format-aware via render(context:). The human form stacks fields in the
+    # order they appear in the printed supplement; the URN form joins number
+    # and year with ":".
+    class Supplement < Lutaml::Model::Serializable
+      DEFAULT_TYPE = "sup"
+
+      attribute :type, :string, default: -> { DEFAULT_TYPE }
+      attribute :number, :string
+      attribute :date, Date
+      attribute :range_end_date, Date
+      attribute :stage, Stage
+      attribute :iteration, Components::Iteration
+      attribute :has_revision, :boolean, default: false
+      attribute :suffix, :string
+
+      IDENTITY_FIELDS = %i[
+        type number date range_end_date stage iteration has_revision suffix
+      ].freeze
+
+      # Fields whose presence indicates the supplement carries data.
+      # `type` is excluded — it always has a value (the default "sup") but
+      # doesn't mean the supplement carries content.
+      CONTENT_FIELDS = %i[
+        number date range_end_date stage iteration has_revision suffix
+      ].freeze
+
+      # True when the supplement carries any data. Distinguishes a present-
+      # but-empty supplement (bare marker, "sup") from no supplement at all.
+      def present?
+        CONTENT_FIELDS.any? { |f| present_value?(public_send(f)) }
+      end
+
+      # True when this supplement spans a date range (start + end set).
+      def range?
+        date&.present? && range_end_date&.present?
+      end
+
+      def render(context: nil)
+        return render_urn if context&.format == :urn
+
+        render_human
+      end
+
+      def to_s(**opts)
+        render(context: opts[:context])
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+
+        identity_fields.all? { |f| public_send(f) == other.public_send(f) }
+      end
+
+      alias eql? ==
+
+      def hash
+        @hash ||= [self.class, *identity_fields.map { |f| public_send(f) }].hash
+      end
+
+      private
+
+      def identity_fields
+        IDENTITY_FIELDS
+      end
+
+      def non_empty?(value)
+        return false if value.nil?
+
+        value.is_a?(String) ? !value.empty? : value.present?
+      end
+
+      def present_value?(value)
+        return value if [true, false].include?(value)
+        return false if value.nil?
+
+        value.is_a?(String) ? !value.empty? : value.present?
+      end
+
+      def number?
+        non_empty?(number)
+      end
+
+      def suffix?
+        non_empty?(suffix)
+      end
+
+      def stage_abbr
+        return nil if stage.nil? || stage.abbr.nil?
+
+        abbr = stage.abbr.to_s
+        abbr.empty? ? nil : abbr
+      end
+
+      # Human / mr: stack fields in canonical order.
+      #   "1924"            (year)
+      #   "Jan1924"         (month + year)
+      #   "3/1926"          (number + year)
+      #   "1"               (number)
+      #   "A"               (suffix)
+      #   "Jan1924-Jun1925" (range)
+      def render_human
+        return early_marker if has_revision || suffix?
+        return date_range_string if range?
+
+        assemble_body
+      end
+
+      def early_marker
+        has_revision ? "rev" : suffix.to_s
+      end
+
+      def assemble_body
+        body = number_or_date_string
+        body += iteration_suffix if include_iteration?
+        stage_abbr ? "#{stage_abbr}#{body}" : body
+      end
+
+      def include_iteration?
+        iteration && stage_abbr.nil?
+      end
+
+      def render_urn
+        return "" unless present?
+
+        [number&.to_s, date&.year&.to_s].compact.reject(&:empty?).join(":")
+      end
+
+      def iteration_suffix
+        "-#{iteration.number}"
+      end
+
+      def date_range_string
+        "#{date_string(date)}-#{date_string(range_end_date)}"
+      end
+
+      def number_or_date_string
+        return date_string(date) unless number?
+
+        date&.present? ? "#{number}/#{date_string(date)}" : number.to_s
+      end
+
+      # Render the body of a date fragment preserving the original month
+      # abbreviation when month is a non-numeric string. Falls back to
+      # Components::Date#render when month is numeric.
+      def date_string(date_value)
+        return "" unless date_value&.present?
+
+        if month_abbreviation?(date_value)
+          "#{date_value.month}#{date_value.year}"
+        else
+          date_value.render(context: nil)
+        end
+      end
+
+      def month_abbreviation?(date_value)
+        date_value.month && !date_value.month.match?(/^\d+$/)
+      end
+    end
+  end
+end

data/lib/pubid/components/type.rb

@@ -1,26 +1,21 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
-require_relative "../rendering/context" if File.exist?(File.join(__dir__,
-                                                                 "../../rendering/context.rb"))
 
 module Pubid
   module Components
     # Resource type component (a set of defined resource types)
+    #
+    # Human render: abbreviation with flavor-specific separator.
+    # URN render: type code (e.g. "tr", "ts") per RFC 5141-bis.
     class Type < Lutaml::Model::Serializable
       attribute :name, :string
       attribute :abbr, :string
       attribute :type_code, :string
 
-      # Render type with optional context for flavor-specific separators and default handling
-      #
-      # @param context [RenderingContext] rendering context for flavor rules
-      # @param has_prefix [Boolean] whether there's a prefix (stage or copublisher)
-      # @return [String] rendered type string
       def to_s(context: nil, has_prefix: false)
         return "" unless abbr
 
-        # Check if this type should be rendered (not the default)
         if context && !context.should_render_type?(abbr)
           return ""
         end
@@ -29,25 +24,20 @@ module Pubid
           sep = context.type_separator_for(has_prefix)
           sep == "" ? abbr : "#{sep}#{abbr}"
         else
-          # Default behavior: space after prefix, slash otherwise
           has_prefix ? " #{abbr}" : "/#{abbr}"
         end
       end
 
       def render(context: nil)
+        return type_code.to_s if context&.urn? && type_code
+
         name.to_s
       end
 
-      # Returns hash code for type component
-      # @return [Integer] hash code
-      # @note Memoized for performance
       def hash
         @hash ||= [type_code, abbr].compact.map(&:hash).hash
       end
 
-      # Checks equality with another type component
-      # @param other [Object] object to compare with
-      # @return [Boolean] true if equal
       def eql?(other)
         return false unless other.is_a?(self.class)
 

data/lib/pubid/components/typed_stage.rb

@@ -1,18 +1,21 @@
-require_relative "stage"
 # frozen_string_literal: true
-require_relative "type"
 
 module Pubid
   module Components
+    # TypedStage component (combined stage + type, e.g. "DTR", "FDIS")
+    #
+    # Human render: typed-stage abbreviation with flavor-specific separator.
+    # URN render: stage code (RFC 5141-bis: stage-XX.XX format handled by urn_generator).
     class TypedStage < Lutaml::Model::Serializable
       attribute :name, :string
+      attribute :code, :string
       attribute :type_code, :string
       attribute :stage_code, :string
       attribute :abbr, :string, collection: true
       attribute :harmonized_stages, :string, collection: true
-      attribute :original_abbr, :string # Store the actual parsed abbreviation
-      attribute :short_abbr, :string  # Short form: DAM, COR, FDAM
-      attribute :long_abbr, :string   # Long form: DAmd, Cor, FDAmd
+      attribute :original_abbr, :string
+      attribute :short_abbr, :string
+      attribute :long_abbr, :string
 
       def to_stage
         Stage.new(
@@ -32,21 +35,21 @@ module Pubid
       end
 
       def render(context: nil)
+        return code.to_s if context&.urn? && code
+
         abbreviation(format_long: context&.stage_format_long || false)
       end
 
       def abbreviation(format_long: true)
-        # Use format preference
         if format_long && long_abbr
           long_abbr
         elsif !format_long && short_abbr
           short_abbr
         else
-          abbr.first # Fallback to canonical
+          abbr.first
         end
       end
 
-      # Returns the canonical (normalized) abbreviation, always abbr.first
       def canonical_abbreviation
         abbr.first
       end

data/lib/pubid/components.rb

@@ -2,13 +2,17 @@
 
 module Pubid
   module Components
+    autoload :Adoption, "pubid/components/adoption"
     autoload :Code, "pubid/components/code"
     autoload :Date, "pubid/components/date"
     autoload :Edition, "pubid/components/edition"
+    autoload :Iteration, "pubid/components/iteration"
     autoload :Language, "pubid/components/language"
     autoload :Locality, "pubid/components/locality"
     autoload :Publisher, "pubid/components/publisher"
+    autoload :Relationship, "pubid/components/relationship"
     autoload :Stage, "pubid/components/stage"
+    autoload :Supplement, "pubid/components/supplement"
     autoload :Type, "pubid/components/type"
     autoload :TypedStage, "pubid/components/typed_stage"
   end

data/lib/pubid/core/update_codes.rb

@@ -15,18 +15,24 @@ module Pubid
     #
     # Format in YAML files:
     #   plain string match: "IEC 60285-/1:1989"  →  "IEC 60285-1:1989"
-    #   regex match:        "/^NBS CIRC sup$/"  →  "NBS CIRC 24e7sup"
+    #   regex match:        "/^NBS CIRC sup$/"   →  "NBS CIRC 24e7sup"
+    #   regex with flags:   "/^nbs\\b/i"          →  "NBS"
     #
     # Plain strings use full-line anchoring (^pattern$).
-    # Regex patterns are wrapped in /.../ slashes.
+    # Regex patterns are wrapped in /.../ slashes with optional trailing flags
+    # (i = IGNORECASE, m = MULTILINE, x = EXTENDED) and applied via gsub.
     class UpdateCodes
       DATA_DIR = Pathname.new(__dir__).join("../../../data").expand_path
 
+      # Regex literal: /body/flags  where flags is optional (i, m, x).
+      REGEX_LITERAL = %r{\A/(.*)/([imx]*)\z}m
+
       class << self
         # Apply update_codes substitutions for the given flavor.
         #
         # @param code [String] identifier string to normalize
-        # @param flavor [Symbol, String] flavor name (e.g., :iso, :iec, :ieee, :nist)
+        # @param flavor [Symbol, String] flavor name
+        #   (e.g., :iso, :iec, :ieee, :nist)
         # @return [String] normalized identifier string
         #
         # @example
@@ -37,9 +43,7 @@ module Pubid
           return code if codes.nil? || codes.empty?
 
           codes.each do |from, to|
-            code = code.gsub(
-              from.match?(%r{^/.*/$}) ? Regexp.new(from[1..-2]) : /^#{Regexp.escape(from)}$/, to
-            )
+            code = code.gsub(compile_pattern(from), to.to_s)
           end
           code
         end
@@ -56,13 +60,30 @@ module Pubid
 
         # Available flavors that have update_codes files.
         #
-        # @return [Array<Symbol>] list of flavors with data/{flavor}/update_codes.yaml
+        # @return [Array<Symbol>] flavors with data/{flavor}/update_codes.yaml
         def flavors
           @flavors ||= DATA_DIR.children.select(&:directory?).map do |dir|
             dir.basename.to_s.to_sym
           end.select { |f| (DATA_DIR / f.to_s / "update_codes.yaml").exist? }
         end
 
+        # Compile a YAML key into a Regexp. Plain strings are anchored to the
+        # full line; regex literals support optional trailing flags.
+        def compile_pattern(from)
+          match = from.to_s.match(REGEX_LITERAL)
+          return /^#{Regexp.escape(from.to_s)}$/ unless match
+
+          Regexp.new(match[1], compile_options(match[2]))
+        end
+
+        def compile_options(flags)
+          options = 0
+          options |= Regexp::IGNORECASE if flags.include?("i")
+          options |= Regexp::MULTILINE if flags.include?("m")
+          options |= Regexp::EXTENDED if flags.include?("x")
+          options
+        end
+
         private
 
         def load_yaml(flavor)

data/lib/pubid/csa/identifier.rb

@@ -427,9 +427,6 @@ module Pubid
       end
 
       def self.parse_external_standard(input)
-        # Ensure full Pubid is loaded (handles Scheme and all flavors)
-        require_relative "../../pubid" unless defined?(Pubid::Iso) && defined?(Pubid::Iec)
-
         # Try ISO/IEC first (most common)
         if input.match?(/^(ISO\/IEC|ISO|IEC|CEI|CEI\/IEC)\s/)
           begin

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

@@ -4,128 +4,8 @@ module Pubid
   module Csa
     module Identifiers
       class Base < SingleIdentifier
-        def to_s
-          prefix = publisher_prefix || "CSA"
-
-          # Handle code_only identifiers (empty string means no prefix)
-          if prefix == ""
-            # No prefix for code_only identifiers
-            parts = []
-          else
-            # Determine if we need space after prefix
-            # CAN/CSA- and CAN3- end with dash, so no space needed
-            needs_space = !prefix.end_with?("-")
-
-            parts = []
-            parts << prefix
-          end
-
-          # Code and year together
-          code_part = code.to_s if code
-
-          # NO. keyword
-          if no_number
-            code_part += " NO. #{no_number}"
-          end
-
-          # Series prefix and keyword (before year)
-          if series_prefix
-            code_part += " #{series_prefix} SERIES"
-          elsif series
-            # SERIES without prefix
-            code_part += " SERIES"
-          end
-
-          parts << code_part if code_part
-
-          # Year with proper format (colon or dash)
-          if year
-            # Use dash if year_format is dash, otherwise colon
-            separator = year_format == "dash" ? "-" : ":"
-            year_part = separator
-            year_part += year_prefix if year_prefix # Add M or F prefix
-            year_part += "F" if french && year_format != "dash" && !year_prefix # Only add F if no prefix
-            # Convert 4-digit year back to 2-digit for M/F prefix preservation
-            # M1983 → M83, F1983 → F83, 1983 → 83, 20xx → xx
-            # However, preserve original 4-digit format if the input was 4-digit (original_year_4digit)
-            year_str = year.to_s
-            year_part += if original_year_4digit
-                           # Preserve 4-digit format (e.g., "M1981" stays "M1981")
-                           year_str
-                         elsif year_prefix&.match?(/^[MF]$/) && year_str.length == 4 && year_str.start_with?("19")
-                           # M/F + 4-digit year (1900s) → convert to 2-digit with prefix
-                           year_str[2..3]
-                         elsif year_str.length == 4 && year_str.start_with?("20")
-                           # 2000s → just last 2 digits
-                           year_str[2..3]
-                         elsif year_str.length == 4 && year_str.start_with?("19") && !original_year_4digit
-                           # 1900s with no M/F prefix, but original was 2-digit (e.g., CAN3-Z299.0-86)
-                           # Convert back to 2-digit
-                           year_str[2..3]
-                         else
-                           # Other formats - keep as-is
-                           year_str
-                         end
-            parts[-1] += year_part
-          end
-
-          result = if prefix == ""
-                     # No prefix, just join parts
-                     parts.join(" ")
-                   elsif needs_space
-                     parts.join(" ")
-                   elsif parts.length == 2
-                     # No space after dash-ending prefix - join first two parts directly
-                     # If there are more parts after code, they should still have spaces
-                     parts.join
-                   else
-                     # More than 2 parts shouldn't happen in current design
-                     parts.join
-                   end
-
-          # Reaffirmation - preserve original format and determine spacing
-          if reaffirmation
-            # Check if year was originally 2-digit (original_year_4digit flag)
-            year_was_2digit = !original_year_4digit
-
-            # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
-            reaffirmation_was_4digit = original_reaffirmation_4digit
-
-            # Preserve original reaffirmation format
-            # If original was 4-digit, keep as 4-digit
-            # If original was 2-digit, convert from 4-digit storage back to 2-digit
-            reaffirmation_str = if reaffirmation_was_4digit
-                                  # Original was 4-digit, keep as-is
-                                  reaffirmation.to_s
-                                elsif reaffirmation.to_s.length == 4 && reaffirmation.to_s.start_with?(
-                                  "19", "20"
-                                )
-                                  # Original was 2-digit, convert 4-digit storage back to 2-digit
-                                  # (R2004) → (R04), (R1994) → (R94)
-                                  reaffirmation.to_s[2..3]
-                                else
-                                  # Already 2-digit or other format
-                                  reaffirmation.to_s
-                                end
-
-            # Determine spacing based on original formats
-            # Space needed if year is 2-digit and reaffirmation is 4-digit (original format)
-            # No space if both year and reaffirmation are 2-digit, or both are 4-digit
-            if year_was_2digit && reaffirmation_was_4digit
-              # Year was 2-digit, reaffirmation was 4-digit → add space
-              result += " (R#{reaffirmation_str})"
-            else
-              # Both 2-digit, both 4-digit, or other cases → no space
-              result += "(R#{reaffirmation_str})"
-            end
-          end
-
-          # Package (already has leading space from parser)
-          if package
-            result += package
-          end
-
-          result
+        def to_s(**opts)
+          render(format: :human, **opts)
         end
       end
     end

data/lib/pubid/csa/identifiers/cec.rb

@@ -21,107 +21,8 @@ module Pubid
           @code ||= Components::Code.new(value: "#{cec_part.value}-#{no_number.value}")
         end
 
-        def to_s
-          parts = []
-
-          # Publisher prefix (CSA, CAN/CSA-, CAN3-)
-          prefix = publisher_prefix || "CSA"
-
-          # Determine if we need space after prefix
-          # CAN/CSA- and CAN3- end with dash, so no space needed
-          needs_space = !prefix.end_with?("-")
-
-          parts << prefix unless prefix == ""
-
-          # CEC Part (C22.2, C22.3, etc.)
-          parts << cec_part.value if cec_part
-
-          # NO. notation - this is the key semantic component
-          parts << "NO."
-
-          # Number after NO.
-          parts << no_number.value if no_number
-
-          # Determine separator based on prefix ending
-          result = if prefix == ""
-                     parts.join(" ")
-                   elsif needs_space
-                     parts.join(" ")
-                   elsif parts.length <= 2
-                     # No space after dash-ending prefix (CAN/CSA-, CAN3-)
-                     # Join first two parts directly, rest with spaces
-                     parts.join
-                   else
-                     parts[0] + parts[1..].join(" ")
-                   end
-
-          # Year with proper format (colon or dash)
-          if year
-            # Use dash if year_format is dash, otherwise colon
-            separator = year_format == "dash" ? "-" : ":"
-            year_part = separator
-
-            # Convert 4-digit year back to 2-digit for display
-            year_str = year.to_s
-            display_year = if year_str.length == 4 && year_str.start_with?("20")
-                             year_str[2..3]
-                           elsif year_str.length == 4 && year_str.start_with?("19")
-                             year_str[2..3]
-                           else
-                             year_str
-                           end
-
-            # Add prefix if present
-            year_part += if year_prefix
-                           year_prefix + display_year
-                         elsif french && year_format != "dash"
-                           # Only add F if no prefix already set
-                           "F#{display_year}"
-                         else
-                           display_year
-                         end
-
-            result += year_part
-          end
-
-          # Reaffirmation - preserve original format and determine spacing
-          if reaffirmation
-            # Check if year was originally 2-digit (original_year_4digit flag)
-            year_was_2digit = !original_year_4digit
-
-            # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
-            reaffirmation_was_4digit = original_reaffirmation_4digit
-
-            # Preserve original reaffirmation format
-            # If original was 4-digit, keep as 4-digit
-            # If original was 2-digit, convert from 4-digit storage back to 2-digit
-            reaffirmation_str = if reaffirmation_was_4digit
-                                  # Original was 4-digit, keep as-is
-                                  reaffirmation.to_s
-                                elsif reaffirmation.to_s.length == 4 && reaffirmation.to_s.start_with?(
-                                  "19", "20"
-                                )
-                                  # Original was 2-digit, convert 4-digit storage back to 2-digit
-                                  # (R2004) → (R04), (R1994) → (R94)
-                                  reaffirmation.to_s[2..3]
-                                else
-                                  # Already 2-digit or other format
-                                  reaffirmation.to_s
-                                end
-
-            # Determine spacing based on original formats
-            # Space needed if year is 2-digit and reaffirmation is 4-digit (original format)
-            # No space if both year and reaffirmation are 2-digit, or both are 4-digit
-            if year_was_2digit && reaffirmation_was_4digit
-              # Year was 2-digit, reaffirmation was 4-digit → add space
-              result += " (R#{reaffirmation_str})"
-            else
-              # Both 2-digit, both 4-digit, or other cases → no space
-              result += "(R#{reaffirmation_str})"
-            end
-          end
-
-          result
+        def to_s(**opts)
+          render(format: :human, **opts)
         end
       end
     end