pubid 1.15.19 → 2.0.0.pre.alpha.1

data/lib/pubid/export/result.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Export
+    # Immutable value object representing extracted metadata for one identifier type.
+    # Encapsulates all data needed by the website for a single doc type entry.
+    class IdentifierTypeResult
+      attr_reader :key, :title, :short, :abbr, :typed_stages, :examples
+
+      def initialize(key:, title:, short: nil, abbr: [], typed_stages: [],
+examples: [])
+        @key = key.to_s
+        @title = title
+        @short = short
+        @abbr = Array(abbr).map(&:to_s)
+        @typed_stages = typed_stages.map do |ts|
+          TypedStageResult.from_typed_stage(ts)
+        end
+        @examples = examples
+        freeze
+      end
+
+      def to_h
+        {
+          key: @key,
+          title: @title,
+          short: @short,
+          abbr: @abbr,
+          typed_stages: @typed_stages.map(&:to_h),
+          examples: @examples,
+        }
+      end
+      alias to_hash to_h
+    end
+
+    # Immutable value object for a single typed stage.
+    class TypedStageResult
+      attr_reader :stage_code, :type_code, :abbr, :name, :harmonized_stages
+
+      def initialize(stage_code:, type_code:, abbr:, name:, harmonized_stages:)
+        @stage_code = stage_code.to_s
+        @type_code = type_code.to_s
+        @abbr = Array(abbr).map(&:to_s)
+        @name = name
+        @harmonized_stages = Array(harmonized_stages).map(&:to_s)
+        freeze
+      end
+
+      def self.from_typed_stage(ts)
+        new(
+          stage_code: ts.stage_code,
+          type_code: ts.type_code,
+          abbr: ts.abbr,
+          name: ts.is_a?(Pubid::Components::TypedStage) ? ts.name : nil,
+          harmonized_stages: ts.is_a?(Pubid::Components::TypedStage) ? ts.harmonized_stages : [],
+        )
+      end
+
+      def to_h
+        {
+          stage_code: @stage_code,
+          type_code: @type_code,
+          abbr: @abbr,
+          name: @name,
+          harmonized_stages: @harmonized_stages,
+        }
+      end
+    end
+
+    # Immutable value object for extracted flavor metadata.
+    class FlavorResult
+      attr_reader :flavor, :identifier_types, :wrapper_types, :attributes
+
+      def initialize(flavor:, identifier_types:, wrapper_types: [],
+attributes: [])
+        @flavor = flavor.to_s
+        @identifier_types = identifier_types
+        @wrapper_types = wrapper_types
+        @attributes = attributes
+        freeze
+      end
+
+      def to_h
+        h = {
+          identifier_types: @identifier_types.map(&:to_h),
+          attributes: @attributes,
+        }
+        unless @wrapper_types.empty?
+          h[:wrapper_types] =
+            @wrapper_types.map(&:to_h)
+        end
+        h
+      end
+      alias to_hash to_h
+    end
+  end
+end

