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

data/lib/pubid/csa.rb

@@ -6,9 +6,10 @@ module Pubid
     autoload :Identifier, "#{__dir__}/csa/identifier"
     autoload :Identifiers, "#{__dir__}/csa/identifiers"
     autoload :Parser, "#{__dir__}/csa/parser"
-    autoload :Scheme, "#{__dir__}/csa/scheme"
+    autoload :Renderer, "#{__dir__}/csa/renderer"
     autoload :SingleIdentifier, "#{__dir__}/csa/single_identifier"
     autoload :UrnGenerator, "#{__dir__}/csa/urn_generator"
+    autoload :UrnParser, "#{__dir__}/csa/urn_parser"
     autoload :WrapperIdentifier, "#{__dir__}/csa/wrapper_identifier"
     autoload :CompositeIdentifier, "#{__dir__}/csa/composite_identifier"
     autoload :Components, "#{__dir__}/csa/components"
@@ -16,6 +17,42 @@ module Pubid
     def self.parse(identifier_string)
       Identifier.parse(identifier_string)
     end
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    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.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    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
 
   # Register this flavor with the Pubid registry
@@ -23,3 +60,7 @@ end
 
 # Register Ucsa flavor with the registry
 Pubid::Registry.register(:csa, Pubid::Csa)
+
+# Per-flavor format registry: inherits global formats, overrides :human
+Pubid::Csa::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Csa::SingleIdentifier.format_registry.register(:human, renderer: Pubid::Csa::Renderer)

data/lib/pubid/etsi/components/code.rb

@@ -10,9 +10,12 @@ module Pubid
       #   Simple: 012, 123, 456
       #   GSM: GSM 02.01, 02.01
       #   Complex: ABC 123, ABC-DEF 123
+      #
+      # Stays independent of Pubid::Components::Code because ETSI uses
+      # +minor+ (a flavor-specific sub-number) plus +parts+.
       class Code < Lutaml::Model::Serializable
-        attribute :number, :string  # Main number (can contain dots, letters, etc.)
-        attribute :minor, :string   # Optional minor part
+        attribute :number, :string # Main number
+        attribute :minor, :string # Optional minor part
         attribute :parts, :string, collection: true # Parts array
 
         def initialize(number:, minor: nil, parts: nil)
@@ -29,6 +32,10 @@ module Pubid
           result
         end
 
+        def render(context: nil)
+          to_s
+        end
+
         def ==(other)
           return false unless other.is_a?(Code)
 

data/lib/pubid/etsi/identifier.rb

@@ -9,49 +9,6 @@ module Pubid
       rescue Parslet::ParseFailed => e
         raise "Failed to parse ETSI identifier '#{identifier}': #{e.message}"
       end
-
-      # Factory mirroring pubid 1.x's `Pubid::Etsi::Identifier.create` API.
-      #
-      # ETSI's `type` kwarg (EN, ES, EG, TS, TR, GS, GR, GTS, …) is data
-      # stored on the identifier instance, not a class-dispatch key — all
-      # ETSI standards share the {Identifiers::EtsiStandard} class.
-      #
-      # @param opts [Hash] :type, :code/:number, :parts, :version, :year,
-      #   :month, :date
-      def self.create(**opts)
-        Identifiers::EtsiStandard.new(**coerce_create_attrs(opts))
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {}
-        attrs[:type] = opts[:type].to_s if opts[:type]
-
-        code_value = opts[:code] || opts[:number]
-        if code_value
-          attrs[:code] = Pubid::Etsi::Components::Code.new(
-            number: code_value.to_s,
-            parts:  opts[:parts] ? Array(opts[:parts]).map(&:to_s) : nil,
-          )
-        end
-
-        if (v = opts[:version])
-          attrs[:version] = Pubid::Etsi::Components::Version.new(
-            version: v.to_s,
-          )
-        end
-
-        if opts[:year] || opts[:month]
-          attrs[:date] = ::Pubid::Components::Date.new(
-            year:  opts[:year]&.to_s,
-            month: opts[:month]&.to_s,
-          )
-        end
-
-        # TODO(create-shim): Amendment and Corrigendum supplements need a
-        # base_identifier and aren't yet wired through.
-        attrs
-      end
-      private_class_method :coerce_create_attrs
     end
   end
 end

data/lib/pubid/etsi/identifiers/base.rb

@@ -18,10 +18,7 @@ module Pubid
         end
 
         def to_s
-          result = "#{publisher} #{type} #{code}"
-          result += " #{version} (#{date.year}-#{date.month.to_s.rjust(2,
-                                                                       '0')})"
-          result
+          render(format: :human)
         end
 
         def ==(other)

data/lib/pubid/etsi/identifiers/supplement_identifier.rb

@@ -25,16 +25,9 @@ module Pubid
           base.date
         end
 
-        # Render as: ETSI TYPE CODE/SUPPLEMENTS VERSION (DATE)
-        # When multiple supplements are present, they appear in order: /A1/C1
+        # Render via renderer
         def to_s
-          supplement_notations = collect_supplement_notations(self, [])
-          # Get the actual base ETSI standard (not supplements)
-          actual_base = find_actual_base(base)
-          code_with_supplements = "#{actual_base.code}#{supplement_notations.join}"
-          "#{actual_base.publisher} #{actual_base.type} #{code_with_supplements} #{actual_base.version} (#{actual_base.date.year}-#{actual_base.date.month.to_s.rjust(
-            2, '0'
-          )})"
+          render(format: :human)
         end
 
         # Recursively collect supplement notations from the supplement chain

data/lib/pubid/etsi/renderer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    # Human-readable renderer for ETSI identifiers.
+    #
+    # Produces strings like:
+    #   "ETSI EN 301 419 V1.1.1 (2020-01)"
+    #   "ETSI TS 102 606-1/A1 V1.1.1 (2021-06)"
+    #   "ETSI GS NFV 002 ed.1 (2013-10)"
+    #
+    # The renderer is registered as the `:human` format in the ETSI format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::SupplementIdentifier
+          render_supplement(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      def render_base(id)
+        result = "#{id.publisher} #{id.type} #{id.code}"
+        result += " #{id.version} (#{id.date.render})"
+        result
+      end
+
+      def render_supplement(id)
+        supplement_notations = id.collect_supplement_notations(id, [])
+        actual_base = id.find_actual_base(id.base)
+        code_with_supplements = "#{actual_base.code}#{supplement_notations.join}"
+        "#{actual_base.publisher} #{actual_base.type} #{code_with_supplements} #{actual_base.version} (#{actual_base.date.render})"
+      end
+    end
+  end
+end

data/lib/pubid/etsi/urn_parser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    # Parses ETSI URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:etsi:{type}:{code}:{version}:{date}[:{supplement_notation}:{number}]
+    #
+    # type is the lowercase type abbreviation (en, ets, ts, tr, gs, sr).
+    # code is the identifier code with internal whitespace preserved.
+    # version is the lowercase Vx.y.z form.
+    # date is YYYY or YYYY-MM.
+    #
+    # Examples:
+    # - urn:etsi:en:300 100:v1.1.1:1998-04 → ETSI EN 300 100 V1.1.1 (1998-04)
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        type_token = parts.fetch(0).upcase
+        code = parts.fetch(1)
+        version = parts[2]
+        date = parts[3]
+
+        text = "ETSI #{type_token} #{code}"
+        text += " #{version.upcase}" if version
+        text += " (#{date})" if date
+        flavor_parse(text)
+      end
+    end
+  end
+end

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