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

data/lib/pubid/export/data_class_exporter.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Export
-    # Strategy for flavors using Lutaml::Model::Serializable as their Scheme
-    # (ETSI, Plateau). These have identifier classes in the Identifiers module
-    # that may not have def self.type.
-    class DataClassExporter < FlavorExporter
-      def export
-        klasses = resolve_identifier_classes_from_module
-        return nil if klasses.empty?
-
-        fixture_data = fixture_examples
-
-        identifier_types = klasses.map do |klass|
-          info = extract_type_info(klass)
-          type_key = info[:key]
-          examples = fixture_data[type_key] || fixture_data[type_key.to_s] || []
-
-          IdentifierTypeResult.new(
-            key: info[:key],
-            title: info[:title],
-            short: info[:short],
-            abbr: info[:abbr],
-            typed_stages: [],
-            examples: examples,
-          )
-        end
-
-        scheme = scheme_class
-        attrs = scheme&.methods&.include?(:attributes) ? scheme.attributes.keys.map(&:to_s) : []
-
-        FlavorResult.new(
-          flavor: flavor,
-          identifier_types: identifier_types,
-          attributes: attrs,
-        )
-      end
-
-      private
-
-      def resolve_identifier_classes_from_module
-        mod = scheme_module
-        return [] unless mod
-
-        idents_mod = mod.const_get(:Identifiers)
-        skip = %w[Base Supplement]
-
-        idents_mod.constants.filter_map do |c|
-          klass = begin; idents_mod.const_get(c); rescue NameError; next; end
-          next unless klass.is_a?(Class)
-          next if skip.include?(klass.name&.split("::")&.last)
-
-          klass
-        end
-      end
-    end
-  end
-end

data/lib/pubid/export/ieee_exporter.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-
-module Pubid
-  module Export
-    # Strategy for IEEE, which has identifier classes in the Identifiers module
-    # without a Scheme.identifiers method.
-    class IeeeExporter < FlavorExporter
-      def export
-        klasses = resolve_ieee_identifiers
-        return nil if klasses.empty?
-
-        fixture_data = fixture_examples
-        seen_keys = Set.new
-
-        identifier_types = klasses.filter_map do |klass|
-          info = extract_type_info(klass)
-          next if seen_keys.include?(info[:key])
-
-          seen_keys << info[:key]
-
-          type_key = info[:key]
-          examples = match_ieee_examples(fixture_data, type_key, klass)
-
-          IdentifierTypeResult.new(
-            key: info[:key],
-            title: info[:title],
-            short: info[:short],
-            abbr: info[:abbr],
-            typed_stages: [],
-            examples: examples,
-          )
-        end
-
-        FlavorResult.new(
-          flavor: flavor,
-          identifier_types: identifier_types,
-          attributes: [],
-        )
-      end
-
-      private
-
-      def resolve_ieee_identifiers
-        identifiers_mod = scheme_module::Identifiers
-        skip = %w[Base Supplement]
-        klasses = []
-        collect_classes(identifiers_mod, skip, klasses)
-        klasses
-      end
-
-      def collect_classes(mod, skip, result)
-        mod.constants.each do |c|
-          const = begin; mod.const_get(c); rescue NameError; next; end
-          if const.is_a?(Module) && !const.is_a?(Class)
-            collect_classes(const, skip, result)
-          elsif const.is_a?(Class)
-            next if skip.include?(const.name&.split("::")&.last)
-
-            result << const
-          end
-        end
-      end
-
-      def match_ieee_examples(fixture_data, type_key, klass)
-        # Try direct key match
-        examples = fixture_data[type_key] || fixture_data[type_key.to_s] || []
-        return examples if examples.any?
-
-        # Try class name match
-        class_name = klass.name&.split("::")&.last
-        snake_name = class_name&.gsub(/([A-Z])/, '_\1')&.downcase&.sub(/^_/, "")
-        fixture_data[snake_name] || []
-      end
-    end
-  end
-end

