pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/cie/scheme.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Standard,
+            Identifiers::Conference,
+            Identifiers::Bundle,
+            Identifiers::DualPublished,
+            Identifiers::Identical,
+            Identifiers::JointPublished,
+            Identifiers::Supplement,
+            Identifiers::TutorialBundle,
+          ]
+        end
+
+        def supplement_identifiers
+          [
+            Identifiers::Corrigendum,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def supplement_typed_stages
+          supplement_identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "" if abbr.nil?
+
+          typed_stage = (typed_stages + supplement_typed_stages).detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          identifier_klass = (identifiers + supplement_identifiers).detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cie/single_identifier.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    # Base class for single CIE identifiers (standards, conferences, etc.)
+    # Single Responsibility: Provide common attributes for base documents
+    #
+    # Single identifiers are base documents that can exist independently,
+    # as opposed to supplement identifiers (amendments, corrigenda) which
+    # modify a base identifier.
+    #
+    # Classes inheriting from SingleIdentifier:
+    # - Standard (common CIE publications)
+    # - Conference (conference proceedings)
+    # - Bundle (bundles of multiple identifiers)
+    # - JointPublished (co-published with ISO/IEC)
+    # - DualPublished (dual published with IEC)
+    # - Identical (identical to ISO publications)
+    # - TutorialBundle (tutorial bundles)
+    class SingleIdentifier < Identifier
+      # CIE uses a fixed publisher string
+      def publisher
+        "CIE"
+      end
+
+      attribute :year, :string
+      attribute :date_separator, :string # "dash" or "colon"
+    end
+  end
+end

data/lib/pubid/cie/supplement_identifier.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    # Base class for CIE supplement identifiers
+    # Single Responsibility: Provide common attributes for supplement documents
+    #
+    # Supplement identifiers modify or extend base identifiers.
+    # Unlike ISO/IEC, CIE supplements store base information as flat
+    # string attributes rather than recursive Identifier objects.
+    #
+    # Classes inheriting from SupplementIdentifier:
+    # - Corrigendum (corrigenda with /CorN notation)
+    # - Supplement (supplements with -SPN notation)
+    #
+    # Architecture Note:
+    # CIE uses a different architectural approach than ISO/IEC:
+    # - ISO/IEC: Recursive base_identifier objects
+    # - CIE: Flat string attributes (base_number, base_year, etc.)
+    class SupplementIdentifier < Identifier
+      # Common attribute for all CIE identifiers
+      # Values: "current" (colon date separator) or "legacy" (dash date separator)
+      attribute :style, :string
+    end
+  end
+end

data/lib/pubid/cie/urn_generator.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "cie"]
+
+        special_type = special_identifier_type_component
+        parts << special_type if special_type
+
+        if maybe(:s_prefix)
+          parts << "s"
+        end
+
+        parts << publisher_component
+
+        if identifier.code
+          parts << identifier.code.to_s
+        end
+
+        year = extract_year
+        parts << year.to_s if year
+
+        language = maybe(:language)
+        if language
+          if language&.code
+            parts << language.code.to_s.downcase
+            if language&.format
+              parts << language.format.to_s.downcase
+            end
+          else
+            parts << language.to_s.downcase
+          end
+        end
+
+        stage = maybe(:stage)
+        parts << stage.to_s.downcase if stage
+
+        date_separator = maybe(:date_separator)
+        parts << "sep.#{date_separator}" if date_separator
+
+        iec_identifier = maybe(:iec_identifier)
+        parts << "iec.#{iec_identifier}" if iec_identifier
+
+        iso_reference = maybe(:iso_reference)
+        parts << "iso.#{iso_reference}" if iso_reference
+
+        doc_type = maybe(:doc_type)
+        parts << "doctype.#{doc_type}" if doc_type
+
+        identifiers_string = maybe(:identifiers_string)
+        parts << "bundle.#{identifiers_string}" if identifiers_string
+
+        bundle_number = maybe(:bundle_number)
+        parts << "tut-bundle.#{bundle_number}" if bundle_number
+
+        languages = maybe(:languages)
+        if languages&.any?
+          lang_codes = languages.map(&:code).join(",")
+          parts << lang_codes
+        end
+
+        parts.join(":")
+      end
+
+      private
+
+      def extract_year
+        year = maybe(:year)
+        return year if year
+
+        date = identifier.date
+        if date
+          return date.year
+        end
+
+        nil
+      end
+
+      def special_identifier_type_component
+        return nil unless identifier.class
+
+        class_name = identifier.class.name.to_s
+        case class_name
+        when /DualPublished/
+          "dual-pub"
+        when /Identical/
+          "identical"
+        when /JointPublished/
+          "joint-pub"
+        when /Bundle$/
+          "bundle"
+        when /TutorialBundle/
+          "tut-bundle"
+        end
+      end
+
+      def publisher_component
+        pub = "cie"
+
+        if identifier.publisher
+          p = identifier.publisher.to_s
+          pub = p.to_s.downcase
+        end
+
+        copublisher = maybe(:copublisher)
+        if copublisher
+          cp = copublisher.to_s
+          pub = "#{pub}-#{cp.to_s.downcase}"
+        else
+          copubs = maybe(:copublishers)
+          if copubs&.any?
+            cp = copubs.map(&:to_s)
+            pub = "#{pub}-#{cp.join('-').downcase}"
+          end
+        end
+
+        pub
+      end
+    end
+  end
+end

