pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/iec/renderer.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    # Human-readable renderer for IEC identifiers.
+    #
+    # Components are accessed only through `component.render(context:)`.
+    #
+    # Produces strings like:
+    #   "IEC 60038:2009"
+    #   "IEC/CD 60038"
+    #   "IEC 60038:2009/AMD1:2011"
+    #   "IEC/FDAM 60038-1"
+    #   "IEC 60529:1989+AMD1:1999 CSV"
+    #
+    # The renderer is registered as the `:human` format in the IEC format
+    # registry and invoked via `render(format: :human)`.
+    #
+    # For simple (non-wrapper) identifiers, the renderer delegates to the
+    # identifier's own `publisher_portion` / `number_portion` helpers so that
+    # per-type overrides (e.g. TR, TS, Guide) continue to work without
+    # duplication.  Wrapper types (Consolidated, VAP, Sheet, Fragment,
+    # Supplement, WorkingDocument, TestReportForm) have rendering logic
+    # here because their structure differs fundamentally.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::ConsolidatedIdentifier
+          render_consolidated(id, opts, context)
+        when Identifiers::VapIdentifier
+          render_vap(id, opts, context)
+        when Identifiers::SheetIdentifier
+          render_sheet(id, opts, context)
+        when Identifiers::FragmentIdentifier
+          render_fragment(id, opts, context)
+        when Identifiers::WorkingDocument
+          render_working_document(id, context)
+        when Identifiers::TechnicalGroup
+          render_technical_group(id, context)
+        when Identifiers::TestReportForm
+          render_test_report_form(id, context)
+        when SupplementIdentifier
+          render_supplement(id, opts, context)
+        else
+          render_single(id, opts, context)
+        end
+      end
+
+      private
+
+      def render_single(id, opts, context)
+        parts = []
+        parts << id.publisher_portion
+        parts << id.number_portion
+
+        if id.is_a?(Identifiers::Base)
+          parts << " #{id.edition.render(context:)}" if id.edition&.number
+        elsif opts[:with_edition] && id.edition&.number
+          parts << " #{id.edition.render(context:)}"
+        end
+
+        # VAP codes live on VapIdentifier (rendered in render_vap), not Base.
+
+        if id.is_a?(Identifiers::Base) && id.database
+          parts << " DB"
+        end
+
+        parts << " (all parts)" if id.all_parts
+
+        result = parts.compact.join
+
+        result << id.language_portion(lang_single: opts[:lang_single]) if id.languages&.any?
+
+        result
+      end
+
+      def render_supplement(id, opts, context)
+        id.ensure_base
+
+        if id.synthetic_base?
+          render_supplement_standalone(id, context)
+        elsif id.base
+          render_supplement_attached(id, opts, context)
+        else
+          render_single(id, opts, context)
+        end
+      end
+
+      def render_supplement_standalone(id, context)
+        # This is a second, independent publisher/stage join that
+        # SingleIdentifier#publisher_portion never reaches. It follows the same
+        # house style: the slash separates copublishers, and a SPACE separates
+        # the publisher from the stage abbreviation. See issue #360 item 2.
+        parts = []
+
+        if id.publisher
+          publishers = [id.publisher.render(context:)]
+          if id.copublishers&.any?
+            publishers += id.copublishers.map { |c| c.render(context:) }
+          end
+          parts << publishers.join("/")
+        end
+
+        abbr = id.typed_stage.abbr.first
+        number_str = id.base.number.to_s
+        number_str += "-#{id.number}" if id.number
+        number_str += "-#{id.subpart}" if id.subpart
+        parts << "#{abbr} #{number_str}"
+
+        result = parts.join(" ")
+        result += ":#{id.date.render(context:)}" if id.date
+        result += " #{id.edition.render(context:)}" if id.edition&.number
+        result
+      end
+
+      def render_supplement_attached(id, opts, context)
+        parts = []
+        parts << id.base.to_s(**opts)
+
+        abbr = id.typed_stage.abbr.first.upcase
+        supp_part = "/#{abbr}#{id.number}"
+        supp_part += ":#{id.date.render(context:)}" if id.date
+        parts << supp_part
+
+        parts << " #{id.edition.render(context:)}" if id.edition&.number
+
+        parts.join
+      end
+
+      def render_consolidated(id, opts, _context)
+        id.identifiers.map.with_index do |sub_id, idx|
+          if idx.zero?
+            sub_id.to_s(**opts)
+          elsif sub_id.is_a?(Identifiers::Amendment)
+            render_consolidated_amendment(sub_id)
+          elsif sub_id.is_a?(Identifiers::Corrigendum)
+            render_consolidated_corrigendum(sub_id)
+          else
+            "+#{sub_id.to_s(**opts)}"
+          end
+        end.join
+      end
+
+      def render_consolidated_amendment(id)
+        if id.date&.present?
+          "+AMD#{id.number}:#{id.date.render}"
+        else
+          "+AMD#{id.number}"
+        end
+      end
+
+      def render_consolidated_corrigendum(id)
+        if id.date&.present?
+          "+COR#{id.number}:#{id.date.render}"
+        else
+          "+COR#{id.number}"
+        end
+      end
+
+      def render_vap(id, opts, context)
+        parts = []
+
+        parts << id.base.to_s(**opts.merge(with_edition: false))
+        parts << " #{id.vap.join('-')}" if id.vap&.any?
+        parts << " #{id.edition.render(context:)}" if id.edition&.number
+
+        parts.compact.join
+      end
+
+      def render_sheet(id, opts, context)
+        parts = []
+        parts << id.base.to_s(**opts)
+        parts << "/#{id.sheet_number}"
+        parts << ":#{id.year}" if id.year
+        parts.join
+      end
+
+      def render_fragment(id, opts, context)
+        parts = []
+        parts << id.base.to_s(**opts)
+
+        parts << if id.base.is_a?(Identifiers::Corrigendum)
+                   "/FRAGC#{id.fragment_number}"
+                 else
+                   "/FRAG#{id.fragment_number}"
+                 end
+
+        parts << " #{id.edition.render(context:)}" if id.edition&.number
+
+        parts.join
+      end
+
+      def render_technical_group(id, _context)
+        parts = []
+        parts << id.publisher_portion
+        parts << " #{id.technical_committee}"
+        parts << id.subcommittee if id.subcommittee
+        parts.join
+      end
+
+      def render_working_document(id, context)
+        if id.wp_stage
+          # A work-programme registration renders bare, as it is written:
+          # "PNW 65-915 ED1", not "IEC/PNW 65-915 ED1". Its number is
+          # TC-scoped, not an IEC document number, and prefixing "IEC " would
+          # break idempotence — "IEC PNW 65-915 ED1" re-parses as an
+          # International Standard, so rendering would not be a fixed point.
+          parts = []
+          parts << id.wp_stage
+          if id.wp_type && !id.wp_type.strip.empty?
+            parts << " #{id.wp_type.strip}"
+          end
+
+          if id.number
+            num_str = id.number.to_s
+            num_str += "-#{id.part}" if id.part && id.part.to_s != ""
+            num_str += "-#{id.subpart}" if id.subpart && id.subpart.to_s != ""
+            parts << " #{num_str}"
+          end
+
+          parts << " #{id.edition.render(context:)}" if id.edition&.number
+          return parts.join
+        end
+
+        parts = []
+        parts << id.technical_committee if id.technical_committee
+
+        if id.wd_number
+          num_part = id.wd_number.to_s
+          num_part += "(#{id.wd_language})" if id.wd_language
+          parts << num_part
+        end
+
+        parts << id.wd_stage if id.wd_stage
+
+        parts.join("/")
+      end
+
+      def render_test_report_form(id, context)
+        parts = []
+        parts << id.publisher_portion
+
+        if id.cispr_identifier
+          cispr_parts = []
+          cispr_parts << id.cispr_identifier.publisher.render(context:)
+
+          num_str = id.cispr_identifier.number.to_s
+          num_str += "-#{id.cispr_identifier.part}" if id.cispr_identifier.part && id.cispr_identifier.part.to_s != ""
+          cispr_parts << num_str
+
+          cispr_str = cispr_parts.join(" ")
+          cispr_str += ":#{id.date.render(context:)}" if id.date
+
+          parts << " #{cispr_str}"
+        else
+          parts << id.number_portion
+        end
+
+        parts << id.trf_info.to_s if id.trf_info && !id.trf_info.empty?
+
+        parts.compact.join
+      end
+    end
+  end
+end

