pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.12

data/lib/pubid/iec/identifiers/publicly_available_specification.rb

@@ -82,18 +82,6 @@ module Pubid
             web: :publicly_available_specification, title: "Publicly Available Specification", short: "PAS" }
         end
 
-        # Override publisher_portion to add PAS or DPAS stage
-        def publisher_portion
-          result = publisher.to_s
-
-          if typed_stage
-            abbr = typed_stage.abbreviation
-            # PAS uses space for all stages
-            result += " #{abbr}" unless abbr.empty?
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/iec/identifiers/societal_technology_trend_report.rb

@@ -24,16 +24,6 @@ module Pubid
             short: "Trend Report" }
         end
 
-        # Override publisher_portion to add Trend Report
-        def publisher_portion
-          result = publisher.to_s
-
-          if typed_stage && typed_stage.abbreviation == "Trend Report"
-            result += " Trend Report"
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/iec/identifiers/systems_reference_document.rb

@@ -23,16 +23,6 @@ module Pubid
             web: :systems_reference_document, title: "Systems Reference Document", short: "SRD" }
         end
 
-        # Override publisher_portion to add SRD
-        def publisher_portion
-          result = publisher.to_s
-
-          if typed_stage && typed_stage.abbreviation == "SRD"
-            result += " SRD"
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/iec/identifiers/technical_report.rb

@@ -108,23 +108,6 @@ module Pubid
             web: :technical_report, title: "Technical Report", short: "TR" }
         end
 
-        # Override publisher_portion to handle TR formatting
-        # If copublishers exist, use parent implementation
-        def publisher_portion
-          # If copublishers, delegate to parent (SingleIdentifier) which handles them
-          return super if copublishers&.any?
-
-          # No copublishers: simple TR formatting
-          result = publisher.to_s
-
-          if typed_stage
-            abbr = typed_stage.abbreviation
-            # For TR: always use space (IEC convention for ALL publishers)
-            result += " #{abbr}" unless abbr.empty?
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/iec/identifiers/technical_specification.rb

@@ -108,23 +108,6 @@ module Pubid
             web: :technical_specification, title: "Technical Specification", short: "TS" }
         end
 
-        # Override publisher_portion to handle TS formatting
-        # If copublishers exist, use parent implementation
-        def publisher_portion
-          # If copublishers, delegate to parent (SingleIdentifier) which handles them
-          return super if copublishers&.any?
-
-          # No copublishers: simple TS formatting
-          result = publisher.to_s
-
-          if typed_stage
-            abbr = typed_stage.abbreviation
-            # TS uses space for all stages
-            result += " #{abbr}" unless abbr.empty?
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/iec/identifiers/technology_report.rb

@@ -22,16 +22,6 @@ module Pubid
           { key: :tec, title: "Technology Report", short: "Technology Report" }
         end
 
-        # Override publisher_portion to add Technology Report
-        def publisher_portion
-          result = publisher.to_s
-
-          if typed_stage && typed_stage.abbreviation == "Technology Report"
-            result += " Technology Report"
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/iec/identifiers/test_report_form.rb

@@ -28,17 +28,6 @@ module Pubid
             web: :test_report_form, title: "Test Report Form", short: "TRF" }
         end
 
-        # Override publisher_portion to add TRF with space
-        def publisher_portion
-          result = publisher.to_s
-
-          if typed_stage && typed_stage.abbreviation == "TRF"
-            result += " TRF"
-          end
-
-          result
-        end
-
         # TRF uses special rendering via the Renderer
       end
     end

data/lib/pubid/iec/identifiers/white_paper.rb

@@ -23,16 +23,6 @@ module Pubid
             web: :white_paper, title: "White Paper", short: "White Paper" }
         end
 
-        # Override publisher_portion to add White Paper
-        def publisher_portion
-          result = publisher.to_s
-
-          if typed_stage && typed_stage.abbreviation == "White Paper"
-            result += " White Paper"
-          end
-
-          result
-        end
       end
     end
   end

data/lib/pubid/iec/identifiers/working_document.rb

