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

data/lib/pubid/cie.rb

@@ -11,16 +11,58 @@ module Pubid
     autoload :Identifier, "#{__dir__}/cie/identifier"
     autoload :Identifiers, "#{__dir__}/cie/identifiers"
     autoload :Parser, "#{__dir__}/cie/parser"
-    autoload :Scheme, "#{__dir__}/cie/scheme"
     autoload :SingleIdentifier, "#{__dir__}/cie/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/cie/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/cie/urn_generator"
+    autoload :UrnParser, "#{__dir__}/cie/urn_parser"
 
     # Main entry point for CIE identifiers
     # Delegates to Identifier.parse
     def self.parse(input)
       Identifier.parse(input)
     end
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # CIE identifier classes extend Lutaml::Model::Serializable via
+    # SingleIdentifier / SupplementIdentifier, without a self.type Hash.
+    # We discover by checking for subclasses of those base types.
+    # @return [Array<Class>] identifier classes
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && (c < SingleIdentifier || c < SupplementIdentifier) }
+    end
+
+    # Build typed stage index from identifier types.
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: class name -> identifier class
+    # Since CIE lacks self.type, locate by class name suffix
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find do |t|
+        t.name.split("::").last.gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, "") == code.to_s.downcase ||
+          t.name.split("::").last.downcase == code.to_s.downcase
+      end
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
   end
 end
 

data/lib/pubid/components/adoption.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Components
+    # Adoption component — captures the metadata when one identifier adopts
+    # another. Originally surfaced as BSI's AdoptedInternationalStandard /
+    # AdoptedEuropeanNorm and CEN-CENELEC's AdoptedEuropeanNorm; the same
+    # shape applies to CSA adoptions and IEEE Adopted-Standard relationships.
+    #
+    # Shape (union across BSI, CEN-CENELEC, CSA, IEEE):
+    # - base:                     the adopted document (polymorphic Identifier).
+    # - adopter_publisher:        the publisher doing the adopting (BS, EN,
+    #                             CAN/, CSA, IEEE).
+    # - edition:                  edition of the adoption (BSI-only).
+    # - date:                     adoption date (replaces ad-hoc year attrs).
+    # - translation_lang:         translation language code (BSI-only).
+    # - translation_upper:        upper-case translation marker (BSI-only).
+    # - translation_suffix_type:  "version" or "Translation" (BSI-only).
+    # - reaffirmation_year:       "(R2004)" reaffirmation notation (BSI, CSA).
+    # - expert_commentary:        true when the adoption ships with commentary
+    #                             (BSI-only).
+    # - expert_commentary_topic:  topic of the commentary (BSI-only).
+    # - publisher_prefix:         CSA-specific dash-vs-space prefix.
+    #
+    # Render delegates to the base identifier; the adopter's renderer decides
+    # the prefix and any suffix notation (translation, reaffirmation,
+    # commentary) by calling adoption.render(context:).
+    class Adoption < Lutaml::Model::Serializable
+      attribute :base, ::Pubid::Identifier, polymorphic: true
+      attribute :adopter_publisher, ::Pubid::Components::Publisher
+      attribute :edition, :string
+      attribute :date, ::Pubid::Components::Date
+      attribute :translation_lang, :string
+      attribute :translation_upper, :string
+      attribute :translation_suffix_type, :string
+      attribute :reaffirmation_year, :string
+      attribute :expert_commentary, :boolean
+      attribute :expert_commentary_topic, :string
+      attribute :publisher_prefix, :string
+
+      IDENTITY_FIELDS = %i[
+        base adopter_publisher edition date translation_lang translation_upper
+        translation_suffix_type reaffirmation_year expert_commentary
+        expert_commentary_topic publisher_prefix
+      ].freeze
+
+      def present?
+        IDENTITY_FIELDS.any? { |f| present_value?(public_send(f)) }
+      end
+
+      def render(context: nil)
+        return "" unless base
+
+        body = base.to_s
+        body += translation_suffix if translation_lang
+        body += reaffirmation_suffix if reaffirmation_year
+        body += commentary_suffix if expert_commentary
+        body
+      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 present_value?(value)
+        return false if value.nil?
+        return value if [true, false].include?(value)
+
+        value.is_a?(String) ? !value.empty? : !value.nil?
+      end
+
+      def translation_suffix
+        type = translation_suffix_type || "Translation"
+        lang = translation_lang&.upcase
+        " #{lang}#{type}"
+      end
+
+      def reaffirmation_suffix
+        " (R#{reaffirmation_year})"
+      end
+
+      def commentary_suffix
+        topic = expert_commentary_topic
+        topic ? " (Commentary: #{topic})" : " (Commentary)"
+      end
+    end
+  end
+end

