pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

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

@@ -7,12 +7,8 @@ module Pubid
       # Represents conformance test documents
       # Example: IEEE Std 802.16/Conformance01-2003
       class ConformanceIdentifier < SupplementIdentifier
-        # Uniform `number` (the conformance ordinal) + inherited `year`, not
-        # `conf_number`/`conf_year`. `number` is a plain string redefining the
-        # inherited Components::Code (leaf-safe). `root.number` still returns the
-        # base document number.
-        attribute :number, :string
-        # `year` inherited from the base.
+        attribute :conf_number, :string
+        attribute :conf_year, :string
 
         # TYPED_STAGES for conformance
         # Conformance uses "Conformance" abbreviation
@@ -23,6 +19,16 @@ module Pubid
             stage_code: "published",
           ),
         ].freeze
+
+        def to_s
+          return base_identifier.to_s unless base_identifier
+
+          # Format: BASE/ConformanceNN-YEAR
+          result = base_identifier.to_s
+          result += "/Conformance#{conf_number}" if conf_number
+          result += "-#{conf_year}" if conf_year
+          result
+        end
       end
     end
   end

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

@@ -7,13 +7,8 @@ module Pubid
       # Represents corrections to published standards
       # Example: IEEE Std 535-2013/Cor. 1-2017
       class Corrigendum < SupplementIdentifier
-        # The corrigendum's own ordinal (`number`) and `year` — uniform names,
-        # not `cor_number`/`cor_year`. `number` is a plain string redefining the
-        # inherited Components::Code (leaf-safe, like the standards); `year` is
-        # the inherited base :string. `root.number` still returns the *base*
-        # document number, so the index key is unaffected.
-        attribute :number, :string
-        # `year` inherited from the base.
+        attribute :cor_number, :string
+        attribute :cor_year, :string
 
         # TYPED_STAGES for corrigendum
         # Corrigendum uses "Cor" abbreviation
@@ -25,14 +20,16 @@ module Pubid
           ),
         ].freeze
 
-        # MR supplement suffix: `cor.{number}.{year}` (e.g. "/cor.1.2017").
-        # The MrString renderer recurses into `base` and appends this so the
-        # full IEEE corrigendum round-trips losslessly (issue #142).
-        def mr_supplement_suffix
-          segments = ["cor"]
-          segments << number.to_s if number
-          segments << year.to_s if year
-          segments.join(".")
+        def to_s
+          return super unless base_identifier
+
+          # Format: BASE/Cor NUMBER-YEAR or BASE/Cor. NUMBER-YEAR
+          result = base_identifier.to_s
+          result += "/Cor"
+          result += ". " if cor_number # Add period and space for formal format
+          result += cor_number if cor_number
+          result += "-#{cor_year}" if cor_year
+          result
         end
       end
     end

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

@@ -6,32 +6,11 @@ module Pubid
       # 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 < Identifier
-        attribute :ieee_identifier, Identifier
+      class CsaDualPublished < Base
+        attribute :ieee_identifier, Base
         # CSA identifier is stored as-is (not a Lutaml model type)
         attr_accessor :csa_identifier
 
-        # `csa_identifier` is a real constructor parameter even though it is
-        # not a lutaml attribute, so the unknown-key contract must let it
-        # through — and the constructor must actually assign it.
-        def self.extra_init_keys
-          super + %i[csa_identifier]
-        end
-
-        # Walk to the IEEE designation for the relaton-index key: this wrapper
-        # names one document by an IEEE and a CSA number and holds neither
-        # itself, so `root.number` was "".
-        def root
-          ieee_identifier ? ieee_identifier.root : self
-        end
-
-        # Carry the number onto the URN and the MR slug as well as #root — see
-        # AdoptedStandard#code_obj. `#code` below delegates already, but the
-        # URN generator and the MR renderer both read `code_obj`.
-        def code_obj
-          ieee_identifier&.code_obj
-        end
-
         # Delegate common attributes to ieee_identifier
         def publisher
           ieee_identifier.publisher
@@ -53,8 +32,18 @@ module Pubid
           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)
-          Identifier.parse(string)
+          Base.parse(string)
         end
       end
     end

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

@@ -5,9 +5,13 @@ module Pubid
     module Identifiers
       # Dual Identifier - wraps two identifiers connected with "and"
       # Example: "ANSI C37.61-1973 and IEEE Std 321-1973"
-      class DualIdentifier < Identifier
-        attribute :first_identifier, Identifier, polymorphic: true
-        attribute :second_identifier, Identifier, polymorphic: true
+      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

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

@@ -7,72 +7,21 @@ module Pubid
       # 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
+      class DualPublished < Base
         # First organization's identifier
-        attribute :first_identifier, Identifier, polymorphic: true
+        attribute :first_identifier, Base, polymorphic: true
 
         # Second organization's identifier
-        attribute :second_identifier, Identifier, polymorphic: true
+        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
-
-        # `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

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

@@ -3,110 +3,22 @@
 module Pubid
   module Ieee
     module Identifiers
-      # IEC/IEEE Copublished Identifier - standards copublished by IEC and IEEE.
+      # IEC/IEEE Copublished Identifier - represents 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
+      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)"
 
-        # 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
+        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

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

@@ -7,31 +7,7 @@ module Pubid
       # 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
+        attribute :int_year, :string
 
         # TYPED_STAGES for interpretation
         # Interpretation uses "INT" abbreviation
@@ -42,6 +18,16 @@ module Pubid
             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

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

@@ -29,27 +29,18 @@ module Pubid
       # - "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
-
+      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
 
-        # 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?
+        def initialize(**args)
           # Call super FIRST to initialize Lutaml::Model attributes
-          super(args)
+          super
 
           # Then handle typed_stage
           if args[:typed_stage].is_a?(Components::TypedStage)
@@ -88,33 +79,17 @@ module Pubid
         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)
+        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
@@ -122,7 +97,7 @@ module Pubid
         # Convert to ISO format representation
         # ISO/IEC/IEEE FDIS 26511:2018
         # @return [String] ISO format string
-        def to_iso_format(mark = "")
+        def to_iso_format
           parts = []
 
           # Publishers (slash-separated)
@@ -140,7 +115,6 @@ module Pubid
 
           # 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
@@ -153,7 +127,7 @@ module Pubid
         # Convert to IEEE format representation
         # ISO/IEC/IEEE P26511/D8-2018
         # @return [String] IEEE format string
-        def to_ieee_format(mark = "")
+        def to_ieee_format
           parts = []
 
           # Publishers (slash-separated)
@@ -167,9 +141,6 @@ module Pubid
             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}"
@@ -186,12 +157,6 @@ module Pubid
           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
@@ -201,22 +166,6 @@ module Pubid
         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

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

@@ -8,41 +8,30 @@ module Pubid
       # 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
+      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
@@ -56,29 +45,6 @@ module Pubid
         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