pubid 1.15.17 → 2.0.0.pre.alpha.1

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,193 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        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
+
+      private
+
+      def generate_vap_urn
+        base_gen = self.class.new(identifier.base_identifier)
+        base_urn = base_gen.generate
+
+        base_part = base_urn.sub(/^urn:iec:std:/, "")
+
+        parts = ["urn", "iec", "std", base_part]
+
+        if identifier.vap_suffix
+          suffix = identifier.vap_suffix.to_s
+          parts << "vap.#{suffix.downcase}"
+        end
+
+        if identifier.edition&.number
+          parts << "ed.#{identifier.edition.number}"
+        end
+
+        parts.join(":")
+      end
+
+      def generate_fragment_urn
+        base_gen = self.class.new(identifier.base_identifier)
+        base_urn = base_gen.generate
+
+        base_part = base_urn.sub(/^urn:iec:std:/, "")
+
+        parts = ["urn", "iec", "std", base_part]
+
+        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
+
+      def generate_sheet_urn
+        base_gen = self.class.new(identifier.base_identifier)
+        base_urn = base_gen.generate
+
+        base_part = base_urn.sub(/^urn:iec:std:/, "")
+
+        parts = ["urn", "iec", "std", base_part]
+
+        if identifier.sheet_number
+          parts << "sheet.#{identifier.sheet_number}"
+        end
+
+        if identifier.year
+          parts << identifier.year
+        end
+
+        parts.join(":")
+      end
+
+      def generate_base_urn
+        parts = ["urn", "iec", "std"]
+
+        parts << publisher_component
+
+        type_comp = type_component
+        parts << type_comp if type_comp
+
+        docnumber = docnumber_component
+        parts << docnumber if docnumber
+
+        date_str = urn_date_string(identifier.date)
+        parts << date_str if date_str
+
+        if identifier.stage_iteration
+          parts << "iter.#{identifier.stage_iteration}"
+        end
+
+        if identifier.edition&.number
+          parts << "ed.#{identifier.edition.number}"
+        end
+
+        if identifier.languages&.any?
+          lang_codes = identifier.languages.map(&:code).join(",")
+          parts << lang_codes
+        end
+
+        parts.join(":")
+      end
+
+      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
+
+          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
+
+      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
+
+      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 docnumber_component(id = identifier)
+        return nil unless id&.number
+
+        result = id.number.to_s
+        result += "-#{id.part}" if id.part
+        result += "-#{id.subpart}" if id.subpart
+        result
+      end
+
+      def urn_date_string(date)
+        return nil unless date
+
+        s = date.year.to_s
+        s += "-#{date.month}" if date.month
+        s
+      end
+    end
+  end
+end

