pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/iec/scheme.rb

@@ -0,0 +1,71 @@
+require_relative "identifiers/international_standard"
+# frozen_string_literal: true
+require_relative "identifiers/technical_specification"
+require_relative "identifiers/technical_report"
+require_relative "identifiers/publicly_available_specification"
+require_relative "identifiers/guide"
+require_relative "identifiers/amendment"
+require_relative "identifiers/corrigendum"
+require_relative "identifiers/fragment_identifier"
+
+module Pubid
+  module Iec
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::InternationalStandard,
+            Identifiers::TechnicalSpecification,
+            Identifiers::TechnicalReport,
+            Identifiers::PubliclyAvailableSpecification,
+            Identifiers::Guide,
+          ]
+        end
+
+        def supplement_identifiers
+          [
+            Identifiers::Amendment,
+            Identifiers::Corrigendum,
+            Identifiers::FragmentIdentifier,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def supplement_typed_stages
+          supplement_identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "" if abbr.nil?
+
+          typed_stage = (typed_stages + supplement_typed_stages).detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          identifier_klass = (identifiers + supplement_identifiers).detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iec/single_identifier.rb

@@ -0,0 +1,80 @@
+require_relative "identifier"
+# frozen_string_literal: true
+require_relative "../components/typed_stage"
+require_relative "urn_generator"
+
+module Pubid
+  module Iec
+    class SingleIdentifier < Identifier
+      attribute :typed_stage, Components::TypedStage
+
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      def to_s(lang: :en, lang_single: false, with_edition: false)
+        [].tap do |parts|
+          parts << publisher_portion(lang: lang)
+          parts << number_portion(lang_single: lang_single)
+          parts << edition_portion(lang: lang) if with_edition
+        end.compact.join(" ").tap do |s|
+          s << language_portion(lang_single: lang_single) if languages&.any?
+        end
+      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
+
+        # 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
+
+        pub_string
+      end
+
+      def number_portion(lang_single: false)
+        [
+          (number ? number.to_s : ""),
+          (part ? "-#{part}" : ""),
+          (subpart ? "-#{subpart}" : ""),
+          (stage_iteration ? ".#{stage_iteration}" : ""),
+          (date ? ":#{date.year}" : ""),
+        ].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,161 @@
+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, Identifier, polymorphic: true
+
+      # 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_identifier
+        return @number if @ensuring_base
+
+        # For standalone supplements, trigger base creation first
+        ensure_base_identifier 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_identifier if not set
+      def publisher
+        return @publisher if @ensuring_base
+
+        @publisher || base_identifier&.publisher
+      end
+
+      def copublishers
+        return @copublishers if @ensuring_base
+
+        @copublishers || base_identifier&.copublishers
+      end
+
+      # Ensure we have a base_identifier for standalone supplements
+      # Creates a synthetic base identifier from supplement attributes if needed
+      # 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
+
+        # 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
+        require_relative "../components/typed_stage"
+        base.typed_stage = Pubid::Components::TypedStage.new(
+          abbr: ["IS"],
+          type_code: :is,
+          stage_code: :undated,
+        )
+
+        @base_identifier = base
+
+        # Store the supplement number for getter override
+        # 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_identifier
+      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(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
+end

data/lib/pubid/iec/urn_generator.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    # Generates IEC URNs in the legacy positional format used as ground truth
+    # by relaton-data-iec:
+    #
+    #   urn:iec:std:{publisher}:{number}[-{part}]:{date}:{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.
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      # Deliverable markers occupying the positional deliverable slot.
+      DELIVERABLES = /cmv|csv|exv|prv|rlv|ser/.freeze
+
+      def generate
+        return series_urn if identifier.respond_to?(:all_parts) && identifier.all_parts
+
+        code_to_urn(identifier.to_s, urn_language)
+      end
+
+      private
+
+      # Hyphen-joined language codes (e.g. "en-fr"), or nil when unset.
+      def urn_language
+        return nil unless identifier.respond_to?(: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)
+      end
+    end
+  end
+end

data/lib/pubid/iec/urn_parser.rb

@@ -0,0 +1,90 @@
+# 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 Errors::ParseError, "Invalid IEC URN: #{urn}"
+        end
+
+        code, lang, all_parts = urn_to_code(urn)
+        raise Errors::ParseError, "Invalid IEC URN: #{urn}" unless code
+
+        id = Pubid::Iec::Identifier.parse(code)
+        id.all_parts = true if all_parts && id.respond_to?(:all_parts=)
+        if lang && !lang.empty? && id.respond_to?(:languages=)
+          id.languages = [::Pubid::Components::Language.new(code: lang)]
+        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("-", "/")
+        code += " #{type}" unless type.nil? || type.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 && deliv.casecmp("SER").zero?
+          all_parts = true
+        elsif deliv && !deliv.empty?
+          code += " #{deliv}"
+        end
+
+        [code, lang&.downcase, all_parts]
+      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,85 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+  end
+end
+
+# Require scheme first
+require_relative "scheme"
+
+# Require all identifier classes
+require_relative "iec/identifiers/international_standard"
+require_relative "iec/identifiers/technical_report"
+require_relative "iec/identifiers/technical_specification"
+require_relative "iec/identifiers/publicly_available_specification"
+require_relative "iec/identifiers/guide"
+require_relative "iec/identifiers/test_report_form"
+require_relative "iec/identifiers/interpretation_sheet"
+require_relative "iec/identifiers/systems_reference_document"
+require_relative "iec/identifiers/working_document"
+require_relative "iec/identifiers/amendment"
+require_relative "iec/identifiers/corrigendum"
+
+# Wrapper identifier types
+require_relative "iec/identifiers/vap_identifier"
+require_relative "iec/identifiers/sheet_identifier"
+require_relative "iec/identifiers/consolidated_identifier"
+require_relative "iec/identifiers/fragment_identifier"
+
+# Additional document types
+require_relative "iec/identifiers/component_specification"
+require_relative "iec/identifiers/operational_document"
+require_relative "iec/identifiers/societal_technology_trend_report"
+require_relative "iec/identifiers/white_paper"
+
+module Pubid
+  module Iec
+    # Primary document types (not supplements)
+    IDENTIFIER_TYPES = [
+      Identifiers::InternationalStandard,
+      Identifiers::TechnicalReport,
+      Identifiers::TechnicalSpecification,
+      Identifiers::PubliclyAvailableSpecification,
+      Identifiers::Guide,
+      Identifiers::TestReportForm,
+      Identifiers::InterpretationSheet,
+      Identifiers::SystemsReferenceDocument,
+      Identifiers::WorkingDocument,
+    ].freeze
+
+    # Supplement types (can appear with / notation)
+    SUPPLEMENT_IDENTIFIER_TYPES = [
+      Identifiers::Amendment,
+      Identifiers::Corrigendum,
+      Identifiers::InterpretationSheet, # ISH can act as supplement (/ISH1:1996)
+      Identifiers::FragmentIdentifier,  # FRAG wraps amendments/corrigenda
+    ].freeze
+
+    # Create the Scheme registry with all identifier types
+    Scheme = Pubid::Scheme.new(
+      identifiers: IDENTIFIER_TYPES,
+      supplement_identifiers: SUPPLEMENT_IDENTIFIER_TYPES,
+    )
+
+    # Main entry point for IEC identifiers
+    def self.parse(identifier_string)
+      parsed = Parser.new.parse(identifier_string)
+      Builder.new(Scheme).build(parsed)
+    end
+
+    # Parse an IEC URN string
+    # @param urn [String] the URN string to parse
+    # @return [Identifier] the parsed identifier
+    # @raise [Errors::ParseError] if URN is invalid
+    def self.parse_urn(urn)
+      UrnParser.parse(urn)
+    end
+  end
+end
+
+require_relative "iec/urn_parser"
+require_relative "iec/builder"
+require_relative "iec/parser"
+
+Pubid::Registry.register(:iec, Pubid::Iec)

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

@@ -0,0 +1,71 @@
+# 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_value(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 separator (for rendering distinction)
+          separator_str = extract_value(parsed[:separator])
+          attributes[: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
+
+        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