data/lib/pubid/iec/rendering_style.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    # Base class for rendering styles using Strategy pattern
+    # Each identifier stores its own rendering_style which knows how to render it
+    class RenderingStyle
+      attr_reader :with_language_code, :stage_format_long, :with_date
+
+      def initialize(with_language_code:, stage_format_long:, with_date:)
+        @with_language_code = with_language_code
+        @stage_format_long = stage_format_long
+        @with_date = with_date
+      end
+
+      # Render the identifier according to this style
+      def render(identifier, with_edition: false)
+        parts = []
+
+        # Publisher portion
+        parts << identifier.publisher_portion(
+          lang: :en,
+          stage_format_long: stage_format_long,
+        )
+
+        # Number portion
+        parts << identifier.number_portion(
+          lang_single: single_char_language?,
+          with_date: with_date,
+        )
+
+        # Edition portion (if requested)
+        if with_edition && identifier.edition && (identifier.edition.number || identifier.edition.original_text)
+          parts << identifier.edition_portion(lang: :en)
+        end
+
+        result = parts.compact.join(" ")
+
+        # Language portion (if applicable)
+        if identifier.languages&.any? && with_language_code != :none
+          result << identifier.language_portion(lang_single: single_char_language?)
+        end
+
+        result
+      end
+
+      def single_char_language?
+        with_language_code == :single
+      end
+
+      def self.from_format(format)
+        case format
+        when :ref_num_short
+          RefNumShort.new
+        when :ref_num_long
+          RefNumLong.new
+        when :ref_dated
+          RefDated.new
+        when :ref_dated_long
+          RefDatedLong.new
+        when :ref_undated
+          RefUndated.new
+        when :ref_undated_long
+          RefUndatedLong.new
+        else
+          RefDatedLong.new # Default
+        end
+      end
+    end
+
+    # Instance reference number: 1-letter language code + short form + dated
+    class RefNumShort < RenderingStyle
+      def initialize
+        super(with_language_code: :single, stage_format_long: false, with_date: true)
+      end
+    end
+
+    # Instance reference number long: 2-letter language code + long form + dated
+    class RefNumLong < RenderingStyle
+      def initialize
+        super(with_language_code: :iso, stage_format_long: true, with_date: true)
+      end
+    end
+
+    # Reference dated: no language code + short form + dated
+    class RefDated < RenderingStyle
+      def initialize
+        super(with_language_code: :none, stage_format_long: false, with_date: true)
+      end
+    end
+
+    # Reference dated long: no language code + long form + dated
+    class RefDatedLong < RenderingStyle
+      def initialize
+        super(with_language_code: :none, stage_format_long: true, with_date: true)
+      end
+    end
+
+    # Reference undated: no language code + short form + undated
+    class RefUndated < RenderingStyle
+      def initialize
+        super(with_language_code: :none, stage_format_long: false, with_date: false)
+      end
+    end
+
+    # Reference undated long: no language code + long form + undated
+    class RefUndatedLong < RenderingStyle
+      def initialize
+        super(with_language_code: :none, stage_format_long: true, with_date: false)
+      end
+    end
+  end
+end

