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

data/lib/pubid/export/exporter.rb

@@ -2,24 +2,65 @@
 
 module Pubid
   module Export
-    # Top-level orchestrator. Iterates flavors and delegates to FlavorExporter.
+    # Top-level orchestrator. Iterates flavors, selects the appropriate
+    # extraction strategy, and produces the combined result.
     #
-    # Open/Closed: Adding a new flavor only requires adding it to FLAVORS;
-    # no existing code changes.
+    # Open/Closed: Adding a new flavor only requires registering it in
+    # FLAVOR_STRATEGIES; no existing code changes.
     class Exporter
       FLAVORS = %i[
         iso iec ieee nist bsi itu cen_cenelec etsi ansi astm ashrae asme
-        ccsds cie csa ecma jis jcgm oiml idf api amca plateau sae ogc ietf tgpp w3c xsf
-        bipm iana oasis calconnect
+        ccsds cie csa jis jcgm oiml idf api amca plateau sae
       ].freeze
 
+      # Maps each flavor to its extraction strategy class.
+      # When a flavor follows a new pattern, add a new strategy class here.
+      FLAVOR_STRATEGIES = {
+        iso: :scheme,
+        iec: :scheme,
+        ieee: :ieee,
+        nist: :nist,
+        bsi: :registry,
+        itu: :itu,
+        cen_cenelec: :registry,
+        etsi: :data_class,
+        ansi: :scheme,
+        astm: :scheme,
+        ashrae: :scheme,
+        asme: :scheme,
+        ccsds: :scheme,
+        cie: :scheme,
+        csa: :scheme,
+        jis: :scheme,
+        jcgm: :scheme,
+        oiml: :scheme,
+        idf: :scheme,
+        api: :scheme,
+        amca: :scheme,
+        plateau: :data_class,
+        sae: :scheme,
+      }.freeze
+
+      STRATEGY_CLASSES = {
+        scheme: SchemeExporter,
+        registry: RegistryExporter,
+        data_class: DataClassExporter,
+        nist: NistExporter,
+        ieee: IeeeExporter,
+        itu: ItuExporter,
+      }.freeze
+
       # Export all flavors to a hash suitable for JSON serialization.
       # @return [Hash{String => Hash}]
       def self.export_all
         require "pubid"
 
         FLAVORS.each_with_object({}) do |flavor, result|
-          exporter = FlavorExporter.new(flavor)
+          strategy_name = FLAVOR_STRATEGIES[flavor]
+          strategy_class = STRATEGY_CLASSES[strategy_name]
+          next unless strategy_class
+
+          exporter = strategy_class.new(flavor)
           flavor_result = exporter.export
           next unless flavor_result
 

data/lib/pubid/export/flavor_exporter.rb

@@ -4,14 +4,11 @@ require "set"
 
 module Pubid
   module Export
-    # Unified metadata extractor for all flavors.
+    # Abstract base class for per-flavor metadata extraction.
+    # Subclasses implement strategy for different Scheme patterns.
     #
-    # Uses the self-describing type interface (identifier_types, all_typed_stages,
-    # locate_type, locate_stage) on each flavor module. No Scheme dependency (Scheme class removed).
-    #
-    # Open/Closed: Adding a new flavor requires only adding it to Exporter::FLAVORS.
-    # Single Responsibility: Extracts metadata from flavor modules into value objects.
-    # Single Source of Truth: Each identifier class IS the type definition.
+    # Open/Closed: New flavors add a subclass; no existing code changes.
+    # Single Responsibility: Each subclass extracts data for one Scheme pattern.
     class FlavorExporter
       attr_reader :flavor
 
@@ -25,121 +22,300 @@ module Pubid
         @flavor = flavor
       end
 
+      # Subclasses must override
       def export
-        mod = flavor_module
-        return nil unless mod
+        raise NotImplementedError
+      end
 
-        klasses = resolve_identifier_classes(mod)
-        return nil if klasses.empty?
+      protected
 
