pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/iec/components/vap_suffix.rb

@@ -0,0 +1,41 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    module Components
+      # VAP (Validation Assessment Programme) suffix codes
+      # Single Responsibility: Represents VAP validation status suffixes
+      class VapSuffix < Lutaml::Model::Serializable
+        # VAP suffix codes as defined by IEC
+        CODES = {
+          "CMV" => "Common Modifications and Variations",
+          "RLV" => "Relevant",
+          "SER" => "Serial",
+        }.freeze
+
+        attribute :code, :string
+
+        def validate!
+          unless CODES.key?(code)
+            raise ArgumentError,
+                  "Unknown VAP suffix code: #{code}. Valid codes: #{CODES.keys.join(', ')}"
+          end
+        end
+
+        def to_s
+          code
+        end
+
+        def full_name
+          CODES[code]
+        end
+
+        # VAP suffix appears after the main identifier with a space
+        def render_with_space
+          " #{code}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iec/identifier.rb

@@ -0,0 +1,256 @@
+require_relative "../identifier"
+# frozen_string_literal: true
+require_relative "../components/typed_stage"
+require_relative "../components/factory"
+
+module Pubid
+  module Iec
+    class Identifier < ::Pubid::Identifier
+      # Long-tail document types that `create` may build but which are not in
+      # Scheme.identifiers (the parse/build candidate set). Loaded lazily (not
+      # at require time) to avoid a circular load with identifiers/base.rb.
+      EXTRA_CREATE_KLASS_FILES = %w[
+        conformity_assessment technology_report white_paper
+        societal_technology_trend_report systems_reference_document
+        interpretation_sheet
+      ].freeze
+      def self.parse(string)
+        # Route URN strings to the URN parser (mirrors Iso::Identifier.parse)
+        if Pubid::FormatDetector.detect(string) == :urn
+          return Pubid::Iec::UrnParser.parse(string)
+        end
+
+        # Apply legacy update_codes normalization first, before any other preprocessing
+        normalized = Core::UpdateCodes.apply(string, :iec)
+        parsed = Pubid::Iec::Parser.new.parse(normalized)
+        if parsed.nil? || parsed.empty?
+          raise Pubid::Iec::Parser::ParseError,
+                "Invalid identifier format"
+        end
+
+        Pubid::Iec::Builder.new(Pubid::Iec::Scheme).build(parsed)
+      end
+
+      # Factory mirroring pubid 1.x's `Pubid::Iec::Identifier.create` API.
+      # See {Pubid::Iso::Identifier.create} for the shared design. Builds the
+      # IEC `Components::*` subclasses (not the base ones) and populates
+      # type/stage from the resolved TypedStage, so that a created identifier
+      # round-trips `==` against the same identifier produced by `parse`.
+      def self.create(type: nil, stage: nil, **opts)
+        # A VAP suffix (CSV/RLV/…) is the outermost wrapper around the base
+        # document (which may itself be amended); rebuild it first.
+        if (vap = opts.delete(:vap))
+          base = create(type: type, stage: stage, **opts)
+          return Identifiers::VapIdentifier.new(
+            base_identifier: base,
+            vap_suffix: Components::VapSuffix.new(code: Array(vap).first.to_s),
+          )
+        end
+
+        # Structured index rows carry amendments/corrigendums as a flat list
+        # alongside the base document's keys; rebuild the supplement wrapping
+        # the recursively-created base, mirroring what parse produces.
+        if (supp = extract_supplement(opts))
+          return build_supplement(supp, type: type, stage: stage, opts: opts)
+        end
+
+        # A nested base: holds the base document of a supplement whose own
+        # number/year sit at the top level (e.g. an Interpretation Sheet).
+        if (base_hash = opts.delete(:base))
+          return build_based_supplement(type: type, base_hash: base_hash,
+                                        opts: opts)
+        end
+
+        klass = resolve_create_class(type: type, stage: stage)
+        attrs = coerce_create_attrs(opts)
+        ts = resolve_create_typed_stage(klass, stage)
+        if ts
+          attrs[:typed_stage] = ts
+          # Parse derives `type` and `stage` from the TypedStage (see
+          # Builder#cast for :type_with_stage); mirror that here.
+          attrs[:type] ||= ts.to_type
+          attrs[:stage] ||= ts.to_stage
+        end
+        klass.new(**attrs)
+      end
+
+      # Pop a supplement spec off the flat opts hash, if present. Returns
+      # { klass:, entry: } or nil. Amendments take precedence over
+      # corrigendums for the (rare) consolidated rows that carry both.
+      def self.extract_supplement(opts)
+        if (amds = opts.delete(:amendments))
+          { klass: Identifiers::Amendment, entry: Array(amds).first }
+        elsif (cors = opts.delete(:corrigendums))
+          { klass: Identifiers::Corrigendum, entry: Array(cors).first }
+        end
+      end
+
+      # Build an Amendment/Corrigendum from { number:, year: } wrapping a base
+      # identifier created from the remaining opts (which may themselves carry
+      # a type, e.g. an amendment to a TR).
+      def self.build_supplement(supp, type:, stage:, opts:)
+        base = create(type: type, stage: stage, **opts)
+        klass = supp[:klass]
+        entry = supp[:entry] || {}
+        ts = klass::TYPED_STAGES.find { |t| t.stage_code.to_sym == :published }
+        attrs = { base_identifier: base, typed_stage: ts,
+                  type: ts.to_type, stage: ts.to_stage }
+        if (n = entry[:number])
+          attrs[:number] = Components::Code.new(number: n.to_s)
+        end
+        if (y = entry[:year])
+          attrs[:date] = ::Pubid::Components::Date.new(year: y.to_s)
+        end
+        klass.new(**attrs)
+      end
+
+      # Build a supplement whose base document is carried in a nested base:
+      # hash (e.g. type: "ISH"); the supplement's own number/year are the
+      # remaining top-level keys.
+      def self.build_based_supplement(type:, base_hash:, opts:)
+        klass = (type && locate_klass_by_type_or_short(type)) ||
+                Identifiers::InternationalStandard
+        base = create(**base_hash.transform_keys(&:to_sym))
+        attrs = coerce_create_attrs(opts)
+                .slice(:number, :part, :subpart, :date, :publisher, :copublishers)
+        attrs[:base_identifier] = base
+        if klass.const_defined?(:TYPED_STAGES) &&
+            (ts = klass::TYPED_STAGES.find { |t| t.stage_code.to_sym == :published })
+          attrs[:typed_stage] = ts
+          attrs[:type] ||= ts.to_type
+          attrs[:stage] ||= ts.to_stage
+        end
+        klass.new(**attrs)
+      end
+
+      # Coerce a 1.x-style attribute hash into IEC Component instances,
+      # matching what the parser/builder produces. Unknown keys are dropped.
+      def self.coerce_create_attrs(opts)
+        out = {}
+        if (v = opts[:publisher])
+          out[:publisher] = Components::Publisher.new(body: v.to_s)
+        end
+        if (copubs = opts[:copublishers] || opts[:copublisher])
+          out[:copublishers] =
+            Array(copubs).map { |c| Components::Publisher.new(body: c.to_s) }
+        end
+        if (v = opts[:number])
+          out[:number] = Components::Code.new(number: v.to_s)
+        end
+        # Indexes fold the subpart into a single "2-4" part string; parse
+        # keeps part and subpart separate, so split to match.
+        part, subpart = split_part(opts[:part], opts[:subpart])
+        out[:part] = Components::Code.new(number: part.to_s) unless part.nil?
+        out[:subpart] = Components::Code.new(number: subpart.to_s) unless subpart.nil?
+        if (v = opts[:year])
+          out[:date] = ::Pubid::Components::Date.new(year: v.to_s)
+        end
+        if (v = opts[:edition])
+          out[:edition] = ::Pubid::Components::Edition.new(number: v)
+        end
+        if (v = opts[:language])
+          out[:languages] = [::Pubid::Components::Language.new(code: v.to_s)]
+        end
+        out[:database] = true if opts[:database]
+        out
+      end
+
+      # Split a folded "2-4" part into [part, subpart], matching parse. A part
+      # without a dash (or an explicit subpart already supplied) is untouched.
+      def self.split_part(part, subpart)
+        return [nil, subpart] if part.nil?
+        if subpart.nil? && part.to_s.include?("-")
+          part.to_s.split("-", 2)
+        else
+          [part, subpart]
+        end
+      end
+
+      def self.resolve_create_class(type:, stage:)
+        if type && supplement_type?(type)
+          # Supplements are built from amendments:/corrigendums: data (which
+          # carry the supplement number/year); an explicit supplement `type:`
+          # alone has no base to wrap.
+          raise ArgumentError,
+                "#{type} requires a base_identifier; pass amendments:/" \
+                "corrigendums: instead of type:"
+        end
+
+        klass =
+          if type
+            locate_klass_by_type_or_short(type)
+          elsif stage
+            ts = safe_locate_typed_stage(stage)
+            ts && locate_klass_by_type_or_short(ts.type_code)
+          end
+        klass || Identifiers::InternationalStandard
+      end
+
+      # True when `type` names a supplement identifier (Amendment/Corrigendum/
+      # Fragment) by key, downcased key, or short abbreviation.
+      def self.supplement_type?(type)
+        t = type.to_s
+        Scheme.supplement_identifiers.any? do |k|
+          k.type[:key].to_s == t || k.type[:key].to_s == t.downcase ||
+            Array(k.type[:short]).map(&:to_s).include?(t)
+        end
+      end
+
+      # Structured indexes store `type:` as the registry key (:tr), an
+      # upper-cased abbreviation ("TR"), or a title ("Technology Report").
+      # Try each spelling, across every IEC identifier class (the create
+      # candidate set is wider than Scheme.identifiers).
+      def self.locate_klass_by_type_or_short(type)
+        t = type.to_s
+        all_create_klasses.detect { |k| k.type[:key].to_s == t } ||
+          all_create_klasses.detect { |k| k.type[:key].to_s == t.downcase } ||
+          all_create_klasses.detect { |k| Array(k.type[:short]).map(&:to_s).include?(t) } ||
+          all_create_klasses.detect { |k| k.type[:title].to_s == t }
+      end
+
+      # All IEC identifier classes that `create` may build, including the
+      # long-tail document types absent from Scheme.identifiers. Memoized;
+      # the extra classes are required here (not at load time) to dodge the
+      # circular require with identifiers/base.rb.
+      def self.all_create_klasses
+        @all_create_klasses ||= begin
+          extra = EXTRA_CREATE_KLASS_FILES.map do |f|
+            require_relative "identifiers/#{f}"
+            Identifiers.const_get(camelize_klass_file(f))
+          end
+          Scheme.identifiers + extra
+        end
+      end
+
+      def self.camelize_klass_file(file)
+        file.split("_").map(&:capitalize).join
+      end
+
+      # IEC Scheme raises ArgumentError on miss instead of returning nil;
+      # wrap so the same control flow works as in the ISO factory.
+      def self.safe_locate_typed_stage(abbr)
+        Scheme.locate_typed_stage_by_abbr(abbr.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      def self.resolve_create_typed_stage(klass, stage)
+        if stage
+          safe_locate_typed_stage(stage)
+        elsif klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES).find do |ts|
+            ts.stage_code.to_sym == :published
+          end
+        end
+      end
+      private_class_method :resolve_create_class,
+                           :safe_locate_typed_stage,
+                           :resolve_create_typed_stage, :coerce_create_attrs,
+                           :extract_supplement, :build_supplement,
+                           :build_based_supplement,
+                           :locate_klass_by_type_or_short, :all_create_klasses,
+                           :camelize_klass_file, :supplement_type?,
+                           :split_part
+    end
+  end
+end

