pubid 1.15.17 → 2.0.0.pre.alpha.1

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,21 @@
+require_relative "../identifier"
+# frozen_string_literal: true
+require_relative "../components/typed_stage"
+
+module Pubid
+  module Iec
+    class Identifier < ::Pubid::Identifier
+      def self.parse(string)
+        # 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
+    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,78 @@
+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
+
+          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,86 @@
+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 type
+          :consolidated
+        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

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

@@ -0,0 +1,94 @@
+require_relative "../supplement_identifier"
+# frozen_string_literal: true
+require_relative "../../components/typed_stage"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Corrigendum Identifier
+      class Corrigendum < SupplementIdentifier
+        attribute :type, Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pwi_cor,
+            stage_code: :pwi,
+            type_code: :cor,
+            abbr: ["PWI Cor"],
+            name: "Preliminary Work Item Corrigendum",
+            harmonized_stages: %w[00.00 00.20 00.60 00.98 00.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :np_cor,
+            stage_code: :np,
+            type_code: :cor,
+            abbr: ["NP Cor"],
+            name: "New Proposal Corrigendum",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.98],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :anw_cor,
+            stage_code: :anw,
+            type_code: :cor,
+            abbr: ["ANW Cor"],
+            name: "Approved New Work Item Corrigendum",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :wdcor,
+            stage_code: :wd,
+            type_code: :cor,
+            abbr: ["WDCor"],
+            name: "Working Draft Corrigendum",
+            harmonized_stages: %w[20.20 20.60 20.98 20.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :cdcor,
+            stage_code: :cd,
+            type_code: :cor,
+            abbr: ["CDCor"],
+            short_abbr: "CDCor",
+            long_abbr: "CD Cor",
+            name: "Committee Draft Corrigendum",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :dcor,
+            stage_code: :dcor,
+            type_code: :cor,
+            abbr: ["DCOR"],
+            short_abbr: "DCOR",
+            long_abbr: "DCor",
+            name: "Draft Corrigendum",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.98 40.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :fdcor,
+            stage_code: :fdcor,
+            type_code: :cor,
+            abbr: ["FDCOR", "PRF Cor"],
+            short_abbr: "FDCOR",
+            long_abbr: "FDCor",
+            name: "Final Draft Corrigendum",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :pubcor,
+            stage_code: :published,
+            type_code: :cor,
+            abbr: ["Cor", "COR"],
+            short_abbr: "COR",
+            long_abbr: "Cor",
+            name: "Corrigendum",
+            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: :cor, title: "Corrigendum", short: "COR" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+require_relative "../identifier"
+# frozen_string_literal: true
+require_relative "../../components/typed_stage"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Fragment Identifier
+      # Single Responsibility: Represents a specific fragment/part within an Amendment or Corrigendum
+      # Example: "IEC 60050-191/AMD2/FRAG2 ED1" = Fragment 2 of Amendment 2
+      # Fragments are independently approved and have their own lifecycle stages.
+      class FragmentIdentifier < Identifier
+        attribute :base_identifier, Identifier, polymorphic: true
+        attribute :fragment_number, :string
+        attribute :edition, ::Pubid::Components::Edition, default: -> {}
+        attribute :typed_stage, ::Pubid::Components::TypedStage
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pwi_frag,
+            stage_code: :pwi,
+            type_code: :frag,
+            abbr: ["PWI Frag"],
+            name: "Preliminary Work Item Fragment",
+            harmonized_stages: %w[00.00 00.20 00.60 00.98 00.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :np_frag,
+            stage_code: :np,
+            type_code: :frag,
+            abbr: ["NP Frag"],
+            name: "New Proposal Fragment",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.98],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :anw_frag,
+            stage_code: :anw,
+            type_code: :frag,
+            abbr: ["ANW Frag"],
+            name: "Approved New Work Item Fragment",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :wd_frag,
+            stage_code: :wd,
+            type_code: :frag,
+            abbr: ["WD Frag"],
+            name: "Working Draft Fragment",
+            harmonized_stages: %w[20.20 20.60 20.98 20.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :cdfrag,
+            stage_code: :cd,
+            type_code: :frag,
+            abbr: ["CDFRAG"],
+            name: "Committee Draft Fragment",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :dfrag,
+            stage_code: :dfrag,
+            type_code: :frag,
+            abbr: ["DFRAG"],
+            name: "Draft Fragment",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.98 40.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :fdfrag,
+            stage_code: :fdfrag,
+            type_code: :frag,
+            abbr: ["FDFRAG", "PRF Frag"],
+            name: "Final Draft Fragment",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :frag,
+            stage_code: :published,
+            type_code: :frag,
+            abbr: ["FRAG"],
+            name: "Fragment",
+            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: :frag, title: "Fragment", short: "FRAG" }
+        end
+
+        def to_s(lang: :en, lang_single: false, with_edition: false)
+          parts = []
+
+          # Render base identifier (the amendment/corrigendum)
+          parts << base_identifier.to_s(lang: lang, lang_single: lang_single,
+                                        with_edition: with_edition)
+
+          # Add fragment notation /FRAGN or /FRAGCN depending on base type
+          parts << if base_identifier.is_a?(Identifiers::Corrigendum)
+                     "/FRAGC#{fragment_number}"
+                   else
+                     "/FRAG#{fragment_number}"
+                   end
+
+          # Add edition if present
+          parts << " #{edition}" if edition&.number
+
+          parts.join
+        end
+
+        # Delegate common attributes to base_identifier
+        def publisher
+          base_identifier&.publisher
+        end
+
+        def copublishers
+          base_identifier&.copublishers
+        end
+
+        def code
+          base_identifier&.code
+        end
+
+        def number
+          base_identifier&.number
+        end
+
+        def date
+          base_identifier&.date
+        end
+
+        def type
+          :frag
+        end
+
+        def stage
+          typed_stage&.to_stage || base_identifier&.stage
+        end
+      end
+    end
+  end
+end