pubid 1.15.19 → 2.0.0.pre.alpha.2

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    class Builder < Pubid::Builder::Base
+      LANG_CHAR_MAP = {
+        "R" => "ru",
+        "F" => "fr",
+        "E" => "en",
+        "A" => "ar",
+        "S" => "es",
+        "D" => "de",
+      }.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
+
+        if type_with_stage_fr = parsed_hash.delete(:type_with_stage_fr)
+          parsed_hash[:type_with_stage] = type_with_stage_fr
+        end
+
+        assign_attributes(identifier, parsed_hash)
+        identifier
+      end
+
+      private
+
+      def default_identifier_class
+        Identifiers::InternationalStandard
+      end
+
+      def cast(type, value)
+        case type
+        when :base_identifier
+          build(value)
+        when :publisher
+          Components::Publisher.new(body: value)
+        when :number_with_part
+          parts = value.to_s.split("-")
+          number = parts.shift
+          part = parts.shift
+          subpart = parts.size.positive? ? parts.join("-") : nil
+          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 = Scheme.locate_typed_stage_by_abbr(value || "")
+          {
+            stage: typed_stage.to_stage,
+            type: typed_stage.to_type,
+            typed_stage: typed_stage,
+          }
+        when :date
+          value = value.to_s
+          if value.match?(/^\d{4}(-\d{2})?$/)
+            year, month = value.split("-")
+            Components::Date.new(year: year, month: month || nil)
+          elsif value.is_a?(Integer) || (value.is_a?(String) && value.match?(/^\d{4}$/))
+            Components::Date.new(year: value)
+          else
+            raise ArgumentError, "Invalid date format: #{value.inspect}"
+          end
+        when :languages
+          value = value.to_s.gsub("/", ",")
+          value.split(",").map do |lang|
+            lang = lang.strip
+            lang = LANG_CHAR_MAP[lang] if lang.length == 1
+            Components::Language.new(code: lang)
+          end
+        when :all_parts
+          Components::Locality.new(all_parts: true)
+        else
+          raise ArgumentError, "Unknown type: #{type}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/idf/identifier.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Identifier that
+  module Idf
+    # An IDF identifier has no copublisher
+    class Identifier < ::Pubid::Identifier
+      attribute :typed_stage, Components::TypedStage
+
+      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)
+        [
+          publisher.body,
+          (typed_stage.abbreviation.empty? ? "" : "/#{typed_stage.abbreviation}"),
+        ].join
+      end
+
+      def number_portion(lang_single: false)
+        [
+          # Directives may not have a number
+          (number ? " #{number.value}" : ""),
+
+          # Parts and subparts are optional
+          (part ? "-#{part.value}" : ""),
+          (subpart ? "-#{subpart.value}" : ""),
+
+          # Stage iteration is optional
+          (stage_iteration ? ".#{stage_iteration.value}" : ""),
+
+          # Date is optional
+          (date ? ":#{date.year}" : ""),
+
+          # Languages are optional
+          language_portion(lang_single: lang_single),
+        ].join
+      end
+
+      # Returns a string representation of the languages
+      # :single returns single-char language codes
+      def language_portion(lang_single: false)
+        return "" unless languages&.any?
+
+        [
+          "(",
+          languages.map do |lang|
+            lang.to_s(lang_single: lang_single)
+          end.join(lang_single ? "/" : ","),
+          ")",
+        ].join
+      end
+
+      def self.parse(string)
+        parsed = Pubid::Idf::Parser.new.parse(string)
+        if parsed.nil? || parsed.empty?
+          raise Pubid::Idf::Parser::ParseError,
+                "Invalid identifier format"
+        end
+
+        Pubid::Idf::Builder.new.build(parsed)
+      end
+
+      # Factory mirroring pubid 1.x's `Pubid::Idf::Identifier.create` API.
+      # Default subclass is {Identifiers::InternationalStandard}.
+      #
+      # IDF's renderer requires `typed_stage` to be set (calls
+      # `.abbreviation` without a nil check); factory auto-resolves the
+      # "published" TypedStage for the chosen subclass.
+      TYPE_KEY_TO_KLASS = {
+        is:              "InternationalStandard",
+        reviewed_method: "ReviewedMethod",
+      }.freeze
+
+      def self.create(type: nil, stage: nil, **opts)
+        klass = resolve_create_class(type)
+        attrs = coerce_create_attrs(opts)
+        ts = resolve_create_typed_stage(klass, stage)
+        attrs[:typed_stage] = ts if ts
+        klass.new(**attrs)
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::InternationalStandard if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown IDF type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.resolve_create_typed_stage(klass, stage)
+        return nil unless klass.const_defined?(:TYPED_STAGES)
+
+        if stage
+          klass.const_get(:TYPED_STAGES).find do |ts|
+            ts.abbr.include?(stage.to_s)
+          end
+        else
+          klass.const_get(:TYPED_STAGES).find do |ts|
+            ts.stage_code&.to_sym == :published
+          end
+        end
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {
+          publisher: Pubid::Components::Publisher.new(
+            body: (opts[:publisher] || "IDF").to_s,
+          ),
+        }
+        if (v = opts[:number])
+          attrs[:number] = Pubid::Components::Code.new(value: v.to_s)
+        end
+        if (v = opts[:year])
+          attrs[:date] = Pubid::Components::Date.new(year: v.to_s)
+        end
+        attrs
+      end
+      private_class_method :resolve_create_class,
+                           :resolve_create_typed_stage,
+                           :coerce_create_attrs
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    module Identifiers
+      class Amendment < SupplementIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :published,
+            abbr: ["AMD"],
+            short_abbr: "AMD",
+            long_abbr: "AMD",
+            type_code: :amd,
+            stage_code: :published,
+            name: "Amendment",
+          ),
+        ].freeze
+
+        def self.type
+          { key: :amd, title: "Amendment", short: "AMD" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    module Identifiers
+      class Corrigendum < SupplementIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :published,
+            abbr: ["COR"],
+            short_abbr: "COR",
+            long_abbr: "COR",
+            type_code: :cor,
+            stage_code: :published,
+            name: "Corrigendum",
+          ),
+        ].freeze
+
+        def self.type
+          { key: :cor, title: "Corrigendum", short: "COR" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    module Identifiers
+      # International Standard Identifier
+      class InternationalStandard < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pwiis,
+            stage_code: :pwi,
+            type_code: :is,
+            abbr: ["PWI"],
+            name: "Proposed Work Item for International Standard",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          Components::TypedStage.new(
+            code: :isnp,
+            stage_code: :np,
+            type_code: :is,
+            abbr: ["NP", "NWIP"],
+            name: "New Work Item Proposal for International Standard",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          Components::TypedStage.new(
+            code: :awiis,
+            stage_code: :awi,
+            type_code: :is,
+            abbr: ["AWI"],
+            name: "Approved Work Item for International Standard",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          Components::TypedStage.new(
+            code: :wdis,
+            stage_code: :wd,
+            type_code: :is,
+            abbr: ["WD"],
+            name: "Working Draft for International Standard",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          Components::TypedStage.new(
+            code: :cdis,
+            stage_code: :cd,
+            type_code: :is,
+            abbr: ["CD"],
+            name: "Committee Draft for International Standard",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          Components::TypedStage.new(
+            code: :fcdis,
+            stage_code: :fcd,
+            type_code: :is,
+            abbr: ["FCD"],
+            name: "Final Committee Draft for International Standard",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          Components::TypedStage.new(
+            code: :dis,
+            stage_code: :dis,
+            type_code: :is,
+            abbr: ["DIS", "FPD"],
+            name: "Draft International Standard",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          Components::TypedStage.new(
+            code: :fdis,
+            stage_code: :fdis,
+            type_code: :is,
+            abbr: ["FDIS"],
+            name: "Final Draft International Standard",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          Components::TypedStage.new(
+            code: :prfis,
+            stage_code: :prf,
+            type_code: :is,
+            abbr: ["PRF", "Fpr"],
+            name: "Proof International Standard",
+            harmonized_stages: %w[60.00],
+          ),
+          Components::TypedStage.new(
+            code: :is,
+            stage_code: :published,
+            type_code: :is,
+            abbr: [""],
+            name: "International Standard",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+          Components::TypedStage.new(
+            code: :wdr,
+            stage_code: :wdr,
+            type_code: :is,
+            abbr: ["WDR"],
+            name: "Proposed for Withdrawal",
+            harmonized_stages: %w[90.92],
+          ),
+          Components::TypedStage.new(
+            code: :wda,
+            stage_code: :wda,
+            type_code: :is,
+            abbr: ["WDA"],
+            name: "Withdrawal Approved",
+            harmonized_stages: %w[90.93],
+          ),
+          Components::TypedStage.new(
+            code: :wdar,
+            stage_code: :wdar,
+            type_code: :is,
+            abbr: ["WDAR"],
+            name: "Withdrawal Archived",
+            harmonized_stages: %w[95.99],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :is, title: "International Standard", short: nil }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    module Identifiers
+      class ReviewedMethod < SingleIdentifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            code: :pwirm,
+            stage_code: :pwi,
+            type_code: :rm,
+            abbr: ["PWI RM"],
+            name: "Proposed Work Item for Reviewed Method",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          Components::TypedStage.new(
+            code: :nprm,
+            stage_code: :np,
+            type_code: :rm,
+            abbr: ["NP RM"],
+            name: "New Work Item Proposal for Reviewed Method",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+
+          Components::TypedStage.new(
+            code: :awirm,
+            stage_code: :awi,
+            type_code: :rm,
+            abbr: ["AWI RM"],
+            name: "Approved Work Item for Reviewed Method",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+
+          Components::TypedStage.new(
+            code: :wdrm,
+            stage_code: :wd,
+            type_code: :rm,
+            abbr: ["WD RM"],
+            name: "Working Draft Reviewed Method",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+
+          Components::TypedStage.new(
+            code: :cdrm,
+            stage_code: :cd,
+            type_code: :rm,
+            abbr: ["CD RM"],
+            name: "Committee Draft Reviewed Method",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          Components::TypedStage.new(
+            code: :pdrm,
+            stage_code: :cd,
+            type_code: :rm,
+            abbr: ["PDRM"],
+            name: "Proposed Draft Reviewed Method",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+
+          Components::TypedStage.new(
+            code: :drm,
+            type_code: :rm,
+            abbr: ["DRM"],
+            name: "Draft Reviewed Method",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          Components::TypedStage.new(
+            code: :fdrm,
+            type_code: :rm,
+            abbr: ["FDRM"],
+            name: "Final Draft Reviewed Method",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+
+          Components::TypedStage.new(
+            code: :prfrm,
+            stage_code: :prf,
+            type_code: :rm,
+            abbr: ["PRF RM"],
+            name: "Proof Reviewed Method",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          Components::TypedStage.new(
+            code: :pubrm,
+            stage_code: :published,
+            type_code: :rm,
+            abbr: ["RM"],
+            name: "Published Reviewed Method",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :rm, title: "Reviewed Method", short: "RM" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/idf/identifiers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    module Identifiers
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :InternationalStandard,
+               "#{__dir__}/identifiers/international_standard"
+      autoload :ReviewedMethod, "#{__dir__}/identifiers/reviewed_method"
+    end
+  end
+end