data/lib/pubid/iec/identifiers/amendment.rb

@@ -0,0 +1,94 @@
+require_relative "../supplement_identifier"
+# frozen_string_literal: true
+require_relative "../../components/typed_stage"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Amendment Identifier
+      class Amendment < SupplementIdentifier
+        attribute :type, Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pwi_amd,
+            stage_code: :pwi,
+            type_code: :amd,
+            abbr: ["PWI Amd"],
+            name: "Preliminary Work Item Amendment",
+            harmonized_stages: %w[00.00 00.20 00.60 00.98 00.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :np_amd,
+            stage_code: :np,
+            type_code: :amd,
+            abbr: ["NP Amd"],
+            name: "New Proposal Amendment",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.98],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :anw_amd,
+            stage_code: :anw,
+            type_code: :amd,
+            abbr: ["ANW Amd"],
+            name: "Approved New Work Item Amendment",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :wd_amd,
+            stage_code: :wd,
+            type_code: :amd,
+            abbr: ["WD Amd"],
+            name: "Working Draft Amendment",
+            harmonized_stages: %w[20.20 20.60 20.98 20.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :cdamd,
+            stage_code: :cd,
+            type_code: :amd,
+            abbr: ["CDAM"],
+            short_abbr: "CDV",
+            long_abbr: "CD",
+            name: "Committee Draft Amendment",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :damd,
+            stage_code: :damd,
+            type_code: :amd,
+            abbr: ["DAM"],
+            short_abbr: "DAM",
+            long_abbr: "DAm",
+            name: "Draft Amendment",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.98 40.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :fdamd,
+            stage_code: :fdamd,
+            type_code: :amd,
+            abbr: ["FDAM", "PRF Amd"],
+            short_abbr: "FDIS",
+            long_abbr: "FDIS",
+            name: "Final Draft Amendment",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :pubamd,
+            stage_code: :published,
+            type_code: :amd,
+            abbr: ["Amd", "AMD"],
+            short_abbr: "AMD",
+            long_abbr: "Amd",
+            name: "Amendment",
+            harmonized_stages: %w[60.00 60.60 90.20 90.60 90.92 90.93 90.99
+                                  95.20 95.60 95.92 95.99],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :amd, title: "Amendment", short: "AMD" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iec/identifiers/base.rb

@@ -0,0 +1,82 @@
+require_relative "../single_identifier"
+# frozen_string_literal: true
+require_relative "../components/publisher"
+require_relative "../components/code"
+require_relative "../components/vap_suffix"
+require_relative "../components/trf_info"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Base class for all IEC identifiers
+      # Inherits from SingleIdentifier to get common functionality
+      # Single Responsibility: Common IEC identifier attributes and behavior
+      class Base < SingleIdentifier
+        # IEC-specific attributes
+        attribute :vap_suffix, Components::VapSuffix, default: -> {}
+        attribute :trf_info, Components::TrfInfo, default: -> {}
+        attribute :database, :boolean, default: -> { false }
+        attribute :fragment, :string, default: -> {}
+        attribute :version, :string, default: -> {}
+        attribute :decision_sheet, :string, default: -> {}
+
+        def to_s(_format = :short)
+          parts = []
+
+          # Publisher and type portion (from typed_stage) - uses inherited method
+          parts << publisher_portion
+
+          # Number portion (number with part/subpart)
+          parts << number_portion
+
+          # Edition if present - add space before edition
+          parts << " #{edition}" if edition&.number
+
+          # VAP suffix
+          parts << vap_suffix.render_with_space if vap_suffix
+
+          # Database flag
+          parts << " DB" if database
+
+          # All-parts marker — rendered the same as the generic
+          # HumanReadable renderer for parity (see Pubid::Renderers::HumanReadable#render).
+          parts << " (all parts)" if all_parts
+
+          parts.compact.join
+        end
+
+        def number_portion
+          return "" unless number
+
+          result = " #{number}"
+
+          # Add part if present
+          result += "-#{part}" if part && part.to_s != ""
+
+          # Add subpart if present
+          result += "-#{subpart}" if subpart && subpart.to_s != ""
+
+          # Add date if present
+          result += ":#{date.year}" if date
+
+          result
+        end
+
+        def self.type
+          raise NotImplementedError, "Subclass must implement self.type method"
+        end
+
+        # Validate IEC-specific constraints
+        def validate!
+          super if defined?(super)
+
+          # Validate VAP suffix if present
+          vap_suffix&.validate!
+
+          # Validate TRF info if present
+          trf_info&.validate! if trf_info && !trf_info.empty?
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iec/identifiers/component_specification.rb

@@ -0,0 +1,39 @@
+require_relative "base"
+require_relative "../../components/typed_stage"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Component Specification identifier class
+      # Single Responsibility: Represents IEC CS documents
+      class ComponentSpecification < Base
+        # Component Specifications have CS as type abbreviation
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :cs,
+            stage_code: :published,
+            type_code: :cs,
+            abbr: ["CS"],
+            name: "Component Specification",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :cs, title: "Component Specification", short: "CS" }
+        end
+
+        # Override publisher_portion to add CS
+        def publisher_portion
+          result = publisher.to_s
+
+          if typed_stage && typed_stage.abbreviation == "CS"
+            result += " CS"
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iec/identifiers/conformity_assessment.rb