-        fixture_data = fixture_examples
-        seen_keys = Set.new
+      def scheme_module
+        # const_get doesn't trigger autoload; reference the constant directly
+        @scheme_module ||= case flavor.to_s
+                           when "iso" then Pubid::Iso
+                           when "iec" then Pubid::Iec
+                           when "ieee" then Pubid::Ieee
+                           when "nist" then Pubid::Nist
+                           when "bsi" then Pubid::Bsi
+                           when "itu" then Pubid::Itu
+                           when "cen_cenelec" then Pubid::CenCenelec
+                           when "etsi" then Pubid::Etsi
+                           when "ansi" then Pubid::Ansi
+                           when "astm" then Pubid::Astm
+                           when "ashrae" then Pubid::Ashrae
+                           when "asme" then Pubid::Asme
+                           when "ccsds" then Pubid::Ccsds
+                           when "cie" then Pubid::Cie
+                           when "csa" then Pubid::Csa
+                           when "jis" then Pubid::Jis
+                           when "jcgm" then Pubid::Jcgm
+                           when "oiml" then Pubid::Oiml
+                           when "idf" then Pubid::Idf
+                           when "api" then Pubid::Api
+                           when "amca" then Pubid::Amca
+                           when "plateau" then Pubid::Plateau
+                           when "sae" then Pubid::Sae
+                           end
+      end
 
-        identifier_types = klasses.filter_map do |klass|
-          info = extract_type_info(klass)
-          next if seen_keys.include?(info[:key])
+      def scheme_class
+        @scheme_class ||= begin
+          mod = scheme_module
+          mod&.const_get(:Scheme)
+        rescue NameError
+          nil
+        end
+      end
 
-          seen_keys << info[:key]
+      def identifier_classes
+        resolve_identifier_classes
+      end
 
-          stages = extract_typed_stages(klass)
-          examples = match_examples(fixture_data, info[:key]&.to_s, klass)
+      def resolve_identifier_classes
+        scheme = scheme_class
+        scheme_klasses = []
 
-          IdentifierTypeResult.new(
-            key: info[:key],
-            title: info[:title],
-            short: info[:short],
-            abbr: info[:abbr],
-            typed_stages: stages,
-            examples: examples,
-          )
+        # Pattern 1: Class methods (ISO, IEC, ASTM, etc.)
+        begin
+          scheme_klasses = scheme.identifiers if scheme
+        rescue NoMethodError
+          scheme_klasses = []
+        end
+
+        # Pattern 2: Instance-based (AMCA, BSI)
+        if scheme_klasses.empty? && scheme
+          instance = begin
+            scheme.new
+          rescue NoMethodError
+            nil
+          end
+          if instance
+            ids = begin
+              instance.identifiers
+            rescue NoMethodError
+              nil
+            end
+            scheme_klasses = ids if ids && !ids.empty?
+          end
+        end
+
+        # Build set of website keys from Scheme classes to avoid duplicates
+        known_website_keys = Set.new
+        scheme_klasses.each do |klass|
+          info = extract_type_info(klass)
+          known_website_keys << info[:key].to_s if info[:key]
         end
 
-        FlavorResult.new(
-          flavor: flavor,
-          identifier_types: identifier_types,
-          wrapper_types: extract_wrapper_types,
-          attributes: extract_attributes(klasses.first),
-        )
+        # Supplement with any typed classes in the Identifiers module
+        # that weren't returned by Scheme (e.g., supplements, fragments)
+        additional = discover_additional_typed_classes(scheme_klasses,
+                                                       known_website_keys)
+        scheme_klasses + additional
       end
 
-      protected
+      # Classes to skip when discovering additional identifier types
+      SKIP_CLASSES = %w[Base].freeze
 
-      # Resolve identifier classes from the flavor module.
-      # Primary: use the module's self-describing identifier_types method.
-      # Fallback: scan the Identifiers namespace directly for Pubid::Identifier
-      # subclasses (handles ETSI, ITU, and other non-standard patterns).
-      def resolve_identifier_classes(mod)
-        klasses = mod.identifier_types
-        return klasses if klasses && !klasses.empty?
+      def discover_additional_typed_classes(known_classes,
+known_website_keys = Set.new)
+        mod = scheme_module
+        return [] unless mod
 
-        discover_from_namespace(mod)
-      end
+        idents_mod = mod.const_get(:Identifiers)
+        known_set = Set.new(known_classes)
 
