pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

data/lib/pubid/etsi.rb

@@ -9,12 +9,53 @@ module Pubid
     autoload :Identifier, "#{__dir__}/etsi/identifier"
     autoload :Identifiers, "#{__dir__}/etsi/identifiers"
     autoload :Parser, "#{__dir__}/etsi/parser"
-    autoload :Scheme, "#{__dir__}/etsi/scheme"
+    autoload :Renderer, "#{__dir__}/etsi/renderer"
     autoload :UrnGenerator, "#{__dir__}/etsi/urn_generator"
+    autoload :UrnParser, "#{__dir__}/etsi/urn_parser"
 
     def self.parse(identifier)
       Identifier.parse(identifier)
     end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifiers::Base.format_registry.register(:human, renderer: Etsi::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @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 }
+        .reject { |c| c.name&.split("::")&.last == "Base" }
+    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
 

data/lib/pubid/export/exporter.rb

@@ -2,65 +2,23 @@
 
 module Pubid
   module Export
-    # Top-level orchestrator. Iterates flavors, selects the appropriate
-    # extraction strategy, and produces the combined result.
+    # Top-level orchestrator. Iterates flavors and delegates to FlavorExporter.
     #
-    # Open/Closed: Adding a new flavor only requires registering it in
-    # FLAVOR_STRATEGIES; no existing code changes.
+    # Open/Closed: Adding a new flavor only requires adding it to FLAVORS;
+    # no existing code changes.
     class Exporter
       FLAVORS = %i[
         iso iec ieee nist bsi itu cen_cenelec etsi ansi astm ashrae asme
         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|
-          strategy_name = FLAVOR_STRATEGIES[flavor]
-          strategy_class = STRATEGY_CLASSES[strategy_name]
-          next unless strategy_class
-
-          exporter = strategy_class.new(flavor)
+          exporter = FlavorExporter.new(flavor)
           flavor_result = exporter.export
           next unless flavor_result
 

data/lib/pubid/export/flavor_exporter.rb

@@ -4,11 +4,14 @@ require "set"
 
 module Pubid
   module Export
-    # Abstract base class for per-flavor metadata extraction.
-    # Subclasses implement strategy for different Scheme patterns.
+    # Unified metadata extractor for all flavors.
     #
-    # Open/Closed: New flavors add a subclass; no existing code changes.
-    # Single Responsibility: Each subclass extracts data for one Scheme pattern.
+    # 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.
     class FlavorExporter
       attr_reader :flavor
 
@@ -22,300 +25,106 @@ module Pubid
         @flavor = flavor
       end
 
-      # Subclasses must override
       def export
-        raise NotImplementedError
-      end
-
-      protected
+        mod = flavor_module
+        return nil unless mod
 
-      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
-
-      def scheme_class
-        @scheme_class ||= begin
-          mod = scheme_module
-          mod&.const_get(:Scheme)
-        rescue NameError
-          nil
-        end
-      end
+        klasses = resolve_identifier_classes(mod)
+        return nil if klasses.empty?
 
-      def identifier_classes
-        resolve_identifier_classes
-      end
+        fixture_data = fixture_examples
+        seen_keys = Set.new
 
-      def resolve_identifier_classes
-        scheme = scheme_class
-        scheme_klasses = []
+        identifier_types = klasses.filter_map do |klass|
+          info = extract_type_info(klass)
+          next if seen_keys.include?(info[:key])
 
-        # Pattern 1: Class methods (ISO, IEC, ASTM, etc.)
-        begin
-          scheme_klasses = scheme.identifiers if scheme
-        rescue NoMethodError
-          scheme_klasses = []
-        end
+          seen_keys << info[:key]
 
-        # 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
+          stages = extract_typed_stages(klass)
+          examples = match_examples(fixture_data, info[:key]&.to_s, klass)
 
-        # 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]
+          IdentifierTypeResult.new(
+            key: info[:key],
+            title: info[:title],
+            short: info[:short],
+            abbr: info[:abbr],
+            typed_stages: stages,
+            examples: examples,
+          )
         end
 
-        # 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
+        FlavorResult.new(
+          flavor: flavor,
+          identifier_types: identifier_types,
+          wrapper_types: extract_wrapper_types,
+          attributes: extract_attributes(klasses.first),
+        )
       end
 
-      # Classes to skip when discovering additional identifier types
-      SKIP_CLASSES = %w[Base].freeze
-
-      def discover_additional_typed_classes(known_classes,
-known_website_keys = Set.new)
-        mod = scheme_module
-        return [] unless mod
-
-        idents_mod = mod.const_get(:Identifiers)
-        known_set = Set.new(known_classes)
-
-        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)
+      protected
 