@@ -28,19 +28,33 @@ module Pubid
             web: :working_document, title: "Working Document", short: "WD" }
         end
 
-        # Return stage object for PWI/PNW stage
+        # A working document prints its committee, number, language and stage —
+        # `1/2457(F)/FDIS` — and none of those is the `number` the shared token
+        # table looks for, so it had no annotatable token. `wd_stage` is the
+        # printed stage token ("FDIS"); the derived `#stage` reader covers only
+        # the PWI/PNW work-programme form and is nil here.
+        def annotation_tokens
+          super + [
+            [:technical_committee, "docnumber"],
+            [:wd_number, "docnumber"],
+            [:wd_language, "language"],
+            [:wd_stage, "stage"],
+            [:wp_stage, "stage"],
+            [:wp_type, "doctype"],
+          ]
+        end
+
+        # Return stage object for the PWI/PNW work-programme stage.
+        #
+        # This used to build a bare Stage from a hand-written abbreviation map,
+        # so the stage carried no harmonized code and "pnw" existed as a stage
+        # code nowhere else in the registry. It now resolves through the shared
+        # registry, so PWI carries 00.* and PNW carries 10.20 — which is what
+        # the URN generator reads.
         def stage
           return nil unless wp_stage
 
-          # Map PWI/PNW to stage codes
-          stage_map = {
-            "PWI" => "pwi",
-            "PNW" => "pnw",
-          }
-          stage_code = stage_map[wp_stage]
-          return nil unless stage_code
-
-          @stage ||= ::Pubid::Components::Stage.new(stage_code: stage_code)
+          @stage ||= Pubid::Iec.locate_stage(wp_stage)&.to_stage
         end
       end
     end

data/lib/pubid/iec/parser.rb

@@ -3,7 +3,7 @@ require "parslet"
 
 module Pubid
   module Iec
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 
@@ -17,8 +17,7 @@ module Pubid
       root :identifier
 
       rule(:identifier) do
-        working_programme_with_publisher |
-          working_programme |
+        working_programme |
           technical_group |
           working_document |
           sheet_supplement_identifier |
@@ -81,21 +80,6 @@ module Pubid
           (space >> edition).maybe
       end
 
-      # Working Programme with publisher prefix: IEC/PWI [TR] number edition
-      # Examples: "IEC/PWI 60038", "ISO/IEC/PWI TR 100-36 ED1"
-      rule(:working_programme_with_publisher) do
-        prefix_with_copublishers >> str("/") >>
-          (str("PWI") | str("PNW")).as(:wp_stage) >>
-          space >>
-          (
-            (str("TR") >> space) |
-            (str("TS") >> space) |
-            (str("SRD") >> space)
-          ).maybe.as(:wp_type) >>
-          wp_number >>
-          (space >> edition).maybe
-      end
-
       # Working programme numbers can be digits or TC names
       rule(:wp_number) do
         # TC-style: SYCSMARTENERGY-1, SyCLVDC-125

data/lib/pubid/iec/renderer.rb

@@ -89,13 +89,18 @@ module Pubid
       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
-          parts << id.publisher.render(context:)
+          publishers = [id.publisher.render(context:)]
           if id.copublishers&.any?
-            parts << "/#{id.copublishers.map { |c| c.render(context:) }.join('/')}"
+            publishers += id.copublishers.map { |c| c.render(context:) }
           end
+          parts << publishers.join("/")
         end
 
         abbr = id.typed_stage.abbr.first
@@ -104,7 +109,7 @@ module Pubid
         number_str += "-#{id.subpart}" if id.subpart
         parts << "#{abbr} #{number_str}"
 
-        result = parts.join("/")
+        result = parts.join(" ")
         result += ":#{id.date.render(context:)}" if id.date
         result += " #{id.edition.render(context:)}" if id.edition&.number
         result
@@ -197,14 +202,12 @@ module Pubid
 
       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 = []
-          if id.publisher
-            parts << id.publisher.render(context:)
-            if id.copublishers&.any?
-              parts << "/#{id.copublishers.map { |c| c.render(context:) }.join('/')}"
-            end
-            parts << "/"
-          end
           parts << id.wp_stage
           if id.wp_type && !id.wp_type.strip.empty?
             parts << " #{id.wp_type.strip}"

