pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

data/lib/pubid/components/relationship.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Components
+    # Relationship component — captures how one identifier relates to others.
+    #
+    # Originally modeled as IEEE's Components::Relationship; promoted to the
+    # shared namespace because the same relationship vocabulary applies to
+    # ISO, IEC, and other flavors that need to express "revises", "amends",
+    # "incorporates", "adopts", etc.
+    #
+    # Shape:
+    # - relationship_type: one of the VALID_TYPES constants below.
+    # - related_identifiers: array of identifier objects the relationship
+    #   points at (e.g., the standards being revised).
+    # - intermediate_amendments: optional array of identifiers that amended
+    #   the related identifier between its original publication and the
+    #   current revision (renders as "... as amended by ...").
+    # - approved_amendments_flag: when true and no intermediate_amendments
+    #   are listed, renders "... and its approved amendments".
+    class Relationship < Lutaml::Model::Serializable
+      REVISION_OF = "revision_of"
+      AMENDMENT_TO = "amendment_to"
+      CORRIGENDUM_TO = "corrigendum_to"
+      INCORPORATES = "incorporates"
+      INCORPORATING = "incorporating"
+      ADOPTION_OF = "adoption_of"
+      SUPPLEMENT_TO = "supplement_to"
+      DRAFT_AMENDMENT_TO = "draft_amendment_to"
+      DRAFT_REVISION_OF = "draft_revision_of"
+      REAFFIRMATION_OF = "reaffirmation_of"
+      REDESIGNATION_OF = "redesignation_of"
+      SUPERSEDES = "supersedes"
+      PREVIOUSLY_DESIGNATED_AS = "previously_designated_as"
+      INCLUDES = "includes"
+
+      VALID_TYPES = [
+        REVISION_OF,
+        AMENDMENT_TO,
+        CORRIGENDUM_TO,
+        INCORPORATES,
+        INCORPORATING,
+        ADOPTION_OF,
+        SUPPLEMENT_TO,
+        DRAFT_AMENDMENT_TO,
+        DRAFT_REVISION_OF,
+        REAFFIRMATION_OF,
+        REDESIGNATION_OF,
+        SUPERSEDES,
+        PREVIOUSLY_DESIGNATED_AS,
+        INCLUDES,
+      ].freeze
+
+      attribute :relationship_type, :string
+
+      attr_accessor :related_identifiers, :intermediate_amendments,
+                    :approved_amendments_flag
+
+      PREFIXES = {
+        REVISION_OF => "Revision of",
+        AMENDMENT_TO => "Amendment to",
+        CORRIGENDUM_TO => "Corrigendum to",
+        INCORPORATES => "incorporates",
+        ADOPTION_OF => "Adoption of",
+        SUPPLEMENT_TO => "Supplement to",
+        DRAFT_AMENDMENT_TO => "Draft Amendment to",
+        DRAFT_REVISION_OF => "Draft Revision of",
+        REAFFIRMATION_OF => "Reaffirmation of",
+        REDESIGNATION_OF => "Redesignation of",
+        SUPERSEDES => "Supersedes",
+        PREVIOUSLY_DESIGNATED_AS => "Previously designated as",
+        INCLUDES => "Includes",
+      }.freeze
+
+      def initialize(**args)
+        @related_identifiers = args.delete(:related_identifiers)
+        @intermediate_amendments = args.delete(:intermediate_amendments)
+        @approved_amendments_flag = args.delete(:approved_amendments_flag)
+        super
+        normalize_incorporating!
+        validate_relationship_type if relationship_type
+      end
+
+      def normalize_incorporating!
+        return unless relationship_type == INCORPORATING
+
+        self.relationship_type = INCORPORATES
+      end
+
+      def validate_relationship_type
+        return if VALID_TYPES.include?(relationship_type)
+
+        raise ArgumentError,
+              "Invalid relationship type: #{relationship_type}. " \
+              "Valid types: #{VALID_TYPES.join(', ')}"
+      end
+
+      def to_s
+        return "" if related_identifiers.nil? || related_identifiers.empty?
+
+        prefix = format_relationship_prefix
+        ids = format_identifier_list(related_identifiers)
+        return "#{prefix} #{ids}" unless intermediate_clause?
+
+        "#{prefix} #{ids} #{intermediate_clause}"
+      end
+
+      def render(context: nil)
+        to_s
+      end
+
+      private
+
+      def intermediate_clause?
+        (intermediate_amendments && !intermediate_amendments.empty?) ||
+          approved_amendments_flag
+      end
+
+      def intermediate_clause
+        if intermediate_amendments && !intermediate_amendments.empty?
+          "as amended by #{format_identifier_list(intermediate_amendments)}"
+        else
+          "and its approved amendments"
+        end
+      end
+
+      def format_relationship_prefix
+        PREFIXES.fetch(relationship_type, relationship_type)
+      end
+
+      # Format a list of identifiers using proper English grammar:
+      # - Single: "IEEE Std X"
+      # - Two: "IEEE Std X and IEEE Std Y"
+      # - Three+: "IEEE Std X, IEEE Std Y, and IEEE Std Z" (Oxford comma)
+      def format_identifier_list(identifiers)
+        return "" if identifiers.nil? || identifiers.empty?
+
+        case identifiers.length
+        when 1
+          identifiers.first.to_s
+        when 2
+          "#{identifiers.first} and #{identifiers.last}"
+        else
+          "#{identifiers[0..-2].join(', ')}, and #{identifiers.last}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/components/stage.rb