-      # Scan Identifiers namespace for all Pubid::Identifier subclasses,
-      # excluding structural base classes.
-      def discover_from_namespace(mod)
-        if mod.const_defined?(:Identifiers)
-          classes = collect_identifier_classes(mod.const_get(:Identifiers))
-          return classes unless classes.empty?
-        end
+        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 known_set.include?(klass)
+          next if klass <= Exception
+          next if SKIP_CLASSES.include?(klass.name&.split("::")&.last)
+
+          # Check if this class produces a duplicate website key
+          info = extract_type_info(klass)
+          wkey = info[:key]&.to_s
+          next if wkey && known_website_keys.include?(wkey)
 
-        # Single-class flavors (e.g. SAE) expose no concrete types under
-        # Identifiers — the flavor's own Identifier class IS the sole document
-        # type (previously discovered via the removed Identifiers::Base alias).
-        Array(single_class_flavor_type(mod))
+          known_website_keys << wkey if wkey
+          klass
+        end
       end
 
-      # The flavor's own `Identifier` class when it is a concrete
-      # Pubid::Identifier subclass, else nil (used as the sole type for
-      # single-class flavors with an empty Identifiers namespace).
-      def single_class_flavor_type(mod)
-        return unless mod.const_defined?(:Identifier)
+      # Explicit overrides mapping (flavor, library_key) → website key
+      # for cases where derived key doesn't match the website convention.
+      WEBSITE_KEY_OVERRIDES = {
+        # ISO
+        [%i[iso], :is] => :international_standard,
+        [%i[iso], :tr] => :technical_report,
+        [%i[iso], :ts] => :technical_specification,
+        [%i[iso], :pas] => :publicly_available_specification,
+        [%i[iso], :tta] => :technology_trends_assessments,
+        [%i[iso], :iwa] => :international_workshop_agreement,
+        [%i[iso], :isp] => :international_standardized_profile,
+        [%i[iso], :rec] => :recommendation,
+        [%i[iso], :dir] => :directives,
+        [%i[iso], :"dir-sup"] => :directives_supplement,
+        [%i[iso], :amd] => :amendment,
+        [%i[iso], :cor] => :corrigendum,
+        [%i[iso], :suppl] => :supplement,
+        [%i[iso], :ext] => :extract,
+        [%i[iso], :add] => :addendum,
+        [%i[iso], :tc] => :tc_document,
+        # IEC
+        [%i[iec], :is] => :international_standard,
+        [%i[iec], :tr] => :technical_report,
+        [%i[iec], :ts] => :technical_specification,
+        [%i[iec], :pas] => :publicly_available_specification,
+        [%i[iec], :trf] => :test_report_form,
+        [%i[iec], :ish] => :interpretation_sheet,
+        [%i[iec], :srd] => :systems_reference_document,
+        [%i[iec], :wd] => :working_document,
+        [%i[iec], :frag] => :fragment_identifier,
+        [%i[iec], :amd] => :amendment,
+        [%i[iec], :cor] => :corrigendum,
+        [%i[iec], :cs] => :component_specification,
+        [%i[iec], :od] => :operational_document,
+        [%i[iec], :sttr] => :societal_technology_trend_report,
+        [%i[iec], :wp] => :white_paper,
+        # IEEE
+        [%i[ieee], :std] => :standard,
+        # NIST
+        [%i[nist], :sp] => :special_publication,
+        [%i[nist], :fips] => :federal_information_processing_standards,
+        [%i[nist], :ir] => :interagency_report,
+        [%i[nist], :hb] => :handbook,
+        [%i[nist], :tn] => :technical_note,
+        [%i[nist], :circ] => :circular,
+        [%i[nist], :circ_supp] => :circular_supplement,
+        [%i[nist], :crpl] => :crpl_report,
+        [%i[nist], :rpt] => :report,
+        [%i[nist], :mono] => :monograph,
+        [%i[nist], :mp] => :miscellaneous_publication,
+        [%i[nist], :gcr] => :grant_contractor_report,
+        [%i[nist], :lc] => :letter_circular,
+        [%i[nist], :cs] => :commercial_standard,
+        [%i[nist], :cse] => :commercial_standard_emergency,
+        [%i[nist], :csm] => :commercial_standards_monthly,
+        # BSI — adopted types share keys with base types, need unique mappings
+        [%i[bsi], :bs] => :british_standard,
+        [%i[bsi], :pd] => :published_document,
+        [%i[bsi], :pas] => :publicly_available_specification,
+        [%i[bsi], :na] => :national_annex,
+        [%i[bsi], :dd] => :draft_document,
+        [%i[bsi], :ep] => :electronic_book,
+        [%i[bsi], :ts] => :technical_specification,
+        [%i[bsi], :handbook] => :handbook,
+        [%i[bsi], :aerospace] => :aerospace_standard,
+        # CEN-CENELEC
+        [%i[cen_cenelec], :en] => :european_norm,
+        [%i[cen_cenelec], :ts] => :technical_specification,
+        [%i[cen_cenelec], :tr] => :technical_report,
+        [%i[cen_cenelec], :cwa] => :cen_workshop_agreement,
+        [%i[cen_cenelec], :hd] => :harmonization_document,
+        [%i[cen_cenelec], :es] => :european_specification,
+        [%i[cen_cenelec], :cr] => :cen_report,
+        [%i[cen_cenelec], :env] => :european_prestandard,
+        # IDF
+        [%i[idf], :is] => :international_standard,
+        [%i[idf], :rm] => :reviewed_method,
+        [%i[idf], :amd] => :amendment,
+        [%i[idf], :cor] => :corrigendum,
+        # CCSDS
+        [%i[ccsds], :base] => :base,
+        [%i[ccsds], :cor] => :corrigendum,
+        # JIS
+        [%i[jis], :jis] => :japanese_industrial_standard,
+        [%i[jis], :tr] => :technical_report,
+        [%i[jis], :ts] => :technical_specification,
+        # SAE
+        [%i[sae], :base] => :standard,
+        # ANSI
+        [%i[ansi], :ans] => :american_national_standard,
+      }.freeze
 
