pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.2

data/lib/pubid/iec/urn_generator.rb

@@ -2,191 +2,77 @@
 
 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
-      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"]
+      # Deliverable markers occupying the positional deliverable slot.
+      DELIVERABLES = /cmv|csv|exv|prv|rlv|ser/.freeze
 
-        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
+      def generate
+        return series_urn if identifier.respond_to?(:all_parts) && identifier.all_parts
 
-        parts.join(":")
+        code_to_urn(identifier.to_s, urn_language)
       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
+      private
 
-      def publisher_component(id = identifier)
-        return "iec" unless id&.publisher
+      # Hyphen-joined language codes (e.g. "en-fr"), or nil when unset.
+      def urn_language
+        return nil unless identifier.respond_to?(:languages)
 
-        copubs = id.copublishers || []
+        langs = identifier.languages
+        return nil unless langs&.any?
 
-        publishers = [id.publisher] + copubs
-        publishers.map(&:to_s).map(&:downcase).join("-")
+        langs.map(&:code).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
+      # 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
 
-      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
+      # 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
 
-      def urn_date_string(date)
-        return nil unless date
-
-        s = date.year.to_s
-        s += "-#{date.month}" if date.month
-        s
+      # 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

data/lib/pubid/iec/urn_parser.rb

@@ -2,55 +2,23 @@
 
 module Pubid
   module Iec
-    # Parses RFC 5141-bis compliant URNs into IEC identifiers
+    # Parses IEC URNs in the legacy positional format (relaton-data-iec ground
+    # truth):
     #
-    # URN format: urn:iec:std:{publisher}:{type}:{number}[-{part}]:{year}:{supplements}
+    #   urn:iec:std:{publisher}:{number}[-{part}]:{date}:{type}:{deliverable}:{language}[:{adjuncts}]
     #
     # 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
+    # - 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
-      # 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
@@ -62,227 +30,60 @@ 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 Errors::ParseError,
-                "Invalid IEC URN: #{urn}"
+          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
+        code, lang, all_parts = urn_to_code(urn)
+        raise Errors::ParseError, "Invalid IEC URN: #{urn}" unless code
 
-        # Parse edition if present (ed.N format)
-        edition = nil
-        if parts.first&.start_with?("ed.")
-          edition = parts.shift.sub("ed.", "").to_i
+        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
-
-        # 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)
+        id
       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]
+      # 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
-      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
+        [code, lang&.downcase, all_parts]
       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
+      # 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 the final identifier
-        builder = Pubid::Iec::Builder.new(Pubid::Iec::Scheme)
-        builder.build(base_hash)
+        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

data/lib/pubid/ieee/identifier.rb

@@ -7,6 +7,47 @@ module Pubid
         def parse(input)
           Identifiers::Base.parse(input)
         end
+
+        # Factory mirroring pubid 1.x's `Pubid::Ieee::Identifier.create` API.
+        # Dispatches via {Pubid::Ieee::Scheme.locate_identifier_klass_by_type_code}.
+        # Default subclass (no `type:`) is Identifiers::Standard — the
+        # canonical class produced by parsing typical IEEE identifiers.
+        def create(type: nil, **opts)
+          klass = type ?
+                  Scheme.locate_identifier_klass_by_type_code(type) :
+                  Identifiers::Standard
+          attrs = coerce_create_attrs(opts)
+          # ProjectDraftIdentifier renders the "P" prefix from typed_stage,
+          # not from `type`. Set both so the output matches a parsed form.
+          if klass == Identifiers::ProjectDraftIdentifier
+            attrs[:type] = "P"
+            attrs[:typed_stage] ||= Scheme.locate_typed_stage_by_abbr("P")
+          end
+          klass.new(**attrs)
+        end
+
+        private
+
+        def coerce_create_attrs(opts)
+          attrs = {}
+          attrs[:publisher] = opts[:publisher].to_s if opts[:publisher]
+          if opts[:copublisher]
+            attrs[:copublisher] =
+              Array(opts[:copublisher]).map(&:to_s)
+          end
+          # :code or :number alias
+          if (v = opts[:code] || opts[:number])
+            attrs[:code] = v.to_s
+          end
+          %i[year edition month day draft_status].each do |k|
+            v = opts[k]
+            attrs[k] = v.to_s unless v.nil?
+          end
+          attrs[:redline] = opts[:redline] if opts.key?(:redline)
+          # TODO(create-shim): amendments/corrigenda/revision_of/incorporates
+          # are nested Base relations; not yet wired through.
+          attrs
+        end
       end
     end
   end

data/lib/pubid/iho/identifier.rb

@@ -14,6 +14,48 @@ module Pubid
       rescue Parslet::ParseFailed => e
         raise "Failed to parse IHO identifier '#{identifier}': #{e.message}"
       end
+
+      # Factory that builds an IHO identifier from a hash of primitives.
+      #
+      # IHO identifiers are simpler than ISO/IEC: attributes are plain
+      # strings (no Component wrapping), so coercion just calls #to_s.
+      #
+      # Dispatch:
+      #   * `type:` accepts the type key (`:standard`, `:publication`,
+      #     `:miscellaneous`, `:bibliographic`, `:circular_letter`) or
+      #     the IHO series letter (`"S"`, `"P"`, `"M"`, `"B"`, `"C"`).
+      #   * Default is {Identifiers::Standard}.
+      #
+      # @param type [Symbol, String, nil]
+      # @param opts [Hash] :publisher (default "IHO"), :code, :appendix,
+      #   :part, :annex, :supplement, :version
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts))
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Standard if type.nil?
+
+        by_key = Scheme::IDENTIFIERS.to_h { |k| [k.type[:key], k] }
+        return by_key[type.to_sym] if by_key.key?(type.to_sym)
+
+        begin
+          Scheme.identifier_klass_for_type_letter(type.to_s.upcase)
+        rescue KeyError
+          raise ArgumentError, "Unknown IHO type: #{type.inspect}"
+        end
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {}
+        %i[publisher code appendix part annex supplement version].each do |k|
+          v = opts[k]
+          attrs[k] = v.to_s unless v.nil?
+        end
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end