pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/iec/supplement_identifier.rb

@@ -1,72 +1,25 @@
+require_relative "identifier"
+require_relative "single_identifier"
 # 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
+      attribute :base_identifier, Identifier, polymorphic: true
 
-      # 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
+      # Override base_identifier getter to ensure it's always created for standalone supplements
+      def base_identifier
+        @base_identifier || ensure_base_identifier
       end
 
       # Override number getter to trigger swap for standalone supplements
       def number
-        # Guard against recursion in ensure_base
+        # Guard against recursion in ensure_base_identifier
         return @number if @ensuring_base
 
         # For standalone supplements, trigger base creation first
-        ensure_base if @synthetic_base.nil? && publisher && part
+        ensure_base_identifier if @synthetic_base.nil? && publisher && part
 
         if @synthetic_base
           @supplement_number || @number
@@ -85,28 +38,24 @@ module Pubid
         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.
+      # Delegate publisher and copublishers to base_identifier if not set
       def publisher
         return @publisher if @ensuring_base
 
-        base ? base.publisher : @publisher
+        @publisher || base_identifier&.publisher
       end
 
       def copublishers
         return @copublishers if @ensuring_base
 
-        base ? base.copublishers : @copublishers
+        @copublishers || base_identifier&.copublishers
       end
 
-      # Ensure we have a base for standalone supplements
+      # Ensure we have a base_identifier for standalone supplements
       # Creates a synthetic base identifier from supplement attributes if needed
-      # Returns the base
-      def ensure_base
-        return @base if @base
+      # Returns the base_identifier
+      def ensure_base_identifier
+        return @base_identifier if @base_identifier
 
         # Guard flag to prevent recursion in number getter
         @ensuring_base = true
@@ -134,20 +83,21 @@ module Pubid
 
         # Create typed_stage for the base - use "IS" (International Standard) type
         # not the supplement type
+        require_relative "../components/typed_stage"
         base.typed_stage = Pubid::Components::TypedStage.new(
           abbr: ["IS"],
           type_code: :is,
           stage_code: :undated,
         )
 
-        @base = base
+        @base_identifier = base
 
         # Store the supplement number for getter override
-        # The original number is the base number (moved to base)
+        # The original number is the base number (moved to base_identifier)
         # The original part is the supplement number (what we want to return)
         @supplement_number = supplement_number
 
-        @base
+        @base_identifier
       ensure
         @ensuring_base = false
       end
@@ -157,21 +107,54 @@ module Pubid
         @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(".")
+      def to_s(lang: :en, lang_single: false, with_edition: false)
+        # Ensure we have a base_identifier for standalone supplements
+        ensure_base_identifier
+
+        # For standalone supplements (synthetic base), use standalone format
+        # IEC/FDAM 60038-1, not IEC/IS 60038/FDAM1
+        if synthetic_base?
+          parts = []
+
+          # Publisher portion
+          if publisher
+            parts << publisher.body
+            parts << "/#{copublishers.map(&:body).join('/')}" if copublishers&.any?
+          end
+
+          # Supplement type and number with part (use base number)
+          abbr = typed_stage.abbr.first
+          number_str = base_identifier.number.to_s
+          number_str += "-#{number}" if number # supplement number
+          number_str += "-#{subpart}" if subpart
+          parts << "#{abbr} #{number_str}"
+
+          result = parts.join("/")
+          result += ":#{date.year}" if date
+          result += " #{edition}" if edition&.number
+          result
+        elsif base_identifier
+          # Normal supplement with real base identifier
+          # Format: "IEC 60050-102:2007/AMD1:2017"
+          parts = []
+          parts << base_identifier.to_s(lang: lang, lang_single: lang_single,
+                                        with_edition: with_edition)
+
+          # Supplement notation
+          # Use uppercase abbreviation without space: /AMD1, /COR1
+          abbr = typed_stage.abbr.first.upcase
+          supp_part = "/#{abbr}#{number}"
+          supp_part += ":#{date.year}" if date
+          parts << supp_part
+
+          # Add edition if present
+          parts << " #{edition}" if edition&.number
+
+          parts.join
+        else
+          # Fallback - shouldn't happen
+          super
+        end
       end
     end
   end

data/lib/pubid/iec/urn_generator.rb

@@ -2,243 +2,191 @@
 
 module Pubid
   module Iec
