pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/cie/urn_generator.rb

@@ -15,8 +15,8 @@ module Pubid
 
         parts << publisher_component
 
-        if identifier.respond_to?(:code_string) && identifier.code_string
-          parts << identifier.code_string
+        if identifier.code
+          parts << identifier.code.to_s
         end
 
         year = extract_year
@@ -37,8 +37,8 @@ module Pubid
         stage = maybe(:stage)
         parts << stage.to_s.downcase if stage
 
-        # style is the sole separator field; record it for dated identifiers
-        parts << "sep.#{maybe(:style)}" if year
+        date_separator = maybe(:date_separator)
+        parts << "sep.#{date_separator}" if date_separator
 
         iec_identifier = maybe(:iec_identifier)
         parts << "iec.#{iec_identifier}" if iec_identifier
@@ -49,14 +49,11 @@ module Pubid
         doc_type = maybe(:doc_type)
         parts << "doctype.#{doc_type}" if doc_type
 
-        if identifier.respond_to?(:ids) && identifier.ids&.any?
-          parts << "bundle.#{identifier}"
-        end
+        identifiers_string = maybe(:identifiers_string)
+        parts << "bundle.#{identifiers_string}" if identifiers_string
 
-        if identifier.is_a?(Cie::Identifiers::TutorialBundle) &&
-           identifier.number
-          parts << "tut-bundle.#{identifier.number}"
-        end
+        bundle_number = maybe(:bundle_number)
+        parts << "tut-bundle.#{bundle_number}" if bundle_number
 
         languages = maybe(:languages)
         if languages&.any?

data/lib/pubid/cie.rb

@@ -2,12 +2,8 @@
 
 module Pubid
   module Cie
-    extend Pubid::PrefixesSupport
-
-    # Sole CIE publisher token (see the parser grammar).
-    PREFIXES = ["CIE"].freeze
-
     module Components
+      autoload :Code, "#{__dir__}/cie/components/code"
       autoload :Language, "#{__dir__}/cie/components/language"
     end
 
@@ -15,67 +11,16 @@ 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)
-      unless input.is_a?(String)
-        raise Pubid::Errors::InvalidInputError,
-              Pubid::INPUT_NOT_A_STRING_MESSAGE
-      end
-
-      if input.length > Pubid::MAX_INPUT_LENGTH
-        raise Pubid::Errors::InvalidInputError, 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/code.rb

@@ -2,46 +2,32 @@
 
 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
-        [value, prefix, part, subpart, parts].hash
+        @hash ||= value.hash
       end
 
-      # rubocop:disable Metrics/AbcSize
+      # Checks equality with another code component
+      # @param other [Object] object to compare with
+      # @return [Boolean] true if equal
       def eql?(other)
         return false unless other.is_a?(self.class)
 
-        value == other.value &&
-          prefix == other.prefix &&
-          part == other.part &&
-          subpart == other.subpart &&
-          parts == other.parts
+        value == other.value
       end
-      # rubocop:enable Metrics/AbcSize
     end
   end
 end

data/lib/pubid/components/date.rb

@@ -5,67 +5,44 @@ require "lutaml/model"
 module Pubid
   module Components
     # Publication date component
-    #
-    # Human render: "YYYY" or "YYYY-MM" or "YYYY-MM-DD"; or "--" when the
-    # date slot is present but explicitly undated (ISO/IEC undated-reference
-    # convention, e.g. "ISO 16634:--"). URN render: year only (RFC 5141-bis
-    # URN spec); flavors that drop the slot when undated gate that decision
-    # at the URN-generator level, not here.
     class Date < Lutaml::Model::Serializable
       attribute :year, :string
       attribute :month, :string
       attribute :day, :string
-      attribute :undated, :boolean, default: false
-
-      # True when the year is set to a non-empty value, OR the date is
-      # explicitly marked undated. An undated date is a meaningful
-      # publication-date slot (it is what renders as `:--` in ISO/IEC), so
-      # callers that gate rendering on "is there a date at all?" should
-      # treat undated as present.
-      def present?
-        return true if undated
-        !year.nil? && !year.to_s.empty?
-      end
-
-      def undated?
-        !!undated
-      end
 
+      # 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
       def render(context: nil)
