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

data/lib/pubid/sae/scheme.rb

@@ -0,0 +1,47 @@
+# 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/sae/urn_generator.rb

@@ -9,10 +9,18 @@ module Pubid
         identifier.type.abbr.to_s.downcase
       end
 
+      def urn_year
+        if identifier.date&.year
+          return identifier.date.year.to_s
+        end
+
+        identifier.year&.to_s
+      end
+
       def urn_number
         return nil unless identifier.number
 
-        identifier.number.render(context: URN_CONTEXT)
+        identifier.number.value.to_s
       end
 
       def generate
@@ -21,7 +29,7 @@ module Pubid
         parts << urn_number if urn_number
         parts << urn_year if urn_year
 
-        parts[1] = urn_publisher if urn_publisher
+        parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
 
         parts.join(":")
       end

data/lib/pubid/sae.rb

@@ -2,65 +2,18 @@
 
 module Pubid
   module Sae
-    extend Pubid::PrefixesSupport
-
-    # Sole SAE publisher token (see the parser's `publisher` rule). Document
-    # types (AMS/AIR/ARP/AS/J/MA) follow the SAE prefix and are excluded.
-    PREFIXES = ["SAE"].freeze
-
     autoload :Builder, "#{__dir__}/sae/builder"
     autoload :Components, "#{__dir__}/sae/components"
-    autoload :Identifier, "#{__dir__}/sae/identifiers/base"
+    autoload :Identifier, "#{__dir__}/sae/identifier"
     autoload :Identifiers, "#{__dir__}/sae/identifiers"
     autoload :Parser, "#{__dir__}/sae/parser"
-    autoload :Renderer, "#{__dir__}/sae/renderer"
+    autoload :Scheme, "#{__dir__}/sae/scheme"
     autoload :UrnGenerator, "#{__dir__}/sae/urn_generator"
-    autoload :UrnParser, "#{__dir__}/sae/urn_parser"
 
     def self.parse(input)
       Identifier.parse(input)
     end
-
-    # Auto-discover all identifier types from the Identifiers namespace.
-    # SAE has only one identifier class (Base), which IS the document type.
-    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
-    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 < Pubid::Identifier }
-    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: 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(:sae, Pubid::Sae)
-
-# Per-flavor format registry: inherits global formats, overrides :human
-Pubid::Sae::Identifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::Sae::Identifier.format_registry.register(:human, renderer: Pubid::Sae::Renderer)

data/lib/pubid/scheme.rb

@@ -0,0 +1,207 @@
+# 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 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

data/lib/pubid/urn_generator/base.rb

@@ -6,9 +6,6 @@ module Pubid
     # Provides template methods for common URN parts.
     # Flavors subclass and override only what differs.
     class Base
-      URN_CONTEXT = Rendering::RenderingContext.urn.freeze
-      private_constant :URN_CONTEXT
-
       attr_reader :identifier
 
       def initialize(identifier)
@@ -38,7 +35,7 @@ module Pubid
         pub = maybe(:publisher)
         return nil unless pub
 
-        pub.is_a?(Components::Publisher) ? pub.render(context: URN_CONTEXT) : pub.to_s.downcase
+        pub.to_s.downcase
       end
 
       def urn_type
@@ -49,31 +46,34 @@ module Pubid
         val = maybe(:number) || maybe(:code)
         return nil unless val
 
-        val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val.to_s
+        val.is_a?(Components::Code) ? val.value.to_s : val.to_s
       end
 
       def urn_part
         val = maybe(:part)
         return nil unless val
 
-        "-#{val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val}"
+        "-#{val.is_a?(Components::Code) ? val.value : val}"
       end
 
       def urn_subpart
         val = maybe(:subpart)
         return nil unless val
 
-        "-#{val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val}"
+        "-#{val.is_a?(Components::Code) ? val.value : val}"
       end
 
       def urn_year
         date = maybe(:date)
-        if date.is_a?(Components::Date)
-          return date.render(context: URN_CONTEXT) if date.present?
-        elsif date
-          return date.to_s
+        if date
+          year = date.is_a?(Components::Date) ? date.year : date.to_s
+          return year.to_s if year
+        end
+        if maybe(:year)
+          return identifier.year.to_s
         end
-        maybe(:year)&.to_s
+
+        nil
       end
 
       def urn_edition

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.0.alpha.10"
+  VERSION = "2.0.0.pre.alpha.1"
 end