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

data/lib/pubid/rendering/common.rb

@@ -1,211 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Rendering
-    # Common rendering methods for identifier string representation
-    #
-    # This module extracts duplicated rendering logic across flavors
-    # to reduce code duplication and ensure consistency.
-    #
-    # == Usage
-    #
-    # Include this module in flavor-specific identifier base classes:
-    #
-    #   class Base < ::Pubid::Identifier
-    #     include Pubid::Rendering::Common
-    #
-    #     def to_s(lang: :en, lang_single: false, with_edition: false)
-    #       render_identifier(lang: lang, lang_single: lang_single, with_edition: with_edition)
-    #     end
-    #   end
-    #
-    module Common
-      # Render publisher with optional copublishers
-      #
-      # @param publisher [Components::Publisher] publisher component
-      # @param copublisher_separator [String] separator for copublishers (default: "/")
-      # @return [String] formatted publisher string
-      def render_publisher(publisher, copublisher_separator: "/")
-        return "" unless publisher
-
-        result = publisher.to_s
-        cops = publisher.is_a?(Components::Publisher) ? publisher.copublisher : nil
-        if cops&.any?
-          result += cops.map do |cp|
-            "#{copublisher_separator}#{cp}"
-          end.join
-        end
-        result
-      end
-
-      # Render stage and type abbreviations with proper separators
-      #
-      # @param stage [Components::Stage] stage component
-      # @param type [Components::Type] type component
-      # @param has_copublisher [Boolean] whether identifier has copublisher
-      # @param default_type_abbr [String] default type abbreviation to skip (default: "IS")
-      # @param stage_separator [String] separator before stage without copublisher
-      # @return [String] formatted stage/type string
-      def render_stage_type(stage, type, has_copublisher: false,
-                           default_type_abbr: "IS",
-                           stage_separator: "/")
-        result = ""
-
-        # Add stage abbreviation if present
-        if stage&.abbr
-          sep = has_copublisher ? " " : stage_separator
-          result += "#{sep}#{stage.abbr}"
-        end
-
-        # Add type abbreviation if present and not default
-        if type&.abbr && type.abbr != default_type_abbr
-          # Separator: space after stage or copublisher, slash otherwise
-          has_prefix = stage&.abbr || has_copublisher
-          sep = has_prefix ? " " : stage_separator
-          result += "#{sep}#{type.abbr}"
-        end
-
-        result
-      end
-
-      # Render number with optional parts
-      #
-      # @param number [Components::Code] primary number component
-      # @param part [Components::Code] optional part component
-      # @param subpart [Components::Code] optional subpart component
-      # @param part_separator [String] separator for parts (default: "-")
-      # @return [String] formatted numbering string
-      def render_numbering(number, part = nil, subpart = nil,
-part_separator: "-")
-        return "" unless number&.value
-
-        result = " #{number.value}"
-        result += "#{part_separator}#{part.value}" if part&.value
-        result += "#{part_separator}#{subpart.value}" if subpart&.value
-        result
-      end
-
-      # Render stage iteration (e.g., ".1" for stage iteration)
-      #
-      # @param stage_iteration [Components::Code] stage iteration component
-      # @return [String] formatted stage iteration or empty string
-      def render_stage_iteration(stage_iteration)
-        stage_iteration&.value ? ".#{stage_iteration.value}" : ""
-      end
-
-      # Render date with optional year/month/day
-      #
-      # @param date [Components::Date] date component
-      # @param include_month [Boolean] include month in output
-      # @param date_separator [String] separator for date parts (default: "-")
-      # @return [String] formatted date string or empty string
-      def render_date(date, include_month: false, date_separator: "-")
-        return "" unless date&.year
-
-        result = ":#{date.year}"
-        if date.month && include_month
-          result += "#{date_separator}#{format('%02d', date.month)}"
-          result += "#{date_separator}#{format('%02d', date.day)}" if date.day
-        end
-        result
-      end
-
-      # Render language codes
-      #
-      # @param languages [Array<Components::Language>] language components
-      # @param lang_single [Boolean] use single character format
-      # @param lang_separator [String] separator between languages (default: "/")
-      # @return [String] formatted language string or empty string
-      def render_languages(languages, lang_single: false, lang_separator: "/")
-        return "" unless languages&.any?
-
-        formatted = languages.map do |l|
-          l.to_s(lang_single: lang_single)
-        end.join(lang_separator)
-        "(#{formatted})"
-      end
-
-      # Render edition component
-      #
-      # @param edition [Components::Edition] edition component
-      # @param with_prefix [Boolean] include prefix (default: true)
-      # @return [String] formatted edition string or empty string
-      def render_edition(edition, with_prefix: true)
-        return "" unless edition
-
-        if with_prefix
-          edition.to_s
-        else
-          " #{edition}"
-        end
-      end
-
-      # Check if publisher has copublishers
-      #
-      # @param publisher [Components::Publisher] publisher component
-      # @return [Boolean] true if has copublishers
-      def publisher_has_copublisher?(publisher)
-        publisher.is_a?(Components::Publisher) && publisher.has_copublisher?
-      end
-
-      # Get publisher body/name
-      #
-      # @param publisher [Components::Publisher] publisher component
-      # @return [String] publisher body
-      def publisher_body(publisher)
-        publisher.is_a?(Components::Publisher) ? publisher.body : publisher.to_s
-      end
-
-      # Get copublishers as array
-      #
-      # @param publisher [Components::Publisher] publisher component
-      # @return [Array<String>] array of copublisher names
-      def copublishers_list(publisher)
-        return [] unless publisher.is_a?(Components::Publisher) && publisher.copublisher&.any?
-
-        publisher.copublisher.map { |cp| publisher_body(cp) }
-      end
-
-      # Render full identifier with all components
-      #
-      # This is a convenience method that combines all rendering methods
-      # in the standard order for most identifier types.
-      #
-      # @param publisher [Components::Publisher] publisher component
-      # @param stage [Components::Stage] stage component
-      # @param type [Components::Type] type component
-      # @param number [Components::Code] number component
-      # @param part [Components::Code] part component
-      # @param subpart [Components::Code] subpart component
-      # @param stage_iteration [Components::Code] stage iteration component
-      # @param date [Components::Date] date component
-      # @param edition [Components::Edition] edition component
-      # @param languages [Array<Components::Language>] language components
-      # @param lang [Symbol] language for rendering (:en or :fr)
-      # @param lang_single [Boolean] use single char language format
-      # @param with_edition [Boolean] include edition in output
-      # @param default_type_abbr [String] default type abbreviation to skip
-      # @return [String] formatted identifier string
-      def render_full_identifier(publisher:, stage: nil, type: nil,
-                                 number: nil, part: nil, subpart: nil,
-                                 stage_iteration: nil, date: nil,
-                                 edition: nil, languages: nil,
-                                 lang: :en, lang_single: false,
-                                 with_edition: false,
-                                 default_type_abbr: "IS")
-        result = render_publisher(publisher)
-        result += render_stage_type(stage, type,
-                                    has_copublisher: publisher_has_copublisher?(
-                                      publisher,
-                                    ),
-                                    default_type_abbr: default_type_abbr)
-        result += render_numbering(number, part, subpart)
-        result += render_stage_iteration(stage_iteration) if stage_iteration
-        result += render_date(date)
-        result += render_edition(edition) if with_edition && edition
-        result += render_languages(languages, lang_single: lang_single)
-        result
-      end
-    end
-  end
-end

