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

data/lib/pubid/api/identifier.rb

@@ -7,14 +7,35 @@ module Pubid
     # `is_a?(Pubid::Api::Identifier)` natively and gets the shared polymorphic
     # `from_hash` (no facade needed).
     class Identifier < ::Pubid::Identifier
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: API stores a bare string in every one of them.
+      # Declaring on this class is safe because its body lives in this one file
+      # and is never reopened, so every subclass body opens after it has run
+      # (lutaml deep-dups the parent attribute table at class-definition time).
+      # `code` keeps its Components::Code type on SingleIdentifier - it is not
+      # one of the three attributes the shared base declares.
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
+
       def self.parse(input)
-        # Filter out comments
-        return nil if input.start_with?("#")
+        unless input.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if input.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
 
+        # There used to be a `return nil if input.start_with?("#")` here, to
+        # skip the comment lines of a fixture file. A comment is not an
+        # identifier, so it must be rejected like any other unparseable string:
+        # this was the one public parse in the gem that could return nil, which
+        # a caller reading `id.to_s` sees as a NoMethodError far from the cause.
+        # Both API fixture loaders already drop `#` lines themselves.
         tree = Parser.new.parse(input)
         Builder.new.build(tree)
-      rescue Parslet::ParseFailed => e
-        raise e
       end
     end
   end

data/lib/pubid/api/identifiers/mpms.rb

@@ -4,20 +4,22 @@ module Pubid
   module Api
     module Identifiers
       class Mpms < Base
-        attribute :chapter, :string
+        # The MPMS chapter IS the document number — "API MPMS CH 12.2" is
+        # chapter 12, section 2 — so it lives in the `number` inherited from
+        # ::Pubid::Identifier, which every other API type already sets. It used
+        # to sit in a separate `chapter` :string, leaving `number` nil, so all
+        # 30 MPMS ids keyed "" for relaton-index.
+        #
+        # `section`/`subsection` stay as sibling part columns, which is what
+        # gives the bucket semantics a part-less reference needs: every section
+        # of chapter 12 shares the key "12". `CH` is a literal marker in the
+        # renderer and was never part of the value.
         attribute :section, :string
         attribute :subsection, :string
 
         def type_string
           "MPMS"
         end
-
-        private
-
-        def code_portion
-          # Override - MPMS doesn't use code_portion
-          nil
-        end
       end
     end
   end

data/lib/pubid/api/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Api
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:dash) { str("-") }

data/lib/pubid/api/renderer.rb

@@ -30,10 +30,11 @@ module Pubid
       def render_default(id)
         parts = ["API"]
 
-        # Add type if available
-        if id.class.attributes.key?(:type_string) && id.type_string
-          parts << id.type_string
-        end
+        # Add the type token (RP, STD, BULL, PUBL, SPEC, TR ...) if the leaf
+        # defines one. `type_string` is a plain METHOD on each leaf, never a
+        # lutaml attribute, so the old `attributes.key?(:type_string)` guard
+        # was always false and the token was dropped from every rendering.
+        parts << id.type_string if id.respond_to?(:type_string) && id.type_string
 
         # Add code/number with part as one token
         parts << code_portion(id) if code_portion(id)
@@ -48,7 +49,7 @@ module Pubid
         parts = ["API", "MPMS"]
 
         # Add chapter
-        parts << "CH #{id.chapter}" if id.chapter
+        parts << "CH #{id.number}" if id.number
 
         # Add section/subsection
         if id.section
@@ -77,10 +78,18 @@ module Pubid
         parts.join(" ")
       end
 
+      # The document number plus its part, as one token.
+      #
+      # This used to read a `code` attribute that NOTHING ever assigned — the
+      # parser emits no `:code` key and the builder never sets one — so it
+      # always returned nil and 163 of API's 193 corpus identifiers rendered
+      # as the bare publisher "API". That string is both the document number
+      # and the output filename, so they all collapsed onto each other.
+      # `number` is what Builder#cast actually populates.
       def code_portion(id)
-        return nil unless id.code
+        return nil unless id.number
 
-        code_str = id.code.to_s
+        code_str = id.number.to_s
         code_str += "-#{id.part}" if id.part
         code_str
       end

data/lib/pubid/api/single_identifier.rb

@@ -12,20 +12,13 @@ module Pubid
       # serialize a String against the Components::Publisher attribute.
       attribute :publisher, :string, default: -> { "API" }
 
