pubid 1.15.21 → 2.0.0.alpha.10

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

@@ -0,0 +1,79 @@
+# 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 < Identifier
+        # First organization's identifier
+        attribute :first_identifier, Identifier, polymorphic: true
+
+        # Second organization's identifier
+        attribute :second_identifier, Identifier, polymorphic: true
+
+        def publisher
+          # Return array of both publishers
+          [first_identifier&.publisher, second_identifier&.publisher].compact
+        end
+
+        # `publisher` above is DERIVED from the two member identifiers (the
+        # serialized source of truth), so it must not be serialized itself.
+        # Emitting it breaks the canonical round-trip exactly as it did on
+        # Identifiers::AdoptedStandard and Identifiers::JointDevelopment: the
+        # derived value is default-omitted on the parse path (the attribute is
+        # unset), but re-emitted once from_hash materializes the attribute
+        # default, because the override then returns the members' publishers
+        # rather than the "IEEE" default. Worse here, it is an ARRAY, so the
+        # re-emitted value was the literal string `["IEEE", "IEEE"]`.
+        #
+        # This made all 25 DualPublished ids in the fixture corpus fail
+        # `from_hash(to_hash) == to_hash` — the gate relaton's index build
+        # uses, which SKIPS a document that fails it. Dropping the key is
+        # lossless: first_identifier and second_identifier rebuild it.
+        #
+        # A top-level to_hash delete is sufficient because DualPublished is
+        # only ever a top-level wrapper, never a nested `base` (where lutaml's
+        # own transform would bypass this override).
+        def to_hash(*args)
+          hash = super
+          hash.delete("publisher") if hash.is_a?(::Hash)
+          hash
+        end
+
+        # A dual-published document is one document under two designations, and
+        # this wrapper carries neither number itself — so `root.number`, the key
+        # relaton-index sorts and bsearches on, was "". Walk to the first
+        # designation, which is the one the printed reference leads with.
+        def root
+          first_identifier ? first_identifier.root : self
+        end
+
+        # Carry the number onto the URN and the MR slug as well as #root — see
+        # AdoptedStandard#code_obj for why all three surfaces need it.
+        def code_obj
+          first_identifier&.code_obj
+        end
+
+        # See AdoptedStandard#mr_year — without it the 1989 and the 1993
+        # printings of "IEEE Std 960 and IEEE Std 1177" shared one slug.
+        def mr_year
+          (year || first_identifier&.year)&.to_s
+        end
+
+        # `#publisher` above returns an ARRAY, and the inherited `mr_publisher`
+        # is `publisher&.to_s&.downcase` — so the MR slug contained a literal
+        # Ruby array (`["ieee", "asme"]`, brackets, quotes, comma and space
+        # included) and `to_slug` is an output FILENAME. Join the two instead,
+        # keeping both publishers in the slug: they are equally part of this
+        # document's identity, so by the project rule both must reach it.
+        def mr_publisher
+          names = Array(publisher).map { |p| p.to_s.downcase }.reject(&:empty?)
+          names.empty? ? nil : names.join("-")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # IEC/IEEE Copublished Identifier - standards copublished by IEC and IEEE.
+      # Example: "IEC/IEEE 60079-30-2/D5 IEC:2013 (10/07)"
+      #
+      # The printed IEC/IEEE number is stored as split index columns rather than
+      # a verbatim string: `number` (bare-digit narrowing key), `parts` (matched
+      # within the bucket), `separators` (per-part `.`/`-`, since a single code
+      # mixes them, e.g. `60076.57-1202`), and the trailing publication `year`
+      # (inherited from the base; attached with `year_sep`, always `-` in
+      # practice). The verbatim `copublished_number` is reconstructed from these
+      # for rendering — see #copublished_number — so it is NOT serialized.
+      class IecIeeeCopublished < Identifier
+        attribute :number, :string
+        attribute :parts, :string, collection: true, default: -> { [] }
+        attribute :separators, :string, collection: true, default: -> { [] }
+        attribute :year_sep, :string, default: -> { "-" }
+        # `year` is inherited from the base (:string).
+
+        attribute :iec_identifier, Identifier, polymorphic: true
+        attribute :ieee_identifier, Identifier, polymorphic: true
+        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)"
+
+        # The printed IEC/IEEE number, rebuilt losslessly from the split
+        # columns (the renderer/urn read this). Not stored — number/parts/
+        # separators/year fully describe it, so the verbatim string never
+        # bloats an index row.
+        # @param mark [String] IEEE trademark symbol, spliced in after the
+        #   number and its parts and before the publication year (IEEE prints
+        #   it there); "" for the ordinary, unmarked rendering.
+        def copublished_number(mark = "")
+          return nil if number.to_s.empty?
+
+          code = marked_code(mark)
+          code += "#{year_sep}#{year}" if year
+          code
+        end
+
+        # The dotted/dashed parts portion, each part with its own separator.
+        def parts_suffix
+          separators.zip(parts).map { |sep, part| "#{sep}#{part}" }.join
+        end
+
+        # A stage word printed ahead of the number (`FDIS 60079-30-2`,
+        # `CD2 P62704-5 ED1`, `TS P61869-105 ED1`). The lookahead — the next
+        # token must start like a document number — is what stops this eating a
+        # number that merely begins with a letter.
+        STAGE_PREFIX = /\A[A-Z]+\d*\s+(?=P?\d)/
+
+        # Inside the number token, the printed code stops early at:
+        #
+        # * a colon-attached publication year (`62582-2:2022`);
+        # * a dash/dot-attached 19xx/20xx year (`62395.1-2024 Redline`) — only
+        #   one a descriptive tail stranded inside the code gets here, since
+        #   #peel_copublished_year moves a genuinely trailing year into the
+        #   `year` attribute. The 19/20 prefix keeps a part that merely looks
+        #   like a year (`60076.57-1202`) from matching;
+        # * a glued parenthetical (`62704-1(E)`), which is a language marker
+        #   rather than part of the number.
+        CODE_END = /:\d{4}|[-.](?:19|20)\d{2}\z|\(/
+
+        # `number` + #parts_suffix with the mark spliced at the end of the code
+        # proper.
+        #
+        # Some copublished references carry an edition, a colon year, a stage
+        # word or a "- Redline" tail that the parser keeps inside
+        # `number`/`parts` rather than in dedicated attributes; appending the
+        # mark after all of it would print
+        # `IEC/IEEE 60076-16 Edition 2.0 2018-09™` instead of
+        # `IEC/IEEE 60076-16™ Edition 2.0 2018-09`. Scanning the whole printed
+        # code (not just the suffix) matters because the split point varies —
+        # `60802 Edition 1` lands in `number`, `-16 Edition 2` in `parts`.
+        #
+        # With the flag off `mark` is "" and this returns the code unchanged, so
+        # the plain rendering is byte-identical by construction.
+        def marked_code(mark)
+          code = "#{number}#{parts_suffix}"
+          return code if mark.to_s.empty?
+
+          at = code_end_index(code)
+          "#{code[0...at]}#{mark}#{code[at..]}"
+        end
+
+        # Index at which the printed code ends and descriptive text begins.
+        #
+        # The number is the first whitespace-delimited token after any stage
+        # word, so the code can never run past that token's end — which is what
+        # keeps the mark off a trailing edition/date phrase even when no
+        # CODE_END boundary matches inside the token.
+        def code_end_index(code)
+          start = code[STAGE_PREFIX]&.length || 0
+          token_end = code.index(" ", start) || code.length
+          boundary = code[start...token_end].index(CODE_END)
+          boundary ? start + boundary : token_end
+        end
+
+        # The base IEEE #exclude already nils year/month/day; also reset the
+        # year separator (a format sibling of the scalar year, per the CSA
+        # lesson) so a date-less reference matches a `:`-dated form too.
+        def exclude(*args)
+          result = super
+          if args.intersect?(%i[year date]) && result.respond_to?(:year_sep=)
+            result.year_sep = "-"
+          end
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# 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
+        # Uniform `year` (the interpretation year), not `int_year` — inherited
+        # from the base, so no attribute is declared here.
+
+        # The interpreted standard's code must reach the URN. Before this
+        # change the flat-parsed form kept its number in the wrapper's own
+        # `code_obj` (the builder never built a base), so the URN carried it by
+        # accident; now that the number lives on `base` where it belongs, the
+        # URN generator has to be pointed at it or the URN silently loses the
+        # document number. `code_obj` is a plain attr_accessor, not a lutaml
+        # attribute, so overriding it as a method is safe.
+        def code_obj
+          super || base&.code_obj
+        end
+
+        # MR supplement suffix: `int.{year}` — mirrors Corrigendum/Amendment.
+        # Without it the MrString renderer slugs an interpretation FLAT off
+        # attributes a supplement does not have, instead of recursing into
+        # `base`, so every interpretation of every standard collapsed onto
+        # "ieee.std.{year}" with no document number at all — and `to_slug` is
+        # an output FILENAME.
+        def mr_supplement_suffix
+          segments = ["int"]
+          segments << year.to_s if year
+          segments.join(".")
+        end
+
+        # TYPED_STAGES for interpretation
+        # Interpretation uses "INT" abbreviation
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            abbr: ["INT"],
+            type_code: "interpretation",
+            stage_code: "published",
+          ),
+        ].freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,223 @@
+# 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 < Identifier
+        # Split index columns (number/prefix/parts/separator) instead of a
+        # `code` string, like every IEEE leaf — see CodeNumber. Rendering reads
+        # `code` (base #code → code_obj), which CodeNumber rebuilds from the
+        # split fields, so to_ieee_format / to_iso_format are unaffected.
+        include CodeNumber
+
+        attribute :publishers, :string, collection: true
+        attribute :lead_party, :string              # "IEEE", "ISO", "IEC", etc.
+        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
+
+        # Accepts keyword args or a single positional hash (the base
+        # #exclude/matching rebuild passes the latter) — see
+        # Identifier#initialize.
+        def initialize(args = {}, **kwargs)
+          args = args.merge(kwargs) unless kwargs.empty?
+          # Call super FIRST to initialize Lutaml::Model attributes
+          super(args)
+
+          # 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
+        # JointDevelopment has its own dual-format logic (IEEE vs ISO)
+        # that doesn't go through the format registry renderer.
+        # @param format [Symbol] :ieee or :iso (defaults to canonical_format)
+        # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
+        # @return [String] formatted identifier
+        # `**_opts` absorbs render flags this list does not name (`annotated:`),
+        # which the closed keyword list used to reject outright.
+        def to_s(format: canonical_format, trademark: false, **opts)
+          # The mark goes after the code number, before the draft and the year
+          # ("ISO/IEC/IEEE P26511™/D8-2018"), so it is threaded into the
+          # format builders rather than appended to the finished string.
+          mark = if trademark
+                   Pubid::Ieee.trademark_symbol_for(code&.number,
+                                                    code&.prefix,
+                                                    publishers: publishers)
+                 else
+                   ""
+                 end
+
+          result = case format
+                   when :iso
+                     to_iso_format(mark)
+                   else
+                     to_ieee_format(mark)
+                   end
+
+          annotate_plain_render(result, **opts)
+        end
+
+        private
+
+        # Convert to ISO format representation
+        # ISO/IEC/IEEE FDIS 26511:2018
+        # @return [String] ISO format string
+        def to_iso_format(mark = "")
+          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/, "")
+          code_str += mark unless code_str.empty?
+          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(mark = "")
+          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
+
+          # Mark after the number, before the draft and the year
+          code_str += mark unless code_str.empty?
+
+          # 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
+
+        # Public again: these override base accessors and MUST be public — lutaml
+        # serialization calls `public_send(:publisher)`, so leaving them under the
+        # `private` above made JointDevelopment#to_hash raise (it could not be
+        # serialized or round-tripped / indexed at all).
+        public
+
+        # 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
+
+        # `publisher`/`copublisher` are *derived* from `publishers` (the source
+        # of truth, which IS serialized). Emitting them too breaks the canonical
+        # round-trip: the derived `publisher` is default-omitted on the parse
+        # path but re-emitted after from_hash (the override returns
+        # publishers.first, not the default). Drop both — publishers rebuilds
+        # them. (JointDevelopment is a top-level root, never nested, so a
+        # to_hash-level drop is sufficient.)
+        def to_hash(*args)
+          hash = super
+          if hash.is_a?(::Hash)
+            hash.delete("publisher")
+            hash.delete("copublisher")
+          end
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# 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 < Identifier
+        # Both designations are real lutaml attributes.
+        #
+        # They used to be `attr_accessor`s, which lutaml cannot see — so
+        # `to_hash` emitted {"_type" => "pubid:ieee:multi-numbered-identifier"}
+        # and NOTHING else, `from_hash` could not rebuild either member, and
+        # `#exclude` (which iterates self.class.attributes) skipped them. The
+        # whole identity was dropped. That is the CSA container defect recorded
+        # in CLAUDE.md, and the fix is the same: make the members attributes.
+        #
+        # The type is the CROSS-FLAVOR ::Pubid::Identifier, not IEEE's own:
+        # `polymorphic: true` widens only to subclasses, and the second
+        # designation may belong to another body — the same reason
+        # AdoptedStandard's members carry that type.
+        attribute :primary_identifier, ::Pubid::Identifier, polymorphic: true
+        attribute :secondary_identifier, ::Pubid::Identifier, polymorphic: true
+
+        # One document under two numbers, neither of them held here, so
+        # `root.number` was "". Walk to the primary designation.
+        def root
+          primary_identifier ? primary_identifier.root : self
+        end
+
+        # Carry the number onto the URN and the MR slug as well as #root — see
+        # AdoptedStandard#code_obj.
+        def code_obj
+          primary_identifier&.code_obj
+        end
+
+        # See AdoptedStandard#mr_year. `year` below already delegates, so this
+        # only stringifies — it is kept explicit so the hook survives if that
+        # delegation is ever removed in favour of the URN generator's
+        # `year_component` root fallback.
+        def mr_year
+          year&.to_s
+        end
+
+        def publisher
+          primary_identifier&.publisher
+        end
+
+        def code
+          primary_identifier&.code
+        end
+
+        def year
+          primary_identifier&.year
+        end
+
+        # `publisher` and `year` are DERIVED from primary_identifier — and,
+        # since that member became a serialized attribute above, the derived
+        # values are now re-emitted after from_hash materializes the attribute
+        # defaults, while the parse path omits them as unset. That asymmetry
+        # breaks `from_hash(to_hash) == to_hash`, the gate relaton's index
+        # build uses to decide whether to keep a document.
+        #
+        # It is latent rather than live for the one corpus id (its primary is
+        # IEEE-published with no year, so both derived values match their
+        # defaults and are dropped anyway), but the class documents that its
+        # members may belong to another body — and a synthetic AIEE primary
+        # reproduces it immediately. Dropping the keys is lossless:
+        # primary_identifier rebuilds both. Same treatment as
+        # AdoptedStandard#to_hash and DualPublished#to_hash.
+        def to_hash(*args)
+          hash = super
+          return hash unless hash.is_a?(::Hash)
+
+          hash.delete("publisher")
+          hash.delete("year")
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# 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.number # => "2"   (prefix "C")
+        #   nesc.year        # => "1997"
+        #
+        # @example Handbook format
+        #   nesc = Pubid::Ieee.parse("2017 NESC Handbook, Premier Edition")
+        #   nesc.year        # => "2017"
+        #   nesc.variant     # => "Handbook"
+        #   nesc.edition     # => "Premier Edition"
+        #
+        # Reparented onto Pubid::Ieee::Identifier (it used to descend from bare
+        # Lutaml::Model::Serializable) so NESC shares `#root`, a polymorphic
+        # `_type` and from_hash routing with every other IEEE type — see
+        # Pubid::Ieee::Aiee::Identifier for the same migration. Three
+        # attributes were reconciled against the base to avoid type collisions:
+        #
+        #   `code`  -> travels as the runtime `code_obj` (base #code returns
+        #              it); the concrete leaves serialize the flat split
+        #              columns via the CodeNumber mixin.
+        #   `year`  -> the base's plain `:string` year (was a
+        #              Pubid::Components::Date), matching IEEE's scalar-date
+        #              convention. `nesc.year` is now "2017", not a component.
+        #   `draft` -> dropped; the base declares a `:string` `draft` (the draft
+        #              *designator*), so a boolean here would corrupt it. Test
+        #              draft-ness with `#draft?` / the Nesc::Draft class.
+        #
+        # This class is abstract and enforces it in #initialize: the builder
+        # always instantiates a concrete leaf (Nesc::Edition for the plain
+        # year-first form), because only leaves may redefine `number` as a
+        # :string (see the CodeNumber mixin) and only leaves declare the
+        # NESC-specific `polymorphic_name` that from_hash routes on.
+        class Base < Pubid::Ieee::Identifier
+          attribute :variant, :string # Handbook, Redline, etc.
+          # Registered-trademark "(R)" after the full name or abbreviation
+          attribute :registered, :boolean
+          # Whether the "(NESC)"/"(NESC(R))" abbreviation suffix was present
+          attribute :abbr_suffix, :boolean
+          # Registered-trademark "(R)" inside the "(NESC(R))" suffix
+          attribute :abbr_suffix_registered, :boolean
+
+          # Guards the abstract contract — see the class docs. Ruby has no
+          # `abstract`, and an instantiated Base would carry the derived
+          # `_type` "pubid:ieee:base" (which from_hash cannot resolve back to
+          # NESC) and a nil `number` (the empty relaton index key).
+          def initialize(args = {}, **kwargs)
+            if instance_of?(Base)
+              raise NotImplementedError,
+                    "#{self.class} is abstract; instantiate a concrete NESC " \
+                    "type (Standard, Edition, Handbook, Redline, Draft)"
+            end
+
+            super
+          end
+
+          # Publisher portion for NESC identifiers
+          #
+          # @return [String] Always returns "NESC"
+          def publisher_portion
+            "NESC"
+          end
+
+          # Whether this is a draft of the code. NESC has no `draft` attribute
+          # of its own (the base's `draft` is the draft designator string), so
+          # draft-ness lives in the class.
+          #
+          # @return [Boolean]
+          def draft?
+            is_a?(Nesc::Draft)
+          end
+
+          # Rendering for year-first NESC identifiers (the C2-code standard form
+          # overrides this in Nesc::Standard). IEEE catalogues the year-first
+          # editions with the "IEEE Std" prefix, so it is prepended here.
+          #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
+          # @return [String] String representation
+          def to_s(trademark: false, **opts)
+            result = ["IEEE Std", year, name_portion].compact.join(" ")
+            result += trademark_symbol if trademark
+            annotate_plain_render(result, **opts)
+          end
+
+          # Trademark symbol for this document's own code. A NESC string starts
+          # with the publication *year*, so the string-scanning
+          # Pubid::Ieee.trademark_symbol would pick the wrong field — an
+          # edition year of 2030 would silently render ®.
+          #
+          # @return [String] "®" or "™"
+          def trademark_symbol
+            Pubid::Ieee.trademark_symbol_for(code_obj&.number,
+                                             code_obj&.prefix,
+                                             publishers: [publisher])
+          end
+
+          # The document-name portion, including the registered marks and the
+          # optional "(NESC(R))" abbreviation suffix.
+          #
+          # @return [String] e.g. "National Electrical Safety Code(R) (NESC(R))"
+          def name_portion
+            name = "National Electrical Safety Code"
+            name += "(R)" if registered
+            if abbr_suffix
+              suffix = "NESC"
+              suffix += "(R)" if abbr_suffix_registered
+              name += " (#{suffix})"
+            end
+            name
+          end
+        end
+      end
+    end
+  end
+end