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

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.ancestors.include?(Pubid::IdentifierMetadata)
+        @metadata ||= if superclass.is_a?(Class) && superclass.respond_to?(:metadata)
                         superclass.metadata
                       end
       end

data/lib/pubid/identifier_registry.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require_relative "identifier_metadata"
+
+module Pubid
+  # Global registry of all identifier types across all flavors
+  # Provides searchable index for machine-readable lookups
+  class IdentifierRegistry
+    class << self
+      # Register an identifier class with its metadata
+      # @param identifier_class [Class] The identifier class
+      # @param metadata [Hash] Metadata attributes
+      def register(identifier_class, **metadata)
+        # Extract class name from full class name
+        identifier_class_name = identifier_class.name.to_s.split("::")&.last
+
+        all_identifiers[identifier_class] = IdentifierMetadata::Metadata.new(
+          flavor: metadata.fetch(:flavor),
+          identifier_class: identifier_class_name,
+          **metadata,
+        )
+
+        # Index by various keys for fast lookup
+        index_by_flavor(metadata[:flavor], identifier_class)
+        if metadata[:type_key]
+          index_by_type_key(metadata[:type_key],
+                            identifier_class)
+        end
+        index_by_abbr(metadata[:abbr], identifier_class) if metadata[:abbr]
+
+        identifier_class
+      end
+
+      # Find identifier class by flavor and type key
+      # @param flavor [String, Symbol] The flavor
+      # @param type_key [String, Symbol] The type key
+      # @return [Class, nil]
+      def find_by_type(flavor, type_key)
+        flavor_index[flavor.to_s]&.dig(type_key.to_s)
+      end
+
+      # Find identifier class by abbreviation
+      # @param flavor [String, Symbol] The flavor
+      # @param abbr [String] The abbreviation
+      # @return [Array<Class>] All matching classes
+      def find_by_abbr(flavor, abbr)
+        abbr_index[flavor.to_s]&.dig(abbr.to_s.downcase) || []
+      end
+
+      # Get all identifiers for a flavor
+      # @param flavor [String, Symbol] The flavor
+      # @return [Array<Class>]
+      def all_for_flavor(flavor)
+        flavor_index[flavor.to_s]&.values || []
+      end
+
+      # Get all registered identifiers
+      # @return [Hash<Class, Metadata>]
+      def all_identifiers
+        @all_identifiers ||= {}
+      end
+
+      # Get metadata for an identifier class
+      # @param identifier_class [Class] The identifier class
+      # @return [Metadata, nil]
+      def metadata_for(identifier_class)
+        all_identifiers[identifier_class]
+      end
+
+      # Search identifiers by criteria
+      # @param criteria [Hash] Search criteria
+      # @option criteria [String, Symbol] :flavor Filter by flavor
+      # @option criteria [String, Symbol] :type_key Filter by type key
+      # @option criteria [String] :abbr Filter by abbreviation
+      # @option criteria [String] :title Filter by title (partial match)
+      # @option criteria [Boolean] :base_class Filter by base class status
+      # @option criteria [Boolean] :supplement_class Filter by supplement class status
+      # @return [Array<Hash>] Array of {class: Class, metadata: Metadata}
+      def search(**criteria)
+        results = []
+
+        all_identifiers.each do |klass, metadata|
+          matches = true
+
+          if criteria[:flavor]
+            matches &= metadata.flavor.to_s == criteria[:flavor].to_s
+          end
+
+          if criteria[:type_key]
+            matches &= metadata.type_key.to_s == criteria[:type_key].to_s
+          end
+
+          if criteria[:abbr]
+            matches &= metadata.abbr.map(&:to_s).map(&:downcase).include?(criteria[:abbr].to_s.downcase)
+          end
+
+          if criteria[:title]
+            matches &= metadata.title.to_s.downcase.include?(criteria[:title].to_s.downcase)
+          end
+
+          if criteria[:base_class]
+            matches &= !metadata.base_class.nil? == criteria[:base_class]
+          end
+
+          if criteria[:supplement_class]
+            matches &= !metadata.supplement_class.nil? == criteria[:supplement_class]
+          end
+
+          results << { class: klass, metadata: metadata } if matches
+        end
+
+        results
+      end
+
+      # Export registry to machine-readable format (JSON)
+      # @return [String] JSON representation
+      def to_json(*args)
+        all_identifiers.values.map(&:to_hash).to_json(*args)
+      end
+
+      # Export registry to machine-readable format (YAML)
+      # @return [String] YAML representation
+      def to_yaml
+        require "json"
+        hash = all_identifiers.values.map(&:to_h)
+        # Convert to YAML format (basic implementation)
+        hash.map(&:to_json).join("\n")
+      end
+
+      # Clear all registrations (useful for testing)
+      def clear!
+        @all_identifiers = {}
+        @flavor_index = nil
+        @type_key_index = nil
+        @abbr_index = nil
+      end
+
+      # Generate a summary report
+      # @return [String] Human-readable summary
+      def summary
+        flavors = all_identifiers.values.map(&:flavor).uniq.sort
+        total = all_identifiers.size
+
+        summary = "Identifier Registry Summary\n"
+        summary += "#{'=' * 50}\n"
+        summary += "Total identifiers: #{total}\n"
+        summary += "Flavors: #{flavors.join(', ')}\n\n"
+
+        flavors.each do |flavor|
+          flavor_ids = all_identifiers.values.select do |m|
+            m.flavor.to_s == flavor
+          end
+          summary += "#{flavor.upcase} (#{flavor_ids.size}):\n"
+          flavor_ids.sort_by(&:type_key).each do |metadata|
+            summary += "  - #{metadata.type_key}: #{metadata.title}\n"
+          end
+        end
+
+        summary
+      end
+
+      private
+
+      def flavor_index
+        @flavor_index ||= Hash.new { |h, k| h[k] = {} }
+      end
+
+      def type_key_index
+        @type_key_index ||= Hash.new { |h, k| h[k] = {} }
+      end
+
+      def abbr_index
+        @abbr_index ||= Hash.new do |h, k|
+          h[k] = Hash.new do |h2, k2|
+            h2[k2] = []
+          end
+        end
+      end
+
+      def index_by_flavor(flavor, identifier_class)
+        flavor_index[flavor.to_s][:_all] ||= []
+        flavor_index[flavor.to_s][:_all] << identifier_class
+      end
+
+      def index_by_type_key(type_key, identifier_class)
+        flavor = all_identifiers[identifier_class].flavor
+        flavor_index[flavor.to_s][type_key.to_s] = identifier_class
+      end
+
+      def index_by_abbr(abbr, identifier_class)
+        flavor = all_identifiers[identifier_class].flavor
+        Array(abbr).each do |a|
+          abbr_index[flavor.to_s][a.to_s.downcase] << identifier_class
+        end
+      end
+    end
+  end
+end