data/lib/pubid/export/itu_exporter.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Export
-    # Strategy for ITU, which uses a transform/model pattern without
-    # traditional identifier classes or TYPED_STAGES.
-    class ItuExporter < FlavorExporter
-      WEBSITE_KEY_OVERRIDES = {
-        "special_publication" => "special_publication",
-      }.freeze
-
-      def export
-        klasses = resolve_itu_identifiers
-        return nil if klasses.empty?
-
-        fixture_data = fixture_examples
-
-        identifier_types = klasses.map do |klass|
-          info = extract_type_info(klass)
-          type_key = info[:key]
-          examples = fixture_data[type_key] || fixture_data[type_key.to_s] || []
-
-          IdentifierTypeResult.new(
-            key: info[:key],
-            title: info[:title],
-            short: info[:short],
-            abbr: info[:abbr],
-            typed_stages: [],
-            examples: examples,
-          )
-        end
-
-        FlavorResult.new(
-          flavor: flavor,
-          identifier_types: identifier_types,
-          attributes: extract_attribute_names,
-        )
-      end
-
-      private
-
-      def resolve_itu_identifiers
-        identifiers_mod = scheme_module::Identifiers
-        skip = %w[Base]
-        identifiers_mod.constants.filter_map do |c|
-          klass = begin
-            identifiers_mod.const_get(c); rescue NameError; next
-          end
-          next unless klass.is_a?(Class)
-          next if skip.include?(klass.name&.split("::")&.last)
-
-          klass
-        end
-      end
-
-      def extract_attribute_names
-        model = scheme_module::Identifier
-        return [] unless model&.methods&.include?(:model_attributes)
-
-        model.model_attributes.keys.map(&:to_s)
-      rescue NoMethodError, NameError
-        []
-      end
-    end
-  end
-end

data/lib/pubid/export/nist_exporter.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Export
-    # Strategy for NIST, which has a unique identifier architecture:
-    # per-class typed_stages class method (not TYPED_STAGES constant),
-    # and a Scheme.identifiers class method.
-    class NistExporter < FlavorExporter
-      def export
-        scheme = scheme_class
-        return nil unless scheme
-
-        klasses = scheme.identifiers.reject { |k| k == scheme_module::Identifiers::Base }
-        fixture_data = fixture_examples
-
-        seen_keys = Set.new
-        identifier_types = klasses.filter_map do |klass|
-          info = extract_type_info(klass)
-          type_key = info[:key]
-          next if seen_keys.include?(type_key)
-
-          seen_keys << type_key
-
-          examples = match_nist_examples(fixture_data, type_key, klass)
-          stages = klass.typed_stages
-
-          IdentifierTypeResult.new(
-            key: info[:key],
-            title: info[:title],
-            short: info[:short],
-            abbr: stages.flat_map(&:abbr),
-            typed_stages: stages,
-            examples: examples,
-          )
-        end
-
-        FlavorResult.new(
-          flavor: flavor,
-          identifier_types: identifier_types,
-          attributes: klasses.first ? extract_attributes(klasses.first) : [],
-        )
-      end
-
-      private
-
-      def match_nist_examples(fixture_data, type_key, klass)
-        return [] unless type_key
-
-        # NIST fixtures use series codes like "nist_sp", "nist_ir", etc.
-        key_str = type_key.to_s
-        examples = fixture_data["nist_#{key_str}"] ||
-          fixture_data[key_str.to_s] ||
-          []
-
-        return examples if examples.any?
-
-        # Try class name match
-        class_name = klass.name&.split("::")&.last
-        snake_name = class_name&.gsub(/([A-Z])/, '_\1')&.downcase&.sub(/^_/, "")
-        fixture_data[snake_name] || []
-      end
-    end
-  end
-end

