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

data/lib/pubid/ashrae/builder.rb

@@ -3,17 +3,17 @@
 module Pubid
   module Ashrae
     # Builder class for constructing ASHRAE identifier scheme from parsed data
-    # Single Responsibility: Transform parsed data into identifier objects
+    # Single Responsibility: Transform parsed data into Scheme objects
     class Builder
       attr_reader :identifier_class
 
-      def initialize(identifier_class = Identifier)
+      def initialize(identifier_class = Identifiers::Base)
         @identifier_class = identifier_class
       end
 
       # Build a scheme object from parsed data
       # @param parsed [Hash, Array] the parsed identifier data
-      # @return [identifier] the constructed scheme object
+      # @return [Scheme] the constructed scheme object
       def build(parsed)
         # Parslet can return array of hashes - merge them
         parsed_hash = parsed.is_a?(Array) ? merge_parsed_array(parsed) : parsed
@@ -39,18 +39,6 @@ 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
@@ -65,7 +53,7 @@ module Pubid
 
       # Class method to build an identifier from parsed data
       # @param parsed [Hash, Array] the parsed identifier data
-      # @return [Identifier] the constructed identifier object
+      # @return [Identifiers::Base] the constructed identifier object
       def self.build(parsed)
         new.build(parsed)
       end
@@ -83,7 +71,7 @@ module Pubid
 
       # Extract and normalize attributes from parsed data
       # @param parsed [Hash] the parsed data
-      # @return [Hash] normalized attributes for identifier
+      # @return [Hash] normalized attributes for Scheme
       def extract_attributes(parsed)
         attributes = {}
 
@@ -101,7 +89,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[:number] =
+            attributes[:code] =
               extract_value(code_year_data[:code])
           end
           if code_year_data && code_year_data[:year]
@@ -109,7 +97,7 @@ module Pubid
               extract_value(code_year_data[:year])
           end
         elsif parsed[:code]
-          attributes[:number] = extract_value(parsed[:code])
+          attributes[:code] = extract_value(parsed[:code])
         end
 
         # Extract year if not already extracted from code_with_year
