pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/sae/components.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    module Components
+      autoload :Code, "#{__dir__}/components/code"
+      autoload :Date, "#{__dir__}/components/date"
+      autoload :Type, "#{__dir__}/components/type"
+    end
+  end
+end

data/lib/pubid/sae/identifier.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    class Identifier
+      def self.parse(input)
+        parsed = Parser.parse(input)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse SAE identifier: #{input}\n#{e.message}"
+      end
+
+      # Factory that builds a SAE identifier from a hash of primitives.
+      # SAE has only one identifier class ({Identifiers::Base}); `:type`
+      # is data (the document-type abbreviation: "J", "AS", "ARP", "AMS",
+      # "AIR", "MA") rather than a class-dispatch key.
+      def self.create(**opts)
+        Identifiers::Base.new(**coerce_create_attrs(opts))
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = { publisher: (opts[:publisher] || "SAE").to_s }
+        if (v = opts[:type])
+          attrs[:type] = Pubid::Sae::Components::Type.new(abbr: v.to_s)
+        end
+        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 :coerce_create_attrs
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    module Identifiers
+      # Base SAE Identifier
+      # Handles all SAE document types (AMS, AIR, ARP, AS, MA)
+      class Base < Pubid::Identifier
+        # Generate URN for this identifier
+        #
+        # @return [String] URN representation
+
+        attribute :publisher, :string, default: -> { "SAE" }
+        attribute :type, Sae::Components::Type
+        attribute :number, Sae::Components::Code
+        attribute :date, Sae::Components::Date
+
+        def to_s
+          parts = []
+
+          # Publisher and type
+          parts << publisher if publisher
+          parts << type.to_s if type
+
+          # Number
+          parts << number.to_s if number
+
+          result = parts.join(" ")
+
+          # Date
+          result += ":#{date.year}" if date
+
+          result
+        end
+
+        def year
+          date&.year
+        end
+      end
+    end
+  end
+end

data/lib/pubid/sae/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    module Identifiers
+      autoload :Base, "#{__dir__}/identifiers/base"
+    end
+  end
+end

data/lib/pubid/sae/parser.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Sae
+    class Parser < Parslet::Parser
+      rule(:space) { str(" ") }
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+      rule(:letter) { match["A-Z"] }
+      rule(:colon) { str(":") }
+
+      # Publisher
+      rule(:publisher) { str("SAE").as(:publisher) }
+
+      # Document types with optional number suffix (e.g., J300, J308A)
+      rule(:doc_type) do
+        (
+          str("AMS") |  # Aerospace Material Specification
+          str("AIR") |  # Aerospace Information Report
+          str("ARP") |  # Aerospace Recommended Practice
+          str("AS") |   # Aerospace Standard
+          str("J") |    # SAE Standard (e.g., J300)
+          str("MA")     # Material Advisory
+        ).as(:type)
+      end
+
+      # Number with optional letter prefix or suffix
+      rule(:number) do
+        ((letter.repeat(1,
+                        1) >> digits) | (digits >> letter.repeat(0,
+                                                                 1))).as(:number)
+      end
+
+      # Year
+      rule(:year) { digit.repeat(4, 4).as(:year) }
+
+      # Date
+      rule(:date) { colon >> year }
+
+      # Main identifier
+      rule(:identifier) do
+        publisher >> space >> doc_type >> space.maybe >>
+          number >> date.maybe
+      end
+
+      root(:identifier)
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/sae/scheme.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Base,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "SAE" if abbr.nil? || abbr.to_s.empty?
+
+          typed_stage = 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.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/sae/urn_generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_type
+        return "std" unless identifier.type
+
+        identifier.type.abbr.to_s.downcase
+      end
+
+      def urn_year
+        if identifier.date&.year
+          return identifier.date.year.to_s
+        end
+
+        identifier.year&.to_s
+      end
+
+      def urn_number
+        return nil unless identifier.number
+
+        identifier.number.value.to_s
+      end
+
+      def generate
+        parts = ["urn", "sae"]
+        parts << urn_type
+        parts << urn_number if urn_number
+        parts << urn_year if urn_year
+
+        parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/sae.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    autoload :Builder, "#{__dir__}/sae/builder"
+    autoload :Components, "#{__dir__}/sae/components"
+    autoload :Identifier, "#{__dir__}/sae/identifier"
+    autoload :Identifiers, "#{__dir__}/sae/identifiers"
+    autoload :Parser, "#{__dir__}/sae/parser"
+    autoload :Scheme, "#{__dir__}/sae/scheme"
+    autoload :UrnGenerator, "#{__dir__}/sae/urn_generator"
+
+    def self.parse(input)
+      Identifier.parse(input)
+    end
+  end
+end
+
+Pubid::Registry.register(:sae, Pubid::Sae)