data/lib/pubid/export/registry_exporter.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-
-module Pubid
-  module Export
-    # Strategy for flavors using TYPED_STAGES_REGISTRY on the Scheme class
-    # (BSI, CEN). These don't use per-class TYPED_STAGES but instead have
-    # a centralized registry mapping type_code → typed stages.
-    class RegistryExporter < FlavorExporter
-      def export
-        registry = extract_registry
-        return nil if registry.empty?
-
-        known_website_keys = Set.new
-
-        identifier_types = registry.group_by(&:type_code).map do |type_code, stages|
-          wkey = resolve_website_key(type_code).to_s
-          known_website_keys << wkey
-          primary = stages.first
-          IdentifierTypeResult.new(
-            key: wkey,
-            title: primary.name,
-            short: nil,
-            abbr: primary.abbr,
-            typed_stages: stages,
-            examples: [],
-          )
-        end
-
-        # Supplement with typed classes not in the registry
-        additional = discover_additional_from_identifiers(known_website_keys)
-        identifier_types.concat(additional)
-
-        FlavorResult.new(
-          flavor: flavor,
-          identifier_types: identifier_types,
-          wrapper_types: extract_wrapper_types,
-          attributes: [],
-        )
-      end
-
-      private
-
-      def extract_registry
-        scheme = scheme_class
-        return [] unless scheme
-
-        if scheme.const_defined?(:TYPED_STAGES_REGISTRY)
-          scheme.const_get(:TYPED_STAGES_REGISTRY)
-        else
-          []
-        end
-      end
-
-      def discover_additional_from_identifiers(known_keys)
-        mod = scheme_module
-        return [] unless mod
-
-        idents_mod = mod.const_get(:Identifiers)
-        skip = %w[Base]
-
-        idents_mod.constants.filter_map do |c|
-          klass = idents_mod.const_get(c)
-        rescue NameError
-          next
-        else
-          next unless klass.is_a?(Class)
-          next if skip.include?(klass.name&.split("::")&.last)
-
-          info = extract_type_info(klass)
-          next unless info[:key]
-
-          website_key = info[:key].to_s
-          next if known_keys.include?(website_key)
-
-          known_keys << website_key
-          IdentifierTypeResult.new(
-            key: website_key,
-            title: info[:title],
-            short: info[:short],
-            abbr: [],
-            typed_stages: [],
-            examples: [],
-          )
-        end
-      end
-    end
-  end
-end

data/lib/pubid/export/scheme_exporter.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Export
-    # Strategy for flavors using Scheme with class-level identifiers method
-    # and def self.type / TYPED_STAGES patterns.
-    #
-    # Covers: ISO, IEC, ASTM, ASHRAE, ASME, CCSDS, CIE, CSA, JIS, JCGM,
-    #         OIML, IDF, API, SAE, NIST, IEEE
-    class SchemeExporter < FlavorExporter
-      def export
-        klasses = identifier_classes
-        return nil if klasses.empty?
-
-        fixture_data = fixture_examples
-
-        identifier_types = klasses.filter_map do |klass|
-          info = extract_type_info(klass)
-          stages = extract_typed_stages(klass)
-          type_key = info[:key]&.to_s
-
-          # Match fixture examples to this type
-          examples = match_examples(fixture_data, type_key, klass)
-
-          IdentifierTypeResult.new(
-            key: info[:key],
-            title: info[:title],
-            short: info[:short],
-            abbr: info[:abbr],
-            typed_stages: stages,
-            examples: examples,
-          )
-        end
-
-        all_attrs = klasses.first ? extract_attributes(klasses.first) : []
-        wrapper_types = extract_wrapper_types
-
-        FlavorResult.new(
-          flavor: flavor,
-          identifier_types: identifier_types,
-          wrapper_types: wrapper_types,
-          attributes: all_attrs,
-        )
-      end
-
-      private
-
-      def match_examples(fixture_data, type_key, klass)
-        return [] unless type_key
-
-        # Try direct type key match first
-        examples = fixture_data[map_fixture_key_to_type_key(type_key)] ||
-          fixture_data[map_fixture_key_to_type_key(type_key.gsub("_",
-                                                                 ""))] ||
-          []
-
-        return examples if examples.any?
-
-        # Try class name match
-        class_name = klass.name&.split("::")&.last
-        snake_name = class_name&.gsub(/([A-Z])/, '_\1')&.downcase&.sub(/^_/, "")
-        if snake_name && fixture_data.key?(snake_name)
-          fixture_data[snake_name]
-        else
-          []
-        end
-      end
-    end
-  end
-end

