pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/rendering/common.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    # Common rendering methods for identifier string representation
+    #
+    # This module extracts duplicated rendering logic across flavors
+    # to reduce code duplication and ensure consistency.
+    #
+    # == Usage
+    #
+    # Include this module in flavor-specific identifier base classes:
+    #
+    #   class Base < ::Pubid::Identifier
+    #     include Pubid::Rendering::Common
+    #
+    #     def to_s(lang: :en, lang_single: false, with_edition: false)
+    #       render_identifier(lang: lang, lang_single: lang_single, with_edition: with_edition)
+    #     end
+    #   end
+    #
+    module Common
+      # Render publisher with optional copublishers
+      #
+      # @param publisher [Components::Publisher] publisher component
+      # @param copublisher_separator [String] separator for copublishers (default: "/")
+      # @return [String] formatted publisher string
+      def render_publisher(publisher, copublisher_separator: "/")
+        return "" unless publisher
+
+        result = publisher.to_s
+        cops = publisher.is_a?(Components::Publisher) ? publisher.copublisher : nil
+        if cops&.any?
+          result += cops.map do |cp|
+            "#{copublisher_separator}#{cp}"
+          end.join
+        end
+        result
+      end
+
+      # Render stage and type abbreviations with proper separators
+      #
+      # @param stage [Components::Stage] stage component
+      # @param type [Components::Type] type component
+      # @param has_copublisher [Boolean] whether identifier has copublisher
+      # @param default_type_abbr [String] default type abbreviation to skip (default: "IS")
+      # @param stage_separator [String] separator before stage without copublisher
+      # @return [String] formatted stage/type string
+      def render_stage_type(stage, type, has_copublisher: false,
+                           default_type_abbr: "IS",
+                           stage_separator: "/")
+        result = ""
+
+        # Add stage abbreviation if present
+        if stage&.abbr
+          sep = has_copublisher ? " " : stage_separator
+          result += "#{sep}#{stage.abbr}"
+        end
+
+        # Add type abbreviation if present and not default
+        if type&.abbr && type.abbr != default_type_abbr
+          # Separator: space after stage or copublisher, slash otherwise
+          has_prefix = stage&.abbr || has_copublisher
+          sep = has_prefix ? " " : stage_separator
+          result += "#{sep}#{type.abbr}"
+        end
+
+        result
+      end
+
+      # Render number with optional parts
+      #
+      # @param number [Components::Code] primary number component
+      # @param part [Components::Code] optional part component
+      # @param subpart [Components::Code] optional subpart component
+      # @param part_separator [String] separator for parts (default: "-")
+      # @return [String] formatted numbering string
+      def render_numbering(number, part = nil, subpart = nil,
+part_separator: "-")
+        return "" unless number&.value
+
+        result = " #{number.value}"
+        result += "#{part_separator}#{part.value}" if part&.value
+        result += "#{part_separator}#{subpart.value}" if subpart&.value
+        result
+      end
+
+      # Render stage iteration (e.g., ".1" for stage iteration)
+      #
+      # @param stage_iteration [Components::Code] stage iteration component
+      # @return [String] formatted stage iteration or empty string
+      def render_stage_iteration(stage_iteration)
+        stage_iteration&.value ? ".#{stage_iteration.value}" : ""
+      end
+
+      # Render date with optional year/month/day
+      #
+      # @param date [Components::Date] date component
+      # @param include_month [Boolean] include month in output
+      # @param date_separator [String] separator for date parts (default: "-")
+      # @return [String] formatted date string or empty string
+      def render_date(date, include_month: false, date_separator: "-")
+        return "" unless date&.year
+
+        result = ":#{date.year}"
+        if date.month && include_month
+          result += "#{date_separator}#{format('%02d', date.month)}"
+          result += "#{date_separator}#{format('%02d', date.day)}" if date.day
+        end
+        result
+      end
+
+      # Render language codes
+      #
+      # @param languages [Array<Components::Language>] language components
+      # @param lang_single [Boolean] use single character format
+      # @param lang_separator [String] separator between languages (default: "/")
+      # @return [String] formatted language string or empty string
+      def render_languages(languages, lang_single: false, lang_separator: "/")
+        return "" unless languages&.any?
+
+        formatted = languages.map do |l|
+          l.to_s(lang_single: lang_single)
+        end.join(lang_separator)
+        "(#{formatted})"
+      end
+
+      # Render edition component
+      #
+      # @param edition [Components::Edition] edition component
+      # @param with_prefix [Boolean] include prefix (default: true)
+      # @return [String] formatted edition string or empty string
+      def render_edition(edition, with_prefix: true)
+        return "" unless edition
+
+        if with_prefix
+          edition.to_s
+        else
+          " #{edition}"
+        end
+      end
+
+      # Check if publisher has copublishers
+      #
+      # @param publisher [Components::Publisher] publisher component
+      # @return [Boolean] true if has copublishers
+      def publisher_has_copublisher?(publisher)
+        publisher.is_a?(Components::Publisher) && publisher.has_copublisher?
+      end
+
+      # Get publisher body/name
+      #
+      # @param publisher [Components::Publisher] publisher component
+      # @return [String] publisher body
+      def publisher_body(publisher)
+        publisher.is_a?(Components::Publisher) ? publisher.body : publisher.to_s
+      end
+
+      # Get copublishers as array
+      #
+      # @param publisher [Components::Publisher] publisher component
+      # @return [Array<String>] array of copublisher names
+      def copublishers_list(publisher)
+        return [] unless publisher.is_a?(Components::Publisher) && publisher.copublisher&.any?
+
+        publisher.copublisher.map { |cp| publisher_body(cp) }
+      end
+
+      # Render full identifier with all components
+      #
+      # This is a convenience method that combines all rendering methods
+      # in the standard order for most identifier types.
+      #
+      # @param publisher [Components::Publisher] publisher component
+      # @param stage [Components::Stage] stage component
+      # @param type [Components::Type] type component
+      # @param number [Components::Code] number component
+      # @param part [Components::Code] part component
+      # @param subpart [Components::Code] subpart component
+      # @param stage_iteration [Components::Code] stage iteration component
+      # @param date [Components::Date] date component
+      # @param edition [Components::Edition] edition component
+      # @param languages [Array<Components::Language>] language components
+      # @param lang [Symbol] language for rendering (:en or :fr)
+      # @param lang_single [Boolean] use single char language format
+      # @param with_edition [Boolean] include edition in output
+      # @param default_type_abbr [String] default type abbreviation to skip
+      # @return [String] formatted identifier string
+      def render_full_identifier(publisher:, stage: nil, type: nil,
+                                 number: nil, part: nil, subpart: nil,
+                                 stage_iteration: nil, date: nil,
+                                 edition: nil, languages: nil,
+                                 lang: :en, lang_single: false,
+                                 with_edition: false,
+                                 default_type_abbr: "IS")
+        result = render_publisher(publisher)
+        result += render_stage_type(stage, type,
+                                    has_copublisher: publisher_has_copublisher?(
+                                      publisher,
+                                    ),
+                                    default_type_abbr: default_type_abbr)
+        result += render_numbering(number, part, subpart)
+        result += render_stage_iteration(stage_iteration) if stage_iteration
+        result += render_date(date)
+        result += render_edition(edition) if with_edition && edition
+        result += render_languages(languages, lang_single: lang_single)
+        result
+      end
+    end
+  end
+end

