pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/iec/urn_generator.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+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?
+
+        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
+
+      # 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
+end

data/lib/pubid/iec/urn_parser.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    # Parses IEC URNs in the legacy positional format (relaton-data-iec ground
+    # truth):
+    #
+    #   urn:iec:std:{publisher}:{number}[-{part}]:{date}:{type}:{deliverable}:{language}[:{adjuncts}]
+    #
+    # Examples:
+    # - urn:iec:std:iec:60050:2011:::
+    # - urn:iec:std:iec:62547:2013:tr::          (type after date)
+    # - urn:iec:std:iec:60050-102:2007:::::amd:1:2017
+    # - urn:iec:std:iec:60034-16-3:1996:ts::fr   (deliverable empty, language fr)
+    # - urn:iec:std:iec:80000:::ser              (all-parts series)
+    #
+    # This is a port of relaton-iec's +urn_to_code+: the positional fields are
+    # reassembled into a code string which is then run through the text parser
+    # (+Identifier.parse+), so there is a single source of truth for building
+    # the identifier object.
+    class UrnParser
+      # Parse IEC URN string
+      # @param urn [String] URN string to parse
+      # @return [Identifier] parsed identifier
+      def self.parse(urn)
+        new.parse_urn(urn)
+      end
+
+      # Parse URN string into identifier
+      # @param urn [String] URN string
+      # @return [Identifier] parsed identifier
+      def parse_urn(urn)
+        unless urn.start_with?("urn:iec:std:")
+          raise Pubid::UrnParser::Errors::ParseError, "Invalid IEC URN: #{urn}"
+        end
+
+        code, lang, all_parts = urn_to_code(urn)
+        unless code
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid IEC URN: #{urn}"
+        end
+
+        id = Pubid::Iec::Identifier.parse(code)
+        id.all_parts = true if all_parts && id.class.attributes.key?(:all_parts)
+        # The language slot joins codes with a hyphen ("en-fr"). Building one
+        # Language from the whole field gave a single bogus language that
+        # rendered as "(en-fr)".
+        if lang && !lang.empty? && id.class.attributes.key?(:languages)
+          id.languages = lang.split("-").map do |code|
+            ::Pubid::Components::Language.new(code: code)
+          end
+        end
+        id
+      end
+
+      private
+
+      # Port of Relaton::Iec.urn_to_code. Reassembles the positional URN fields
+      # into a text code string. Returns [code, language, all_parts].
+      def urn_to_code(urn)
+        fields = urn.upcase.split(":")
+        return if fields.size < 5
+
+        head, num, date, type, deliv, lang = fields[3, 8]
+        all_parts = false
+
+        code = head.gsub("-", "/")
+        type_code = type_slot_to_code(type)
+        code += " #{type_code}" unless type_code.empty?
+        code += " #{num}"
+        code += ":#{date}" unless date.nil? || date.empty?
+        code += adjunct_to_code(fields[9..])
+
+        # "ser" marks an all-parts series rather than a deliverable suffix; it
+        # is signalled out-of-band (the code built from a series URN carries no
+        # part or date, so to_s renders "IEC NNNN (all parts)").
+        if deliv&.casecmp("SER")&.zero?
+          all_parts = true
+        elsif (edition = edition_slot_to_code(deliv))
+          code += " #{edition}"
+        elsif deliv && !deliv.empty?
+          code += " #{deliv}"
+        end
+
+        [code, lang&.downcase, all_parts]
+      end
+
+      # The type slot holds either the legacy type token ("TS"), a stage
+      # ("STAGE-10.20"), or both ("TS-STAGE-50.00"). A stage is written back as
+      # the abbreviation the grammar accepts, resolved from the registry by
+      # type code and harmonized code — so the round trip is exact in both
+      # directions. See issue #360 item 4.
+      def type_slot_to_code(type)
+        return "" if type.nil? || type.empty?
+
+        match = /\A(?:([A-Z]+)-)?STAGE-([\d.]+)\z/.match(type)
+        return type unless match
+
+        type_code = (match[1] || "IS").downcase
+        stage = Pubid::Iec.all_typed_stages.find do |s|
+          s.type_code.to_s == type_code &&
+            s.harmonized_stages&.first.to_s == match[2]
+        end
+        return "" unless stage
+
+        stage.abbr.first.to_s
+      end
+
+      # "ED-7" in the deliverable slot is an edition, not a deliverable code.
+      def edition_slot_to_code(deliv)
+        match = /\AED-(.+)\z/.match(deliv.to_s)
+        match && "ED#{match[1]}"
+      end
+
+      # Port of Relaton::Iec.ajanct_to_code — recursively rebuilds amd/cor/ish
+      # adjuncts from (relation, type, number, date) quartets. A "PLUS"
+      # relation token (the consolidated "+" marker) yields "+"; otherwise "/".
+      def adjunct_to_code(fields)
+        return "" if fields.nil? || fields.empty?
+
+        rel, type, num, date = fields[0..3]
+        code = (rel.empty? ? "/" : "+") + type + num
+        code += ":#{date}" unless date.nil? || date.empty?
+        code + adjunct_to_code(fields[4..])
+      end
+    end
+  end
+end