-      attribute :code, Components::Code
-      attribute :part, :string
+      # `number` and `part` are inherited as :string from
+      # Pubid::Api::Identifier. There is deliberately no `code` attribute: one
+      # existed here typed Components::Code, but nothing ever assigned it
+      # (the parser emits no `:code` key), so it only misdirected
+      # Renderer#code_portion away from the `number` the builder populates.
       attribute :year, :string
       attribute :reaffirmation, :string
-
-      private
-
-      def code_portion
-        return nil unless code
-
-        code_str = code.to_s
-        code_str += "-#{part}" if part
-        code_str
-      end
     end
   end
 end

data/lib/pubid/api.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Api
     extend Pubid::PrefixesSupport

data/lib/pubid/ashrae/builder.rb

@@ -7,7 +7,7 @@ module Pubid
     class Builder
       attr_reader :identifier_class
 
-      def initialize(identifier_class = Identifiers::Base)
+      def initialize(identifier_class = Identifier)
         @identifier_class = identifier_class
       end
 
@@ -39,6 +39,18 @@ module Pubid
           return build_addendum_no_type(parsed_hash[:addendum_no_type])
         elsif parsed_hash[:standard_addendum]
           return build_standard_addendum(parsed_hash[:standard_addendum])
+        # These two grammar rules had NO dispatch branch, so they fell through
+        # to the plain-identifier path below. That path looks for
+        # publisher/type/code at the TOP of the hash, finds only the wrapper
+        # key, and builds an empty Standard — 123 corpus ids rendered as the
+        # bare string "ASHRAE Standard ". Both subtrees are flat and carry
+        # exactly the keys #build_addendum_from_identifier already reads.
+        elsif parsed_hash[:addendum]
+          return build_addendum_from_identifier(parsed_hash[:addendum])
+        elsif parsed_hash[:publisher_base_addendum]
+          return build_addendum_from_identifier(
+            parsed_hash[:publisher_base_addendum],
+          )
         end
 
         # Handle base identifier
@@ -53,7 +65,7 @@ module Pubid
 
       # Class method to build an identifier from parsed data
       # @param parsed [Hash, Array] the parsed identifier data
-      # @return [Identifiers::Base] the constructed identifier object
+      # @return [Identifier] the constructed identifier object
       def self.build(parsed)
         new.build(parsed)
       end
@@ -89,7 +101,7 @@ module Pubid
           # code_with_year contains both code and year
           code_year_data = parsed[:code_with_year]
           if code_year_data && code_year_data[:code]
-            attributes[:code] =
+            attributes[:number] =
               extract_value(code_year_data[:code])
           end
           if code_year_data && code_year_data[:year]
@@ -97,7 +109,7 @@ module Pubid
               extract_value(code_year_data[:year])
           end
         elsif parsed[:code]
-          attributes[:code] = extract_value(parsed[:code])
+          attributes[:number] = extract_value(parsed[:code])
         end
 
         # Extract year if not already extracted from code_with_year
