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

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

@@ -13,6 +13,15 @@ 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"],

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

@@ -8,6 +8,9 @@ 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,6 +11,22 @@ 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"],

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

@@ -8,6 +8,9 @@ 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 = [

data/lib/pubid/ashrae/identifiers.rb

@@ -5,7 +5,6 @@ module Pubid
     module Identifiers
       autoload :AddendaPackage, "#{__dir__}/identifiers/addenda_package"
       autoload :Addendum, "#{__dir__}/identifiers/addendum"
-      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :CombinedAddenda, "#{__dir__}/identifiers/combined_addenda"
       autoload :Errata, "#{__dir__}/identifiers/errata"
       autoload :Guideline, "#{__dir__}/identifiers/guideline"

data/lib/pubid/ashrae/parser.rb

@@ -6,7 +6,7 @@ module Pubid
   module Ashrae
     # Parser class for ASHRAE identifiers
     # Single Responsibility: Parsing ASHRAE identifier syntax
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:space?) { space.maybe }
@@ -54,15 +54,25 @@ module Pubid
       end
 
       # Code with year pattern (e.g., 34-2024, 62.1-2022, 90A-2010) - used when type is missing
+      #
+      # The code portion MUST be captured with `.as(:code)`. Without it the
+      # digits were matched and then discarded — only the year was named — so
+      # every identifier reaching this rule lost its document number: 48 corpus
+      # ids rendered as "ANSI/ASHRAE Addendum a to ASHRAE Standard -2024",
+      # number gone and a dangling dash left behind. Builder#extract_base_attributes
+      # already read `code_with_year[:code]`; it was waiting for a value the
+      # grammar never produced.
       rule(:code_with_year) do
         (
-          digits >> # First part (e.g., 34, 62)
-          (dot >> digits).repeat(0, 2) >> # Optional dotted parts (e.g., .1)
-          # Special pattern for codes like "90A,B,C-2010"
           (
-            letter >> # Single letter after digits
-            (comma >> letter).repeat(0, 10) # Optional comma-separated letters
-          ).maybe >>
+            digits >> # First part (e.g., 34, 62)
+            (dot >> digits).repeat(0, 2) >> # Optional dotted parts (e.g., .1)
+            # Special pattern for codes like "90A,B,C-2010"
+            (
+              letter >> # Single letter after digits
+              (comma >> letter).repeat(0, 10) # Optional comma-separated letters
+            ).maybe
+          ).as(:code) >>
           space?.maybe >> dash >>
           year_digits.as(:year)
         ).as(:code_with_year)
@@ -166,7 +176,7 @@ module Pubid
           (space >> additional_copublisher).maybe >>
           suffix.maybe >>
           reaffirmed.maybe
-        ).as(:base_identifier) >>
+        ).as(:base) >>
           space >>
           str("Errata").as(:errata_keyword) >>
           (
@@ -188,7 +198,7 @@ module Pubid
             (space >> additional_copublisher).maybe >>
             suffix.maybe >>
             reaffirmed.maybe
-          ).as(:base_identifier) >>
+          ).as(:base) >>
             space >>
             str("Errata").as(:errata_keyword) >>
             (
@@ -207,7 +217,7 @@ module Pubid
             (space >> additional_copublisher).maybe >>
             suffix.maybe >>
             reaffirmed.maybe
-          ).as(:base_identifier) >>
+          ).as(:base) >>
             space >>
             str("Errata").as(:errata_keyword) >>
             errata_date.maybe >>
@@ -219,7 +229,7 @@ module Pubid
       rule(:interpretation_identifier) do
         str("Interpretations") >> space >>
           str("for") >> space >>
-          (type.as(:type) >> space >> code >> (dash >> year_digits.as(:year)).maybe).as(:base_identifier)
+          (type.as(:type) >> space >> code >> (dash >> year_digits.as(:year)).maybe).as(:base)
       end
 
       # Combined Addenda pattern (multiple addendums grouped together)