data/lib/pubid/components/code.rb

@@ -2,32 +2,46 @@
 
 module Pubid
   module Components
+    # Document code/number component.
+    #
+    # Holds the structured fields that recur across flavors: the main +value+
+    # (always present), plus optional +prefix+ (series/type designator),
+    # +part+, +subpart+, and free-form +parts+. Subclasses own their
+    # composition rules — flavor-specific separators and orderings live in
+    # the subclass #to_s / #render override.
     class Code < Lutaml::Model::Serializable
       attribute :value, :string
+      attribute :prefix, :string
+      attribute :part, :string
+      attribute :subpart, :string
+      attribute :parts, :string, collection: true
 
       def to_s
         value.to_s
       end
 
+      # Format-aware render seam. Default returns the bare value; subclasses
+      # override to compose flavor-specific shapes (e.g. ISO joins parts
+      # with "-", NIST joins subpart with ".").
       def render(context: nil)
         value.to_s
       end
 
-      # Returns hash code for code component
-      # @return [Integer] hash code
-      # @note Memoized for performance
       def hash
-        @hash ||= value.hash
+        [value, prefix, part, subpart, parts].hash
       end
 
-      # Checks equality with another code component
-      # @param other [Object] object to compare with
-      # @return [Boolean] true if equal
+      # rubocop:disable Metrics/AbcSize
       def eql?(other)
         return false unless other.is_a?(self.class)
 
-        value == other.value
+        value == other.value &&
+          prefix == other.prefix &&
+          part == other.part &&
+          subpart == other.subpart &&
+          parts == other.parts
       end
+      # rubocop:enable Metrics/AbcSize
     end
   end
 end

data/lib/pubid/components/date.rb

@@ -5,40 +5,47 @@ require "lutaml/model"
 module Pubid
   module Components
     # Publication date component
+    #
+    # Human render: "YYYY" or "YYYY-MM" or "YYYY-MM-DD".
+    # URN render: year only (RFC 5141-bis URN spec).
     class Date < Lutaml::Model::Serializable
       attribute :year, :string
       attribute :month, :string
       attribute :day, :string
 
-      # Render date with optional context for flavor-specific formatting
-      #
-      # @param _context [RenderingContext] rendering context
-      #   (for future extensibility)
-      # @param _include_month [Boolean] include month in output
-      #   (for future extensibility)
-      # @return [String] rendered date string
+      # True when the year is set to a non-empty value.
+      def present?
+        !year.nil? && !year.to_s.empty?
+      end
+
       def render(context: nil)
-        to_s
+        return nil unless present?
+        return year.to_s if context&.urn?
+        return year.to_s unless month
+
+        result = "#{year}-#{pad2(month)}"
+        result += "-#{pad2(day)}" if day
+        result
       end
 
       def to_s(_context: nil, _include_month: false)
         return year.to_s unless month
 
-        result = "#{year}-#{month}"
-        result += "-#{day}" if day
+        result = "#{year}-#{pad2(month)}"
+        result += "-#{pad2(day)}" if day
         result
       end
 
-      # Returns hash code for date component
-      # @return [Integer] hash code
-      # @note Memoized for performance
+      private
+
+      def pad2(value)
+        value.to_s.rjust(2, "0")
+      end
+
       def hash
         @hash ||= [year, month, day].compact.map(&:hash).hash
       end
 
-      # Checks equality with another date 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/edition.rb

@@ -3,27 +3,30 @@
 module Pubid
   module Components
     # Edition component (typically a year and number)