data/lib/pubid/iec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    autoload :Components, "#{__dir__}/iec/components"
+
+    extend Pubid::PrefixesSupport
+
+    # Sourced from the parser's publisher list (Components::Publisher::PUBLISHERS)
+    # minus the joint "ISO/IEC", which is contributed symmetrically via
+    # Pubid::JOINT_PREFIXES (along with IEC/ISO and ISO/IEC/IEEE).
+    PREFIXES = (Components::Publisher::PUBLISHERS.keys - ["ISO/IEC"]).freeze
+
+    autoload :Identifier, "#{__dir__}/iec/identifier"
+    autoload :Identifiers, "#{__dir__}/iec/identifiers"
+    autoload :SingleIdentifier, "#{__dir__}/iec/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/iec/supplement_identifier"
+    autoload :Parser, "#{__dir__}/iec/parser"
+    autoload :Builder, "#{__dir__}/iec/builder"
+    autoload :UrnParser, "#{__dir__}/iec/urn_parser"
+    autoload :UrnGenerator, "#{__dir__}/iec/urn_generator"
+    autoload :RenderingStyle, "#{__dir__}/iec/rendering_style"
+    autoload :Renderer, "#{__dir__}/iec/renderer"
+
+    def self.parse(identifier_string)
+      Identifier.parse(identifier_string)
+    end
+
+    def self.parse_urn(urn)
+      UrnParser.parse(urn)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Iec::Renderer)
+
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| begin; c.type.is_a?(Hash); rescue NotImplementedError; false; end }
+    end
+
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+Pubid::Registry.register(:iec, Pubid::Iec)

