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

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

data/lib/pubid/identifier.rb

@@ -1,14 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "components/code"
-require_relative "components/date"
-require_relative "components/edition"
-require_relative "components/language"
-require_relative "components/locality"
-require_relative "components/publisher"
-require_relative "components/stage"
-require_relative "components/type"
-
 module Pubid
   class Identifier < Lutaml::Model::Serializable
     class << self
@@ -23,7 +14,7 @@ module Pubid
     attribute :number, Components::Code
     attribute :part, Components::Code
     attribute :subpart, Components::Code
-    attribute :stage_iteration, Components::Code
+    attribute :stage_iteration, Components::Iteration
     attribute :date, Components::Date
     attribute :edition, Components::Edition
     attribute :languages, Components::Language, collection: true
@@ -62,12 +53,6 @@ module Pubid
       "pubid:#{flavor}:#{type_kebab}"
     end
 
-    klass_ref = self
-    key_value do
-      klass_ref.attributes.each_key do |name|
-        map name.to_s, to: name.to_sym
-      end
-    end
 
     def root
       return base_identifier.root if base_identifier
@@ -165,7 +150,7 @@ module Pubid
       excluded_args << :date if excluded_args.delete(:year)
 
       attrs = self.class.attributes.each_with_object({}) do |(name, _), h|
-        h[name] = excluded_args.include?(name) ? nil : send(name)
+        h[name] = excluded_args.include?(name) ? nil : public_send(name)
       end
       self.class.new(attrs)
     end

