pubid 1.15.19 → 2.0.0.pre.alpha.1

data/lib/pubid/renderers/guide_renderer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class GuideRenderer < HumanReadable
+      private
+
+      def render_publisher_and_stage(context)
+        pub_str = @id.publisher.render(context:) if @id.publisher
+        stage_str = @id.typed_stage.render(context:) if @id.typed_stage
+
+        if stage_str && !stage_str.empty?
+          "#{pub_str} #{stage_str}"
+        else
+          pub_str
+        end
+      end
+    end
+  end
+end

data/lib/pubid/renderers/human_readable.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class HumanReadable < Base
+      def render(context:, with_edition: false)
+        parts = []
+        parts << render_publisher_and_stage(context)
+        parts << render_number_portion(context)
+        parts << render_edition_portion(context) if with_edition
+        result = parts.compact.join(" ")
+        result << render_language_portion(context, with_edition: with_edition)
+        result << " (all parts)" if @id.all_parts
+        result
+      end
+
+      private
+
+      def render_publisher_and_stage(context)
+        pub_str = @id.publisher.render(context:) if @id.publisher
+        stage_str = @id.typed_stage.render(context:) if @id.typed_stage
+
+        if stage_str && !stage_str.empty?
+          has_copub = @id.publisher&.copublished?
+          sep = has_copub ? " " : "/"
+          "#{pub_str}#{sep}#{stage_str}"
+        else
+          pub_str
+        end
+      end
+
+      def render_number_portion(context)
+        parts = []
+        parts << @id.number.render(context:) if @id.number
+        parts << "-#{@id.part.render(context:)}" if @id.part
+        parts << "-#{@id.subpart.render(context:)}" if @id.subpart
+        parts << ".#{@id.stage_iteration.render(context:)}" if @id.stage_iteration
+        date_str = @id.date.render(context:) if @id.date && context.with_date
+        parts << ":#{date_str}" if date_str
+        parts.join
+      end
+
+      def render_edition_portion(context)
+        @id.edition.render(context:) if @id.edition&.number
+      end
+
+      def render_language_portion(context, with_edition: false)
+        return "" unless @id.languages&.any? && context.with_language_code != :none
+
+        use_single = with_edition ? false : context.with_language_code == :single
+        rendered = @id.languages.map do |l|
+          l.render(context:, lang_single: use_single)
+        end
+        "(#{rendered.join(use_single ? '/' : ',')})"
+      end
+    end
+  end
+end

data/lib/pubid/renderers/iwa_renderer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class IwaRenderer < HumanReadable
+      def render(context:, with_edition: false)
+        parts = []
+        parts << @id.typed_stage.render(context:) if @id.typed_stage
+        parts << render_number_portion(context)
+        result = parts.compact.join(" ")
+        result << render_language_portion(context, with_edition: with_edition)
+        result
+      end
+    end
+  end
+end

data/lib/pubid/renderers/mr_string.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class MrString < Base
+      def render(context: nil, **)
+        parts = []
+        parts << @id.mr_publisher
+        parts << @id.mr_type
+        parts << @id.mr_number_with_part
+        parts << @id.mr_year
+        parts.compact.join(".")
+      end
+    end
+  end
+end

data/lib/pubid/renderers/supplement_renderer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class SupplementRenderer < HumanReadable
+      def render(context:, with_edition: false)
+        parts = []
+
+        base_str = @id.base_identifier.to_s(
+          with_edition: with_edition,
+          stage_format_long: context.stage_format_long,
+          with_date: context.with_date,
+        )
+
+        stage_str = @id.typed_stage.render(context:)
+        parts << "#{base_str}/#{stage_str}"
+
+        num_port = render_number_portion(context)
+        if num_port && !num_port.empty? && !num_port.start_with?(":")
+          parts << (stage_str.end_with?(".") ? "" : " ")
+        end
+        parts << num_port
+
+        parts << " #{render_edition_portion(context)}" if with_edition && @id.edition&.number
+        if @id.languages&.any?
+          parts << render_language_portion(context,
+                                           with_edition: with_edition)
+        end
+        parts.compact.join
+      end
+    end
+  end
+end

data/lib/pubid/renderers/urn.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class Urn < Base
+      def render(context: nil, **)
+        @id.to_urn
+      end
+    end
+  end
+end

data/lib/pubid/renderers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    autoload :Base, "pubid/renderers/base"
+    autoload :DirectivesRenderer, "pubid/renderers/directives_renderer"
+    autoload :GuideRenderer, "pubid/renderers/guide_renderer"
+    autoload :HumanReadable, "pubid/renderers/human_readable"
+    autoload :IwaRenderer, "pubid/renderers/iwa_renderer"
+    autoload :MrString, "pubid/renderers/mr_string"
+    autoload :SupplementRenderer, "pubid/renderers/supplement_renderer"
+    autoload :Urn, "pubid/renderers/urn"
+  end
+end

data/lib/pubid/rendering/base.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "publisher"
+require_relative "numbering"
+require_relative "date"
+require_relative "supplement"
+require_relative "stage"
+require_relative "language"
+require_relative "format"
+
+module Pubid
+  module Rendering
+    module Base
+      include Pubid::Rendering::Publisher
+      include Pubid::Rendering::Numbering
+      include Pubid::Rendering::Date
+      include Pubid::Rendering::Supplement
+      include Pubid::Rendering::Stage
+      include Pubid::Rendering::Language
+      include Pubid::Rendering::Format
+
+      # Base rendering method to be composed by subclasses
+      # @param options [Hash] rendering options
+      # @return [String] formatted identifier string
+      def render_base(**options)
+        parts = []
+
+        # Publisher/copublisher
+        pub = maybe(:publisher)
+        if pub
+          parts << render_publisher(pub,
+                                    maybe(:copublishers), **options)
+        end
+
+        # Numbering (number, part, subpart)
+        num = maybe(:number)
+        if num
+          parts << render_numbering(num, maybe(:part),
+                                    maybe(:subpart), **options)
+        end
+
+        # Date
+        d = maybe(:date)
+        if d
+          parts << render_date(d, **options)
+        end
+
+        # Stage and type
+        stg = maybe(:stage)
+        if stg
+          parts << render_stage(stg, maybe(:type),
+                                has_copublisher: maybe(:copublishers)&.any?, **options)
+        end
+
+        # Language codes
+        langs = maybe(:languages)
+        if langs&.any?
+          parts << render_languages(langs, **options)
+        end
+
+        parts.compact.join
+      end
+
+      private
+
+      def maybe(method_name)
+        return nil unless self.class.attributes.key?(method_name)
+
+        public_send(method_name)
+      end
+    end
+  end
+end

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,156 @@
+# 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
+
+      # 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)
+        @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
+      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