data/lib/pubid/iec/single_identifier.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    class SingleIdentifier < Identifier
+      # Default to the class's published typed_stage so an omitted "stage" key
+      # reconstructs the published state on from_hash.
+      attribute :typed_stage, ::Pubid::Components::TypedStage,
+                default: -> { self.class.published_typed_stage }
+
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      def publisher_portion(lang: :en)
+        # IEC identifiers can have copublishers (e.g., IEC/IEEE, ISO/IEC)
+
+        # Build publisher string
+        pub_string = if copublishers&.any?
+                       # Has copublishers: "IEC/IEEE" or "ISO/IEC"
+                       ([publisher] + copublishers).map(&:body).join("/")
+                     else
+                       # No copublishers: just "IEC"
+                       publisher.body
+                     end
+
+        # IEC house style separates the publisher from the typed-stage
+        # abbreviation with a SPACE, for every type and whether or not there
+        # are copublishers: "IEC CD 60038", "IEC PNW 1000-1:2023". The slash
+        # stays the copublisher separator only. The slash input spelling
+        # ("IEC/CD 60038") is still accepted by the parser; only rendering
+        # normalises. See issue #360 item 2.
+        abbr = typed_stage&.abbreviation.to_s
+        pub_string += " #{abbr}" unless abbr.empty?
+
+        pub_string
+      end
+
+      def number_portion(lang_single: false)
+        [
+          (number ? number.to_s : ""),
+          (part ? "-#{part}" : ""),
+          (subpart ? "-#{subpart}" : ""),
+          (stage_iteration ? ".#{stage_iteration}" : ""),
+          (date ? ":#{date.render}" : ""),
+        ].join
+      end
+
+      def language_portion(lang_single: false)
+        return "" unless languages&.any?
+
+        [
+          "(",
+          languages.map do |lang|
+            lang.to_s(lang_single: lang_single)
+          end.join(lang_single ? "/" : ","),
+          ")",
+        ].join
+      end
+
+      def edition_portion(lang: :en)
+        return nil unless edition&.number
+
+        "ED#{edition.number}"
+      end
+    end
+  end
+end

