pubid 1.15.21 → 2.0.0.alpha.10

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

@@ -0,0 +1,43 @@
+# 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 NESC, June 2011")
+        #   nesc.to_s
+        #   # => "Draft National Electrical Safety Code, June 2011"
+        #
+        # NOTE: the spelled-out "Draft National Electrical Safety Code, …" form
+        # is claimed by the generic IEEE grammar before it reaches the NESC
+        # sub-parser, so it does not currently build this class. Pre-existing
+        # dispatcher gap, pinned in spec/pubid/ieee/ire_nesc_roundtrip_spec.rb.
+        class Draft < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-draft"
+          end
+
+          # Render draft identifier
+          #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
+          # @return [String] Draft format with optional month and year
+          def to_s(trademark: false, **opts)
+            parts = ["Draft National Electrical Safety Code"]
+            parts << ", #{month} #{year}" if month && year
+            result = parts.join
+            result += trademark_symbol if trademark
+            annotate_plain_render(result, **opts)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      module Nesc
+        # A plain year-first NESC edition — the National Electrical Safety Code
+        # itself, referenced by publication year rather than by its C2 code.
+        #
+        # @example
+        #   nesc = Pubid::Ieee.parse(
+        #     "2017 National Electrical Safety Code(R) (NESC(R))",
+        #   )
+        #   nesc.to_s
+        #   # => "IEEE Std 2017 National Electrical Safety Code(R) (NESC(R))"
+        #
+        # Rendering is Nesc::Base's; this class exists so that the builder never
+        # instantiates the abstract Base. Only concrete leaves may carry the
+        # CodeNumber mixin's `:string` `number` (see the mixin's notes on the
+        # multi-flavor attribute-resolution landmine), and every identifier that
+        # can be a `#root` needs a non-empty `number` for the relaton index.
+        class Edition < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-edition"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# 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  # => "IEEE Std 2012 NESC Handbook"
+        #
+        # @example With edition
+        #   nesc = Pubid::Ieee.parse("2017 NESC Handbook, Premier Edition")
+        #   nesc.to_s  # => "IEEE Std 2017 NESC Handbook, Premier Edition"
+        class Handbook < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-handbook"
+          end
+
+          # Render handbook identifier
+          #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
+          # @return [String] YYYY NESC Handbook format with optional edition
+          def to_s(trademark: false, **opts)
+            abbr = "NESC"
+            abbr += "(R)" if registered
+            parts = [["IEEE Std", year, "#{abbr} Handbook"].compact.join(" ")]
+            parts << ", #{edition}" if edition
+            result = parts.join
+            result += trademark_symbol if trademark
+            annotate_plain_render(result, **opts)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# 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
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-redline"
+          end
+
+          # Render redline identifier
+          #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
+          # @return [String] YYYY NESC Redline format
+          def to_s(trademark: false, **opts)
+            result = [year, "NESC Redline"].compact.join(" ")
+            result += trademark_symbol if trademark
+            annotate_plain_render(result, **opts)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# 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
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          # Distinct from Identifiers::Standard, whose derived polymorphic name
+          # is also "pubid:ieee:standard".
+          def self.polymorphic_name
+            "pubid:ieee:nesc-standard"
+          end
+
+          # Render standard NESC identifier
+          #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
+          # @return [String] C2-YYYY format (bare "C2" when the year is absent,
+          #   e.g. a partial reference produced by `#exclude(:year)`)
+          def to_s(trademark: false, **opts)
+            # Unlike the year-first NESC editions, this form renders a code, so
+            # the mark goes after it and before the year — as everywhere else.
+            code_part = "C2"
+            code_part += trademark_symbol if trademark
+            code_part += "-#{year}" if year
+            annotate_plain_render("#{code_part} National Electrical Safety Code", **opts)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      module Nesc
+        autoload :Base, "#{__dir__}/nesc/base"
+        autoload :Draft, "#{__dir__}/nesc/draft"
+        autoload :Edition, "#{__dir__}/nesc/edition"
+        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,14 @@
+# 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 < Identifier
+        attribute :base, Identifier, polymorphic: true
+        attribute :parenthetical_identifier, Identifier, polymorphic: true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# 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 < Identifier
+        # Reliable string `number` for relaton's index key (see CodeNumber).
+        # Its #initialize `super` chains through CodeNumber, which sets `number`
+        # from the (P-stripped) code after the parent builds code_obj.
+        include CodeNumber
+
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            abbr: ["P"],
+            stage_code: "draft",
+            type_code: "draft",
+            ieee_draft_equivalent: "P",
+            approval_status: "unapproved",
+            project_status: true,
+          ),
+        ].freeze
+
+        def self.type
+          { key: :P, title: "Project Draft", short: "P" }
+        end
+
+        # 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. Accepts keyword args or a single positional hash (the
+        # base #exclude/matching rebuild passes the latter).
+        def initialize(args = {}, **kwargs)
+          args = kwargs.empty? ? args.dup : args.merge(kwargs)
+          # 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 (positional hash)
+          super(args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# 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 < Identifier
+        # The current standard identifier
+        attribute :base, Identifier, polymorphic: true
+
+        # Optional: the standard this revises
+        attribute :revision_of, Identifier, polymorphic: true
+
+        # Redline flag (always true for this class)
+        attribute :redline, :boolean, default: -> { true }
+
+        def publisher
+          base&.publisher || "IEEE"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # SI Standard (Système International) identifier
+      # IEEE/ASTM SI standards for metric system
+      # Handles both:
+      # - SI: Published standards (IEEE/ASTM SI 10-1997)
+      # - PSI: Proposed SI (drafts: IEEE/ASTM PSI 10/D2, October 2015)
+      class SiStandard < Identifier
+        # Reliable string `number` for relaton's index key (see CodeNumber).
+        include CodeNumber
+
+        # TYPED_STAGES for SI standards
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            abbr: ["SI"],
+            type_code: "SI",
+            stage_code: "published",
+          ),
+          Components::TypedStage.new(
+            abbr: ["PSI"],
+            type_code: "SI",
+            stage_code: "draft",
+          ),
+        ].freeze
+
+        # SI standards always have IEEE/ASTM publisher
+        # Format: "IEEE/ASTM SI 10-1997" (published)
+        #     or: "IEEE/ASTM PSI 10/D2, October 2015" (draft)
+
+        # Use proper Draft component (Lutaml::Model object)
+        attr_accessor :draft_obj
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Standard identifier for IEEE standards
+      #
+      # Represents published IEEE standards with the standard format:
+      # "IEEE Std XXX-YYYY"
+      #
+      # @example Standard IEEE identifier
+      #   std = Pubid::Ieee.parse("IEEE Std 802.3-2018")
+      #   std.code.to_s  # => "802.3"
+      #   std.year       # => "2018"
+      #
+      # @example With co-publisher
+      #   std = Pubid::Ieee.parse("ANSI/IEEE Std 500-1984")
+      #   std.publisher        # => "IEEE"
+      #   std.copublisher     # => ["ANSI"]
+      class Standard < Identifier
+        # Reliable string `number` for relaton's index key (see CodeNumber).
+        include CodeNumber
+
+        # TYPED_STAGES for published IEEE standards
+        # Standards use "Std" abbreviation for published state
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            abbr: ["Std"],
+            type_code: "standard",
+            stage_code: "published",
+          ),
+        ].freeze
+
+        def self.type
+          { key: :std, web: :standard, title: "Standard", short: "Std" }
+        end
+
+        # Render standard IEEE format
+        #
+        # @return [String] IEEE Std XXX-YYYY format
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Identifier class for supplement identifiers (amendments, corrigenda, interpretations, etc.)
+      # Supplements modify or add to a base document
+      class SupplementIdentifier < Identifier
+        attribute :base, Identifier, polymorphic: true
+
+        # Delegate publisher to base
+        def publisher
+          base&.publisher
+        end
+
+        # Delegate code to base if not overridden
+        def code
+          base&.code
+        end
+
+        # `publisher` is a pure delegation to `base`, so it must never be
+        # serialized independently on the wrapper. lutaml's default-tracking
+        # otherwise emits it asymmetrically — omitted on the parse path (the
+        # wrapper's own attribute is never assigned) but present after
+        # `from_hash` (deserialization assigns it) — which breaks the canonical
+        # `to_hash` round-trip for a supplement whose base carries a non-default
+        # publisher (e.g. an ANSI/ISO corrigendum). The truth lives in `base`.
+        def to_hash(*args)
+          hash = super
+          if hash.is_a?(::Hash)
+            # `publisher` and `code` are delegated to `base`; never serialize
+            # them on the wrapper (they'd duplicate base.publisher/base.number
+            # and, for publisher, desync across parse vs from_hash).
+            hash.delete("publisher")
+            hash.delete("code")
+          end
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      autoload :AdoptedStandard, "#{__dir__}/identifiers/adopted_standard"
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :ConformanceIdentifier,
+               "#{__dir__}/identifiers/conformance_identifier"
+      autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :CsaDualPublished, "#{__dir__}/identifiers/csa_dual_published"
+      autoload :DualIdentifier, "#{__dir__}/identifiers/dual_identifier"
+      autoload :DualPublished, "#{__dir__}/identifiers/dual_published"
+      autoload :IecIeeeCopublished,
+               "#{__dir__}/identifiers/iec_ieee_copublished"
+      autoload :InterpretationIdentifier,
+               "#{__dir__}/identifiers/interpretation_identifier"
+      autoload :JointDevelopment, "#{__dir__}/identifiers/joint_development"
+      autoload :MultiNumberedIdentifier,
+               "#{__dir__}/identifiers/multi_numbered_identifier"
+      autoload :Nesc, "#{__dir__}/identifiers/nesc"
+      autoload :ParentheticalIdentifier,
+               "#{__dir__}/identifiers/parenthetical_identifier"
+      autoload :ProjectDraftIdentifier,
+               "#{__dir__}/identifiers/project_draft_identifier"
+      autoload :RedlinedStandard, "#{__dir__}/identifiers/redlined_standard"
+      autoload :SiStandard, "#{__dir__}/identifiers/si_standard"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+      autoload :SupplementIdentifier,
+               "#{__dir__}/identifiers/supplement_identifier"
+    end
+  end
+end