data/lib/pubid/scheme.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Base Scheme class defining the standard interface for all flavor schemes.
+  #
+  # The Scheme acts as a registry for identifier types and their associated
+  # typed stages. Each flavor (ISO, IEC, IEEE, etc.) should have a Scheme that
+  # implements this interface.
+  #
+  # == Standard Interface
+  #
+  # All Scheme implementations must provide these methods:
+  #
+  # - locate_typed_stage_by_abbr(abbr) -> Find a TypedStage by abbreviation
+  # - locate_identifier_klass_by_type_code(type_code) -> Find an identifier class
+  # - typed_stages -> Get all typed stages for base identifiers
+  # - supplement_typed_stages -> Get typed stages for supplements
+  # - all_typed_stages -> Get all typed stages combined
+  # - identifiers -> Get all base identifier classes
+  # - supplement_identifiers -> Get all supplement identifier classes
+  # - all_identifier_classes -> Get all identifier classes combined
+  #
+  # == Implementation Patterns
+  #
+  # There are several valid patterns for implementing a Scheme:
+  #
+  # 1. Class-based (ISO, IEEE, JCGM, JIS, CCSDS, ASHRAE):
+  #    Use class << self with class methods
+  #
+  # 2. Instance-based with constants (BSI, CEN):
+  #    Use TYPED_STAGES_REGISTRY and instance methods
+  #
+  # 3. Transform-based (ITU):
+  #    Use model_class and transform methods (no typed stages)
+  #
+  # 4. Data class (ETSI, Plateau):
+  #    Use Lutaml::Model::Serializable as a data model
+  #
+  # 5. Inheritance-based (AMCA):
+  #    Inherit from Pubid::Scheme base class
+  #
+  # == Performance
+  #
+  # All registry lookups are memoized for performance. Callers can rely on
+  # repeated calls being O(1) after the first call.
+  #
+  class Scheme
+    # Registry of identifiers for this scheme
+    attr_accessor :identifiers,
+                  :stages,
+                  :types,
+                  :languages,
+                  :publishers,
+                  :supplement_identifiers
+
+    def initialize(
+      identifiers: [], stages: [], types: [], languages: [], publishers: [],
+      supplement_identifiers: []
+    )
+      @identifiers = identifiers
+      @supplement_identifiers = supplement_identifiers
+      @stages = stages
+      @types = types
+      @languages = languages
+      @publishers = publishers
+    end
+
+    def configure
+      yield self if block_given?
+    end
+
+    # Get all typed stages for base identifiers
+    # @return [Array<TypedStage>] All typed stages from identifiers
+    # @note Memoized for performance
+    def typed_stages
+      return @typed_stages if defined?(@typed_stages)
+
+      @typed_stages = @identifiers.filter_map do |identifier_class|
+        identifier_class.const_defined?(:TYPED_STAGES) ? identifier_class.const_get(:TYPED_STAGES) : nil
+      end.flatten
+    end
+
+    # Get all typed stages for supplement identifiers
+    # @return [Array<TypedStage>] All typed stages from supplement identifiers
+    # @note Memoized for performance
+    def supplement_typed_stages
+      return @supplement_typed_stages if defined?(@supplement_typed_stages)
+
+      @supplement_typed_stages = @supplement_identifiers.filter_map do |identifier_class|
+        identifier_class.const_defined?(:TYPED_STAGES) ? identifier_class.const_get(:TYPED_STAGES) : nil
+      end.flatten
+    end
+
+    # Get all typed stages (base + supplements), sorted by abbreviation
+    # @return [Array<TypedStage>] All typed stages sorted by abbreviation
+    # @note Memoized for performance
+    def all_typed_stages
+      return @all_typed_stages if defined?(@all_typed_stages)
+
+      @all_typed_stages = (typed_stages + supplement_typed_stages).sort_by do |ts|
+        (ts.abbr.first || "").to_s
+      end.reverse
+    end
+
+    # Locate a TypedStage by abbreviation
+    # @param abbr [String, Symbol] The abbreviation to find
+    # @return [TypedStage, nil] The matching TypedStage, or nil if not found
+    # @note Uses hash-based index for O(1) lookup, falls back to linear search
+    def locate_typed_stage_by_abbr(abbr)
+      abbr = "" if abbr.nil? || abbr.to_s.strip.empty?
+
+      # Try hash-based index first (O(1))
+      typed_stage = typed_stage_index[abbr]
+
+      # Fall back to linear search if not found (for abbreviations with
+      # special formatting or edge cases)
+      typed_stage || all_typed_stages.detect do |ts|
+        ts.abbr.include?(abbr)
+      end
+    end
+
+    # Locate a TypedStage by stage code
+    # @param stage_code [String, Symbol] The stage code to find
+    # @return [TypedStage, nil] The matching TypedStage, or nil if not found
+    # @note Uses linear search for stage code lookup
+    def locate_typed_stage_by_stage_code(stage_code)
+      stage_code_sym = stage_code.to_sym
+
+      all_typed_stages.detect do |ts|
+        ts.stage_code.to_sym == stage_code_sym
+      end
+    end
+
+    # Locate a TypedStage by its unique per-typed-stage code
+    # @param code [String, Symbol] The code to find (e.g. :dtr, :fdisp)
+    # @return [TypedStage, nil] The matching TypedStage, or nil if not found
+    # @note Uses linear search for code lookup
+    def locate_typed_stage_by_code(code)
+      code_sym = code.to_sym
+
+      all_typed_stages.detect do |ts|
+        ts.code&.to_sym == code_sym
+      end
+    end
+
+    # Locate a TypedStage by harmonized stage code
+    # @param harmonized_code [String] The harmonized stage code to find (e.g., "00.00", "10.00")
+    # @return [TypedStage, nil] The matching TypedStage, or nil if not found
+    # @note Uses linear search to check harmonized_stages arrays
+    def locate_typed_stage_by_harmonized_code(harmonized_code)
+      harmonized_str = harmonized_code.to_s
+
+      all_typed_stages.detect do |ts|
+        ts.harmonized_stages&.include?(harmonized_str)
+      end
+    end
+
+    # Hash-based index of typed stages by abbreviation
+    # @return [Hash<String, TypedStage>] index mapping abbreviations to typed stages
+    # @note Memoized for O(1) lookup performance
+    def typed_stage_index
+      @typed_stage_index ||= build_typed_stage_index
+    end
+
+    # Get all identifier classes sorted by type key
+    # @return [Array<Class>] All identifier classes sorted by type key
+    # @note Memoized for performance
+    def all_identifier_classes
+      return @all_identifier_classes if defined?(@all_identifier_classes)
+
+      @all_identifier_classes = (@identifiers + @supplement_identifiers).sort_by do |klass|
+        (klass.type&.dig(:key) || "").to_s
+      end
+    end
+    alias all_identifier_classes_by_type_code all_identifier_classes
+
+    # Locate an identifier class by type code
+    # @param type_code [String, Symbol] The type code to find
+    # @return [Class, nil] The matching identifier class, or nil if not found
+    # @note Uses hash-based index for O(1) lookup, falls back to linear search
+    def locate_identifier_klass_by_type_code(type_code)
+      type_str = type_code.to_s
+
+      # Try hash-based index first (O(1))
+      identifier_klass = identifier_class_index[type_str]
+
+      # Fall back to linear search if not found
+      identifier_klass || all_identifier_classes.detect do |identifier_class|
+        identifier_class.type&.dig(:key)&.to_s == type_str
+      end
+    end
+
+    # Hash-based index of identifier classes by type code
+    # @return [Hash<String, Class>] index mapping type codes to identifier classes
+    # @note Memoized for O(1) lookup performance
+    def identifier_class_index
+      @identifier_class_index ||= build_identifier_class_index
+    end
+
+    protected
+
+    # Build hash-based index of typed stages by abbreviation
+    # @return [Hash<String, TypedStage>] index mapping abbreviations to typed stages
+    def build_typed_stage_index
+      all_typed_stages.each_with_object({}) do |ts, index|
+        ts.abbr.each { |abbr| index[abbr] = ts }
+      end
+    end
+
+    # Build hash-based index of identifier classes by type code
+    # @return [Hash<String, Class>] index mapping type codes to identifier classes
+    def build_identifier_class_index
+      all_identifier_classes.each_with_object({}) do |klass, index|
+        type_key = klass.type&.dig(:key)&.to_s
+        index[type_key] = klass if type_key
+      end
+    end
+  end
+end