data/lib/pubid/idf/builder.rb

@@ -13,8 +13,8 @@ module Pubid
       }.freeze
 
       def build(parsed_hash)
-        typed_stage = Pubid::Idf.locate_stage(parsed_hash[:type_with_stage])
-        identifier = Pubid::Idf.locate_type(typed_stage.type_code).new
+        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
 
         if type_with_stage_fr = parsed_hash.delete(:type_with_stage_fr)
           parsed_hash[:type_with_stage] = type_with_stage_fr
@@ -32,7 +32,7 @@ module Pubid
 
       def cast(type, value)
         case type
-        when :base
+        when :base_identifier
           build(value)
         when :publisher
           Components::Publisher.new(body: value)
@@ -41,14 +41,14 @@ module Pubid
           number = parts.shift
           part = parts.shift
           subpart = parts.size.positive? ? parts.join("-") : nil
-          code_hash = { number: number }
-          code_hash[:part] = part if part
-          code_hash[:subpart] = subpart if subpart
+          code_hash = { number: Components::Code.new(value: number) }
+          code_hash[:part] = Components::Code.new(value: part) if part
+          code_hash[:subpart] = Components::Code.new(value: subpart) if subpart
           code_hash
         when :type_with_stage
           iteration = value.to_s.match(/(\d+)$/)
           value = value.to_s.sub(iteration.to_s, "")