data/lib/pubid/ieee/ire/builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Ire
+      # Builder for IRE identifiers
+      class Builder
+        def build(parsed)
+          attributes = {}
+
+          # Extract publisher
+          attributes[:publisher] = extract_value(parsed[:publisher])
+
+          # Extract type
+          attributes[:type] = extract_value(parsed[:type])
+
+          # Extract the document designation. It travels as `code:` so the base
+          # initializer parses it into `code_obj` and the CodeNumber mixin
+          # hoists the flat split columns (number/prefix/parts/separator) that
+          # relaton indexes on.
+          number_str = extract_value(parsed[:number])
+          attributes[:code] = number_str if number_str
+
+          # Extract year - handle both short (52) and full (1952) formats
+          year_str = extract_value(parsed[:year])
+          if year_str
+            year_int = year_str.to_i
+            # Convert 2-digit years to 4-digit (12-63 => 1912-1963)
+            if year_int.between?(12, 63)
+              year_int += 1900
+            end
+            attributes[:year] = year_int.to_s
+          end
+
+          # Override with full_year if present
+          full_year_str = extract_value(parsed[:full_year])
+          if full_year_str
+            attributes[:year] = full_year_str.to_i.to_s
+          end
+
+          # Create identifier
+          Identifier.new(**attributes)
+        end
+
+        private
+
+        def extract_value(value)
+          return nil if value.nil?
+          return nil if value.is_a?(Array) && value.empty?
+
+          if value.is_a?(Array)
+            joined = value.join
+            return joined.length.positive? ? joined : nil
+          end
+
+          str_value = value.to_s.strip
+          str_value.length.positive? ? str_value : nil
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/ire/identifier.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ieee
+    module Ire
+      # IRE identifiers (Institute of Radio Engineers: 1912-1963).
+      #
+      # Reparented onto Pubid::Ieee::Identifier + the CodeNumber mixin for the
+      # same reasons AIEE was (see Pubid::Ieee::Aiee::Identifier): descending
+      # from bare Lutaml::Model::Serializable left IRE without `#root` (relaton
+      # keys its index on `id.root.number.to_s` -> NoMethodError), without a
+      # polymorphic `_type` (so `from_hash` could not route back), and — because
+      # an IRE object was not a ::Pubid::Identifier — unassignable to
+      # Identifiers::AdoptedStandard#adopted_identifiers, which raised
+      # Lutaml::Model::IncorrectModelError on `to_hash` for the IRE-adopted
+      # forms ("IEEE Std 159-1972 (52 IRE 7 S2)").
+      #
+      # The document designation ("7.S2") is carried in the shared `code_obj`
+      # and serialized as the flat split columns (number/prefix/parts/
+      # separator); the publication year uses the base's plain `:string` `year`
+      # (IRE previously declared its own `:integer` one, which would collide).
+      class Identifier < Pubid::Ieee::Identifier
+        include Pubid::Ieee::Identifiers::CodeNumber
+
+        attribute :publisher, :string, default: -> { "IRE" }
+        # IRE spells its type word out when present ("Trans.", "Standard",
+        # "Std") and omits it otherwise, so the base's "Std" default must go —
+        # else "52 IRE 7.S2" would render as "52 IRE Std 7.S2".
+        attribute :type, :string, default: -> {}
+
+        # A distinct polymorphic name so from_hash routes to IRE. The derived
+        # default (last name segment "Identifier") would be
+        # "pubid:ieee:identifier", colliding with the base class.
+        def self.polymorphic_name
+          "pubid:ieee:ire"
+        end
+
+        # Parse IRE identifier string
+        def self.parse(input)
+          parsed = Parser.new.parse(input)
+          builder = Builder.new
+          builder.build(parsed)
+        end
+
+        def to_s(trademark: false, **opts)
+          # Year comes FIRST in IRE format - render as 2-digit short year
+          result = [(short_year if year), publisher, type, code&.to_s]
+            .compact.join(" ")
+          # The code is the last token, so the end of the string already *is*
+          # the code boundary — but the symbol is picked from the code, not by
+          # scanning the string (which starts with the year).
+          if trademark
+            result += Pubid::Ieee.trademark_symbol_for(code_obj&.number,
+                                                       code_obj&.prefix,
+                                                       publishers: [publisher])
+          end
+          annotate_plain_render(result, **opts)
+        end
+
+        private
+
+        # IRE prints the publication year first, abbreviated to two digits for
+        # the 20th century ("1952" => "52").
+        def short_year
+          value = year.to_i
+          (value.between?(1900, 1999) ? value - 1900 : value).to_s
+        end
+      end
+    end
+  end
+end