-    # Generates IEC URNs in the positional format used as ground truth by
-    # relaton-data-iec:
-    #
-    #   urn:iec:std:{authority}:{number}[-{part}[-{subpart}]]
-    #       :{date}:{stage-or-type}:{deliverable}:{language}{adjuncts}
-    #
-    # e.g. +urn:iec:std:iec:60050-102:2007:::+. Absent trailing slots are
-    # emitted as empty fields. The all-parts series URN is the one exception:
-    # a bare series omits the language slot (8 fields).
-    #
-    # This used to be a port of relaton-iec's +code_to_urn+, which regex-scraped
-    # +identifier.to_s+. Three defects followed from reading the printed form:
-    # the stage was folded into the authority slot (+urn:iec:std:iec-np:...+),
-    # the edition was never emitted, and the regex was unanchored, so any type
-    # token outside its hard-coded list consumed the publisher instead
-    # (+IEC/DTS 62271-1+ became +urn:iec:std:dts:62271-1::::+, and every
-    # +IECEE TRF ...+ keyed +urn:iec:std:trf:...+). The generator now reads the
-    # identifier's own components. The slot ORDER is unchanged, because the
-    # published corpus uses it. See issue #360 item 4.
     class UrnGenerator < Pubid::UrnGenerator::Base
-      URN_CONTEXT = Rendering::RenderingContext.urn.freeze
-      private_constant :URN_CONTEXT
-
-      # Type codes that occupy the type slot. `is` and `trf` render empty
-      # there, as they always have. `tec` and `wp` never appear in the corpus
-      # but the legacy grammar accepted them, so they stay recognised.
-      TYPE_SLOT_CODES = %w[tr ts pas srd guide tec wp].freeze
-
-      # Deliverable markers occupying the deliverable slot. "ser" reaches this
-      # list as a spelled-out VAP code ("IEC 60034:2026 SER"), which is not the
-      # same thing as the `all_parts` series form handled below.
-      DELIVERABLES = %w[cmv csv exv prv rlv ser].freeze
-
-      # Supplement classes that contribute an adjunct, and the token each one
-      # writes into it.
-      ADJUNCT_TOKENS = {
-        "Amendment" => "amd",
-        "Corrigendum" => "cor",
-        "InterpretationSheet" => "ish",
-      }.freeze
-
       def generate
-        doc = document
-        return nil if doc.nil?
+        case identifier
+        when Identifiers::VapIdentifier
+          generate_vap_urn
+        when Identifiers::FragmentIdentifier
+          generate_fragment_urn
+        when Identifiers::SheetIdentifier
+          generate_sheet_urn
+        when SupplementIdentifier
+          generate_supplement_urn
+        else
+          generate_base_urn
+        end
+      end
 
-        num = number_segment(doc)
-        return nil if num.nil? || num.empty?
+      private
 
-        slots = ["urn", "iec", "std", authority(doc), num,
-                 date_slot(doc), stage_or_type_slot(doc), deliverable_slot]
-        adjuncts = adjunct_slots(identifier)
-        language = language_slot
-        slots << language unless bare_series?(slots, adjuncts, language)
+      def generate_vap_urn
+        base_gen = self.class.new(identifier.base_identifier)
+        base_urn = base_gen.generate
 
-        (slots + adjuncts).join(":").downcase
-      end
+        base_part = base_urn.sub(/^urn:iec:std:/, "")
 
-      private
+        parts = ["urn", "iec", "std", base_part]
 
-      # The document the URN names: the origin standard, with every amendment,
-      # corrigendum, consolidation, VAP and fragment layer peeled off. Those
-      # layers are what the adjunct and deliverable slots record.
-      #
-      # A CISPR test report form carries no number of its own — the document it
-      # reports on sits in `cispr_identifier`, and that is what the URN has
-      # always named.
-      def document
-        doc = identifier.respond_to?(:root) ? identifier.root : identifier
-        return doc if doc.nil? || number_segment(doc)
-
-        maybe_of(doc, :cispr_identifier) || doc
-      end
+        if identifier.vap_suffix
+          suffix = identifier.vap_suffix.to_s
+          parts << "vap.#{suffix.downcase}"
+        end
 
-      # A publisher body may carry a space ("IEC CA", "IECQ CS", "IECQ OD").
-      # The published corpus records only the last token for those
-      # (+urn:iec:std:ca:01:2017:::+), which is what the old whitespace-
-      # splitting regex produced. Keeping that spelling is what keeps those
-      # rows byte-identical; correcting it to "iec-ca" would need a data
-      # migration first.
-      def authority(doc)
-        publishers = [doc.publisher] + Array(doc.copublishers)
-        publishers.compact.map { |p| p.body.to_s.split(/\s+/).last.to_s }
-          .reject(&:empty?).join("-")
+        if identifier.edition&.number
+          parts << "ed.#{identifier.edition.number}"
+        end
+
+        parts.join(":")
       end
 
-      def number_segment(doc)
-        return nil unless doc.respond_to?(:number) && doc.number
+      def generate_fragment_urn
+        base_gen = self.class.new(identifier.base_identifier)
+        base_urn = base_gen.generate
 