data/lib/pubid/rendering/context.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    # Context object for flavor-specific rendering rules
+    #
+    # This encapsulates the rendering rules that vary between flavors,
+    # allowing components to render themselves correctly based on context.
+    #
+    # == Usage
+    #
+    #   context = RenderingContext.new(
+    #     stage_separator: "/",
+    #     stage_separator_with_copublisher: " ",
+    #     type_separator: "/",
+    #     type_separator_with_prefix: " ",
+    #     default_type_abbr: "IS"
+    #   )
+    #   identifier.to_s(context: context)
+    #
+    class RenderingContext
+      attr_reader :stage_separator, :stage_separator_with_copublisher,
+                  :type_separator, :type_separator_with_prefix,
+                  :default_type_abbr, :lang, :lang_single,
+                  :with_language_code, :stage_format_long, :with_date,
+                  :annotated
+
+      # Initialize a new rendering context
+      #
+      # @param stage_separator [String] separator before stage without copublisher
+      # @param stage_separator_with_copublisher [String] separator before stage with copublisher
+      # @param type_separator [String] separator before type (default)
+      # @param type_separator_with_prefix [String] separator before type when prefix exists
+      # @param default_type_abbr [String] default type abbreviation to skip rendering
+      # @param lang [Symbol] language for rendering (:en or :fr)
+      # @param lang_single [Boolean] use single char language format
+      def initialize(stage_separator: "/",
+                     stage_separator_with_copublisher: " ",
+                     type_separator: "/",
+                     type_separator_with_prefix: " ",
+                     default_type_abbr: "IS",
+                     lang: :en,
+                     lang_single: false,
+                     with_language_code: :none,
+                     stage_format_long: false,
+                     with_date: true,
+                     annotated: false)
+        @stage_separator = stage_separator
+        @stage_separator_with_copublisher = stage_separator_with_copublisher
+        @type_separator = type_separator
+        @type_separator_with_prefix = type_separator_with_prefix
+        @default_type_abbr = default_type_abbr
+        @lang = lang
+        @lang_single = lang_single
+        @with_language_code = with_language_code
+        @stage_format_long = stage_format_long
+        @with_date = with_date
+        @annotated = annotated
+      end
+
+      # Get the appropriate stage separator based on whether there's a copublisher
+      #
+      # @param has_copublisher [Boolean] whether identifier has copublisher
+      # @return [String] the separator to use
+      def stage_separator_for(has_copublisher:)
+        has_copublisher ? @stage_separator_with_copublisher : @stage_separator
+      end
+
+      # Get the appropriate type separator based on whether there's a prefix
+      #
+      # @param has_prefix [Boolean] whether there's a prefix (stage or copublisher)
+      # @return [String] the separator to use
+      def type_separator_for(has_prefix:)
+        has_prefix ? @type_separator_with_prefix : @type_separator
+      end
+
+      # Check if type should be rendered (not default)
+      #
+      # @param type_abbr [String] type abbreviation to check
+      # @return [Boolean] true if type should be rendered
+      def should_render_type?(type_abbr)
+        type_abbr && type_abbr != @default_type_abbr
+      end
+
+      # ISO rendering context singleton
+      # @return [RenderingContext] ISO-specific context
+      def self.iso
+        @iso ||= new(
+          stage_separator: "/",
+          stage_separator_with_copublisher: " ",
+          type_separator: "/",
+          type_separator_with_prefix: " ",
+          default_type_abbr: "IS",
+        )
+      end
+
+      # IEC rendering context singleton
+      # @return [RenderingContext] IEC-specific context
+      def self.iec
+        @iec ||= new(
+          stage_separator: "/",
+          stage_separator_with_copublisher: " ",
+          type_separator: "/",
+          type_separator_with_prefix: " ",
+          default_type_abbr: "IS",
+        )
+      end
+
+      # NIST rendering context singleton
+      # @return [RenderingContext] NIST-specific context
+      def self.nist
+        @nist ||= new(
+          stage_separator: "",
+          stage_separator_with_copublisher: " ",
+          type_separator: " ",
+          type_separator_with_prefix: " ",
+          default_type_abbr: "",
+        )
+      end
+
+      # Format factory methods — replace RenderingStyle hierarchy
+      def self.ref_num_short
+        new(with_language_code: :single, stage_format_long: false,
+            with_date: true)
+      end
+
+      def self.ref_num_long
+        new(with_language_code: :iso, stage_format_long: true, with_date: true)
+      end
+
+      def self.ref_dated
+        new(with_language_code: :none, stage_format_long: false,
+            with_date: true)
+      end
+
+      def self.ref_undated
+        new(with_language_code: :none, stage_format_long: false,
+            with_date: false)
+      end
+
+      def self.ref_undated_long
+        new(with_language_code: :none, stage_format_long: true,
+            with_date: false)
+      end
+
+      def self.from_format(format)
+        case format
+        when :ref_num_short then ref_num_short
+        when :ref_num_long then ref_num_long
+        when :ref_dated then ref_dated
+        when :ref_dated_long then ref_dated
+        when :ref_undated then ref_undated
+        when :ref_undated_long then ref_undated_long
+        else ref_dated
+        end
+      end
+    end
+  end
+end