@@ -170,12 +158,12 @@ module Pubid
       def build_errata(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base = base_class.new(**base_attrs)
+        base_identifier = base_class.new(**base_attrs)
 
         errata_date = extract_errata_date(parsed[:errata_date])
 
         Identifiers::Errata.new(
-          base: base,
+          base_identifier: base_identifier,
           errata_date: errata_date,
         )
       end
@@ -186,10 +174,10 @@ module Pubid
       def build_interpretation(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base = base_class.new(**base_attrs)
+        base_identifier = base_class.new(**base_attrs)
 
         Identifiers::Interpretation.new(
-          base: base,
+          base_identifier: base_identifier,
         )
       end
 
@@ -199,13 +187,13 @@ module Pubid
       def build_addendum_from_identifier(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base = base_class.new(**base_attrs)
+        base_identifier = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base: base,
+          base_identifier: base_identifier,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -217,17 +205,17 @@ module Pubid
       def build_publisher_addendum(parsed)
         base_attrs = {
           type: extract_value(parsed[:type]),
-          number: extract_value(parsed[:code]),
+          code: extract_value(parsed[:code]),
           year: extract_value(parsed[:year]),
         }
         base_class = determine_identifier_class(base_attrs)
-        base = base_class.new(**base_attrs)
+        base_identifier = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base: base,
+          base_identifier: base_identifier,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -240,17 +228,17 @@ module Pubid
         base_attrs = {
           copublisher: extract_value(parsed[:copublisher]),
           type: extract_value(parsed[:type]) || "Standard",
-          number: extract_value(parsed[:code]),
+          code: extract_value(parsed[:code]),
           year: extract_value(parsed[:year]),
         }
         base_class = determine_identifier_class(base_attrs)
-        base = base_class.new(**base_attrs)
+        base_identifier = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base: base,
+          base_identifier: base_identifier,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -272,7 +260,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[:number] =
+            base_attrs[:code] =
               extract_value(code_year_data[:code])
           end
           if code_year_data && code_year_data[:year]
@@ -282,13 +270,13 @@ module Pubid
         end
 
         base_class = determine_identifier_class(base_attrs)
-        base = base_class.new(**base_attrs)
+        base_identifier = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base: base,
+          base_identifier: base_identifier,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -310,7 +298,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[:number] =
+            base_attrs[:code] =
               extract_value(code_year_data[:code])
           end
           if code_year_data && code_year_data[:year]
@@ -320,13 +308,13 @@ module Pubid
         end
 
         base_class = determine_identifier_class(base_attrs)
-        base = base_class.new(**base_attrs)
+        base_identifier = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base: base,
+          base_identifier: base_identifier,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -338,13 +326,13 @@ module Pubid
       def build_standard_addendum(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base = base_class.new(**base_attrs)
+        base_identifier = base_class.new(**base_attrs)
 
         addendum_code = extract_value(parsed[:addendum_code])
         addendum_date = extract_addendum_date(parsed[:addendum_year])
 
         Identifiers::Addendum.new(
-          base: base,
+          base_identifier: base_identifier,
           addendum_code: addendum_code,
           addendum_date: addendum_date,
         )
@@ -361,7 +349,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[:number] =
+            base_attrs[:code] =
               extract_value(code_year_data[:code])
           end
           if code_year_data && code_year_data[:year]
@@ -370,7 +358,7 @@ module Pubid
           end
         else
           base_attrs[:type] = extract_value(parsed[:type]) || "Standard"
-          base_attrs[:number] = extract_value(parsed[:code])
+          base_attrs[:code] = extract_value(parsed[:code])
           base_attrs[:year] = extract_value(parsed[:year])
         end
 
@@ -384,7 +372,7 @@ module Pubid
         end
 
         base_class = determine_identifier_class(base_attrs)
-        base = base_class.new(**base_attrs)
+        base_identifier = base_class.new(**base_attrs)
 
         # Build the addendum_codes string from first code and additional codes
         first_code = extract_value(parsed[:addendum_code])
@@ -418,7 +406,7 @@ module Pubid
         end
 
         Identifiers::CombinedAddenda.new(
-          base: base,
+          base_identifier: base_identifier,
           addendum_codes: addendum_codes_str,
         )
       end
@@ -429,12 +417,12 @@ module Pubid
       def build_addenda_package(parsed)
         base_attrs = extract_base_attributes(parsed)
         base_class = determine_identifier_class(base_attrs)
-        base = base_class.new(**base_attrs)
+        base_identifier = base_class.new(**base_attrs)
 
         package_description = extract_value(parsed[:package_description])
 
         Identifiers::AddendaPackage.new(
-          base: base,
+          base_identifier: base_identifier,
           package_description: package_description,
         )
       end
@@ -443,15 +431,6 @@ 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]
@@ -469,7 +448,7 @@ module Pubid
         if parsed[:code_with_year]
           code_year_data = parsed[:code_with_year]
           if code_year_data && code_year_data[:code]
-            attributes[:number] =
+            attributes[:code] =
               extract_value(code_year_data[:code])
           end
           if code_year_data && code_year_data[:year]
@@ -477,7 +456,7 @@ module Pubid
               extract_value(code_year_data[:year])
           end
         else
-          attributes[:number] = extract_value(parsed[:code]) if parsed[:code]
+          attributes[:code] = extract_value(parsed[:code]) if parsed[:code]
           attributes[:year] = extract_value(parsed[:year]) if parsed[:year]
         end
 

data/lib/pubid/ashrae/identifier.rb

@@ -1,8 +1,18 @@
 # frozen_string_literal: true
 
-# 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 and `.parse` live in identifiers/base.rb; this
-# file just ensures it is loaded when a consumer references
-# Pubid::Ashrae::Identifier directly.
+module Pubid
+  module Ashrae
+    module Identifier
+      # Parse an ASHRAE identifier string into an identifier object
+      # @param identifier [String] The ASHRAE identifier string to parse
+      # @return [Identifiers::Base] The appropriate identifier object
+      # @raise [Parslet::ParseFailed] 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
+    end
+  end
+end

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

@@ -14,12 +14,6 @@ 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"],
@@ -33,8 +27,18 @@ module Pubid
             short: "Addenda Package" }
         end
 
+        def to_s
+          return base_identifier.to_s unless base_identifier
+
+          # Format: ASHRAE Standard 52.2-1999: Addenda Supplement Package
+          result = "ASHRAE #{base_identifier.type || 'Standard'} #{base_identifier.code}"
+          result += "-#{base_identifier.year}" if base_identifier.year
+          result += ": Addenda #{package_description}" if package_description
+          result
+        end
+
         def copublisher
-          base&.copublisher
+          base_identifier&.copublisher
         end
       end
     end

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

@@ -15,14 +15,6 @@ 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"],
@@ -35,8 +27,27 @@ module Pubid
           { key: :addendum, title: "ASHRAE Addendum", short: "Addendum" }
         end
 
+        def to_s
+          return base_identifier.to_s unless base_identifier
+
+          # Determine base type name for rendering
+          base_type = base_identifier.type || "Standard"
+
+          if copublisher
+            # Format: ANSI/ASHRAE Addendum a to ANSI/ASHRAE Standard 15-2019
+            result = "#{copublisher} Addendum #{addendum_code} to #{base_identifier}"
+          else
+            # Format: ASHRAE Addendum a to Standard 15-2001
+            result = "ASHRAE Addendum #{addendum_code} to #{base_type} #{base_identifier.code}"
+            result += "-#{base_identifier.year}" if base_identifier.year
+          end
+
+          result += " (#{addendum_date})" if addendum_date
+          result
+        end
+
         def copublisher
-          base&.copublisher
+          base_identifier&.copublisher
         end
       end
     end

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

@@ -2,117 +2,21 @@
 
 module Pubid
   module Ashrae
-    # Base class for all ASHRAE identifiers. Canonical name
-    # 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 [Pubid::Errors::ParseError] If parsing fails
-      def self.parse(identifier)
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
-      end
-
-      attribute :publisher, :string, default: "ASHRAE"
-      # 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
-
-      # --- 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
+    module Identifiers
+      # Base class for all ASHRAE identifiers
+      class Base < Pubid::Identifier
+        attribute :publisher, :string, default: "ASHRAE"
+        attribute :code, :string
+        attribute :year, :string
+        attribute :type, :string
+        attribute :suffix, :string # R (revision), P (proposed), etc.
+        attribute :amendment, :string
+        attribute :reaffirmed, :string
+        attribute :copublisher, :string
+
+        def self.parse(string)
+          Ashrae::Identifier.parse(string)
+        end
       end
     end
   end

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

@@ -14,13 +14,6 @@ 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"],
@@ -34,8 +27,23 @@ module Pubid
             short: "Addenda" }
         end
 
+        def to_s
+          return base_identifier.to_s unless base_identifier
+
+          base_type = base_identifier.type || "Standard"
+          if addendum_codes
+            # Format: ASHRAE Addenda c and d to Standard 15-1994
+            result = "ASHRAE Addenda #{addendum_codes} to #{base_type} #{base_identifier.code}"
+          else
+            # Format: ASHRAE Addenda to Standard 15-1994 (no specific codes)
+            result = "ASHRAE Addenda to #{base_type} #{base_identifier.code}"
+          end
+          result += "-#{base_identifier.year}" if base_identifier.year
+          result
+        end
+
         def copublisher
-          base&.copublisher
+          base_identifier&.copublisher
         end
       end
     end

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

@@ -13,15 +13,6 @@ module Pubid
       class Errata < SupplementIdentifier
         attribute :errata_date, :string
 
-        # Make Renderers::MrString recurse into `base` instead of slugging the
-        # supplement flat off attributes it does not have. Without it every
-        # erratum of every standard shared one filename, and `to_slug` is what
-        # consumers use as an output filename.
-        def mr_supplement_suffix
-          ["errata", mr_sanitize(errata_date)]
-            .compact.reject(&:empty?).join(".")
-        end
-
         TYPED_STAGES = [
           Components::TypedStage.new(
             abbr: ["Errata"],
@@ -33,6 +24,16 @@ module Pubid
         def self.type
           { key: :errata, title: "ASHRAE Errata", short: "Errata" }
         end
+
+        def to_s
+          return base_identifier.to_s unless base_identifier
+
+          # Format: ASHRAE Guideline 0-2005 Errata (September 28, 2011)
+          result = base_identifier.to_s
+          result += " Errata"
+          result += " (#{errata_date})" if errata_date
+          result
+        end
       end
     end
   end

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

@@ -8,9 +8,6 @@ module Pubid
       # ASHRAE Guideline identifier
       # Example: ASHRAE Guideline 0-2019, ASHRAE Guideline 1.5
       class Guideline < SingleIdentifier
-        # The relaton index key. Declared on the LEAF, not on the shared
-        # Identifier that SupplementIdentifier also inherits — see base.rb.
-        attribute :number, :string
         attribute :type, :string, default: "Guideline"
 
         TYPED_STAGES = [

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

@@ -11,22 +11,6 @@ module Pubid
       # - Interpretations for Standard 15.2-2022
       # - Interpretations for Standard 52.1-1992
       class Interpretation < SupplementIdentifier
-        # Mirrors its four sibling supplement types: without it
-        # Renderers::MrString slugs the interpretation FLAT off attributes it
-        # does not have, instead of recursing into `base`.
-        #
-        # Currently unreachable, and NOT because of alternation ordering:
-        # rule(:interpretation_identifier) is reached and does match, but it
-        # never wraps its output in `.as(:interpretation_identifier)`, so
-        # Builder#build's branch for that key is dead code and the tree falls
-        # through to the plain-Standard path (pre-existing; pinned in
-        # spec/pubid/ashrae/root_number_spec.rb, hand-off
-        # ashrae-interpretation-collapses-onto-base). Added anyway so that
-        # fixing the dispatch does not silently ship malformed filenames.
-        def mr_supplement_suffix
-          "interp"
-        end
-
         TYPED_STAGES = [
           Components::TypedStage.new(
             abbr: ["Interpretations"],
@@ -39,6 +23,16 @@ module Pubid
           { key: :interpretation, title: "ASHRAE Interpretations",
             short: "Interpretations" }
         end
+
+        def to_s
+          return base_identifier.to_s unless base_identifier
+
+          # Format: Interpretations for Standard 15.2-2022
+          base_type = base_identifier.type || "Standard"
+          result = "Interpretations for #{base_type} #{base_identifier.code}"
+          result += "-#{base_identifier.year}" if base_identifier.year
+          result
+        end
       end
     end
   end

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

@@ -8,9 +8,6 @@ module Pubid
       # ASHRAE Standard identifier
       # Example: ASHRAE Standard 15-2024, ASHRAE Standard 90.1-2022
       class Standard < SingleIdentifier
-        # The relaton index key. Declared on the LEAF, not on the shared
-        # Identifier that SupplementIdentifier also inherits — see base.rb.
-        attribute :number, :string
         attribute :type, :string, default: "Standard"
 
         TYPED_STAGES = [