@@ -158,12 +170,12 @@ module Pubid
       def build_errata(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         errata_date = extract_errata_date(parsed[:errata_date])
 
         Identifiers::Errata.new(
-          base_identifier: base_identifier,
+          base: base,
           errata_date: errata_date,
         )
       end
@@ -174,10 +186,10 @@ module Pubid
       def build_interpretation(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         Identifiers::Interpretation.new(
-          base_identifier: base_identifier,
+          base: base,
         )
       end
 
@@ -187,13 +199,13 @@ module Pubid
       def build_addendum_from_identifier(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -205,17 +217,17 @@ module Pubid
       def build_publisher_addendum(parsed)
         base_attrs = {
           type: extract_value(parsed[:type]),
-          code: extract_value(parsed[:code]),
+          number: extract_value(parsed[:code]),
           year: extract_value(parsed[:year]),
         }
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -228,17 +240,17 @@ module Pubid
         base_attrs = {
           copublisher: extract_value(parsed[:copublisher]),
           type: extract_value(parsed[:type]) || "Standard",
-          code: extract_value(parsed[:code]),
+          number: extract_value(parsed[:code]),
           year: extract_value(parsed[:year]),
         }
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -260,7 +272,7 @@ module Pubid
         if parsed[:code_with_year]
           code_year_data = parsed[:code_with_year]
           if code_year_data && code_year_data[:code]
-            base_attrs[:code] =
+            base_attrs[:number] =
               extract_value(code_year_data[:code])
           end
           if code_year_data && code_year_data[:year]
@@ -270,13 +282,13 @@ module Pubid
         end
 
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -298,7 +310,7 @@ module Pubid
         if parsed[:code_with_year]
           code_year_data = parsed[:code_with_year]
           if code_year_data && code_year_data[:code]
-            base_attrs[:code] =
+            base_attrs[:number] =
               extract_value(code_year_data[:code])
           end
           if code_year_data && code_year_data[:year]
@@ -308,13 +320,13 @@ module Pubid
         end
 
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -326,13 +338,13 @@ module Pubid
       def build_standard_addendum(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -349,7 +361,7 @@ module Pubid
         if parsed[:code_with_year]
           code_year_data = parsed[:code_with_year]
           if code_year_data && code_year_data[:code]
-            base_attrs[:code] =
+            base_attrs[:number] =
               extract_value(code_year_data[:code])
           end
           if code_year_data && code_year_data[:year]
@@ -358,7 +370,7 @@ module Pubid
           end
         else
           base_attrs[:type] = extract_value(parsed[:type]) || "Standard"
-          base_attrs[:code] = extract_value(parsed[:code])
+          base_attrs[:number] = extract_value(parsed[:code])
           base_attrs[:year] = extract_value(parsed[:year])
         end
 
@@ -372,7 +384,7 @@ module Pubid
         end
 
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         # Build the addendum_codes string from first code and additional codes
         first_code = extract_value(parsed[:addendum_code])
@@ -406,7 +418,7 @@ module Pubid
         end
 
         Identifiers::CombinedAddenda.new(
-          base_identifier: base_identifier,
+          base: base,
           addendum_codes: addendum_codes_str,
         )
       end
@@ -417,12 +429,12 @@ module Pubid
       def build_addenda_package(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base_identifier = base_class.new(**base_attrs)
+        base = base_class.new(**base_attrs)
 
         package_description = extract_value(parsed[:package_description])
 
         Identifiers::AddendaPackage.new(
-          base_identifier: base_identifier,
+          base: base,
           package_description: package_description,
         )
       end
@@ -431,6 +443,15 @@ module Pubid
       # @param parsed [Hash] the parsed data
       # @return [Hash] attributes for base identifier
       def extract_base_attributes(parsed)
+        # Unwrap the `:base` subtree the supplement grammars nest the base
+        # document under. Builder#build does this for the plain-identifier
+        # path, but the five supplement builders that call this method all
+        # passed the WHOLE parse hash — so every lookup below missed and the
+        # base was built with nothing. 318 Errata rendered as the identical
+        # string "ASHRAE Standard  Errata"; doing it here fixes all five call
+        # sites at once, rather than repeating the unwrap in each.
+        parsed = parsed[:base] if parsed.is_a?(Hash) && parsed[:base]
+
         attributes = {}
 
         if parsed[:publisher]
@@ -448,7 +469,7 @@ module Pubid
         if parsed[:code_with_year]
           code_year_data = parsed[:code_with_year]
           if code_year_data && code_year_data[:code]
-            attributes[:code] =
+            attributes[:number] =
               extract_value(code_year_data[:code])
           end
           if code_year_data && code_year_data[:year]
@@ -456,7 +477,7 @@ module Pubid
               extract_value(code_year_data[:year])
           end
         else
-          attributes[:code] = extract_value(parsed[:code]) if parsed[:code]
+          attributes[:number] = extract_value(parsed[:code]) if parsed[:code]
           attributes[:year] = extract_value(parsed[:year]) if parsed[:year]
         end
 

data/lib/pubid/ashrae/identifier.rb

@@ -3,7 +3,6 @@
 # The ASHRAE flavor base class is Pubid::Ashrae::Identifier — a real
 # Pubid::Identifier subclass that every concrete ASHRAE identifier descends
 # from, so `is_a?` identity and the shared polymorphic `from_hash` work natively
-# (no facade needed). Its body, `.parse`, and the Identifiers::Base back-compat
-# alias live in identifiers/base.rb; this file just ensures it is loaded when a
-# consumer references Pubid::Ashrae::Identifier directly.
-require_relative "identifiers/base"
+# (no facade needed). Its body and `.parse` live in identifiers/base.rb; this
+# file just ensures it is loaded when a consumer references
+# Pubid::Ashrae::Identifier directly.

data/lib/pubid/ashrae/identifiers/addenda_package.rb

@@ -14,6 +14,12 @@ module Pubid
       class AddendaPackage < SupplementIdentifier
         attribute :package_description, :string # e.g., "Addenda Supplement Package"
 
+        # See Errata.
+        def mr_supplement_suffix
+          ["pkg", mr_sanitize(package_description)]
+            .compact.reject(&:empty?).join(".")
+        end
+
         TYPED_STAGES = [
           Components::TypedStage.new(
             abbr: ["Addenda Supplement Package", "Addenda Package"],
@@ -28,7 +34,7 @@ module Pubid
         end
 
         def copublisher
-          base_identifier&.copublisher
+          base&.copublisher
         end
       end
     end

data/lib/pubid/ashrae/identifiers/addendum.rb

@@ -15,6 +15,14 @@ module Pubid
         attribute :addendum_code, :string  # a, b, c, ..., aa, ab, ..., ba, etc.
         attribute :addendum_date, :string  # Optional date (January 22, 2019)
 
+        # See Errata: the renderer must recurse into `base`. The addendum
+        # letter is what distinguishes addendum a from addendum b of one
+        # standard, so it belongs in the slug as well as in `==`.
+        def mr_supplement_suffix
+          ["add", addendum_code&.to_s&.downcase]
+            .compact.reject(&:empty?).join(".")
+        end
+
         TYPED_STAGES = [
           Components::TypedStage.new(
             abbr: ["Addendum", "Addenda"],
@@ -28,7 +36,7 @@ module Pubid
         end
 
         def copublisher
-          base_identifier&.copublisher
+          base&.copublisher
         end
       end
     end

data/lib/pubid/ashrae/identifiers/base.rb

@@ -3,35 +3,117 @@
 module Pubid
   module Ashrae
     # Base class for all ASHRAE identifiers. Canonical name
-    # Pubid::Ashrae::Identifier; every concrete ASHRAE identifier descends from
-    # it, and Identifiers::Base — aliased at the foot of this file — points back
-    # to it.
+    # Pubid::Ashrae::Identifier; every concrete ASHRAE identifier descends from it.
     class Identifier < ::Pubid::Identifier
       # Parse an ASHRAE identifier string into an identifier object
       # @param identifier [String] The ASHRAE identifier string to parse
       # @return [Pubid::Ashrae::Identifier] The appropriate identifier object
-      # @raise [Parslet::ParseFailed] If parsing fails
+      # @raise [Pubid::Errors::ParseError] If parsing fails
       def self.parse(identifier)
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse ASHRAE identifier '#{identifier}': #{e.message}"
       end
 
       attribute :publisher, :string, default: "ASHRAE"
-      attribute :code, :string
+      # The document number used to live here as `attribute :code, :string`,
+      # leaving the `number` inherited from ::Pubid::Identifier nil — so
+      # relaton-index, which sorts and bsearches on `id.root.number.to_s`,
+      # keyed all 3,619 ASHRAE rows on "".
+      #
+      # It is now `attribute :number, :string` on the two single-document
+      # LEAVES (Identifiers::Standard and Identifiers::Guideline), never here:
+      # this class is inherited by BOTH SingleIdentifier and
+      # SupplementIdentifier, and redefining the parent's Components::Code-typed
+      # `number` on an inherited-from class resolves nondeterministically under
+      # multi-flavor load. The supplement types carry no number of their own —
+      # they reach it through #root, which walks `base`.
       attribute :year, :string
       attribute :type, :string
       attribute :suffix, :string # R (revision), P (proposed), etc.
       attribute :amendment, :string
       attribute :reaffirmed, :string
       attribute :copublisher, :string
-    end
 
-    module Identifiers
-      # Backward-compatible alias: ASHRAE's base class used to be
-      # Pubid::Ashrae::Identifiers::Base. It is now Pubid::Ashrae::Identifier.
-      Base = Pubid::Ashrae::Identifier
+      # --- MR slug hooks -------------------------------------------------
+      #
+      # ASHRAE supplied none, and every base hook looks for something ASHRAE
+      # does not use: `mr_type` reads a typed_stage, `mr_year` reads a
+      # Components::Date. With `number` nil too, ALL 3,619 ids collapsed onto
+      # the single slug "ashrae" — the worst collapse measured in the gem, and
+      # `to_slug` is what consumers use as an output FILENAME.
+      #
+      # `type` distinguishes a Guideline from a Standard of the same number
+      # (Guideline 0 and Standard 0 are different documents), so it has to
+      # reach the slug and not only `==`.
+      def mr_type
+        type&.to_s&.downcase
+      end
+
+      # ASHRAE keeps its edition in a plain `year` string, not the inherited
+      # `date`, so the base hook read nil and every edition of one standard
+      # shared a slug.
+      def mr_year
+        year&.to_s
+      end
+
+      # `copublisher` is in `==` and in `to_s`, so by the project rule it has to
+      # reach the slug too: "ASHRAE Standard 15-2019 Addendum a" and
+      # "ANSI/ASHRAE Addendum a to ANSI/ASHRAE Standard 15-2019" have different
+      # hashes and would otherwise share a filename. (Whether those two strings
+      # ought to normalise to ONE identifier is a separate question, and not one
+      # the slug should paper over.)
+      def mr_publisher
+        mr_sanitize(copublisher || publisher)
+      end
+
+      # Both trailing markers are identity-bearing and must reach the slug, not
+      # only `==`: `reaffirmed` ("RA 2017") separates "ANSI/ASHRAE Standard
+      # 206-2013 (RA 2017)" from the plain "…206-2013", and `suffix` ("R" for
+      # revision, "P" for proposed) separates "ASHRAE Guideline 27-2019" from
+      # "…27-2019R". Their hashes differ, so their filenames must too.
+      # Uses the shared #mr_join rather than a bare `compact.join("-")`, so it
+      # returns nil instead of "" when nothing survives: MrString's own
+      # `compact` drops nil but not the empty string, and a blank segment
+      # yields a double dot in the joined slug.
+      def mr_number_with_part
+        mr_join(mr_sanitize(number),
+                (reaffirmed ? "ra#{mr_sanitize(reaffirmed)}" : nil),
+                mr_sanitize(suffix))
+      end
+
+      # An ASHRAE value can carry characters outside the [a-z0-9.-] charset
+      # Renderers::MrString documents: a comma in the code "90A,B,C", a slash
+      # in the copublisher "ANSI/ASHRAE", spaces in a package description.
+      # Filter BY CHARSET (the BIPM `mr_slug` precedent) rather than by an
+      # enumerated escape list, so a character introduced later cannot reach a
+      # filename.
+      #
+      # Public alongside the hooks above rather than tucked behind `private`,
+      # since the whole MR surface here is public, and the supplement types
+      # call it from their own mr_supplement_suffix. The output emptiness check
+      # matters: a value made only of out-of-charset characters collapses to
+      # "", which is truthy in Ruby and would reach the renderer as a blank
+      # segment, producing a double dot in the joined slug.
+      def mr_sanitize(value)
+        return nil if value.nil? || value.to_s.empty?
+
+        sanitized = value.to_s.downcase
+          .gsub(%r{[^a-z0-9.-]+}, "-").gsub(%r{\A-+|-+\z}, "")
+        sanitized.empty? ? nil : sanitized
+      end
+
+      # ASHRAE stores the publication year in a plain :string scalar, not a
+      # Components::Date, so the base #exclude's :year->:date remap cannot nil
+      # it. Reset the scalar directly (mirroring CSA/BIPM) so a year-less
+      # partial reference is a year wildcard under
+      # matches?(other, ignore: [:year]). super still recurses into the nested
+      # `base` of wrapper types (Errata/Addendum/…), which carry no year scalar.
+      def exclude(*args)
+        result = super
+        year_keys = args & %i[year date]
+        result.year = nil if !year_keys.empty? && result.respond_to?(:year=)
+        result
+      end
     end
   end
 end

data/lib/pubid/ashrae/identifiers/combined_addenda.rb

@@ -14,6 +14,13 @@ module Pubid
         attribute :addendum_codes, :string # Multiple codes like "c and d"
         attribute :connector, :string # "and" or ","
 
+        # See Errata. The whole letter list is the identity here — "Addenda a,
+        # b" and "Addenda c, d" of one standard are different documents.
+        def mr_supplement_suffix
+          ["adds", mr_sanitize(addendum_codes)]
+            .compact.reject(&:empty?).join(".")
+        end
+
         TYPED_STAGES = [
           Components::TypedStage.new(
             abbr: ["Addenda", "Combined Addenda"],
@@ -28,7 +35,7 @@ module Pubid
         end
 
         def copublisher
-          base_identifier&.copublisher
+          base&.copublisher
         end
       end
     end