data/lib/pubid/rendering/date.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    module Date
+      # Render date with optional month/day
+      # @param date [Components::Date] date component
+      # @param options [Hash] rendering options
+      # @return [String] formatted date string
+      def render_date(date, **options)
+        return "" unless date&.year
+
+        result = ":#{date.year}"
+
+        if date.month && options[:include_month]
+          result += "-#{format('%02d', date.month)}"
+        end
+
+        if date.day && options[:include_day]
+          result += "-#{format('%02d', date.day)}"
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/pubid/rendering/format.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    module Format
+      # Dispatch to appropriate format renderer
+      # @param format [Symbol] target format
+      # @return [String] formatted identifier string
+      def to_s(format = nil)
+        effective_format = determine_format(format)
+        send(:"to_#{effective_format}_style")
+      end
+
+      private
+
+      def determine_format(format)
+        return :short unless format
+        return :mr if format.to_sym == :mr
+        return :full if %i[full long].include?(format.to_sym)
+
+        :short
+      end
+    end
+  end
+end

data/lib/pubid/rendering/language.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    module Language
+      # Render language codes in parenthetical format
+      # @param languages [Array<Components::Language>] language components
+      # @param options [Hash] rendering options
+      # @return [String] formatted language string
+      def render_languages(languages, **options)
+        return "" unless languages&.any?
+
+        options[:lang_format] || :short
+        formatted = languages.map do |l|
+          l.to_s(lang_single: options[:lang_single])
+        end
+        "(#{formatted.join('/')})"
+      end
+    end
+  end
+end

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