data/lib/pubid/iec/single_identifier.rb

@@ -8,6 +8,31 @@ module Pubid
       attribute :typed_stage, ::Pubid::Components::TypedStage,
                 default: -> { self.class.published_typed_stage }
 
+      # number/part/subpart are mapped HERE, not on Iec::Identifier, and the
+      # placement is the whole design.
+      #
+      # The four wrapper identifiers — FragmentIdentifier,
+      # ConsolidatedIdentifier, VapIdentifier and SheetIdentifier — inherit
+      # from Iec::Identifier DIRECTLY and override `number`/`part`/`subpart` as
+      # readers that delegate to what they wrap. A map on the shared parent
+      # would therefore serialize
+      # the delegated value twice: once at the wrapper's top level and again
+      # inside "base"/"identifiers". SingleIdentifier is the seam that excludes
+      # exactly those four while covering both classes that own a number of
+      # their own (Identifiers::Base and SupplementIdentifier).
+      #
+      # That is a structural exclusion, not a denylist of no-op converters that
+      # a later key can be forgotten from — which is how `month`/`day` came to
+      # leak (see DelegatedFieldSuppression).
+      #
+      # The values are plain strings, so no converter is needed: lutaml writes
+      # the scalar, and ::Pubid::Identifier#to_hash drops a nil.
+      key_value do
+        map "number", to: :number
+        map "part", to: :part
+        map "subpart", to: :subpart
+      end
+
       # Generate URN for this identifier
       #
       # @return [String] URN representation
@@ -28,16 +53,14 @@ module Pubid
                        publisher.body
                      end
 
-        # Add type abbreviation if present
-        if typed_stage && !typed_stage.abbreviation.empty?
-          abbr = typed_stage.abbreviation
-          # For copublishers or empty abbr, use space; otherwise use slash
-          pub_string += if copublishers&.any? || abbr == ""
-                          (abbr == "" ? "" : " #{abbr}")
-                        else
-                          "/#{abbr}"
-                        end
-        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

data/lib/pubid/iec/urn_generator.rb

@@ -2,77 +2,243 @@
 
 module Pubid
   module Iec
-    # Generates IEC URNs in the legacy positional format used as ground truth
-    # by relaton-data-iec:
+    # Generates IEC URNs in the positional format used as ground truth by
+    # relaton-data-iec:
     #
-    #   urn:iec:std:{publisher}:{number}[-{part}]:{date}:{type}:{deliverable}:{language}[:{adjuncts}]
+    #   urn:iec:std:{authority}:{number}[-{part}[-{subpart}]]
+    #       :{date}:{stage-or-type}:{deliverable}:{language}{adjuncts}
     #
-    # e.g. +urn:iec:std:iec:60050-102:2007:::+ (type after date; trailing empty
-    # type/deliverable/language slots). This is a port of relaton-iec's
-    # +Relaton::Iec.code_to_urn+ operating on +identifier.to_s+, which
-    # round-trips faithfully. The all-parts series URN is the one exception: it
-    # omits the language slot (8 fields), so it has a dedicated branch.
+    # 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
-      # Deliverable markers occupying the positional deliverable slot.
-      DELIVERABLES = /cmv|csv|exv|prv|rlv|ser/
+      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
-        return series_urn if identifier.class.attributes.key?(:all_parts) && identifier.all_parts
+        doc = document
+        return nil if doc.nil?
 
-        code_to_urn(identifier.to_s, urn_language)
+        num = number_segment(doc)
+        return nil if num.nil? || num.empty?
+
+        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)
+
+        (slots + adjuncts).join(":").downcase
       end
 
       private
 