@@ -607,9 +617,12 @@ module Pubid
           year_first_addenda_package_identifier |
           addenda_package_identifier |
           addendum_identifier |
-          # Standalone copublisher pattern (ANSI/AMCA 210-99, AMCA 210-99)
-          (((str("ANSI") >> slash).maybe >> letter.repeat(2,
-                                                          10)).as(:copublisher) >>
+          # Standalone copublisher pattern (ANSI/AMCA 210-99, AMCA 210-99).
+          # The literal "ASHRAE" is excluded here so a bare "ASHRAE <code>-<year>"
+          # is not swallowed as a copublisher and instead falls through to the
+          # ASHRAE-publisher branch below.
+          (((str("ANSI") >> slash).maybe >> (str("ASHRAE").absent? >> letter).repeat(2,
+                                                                                     10)).as(:copublisher) >>
             space >>
             code_with_year >>
             optional_suffix.repeat(0, 2)) |
@@ -635,9 +648,11 @@ module Pubid
             suffix.maybe >>
             reaffirmed.maybe >>
             optional_suffix.repeat(0, 2)) |
-          # Standard ASHRAE pattern
+          # Standard ASHRAE pattern. The type keyword is optional so a bare
+          # partial reference "ASHRAE <code>" (no "Standard"/"Guideline") parses;
+          # the builder defaults the absent type to "Standard".
           (publisher.as(:publisher) >> space >>
-            type.as(:type) >> space >>
+            (type.as(:type) >> space).maybe >>
             code >>
             (space?.maybe >> dash >> year_digits.as(:year)).maybe >>
             (space >> additional_copublisher).maybe >>
@@ -650,8 +665,13 @@ module Pubid
       root(:identifier)
 
       def self.parse(string)
+        unless string.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if string.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         # Strip leading/trailing whitespace

data/lib/pubid/ashrae/renderer.rb

@@ -46,7 +46,7 @@ module Pubid
         parts << id.type.to_s if id.type
         result = parts.join(" ")
         result += " " if result.length.positive?
-        result += id.code.to_s
+        result += id.number.to_s
         result += "-#{id.year}" if id.year
         result += " (#{id.amendment})" if id.amendment
         result += id.suffix if id.suffix
@@ -56,48 +56,48 @@ module Pubid
 
       # Addendum: "ASHRAE Addendum a to Standard 15-2001"
       def render_addendum(id)
-        return id.base_identifier.to_s unless id.base_identifier
+        return id.base.to_s unless id.base
 
-        base_type = id.base_identifier.type || "Standard"
+        base_type = id.base.type || "Standard"
 
         if id.copublisher
-          "#{id.copublisher} Addendum #{id.addendum_code} to #{id.base_identifier}"
+          "#{id.copublisher} Addendum #{id.addendum_code} to #{id.base}"
         else
-          result = "ASHRAE Addendum #{id.addendum_code} to #{base_type} #{id.base_identifier.code}"
-          result += "-#{id.base_identifier.year}" if id.base_identifier.year
+          result = "ASHRAE Addendum #{id.addendum_code} to #{base_type} #{id.base.number}"
+          result += "-#{id.base.year}" if id.base.year
           result
         end.tap { |r| r << " (#{id.addendum_date})" if id.addendum_date }
       end
 
       # AddendaPackage: "ASHRAE Standard 52.2-1999: Addenda Supplement Package"
       def render_addenda_package(id)
-        return id.base_identifier.to_s unless id.base_identifier
+        return id.base.to_s unless id.base
 
-        result = "ASHRAE #{id.base_identifier.type || 'Standard'} #{id.base_identifier.code}"
-        result += "-#{id.base_identifier.year}" if id.base_identifier.year
+        result = "ASHRAE #{id.base.type || 'Standard'} #{id.base.number}"
+        result += "-#{id.base.year}" if id.base.year
         result += ": Addenda #{id.package_description}" if id.package_description
         result
       end
 
       # CombinedAddenda: "ASHRAE Addenda c and d to Standard 15-1994"
       def render_combined_addenda(id)
-        return id.base_identifier.to_s unless id.base_identifier
+        return id.base.to_s unless id.base
 
-        base_type = id.base_identifier.type || "Standard"
+        base_type = id.base.type || "Standard"
         if id.addendum_codes
-          result = "ASHRAE Addenda #{id.addendum_codes} to #{base_type} #{id.base_identifier.code}"
+          result = "ASHRAE Addenda #{id.addendum_codes} to #{base_type} #{id.base.number}"
         else
-          result = "ASHRAE Addenda to #{base_type} #{id.base_identifier.code}"
+          result = "ASHRAE Addenda to #{base_type} #{id.base.number}"
         end
-        result += "-#{id.base_identifier.year}" if id.base_identifier.year
+        result += "-#{id.base.year}" if id.base.year
         result
       end
 
       # Errata: "ASHRAE Guideline 0-2005 Errata (September 28, 2011)"
       def render_errata(id)
-        return id.base_identifier.to_s unless id.base_identifier
+        return id.base.to_s unless id.base
 
-        result = id.base_identifier.to_s
+        result = id.base.to_s
         result += " Errata"
         result += " (#{id.errata_date})" if id.errata_date
         result
@@ -105,11 +105,11 @@ module Pubid
 
       # Interpretation: "Interpretations for Standard 15.2-2022"
       def render_interpretation(id)
-        return id.base_identifier.to_s unless id.base_identifier
+        return id.base.to_s unless id.base
 
-        base_type = id.base_identifier.type || "Standard"
-        result = "Interpretations for #{base_type} #{id.base_identifier.code}"
-        result += "-#{id.base_identifier.year}" if id.base_identifier.year
+        base_type = id.base.type || "Standard"
+        result = "Interpretations for #{base_type} #{id.base.number}"
+        result += "-#{id.base.year}" if id.base.year
         result
       end
     end

data/lib/pubid/ashrae/single_identifier.rb

@@ -4,7 +4,7 @@ module Pubid
   module Ashrae
     # Base class for single (non-supplement) ASHRAE identifiers
     # Includes: Guideline, Standard
-    class SingleIdentifier < Identifiers::Base
+    class SingleIdentifier < Identifier
     end
   end
 end

data/lib/pubid/ashrae/supplement_identifier.rb

@@ -6,17 +6,32 @@ module Pubid
   module Ashrae
     # Base class for supplement identifiers (addendums, errata, interpretations)
     # Supplements modify or add to a base document
-    class SupplementIdentifier < Identifiers::Base
-      attribute :base_identifier, Identifiers::Base, polymorphic: true
+    class SupplementIdentifier < Identifier
+      attribute :base, Identifier, polymorphic: true
 
-      # Delegate publisher to base_identifier
+      # Delegate publisher to base
       def publisher
-        base_identifier&.publisher
+        base&.publisher
       end
 
-      # Delegate code to base_identifier
+      # Delegate the document code to the base standard.
+      #
+      # The BODY had to move with the `code` -> `number` rename — it was
+      # `base&.code`, and `code` no longer exists anywhere in the hierarchy, so
+      # it raised NoMethodError on every Errata/Addendum/CombinedAddenda/
+      # AddendaPackage/Interpretation. Nothing inside lib/pubid/ashrae calls
+      # it, which is exactly why the suite stayed green while a public method
+      # on five types was broken.
+      #
+      # The NAME deliberately stays `code`. Renaming it to `number` looks
+      # tidier and is wrong twice over: `number` is an inherited lutaml
+      # attribute typed Components::Code, so a String-returning method of that
+      # name makes `to_hash` raise IncorrectModelError on every supplement —
+      # and even typed correctly it would serialize a duplicate of the base's
+      # number onto the wrapper. `code` is not an attribute anywhere, so it is
+      # free to be a plain reader. Use `#root.number` for the index key.
       def code
-        base_identifier&.code
+        base&.number
       end
     end
   end

data/lib/pubid/ashrae/urn_generator.rb

@@ -3,10 +3,16 @@
 module Pubid
   module Ashrae
     class UrnGenerator < Pubid::UrnGenerator::Base
+      # A supplement carries no number of its own — only the two
+      # single-document leaves declare one — so reach it through #root, which
+      # walks `base` to the standard the supplement attaches to. Without the
+      # fallback every Errata/Addendum URN lost its number when `code` moved
+      # off the shared base onto the leaves.
       def urn_number
-        return nil unless identifier.code
+        num = identifier.number || identifier.root.number
+        return nil if num.nil? || num.to_s.empty?
 
-        identifier.code.to_s
+        num.to_s
       end
 
       def urn_suffix

data/lib/pubid/ashrae.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Ashrae
     extend Pubid::PrefixesSupport
@@ -9,7 +10,7 @@ module Pubid
     PREFIXES = ["ASHRAE"].freeze
 
     autoload :Builder, "#{__dir__}/ashrae/builder"
-    autoload :Identifier, "#{__dir__}/ashrae/identifier"
+    autoload :Identifier, "#{__dir__}/ashrae/identifiers/base"
     autoload :Identifiers, "#{__dir__}/ashrae/identifiers"
     autoload :Parser, "#{__dir__}/ashrae/parser"
     autoload :Renderer, "#{__dir__}/ashrae/renderer"
@@ -19,8 +20,13 @@ module Pubid
     autoload :UrnParser, "#{__dir__}/ashrae/urn_parser"
 
     def self.parse(identifier)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
       if identifier.length > Pubid::MAX_INPUT_LENGTH
-        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
       Identifier.parse(identifier)
@@ -68,5 +74,5 @@ end
 Pubid::Registry.register(:ashrae, Pubid::Ashrae)
 
 # Per-flavor format registry: inherits global formats, overrides :human
-Pubid::Ashrae::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::Ashrae::Identifiers::Base.format_registry.register(:human, renderer: Pubid::Ashrae::Renderer)
+Pubid::Ashrae::Identifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Ashrae::Identifier.format_registry.register(:human, renderer: Pubid::Ashrae::Renderer)

data/lib/pubid/asme/builder.rb

@@ -21,9 +21,18 @@ module Pubid
           identifier.publisher = "ASME"
         end
 
-        # Build code component
+        # The code is stored as flat index columns on the leaf (see
+        # Identifiers::Standard) — `number` is what relaton-index keys on — so
+        # the Code built below is unpacked rather than assigned.
         if parsed_hash[:designator]
-          identifier.code = build_code(parsed_hash)
+          identifier.number = build_code(parsed_hash).to_s
+        elsif parsed_hash[:number]
+          # A joint-published reference ("ISO/ASME 14414-2015") parses to a bare
+          # `number` with no designator. The designator-only guard above dropped
+          # it, so the document number was lost from BOTH the identifier and its
+          # rendering: `to_s` was "ISO/ASME-2015". Pre-existing; recovering it
+          # is what gives these ids an index key.
+          identifier.number = parsed_hash[:number].to_s
         end
 
         # Set PTC suffix

data/lib/pubid/asme/identifier.rb

@@ -4,6 +4,15 @@ module Pubid
   module Asme
     class Identifier < Pubid::Identifier
       def self.parse(str)
+        unless str.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if str.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         parser = Parser.new
         builder = Builder.new
 

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

@@ -4,8 +4,92 @@ module Pubid
   module Asme
     module Identifiers
       class Standard < Base
-        # Standard extends Base with no additional attributes
-        # All functionality inherited from Base
+        # --- Index columns -------------------------------------------------
+        #
+        # relaton-index sorts and bsearches every row on
+        # `id.root.number.to_s`. ASME used to keep the code inside an
+        # Asme::Components::Code under a `code` attribute, leaving the
+        # inherited `number` nil and every row keyed "".
+        #
+        # `number` holds the WHOLE printed code — "B18.3", "A112.19.12",
+        # "BPVC-CC-BPV" — not a designator/number split.
+        #
+        # The split looks tempting (it is what IEEE does) but it cannot key
+        # this corpus: 152 of the 731 fixture ids are Boiler and Pressure
+        # Vessel Code documents whose entire identity IS the designator
+        # ("BPVC COMPLETE CODE BIND", "BPVC.CC.BPV") with no numeric part at
+        # all. Splitting leaves every one of them with an empty key, and
+        # inventing a number for them would be inventing data.
+        #
+        # Nothing is lost by joining: Components::Code#render is a plain
+        # concatenation of designator and number, and the only readers of
+        # `code` anywhere in lib/pubid/asme are `code.to_s` (renderer.rb,
+        # urn_generator.rb). Keying on the whole code also clusters editions of
+        # one document, which is what relaton narrows on — an ASME reference is
+        # always written "ASME B18.3", never "18.3" alone.
+        #
+        # LANDMINE: `number` redefines the Components::Code attribute inherited
+        # from ::Pubid::Identifier, which resolves nondeterministically when
+        # declared on a class others inherit from. Standard is the only
+        # concrete ASME type and has no subclasses, so it is declared here and
+        # never on SingleIdentifier / Identifiers::Base.
+        # spec/pubid/asme/root_number_spec.rb carries the tripwire and is only
+        # meaningful under the full `rake` suite.
+        # There is deliberately no `#code` reader here. An earlier draft had one
+        # composing `Components::Code.new(number: number)` so the renderer and
+        # the URN generator would not have to change — but because `number`
+        # holds the whole printed code, that Code never carried a designator and
+        # `code.to_s` equalled `number` for all 731 corpus ids. It wrapped a
+        # string in an object whose only job was to unwrap to the same string.
+        # Both readers now use `number` directly.
+        #
+        # ASTM keeps its composed `#code` (Identifiers::CodeNumber) for the
+        # opposite reason: its renderer reads `code.letter` / `code.dual_m`
+        # field-by-field, so the component there carries real structure.
+        attribute :number, :string
+
+        # MR slug. Before the index column landed, every ASME slug was just
+        # "asme": 722 of 731 documents shared one filename, and `to_slug` is
+        # what consumers use as an output filename.
+        #
+        # `handbook` is identity-bearing — it is in the serialized hash and in
+        # `==`, and "ASME A17.1/CSA B44-2019" and "ASME A17.1/CSA B44
+        # Handbook-2019" are different documents — so it has to reach the slug
+        # too. CLAUDE.md's rule: a marker that only reaches `==` still lets two
+        # documents share a filename.
+        def mr_number_with_part
+          mr_join(mr_sanitize(number), (handbook ? "handbook" : nil))
+        end
+
+        # ASME keeps its edition in a plain `year` string, not the inherited
+        # `date`, so the base `mr_year` hook read nil and every edition of one
+        # standard shared a slug.
+        def mr_year
+          year&.to_s
+        end
+
+        # ASME keeps a translation marker in a plain `language` string, not the
+        # inherited `languages` collection the base hook reads. Without this,
+        # "ASME B31.8-2016" and its Spanish edition "ASME B31.8 (SPANISH)-2016"
+        # — different documents, and #== agrees — share one filename.
+        def mr_languages
+          language&.to_s&.downcase
+        end
+
+        # An ASME code legitimately contains "." (B18.3), "-" (BPVC-CC-BPV),
+        # "&" (V&V) and spaces ("BPVC COMPLETE CODE BIND"). Renderers::MrString
+        # joins SEGMENTS with ".", so a dot inside one breaks that structure —
+        # filter by charset, the BIPM `mr_slug` precedent, rather than by an
+        # enumerated escape list. 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.
+        def mr_sanitize(value)
+          return nil if value.nil? || value.to_s.empty?
+
+          sanitized = value.to_s.downcase
+            .gsub(/[^a-z0-9-]+/, "-").gsub(/\A-+|-+\z/, "")
+          sanitized.empty? ? nil : sanitized
+        end
       end
     end
   end

data/lib/pubid/asme/parser.rb

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

data/lib/pubid/asme/renderer.rb

@@ -22,15 +22,15 @@ module Pubid
           parts << id.first_publisher
           parts << id.first_code
           parts << "/#{id.second_publisher}" if id.second_publisher
-          parts << id.code.to_s if id.code && id.code.to_s != ""
+          parts << id.number.to_s if id.number && id.number.to_s != ""
         elsif id.joint_publisher
           # ISO/ASME or ASME/ANS format
           parts << id.joint_publisher
-          parts << id.code.to_s if id.code && id.code.to_s != ""
+          parts << id.number.to_s if id.number && id.number.to_s != ""
         else
           # Standard ASME format
           parts << id.publisher if id.publisher
-          parts << id.code.to_s if id.code
+          parts << id.number.to_s if id.number
         end
 
         result = parts.join(" ")

data/lib/pubid/asme/single_identifier.rb

@@ -10,7 +10,14 @@ module Pubid
       # @return [String] URN representation
 
       attribute :publisher, :string
-      attribute :code, Components::Code
+      # The document code lives on the concrete leaf as a single `number`
+      # column holding the WHOLE printed code ("B18.3", "BPVC-CC-BPV") — see
+      # Identifiers::Standard, which explains why it is not split into
+      # designator + number. It cannot be declared here: SingleIdentifier is
+      # inherited by Identifiers::Base and Identifiers::Standard, and
+      # redefining the `number` that ::Pubid::Identifier types as a
+      # Components::Code on an inherited-from class resolves
+      # nondeterministically under multi-flavor load.
       attribute :year, :string
       attribute :reaffirmation, :string     # R2020
       attribute :language, :string          # (SPANISH)

data/lib/pubid/asme/urn_generator.rb

@@ -11,8 +11,8 @@ module Pubid
 
         parts << publisher_component
 
-        if identifier.code
-          parts << identifier.code.to_s
+        if identifier.number
+          parts << identifier.number.to_s
         end
 
         part = maybe(:part)

data/lib/pubid/asme.rb

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

data/lib/pubid/astm/builder.rb

@@ -8,9 +8,16 @@ module Pubid
         identifier_class = determine_identifier_class(parsed_hash)
         identifier = identifier_class.new
 
-        # Build code component if present
+        # The code is stored as flat index columns on every concrete class (see
+        # Identifiers::CodeNumber) — `number` is what relaton-index keys on —
+        # so the Code built below is unpacked rather than assigned.
         if parsed_hash[:letter] || parsed_hash[:number]
-          identifier.code = build_code(parsed_hash)
+          code = build_code(parsed_hash)
+          identifier.letter = code.letter
+          identifier.number = code.number
+          identifier.suffix = code.suffix
+          identifier.subseries = code.subseries
+          identifier.dual_m = code.dual_m || false
         end
 
         # Set publisher
@@ -119,7 +126,7 @@ module Pubid
 
         # Adjunct
         if identifier.is_a?(Identifiers::Adjunct)
-          identifier.designation = parsed_hash[:designation].to_s if parsed_hash[:designation]
+          identifier.number = parsed_hash[:designation].to_s if parsed_hash[:designation]
           identifier.ea_suffix = true if parsed_hash[:ea_suffix]
           identifier.dvd_suffix = true if parsed_hash[:dvd_suffix]
         end

data/lib/pubid/astm/identifier.rb

@@ -4,6 +4,15 @@ module Pubid
   module Astm
     class Identifier < Pubid::Identifier
       def self.parse(str)
+        unless str.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if str.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         parser = Parser.new
         builder = Builder.new