pubid 1.15.18 → 2.0.0.pre.alpha.1

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

@@ -0,0 +1,132 @@
+require_relative "base"
+# frozen_string_literal: true
+require_relative "../../components/typed_stage"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Technical Report identifier class
+      # Single Responsibility: Represents IEC Technical Report documents
+      class TechnicalReport < Base
+        # Convert v1 hash-based TYPED_STAGES to v2 object-based
+        # From gems/pubid-iec/lib/pubid/iec/identifier/technical_report.rb
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pwi_tr,
+            stage_code: :pwi,
+            type_code: :tr,
+            abbr: ["PWI TR"],
+            name: "Preliminary Work Item Technical Report",
+            harmonized_stages: %w[00.00 00.20 00.60 00.98 00.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :np_tr,
+            stage_code: :np,
+            type_code: :tr,
+            abbr: ["NP TR"],
+            name: "New Proposal Technical Report",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.98],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :anw_tr,
+            stage_code: :anw,
+            type_code: :tr,
+            abbr: ["ANW TR"],
+            name: "Approved New Work Item Technical Report",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :wd_tr,
+            stage_code: :wd,
+            type_code: :tr,
+            abbr: ["WD TR"],
+            name: "Working Draft Technical Report",
+            harmonized_stages: %w[20.20 20.60 20.98 20.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :cd_tr,
+            stage_code: :cd,
+            type_code: :tr,
+            abbr: ["CD TR"],
+            name: "Committee Draft Technical Report",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :dtr,
+            stage_code: :draft,
+            type_code: :tr,
+            abbr: ["DTR"],
+            name: "Draft Technical Report",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :tr,
+            stage_code: :published,
+            type_code: :tr,
+            abbr: ["TR"],
+            name: "Technical Report",
+            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
+
+        # Project stages specific to Technical Reports
+        # These are IEC-specific workflow stages
+        PROJECT_STAGES = {
+          adtr: {
+            abbr: "ADTR",
+            name: "Approved for DTR",
+            harmonized_stages: %w[40.99],
+          },
+          cdtr: {
+            abbr: "CDTR",
+            name: "Draft circulated as DTR",
+            harmonized_stages: %w[50.20],
+          },
+          dtrm: {
+            abbr: "DTRM",
+            name: "Rejected DTR to be discussed at meeting",
+            harmonized_stages: %w[50.92],
+          },
+          ndtr: {
+            abbr: "NDTR",
+            name: "DTR rejected",
+            harmonized_stages: %w[50.92],
+          },
+          prvdtr: {
+            abbr: "PRVDTR",
+            name: "Preparation of RVDTR",
+            harmonized_stages: %w[50.60],
+          },
+          tdtr: {
+            abbr: "TDTR",
+            name: "Translation of DTR",
+            harmonized_stages: %w[50.00],
+          },
+        }.freeze
+
+        def self.type
+          { key: :tr, title: "Technical Report", short: "TR" }
+        end
+
+        # Override publisher_portion to handle TR formatting
+        # If copublishers exist, use parent implementation
+        def publisher_portion
+          # If copublishers, delegate to parent (SingleIdentifier) which handles them
+          return super if copublishers&.any?
+
+          # No copublishers: simple TR formatting
+          result = publisher.to_s
+
+          if typed_stage
+            abbr = typed_stage.abbreviation
+            # For TR: always use space (IEC convention for ALL publishers)
+            result += " #{abbr}" unless abbr.empty?
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+require_relative "base"
+# frozen_string_literal: true
+require_relative "../../components/typed_stage"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Technical Specification identifier class
+      # Single Responsibility: Represents IEC Technical Specification documents
+      class TechnicalSpecification < Base
+        # Convert v1 hash-based TYPED_STAGES to v2 object-based
+        # From gems/pubid-iec/lib/pubid/iec/identifier/technical_specification.rb
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pwi_ts,
+            stage_code: :pwi,
+            type_code: :ts,
+            abbr: ["PWI TS"],
+            name: "Preliminary Work Item Technical Specification",
+            harmonized_stages: %w[00.00 00.20 00.60 00.98 00.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :np_ts,
+            stage_code: :np,
+            type_code: :ts,
+            abbr: ["NP TS"],
+            name: "New Proposal Technical Specification",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.98],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :anw_ts,
+            stage_code: :anw,
+            type_code: :ts,
+            abbr: ["ANW TS"],
+            name: "Approved New Work Item Technical Specification",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :wd_ts,
+            stage_code: :wd,
+            type_code: :ts,
+            abbr: ["WD TS"],
+            name: "Working Draft Technical Specification",
+            harmonized_stages: %w[20.20 20.60 20.98 20.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :cd_ts,
+            stage_code: :cd,
+            type_code: :ts,
+            abbr: ["CD TS"],
+            name: "Committee Draft Technical Specification",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :dts,
+            stage_code: :draft,
+            type_code: :ts,
+            abbr: ["DTS"],
+            name: "Draft Technical Specification",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          Pubid::Components::TypedStage.new(
+            code: :ts,
+            stage_code: :published,
+            type_code: :ts,
+            abbr: ["TS"],
+            name: "Technical Specification",
+            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
+
+        # Project stages specific to Technical Specifications
+        # These are IEC-specific workflow stages
+        PROJECT_STAGES = {
+          adts: {
+            abbr: "ADTS",
+            name: "Approved for DTS",
+            harmonized_stages: %w[40.99],
+          },
+          cdts: {
+            abbr: "CDTS",
+            name: "Draft circulated as DTS",
+            harmonized_stages: %w[50.20],
+          },
+          dtsm: {
+            abbr: "DTSM",
+            name: "Rejected DTS to be discussed at meeting",
+            harmonized_stages: %w[50.92],
+          },
+          ndts: {
+            abbr: "NDTS",
+            name: "DTS rejected",
+            harmonized_stages: %w[50.92],
+          },
+          prvdts: {
+            abbr: "PRVDTS",
+            name: "Preparation of RVDTS",
+            harmonized_stages: %w[50.60],
+          },
+          tdts: {
+            abbr: "TDTS",
+            name: "Translation of DTS",
+            harmonized_stages: %w[50.00],
+          },
+        }.freeze
+
+        def self.type
+          { key: :ts, title: "Technical Specification", short: "TS" }
+        end
+
+        # Override publisher_portion to handle TS formatting
+        # If copublishers exist, use parent implementation
+        def publisher_portion
+          # If copublishers, delegate to parent (SingleIdentifier) which handles them
+          return super if copublishers&.any?
+
+          # No copublishers: simple TS formatting
+          result = publisher.to_s
+
+          if typed_stage
+            abbr = typed_stage.abbreviation
+            # TS uses space for all stages
+            result += " #{abbr}" unless abbr.empty?
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,78 @@
+require_relative "base"
+# frozen_string_literal: true
+require_relative "../../components/typed_stage"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Test Report Form identifier class
+      # Single Responsibility: Represents IEC TRF documents
+      # Can embed CISPR identifiers for IECEE TRF format
+      class TestReportForm < Base
+        # TRF can embed a CISPR identifier (MODEL-DRIVEN)
+        attribute :cispr_identifier, Identifier, polymorphic: true, default: -> {
+        }
+
+        # TRF has type abbreviation for parsing
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :trf,
+            stage_code: :published,
+            type_code: :trf,
+            abbr: ["TRF"],
+            name: "Test Report Form",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :trf, title: "Test Report Form", short: "TRF" }
+        end
+
+        # Override publisher_portion to add TRF with space
+        def publisher_portion
+          result = publisher.to_s
+
+          if typed_stage && typed_stage.abbreviation == "TRF"
+            result += " TRF"
+          end
+
+          result
+        end
+
+        # TRF uses special rendering
+        def to_s(_format = :short)
+          parts = []
+
+          # Publisher and type portion
+          parts << publisher_portion
+
+          # If CISPR identifier embedded, render it with TRF date
+          if cispr_identifier
+            cispr_parts = []
+            cispr_parts << cispr_identifier.publisher.body
+
+            # Build number portion with part
+            num_str = cispr_identifier.number.to_s
+            num_str += "-#{cispr_identifier.part}" if cispr_identifier.part && cispr_identifier.part.to_s != ""
+            cispr_parts << num_str
+
+            # Join with space and add TRF year
+            cispr_str = cispr_parts.join(" ")
+            cispr_str += ":#{date.year}" if date
+
+            parts << " #{cispr_str}"
+          else
+            # Normal TRF: number portion
+            parts << number_portion
+          end
+
+          # TRF info if present (handles version, decision sheet, etc.)
+          parts << trf_info.to_s if trf_info && !trf_info.empty?
+
+          parts.compact.join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+require_relative "../identifier"
+# frozen_string_literal: true
+require_relative "../components/vap_suffix"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # VAP (Version/Compilation) Identifier
+      # Single Responsibility: Wraps another identifier with VAP type suffix
+      # Examples: "IEC 61666:2010+AMD1:2021 CSV"
+      class VapIdentifier < Identifier
+        attribute :base_identifier, Identifier, polymorphic: true
+        attribute :vap_suffix, Components::VapSuffix
+        attribute :edition, ::Pubid::Components::Edition, default: -> {}
+
+        # VAP types mapping
+        TYPE_MAP = {
+          "CSV" => "Consolidated version (with Supplements)",
+          "CMV" => "Compiled Maintenance Version",
+          "RLV" => "Redline Version (shows changes)",
+          "SER" => "Serial version",
+        }.freeze
+
+        def to_s(lang: :en, lang_single: false, with_edition: false)
+          parts = []
+
+          # Render base identifier WITHOUT edition (edition goes at VAP level)
+          parts << base_identifier.to_s(lang: lang, lang_single: lang_single,
+                                        with_edition: false)
+
+          # Add VAP suffix with space
+          if vap_suffix
+            parts << " #{vap_suffix}"
+          end
+
+          # Add edition after VAP suffix if present
+          parts << " #{edition}" if edition&.number
+
+          parts.compact.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
+          :vap
+        end
+
+        def stage
+          base_identifier&.stage
+        end
+
+        def typed_stage
+          base_identifier&.typed_stage
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,96 @@
+require_relative "base"
+# frozen_string_literal: true
+require_relative "../../components/stage"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Working Document identifier class
+      # Single Responsibility: Represents IEC Working Documents with TC attribution
+      # Also handles Working Programmes with PWI/PNW stage-first format
+      # Formats:
+      #   Working Programme: "PWI TR 100-36 ED1"
+      #   Working Document: "100/3705(F)/FDIS"
+      class WorkingDocument < Base
+        attribute :technical_committee, :string, default: -> {}
+        attribute :wd_number, :string, default: -> {}
+        attribute :wd_language, :string, default: -> {}
+        attribute :wd_stage, :string, default: -> {}
+        attribute :wp_stage, :string, default: -> {}
+        attribute :wp_type, :string, default: -> {}
+
+        # Working documents have no TYPED_STAGES - they use PROJECT_STAGES only
+        TYPED_STAGES = [].freeze
+
+        # Working document stages
+        PROJECT_STAGES = {}.freeze
+
+        def self.type
+          { key: :wd, title: "Working Document", short: "WD" }
+        end
+
+        # Return stage object for PWI/PNW stage
+        def stage
+          return nil unless wp_stage
+
+          # Map PWI/PNW to stage codes
+          stage_map = {
+            "PWI" => "pwi",
+            "PNW" => "pnw",
+          }
+          stage_code = stage_map[wp_stage]
+          return nil unless stage_code
+
+          @stage ||= ::Pubid::Components::Stage.new(stage_code: stage_code)
+        end
+
+        def to_s(_format = :short)
+          # Working Programme format: "PWI TR 100-36 ED1" or "IEC/PWI 60038"
+          if wp_stage
+            parts = []
+            # Include publisher if present (for IEC/PWI format)
+            if publisher
+              parts << publisher.body
+              if copublishers&.any?
+                parts << "/#{copublishers.map(&:body).join('/')}"
+              end
+              parts << "/"
+            end
+            parts << wp_stage
+            # Only add wp_type if it exists and is not empty/whitespace
+            if wp_type && !wp_type.strip.empty?
+              parts << " #{wp_type.strip}"
+            end
+
+            # Render full number with parts
+            if number
+              num_str = number.to_s
+              num_str += "-#{part}" if part && part.to_s != ""
+              num_str += "-#{subpart}" if subpart && subpart.to_s != ""
+              parts << " #{num_str}"
+            end
+
+            parts << " #{edition}" if edition&.number
+            return parts.join
+          end
+
+          # Working Document format: "100/3705(F)/FDIS"
+          parts = []
+
+          parts << technical_committee if technical_committee
+
+          # Number with optional language
+          if wd_number
+            num_part = wd_number.to_s
+            num_part += "(#{wd_language})" if wd_language
+            parts << num_part
+          end
+
+          parts << wd_stage if wd_stage
+
+          parts.join("/")
+        end
+      end
+    end
+  end
+end