pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

data/lib/pubid/cen_cenelec.rb

@@ -6,16 +6,187 @@ module Pubid
     autoload :Identifier, "#{__dir__}/cen_cenelec/identifier"
     autoload :Identifiers, "#{__dir__}/cen_cenelec/identifiers"
     autoload :Parser, "#{__dir__}/cen_cenelec/parser"
-    autoload :Scheme, "#{__dir__}/cen_cenelec/scheme"
+    autoload :Renderer, "#{__dir__}/cen_cenelec/renderer"
     autoload :SingleIdentifier, "#{__dir__}/cen_cenelec/single_identifier"
     autoload :SupplementIdentifier,
              "#{__dir__}/cen_cenelec/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/cen_cenelec/urn_generator"
+    autoload :UrnParser, "#{__dir__}/cen_cenelec/urn_parser"
+
+    # TYPED_STAGES_REGISTRY for native CEN types
+    TYPED_STAGES_REGISTRY = [
+      # European Norm (EN)
+      Pubid::Components::TypedStage.new(
+        code: :puben,
+        stage_code: :published,
+        type_code: :en,
+        abbr: ["EN"],
+        name: "European Norm",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+      Pubid::Components::TypedStage.new(
+        code: :pren,
+        stage_code: :proposal,
+        type_code: :en,
+        abbr: ["prEN"],
+        name: "Proposal European Norm",
+        harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+      ),
+      Pubid::Components::TypedStage.new(
+        code: :fpren,
+        stage_code: :final_proposal,
+        type_code: :en,
+        abbr: ["FprEN"],
+        name: "Final Proposal European Norm",
+        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.98 40.99],
+      ),
+
+      # Technical Specification (TS)
+      Pubid::Components::TypedStage.new(
+        code: :pubts,
+        stage_code: :published,
+        type_code: :ts,
+        abbr: ["TS"],
+        name: "Technical Specification",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+      Pubid::Components::TypedStage.new(
+        code: :prts,
+        stage_code: :proposal,
+        type_code: :ts,
+        abbr: ["prTS"],
+        name: "Proposal Technical Specification",
+        harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+      ),
+
+      # Technical Report (TR)
+      Pubid::Components::TypedStage.new(
+        code: :pubtr,
+        stage_code: :published,
+        type_code: :tr,
+        abbr: ["TR"],
+        name: "Technical Report",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # CEN Workshop Agreement (CWA)
+      Pubid::Components::TypedStage.new(
+        code: :pubcwa,
+        stage_code: :published,
+        type_code: :cwa,
+        abbr: ["CWA"],
+        name: "CEN Workshop Agreement",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Guide
+      Pubid::Components::TypedStage.new(
+        code: :pubguide,
+        stage_code: :published,
+        type_code: :guide,
+        abbr: ["Guide"],
+        name: "Guide",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Harmonization Document (HD)
+      Pubid::Components::TypedStage.new(
+        code: :pubhd,
+        stage_code: :published,
+        type_code: :hd,
+        abbr: ["HD"],
+        name: "Harmonization Document",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # European Specification (ES)
+      Pubid::Components::TypedStage.new(
+        code: :pubes,
+        stage_code: :published,
+        type_code: :es,
+        abbr: ["ES"],
+        name: "European Specification",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # CEN Report (CR)
+      Pubid::Components::TypedStage.new(
+        code: :pubcr,
+        stage_code: :published,
+        type_code: :cr,
+        abbr: ["CR"],
+        name: "CEN Report",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # European Prestandard (ENV)
+      Pubid::Components::TypedStage.new(
+        code: :pubenv,
+        stage_code: :published,
+        type_code: :env,
+        abbr: ["ENV"],
+        name: "European Prestandard",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+    ].freeze
+
+    # Default typed stage for when no match is found
+    DEFAULT_TYPED_STAGE = Pubid::Components::TypedStage.new(
+      code: :puben,
+      stage_code: :published,
+      type_code: :en,
+      abbr: ["EN"],
+      name: "European Norm",
+      harmonized_stages: %w[60.00 60.60],
+    ).freeze
 
     def self.parse(identifier)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       CenCenelec::Identifier.parse(identifier)
     end
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    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.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from the module's TYPED_STAGES_REGISTRY
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      TYPED_STAGES_REGISTRY
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    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
 
 Pubid::Registry.register(:cen_cenelec, Pubid::CenCenelec)
+Pubid::Registry.register(:cen, Pubid::CenCenelec)
+
+# Per-flavor format registry: inherits global formats, overrides :human
+# Register on both root hierarchies: SingleIdentifier and Identifiers::Base
+cen_renderer = Pubid::CenCenelec::Renderer
+Pubid::CenCenelec::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::CenCenelec::SingleIdentifier.format_registry.register(:human, renderer: cen_renderer)
+Pubid::CenCenelec::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::CenCenelec::Identifiers::Base.format_registry.register(:human, renderer: cen_renderer)

data/lib/pubid/cie/components/code.rb

@@ -7,6 +7,10 @@ module Pubid
     module Components
       # Code component for CIE identifiers
       # Handles number-part-iteration with style awareness
+      #
+      # Stays independent of Pubid::Components::Code because CIE tracks
+      # +style+ ("legacy" / "current") and +part_separator+ to round-trip
+      # slash vs dash notation, plus an +iteration+ sub-field.
       class Code < Lutaml::Model::Serializable
         attribute :number, :string        # "013", "170", "198"
         attribute :part, :string          # "1", "2", "3"
@@ -66,6 +70,10 @@ module Pubid
             new(number: code_str, style: style)
           end
         end
+
+        def render(context: nil)
+          to_s
+        end
       end
     end
   end

data/lib/pubid/cie/identifier.rb

@@ -2,70 +2,23 @@
 
 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)
+        if input.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         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/single_identifier.rb

@@ -18,10 +18,10 @@ module Pubid
     # - Identical (identical to ISO publications)
     # - TutorialBundle (tutorial bundles)
     class SingleIdentifier < Identifier
-      # CIE uses a fixed publisher string
-      def publisher
-        "CIE"
-      end
+      # Stored as a plain string (always "CIE") so it round-trips through
+      # to_hash/from_hash. Was a `def publisher` method, which made lutaml
+      # serialize a String against the Components::Publisher attribute and raise.
+      attribute :publisher, :string, default: -> { "CIE" }
 
       attribute :year, :string
       attribute :date_separator, :string # "dash" or "colon"

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,62 @@ 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)
+      if input.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       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