data/lib/pubid/urn_generator/base.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Pubid
+  module UrnGenerator
+    # Base class for all flavor-specific URN generators.
+    # Provides template methods for common URN parts.
+    # Flavors subclass and override only what differs.
+    class Base
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        parts = ["urn", urn_namespace]
+        parts << urn_publisher if urn_publisher
+        parts << urn_type if urn_type
+        parts << urn_number if urn_number
+        parts << urn_part if urn_part
+        parts << urn_subpart if urn_subpart
+        parts << urn_year if urn_year
+        parts << urn_edition if urn_edition
+        parts << urn_language if urn_language
+        parts.join(":")
+      end
+
+      # Template methods — override in subclasses
+
+      def urn_namespace
+        flavor_name.downcase
+      end
+
+      def urn_publisher
+        pub = maybe(:publisher)
+        return nil unless pub
+
+        pub.to_s.downcase
+      end
+
+      def urn_type
+        nil
+      end
+
+      def urn_number
+        val = maybe(:number) || maybe(:code)
+        return nil unless val
+
+        val.is_a?(Components::Code) ? val.value.to_s : val.to_s
+      end
+
+      def urn_part
+        val = maybe(:part)
+        return nil unless val
+
+        "-#{val.is_a?(Components::Code) ? val.value : val}"
+      end
+
+      def urn_subpart
+        val = maybe(:subpart)
+        return nil unless val
+
+        "-#{val.is_a?(Components::Code) ? val.value : val}"
+      end
+
+      def urn_year
+        date = maybe(:date)
+        if date
+          year = date.is_a?(Components::Date) ? date.year : date.to_s
+          return year.to_s if year
+        end
+        if maybe(:year)
+          return identifier.year.to_s
+        end
+
+        nil
+      end
+
+      def urn_edition
+        ed = maybe(:edition)
+        return nil unless ed
+
+        num = ed.is_a?(Components::Edition) ? ed.number : ed
+        return nil unless num
+
+        "ed.#{num}"
+      end
+
+      def urn_language
+        langs = maybe(:languages)
+        return nil unless langs&.any?
+
+        langs.map(&:code).join(",")
+      end
+
+      def maybe(method_name)
+        return nil unless identifier.class.attributes.key?(method_name)
+
+        identifier.public_send(method_name)
+      end
+
+      private
+
+      def flavor_name
+        parts = identifier.class.name.split("::")
+        parts[1] || "unknown"
+      end
+    end
+  end
+end