data/lib/pubid/identifier_facade.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Mixin for the per-flavor `Identifier` *module* facades (NIST, IHO, BSI,
+  # CEN/CENELEC, ASHRAE). The class-pattern flavors (ISO, IEC, JIS, …) expose
+  # their root identifier as a real class, so `id.is_a?(Pubid::Iso::Identifier)`
+  # and `Pubid::Iso::Identifier.from_hash` already work natively. The
+  # module-pattern flavors keep `Identifier` as a thin parse/factory module;
+  # this mixin gives that module the same two capabilities a consumer relies on
+  # when it is handed the module as its identifier class (e.g. relaton-index's
+  # `pubid_class`):
+  #
+  #   * `from_hash` — polymorphic deserialization that dispatches on the
+  #     `_type` discriminator to the correct concrete `Identifiers::*` class,
+  #     reusing the flavor's own `identifier_types` registry rather than a
+  #     hand-maintained map.
+  #   * identity — `extend`ing this mixin into the `Identifier` module is paired
+  #     with `include`-ing that module into the flavor's `Identifiers::Base`, so
+  #     every concrete identifier descends from it. That makes
+  #     `id.is_a?(Pubid::Nist::Identifier)` and `Pubid::Nist::Identifier === id`
+  #     both true (`Module#===` delegates to `is_a?`) — the test a consumer
+  #     holding the module needs to ask "is this one of my identifiers?".
+  #
+  # The flavor namespace, the `Identifiers` namespace, and the fallback `Base`
+  # class are all derived from the extending module's own name by convention
+  # (`Pubid::<Flavor>::Identifier`), so a flavor opts in with a single
+  # `extend Pubid::IdentifierFacade`.
+  #
+  # Opt-in is deliberately GATED to flavors whose `to_hash`/`from_hash`
+  # round-trips cleanly. Some module-pattern flavors (AMCA, ITU, PLATEAU, IEEE)
+  # have a broken `to_hash` (publisher stored as a String) or a lossy
+  # `from_hash`; for those the facade's identity check would route ids through a
+  # consumer's `to_hash` and crash or silently corrupt them, so they
+  # intentionally do not opt in (see the NOTE in each of their identifier.rb).
+  module IdentifierFacade
+    # Reconstruct a concrete identifier from its serialized key_value hash by
+    # dispatching on the `_type` discriminator. Falls back to the flavor's
+    # `Identifiers::Base` for an absent/unknown type, matching lutaml's own
+    # non-polymorphic default.
+    #
+    # @param data [Hash] the serialized identifier hash (string or symbol keys)
+    # @return [Pubid::Identifier] the concrete identifier instance
+    def from_hash(data, options = {})
+      type = data && (data["_type"] || data[:_type])
+      klass = polymorphic_type_map[type] || identifier_base_class
+      klass.from_hash(data, options)
+    end
+
+    # Map of polymorphic_name ("pubid:nist:interagency-report") => concrete
+    # class, built once from the flavor's identifier-type registry so it tracks
+    # newly registered types automatically.
+    # @return [Hash{String => Class}]
+    def polymorphic_type_map
+      @polymorphic_type_map ||=
+        (identifier_registry_classes + [identifier_base_class]).uniq
+          .each_with_object({}) do |klass, map|
+            poly_name = klass.polymorphic_name
+            map[poly_name] = klass if poly_name
+          end
+    end
+
+    private
+
+    # The flavor module that namespaces this facade, e.g. Pubid::Nist for
+    # Pubid::Nist::Identifier.
+    def facade_flavor_module
+      @facade_flavor_module ||=
+        Object.const_get(name.split("::")[0...-1].join("::"))
+    end
+
+    def facade_identifiers_namespace
+      @facade_identifiers_namespace ||=
+        facade_flavor_module.const_get(:Identifiers)
+    end
+
+    # Fallback class for an absent/unknown `_type`. Most flavors expose a
+    # concrete `Identifiers::Base`; flavors without one (e.g. BSI, whose common
+    # ancestor is SingleIdentifier) fall back to the shared root, which is only
+    # ever reached for an unrecognized `_type`.
+    def identifier_base_class
+      if facade_identifiers_namespace.const_defined?(:Base, false)
+        facade_identifiers_namespace.const_get(:Base)
+      else
+        ::Pubid::Identifier
+      end
+    end
+
+    # Every concrete identifier class whose `_type` may appear in a serialized
+    # hash. Scans the `Identifiers` namespace for descendants of
+    # Pubid::Identifier (the complete set, independent of whatever filtering the
+    # flavor's `identifier_types` applies) and unions in `identifier_types`,
+    # which may register classes living outside that namespace.
+    def identifier_registry_classes
+      (scanned_identifier_classes + registered_identifier_classes).uniq
+    end
+
+    # Concrete identifier classes found directly in the `Identifiers` namespace.
+    def scanned_identifier_classes
+      facade_identifiers_namespace.constants.filter_map do |const|
+        klass = facade_identifiers_namespace.const_get(const)
+        klass if klass.is_a?(Class) && klass < ::Pubid::Identifier
+      rescue NameError
+        nil
+      end
+    end
+
+    # Classes the flavor explicitly registers via `identifier_types`, if any.
+    def registered_identifier_classes
+      return [] unless facade_flavor_module.respond_to?(:identifier_types)
+
+      Array(facade_flavor_module.identifier_types)
+    end
+  end
+end

data/lib/pubid/identifier_metadata.rb

@@ -102,7 +102,7 @@ module Pubid
       # Get the metadata for this class
       # @return [Metadata, nil]
       def metadata
-        @metadata ||= if superclass.is_a?(Class) && superclass.respond_to?(:metadata)
+        @metadata ||= if superclass.is_a?(Class) && superclass.ancestors.include?(Pubid::IdentifierMetadata)
                         superclass.metadata
                       end
       end

data/lib/pubid/idf/builder.rb

@@ -13,8 +13,8 @@ module Pubid
       }.freeze
 
       def build(parsed_hash)
-        typed_stage = Scheme.locate_typed_stage_by_abbr(parsed_hash[:type_with_stage])
-        identifier = Scheme.locate_identifier_klass_by_type_code(typed_stage.type_code).new
+        typed_stage = Pubid::Idf.locate_stage(parsed_hash[:type_with_stage])
+        identifier = Pubid::Idf.locate_type(typed_stage.type_code).new
 
         if type_with_stage_fr = parsed_hash.delete(:type_with_stage_fr)
           parsed_hash[:type_with_stage] = type_with_stage_fr
@@ -48,7 +48,7 @@ module Pubid
         when :type_with_stage
           iteration = value.to_s.match(/(\d+)$/)
           value = value.to_s.sub(iteration.to_s, "")
-          typed_stage = Scheme.locate_typed_stage_by_abbr(value || "")
+          typed_stage = Pubid::Idf.locate_stage(value || "")
           {
             stage: typed_stage.to_stage,
             type: typed_stage.to_type,