data/lib/pubid/iec/urn_parser.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    # Parses RFC 5141-bis compliant URNs into IEC identifiers
+    #
+    # URN format: urn:iec:std:{publisher}:{type}:{number}[-{part}]:{year}:{supplements}
+    #
+    # Examples:
+    # - urn:iec:std:iec:60050:2011
+    # - urn:iec:std:iec:tr:60050:2011
+    # - urn:iec:std:iec:60050-100:2011
+    # - urn:iec:std:iec:60050:2011:amd:1:2020
+    class UrnParser
+      # Reverse mappings from URN format to PubID components
+      TYPED_STAGE_REVERSE_MAP = {
+        "WD" => :wd,
+        "WDS" => :wds,
+        "CD" => :cd,
+        "CDV" => :cdv,
+        "DIS" => :dis,
+        "FDIS" => :fdis,
+        "PDAM" => :pdam,
+        "DAM" => :dam,
+        "FDAM" => :fdamd,
+        "DCOR" => :dcor,
+        "FDCOR" => :fdcor,
+        "CDTS" => :cdts,
+        "DTS" => :dts,
+        "FDTS" => :fdts,
+        "PRF" => :prf,
+        "PWI" => :pwi,
+        "NP" => :np,
+        "AWI" => :awi,
+        "NWIP" => :nwip,
+      }.freeze
+
+      SUPPLEMENT_TYPE_MAP = {
+        "amd" => :amd,
+        "cor" => :cor,
+      }.freeze
+
+      TYPE_CODE_REVERSE_MAP = {
+        "tr" => :tr,
+        "ts" => :ts,
+        "pas" => :pas,
+        "guide" => :guide,
+        "isp" => :isp,
+        "r" => :r,
+        "sr" => :sr,
+        "tap" => :tap,
+      }.freeze
+
+      # 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)
+        # Remove urn:iec:std: prefix
+        unless urn.start_with?("urn:iec:std:")
+          raise Errors::ParseError,
+                "Invalid IEC URN: #{urn}"
+        end
+
+        parts = urn.sub("urn:iec:std:", "").split(":")
+
+        # Parse publisher(s) - first part
+        publishers = parse_publisher(parts.shift)
+
+        # Parse type - optional (defaults to IS)
+        type_code = nil
+        type_code = parse_type(parts.first) if parts.first && TYPE_CODE_REVERSE_MAP.key?(parts.first.downcase)
+        parts.shift if type_code
+
+        # Parse number
+        number_part = parts.shift
+        number, part, subpart = parse_number_part(number_part)
+
+        # Check for stage (stage-XX.XX or typed stage like WD, CD, etc.)
+        stage_code = nil
+        stage_iteration = nil
+        if parts.first&.start_with?("stage-")
+          stage_code, stage_iteration = parse_stage_code(parts.shift)
+        elsif TYPED_STAGE_REVERSE_MAP.key?(parts.first&.upcase)
+          stage_abbr = parts.shift.upcase
+          stage_code = TYPED_STAGE_REVERSE_MAP[stage_abbr]
+          # Check for iteration (WD.2 format)
+          if stage_abbr.include?(".")
+            stage_code, stage_iteration = stage_abbr.split(".")
+            stage_code = TYPED_STAGE_REVERSE_MAP[stage_code]
+            stage_iteration = stage_iteration.to_i
+          end
+        end
+
+        # Parse date if present (year or year-month)
+        date = nil
+        if parts.first&.match(/^\d{4}(-\d{2})?$/)
+          date = parts.shift
+        end
+
+        # Parse edition if present (ed.N format)
+        edition = nil
+        if parts.first&.start_with?("ed.")
+          edition = parts.shift.sub("ed.", "").to_i
+        end
+
+        # Check for supplements (amd, cor)
+        supplements = []
+        while parts.any?
+          supp_type = nil
+          supp_number = nil
+          supp_date = nil
+          supp_stage = nil
+
+          # Check for supplement stage
+          if parts.first&.start_with?("stage-")
+            supp_stage_data = parts.shift
+            supp_stage, = parse_stage_code(supp_stage_data)
+          elsif TYPED_STAGE_REVERSE_MAP.key?(parts.first&.upcase)
+            supp_stage_abbr = parts.shift.upcase
+            supp_stage = TYPED_STAGE_REVERSE_MAP[supp_stage_abbr]
+          end
+
+          # Check for supplement type (amd, cor)
+          if SUPPLEMENT_TYPE_MAP.key?(parts.first&.downcase)
+            supp_type = SUPPLEMENT_TYPE_MAP[parts.shift.downcase]
+          end
+
+          # Check for version (v1, v2, etc.) or number
+          if parts.first&.start_with?("v")
+            version_str = parts.shift
+            supp_number = version_str.sub("v", "").to_i
+          elsif parts.first&.match(/^\d+$/)
+            # Could be year or supplement number
+            if parts.first&.match(/^\d{4}$/)
+              # 4 digits = year
+              supp_date = parts.shift
+            else
+              # 1-3 digits = supplement number
+              supp_number = parts.shift.to_i
+            end
+          end
+
+          # Next part might be year if not already set
+          if supp_date.nil? && parts.first&.match(/^\d{4}(-\d{2})?$/)
+            supp_date = parts.shift
+          end
+
+          # Safety: consume unrecognized token to prevent infinite loop
+          unless supp_type || supp_number || supp_date || supp_stage
+            parts.shift
+          end
+
+          supplements << {
+            type: supp_type,
+            number: supp_number,
+            date: supp_date,
+            stage: supp_stage,
+          }
+        end
+
+        # Build the identifier hash
+        build_identifier(publishers, number, part, subpart, type_code, stage_code, stage_iteration,
+                         date, edition, supplements)
+      end
+
+      private
+
+      # Parse publisher component (iec, iso-iec, etc.)
+      def parse_publisher(publisher_str)
+        publisher_str.split("-").map(&:upcase)
+      end
+
+      # Parse type component
+      def parse_type(type_str)
+        TYPE_CODE_REVERSE_MAP[type_str.downcase]
+      end
+
+      # Parse number component (number, part, subpart)
+      def parse_number_part(number_str)
+        return [nil, nil, nil] unless number_str
+
+        if number_str.include?("-")
+          parts = number_str.split("-")
+          number = parts[0]
+          part = parts[1] if parts[1]
+          subpart = parts[2] if parts[2]
+          [number, part, subpart]
+        else
+          [number_str, nil, nil]
+        end
+      end
+
+      # Parse stage code (stage-XX.XX format)
+      def parse_stage_code(stage_str)
+        stage_code = stage_str.sub("stage-", "")
+
+        if stage_code.include?(".")
+          stage_code, iteration = stage_code.split(".")
+          [stage_code.to_sym, iteration.to_i]
+        else
+          [stage_code.to_sym, nil]
+        end
+      end
+
+      # Build identifier from parsed components
+      def build_identifier(publishers, number, part, subpart, type_code, stage_code, _stage_iteration,
+                         date, edition, supplements)
+        # Start with base document hash
+        base_hash = {
+          publisher: publishers.first,
+          copublishers: publishers[1..]&.map { |c| { copublisher: c } },
+        }
+
+        # Build number_with_part (expected by Builder)
+        if part || subpart
+          number_with_part = number
+          number_with_part += "-#{part}" if part
+          number_with_part += "-#{subpart}" if subpart
+          base_hash[:number_with_part] = number_with_part
+        else
+          base_hash[:number] = number
+        end
+
+        base_hash[:date] = date if date
+        base_hash[:edition] = edition if edition
+
+        # Add type_with_stage if type_code is present
+        if type_code && type_code != :is
+          base_hash[:type_with_stage] = type_code.to_s.upcase
+        end
+
+        # Add stage if present
+        if stage_code
+          # Look up the typed stage abbreviation from stage_code
+          typed_stage = Scheme.locate_typed_stage_by_stage_code(stage_code)
+          if typed_stage
+            base_hash[:type_with_stage] =
+              typed_stage.abbr.is_a?(Array) ? typed_stage.abbr.first : typed_stage.abbr
+          else
+            # Fallback to harmonized stage notation
+            base_hash[:stage] = stage_code.to_s.gsub(".", ".")
+          end
+        end
+
+        # Build supplements recursively
+        supplements.reverse_each do |supp|
+          supp_hash = {}
+
+          if supp[:stage]
+            typed_stage = Scheme.locate_typed_stage_by_stage_code(supp[:stage])
+            supp_hash[:type_with_stage] = if
+typed_stage
+                                            typed_stage.abbr.is_a?(Array) ? typed_stage.abbr.first : typed_stage.abbr
+                                          else
+                                            supp[:stage].to_s.upcase
+                                          end
+          end
+
+          supp_hash[:type_with_stage] ||= supp[:type].to_s.upcase if supp[:type]
+
+          if supp[:number]
+            supp_hash[:number] = supp[:number].to_s
+          end
+
+          if supp[:date]
+            supp_hash[:date] = supp[:date].to_s
+          end
+
+          # Wrap current identifier with supplement
+          base_hash = {
+            base_identifier: base_hash,
+            **supp_hash,
+          }
+        end
+
+        # Build the final identifier
+        builder = Pubid::Iec::Builder.new(Pubid::Iec::Scheme)
+        builder.build(base_hash)
+      end
+    end
+  end
+end