-          # 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)
+      # 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?
 
-          known_website_keys << wkey if wkey
-          klass
-        end
+        discover_from_namespace(mod)
       end
 
-      # 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
+      # Scan Identifiers namespace for all Pubid::Identifier subclasses,
+      # excluding structural base classes.
+      def discover_from_namespace(mod)
+        return [] unless mod.const_defined?(:Identifiers)
 
-      # 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
+        idents_mod = mod.const_get(:Identifiers)
+        collect_identifier_classes(idents_mod)
+      end
 
-      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
+      # 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
           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
 
-        type_info = begin
-          klass.type
-        rescue NoMethodError, NotImplementedError
-          nil
-        end
-        metadata = begin
-          klass.metadata
-        rescue NoMethodError
+      # 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
           nil
         end
+      end
+
+      def extract_type_info(klass)
+        type_info = safe_type(klass)
+        metadata = safe_metadata(klass)
 
-        lib_key = type_info&.dig(:key)
+        key = type_info&.dig(:web) || type_info&.dig(:key)
         title = type_info&.dig(:title) || metadata&.title
         short = type_info&.dig(:short) || metadata&.short
         abbr = metadata&.abbr || []
 
-        # Derive from class name when def self.type is missing
-        unless lib_key
+        unless key
           class_name = klass.name&.split("::")&.last
-          lib_key = class_name&.gsub(/([A-Z])/, '_\1')&.downcase&.sub(/^_/,
-                                                                      "")&.to_sym
+          key = class_name&.gsub(/([A-Z])/, '_\1')&.downcase&.sub(/^_/, "")
           title ||= class_name&.gsub(/([A-Z])/, ' \1')&.strip
         end
 
-        # 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
+        { key: key&.to_s, title: title, short: short, abbr: abbr }
       end
 
       def extract_typed_stages(klass)
@@ -326,14 +135,10 @@ known_website_keys = Set.new)
         []
       end
 
-      # Map flavor keys to fixture directory names when they differ
-      FIXTURE_DIR_ALIASES = {}.freeze
-
+      # Fixture example extraction
       def fixture_examples
-        # __dir__ = lib/pubid/export → go up 3 levels to gem root, then spec/fixtures
         gem_root = File.expand_path("../../..", __dir__)
-        dir_name = FIXTURE_DIR_ALIASES[flavor] || flavor.to_s
-        base = File.join(gem_root, "spec", "fixtures", dir_name, "identifiers",
+        base = File.join(gem_root, "spec", "fixtures", flavor.to_s, "identifiers",
                          "pass")
         return {} unless Dir.exist?(base)
 
@@ -351,10 +156,8 @@ known_website_keys = Set.new)
         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
@@ -364,8 +167,24 @@ known_website_keys = Set.new)
         identifiers.uniq.first(10)
       end
 
-      def map_fixture_key_to_type_key(fixture_key)
-        fixture_key
+      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
       end
 
       def extract_attributes(klass)
@@ -378,7 +197,7 @@ known_website_keys = Set.new)
         names = WRAPPER_CLASSES[flavor]
         return [] unless names
 
-        mod = scheme_module
+        mod = flavor_module
         return [] unless mod
 
         identifiers_mod = mod.const_get(:Identifiers)
@@ -397,6 +216,20 @@ known_website_keys = Set.new)
           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.rb

@@ -6,12 +6,6 @@ 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