@@ -1,23 +1,19 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
-require_relative "../rendering/context" if File.exist?(File.join(__dir__,
-                                                                 "../../rendering/context.rb"))
 
 module Pubid
   module Components
     # Stage component (a set of defined stages)
+    #
+    # Human render: abbreviation with flavor-specific separator.
+    # URN render: stage abbreviation alone (no separator).
     class Stage < Lutaml::Model::Serializable
       attribute :name, :string
       attribute :stage_code, :string
       attribute :harmonized_stages, :string, collection: true
       attribute :abbr, :string
 
-      # Render stage with optional context for flavor-specific separators
-      #
-      # @param context [RenderingContext] rendering context for flavor rules
-      # @param has_copublisher [Boolean] whether identifier has copublisher
-      # @return [String] rendered stage string
       def to_s(context: nil, has_copublisher: false)
         return "" unless abbr
 
@@ -25,25 +21,20 @@ module Pubid
           sep = context.stage_separator_for(has_copublisher:)
           sep == "" ? abbr : "#{sep}#{abbr}"
         else
-          # Default behavior: space after copublisher, slash otherwise
           has_copublisher ? " #{abbr}" : "/#{abbr}"
         end
       end
 
       def render(context: nil)
+        return abbr.to_s if context&.urn?
+
         abbr.to_s
       end
 
-      # Returns hash code for stage component
-      # @return [Integer] hash code
-      # @note Memoized for performance
       def hash
         @hash ||= [stage_code, abbr].compact.map(&:hash).hash
       end
 
-      # Checks equality with another stage 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/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,22 +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
-      # Unique per-typed-stage code (e.g. :dtr, :fdisp). Distinct from the
-      # generic stage_code (e.g. :draft, :fdis) which is shared across types.
-      # Some index data serializes this code, so it must be resolvable.
       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(
@@ -36,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,14 +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 :Factory, "pubid/components/factory"
+    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

@@ -3,62 +3,6 @@
 module Pubid
   module Csa
     class Identifier
-      # Factory that builds a CSA identifier from a hash of primitives.
-      # Default is {Identifiers::Standard}.
-      TYPE_KEY_TO_KLASS = {
-        standard:         "Standard",
-        bundled:          "Bundled",
-        canadian_adopted: "CanadianAdopted",
-        cec:              "Cec",
-        combined:         "Combined",
-        csa_adopted:      "CsaAdopted",
-        package:          "Package",
-        series:           "Series",
-      }.freeze
-
-      def self.create(type: nil, **opts)
-        klass = resolve_create_class(type)
-        klass.new(**coerce_create_attrs(opts, klass: klass))
-      end
-
-      def self.resolve_create_class(type)
-        return Identifiers::Standard if type.nil?
-
-        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
-        raise ArgumentError, "Unknown CSA type: #{type.inspect}" unless klass_name
-
-        Identifiers.const_get(klass_name)
-      end
-
-      def self.coerce_create_attrs(opts, klass:)
-        attrs = {}
-
-        if (v = opts[:code] || opts[:number])
-          attrs[:code] = Pubid::Components::Code.new(value: v.to_s)
-        end
-
-        if opts[:year]
-          year_str = opts[:year].to_s
-          attrs[:year] = year_str
-          # Preserve 4-digit year rendering (e.g. "B51:2024") rather than
-          # collapsing to "B51:24".
-          attrs[:original_year_4digit] = year_str.length == 4 unless opts.key?(:original_year_4digit)
-        end
-        attrs[:original_year_4digit] = opts[:original_year_4digit] if opts.key?(:original_year_4digit)
-        attrs[:year_format] = opts[:year_format].to_s if opts[:year_format]
-        attrs[:year_prefix] = opts[:year_prefix].to_s if opts[:year_prefix]
-        attrs[:reaffirmation] = opts[:reaffirmation].to_s if opts[:reaffirmation]
-        attrs[:french] = opts[:french] if opts.key?(:french)
-        attrs[:has_publisher] = opts.fetch(:has_publisher, true)
-        attrs[:publisher_prefix] = opts[:publisher_prefix].to_s if opts[:publisher_prefix]
-        attrs[:series_prefix] = opts[:series_prefix].to_s if opts[:series_prefix]
-        attrs[:series] = opts[:series] if opts.key?(:series) && [true, false].include?(opts[:series])
-        attrs[:package] = opts[:package].to_s if opts[:package]
-        attrs[:no_number] = opts[:no_number].to_s if opts[:no_number]
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
-
       def self.parse(input)
         # Filter out comments
         return nil if input.start_with?("#")
@@ -483,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