pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/renderers/mr_string.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    # Machine-readable string renderer.
+    #
+    # Produces a lossless, dot-separated, all-lowercase, filename-safe slug:
+    #
+    #   iso 9001:2015                       -> iso.9001.2015
+    #   iso/iec 17031-1:2020                -> iso-iec.17031-1.2020
+    #   iso 1234-1-2-3:2020                 -> iso.1234-1-2-3.2020
+    #   iso/tr 14627:2017                   -> iso.tr.14627.2017
+    #   iso 16634:--                        -> iso.16634.--
+    #   iso 9001:2015/amd 1:2020            -> iso.9001.2015_amd.1.2020
+    #   iso/iec 13818-1:2015/amd 3:2016/cor 1:2017
+    #                                       -> iso-iec.13818-1.2015_amd.3.2016_cor.1.2017
+    #
+    # The renderer recurses into a supplement's `base` (one level per
+    # `mr_supplement_suffix`) so chained Cor-Amd-IS structures render fully,
+    # instead of every supplement layer collapsing onto its own
+    # type/number/year and dropping the base (issue #142).
+    #
+    # Character set is restricted to [a-z0-9.-] plus `_` (supplement
+    # separator), so `to_mr_string` doubles as a filesystem-/URL-safe slug.
+    # `Identifier#to_slug` delegates here; NIST is the one flavor that
+    # overrides `to_slug` because its MR shape is fixed by the pubid standard
+    # and stays uppercase.
+    class MrString < Base
+      SEPARATOR_SUPPLEMENT = "_"
+
+      # The flat MR segments, in order, as the hook each one reads. A hook
+      # returning nil contributes no segment, so a flavor fills only the slots
+      # its identity actually uses — `mr_volume` (ECMA) is nil everywhere else.
+      SEGMENTS = %i[
+        mr_publisher
+        mr_type
+        mr_number_with_part
+        mr_year
+        mr_edition
+        mr_volume
+        mr_languages
+        mr_all_parts
+      ].freeze
+
+      def render(context: nil, **)
+        suffix = @id.mr_supplement_suffix
+
+        if suffix
+          base = @id.base
+          head = base ? self.class.new(base).render : ""
+          head.empty? ? suffix : "#{head}#{SEPARATOR_SUPPLEMENT}#{suffix}"
+        else
+          render_flat(@id)
+        end
+      end
+
+      private
+
+      def render_flat(id)
+        SEGMENTS.filter_map { |hook| id.public_send(hook) }.join(".")
+      end
+    end
+  end
+end

data/lib/pubid/renderers/supplement_renderer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    class SupplementRenderer < HumanReadable
+      def render(context:, with_edition: false)
+        parts = []
+
+        base_str = @id.base.to_s(
+          with_edition: with_edition,
+          stage_format_long: context.stage_format_long,
+          with_date: context.with_date,
+          annotated: context.annotated,
+        )
+
+        stage_str = annotate(@id.typed_stage.render(context:),
+                             typed_stage_css(@id.typed_stage),
+                             annotated: context.annotated)
+        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,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    autoload :Annotator, "pubid/renderers/annotator"
+    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/context.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    # Context object for flavor-specific and format-specific rendering rules
+    #
+    # Encapsulates rendering rules that vary between flavors and between
+    # output formats (human-readable, URN, MR string). Components receive
+    # this context and render themselves accordingly — renderers and
+    # URN generators never reach into component internals.
+    class RenderingContext
+      attr_reader :format, :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
+
+      # @param format [Symbol] output format: :human, :urn, or :mr
+      # @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(format: :human,
+                     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)
+        @format = format
+        @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
+
+      def urn?
+        @format == :urn
+      end
+
+      def human?
+        @format == :human
+      end
+
+      def mr?
+        @format == :mr
+      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
+
+      # URN rendering context: components emit URN-format fragments
+      # @return [RenderingContext] URN-specific context
+      def self.urn
+        @urn ||= new(format: :urn)
+      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/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,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    module Numbering
+      # Render number with optional parts and subparts
+      # @param number [Components::Code, String, nil] primary number
+      # @param part [Components::Code, String, nil] optional part
+      # @param subpart [Components::Code, String, nil] optional subpart
+      # @param options [Hash] rendering options
+      # @return [String] formatted numbering string
+      def render_numbering(number, part = nil, subpart = nil, **options)
+        number_str = numbering_value(number)
+        return "" unless number_str
+
+        result = " #{number_str}"
+        separator = options[:part_separator] || "-"
+        [part, subpart].each do |component|
+          value = numbering_value(component)
+          result += "#{separator}#{value}" if value
+        end
+
+        result
+      end
+
+      private
+
+      # `number`/`part`/`subpart` are a Components::Code on ::Pubid::Identifier
+      # but a plain :string in a growing number of flavors, so read the value
+      # through whichever shape the caller holds. Returns nil for an absent or
+      # empty component, which is what suppresses the segment.
+      def numbering_value(component)
+        return nil if component.nil?
+
+        value = component.respond_to?(:value) ? component.value : component
+        return nil if value.nil? || value.to_s.empty?
+
+        value.to_s
+      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] base identifier
+      # @param supplements [Array<Hash>] list of supplements
+      # @param options [Hash] rendering options
+      # @return [String] formatted supplement string
+      def render_supplements(base, supplements, **options)
+        return base.to_s(**options) unless supplements&.any?
+
+        result = base.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,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Rendering
+    autoload :Date, "pubid/rendering/date"
+    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
+        Identifier
+      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,27 @@
+# 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 present?
+          !year.nil?
+        end
+
+        def to_s
+          render
+        end
+
+        def render(context: nil)
+          year.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# 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
+          render
+        end
+
+        def render(context: nil)
+          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,4 @@
+# frozen_string_literal: true
+
+# Pubid::Sae::Identifier is the SAE base class (a real Pubid::Identifier
+# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    # Base SAE Identifier. Canonical name Pubid::Sae::Identifier. SAE has a single identifier class that IS the
+    # document type, so this class is both the base and the only concrete type.
+    # Handles all SAE document types (AMS, AIR, ARP, AS, MA).
+    class Identifier < ::Pubid::Identifier
+      def self.parse(input)
+        unless input.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if input.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(input)
+        Builder.build(parsed)
+      end
+
+      attribute :publisher, :string, default: -> { "SAE" }
+      attribute :type, Sae::Components::Type
+      attribute :number, Sae::Components::Code
+      attribute :date, Sae::Components::Date
+
+      def self.type
+        { key: :base, web: :standard, title: "Standard", short: "SAE" }
+      end
+
+      def year
+        date&.year
+      end
+
+      # SAE encodes the document class (AS, ARP, AMS, AIR, J, …) in `type.abbr`,
+      # not in `typed_stage.type_code`, so the generic mr_type returns nil.
+      # Losslessness requires the type letter to appear in MR — without it,
+      # `SAE J300` and `SAE AS300` would collide on `SAE.300.<year>`.
+      # Lowercased to match the all-lowercase MR convention (issue #142).
+      def mr_type
+        type&.abbr&.to_s&.downcase
+      end
+    end
+
+  end
+end