+    #
+    # Human render: "ED#{number}".
+    # URN render: "ed-#{number}" per RFC 5141-bis.
     class Edition < Lutaml::Model::Serializable
       attribute :year, :string
-      attribute :number, Lutaml::Model::Type::Value # Accept any value type
-      attribute :original_text, :string # Store the exact parsed edition text
+      attribute :number, Lutaml::Model::Type::Value
+      attribute :original_text, :string
 
       def to_s
-        # Always use canonical format for rendering
         number_value = number.is_a?(Components::Code) ? number.value : number
         number_value ? "ED#{number_value}" : nil
       end
 
-      # V1 API compatibility - tests expect .value on edition itself
       def value
         number.is_a?(Components::Code) ? number.value : number
       end
 
       def render(context: nil)
-        to_s
+        number_value = number.is_a?(Components::Code) ? number.value : number
+        return nil unless number_value
+
+        context&.urn? ? "ed-#{number_value}" : "ED#{number_value}"
       end
 
-      # Method to get the original parsed format if needed
       def original_format
         original_text
       end

data/lib/pubid/components/iteration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Components
+    # Stage iteration component — the numeric suffix on a stage (e.g., "WD.2").
+    #
+    # Renders as the bare number; the caller decides the separator (".")
+    # because URN, MR, and human formats position iteration differently
+    # relative to the stage abbreviation.
+    class Iteration < Lutaml::Model::Serializable
+      attribute :number, :string
+
+      def to_s
+        number.to_s
+      end
+
+      def render(context: nil)
+        number.to_s
+      end
+
+      def hash
+        @hash ||= number.hash
+      end
+
+      def eql?(other)
+        return false unless other.is_a?(self.class)
+
+        number == other.number
+      end
+    end
+  end
+end

data/lib/pubid/components/language.rb

@@ -3,6 +3,9 @@
 module Pubid
   module Components
     # Language component (typically a language code)
+    #
+    # Human render: language code, optionally single-char.
+    # URN render: lowercase ISO 639-1 code (RFC 5141-bis).
     class Language < Lutaml::Model::Serializable
       CHAR_MAP = {
         "R" => "ru",
@@ -13,13 +16,10 @@ module Pubid
         "D" => "de",
       }.freeze
 
-      # code is always an ISO 639-1 two-letter code
       attribute :code, :string, values: CHAR_MAP.values
-      attribute :original_code, :string # Store the actual parsed format
+      attribute :original_code, :string
 
       def to_s(lang_single: false)
-        # When multi-char format requested (lang_single: false) but original was
-        # single-char, normalize to multi-char (for with_edition: true mode)
         if !lang_single && original_code&.length == 1
           code
         elsif original_code
@@ -30,6 +30,8 @@ module Pubid
       end
 
       def render(context: nil, **opts)
+        return code&.downcase if context&.urn?
+
         to_s(**opts)
       end
     end

data/lib/pubid/components/locality.rb

@@ -2,9 +2,18 @@
 
 module Pubid
   module Components
-    # Handles "all parts"
+    # Locality marker (e.g. "all parts")
+    #
+    # Renders the human-readable phrase "(all parts)" and a URN
+    # suffix that completes the locality segment.
     class Locality < Lutaml::Model::Serializable
       attribute :value, :string
+
+      def render(context: nil)
+        return "all" if context&.urn?
+
+        "(all parts)"
+      end
     end
   end
 end

data/lib/pubid/components/publisher.rb

@@ -5,6 +5,9 @@ require "lutaml/model"
 module Pubid
   module Components
     # Publisher ISO, IEC, etc.
+    #
+    # Human render: the publisher body (e.g. "ISO").
+    # URN render: lowercase body (e.g. "iso") per RFC 5141-bis.
     class Publisher < Lutaml::Model::Serializable
       attribute :body, :string
 
@@ -13,19 +16,19 @@ module Pubid
       end
 
       def render(context: nil)
+        return body&.downcase if context&.urn?
+
         body
       end
 
-      # Returns hash code for publisher component
-      # @return [Integer] hash code
-      # @note Memoized for performance
+      def copublished?
+        false
+      end
+
       def hash
         @hash ||= body.hash
       end
 
-      # Checks equality with another publisher 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/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)