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

data/lib/pubid/cie/identifier.rb

@@ -2,70 +2,19 @@
 
 module Pubid
   module Cie
-    # Base Identifier class for CIE
-    # Provides parse() entry point
-    class Identifier < Lutaml::Model::Serializable
+    # Base Identifier class for CIE.
+    #
+    # Inherits the shared Pubid::Identifier contract (format_registry, render,
+    # to_urn, exclude, hash, eql?) while allowing CIE-specific attributes
+    # such as +style+ ("legacy" vs "current" date separator).
+    class Identifier < ::Pubid::Identifier
       attribute :style, :string # "legacy" or "current"
 
-      # Parse CIE identifier string
       def self.parse(input)
         parsed = Parser.parse(input)
         builder = Builder.new
         builder.build(parsed, original_string: input)
       end
-
-      # Factory that builds a CIE identifier from a hash of primitives.
-      # Dispatch on `:type` to a SingleIdentifier subclass; default is
-      # {Identifiers::Standard}.
-      TYPE_KEY_TO_KLASS = {
-        standard:        "Standard",
-        conference:      "Conference",
-        bundle:          "Bundle",
-        joint_published: "JointPublished",
-        dual_published:  "DualPublished",
-        identical:       "Identical",
-        tutorial_bundle: "TutorialBundle",
-      }.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 CIE type: #{type.inspect}" unless klass_name
-
-        Identifiers.const_get(klass_name)
-      end
-
-      def self.coerce_create_attrs(opts, klass:)
-        attrs = {}
-        attrs[:year] = opts[:year].to_s if opts[:year]
-        attrs[:date_separator] = opts[:date_separator].to_s if opts[:date_separator]
-
-        if (v = opts[:code] || opts[:number])
-          attrs[:code] = Pubid::Cie::Components::Code.new(
-            number:         v.to_s,
-            part:           opts[:part]&.to_s,
-            iteration:      opts[:iteration]&.to_s,
-            style:          opts[:style]&.to_s,
-            part_separator: opts[:part_separator]&.to_s,
-          )
-        end
-
-        # Standard-only attributes
-        if klass.attributes.key?(:s_prefix) && opts.key?(:s_prefix)
-          attrs[:s_prefix] = opts[:s_prefix]
-        end
-        if klass.attributes.key?(:stage) && opts[:stage]
-          attrs[:stage] = opts[:stage].to_s
-        end
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end

data/lib/pubid/cie/urn_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    # Parses CIE URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:cie:cie:{code}:{year}:sep.colon
+    #
+    # The trailing `sep.colon` token records the code/year separator used
+    # in the human-readable form (`:`). The leading `cie` after the
+    # namespace is the lowercase publisher.
+    #
+    # Examples:
+    # - urn:cie:cie:015:2018:sep.colon → CIE 015:2018
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body).reject { |p| p.start_with?("sep.") }
+
+        _publisher, code, year = parts
+        text = "CIE #{code}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

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)