data/lib/pubid/iec/supplement_identifier.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    # Identifier that represents a supplement to a base identifier.
+    class SupplementIdentifier < SingleIdentifier
+      attribute :base, Identifier, polymorphic: true
+
+      # Serialize the supplemented document under "base". The supplement's own
+      # number/date/stage come from the inherited common maps; route the nested
+      # base hash back through Identifier.from_hash so its concrete subclass (and
+      # any further nesting) is reconstructed.
+      key_value do
+        map "base", with: { to: :base_to_kv, from: :base_from_kv }
+      end
+
+      def base_to_kv(model, doc)
+        base = model.base
+        return unless base
+
+        # `base` synthesises a base for a supplement that has none
+        # (e.g. a bare "+AMD1:2008" nested in a consolidation): a fake doc whose
+        # number equals the supplement's own. It renders nothing and the getter
+        # recreates it identically on load, so don't persist it. A standalone
+        # supplement ("IEC/FDAM 60038-1") instead moves the real base number into
+        # the synthetic base (base.number != own number), which must be kept.
+        return if model.synthetic_base? && base.number.to_s == model.number.to_s
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("base",
+                                                              base.to_hash))
+      end
+
+      def base_from_kv(model, value)
+        return unless value
+
+        base = ::Pubid::Iec::Identifier.from_hash(value)
+        model.base = base
+
+        # A base of the exact SingleIdentifier class is the synthetic self-base
+        # of a standalone supplement ("IEC/FDAM 60038-1"); a real attached base
+        # is always a concrete type (InternationalStandard, etc.). Re-engage the
+        # synthetic-base state so the supplement renders in standalone form
+        # (publisher/TYPE base-number-supp-number) instead of attached form.
+        if base.instance_of?(::Pubid::Iec::SingleIdentifier)
+          model.mark_synthetic_standalone!
+        end
+      end
+
+      # Re-engage the standalone synthetic-base state on a deserialized
+      # supplement. At this point `number` already holds the supplement number
+      # (set from the "number" key before "base"), so preserve it as the
+      # supplement number and flag the synthetic base.
+      def mark_synthetic_standalone!
+        @synthetic_base = true
+        @supplement_number = @number
+      end
+
+      # Override base getter to ensure it's always created for standalone supplements
+      def base
+        @base || ensure_base
+      end
+
+      # Override number getter to trigger swap for standalone supplements
+      def number
+        # Guard against recursion in ensure_base
+        return @number if @ensuring_base
+
+        # For standalone supplements, trigger base creation first
+        ensure_base if @synthetic_base.nil? && publisher && part
+
+        if @synthetic_base
+          @supplement_number || @number
+        else
+          super
+        end
+      end
+
+      # Override part getter for standalone supplements (part becomes nil after swap)
+      def part
+        # For standalone supplements with synthetic base, part is nil (moved to number)
+        if @synthetic_base
+          nil
+        else
+          super
+        end
+      end
+
+      # Delegate publisher and copublishers to base whenever there is
+      # a base (a supplement carries the publisher of the document it
+      # supplements). Checking base first — rather than `@publisher || base` — is
+      # required now that the publisher attribute has an IEC default, which would
+      # otherwise mask the delegation.
+      def publisher
+        return @publisher if @ensuring_base
+
+        base ? base.publisher : @publisher
+      end
+
+      def copublishers
+        return @copublishers if @ensuring_base
+
+        base ? base.copublishers : @copublishers
+      end
+
+      # Ensure we have a base for standalone supplements
+      # Creates a synthetic base identifier from supplement attributes if needed
+      # Returns the base
+      def ensure_base
+        return @base if @base
+
+        # Guard flag to prevent recursion in number getter
+        @ensuring_base = true
+
+        # For standalone supplements like "IEC/FDAM 60038-1"
+        # The supplement number is in the `part` attribute, while `number` is the base number
+        # We need to create a synthetic base and use part as the supplement number
+        return nil unless publisher && (number || part)
+
+        # Capture original values BEFORE marking as synthetic
+        # (otherwise our getters will return swapped values)
+        base_number = number
+        supplement_number = part
+
+        # NOW mark that this is a synthetic base (after capturing values)
+        @synthetic_base = true
+
+        # Use SingleIdentifier which has typed_stage attribute
+        base = SingleIdentifier.new
+        base.publisher = publisher
+        base.number = base_number if base_number
+        base.part = nil # Base doesn't have part - part is the supplement number
+        base.subpart = subpart if subpart
+        base.date = date if date
+
+        # Create typed_stage for the base - use "IS" (International Standard) type
+        # not the supplement type
+        base.typed_stage = Pubid::Components::TypedStage.new(
+          abbr: ["IS"],
+          type_code: :is,
+          stage_code: :undated,
+        )
+
+        @base = base
+
+        # Store the supplement number for getter override
+        # The original number is the base number (moved to base)
+        # The original part is the supplement number (what we want to return)
+        @supplement_number = supplement_number
+
+        @base
+      ensure
+        @ensuring_base = false
+      end
+
+      # Check if this supplement has a synthetic base (created for standalone format)
+      def synthetic_base?
+        @synthetic_base ||= false
+      end
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      # MR supplement suffix: `/{type}.{number}.{year}` (e.g. "/amd.1.2016").
+      # The MrString renderer recurses into `base` and appends this so the
+      # full supplement chain round-trips losslessly (issue #142).
+      def mr_supplement_suffix
+        segments = []
+        segments << mr_type if mr_type
+        segments << number&.to_s if number
+        segments << date&.year&.to_s if date&.year
+        return nil if segments.empty?
+
+        segments.join(".")
+      end
+    end
+  end
+end