@@ -0,0 +1,39 @@
+require_relative "base"
+require_relative "../../components/typed_stage"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Conformity Assessment identifier class
+      # Single Responsibility: Represents IEC CA documents
+      class ConformityAssessment < Base
+        # Conformity Assessment has CA as type abbreviation
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :ca,
+            stage_code: :published,
+            type_code: :ca,
+            abbr: ["CA"],
+            name: "Conformity Assessment",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :ca, title: "Conformity Assessment", short: "CA" }
+        end
+
+        # Override publisher_portion to add /CA
+        def publisher_portion
+          result = publisher.to_s
+
+          if typed_stage && typed_stage.abbreviation == "CA"
+            result += " CA"
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iec/identifiers/consolidated_identifier.rb

@@ -0,0 +1,82 @@
+require_relative "../identifier"
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Consolidated Identifier
+      # Single Responsibility: Represents a consolidated publication containing multiple documents
+      # Example: "IEC 60529:1989+AMD1:1999" contains [IS, AMD] as separate identifier objects
+      # This is MODEL-DRIVEN: stores the actual identifiers, not just renders with +
+      class ConsolidatedIdentifier < Identifier
+        attribute :identifiers, Identifier, polymorphic: true, collection: true
+
+        def to_s(lang: :en, lang_single: false, with_edition: false)
+          identifiers.map.with_index do |id, idx|
+            if idx.zero?
+              # First identifier renders normally
+              id.to_s(lang: lang, lang_single: lang_single,
+                      with_edition: with_edition)
+            elsif id.is_a?(Amendment)
+              # Subsequent identifiers render with + prefix
+              # For amendments, just show +AMDn:year part (or +AMDn if no date)
+              if id.date&.year && !id.date.year.empty?
+                "+AMD#{id.number}:#{id.date.year}"
+              else
+                "+AMD#{id.number}"
+              end
+            elsif id.is_a?(Corrigendum)
+              if id.date&.year && !id.date.year.empty?
+                "+COR#{id.number}:#{id.date.year}"
+              else
+                "+COR#{id.number}"
+              end
+            else
+              "+#{id.to_s(lang: lang, lang_single: lang_single,
+                          with_edition: with_edition)}"
+            end
+          end.join
+        end
+
+        # Delegate common attributes to first identifier (base document)
+        def publisher
+          identifiers&.first&.publisher
+        end
+
+        def copublishers
+          identifiers&.first&.copublishers
+        end
+
+        def code
+          identifiers&.first&.code
+        end
+
+        def number
+          identifiers&.first&.number
+        end
+
+        def date
+          identifiers&.first&.date
+        end
+
+        def stage
+          identifiers&.first&.stage
+        end
+
+        def typed_stage
+          identifiers&.first&.typed_stage
+        end
+
+        # Get the base document (first identifier)
+        def base_document
+          identifiers&.first
+        end
+
+        # Get all supplements (identifiers after first)
+        def supplements
+          identifiers&.drop(1) || []
+        end
+      end
+    end
+  end
+end