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

data/lib/pubid/iec/urn_parser.rb

@@ -2,23 +2,55 @@
 
 module Pubid
   module Iec
-    # Parses IEC URNs in the legacy positional format (relaton-data-iec ground
-    # truth):
+    # Parses RFC 5141-bis compliant URNs into IEC identifiers
     #
-    #   urn:iec:std:{publisher}:{number}[-{part}]:{date}:{type}:{deliverable}:{language}[:{adjuncts}]
+    # URN format: urn:iec:std:{publisher}:{type}:{number}[-{part}]:{year}:{supplements}
     #
     # 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.
+    # - 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
@@ -30,98 +62,227 @@ module Pubid
       # @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 Pubid::UrnParser::Errors::ParseError, "Invalid IEC URN: #{urn}"
+          raise 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}"
+        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
 
-        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)
+        # 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
-        id
+
+        # Build the identifier hash
+        build_identifier(publishers, number, part, subpart, type_code, stage_code, stage_iteration,
+                         date, edition, supplements)
       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
+      # Parse publisher component (iec, iso-iec, etc.)
+      def parse_publisher(publisher_str)
+        publisher_str.split("-").map(&:upcase)
+      end
 
-        [code, lang&.downcase, all_parts]
+      # Parse type component
+      def parse_type(type_str)
+        TYPE_CODE_REVERSE_MAP[type_str.downcase]
       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
+      # Parse number component (number, part, subpart)
+      def parse_number_part(number_str)
+        return [nil, nil, nil] unless number_str
 
-        stage.abbr.first.to_s
+        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
 
-      # "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]}"
+      # 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
 
-      # 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?
+      # 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
 
-        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..])
+        # Build the final identifier
+        builder = Pubid::Iec::Builder.new(Pubid::Iec::Scheme)
+        builder.build(base_hash)
       end
     end
   end

data/lib/pubid/iec.rb

@@ -2,63 +2,84 @@
 
 module Pubid
   module Iec
-    autoload :Components, "#{__dir__}/iec/components"
-
-    extend Pubid::PrefixesSupport
+  end
+end
 
-    # 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
+# Require scheme first
+require_relative "scheme"
 
-    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"
+# 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"
 
-    def self.parse(identifier_string)
-      Identifier.parse(identifier_string)
-    end
+# 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"
 
-    def self.parse_urn(urn)
-      UrnParser.parse(urn)
-    end
+# 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"
 
-    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Iec::Renderer)
+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
 
-    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
+    # 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
 
-    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
+    # Create the Scheme registry with all identifier types
+    Scheme = Pubid::Scheme.new(
+      identifiers: IDENTIFIER_TYPES,
+      supplement_identifiers: SUPPLEMENT_IDENTIFIER_TYPES,
+    )
 
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    # Main entry point for IEC identifiers
+    def self.parse(identifier_string)
+      parsed = Parser.new.parse(identifier_string)
+      Builder.new(Scheme).build(parsed)
     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 } }
+    # 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

@@ -23,7 +23,7 @@ module Pubid
                               end
 
           # Extract code
-          code_str = extract_number(parsed[:number])
+          code_str = extract_value(parsed[:number])
           if code_str
             attributes[:code] = Components::Code.parse(code_str)
           end
@@ -36,11 +36,9 @@ module Pubid
           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`.
+          # Extract separator (for rendering distinction)
           separator_str = extract_value(parsed[:separator])
-          attributes[:date_separator] = separator_str if separator_str
+          attributes[:separator] = separator_str if separator_str
 
           # Set original format based on parsed data
           attributes[:original_format] = if separator_str || month_str
@@ -55,18 +53,6 @@ module Pubid
 
         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?