data/lib/pubid/cie.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    module Components
+      autoload :Code, "#{__dir__}/cie/components/code"
+      autoload :Language, "#{__dir__}/cie/components/language"
+    end
+
+    autoload :Builder, "#{__dir__}/cie/builder"
+    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"
+
+    # Main entry point for CIE identifiers
+    # Delegates to Identifier.parse
+    def self.parse(input)
+      Identifier.parse(input)
+    end
+  end
+end
+
+# Register Ucie flavor with the registry
+Pubid::Registry.register(:cie, Pubid::Cie)

data/lib/pubid/components/code.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Components
+    class Code < Lutaml::Model::Serializable
+      attribute :value, :string
+
+      def to_s
+        value.to_s
+      end
+
+      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
+      end
+
+      # 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
+      end
+    end
+  end
+end

data/lib/pubid/components/date.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Components
+    # Publication date component
+    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
+      def render(context: nil)
+        to_s
+      end
+
+      def to_s(_context: nil, _include_month: false)
+        return year.to_s unless month
+
+        result = "#{year}-#{month}"
+        result += "-#{day}" if day
+        result
+      end
+
+      # Returns hash code for date component
+      # @return [Integer] hash code
+      # @note Memoized for performance
+      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)
+
+        year == other.year && month == other.month && day == other.day
+      end
+    end
+  end
+end

data/lib/pubid/components/edition.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Components
+    # Edition component (typically a year and number)
+    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
+
+      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
+      end
+
+      # Method to get the original parsed format if needed
+      def original_format
+        original_text
+      end
+    end
+  end
+end

data/lib/pubid/components/factory.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "code"
+require_relative "date"
+require_relative "edition"
+require_relative "language"
+require_relative "publisher"
+
+module Pubid
+  module Components
+    # Coerces loose primitive kwargs (matching pubid 1.x's `Identifier.create`
+    # signature) into the structured Component objects pubid 2.x expects.
+    #
+    # Used by per-flavor `.create` factories.
+    module Factory
+      # Per-kwarg coercer. Returns a Component, or an Array<Component> for
+      # collection attributes such as `languages`.
+      COERCERS = {
+        publisher: ->(v) { Publisher.new(body: v.to_s) },
+        number:    ->(v) { Code.new(value: v.to_s) },
+        part:      ->(v) { Code.new(value: v.to_s) },
+        subpart:   ->(v) { Code.new(value: v.to_s) },
+        year:      ->(v) { Date.new(year: v.to_s) },
+        edition:   ->(v) { Edition.new(number: v) },
+        language:  ->(v) { [Language.new(code: v.to_s)] },
+      }.freeze
+
+      # 1.x kwarg name → 2.x attribute name.
+      # Applied after coercion.
+      KEY_RENAMES = {
+        year: :date,
+        language: :languages,
+      }.freeze
+
+      # Convert a hash of 1.x-style primitive kwargs into a hash of 2.x-style
+      # Component-valued attributes ready for `<IdentifierClass>.new(...)`.
+      #
+      # Unknown keys pass through unchanged; nil values are dropped.
+      def self.from_hash(opts)
+        opts.each_with_object({}) do |(k, v), out|
+          next if v.nil?
+
+          target = KEY_RENAMES.fetch(k, k)
+          coercer = COERCERS[k]
+          out[target] = coercer ? coercer.call(v) : v
+        end
+      end
+    end
+  end
+end

data/lib/pubid/components/language.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Components
+    # Language component (typically a language code)
+    class Language < Lutaml::Model::Serializable
+      CHAR_MAP = {
+        "R" => "ru",
+        "F" => "fr",
+        "E" => "en",
+        "A" => "ar",
+        "S" => "es",
+        "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
+
+      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
+          original_code
+        else
+          lang_single ? CHAR_MAP.key(code) : code
+        end
+      end
+
+      def render(context: nil, **opts)
+        to_s(**opts)
+      end
+    end
+  end
+end

data/lib/pubid/components/locality.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Components
+    # Handles "all parts"
+    class Locality < Lutaml::Model::Serializable
+      attribute :value, :string
+    end
+  end
+end

data/lib/pubid/components/publisher.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Components
+    # Publisher ISO, IEC, etc.
+    class Publisher < Lutaml::Model::Serializable
+      attribute :body, :string
+
+      def to_s
+        body
+      end
+
+      def render(context: nil)
+        body
+      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)
+
+        body == other.body
+      end
+    end
+  end
+end

data/lib/pubid/components/stage.rb

@@ -0,0 +1,54 @@
+# 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)
+    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
+
+        if context
+          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)
+        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)
+
+        stage_code == other.stage_code && abbr == other.abbr
+      end
+    end
+  end
+end

data/lib/pubid/components/type.rb

@@ -0,0 +1,58 @@
+# 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)
+    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
+
+        if context
+          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)
+        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)
+
+        type_code == other.type_code && abbr == other.abbr
+      end
+    end
+  end
+end