data/lib/pubid/rendering/format.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Rendering
-    module Format
-      # Dispatch to appropriate format renderer
-      # @param format [Symbol] target format
-      # @return [String] formatted identifier string
-      def to_s(format = nil)
-        effective_format = determine_format(format)
-        send(:"to_#{effective_format}_style")
-      end
-
-      private
-
-      def determine_format(format)
-        return :short unless format
-        return :mr if format.to_sym == :mr
-        return :full if %i[full long].include?(format.to_sym)
-
-        :short
-      end
-    end
-  end
-end

data/lib/pubid/sae/scheme.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Sae
-    class Scheme < Pubid::Scheme
-      class << self
-        def identifiers
-          [
-            Identifiers::Base,
-          ]
-        end
-
-        def typed_stages
-          identifiers.flat_map { |klass| klass::TYPED_STAGES }
-        end
-
-        def locate_typed_stage_by_abbr(abbr)
-          abbr = "SAE" if abbr.nil? || abbr.to_s.empty?
-
-          typed_stage = 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.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/scheme.rb

@@ -1,219 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  # Base Scheme class defining the standard interface for all flavor schemes.
-  #
-  # The Scheme acts as a registry for identifier types and their associated
-  # typed stages. Each flavor (ISO, IEC, IEEE, etc.) should have a Scheme that
-  # implements this interface.
-  #
-  # == Standard Interface
-  #
-  # All Scheme implementations must provide these methods:
-  #
-  # - locate_typed_stage_by_abbr(abbr) -> Find a TypedStage by abbreviation
-  # - locate_identifier_klass_by_type_code(type_code) -> Find an identifier class
-  # - typed_stages -> Get all typed stages for base identifiers
-  # - supplement_typed_stages -> Get typed stages for supplements
-  # - all_typed_stages -> Get all typed stages combined
-  # - identifiers -> Get all base identifier classes
-  # - supplement_identifiers -> Get all supplement identifier classes
-  # - all_identifier_classes -> Get all identifier classes combined
-  #
-  # == Implementation Patterns
-  #
-  # There are several valid patterns for implementing a Scheme:
-  #
-  # 1. Class-based (ISO, IEEE, JCGM, JIS, CCSDS, ASHRAE):
-  #    Use class << self with class methods
-  #
-  # 2. Instance-based with constants (BSI, CEN):
-  #    Use TYPED_STAGES_REGISTRY and instance methods
-  #
-  # 3. Transform-based (ITU):
-  #    Use model_class and transform methods (no typed stages)
-  #
-  # 4. Data class (ETSI, Plateau):
-  #    Use Lutaml::Model::Serializable as a data model
-  #
-  # 5. Inheritance-based (AMCA):
-  #    Inherit from Pubid::Scheme base class
-  #
-  # == Performance
-  #
-  # All registry lookups are memoized for performance. Callers can rely on
-  # repeated calls being O(1) after the first call.
-  #
-  class Scheme
-    # Registry of identifiers for this scheme
-    attr_accessor :identifiers,
-                  :stages,
-                  :types,
-                  :languages,
-                  :publishers,
-                  :supplement_identifiers
-
-    def initialize(
-      identifiers: [], stages: [], types: [], languages: [], publishers: [],
-      supplement_identifiers: []
-    )
-      @identifiers = identifiers
-      @supplement_identifiers = supplement_identifiers
-      @stages = stages
-      @types = types
-      @languages = languages
-      @publishers = publishers
-    end
-
-    def configure
-      yield self if block_given?
-    end
-
-    # Get all typed stages for base identifiers
-    # @return [Array<TypedStage>] All typed stages from identifiers
-    # @note Memoized for performance
-    def typed_stages
-      return @typed_stages if defined?(@typed_stages)
-
-      @typed_stages = @identifiers.filter_map do |identifier_class|
-        identifier_class.const_defined?(:TYPED_STAGES) ? identifier_class.const_get(:TYPED_STAGES) : nil
-      end.flatten
-    end
-
-    # Get all typed stages for supplement identifiers
-    # @return [Array<TypedStage>] All typed stages from supplement identifiers
-    # @note Memoized for performance
-    def supplement_typed_stages
-      return @supplement_typed_stages if defined?(@supplement_typed_stages)
-
-      @supplement_typed_stages = @supplement_identifiers.filter_map do |identifier_class|
-        identifier_class.const_defined?(:TYPED_STAGES) ? identifier_class.const_get(:TYPED_STAGES) : nil
-      end.flatten
-    end
-
-    # Get all typed stages (base + supplements), sorted by abbreviation
-    # @return [Array<TypedStage>] All typed stages sorted by abbreviation
-    # @note Memoized for performance
-    def all_typed_stages
-      return @all_typed_stages if defined?(@all_typed_stages)
-
-      @all_typed_stages = (typed_stages + supplement_typed_stages).sort_by do |ts|
-        (ts.abbr.first || "").to_s
-      end.reverse
-    end
-
-    # Locate a TypedStage by abbreviation
-    # @param abbr [String, Symbol] The abbreviation to find
-    # @return [TypedStage, nil] The matching TypedStage, or nil if not found
-    # @note Uses hash-based index for O(1) lookup, falls back to linear search
-    def locate_typed_stage_by_abbr(abbr)
-      abbr = "" if abbr.nil? || abbr.to_s.strip.empty?
-
-      # Try hash-based index first (O(1))
-      typed_stage = typed_stage_index[abbr]
-
-      # Fall back to linear search if not found (for abbreviations with
-      # special formatting or edge cases)
-      typed_stage || all_typed_stages.detect do |ts|
-        ts.abbr.include?(abbr)
-      end
-    end
-
-    # Locate a TypedStage by stage code
-    # @param stage_code [String, Symbol] The stage code to find
-    # @return [TypedStage, nil] The matching TypedStage, or nil if not found
-    # @note Uses linear search for stage code lookup
-    def locate_typed_stage_by_stage_code(stage_code)
-      stage_code_sym = stage_code.to_sym
-
-      all_typed_stages.detect do |ts|
-        ts.stage_code.to_sym == stage_code_sym
-      end
-    end
-
-    # Locate a TypedStage by its unique per-typed-stage code
-    # @param code [String, Symbol] The code to find (e.g. :dtr, :fdisp)
-    # @return [TypedStage, nil] The matching TypedStage, or nil if not found
-    # @note Uses linear search for code lookup
-    def locate_typed_stage_by_code(code)
-      code_sym = code.to_sym
-
-      all_typed_stages.detect do |ts|
-        ts.code&.to_sym == code_sym
-      end
-    end
-
-    # Locate a TypedStage by harmonized stage code
-    # @param harmonized_code [String] The harmonized stage code to find (e.g., "00.00", "10.00")
-    # @return [TypedStage, nil] The matching TypedStage, or nil if not found
-    # @note Uses linear search to check harmonized_stages arrays
-    def locate_typed_stage_by_harmonized_code(harmonized_code)
-      harmonized_str = harmonized_code.to_s
-
-      all_typed_stages.detect do |ts|
-        ts.harmonized_stages&.include?(harmonized_str)
-      end
-    end
-
-    # Hash-based index of typed stages by abbreviation
-    # @return [Hash<String, TypedStage>] index mapping abbreviations to typed stages
-    # @note Memoized for O(1) lookup performance
-    def typed_stage_index
-      @typed_stage_index ||= build_typed_stage_index
-    end
-
-    # Get all identifier classes sorted by type key
-    # @return [Array<Class>] All identifier classes sorted by type key
-    # @note Memoized for performance
-    def all_identifier_classes
-      return @all_identifier_classes if defined?(@all_identifier_classes)
-
-      @all_identifier_classes = (@identifiers + @supplement_identifiers).sort_by do |klass|
-        (klass.type&.dig(:key) || "").to_s
-      end
-    end
-    alias all_identifier_classes_by_type_code all_identifier_classes
-
-    # Locate an identifier class by type code
-    # @param type_code [String, Symbol] The type code to find
-    # @return [Class, nil] The matching identifier class, or nil if not found
-    # @note Uses hash-based index for O(1) lookup, falls back to linear search
-    def locate_identifier_klass_by_type_code(type_code)
-      type_str = type_code.to_s
-
-      # Try hash-based index first (O(1))
-      identifier_klass = identifier_class_index[type_str]
-
-      # Fall back to linear search if not found
-      identifier_klass || all_identifier_classes.detect do |identifier_class|
-        identifier_class.type&.dig(:key)&.to_s == type_str
-      end
-    end
-
-    # Hash-based index of identifier classes by type code
-    # @return [Hash<String, Class>] index mapping type codes to identifier classes
-    # @note Memoized for O(1) lookup performance
-    def identifier_class_index
-      @identifier_class_index ||= build_identifier_class_index
-    end
-
-    protected
-
-    # Build hash-based index of typed stages by abbreviation
-    # @return [Hash<String, TypedStage>] index mapping abbreviations to typed stages
-    def build_typed_stage_index
-      all_typed_stages.each_with_object({}) do |ts, index|
-        ts.abbr.each { |abbr| index[abbr] = ts }
-      end
-    end
-
-    # Build hash-based index of identifier classes by type code
-    # @return [Hash<String, Class>] index mapping type codes to identifier classes
-    def build_identifier_class_index
-      all_identifier_classes.each_with_object({}) do |klass, index|
-        type_key = klass.type&.dig(:key)&.to_s
-        index[type_key] = klass if type_key
-      end
-    end
-  end
-end