-          typed_stage = Pubid::Idf.locate_stage(value || "")
+          typed_stage = Scheme.locate_typed_stage_by_abbr(value || "")
           {
             stage: typed_stage.to_stage,
             type: typed_stage.to_type,

data/lib/pubid/idf/identifier.rb

@@ -7,17 +7,11 @@ module Pubid
     class Identifier < ::Pubid::Identifier
       attribute :typed_stage, Components::TypedStage
 
-      # `number`/`part`/`subpart` are declared here rather than inherited as a
-      # Components::Code: IDF stores a bare string in every one of them.
-      # Declaring on this class is safe because its body lives in this one file
-      # and is never reopened, so every subclass body opens after it has run
-      # (lutaml deep-dups the parent attribute table at class-definition time).
-      attribute :number, :string
-      attribute :part, :string
-      attribute :subpart, :string
-
-      def to_s(**opts)
-        render(format: :human, **opts)
+      def to_s(lang: :en, lang_single: false, with_edition: false)
+        [
+          publisher_portion(lang: lang),
+          number_portion(lang_single: lang_single),
+        ].join
       end
 
       def publisher_portion(lang: :en)
@@ -30,14 +24,14 @@ module Pubid
       def number_portion(lang_single: false)
         [
           # Directives may not have a number
-          (number ? " #{number}" : ""),
+          (number ? " #{number.value}" : ""),
 
           # Parts and subparts are optional
-          (part ? "-#{part}" : ""),
-          (subpart ? "-#{subpart}" : ""),
+          (part ? "-#{part.value}" : ""),
+          (subpart ? "-#{subpart.value}" : ""),
 
           # Stage iteration is optional
-          (stage_iteration ? ".#{stage_iteration.number}" : ""),
+          (stage_iteration ? ".#{stage_iteration.value}" : ""),
 
           # Date is optional
           (date ? ":#{date.year}" : ""),
@@ -62,16 +56,12 @@ module Pubid
       end
 
       def self.parse(string)
-        unless string.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if string.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        parsed = Pubid::Idf::Parser.new.parse(string)
+        if parsed.nil? || parsed.empty?
+          raise Pubid::Idf::Parser::ParseError,
+                "Invalid identifier format"
         end
 
-        parsed = Pubid::Idf::Parser.new.parse(string)
         Pubid::Idf::Builder.new.build(parsed)
       end
     end

data/lib/pubid/idf/identifiers/amendment.rb

@@ -19,8 +19,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :amd,
-            web: :amendment, title: "Amendment", short: "AMD" }
+          { key: :amd, title: "Amendment", short: "AMD" }
         end
       end
     end

data/lib/pubid/idf/identifiers/corrigendum.rb

@@ -19,8 +19,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :cor,
-            web: :corrigendum, title: "Corrigendum", short: "COR" }
+          { key: :cor, title: "Corrigendum", short: "COR" }
         end
       end
     end

data/lib/pubid/idf/identifiers/international_standard.rb

@@ -115,8 +115,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :is,
-            web: :international_standard, title: "International Standard", short: nil }
+          { key: :is, title: "International Standard", short: nil }
         end
       end
     end

data/lib/pubid/idf/identifiers/reviewed_method.rb

@@ -92,8 +92,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :rm,
-            web: :reviewed_method, title: "Reviewed Method", short: "RM" }
+          { key: :rm, title: "Reviewed Method", short: "RM" }
         end
       end
     end