-        return "--" if undated? && (year.nil? || year.to_s.empty?)
-        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
+        to_s
       end
 
       def to_s(_context: nil, _include_month: false)
-        return "--" if undated? && (year.nil? || year.to_s.empty?)
         return year.to_s unless month
 
-        result = "#{year}-#{pad2(month)}"
-        result += "-#{pad2(day)}" if day
+        result = "#{year}-#{month}"
+        result += "-#{day}" if day
         result
       end
 
-      private
-
-      def pad2(value)
-        value.to_s.rjust(2, "0")
-      end
-
+      # Returns hash code for date component
+      # @return [Integer] hash code
+      # @note Memoized for performance
       def hash
-        @hash ||= [year, month, day, undated].compact.map(&:hash).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)
 
-        year == other.year && month == other.month && day == other.day &&
-          undated == other.undated
+        year == other.year && month == other.month && day == other.day
       end
     end
   end

data/lib/pubid/components/edition.rb

@@ -3,30 +3,27 @@
 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
-      attribute :original_text, :string
+      attribute :number, Lutaml::Model::Type::Value # Accept any value type
+      attribute :original_text, :string # Store the exact parsed edition text
 
       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)
-        number_value = number.is_a?(Components::Code) ? number.value : number
-        return nil unless number_value
-
-        context&.urn? ? "ed-#{number_value}" : "ED#{number_value}"
+        to_s
       end
 
+      # Method to get the original parsed format if needed
       def original_format
         original_text
       end

data/lib/pubid/components/language.rb

@@ -3,9 +3,6 @@
 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",
@@ -16,10 +13,13 @@ 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
+      attribute :original_code, :string # Store the actual parsed format
 
       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,8 +30,6 @@ 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,18 +2,9 @@
 
 module Pubid
   module Components
-    # Locality marker (e.g. "all parts")
-    #
-    # Renders the human-readable phrase "(all parts)" and a URN
-    # suffix that completes the locality segment.
+    # Handles "all parts"
     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,9 +5,6 @@ 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
 
@@ -16,19 +13,19 @@ module Pubid
       end
 
       def render(context: nil)
-        return body&.downcase if context&.urn?
-
         body
       end
 
-      def copublished?
-        false
-      end
-
+      # Returns hash code for publisher component
+      # @return [Integer] hash code
+      # @note Memoized for performance
       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/stage.rb

@@ -1,19 +1,23 @@
 # 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
 
@@ -21,20 +25,25 @@ 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/type.rb

@@ -1,21 +1,26 @@
 # 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
@@ -24,20 +29,25 @@ 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,21 +1,18 @@
+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
-      attribute :short_abbr, :string
-      attribute :long_abbr, :string
+      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
 
       def to_stage
         Stage.new(
@@ -35,21 +32,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
+          abbr.first # Fallback to canonical
         end
       end
 
+      # Returns the canonical (normalized) abbreviation, always abbr.first
       def canonical_abbreviation
         abbr.first
       end

data/lib/pubid/components.rb

@@ -2,17 +2,13 @@
 
 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,24 +15,18 @@ 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 with flags:   "/^nbs\\b/i"          →  "NBS"
+    #   regex match:        "/^NBS CIRC sup$/"  →  "NBS CIRC 24e7sup"
     #
     # Plain strings use full-line anchoring (^pattern$).
-    # Regex patterns are wrapped in /.../ slashes with optional trailing flags
-    # (i = IGNORECASE, m = MULTILINE, x = EXTENDED) and applied via gsub.
+    # Regex patterns are wrapped in /.../ slashes.
     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
@@ -43,7 +37,9 @@ module Pubid
           return code if codes.nil? || codes.empty?
 
           codes.each do |from, to|
-            code = code.gsub(compile_pattern(from), to.to_s)
+            code = code.gsub(
+              from.match?(%r{^/.*/$}) ? Regexp.new(from[1..-2]) : /^#{Regexp.escape(from)}$/, to
+            )
           end
           code
         end
@@ -60,30 +56,13 @@ module Pubid
 
         # Available flavors that have update_codes files.
         #
-        # @return [Array<Symbol>] flavors with data/{flavor}/update_codes.yaml
+        # @return [Array<Symbol>] list of 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)