-      # Hyphen-joined language codes (e.g. "en-fr"), or nil when unset.
-      def urn_language
-        return nil unless identifier.class.attributes.key?(:languages)
-
-        langs = identifier.languages
-        return nil unless langs&.any?
-
-        langs.map(&:code).join("-")
-      end
-
-      # The all-parts series URN drops the language slot and carries no part or
-      # date: urn:iec:std:iec:80000:::ser.
-      def series_urn
-        code = identifier.to_s.sub(/\s*\(all parts\)\s*\z/, "")
-        m = code.downcase.match(/(?<head>\S+)\s+(?<pnum>[\d-]+)/)
-        head = m[:head].split("/").join("-")
-        ["urn", "iec", "std", head, m[:pnum], "", "", "ser"].join(":")
-      end
-
-      # Port of Relaton::Iec.code_to_urn.
-      def code_to_urn(code, lang = nil)
-        rest = code.downcase.sub(%r{
-          (?<head>[^\s]+)\s
-          (?<type>is|ts|tr|pas|srd|guide|tec|wp)?(?(<type>)\s)
-          (?<pnum>[\d-]+)\s?
-          (?<_dd>:)?(?(<_dd>)(?<date>[\d-]+)\s?)
-        }x, "")
-        m = $~
-        return unless m && m[:head] && m[:pnum]
-
-        deliv = DELIVERABLES.match(code.downcase).to_s
-        urn = ["urn", "iec", "std", m[:head].split("/").join("-"), m[:pnum],
-               m[:date], m[:type], deliv, lang]
-        (urn + adjunct_to_urn(rest)).join(":")
-      end
-
-      # Port of Relaton::Iec.ajunct_to_urn — recursively emits amd/cor/ish
-      # adjuncts, prefixing "plus" for the "+" (consolidated) relation.
-      def adjunct_to_urn(rest)
-        r = rest.sub(%r{
-          (?<pl>\+|/)(?(<pl>)(?<adjunct>(?:amd|cor|ish))(?<adjnum>\d+)\s?)
-          (?<_d2>:)?(?(<_d2>)(?<adjdt>[\d-]+)\s?)
-        }x, "")
-        m = $~ || {}
-        return [] unless m[:adjunct]
-
-        plus = "plus" if m[:pl] == "+"
-        urn = [plus, m[:adjunct], m[:adjnum], m[:adjdt]]
-        urn + adjunct_to_urn(r)
+      # 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
+
+      # 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("-")
+      end
+
+      def number_segment(doc)
+        return nil unless doc.respond_to?(:number) && doc.number
+
+        segment = [doc.number, maybe_of(doc, :part), maybe_of(doc, :subpart)]
+          .compact.map(&:to_s).reject(&:empty?).join("-")
+        return nil if segment.empty?
+
+        # A few document numbers are multi-word ("DIR 1 IEC SUP"). A URN
+        # carries no spaces, so they become hyphens.
+        segment.gsub(/\s+/, "-")
+      end
+
+      # `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
+      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)
+
+        return type if stage.nil?
+
+        [type, stage].reject { |t| t.nil? || t.empty? }.join("-")
+      end
+
+      def type_token(doc)
+        ts = maybe_of(doc, :typed_stage)
+        code = ts&.type_code.to_s.downcase
+        TYPE_SLOT_CODES.include?(code) ? code : ""
+      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)
+
+        "stage-#{harmonized}"
+      end
+
+      def published_stage?(stage)
+        stage.stage_code.to_s == "published"
+      end
+
+      # 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)
+
+        vap = vap_codes
+        return vap unless vap.empty?
+
+        edition = maybe_of(identifier, :edition)
+        return "" unless edition&.number
+
+        edition.render(context: URN_CONTEXT).to_s
+      end
+
+      # 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
+
+        Array(codes).map { |c| c.to_s.downcase }
+          .select { |c| DELIVERABLES.include?(c) }.join("-")
+      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
+        end
+        nil
+      end
+
+      def language_slot
+        langs = maybe_of(identifier, :languages)
+        return "" unless langs&.any?
+
+        langs.map { |l| l.code.to_s }.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?
+      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
+      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
+
+        [plus ? "plus" : "", token, id.number.to_s,
+         maybe_of(id, :date)&.render(context: URN_CONTEXT).to_s]
+      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
       end
     end
   end