data/lib/pubid/idf/parser.rb

@@ -4,15 +4,14 @@ require "parslet"
 
 module Pubid
   module Idf
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 
       # We need to sort by length to match longest first because that's how Parslet works
-      TYPED_STAGES = Pubid::Idf.all_typed_stages
+      TYPED_STAGES = Pubid::Idf::Scheme.typed_stages
         .map(&:abbr).flatten.sort_by(&:length).reverse
-      TYPED_STAGES_SUPPLEMENTS = Pubid::Idf.all_typed_stages
-        .select { |ts| %w[amd cor].include?(ts.type_code.to_s) }
+      TYPED_STAGES_SUPPLEMENTS = Pubid::Idf::Scheme.supplement_typed_stages
         .map(&:abbr).flatten.sort_by(&:length).reverse
 
       root :identifier
@@ -117,7 +116,7 @@ module Pubid
       # IDF 148-1:2008 / COR 1:2009
       # IDF 140-1:2007 / AMD1:2012 (no space between AMD and 1)
       rule(:supplement_identifier_no_third) do
-        identifier_publisher_no_third.as(:base) >>
+        identifier_publisher_no_third.as(:base_identifier) >>
           space? >> str("/") >> space? >>
           supplement_type_with_stage >>
           space.maybe >> second_part
@@ -130,7 +129,7 @@ module Pubid
       # # ISO/IEC 13818-1:2015/Amd 3:2016/Cor 1:2017
       # # ISO/IEC 19794-7:2014/Amd 1:2015/CD Cor 1
       # rule(:supplement_supplement_identifier) do
-      #   supplement_identifier_no_third.as(:base) >>
+      #   supplement_identifier_no_third.as(:base_identifier) >>
       #     str("/") >> supplement_type_with_stage >>
       #     # digits.as(:stage_iteration).maybe >>
       #     space? >> second_part >> third_part

data/lib/pubid/idf/scheme.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          @identifiers ||= [
+            Identifiers::InternationalStandard,
+            Identifiers::ReviewedMethod,
+          ].freeze
+        end
+
+        def supplement_identifiers
+          @supplement_identifiers ||= [
+            Identifiers::Amendment,
+            Identifiers::Corrigendum,
+          ].freeze
+        end
+
+        def typed_stages
+          @typed_stages ||= identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def supplement_typed_stages
+          @supplement_typed_stages ||= supplement_identifiers.flat_map do |klass|
+            klass::TYPED_STAGES
+          end
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "" if abbr.nil?
+
+          typed_stage = (typed_stages + supplement_typed_stages).detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          identifier_klass = (identifiers + supplement_identifiers).detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      end
+    end
+  end
+end

data/lib/pubid/idf/supplement_identifier.rb

@@ -12,23 +12,31 @@ module Pubid
     # SingleIdentifier (which is for base documents only).
     #
     # Architecture Note:
-    # - Supplements have a base attribute (recursive structure)
+    # - Supplements have a base_identifier attribute (recursive structure)
     # - Supplements share the to_s rendering pattern
     # - Supplements inherit typed_stage from base Identifier class
     class SupplementIdentifier < Identifier
-      attribute :base, Identifier
+      attribute :base_identifier, Identifier
 
       # Render supplement identifier as string.
       #
-      # Format: "base/ABBREVIATION number:year"
+      # Format: "base_identifier/ABBREVIATION number:year"
       # Example: "IDF 125:1988/AMD 1:2023"
       #
       # @param lang [Symbol] Language (default: :en)
       # @param lang_single [Boolean] Use single-char language codes (default: false)
       # @param with_edition [Boolean] Include edition (default: false)
       # @return [String] String representation of supplement