data/lib/pubid/ieee/aiee/builder.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Aiee
+      # Builder for AIEE identifiers
+      class Builder
+        def build(parsed)
+          attributes = {}
+
+          # Extract and normalize publisher
+          # All AIEE variants (AIEE, A.I.E.E., A. I. E. E., IEEE-AIEE) normalize to "AIEE"
+          attributes[:publisher] = "AIEE"
+
+          # Extract and normalize type
+          type_str = extract_value(parsed[:type])
+          # Normalize compound types like "Standard No." to "No"
+          # Also normalize "Standard No" (without dot) to "No"
+          attributes[:type] = if type_str&.start_with?("Standard")
+                                "No"
+                              else
+                                type_str
+                              end
+
+          # Extract code
+          code_str = extract_number(parsed[:number])
+          if code_str
+            attributes[:code] = Components::Code.parse(code_str)
+          end
+
+          # Extract year (convert to string for consistency)
+          year_str = extract_value(parsed[:year])
+          attributes[:year] = year_str&.to_s
+
+          # Extract month
+          month_str = extract_value(parsed[:month])
+          attributes[:month] = month_str if month_str
+
+          # Extract the long-form date separator ("," or ".") for rendering.
+          # Named `date_separator` on the identifier to avoid colliding with the
+          # CodeNumber code-part `separator`.
+          separator_str = extract_value(parsed[:separator])
+          attributes[:date_separator] = separator_str if separator_str
+
+          # Set original format based on parsed data
+          attributes[:original_format] = if separator_str || month_str
+                                           "long"
+                                         else
+                                           "short"
+                                         end
+
+          # Create identifier
+          Identifier.new(**attributes)
+        end
+
+        private
+
+        # Extract the number, flattening a "431 (105)" main-number/parenthetical
+        # subtree into a plain string. Without this, a Hash node leaks its raw
+        # Parslet inspect form (e.g. `{main_number: "431"@8, ...}`) into `to_s`.
+        def extract_number(value)
+          return extract_value(value) unless value.is_a?(Hash)
+
+          main = extract_value(value[:main_number])
+          paren = value[:parenthetical]
+          alt = paren.is_a?(Hash) ? extract_value(paren[:alt_number]) : nil
+          alt ? "#{main} (#{alt})" : main
+        end
+
+        def extract_value(value)
+          return nil if value.nil?
+          return nil if value.is_a?(Array) && value.empty?
+
+          if value.is_a?(Array)
+            joined = value.join
+            return joined.length.positive? ? joined : nil
+          end
+
+          str_value = value.to_s.strip
+          str_value.length.positive? ? str_value : nil
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/aiee/identifier.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Aiee
+      # AIEE identifiers (American Institute of Electrical Engineers: 1884-1963).
+      #
+      # Reparented onto Pubid::Ieee::Identifier + the CodeNumber mixin so AIEE
+      # shares the flat split-column serialization (number/prefix/parts/
+      # separator), a polymorphic `_type`, `#root`, and from_hash routing with
+      # every other IEEE type. Previously it descended from bare
+      # Lutaml::Model::Serializable and serialized a nested `code` object with no
+      # `_type`, so Pubid::Ieee::Identifier.from_hash could not route back to
+      # this class and dropped the code entirely — every AIEE row failed the
+      # relaton index-v2 round-trip gate and had a nil `root.number`.
+      #
+      # The date long-form separator is named `date_separator` (not `separator`)
+      # to avoid colliding with the CodeNumber code-part `separator`.
+      class Identifier < Pubid::Ieee::Identifier
+        include Pubid::Ieee::Identifiers::CodeNumber
+
+        attribute :publisher, :string, default: -> { "AIEE" }
+        # AIEE carries no implicit type keyword, so override the base's "Std"
+        # default (else "AIEE 11-1937" would render as "AIEE Std 11-1937").
+        attribute :type, :string, default: -> {}
+        attribute :date_separator, :string  # "," or "." for long-form dates
+        attribute :original_format, :string # "short"/"long" (preserves parsed format)
+
+        # A distinct polymorphic name so from_hash routes to AIEE. The derived
+        # default (last name segment "Identifier") would be
+        # "pubid:ieee:identifier", colliding with the base class.
+        def self.polymorphic_name
+          "pubid:ieee:aiee"
+        end
+
+        # Parse AIEE identifier string
+        def self.parse(input)
+          parsed = Parser.new.parse(input)
+          Builder.new.build(parsed)
+        end
+
+        def to_s(date_format: nil, trademark: false, **opts)
+          result = [publisher]
+          result << type if type
+          result << code.to_s if code
+
+          base = result.join(" ")
+
+          # IEEE attaches the mark to the number, before the date suffix
+          # ("AIEE No 13™-1930").
+          if trademark
+            base += Pubid::Ieee.trademark_symbol_for(code_obj&.number,
+                                                     code_obj&.prefix,
+                                                     publishers: [publisher])
+          end
+
+          # Priority: explicit parameter > original_format > format auto-detect
+          format = date_format&.to_s || original_format
+          format ||= month || date_separator ? "long" : "short"
+
+          if year
+            case format
+            when "short", :short
+              base += "-#{year}"
+            when "long", :long
+              sep = date_separator || "," # Default to comma for long form
+              base += "#{sep} #{"#{month} " if month}#{year}"
+            else
+              base += if date_separator
+                        "#{date_separator} #{"#{month} " if month}#{year}"
+                      elsif month
+                        ", #{month} #{year}"
+                      else
+                        "-#{year}"
+                      end
+            end
+          end
+
+          # The descriptive relationships narrative is deliberately kept out of
+          # to_s (an identifier string must stay bounded — it is used as a
+          # document number/filename downstream). It stays reachable on
+          # `relationships`.
+
+          annotate_plain_render(base, **opts)
+        end
+      end
+    end
+  end
+end