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

data/lib/pubid/export/itu_exporter.rb

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

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

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

@@ -0,0 +1,70 @@
+# 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/export.rb

@@ -6,6 +6,12 @@ module Pubid
     autoload :TypedStageResult, "#{__dir__}/export/result"
     autoload :FlavorResult, "#{__dir__}/export/result"
     autoload :FlavorExporter, "#{__dir__}/export/flavor_exporter"
+    autoload :SchemeExporter, "#{__dir__}/export/scheme_exporter"
+    autoload :IeeeExporter, "#{__dir__}/export/ieee_exporter"
+    autoload :RegistryExporter, "#{__dir__}/export/registry_exporter"
+    autoload :DataClassExporter, "#{__dir__}/export/data_class_exporter"
+    autoload :NistExporter, "#{__dir__}/export/nist_exporter"
+    autoload :ItuExporter, "#{__dir__}/export/itu_exporter"
     autoload :Auditor, "#{__dir__}/export/auditor"
     autoload :Exporter, "#{__dir__}/export/exporter"
   end