-      def to_s(**opts)
-        render(format: :human, **opts)
+      def to_s(lang: :en, lang_single: false, with_edition: false)
+        [
+          base_identifier.to_s(lang: lang, lang_single: lang_single,
+                               with_edition: with_edition),
+          "/",
+          typed_stage.abbreviation,
+          " ",
+          number.value,
+          (date ? ":#{date.year}" : ""),
+        ].join
       end
     end
   end

data/lib/pubid/idf/urn_generator.rb

@@ -9,6 +9,41 @@ module Pubid
         identifier.type.abbr.to_s.downcase
       end
 
+      def urn_number
+        return nil unless identifier.number
+
+        identifier.number.value.to_s
+      end
+
+      def urn_part
+        return nil unless identifier.part
+
+        "-#{identifier.part.value}"
+      end
+
+      def urn_subpart
+        return nil unless identifier.subpart
+
+        "-#{identifier.subpart.value}"
+      end
+
+      def urn_year
+        if identifier.date&.year
+          return identifier.date.year.to_s
+        end
+
+        identifier.year&.to_s
+      end
+
+      def urn_edition
+        return nil unless identifier.edition
+
+        num = identifier.edition.number
+        return nil unless num
+
+        "ed.#{num}"
+      end
+
       def generate
         parts = ["urn", "idf"]
         parts << urn_number if urn_number
@@ -19,12 +54,12 @@ module Pubid
         parts << urn_type if urn_type
 
         if identifier.publisher
-          parts[1] = identifier.publisher.render(context: URN_CONTEXT)
+          parts[1] = identifier.publisher.body.to_s.downcase
         end
 
         if identifier.copublishers&.any?
-          copubs = identifier.copublishers.map { |cp| cp.render(context: URN_CONTEXT) }
-          parts[1] = "#{parts[1]}-#{copubs.join('-')}"
+          copubs = identifier.copublishers.map(&:body)
+          parts[1] = "#{parts[1]}-#{copubs.join('-').downcase}"
         end
 
         if identifier.languages&.any?
@@ -38,7 +73,7 @@ module Pubid
           end
 
           if identifier.number
-            parts << identifier.number
+            parts << identifier.number.value.to_s
           end
         end
 

data/lib/pubid/idf.rb

@@ -2,86 +2,22 @@
 
 module Pubid
   module Idf
-    extend Pubid::PrefixesSupport
-
-    # Sole IDF publisher token (see the parser's `prefix_sole_publisher` rule).
-    PREFIXES = ["IDF"].freeze
-
     autoload :Builder, "#{__dir__}/idf/builder"
     autoload :Identifier, "#{__dir__}/idf/identifier"
     autoload :Identifiers, "#{__dir__}/idf/identifiers"
     autoload :Parser, "#{__dir__}/idf/parser"
-    autoload :Renderer, "#{__dir__}/idf/renderer"
+    autoload :Scheme, "#{__dir__}/idf/scheme"
     autoload :SingleIdentifier, "#{__dir__}/idf/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/idf/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/idf/urn_generator"
-    autoload :UrnParser, "#{__dir__}/idf/urn_parser"
 
     def self.parse(identifier)
-      unless identifier.is_a?(String)
-        raise Pubid::Errors::InvalidInputError,
-              Pubid::INPUT_NOT_A_STRING_MESSAGE
-      end
-
-      if identifier.length > Pubid::MAX_INPUT_LENGTH
-        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-      end
-
       parser = Parser.new
       builder = Builder.new
 
       parsed = parser.parse(identifier)
       builder.build(parsed)
     end
-
-    # Build an IDF identifier from a parse-tree hash (used by ISO joint-identifier
-    # parsing). This is the public seam: callers should never reach into
-    # `Idf::Builder` directly.
-    # @param hash [Hash] parse tree for the joint identifier
-    # @return [Pubid::Idf::Identifier]
-    def self.build_from_parse(hash)
-      Builder.new.build(hash)
-    end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Idf::Renderer)
-
-    # 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
 end