-        ident = mod.const_get(:Identifier)
-        ident if ident.is_a?(Class) && ident < Pubid::Identifier
-      end
+      # Per-class overrides keyed by class name (for classes that share type keys)
+      CLASS_KEY_OVERRIDES = {
+        "Pubid::Bsi::Identifiers::AdoptedEuropeanNorm" => "adopted_european_norm",
+        "Pubid::Bsi::Identifiers::AdoptedInternationalStandard" => "adopted_international_standard",
+        "Pubid::CenCenelec::Identifiers::AdoptedEuropeanNorm" => "adopted_european_norm",
+        "Pubid::Ansi::Identifiers::Standard" => "standard",
+        "Pubid::Ansi::Identifiers::AmericanNationalStandard" => "american_national_standard",
+        "Pubid::Jis::Identifiers::Standard" => "standard",
+        "Pubid::Ieee::Identifiers::Nesc::Standard" => "nesc",
+        "Pubid::Ieee::Identifiers::Nesc::Draft" => "nesc",
+        "Pubid::Ieee::Identifiers::Nesc::Handbook" => "nesc",
+        "Pubid::Ieee::Identifiers::Nesc::Redline" => "nesc",
+      }.freeze
 
-      # Recursively collect all Pubid::Identifier subclasses from a module,
-      # descending into submodules (e.g., IEEE's Nesc namespace).
-      def collect_identifier_classes(mod)
-        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)
-            result.concat(collect_identifier_classes(const))
-          elsif const.is_a?(Class) && const < Pubid::Identifier
-            result << const
+      def extract_type_info(klass)
+        # Per-class override takes highest priority
+        class_key = CLASS_KEY_OVERRIDES[klass.name]
+        if class_key
+          type_info = begin
+            klass.type
+          rescue NoMethodError, NotImplementedError
+            nil
           end
+          metadata = begin
+            klass.metadata
+          rescue NoMethodError
+            nil
+          end
+          return {
+            key: class_key,
+            title: type_info&.dig(:title) || metadata&.title || class_key.tr(
+              "_", " "
+            ).capitalize,
+            short: type_info&.dig(:short) || metadata&.short,
+            abbr: metadata&.abbr || [],
+          }
         end
-        result
-      end
 