data/lib/pubid/export/scheme_exporter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Export
+    # Strategy for flavors using Scheme with class-level identifiers method
+    # and def self.type / TYPED_STAGES patterns.
+    #
+    # Covers: ISO, IEC, ASTM, ASHRAE, ASME, CCSDS, CIE, CSA, JIS, JCGM,
+    #         OIML, IDF, API, SAE, NIST, IEEE
+    class SchemeExporter < FlavorExporter
+      def export
+        klasses = identifier_classes
+        return nil if klasses.empty?
+
+        fixture_data = fixture_examples
+
+        identifier_types = klasses.filter_map do |klass|
+          info = extract_type_info(klass)
+          stages = extract_typed_stages(klass)
+          type_key = info[:key]&.to_s
+
+          # Match fixture examples to this type
+          examples = match_examples(fixture_data, type_key, klass)
+
+          IdentifierTypeResult.new(
+            key: info[:key],
+            title: info[:title],
+            short: info[:short],
+            abbr: info[:abbr],
+            typed_stages: stages,
+            examples: examples,
+          )
+        end
+
+        all_attrs = klasses.first ? extract_attributes(klasses.first) : []
+        wrapper_types = extract_wrapper_types
+
+        FlavorResult.new(
+          flavor: flavor,
+          identifier_types: identifier_types,
+          wrapper_types: wrapper_types,
+          attributes: all_attrs,
+        )
+      end
+
+      private
+
+      def match_examples(fixture_data, type_key, klass)
+        return [] unless type_key
+
+        # Try direct type key match first
+        examples = fixture_data[map_fixture_key_to_type_key(type_key)] ||
+          fixture_data[map_fixture_key_to_type_key(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
+    end
+  end
+end

data/lib/pubid/export.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Export
+    autoload :IdentifierTypeResult, "#{__dir__}/export/result"
+    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
+end

data/lib/pubid/format_detector.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module FormatDetector
+    URN_PATTERN = /\Aurn:/i
+    MR_STRING_PATTERN = /\A[A-Z]{2,}[.-]/
+
+    def self.detect(string)
+      case string
+      when URN_PATTERN then :urn
+      when MR_STRING_PATTERN then :mr_string
+      else :human
+      end
+    end
+  end
+end

data/lib/pubid/format_registry.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  class FormatRegistry
+    attr_reader :formats
+
+    def initialize(parent: nil)
+      @formats = {}
+      @parent = parent
+    end
+
+    def register(format, renderer: nil, parser: nil)
+      @formats[format.to_sym] = { renderer:, parser: }
+    end
+
+    def renderer_for(format)
+      entry = @formats[format.to_sym]
+      return entry[:renderer] if entry && entry[:renderer]
+      return @parent.renderer_for(format) if @parent
+
+      nil
+    end
+
+    def parser_for(format)
+      entry = @formats[format.to_sym]
+      return entry[:parser] if entry && entry[:parser]
+      return @parent.parser_for(format) if @parent
+
+      nil
+    end
+
+    def registered_formats
+      formats = @formats.keys
+      formats |= @parent.registered_formats if @parent
+      formats
+    end
+
+    def has?(format)
+      @formats.key?(format.to_sym) || (@parent&.has?(format) || false)
+    end
+  end
+end

data/lib/pubid/identifier.rb

@@ -0,0 +1,235 @@
+# 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
+      def format_registry
+        @format_registry || superclass&.format_registry
+      end
+
+      attr_writer :format_registry
+    end
+
+    attribute :_type, :string, polymorphic_class: true
+    attribute :number, Components::Code
+    attribute :part, Components::Code
+    attribute :subpart, Components::Code
+    attribute :stage_iteration, Components::Code
+    attribute :date, Components::Date
+    attribute :edition, Components::Edition
+    attribute :languages, Components::Language, collection: true
+    attribute :publisher, Components::Publisher
+    attribute :copublishers, Components::Publisher, collection: true
+    attribute :type, Components::Type
+    attribute :stage, Components::Stage
+    attribute :locality, Components::Locality
+    attribute :typed_stage, Components::TypedStage
+    attribute :all_parts, Lutaml::Model::Type::Boolean, default: false
+    # base_identifier is declared by supplement subclasses with proper type
+    def base_identifier
+      nil
+    end
+
+    def initialize(attrs = {}, options = {})
+      attrs = attrs.dup
+      attrs[:_type] ||= self.class.polymorphic_name
+      super
+    end
+
+    def self.polymorphic_name
+      return nil unless name
+
+      parts = name.split("::")
+      flavor = parts[1]&.downcase
+      type_kebab = parts.last
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1-\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1-\2')
+        .downcase
+      "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
+
+      self
+    end
+
+    # Unified render — delegates to format registry
+    def render(format: :human, **opts)
+      registry = self.class.format_registry
+      unless registry
+        raise ArgumentError, "No format registry configured on #{self.class}"
+      end
+
+      renderer = registry.renderer_for(format)
+      unless renderer
+        raise ArgumentError, "No renderer registered for format: #{format}"
+      end
+
+      context = build_rendering_context(renderer, format:, **opts)
+      renderer.new(self).render(context:, **opts.slice(:with_edition))
+    end
+
+    def to_s(**opts)
+      render(format: :human, **opts)
+    end
+
+    def to_mr_string
+      render(format: :mr_string)
+    end
+
+    # MR string template methods — flavors override as needed
+    def mr_publisher
+      publisher&.to_s
+    end
+
+    def mr_type
+      return nil unless typed_stage
+
+      code = typed_stage.type_code
+      return nil if code.nil? || code.empty? || code == "is"
+
+      code
+    end
+
+    def mr_number_with_part
+      num = mr_number
+      return nil unless num
+
+      prt = mr_part
+      prt ? "#{num}-#{prt}" : num
+    end
+
+    def mr_number
+      number&.to_s
+    end
+
+    def mr_part
+      part&.to_s
+    end
+
+    def mr_year
+      date&.year&.to_s
+    end
+
+    # URN template methods — flavors override as needed
+    def urn_type_code
+      nil
+    end
+
+    def urn_supplement_type
+      nil
+    end
+
+    # Supplement rendering hook — flavors override for supplement-specific rendering
+    def to_supplement_s(**opts)
+      to_s(**opts)
+    end
+
+    # Default URN generation — resolves flavor's UrnGenerator class
+    def to_urn
+      resolve_urn_generator.new(self).generate
+    end
+
+    def resolve_urn_generator
+      flavor = self.class.name.split("::")[1]
+      Object.const_get("Pubid::#{flavor}::UrnGenerator")
+    rescue NameError
+      Pubid::UrnGenerator::Base
+    end
+
+    def exclude(*args)
+      excluded_args = args.dup
+      # Map :year to :date since identifiers store years inside date
+      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)
+      end
+      self.class.new(attrs)
+    end
+
+    def new_edition_of?(other)
+      unless publisher == other.publisher
+        raise ArgumentError,
+              "Cannot compare edition: different publisher"
+      end
+      unless number == other.number
+        raise ArgumentError,
+              "Cannot compare edition: different number"
+      end
+      unless part == other.part
+        raise ArgumentError,
+              "Cannot compare edition: different part"
+      end
+
+      unless date && other.date
+        raise ArgumentError,
+              "Cannot compare identifier without date/year"
+      end
+
+      return date.year > other.date.year if date.year != other.date.year
+
+      if edition && other.edition
+        return edition.number > other.edition.number
+      end
+
+      false
+    end
+
+    def hash
+      @hash ||= compute_hash
+    end
+
+    def eql?(other)
+      return false unless other.is_a?(self.class)
+
+      hash == other.hash && self == other
+    end
+
+    private
+
+    def build_rendering_context(_renderer, format:, with_edition: false,
+                                lang: :en, lang_single: false,
+                                stage_format_long: nil, with_date: nil)
+      if format == :mr_string
+        nil
+      else
+        Rendering::RenderingContext.new(
+          with_language_code: lang_single ? :single : :none,
+          stage_format_long: stage_format_long || false,
+          with_date: with_date.nil? || with_date,
+        )
+      end
+    end
+
+    def compute_hash
+      attrs = [
+        publisher,
+        number,
+        part,
+        subpart,
+        date,
+        type,
+        stage,
+      ]
+      attrs.compact.map(&:hash).hash
+    end
+  end
+end

data/lib/pubid/identifier_metadata.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Machine-readable metadata for identifier classes
+  # Provides a standardized way to describe identifier types for:
+  # - Index search and lookup
+  # - File naming conventions
+  # - Cross-references between flavors
+  # - Automated documentation generation
+  module IdentifierMetadata
+    class Metadata
+      attr_reader :flavor, :identifier_class, :type_key, :title, :short, :abbr,
+                  :base_class, :supplement_class, :stage_codes, :machine_codes
+
+      def initialize(flavor:, identifier_class:, type_key:, title:, short: nil,
+                     abbr: [], base_class: nil, supplement_class: nil,
+                     stage_codes: [], machine_codes: {}, **extra_metadata)
+        @flavor = flavor
+        @identifier_class = identifier_class
+        @type_key = type_key
+        @title = title
+        @short = short
+        @abbr = Array(abbr)
+        @base_class = base_class
+        @supplement_class = supplement_class
+        @stage_codes = Array(stage_codes)
+        @machine_codes = machine_codes
+        @extra_metadata = extra_metadata
+      end
+
+      # Fully qualified class name
+      def qualified_class_name
+        "#{flavor.capitalize}::#{identifier_class}"
+      end
+
+      # Machine-readable slug for file naming
+      def slug
+        "#{flavor}-#{type_key}".downcase.gsub(/[^a-z0-9]+/, "-")
+      end
+
+      # URN-style identifier for this type
+      def urn
+        "urn:pubid:#{flavor}:type:#{type_key}"
+      end
+
+      # Check if this identifier type matches a code
+      def matches_code?(code)
+        return false if code.nil?
+
+        code_str = code.to_s.downcase.strip
+        @abbr.map(&:to_s).map(&:downcase).include?(code_str) ||
+          @type_key.to_s.downcase == code_str
+      end
+
+      # Additional metadata accessors
+      def [](key)
+        @extra_metadata[key]
+      end
+
+      def to_h
+        {
+          flavor: @flavor,
+          identifier_class: @identifier_class,
+          type_key: @type_key,
+          title: @title,
+          short: @short,
+          abbr: @abbr,
+          base_class: @base_class,
+          supplement_class: @supplement_class,
+          stage_codes: @stage_codes,
+          machine_codes: @machine_codes,
+          slug: slug,
+          urn: urn,
+          qualified_class_name: qualified_class_name,
+        }.merge(@extra_metadata)
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
+    module ClassMethods
+      # Define metadata for an identifier class
+      # @param attrs [Hash] Metadata attributes
+      def define_metadata(**attrs)
+        flavor = attrs.fetch(:flavor) do
+          # Extract flavor from class name (e.g., "Pubid::Iso::Identifiers::Foo" -> "iso")
+          name.to_s.split("::")[1..2]&.join("/")&.downcase || "unknown"
+        end
+
+        # Extract class name (e.g., "Pubid::Iso::Identifiers::Foo" -> "Foo")
+        identifier_class = name.to_s.split("::")&.last
+
+        @metadata = Metadata.new(
+          flavor: flavor,
+          identifier_class: identifier_class,
+          **attrs,
+        )
+      end
+
+      # Get the metadata for this class
+      # @return [Metadata, nil]
+      def metadata
+        @metadata ||= if superclass.is_a?(Class) && superclass.respond_to?(:metadata)
+                        superclass.metadata
+                      end
+      end
+
+      # Get the type key from metadata
+      # @return [Symbol, nil]
+      def type_key
+        metadata&.type_key
+      end
+
+      # Get the title from metadata
+      # @return [String, nil]
+      def type_title
+        metadata&.title
+      end
+    end
+
+    module InstanceMethods
+      # Get metadata for this instance's class
+      # @return [Metadata, nil]
+      def metadata
+        self.class.metadata
+      end
+
+      # Get the type key for this identifier
+      # @return [Symbol, nil]
+      def type_key
+        self.class.type_key
+      end
+
+      # Get the machine-readable slug
+      # @return [String, nil]
+      def slug
+        metadata&.slug
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(InstanceMethods)
+    end
+  end
+end