pubid 1.15.19 → 2.0.0.pre.alpha.1

data/lib/pubid/ieee/identifiers/csa_dual_published.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # CSA dual published identifier
+      # Represents IEEE/CSA dual published standards
+      # Example: IEEE Std 844.1-2017/CSA C22.2 No. 293.1-17
+      class CsaDualPublished < Base
+        attribute :ieee_identifier, Base
+        # CSA identifier is stored as-is (not a Lutaml model type)
+        attr_accessor :csa_identifier
+
+        # Delegate common attributes to ieee_identifier
+        def publisher
+          ieee_identifier.publisher
+        end
+
+        def copublisher
+          ieee_identifier.copublisher
+        end
+
+        def code
+          ieee_identifier.code
+        end
+
+        def year
+          ieee_identifier.year
+        end
+
+        def typed_stage
+          ieee_identifier.typed_stage
+        end
+
+        def to_s
+          # Format: IEEE_IDENTIFIER/CSA CSA_IDENTIFIER
+          # The CSA identifier should render with "CSA" prefix
+          csa_str = csa_identifier.to_s
+          # Ensure CSA prefix is present
+          csa_str = "CSA #{csa_str}" unless csa_str.start_with?("CSA", "CAN/")
+
+          "#{ieee_identifier}/#{csa_str}"
+        end
+
+        def self.parse(string)
+          Base.parse(string)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/dual_identifier.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Dual Identifier - wraps two identifiers connected with "and"
+      # Example: "ANSI C37.61-1973 and IEEE Std 321-1973"
+      class DualIdentifier < Base
+        attribute :first_identifier, Base, polymorphic: true
+        attribute :second_identifier, Base, polymorphic: true
+
+        def to_s
+          "#{first_identifier} and #{second_identifier}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/dual_published.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Dual Published Identifier
+      # Document jointly published by two organizations
+      # Example: "ANSI C37.61-1973 and IEEE Std 321-1973"
+      # This means the document was published together by both organizations
+      class DualPublished < Base
+        # First organization's identifier
+        attribute :first_identifier, Base, polymorphic: true
+
+        # Second organization's identifier
+        attribute :second_identifier, Base, polymorphic: true
+
+        def to_s
+          "#{first_identifier} and #{second_identifier}"
+        end
+
+        def publisher
+          # Return array of both publishers
+          [first_identifier&.publisher, second_identifier&.publisher].compact
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/iec_ieee_copublished.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # IEC/IEEE Copublished Identifier - represents standards copublished by IEC and IEEE
+      # Example: "IEC/IEEE 60079-30-2/D5 IEC:2013 (10/07)"
+      class IecIeeeCopublished < Base
+        attribute :iec_identifier, Base, polymorphic: true
+        attribute :ieee_identifier, Base, polymorphic: true
+        attribute :copublished_number, :string  # The shared number like "60079-30-2"
+        attribute :draft_info, :string          # Draft information like "/D5"
+        attribute :iec_year, :string            # IEC year like "2013"
+        attribute :date_info, :string           # Date information like "(10/07)"
+
+        def to_s
+          result = "IEC/IEEE"
+          result += " #{copublished_number}" if copublished_number
+          result += draft_info if draft_info
+          result += " IEC:#{iec_year}" if iec_year
+          result += " #{date_info}" if date_info
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/interpretation_identifier.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Interpretation identifier for IEEE standards
+      # Represents an interpretation sheet or clarification
+      # Example: IEEE Std 1076/INT-1991, IEEE Std 1003.1-1988/INT
+      class InterpretationIdentifier < SupplementIdentifier
+        attribute :int_year, :string
+
+        # TYPED_STAGES for interpretation
+        # Interpretation uses "INT" abbreviation
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            abbr: ["INT"],
+            type_code: "interpretation",
+            stage_code: "published",
+          ),
+        ].freeze
+
+        def to_s
+          return base_identifier.to_s unless base_identifier
+
+          # Format: BASE/INT or BASE/INT-YEAR
+          result = base_identifier.to_s
+          result += "/INT"
+          result += "-#{int_year}" if int_year
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/joint_development.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Handles ISO/IEC/IEEE joint development identifiers
+      # Supports bidirectional format conversion between IEEE and ISO representations
+      #
+      # Joint development standards can be represented in two formats based on lead party:
+      #
+      # IEEE-led Format (lead_party: "IEEE"):
+      #   ISO/IEC/IEEE P26511/D8-2018
+      #   - Publishers: ISO/IEC/IEEE (slash-separated)
+      #   - Lead party: IEEE (drives development)
+      #   - P prefix indicates IEEE project (draft)
+      #   - /D8 indicates IEEE draft notation
+      #   - Dash before year
+      #
+      # ISO-led Format (lead_party: "ISO"):
+      #   ISO/IEC/IEEE FDIS 26511:2018
+      #   - Publishers: ISO/IEC/IEEE (slash-separated)
+      #   - Lead party: ISO (drives development)
+      #   - ISO stage code (FDIS) instead of P/D notation
+      #   - Colon before year
+      #
+      # Key principles:
+      # - Lead party determines canonical format
+      # - NO equivalence mapping (as per IEEE staff guidance)
+      # - "P" prefix means IEEE project (any stage)
+      # - ISO stages and IEEE drafts can coexist but are not equivalent
+      # - Format conversion preserves semantic meaning within each system
+      class JointDevelopment < Base
+        attribute :publishers, :string, collection: true
+        attribute :lead_party, :string              # "IEEE", "ISO", "IEC", etc.
+        attribute :code, :string
+        attribute :typed_stage, Components::TypedStage
+        attribute :year, :string
+        attribute :iso_stage, :string               # For ISO stage if present
+        attribute :ieee_draft, :string              # For IEEE P/D notation if present
+
+        def initialize(**args)
+          # Call super FIRST to initialize Lutaml::Model attributes
+          super
+
+          # Then handle typed_stage
+          if args[:typed_stage].is_a?(Components::TypedStage)
+            self.typed_stage = args[:typed_stage]
+          end
+
+          # Set publishers
+          if args[:publishers]
+            self.publishers = args[:publishers]
+          elsif args[:publisher] && args[:copublisher]
+            # Combine publisher and copublisher into publishers array
+            self.publishers = [args[:publisher], *args[:copublisher]].compact
+          end
+
+          # Set lead_party if not provided - default to first publisher
+          if args[:lead_party]
+            self.lead_party = args[:lead_party]
+          elsif publishers && !publishers.empty?
+            # Lead party defaults to first publisher if not explicitly set
+            # Builder should override this with detected lead party
+            self.lead_party = publishers.first
+          end
+        end
+
+        # Canonical format based on lead party
+        # @return [Symbol] :ieee or :iso
+        def canonical_format
+          case lead_party
+          when "IEEE", "AIEE"
+            :ieee
+          when "ISO", "IEC"
+            :iso
+          else
+            :ieee # default to IEEE format
+          end
+        end
+
+        # Convert to string representation
+        # @param format [Symbol] :ieee or :iso (defaults to canonical_format)
+        # @return [String] formatted identifier
+        def to_s(format: canonical_format)
+          case format
+          when :iso
+            to_iso_format
+          when :ieee
+            to_ieee_format
+          else
+            to_ieee_format
+          end
+        end
+
+        private
+
+        # Convert to ISO format representation
+        # ISO/IEC/IEEE FDIS 26511:2018
+        # @return [String] ISO format string
+        def to_iso_format
+          parts = []
+
+          # Publishers (slash-separated)
+          parts << publishers.join("/") if publishers && !publishers.empty?
+
+          # ISO stage code (only if this was originally ISO-led)
+          # For IEEE-led conversions, we skip the stage since we don't have ISO equivalent
+          if lead_party == "ISO" && (typed_stage || iso_stage)
+            if typed_stage
+              parts << typed_stage.to_iso_format
+            elsif iso_stage
+              parts << iso_stage
+            end
+          end
+
+          # Code (NO P prefix in ISO format, NO draft notation)
+          code_str = code.to_s.gsub(/^P/, "")
+          parts << code_str if code_str && !code_str.empty?
+
+          # Join with space and add year with colon
+          result = parts.join(" ")
+          result += ":#{year}" if year
+
+          result
+        end
+
+        # Convert to IEEE format representation
+        # ISO/IEC/IEEE P26511/D8-2018
+        # @return [String] IEEE format string
+        def to_ieee_format
+          parts = []
+
+          # Publishers (slash-separated)
+          parts << publishers.join("/") if publishers && !publishers.empty?
+
+          # Build code part
+          code_str = code.to_s.gsub(/^P/, "") # Remove any existing P first
+
+          # Add P prefix for projects (IEEE format always shows P for drafts)
+          if typed_stage&.project_status || type == "P"
+            code_str = "P#{code_str}"
+          end
+
+          # Add IEEE draft notation if available (e.g., /D8)
+          if ieee_draft
+            code_str += "/#{ieee_draft}"
+          elsif typed_stage&.ieee_draft_equivalent
+            code_str += "/#{typed_stage.ieee_draft_equivalent}"
+          end
+
+          parts << code_str if code_str && !code_str.empty?
+
+          # Join with space and add year with dash
+          result = parts.join(" ")
+          result += "-#{year}" if year
+
+          result
+        end
+
+        # Override to ensure proper publisher handling
+        def publisher
+          publishers&.first || super
+        end
+
+        # Override to ensure proper copublisher handling
+        def copublisher
+          publishers&.drop(1) || super
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/multi_numbered_identifier.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Multi-Numbered Identifier
+      # Represents a single document published under multiple numbers
+      # Examples:
+      # - "IEEE Std 1299/C62.22.1-1996" (same document, two numbers)
+      # - "IEEE Std 960-1989, Std 1177-1989" (same document, two numbers)
+      class MultiNumberedIdentifier < Base
+        # Primary identifier (main IEEE standard number)
+        # Stored as-is (Lutaml model type checking doesn't work with polymorphic identifiers)
+        attr_accessor :primary_identifier
+
+        # Secondary identifier (additional number for same document)
+        attr_accessor :secondary_identifier
+
+        def to_s
+          # Format: PRIMARY/SECONDARY or PRIMARY, SECONDARY
+          # The format depends on the original input
+          return primary_identifier.to_s unless secondary_identifier
+
+          # Check if the secondary identifier starts with "C" (like C62.22.1)
+          # If so, use slash format (cross-reference style)
+          secondary_code = secondary_identifier.code.to_s
+          if secondary_code.start_with?("C") && secondary_code.match?(/^C\d+\./)
+            # Cross-reference format: IEEE Std 1299/C62.22.1-1996
+            "#{primary_identifier}/#{secondary_identifier}"
+          else
+            # Comma format: IEEE Std 960-1989, Std 1177-1989
+            # But we normalize to "and" format for consistency
+            "#{primary_identifier} and #{secondary_identifier}"
+          end
+        end
+
+        def publisher
+          primary_identifier&.publisher
+        end
+
+        def code
+          primary_identifier&.code
+        end
+
+        def year
+          primary_identifier&.year
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/nesc/base.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ieee
+    module Identifiers
+      module Nesc
+        # Base class for National Electrical Safety Code (NESC) identifiers
+        #
+        # NESC is published by IEEE Standards Association and covers electrical
+        # safety standards for utilities and communication systems.
+        #
+        # @example Standard format
+        #   nesc = Pubid::Ieee.parse("C2-1997 National Electric Safety Code")
+        #   nesc.code.value  # => "C2"
+        #   nesc.year.year   # => 1997
+        #
+        # @example Handbook format
+        #   nesc = Pubid::Ieee.parse("2017 NESC Handbook, Premier Edition")
+        #   nesc.year.year   # => 2017
+        #   nesc.variant     # => "Handbook"
+        #   nesc.edition     # => "Premier Edition"
+        class Base < Lutaml::Model::Serializable
+          attribute :code, Pubid::Ieee::Components::Code # "C2" code designation
+          attribute :year, Pubid::Components::Date # Publication year
+          attribute :variant, :string              # Handbook, Redline, etc.
+          attribute :edition, :string              # Edition notation
+          attribute :draft, :boolean               # Draft flag
+          attribute :month, :string                # For draft identifiers
+
+          # Publisher portion for NESC identifiers
+          #
+          # @return [String] Always returns "NESC"
+          def publisher_portion
+            "NESC"
+          end
+
+          # Base rendering - override in subclasses
+          #
+          # @return [String] String representation
+          def to_s
+            parts = []
+            if code && year
+              parts << "#{code}-#{year.year}"
+            elsif year
+              parts << year.year.to_s
+            end
+            parts << "National Electrical Safety Code"
+            parts.join(" ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/nesc/draft.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      module Nesc
+        # Draft NESC identifier
+        #
+        # Represents draft versions of the National Electrical Safety Code
+        # that are under development or review.
+        #
+        # @example
+        #   nesc = Pubid::Ieee.parse("Draft National Electrical Safety Code, January 2016")
+        #   nesc.to_s  # => "Draft National Electrical Safety Code, January 2016"
+        class Draft < Base
+          # Render draft identifier
+          #
+          # @return [String] Draft format with optional month and year
+          def to_s
+            parts = ["Draft National Electrical Safety Code"]
+            parts << ", #{month} #{year.year}" if month && year
+            parts.join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/nesc/handbook.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      module Nesc
+        # NESC Handbook identifier
+        #
+        # Represents NESC Handbook publications which provide comprehensive
+        # guidance and interpretation of the National Electrical Safety Code.
+        #
+        # @example Basic handbook
+        #   nesc = Pubid::Ieee.parse("2012 NESC Handbook")
+        #   nesc.to_s  # => "2012 NESC Handbook"
+        #
+        # @example With edition
+        #   nesc = Pubid::Ieee.parse("2017 NESC Handbook, Premier Edition")
+        #   nesc.to_s  # => "2017 NESC Handbook, Premier Edition"
+        class Handbook < Base
+          # Render handbook identifier
+          #
+          # @return [String] YYYY NESC Handbook format with optional edition
+          def to_s
+            parts = ["#{year.year} NESC Handbook"]
+            parts << ", #{edition}" if edition
+            parts.join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/nesc/redline.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      module Nesc
+        # NESC Redline identifier
+        #
+        # Represents redline versions of NESC which show changes from
+        # previous editions with tracked changes highlighted.
+        #
+        # @example
+        #   nesc = Pubid::Ieee.parse("2017 NESC Redline")
+        #   nesc.to_s  # => "2017 NESC Redline"
+        class Redline < Base
+          # Render redline identifier
+          #
+          # @return [String] YYYY NESC Redline format
+          def to_s
+            "#{year.year} NESC Redline"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/nesc/standard.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      module Nesc
+        # Standard NESC identifier with C2-YYYY format
+        #
+        # Represents the standard National Electrical Safety Code publications
+        # using the C2 designation followed by publication year.
+        #
+        # @example
+        #   nesc = Pubid::Ieee.parse("C2-1997 National Electric Safety Code")
+        #   nesc.to_s  # => "C2-1997 National Electrical Safety Code"
+        class Standard < Base
+          # Render standard NESC identifier
+          #
+          # @return [String] C2-YYYY format
+          def to_s
+            "C2-#{year.year} National Electrical Safety Code"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/nesc.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      module Nesc
+        autoload :Base, "#{__dir__}/nesc/base"
+        autoload :Draft, "#{__dir__}/nesc/draft"
+        autoload :Handbook, "#{__dir__}/nesc/handbook"
+        autoload :Redline, "#{__dir__}/nesc/redline"
+        autoload :Standard, "#{__dir__}/nesc/standard"
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/parenthetical_identifier.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Parenthetical Identifier - wraps identifier with parenthetical annotation
+      # Example: "IEEE Standard No 18-1968 (ANSI C55.1-1968)"
+      class ParentheticalIdentifier < Base
+        attribute :base_identifier, Base, polymorphic: true
+        attribute :parenthetical_identifier, Base, polymorphic: true
+
+        def to_s
+          result = base_identifier.to_s
+          result += " (#{parenthetical_identifier})" if parenthetical_identifier
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/project_draft_identifier.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Project Draft Identifier
+      # Format: "IEEE P1234/D5, July 2019"
+      # where P1234 is the project number and D5 is the draft version
+      # This is distinct from a StandardIdentifier - the "P" indicates project status,
+      # not a code prefix like "C" in "C57.12"
+      class ProjectDraftIdentifier < Base
+        # Override initialize to strip "P" prefix from code before creating Code object
+        # The "P" is reflected in the typed_stage, not in the Code component itself
+        def initialize(**args)
+          # If code is provided with "P" prefix (e.g., "P1234"), strip it
+          if args[:code].is_a?(String) && args[:code].start_with?("P")
+            args[:code] = args[:code][1..] # Strip leading "P"
+          end
+
+          # Call parent initialize with modified code
+          super
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/redlined_standard.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Redlined Standard Identifier
+      # IEEE standard with optional revision note, marked as redline
+      # Example: "IEEE Std 1018-2013 (Revison of IEEE Std 1018-2004) - Redline"
+      # Contains: base standard + optional revision standard + redline flag
+      class RedlinedStandard < Base
+        # The current standard identifier
+        attribute :base_identifier, Base, polymorphic: true
+
+        # Optional: the standard this revises
+        attribute :revision_of, Base, polymorphic: true
+
+        # Redline flag (always true for this class)
+        attribute :redline, :boolean, default: -> { true }
+
+        def to_s
+          result = base_identifier.to_s
+          result += " (Revision of #{revision_of})" if revision_of
+          result += " - Redline" if redline
+          result
+        end
+
+        def publisher
+          base_identifier&.publisher || "IEEE"
+        end
+      end
+    end
+  end
+end