-      # Map flavor symbol to the flavor module.
-      def flavor_module
-        @flavor_module ||= begin
-          mod_name = flavor.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
-          Pubid.const_get(mod_name)
-        rescue NameError
+        type_info = begin
+          klass.type
+        rescue NoMethodError, NotImplementedError
+          nil
+        end
+        metadata = begin
+          klass.metadata
+        rescue NoMethodError
           nil
         end
-      end
-
-      def extract_type_info(klass)
-        type_info = safe_type(klass)
-        metadata = safe_metadata(klass)
 
-        key = type_info&.dig(:web) || type_info&.dig(:key)
+        lib_key = type_info&.dig(:key)
         title = type_info&.dig(:title) || metadata&.title
         short = type_info&.dig(:short) || metadata&.short
         abbr = metadata&.abbr || []
 
-        unless key
+        # Derive from class name when def self.type is missing
+        unless lib_key
           class_name = klass.name&.split("::")&.last
-          key = class_name&.gsub(/([A-Z])/, '_\1')&.downcase&.sub(/^_/, "")
+          lib_key = class_name&.gsub(/([A-Z])/, '_\1')&.downcase&.sub(/^_/,
+                                                                      "")&.to_sym
           title ||= class_name&.gsub(/([A-Z])/, ' \1')&.strip
         end
 
-        { key: key&.to_s, title: title, short: short, abbr: abbr }
+        # Map library key to website-compatible key
+        website_key = resolve_website_key(lib_key)
+
+        {
+          key: website_key,
+          title: title,
+          short: short,
+          abbr: abbr,
+        }
+      end
+
+      def resolve_website_key(lib_key)
+        key_str = lib_key.to_s
+        WEBSITE_KEY_OVERRIDES.each do |(flavors, from_key), to_key|
+          next unless flavors.include?(flavor)
+          return to_key.to_s if from_key.to_s == key_str
+        end
+        key_str
       end
 
       def extract_typed_stages(klass)
@@ -150,10 +326,14 @@ module Pubid
         []
       end
 
-      # Fixture example extraction
+      # Map flavor keys to fixture directory names when they differ
+      FIXTURE_DIR_ALIASES = {}.freeze
+
       def fixture_examples
+        # __dir__ = lib/pubid/export → go up 3 levels to gem root, then spec/fixtures
         gem_root = File.expand_path("../../..", __dir__)
-        base = File.join(gem_root, "spec", "fixtures", flavor.to_s, "identifiers",
+        dir_name = FIXTURE_DIR_ALIASES[flavor] || flavor.to_s
+        base = File.join(gem_root, "spec", "fixtures", dir_name, "identifiers",
                          "pass")
         return {} unless Dir.exist?(base)
 
@@ -171,8 +351,10 @@ module Pubid
         File.readlines(path, chomp: true).each do |line|
           next if line.start_with?("#") || line.strip.empty?
 
+          # Format: "!Type input!expected" or just "input"
           if line.start_with?("!")
             parts = line.split("!")
+            # ["", "Type", "input", "expected"] or ["", "Type", "input"]
             input = parts[2]&.strip
             identifiers << input if input && !input.empty?
           else
@@ -182,24 +364,8 @@ module Pubid
         identifiers.uniq.first(10)
       end
 
-      def match_examples(fixture_data, type_key, klass)
-        return [] unless type_key
-
-        # Try direct type key match first
-        examples = fixture_data[type_key] ||
-          fixture_data[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
+      def map_fixture_key_to_type_key(fixture_key)
+        fixture_key
       end
 
       def extract_attributes(klass)
@@ -212,7 +378,7 @@ module Pubid
         names = WRAPPER_CLASSES[flavor]
         return [] unless names
 
-        mod = flavor_module
+        mod = scheme_module
         return [] unless mod
 
         identifiers_mod = mod.const_get(:Identifiers)
@@ -231,20 +397,6 @@ module Pubid
           nil
         end
       end
-
-      private
-
-      def safe_type(klass)
-        klass.type
-      rescue NoMethodError, NotImplementedError
-        nil
-      end
-
-      def safe_metadata(klass)
-        klass.metadata
-      rescue NoMethodError
-        nil
-      end
     end
   end
 end

data/lib/pubid/export/ieee_exporter.rb

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