pubid 1.15.19 → 2.0.0.pre.alpha.1

data/lib/pubid/rendering/numbering.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    module Numbering
+      # Render number with optional parts and subparts
+      # @param number [Components::Code] primary number
+      # @param part [Components::Code, nil] optional part
+      # @param subpart [Components::Code, nil] optional subpart
+      # @param options [Hash] rendering options
+      # @return [String] formatted numbering string
+      def render_numbering(number, part = nil, subpart = nil, **options)
+        return "" unless number&.value
+
+        result = " #{number.value}"
+        separator = options[:part_separator] || "-"
+        result += "#{separator}#{part.value}" if part&.value
+        result += "#{separator}#{subpart.value}" if subpart&.value
+
+        result
+      end
+    end
+  end
+end

data/lib/pubid/rendering/publisher.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    module Publisher
+      # Render publisher with optional copublishers
+      # @param publisher [Components::Publisher, String] base publisher
+      # @param copublishers [Array<Components::Publisher>, nil] optional copublisher list
+      # @param options [Hash] rendering options
+      # @return [String] formatted publisher string
+      def render_publisher(publisher, copublishers = nil, **options)
+        return "" unless publisher
+
+        result = publisher.to_s
+
+        if copublishers&.any?
+          separator = options[:copublisher_separator] || "/"
+          result += copublishers.map { |cp| "#{separator}#{cp}" }.join
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/pubid/rendering/stage.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    module Stage
+      # Render stage and type abbreviations
+      # @param stage [Components::Stage] stage component
+      # @param type [Components::Type] type component
+      # @param has_copublisher [Boolean] whether copublisher exists
+      # @param options [Hash] rendering options
+      # @return [String] formatted stage/type string
+      def render_stage(stage, type = nil, has_copublisher: false, **_options)
+        result = ""
+
+        if stage&.abbr
+          separator = has_copublisher ? " " : "/"
+          result += "#{separator}#{stage.abbr}"
+        end
+
+        if type&.abbr && type.abbr != default_type_abbr
+          result += type_separator(has_copublisher, result) + type.abbr
+        end
+
+        result
+      end
+
+      private
+
+      def default_type_abbr
+        "IS" # Override in flavors
+      end
+
+      def type_separator(has_copublisher, has_stage)
+        has_copublisher || has_stage.empty? ? " " : "/"
+      end
+    end
+  end
+end

data/lib/pubid/rendering/supplement.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    module Supplement
+      # Render supplement identifiers (amendment, corrigendum, addendum, etc.)
+      # @param base_identifier [Identifier] base identifier
+      # @param supplements [Array<Hash>] list of supplements
+      # @param options [Hash] rendering options
+      # @return [String] formatted supplement string
+      def render_supplements(base_identifier, supplements, **options)
+        return base_identifier.to_s(**options) unless supplements&.any?
+
+        result = base_identifier.to_s(**options)
+
+        supplements.each do |supp|
+          result += render_single_supplement(supp, **options)
+        end
+
+        result
+      end
+
+      private
+
+      def render_single_supplement(supp, **options)
+        typed_stage = supp[:typed_stage]
+        number = supp[:number]
+        date = supp[:date]
+
+        sep = determine_separator(supp, options)
+        abbr = typed_stage.abbreviation(format_long: options[:stage_format_long])
+
+        result = "#{sep}#{abbr}"
+        result += " #{number}" if number
+        result += ":#{date.year}" if date&.year
+
+        result
+      end
+
+      def determine_separator(supp, options)
+        supp_type = supp[:type]&.to_s
+        options[:"#{supp_type}_separator"] || options[:supplement_separator] || "/"
+      end
+    end
+  end
+end

data/lib/pubid/rendering.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    autoload :Base, "pubid/rendering/base"
+    autoload :Common, "pubid/rendering/common"
+    autoload :Date, "pubid/rendering/date"
+    autoload :Format, "pubid/rendering/format"
+    autoload :Language, "pubid/rendering/language"
+    autoload :Numbering, "pubid/rendering/numbering"
+    autoload :Publisher, "pubid/rendering/publisher"
+    autoload :Stage, "pubid/rendering/stage"
+    autoload :Supplement, "pubid/rendering/supplement"
+    autoload :RenderingContext, "pubid/rendering/context"
+  end
+end

data/lib/pubid/sae/builder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    class Builder < Pubid::Builder::Base
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      private
+
+      def default_identifier_class
+        Identifiers::Base
+      end
+
+      def cast(type, value)
+        case type
+        when :publisher
+          "SAE"
+        when :type
+          Components::Type.new(abbr: value.to_s)
+        when :number
+          Components::Code.new(value: value.to_s)
+        when :year
+          { date: Components::Date.new(year: value.to_i) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    module Components
+      Code = Pubid::Components::Code
+    end
+  end
+end

data/lib/pubid/sae/components/date.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Sae
+    module Components
+      # Date component for SAE standards
+      # SAE uses year only (e.g., 2024, 2022)
+      class Date < Lutaml::Model::Serializable
+        attribute :year, :integer
+
+        def to_s
+          year.to_s
+        end
+      end
+    end
+  end
+end

data/lib/pubid/sae/components/type.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Sae
+    module Components
+      # Type component for SAE document types
+      # AMS, AIR,, ARP, AS, MA
+      class Type < Lutaml::Model::Serializable
+        attribute :abbr, :string
+
+        def to_s
+          abbr.to_s
+        end
+      end
+    end
+  end
+end

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,14 @@
+# 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
+    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,207 @@
+# 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 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