-        segment = [doc.number, maybe_of(doc, :part), maybe_of(doc, :subpart)]
-          .compact.map(&:to_s).reject(&:empty?).join("-")
-        return nil if segment.empty?
+        base_part = base_urn.sub(/^urn:iec:std:/, "")
 
-        # A few document numbers are multi-word ("DIR 1 IEC SUP"). A URN
-        # carries no spaces, so they become hyphens.
-        segment.gsub(/\s+/, "-")
-      end
+        parts = ["urn", "iec", "std", base_part]
 
-      # `Components::Date#render` under a URN context deliberately drops the
-      # month, which is the ISO convention. IEC keeps the precision it was
-      # given ("IEC CA 01:2025-10" keys ...:2025-10:...), so this reads the
-      # printed form.
-      def date_slot(doc)
-        maybe_of(doc, :date).to_s
+        if identifier.fragment_number
+          frag_type = identifier.base_identifier.is_a?(Identifiers::Corrigendum) ? "fragc" : "frag"
+          parts << "#{frag_type}.#{identifier.fragment_number}"
+        end
+
+        if identifier.edition&.number
+          parts << "ed.#{identifier.edition.number}"
+        end
+
+        parts.join(":")
       end
 
-      # The stage slot and the type slot are the same slot, and a draft of a
-      # typed document has both. Both are kept, type first
-      # ("ts-stage-50.00"), because the harmonized codes are shared across
-      # types: dropping the type would make a draft TS, a draft TR and a draft
-      # International Standard collide, and `parse_urn` would resolve every one
-      # of them to an International Standard.
-      def stage_or_type_slot(doc)
-        type = type_token(doc)
-        stage = stage_token(doc)
+      def generate_sheet_urn
+        base_gen = self.class.new(identifier.base_identifier)
+        base_urn = base_gen.generate
 
-        return type if stage.nil?
+        base_part = base_urn.sub(/^urn:iec:std:/, "")
 
-        [type, stage].reject { |t| t.nil? || t.empty? }.join("-")
-      end
+        parts = ["urn", "iec", "std", base_part]
 
-      def type_token(doc)
-        ts = maybe_of(doc, :typed_stage)
-        code = ts&.type_code.to_s.downcase
-        TYPE_SLOT_CODES.include?(code) ? code : ""
-      end
+        if identifier.sheet_number
+          parts << "sheet.#{identifier.sheet_number}"
+        end
 
-      # nil when the document is published (or carries no stage at all), so the
-      # slot keeps holding the bare type token for every published row.
-      def stage_token(doc)
-        stage = maybe_of(doc, :typed_stage)&.to_stage || maybe_of(doc, :stage)
-        harmonized = stage&.harmonized_stages&.first.to_s
-        return nil if harmonized.empty?
-        return nil if published_stage?(stage)
+        if identifier.year
+          parts << identifier.year
+        end
 
-        "stage-#{harmonized}"
+        parts.join(":")
       end
 
-      def published_stage?(stage)
-        stage.stage_code.to_s == "published"
-      end
+      def generate_base_urn
+        parts = ["urn", "iec", "std"]
 
-      # A deliverable code owns the slot; the edition takes it only when there
-      # is none.
-      def deliverable_slot
-        return "ser" if maybe_of(identifier, :all_parts)
+        parts << publisher_component
 
-        vap = vap_codes
-        return vap unless vap.empty?
+        type_comp = type_component
+        parts << type_comp if type_comp
 
-        edition = maybe_of(identifier, :edition)
-        return "" unless edition&.number
+        docnumber = docnumber_component
+        parts << docnumber if docnumber
 
-        edition.render(context: URN_CONTEXT).to_s
-      end
+        date_str = urn_date_string(identifier.date)
+        parts << date_str if date_str
 
-      # A deliverable sits on the VAP layer, which is not always the outermost
-      # one: "IEC 60079-10-1:2020 CMV/COR1:2021" is a corrigendum wrapping the
-      # CMV, so the codes have to be looked for down the chain.
-      def vap_codes
-        codes = find_down(:vap)
-        return "" unless codes
+        if identifier.stage_iteration
+          parts << "iter.#{identifier.stage_iteration}"
+        end
 
-        Array(codes).map { |c| c.to_s.downcase }
-          .select { |c| DELIVERABLES.include?(c) }.join("-")
-      end
+        if identifier.edition&.number
+          parts << "ed.#{identifier.edition.number}"
+        end
 