data/lib/pubid/identifier_registry.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "identifier_metadata"
-
-module Pubid
-  # Global registry of all identifier types across all flavors
-  # Provides searchable index for machine-readable lookups
-  class IdentifierRegistry
-    class << self
-      # Register an identifier class with its metadata
-      # @param identifier_class [Class] The identifier class
-      # @param metadata [Hash] Metadata attributes
-      def register(identifier_class, **metadata)
-        # Extract class name from full class name
-        identifier_class_name = identifier_class.name.to_s.split("::")&.last
-
-        all_identifiers[identifier_class] = IdentifierMetadata::Metadata.new(
-          flavor: metadata.fetch(:flavor),
-          identifier_class: identifier_class_name,
-          **metadata,
-        )
-
-        # Index by various keys for fast lookup
-        index_by_flavor(metadata[:flavor], identifier_class)
-        if metadata[:type_key]
-          index_by_type_key(metadata[:type_key],
-                            identifier_class)
-        end
-        index_by_abbr(metadata[:abbr], identifier_class) if metadata[:abbr]
-
-        identifier_class
-      end
-
-      # Find identifier class by flavor and type key
-      # @param flavor [String, Symbol] The flavor
-      # @param type_key [String, Symbol] The type key
-      # @return [Class, nil]
-      def find_by_type(flavor, type_key)
-        flavor_index[flavor.to_s]&.dig(type_key.to_s)
-      end
-
-      # Find identifier class by abbreviation
-      # @param flavor [String, Symbol] The flavor
-      # @param abbr [String] The abbreviation
-      # @return [Array<Class>] All matching classes
-      def find_by_abbr(flavor, abbr)
-        abbr_index[flavor.to_s]&.dig(abbr.to_s.downcase) || []
-      end
-
-      # Get all identifiers for a flavor
-      # @param flavor [String, Symbol] The flavor
-      # @return [Array<Class>]
-      def all_for_flavor(flavor)
-        flavor_index[flavor.to_s]&.values || []
-      end
-
-      # Get all registered identifiers
-      # @return [Hash<Class, Metadata>]
-      def all_identifiers
-        @all_identifiers ||= {}
-      end
-
-      # Get metadata for an identifier class
-      # @param identifier_class [Class] The identifier class
-      # @return [Metadata, nil]
-      def metadata_for(identifier_class)
-        all_identifiers[identifier_class]
-      end
-
-      # Search identifiers by criteria
-      # @param criteria [Hash] Search criteria
-      # @option criteria [String, Symbol] :flavor Filter by flavor
-      # @option criteria [String, Symbol] :type_key Filter by type key
-      # @option criteria [String] :abbr Filter by abbreviation
-      # @option criteria [String] :title Filter by title (partial match)
-      # @option criteria [Boolean] :base_class Filter by base class status
-      # @option criteria [Boolean] :supplement_class Filter by supplement class status
-      # @return [Array<Hash>] Array of {class: Class, metadata: Metadata}
-      def search(**criteria)
-        results = []
-
-        all_identifiers.each do |klass, metadata|
-          matches = true
-
-          if criteria[:flavor]
-            matches &= metadata.flavor.to_s == criteria[:flavor].to_s
-          end
-
-          if criteria[:type_key]
-            matches &= metadata.type_key.to_s == criteria[:type_key].to_s
-          end
-
-          if criteria[:abbr]
-            matches &= metadata.abbr.map(&:to_s).map(&:downcase).include?(criteria[:abbr].to_s.downcase)
-          end
-
-          if criteria[:title]
-            matches &= metadata.title.to_s.downcase.include?(criteria[:title].to_s.downcase)
-          end
-
-          if criteria[:base_class]
-            matches &= !metadata.base_class.nil? == criteria[:base_class]
-          end
-
-          if criteria[:supplement_class]
-            matches &= !metadata.supplement_class.nil? == criteria[:supplement_class]
-          end
-
-          results << { class: klass, metadata: metadata } if matches
-        end
-
-        results
-      end
-
-      # Export registry to machine-readable format (JSON)
-      # @return [String] JSON representation
-      def to_json(*args)
-        all_identifiers.values.map(&:to_hash).to_json(*args)
-      end
-
-      # Export registry to machine-readable format (YAML)
-      # @return [String] YAML representation
-      def to_yaml
-        require "json"
-        hash = all_identifiers.values.map(&:to_h)
-        # Convert to YAML format (basic implementation)
-        hash.map(&:to_json).join("\n")
-      end
-
-      # Clear all registrations (useful for testing)
-      def clear!
-        @all_identifiers = {}
-        @flavor_index = nil
-        @type_key_index = nil
-        @abbr_index = nil
-      end
-
-      # Generate a summary report
-      # @return [String] Human-readable summary
-      def summary
-        flavors = all_identifiers.values.map(&:flavor).uniq.sort
-        total = all_identifiers.size
-
-        summary = "Identifier Registry Summary\n"
-        summary += "#{'=' * 50}\n"
-        summary += "Total identifiers: #{total}\n"
-        summary += "Flavors: #{flavors.join(', ')}\n\n"
-
-        flavors.each do |flavor|
-          flavor_ids = all_identifiers.values.select do |m|
-            m.flavor.to_s == flavor
-          end
-          summary += "#{flavor.upcase} (#{flavor_ids.size}):\n"
-          flavor_ids.sort_by(&:type_key).each do |metadata|
-            summary += "  - #{metadata.type_key}: #{metadata.title}\n"
-          end
-        end
-
-        summary
-      end
-
-      private
-
-      def flavor_index
-        @flavor_index ||= Hash.new { |h, k| h[k] = {} }
-      end
-
-      def type_key_index
-        @type_key_index ||= Hash.new { |h, k| h[k] = {} }
-      end
-
-      def abbr_index
-        @abbr_index ||= Hash.new do |h, k|
-          h[k] = Hash.new do |h2, k2|
-            h2[k2] = []
-          end
-        end
-      end
-
-      def index_by_flavor(flavor, identifier_class)
-        flavor_index[flavor.to_s][:_all] ||= []
-        flavor_index[flavor.to_s][:_all] << identifier_class
-      end
-
-      def index_by_type_key(type_key, identifier_class)
-        flavor = all_identifiers[identifier_class].flavor
-        flavor_index[flavor.to_s][type_key.to_s] = identifier_class
-      end
-
-      def index_by_abbr(abbr, identifier_class)
-        flavor = all_identifiers[identifier_class].flavor
-        Array(abbr).each do |a|
-          abbr_index[flavor.to_s][a.to_s.downcase] << identifier_class
-        end
-      end
-    end
-  end
-end

data/lib/pubid/idf/scheme.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Idf
-    class Scheme < Pubid::Scheme
-      class << self
-        def identifiers
-          @identifiers ||= [
-            Identifiers::InternationalStandard,
-            Identifiers::ReviewedMethod,
-          ].freeze
-        end
-
-        def supplement_identifiers
-          @supplement_identifiers ||= [
-            Identifiers::Amendment,
-            Identifiers::Corrigendum,
-          ].freeze
-        end
-
-        def typed_stages
-          @typed_stages ||= identifiers.flat_map { |klass| klass::TYPED_STAGES }
-        end
-
-        def supplement_typed_stages
-          @supplement_typed_stages ||= supplement_identifiers.flat_map do |klass|
-            klass::TYPED_STAGES
-          end
-        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