pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

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

@@ -7,8 +7,13 @@ module Pubid
       # Represents corrections to published standards
       # Example: IEEE Std 535-2013/Cor. 1-2017
       class Corrigendum < SupplementIdentifier
-        attribute :cor_number, :string
-        attribute :cor_year, :string
+        # 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.
 
         # TYPED_STAGES for corrigendum
         # Corrigendum uses "Cor" abbreviation
@@ -19,6 +24,16 @@ module Pubid
             stage_code: "published",
           ),
         ].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(".")
+        end
       end
     end
   end

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

@@ -6,11 +6,32 @@ 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 < Base
-        attribute :ieee_identifier, Base
+      class CsaDualPublished < Identifier
+        attribute :ieee_identifier, Identifier
         # 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
@@ -33,7 +54,7 @@ module Pubid
         end
 
         def self.parse(string)
-          Base.parse(string)
+          Identifier.parse(string)
         end
       end
     end

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

@@ -5,9 +5,9 @@ module Pubid
     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
+      class DualIdentifier < Identifier
+        attribute :first_identifier, Identifier, polymorphic: true
+        attribute :second_identifier, Identifier, polymorphic: true
       end
     end
   end

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

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

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

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

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

@@ -7,7 +7,31 @@ module Pubid
       # 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
+        # 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

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

@@ -29,18 +29,27 @@ 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 < Base
+      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 :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)
+        # 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
+          super(args)
 
           # Then handle typed_stage
           if args[:typed_stage].is_a?(Components::TypedStage)
@@ -82,16 +91,30 @@ module Pubid
         # 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
-        def to_s(format: canonical_format)
-          case format
-          when :iso
-            to_iso_format
-          when :ieee
-            to_ieee_format
-          else
-            to_ieee_format
-          end
+        # `**_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
@@ -99,7 +122,7 @@ module Pubid
         # Convert to ISO format representation
         # ISO/IEC/IEEE FDIS 26511:2018
         # @return [String] ISO format string
-        def to_iso_format
+        def to_iso_format(mark = "")
           parts = []
 
           # Publishers (slash-separated)
@@ -117,6 +140,7 @@ 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
@@ -129,7 +153,7 @@ module Pubid
         # Convert to IEEE format representation
         # ISO/IEC/IEEE P26511/D8-2018
         # @return [String] IEEE format string
-        def to_ieee_format
+        def to_ieee_format(mark = "")
           parts = []
 
           # Publishers (slash-separated)
@@ -143,6 +167,9 @@ 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}"
@@ -159,6 +186,12 @@ 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
@@ -168,6 +201,22 @@ 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,13 +8,42 @@ 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 < Base
-        # Primary identifier (main IEEE standard number)
-        # Stored as-is (Lutaml model type checking doesn't work with polymorphic identifiers)
-        attr_accessor :primary_identifier
+      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
 
-        # Secondary identifier (additional number for same document)
-        attr_accessor :secondary_identifier
+        # 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
@@ -27,6 +56,29 @@ 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