-      # First non-empty value of `attribute` from the outermost identifier
-      # inwards.
-      def find_down(attribute)
-        id = identifier
-        while id
-          value = maybe_of(id, attribute)
-          return value unless value.nil? ||
-            (value.respond_to?(:empty?) && value.empty?)
-
-          id = maybe_of(id, :base) ||
-            Array(maybe_of(id, :identifiers)).first
+        if identifier.languages&.any?
+          lang_codes = identifier.languages.map(&:code).join(",")
+          parts << lang_codes
         end
-        nil
+
+        parts.join(":")
       end
 
-      def language_slot
-        langs = maybe_of(identifier, :languages)
-        return "" unless langs&.any?
+      def generate_supplement_urn
+        current = identifier
+        supplement_chain = []
+
+        while current.is_a?(SupplementIdentifier)
+          supplement_chain.unshift(current)
+          current = current.base_identifier
+        end
+
+        base_id = current
+
+        parts = ["urn", "iec", "std"]
+
+        if base_id
+          parts << publisher_component(base_id)
+
+          type_comp = type_component(base_id)
+          parts << type_comp if type_comp
+
+          docnumber = docnumber_component(base_id)
+          parts << docnumber if docnumber
+
+          base_date_str = urn_date_string(base_id.date)
+          parts << base_date_str if base_date_str
+        end
+
+        supplement_chain.each do |supp|
+          suppl_type = supp.typed_stage&.type_code&.to_s
+          parts << suppl_type if suppl_type
 
-        langs.map { |l| l.code.to_s }.join("-")
+          supp_date_str = urn_date_string(supp.date)
+          parts << supp_date_str if supp_date_str
+
+          if supp.number
+            parts << "v#{supp.number}"
+          end
+
+          if supp.stage_iteration
+            parts << "iter.#{supp.stage_iteration}"
+          end
+        end
+
+        parts.join(":")
       end
 
-      # A bare, undated, stage- and language-less all-parts series drops the
-      # trailing empty language slot, matching the canonical relaton-data-iec
-      # form urn:iec:std:iec:80000:::ser. A dated series, or one carrying a
-      # stage, keeps the slot.
-      def bare_series?(slots, adjuncts, language)
-        slots.last == "ser" && slots[5, 2].all? { |s| s.to_s.empty? } &&
-          adjuncts.empty? && language.empty?
+      def publisher_component(id = identifier)
+        return "iec" unless id&.publisher
+
+        copubs = id.copublishers || []
+
+        publishers = [id.publisher] + copubs
+        publishers.map(&:to_s).map(&:downcase).join("-")
       end
 
-      # Walks the identifier tree for the amendment / corrigendum /
-      # interpretation-sheet layers, innermost first. A member of a
-      # consolidated identifier carries the "plus" relation marker, which the
-      # printed form spells "+".
-      def adjunct_slots(id)
-        return [] if id.nil?
-
-        case id.class.name.split("::").last
-        when "ConsolidatedIdentifier"
-          members = Array(id.identifiers)
-          adjunct_slots(members.first) +
-            members.drop(1).flat_map { |m| adjunct_fields(m, plus: true) }
-        when *ADJUNCT_TOKENS.keys
-          adjunct_slots(id.base) + adjunct_fields(id, plus: false)
-        else
-          adjunct_slots(id.respond_to?(:base) ? id.base : nil)
-        end
+      def type_component(id = identifier)
+        return nil unless id&.typed_stage
+
+        type_code = id.typed_stage.type_code
+        return nil if !type_code || type_code.to_s == "is"
+
+        type_code.to_s
       end
 
-      def adjunct_fields(id, plus:)
-        token = ADJUNCT_TOKENS[id.class.name.split("::").last]
-        return adjunct_slots(id.respond_to?(:base) ? id.base : nil) unless token
+      def docnumber_component(id = identifier)
+        return nil unless id&.number
 
-        [plus ? "plus" : "", token, id.number.to_s,
-         maybe_of(id, :date)&.render(context: URN_CONTEXT).to_s]
+        result = id.number.to_s
+        result += "-#{id.part}" if id.part
+        result += "-#{id.subpart}" if id.subpart
+        result
       end
 
-      # Not every IEC class declares every attribute, and a wrapper may not
-      # declare one its base does. The `respond_to?` guard covers the missing
-      # attribute; the rescue covers an attribute that exists but nil-chases
-      # while resolving — `SupplementIdentifier#number` runs `ensure_base` and
-      # reads through a base that may not be built yet. It is deliberately
-      # narrow: a broader rescue would swallow a real bug into a silently
-      # empty URN slot instead of failing loudly.
-      def maybe_of(id, attribute)
-        return nil unless id.respond_to?(attribute)
-
-        id.public_send(attribute)
-      rescue NoMethodError
-        nil
+      def urn_date_string(date)
+        return nil unless date
+
+        s = date.year.to_s
+        s += "-#{date.month}" if date.month
+        s
       end
     end
   end