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

data/lib/pubid/ashrae/identifiers.rb

@@ -5,6 +5,7 @@ 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 < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:space?) { space.maybe }
@@ -54,25 +54,15 @@ 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"
           (
-            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) >>
+            letter >> # Single letter after digits
+            (comma >> letter).repeat(0, 10) # Optional comma-separated letters
+          ).maybe >>
           space?.maybe >> dash >>
           year_digits.as(:year)
         ).as(:code_with_year)
@@ -176,7 +166,7 @@ module Pubid
           (space >> additional_copublisher).maybe >>
           suffix.maybe >>
           reaffirmed.maybe
-        ).as(:base) >>
+        ).as(:base_identifier) >>
           space >>
           str("Errata").as(:errata_keyword) >>
           (
@@ -198,7 +188,7 @@ module Pubid
             (space >> additional_copublisher).maybe >>
             suffix.maybe >>
             reaffirmed.maybe
-          ).as(:base) >>
+          ).as(:base_identifier) >>
             space >>
             str("Errata").as(:errata_keyword) >>
             (
@@ -217,7 +207,7 @@ module Pubid
             (space >> additional_copublisher).maybe >>
             suffix.maybe >>
             reaffirmed.maybe
-          ).as(:base) >>
+          ).as(:base_identifier) >>
             space >>
             str("Errata").as(:errata_keyword) >>
             errata_date.maybe >>
@@ -229,7 +219,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)
+          (type.as(:type) >> space >> code >> (dash >> year_digits.as(:year)).maybe).as(:base_identifier)
       end
 
       # Combined Addenda pattern (multiple addendums grouped together)
@@ -617,12 +607,9 @@ module Pubid
           year_first_addenda_package_identifier |
           addenda_package_identifier |
           addendum_identifier |
-          # 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) >>
+          # Standalone copublisher pattern (ANSI/AMCA 210-99, AMCA 210-99)
+          (((str("ANSI") >> slash).maybe >> letter.repeat(2,
+                                                          10)).as(:copublisher) >>
             space >>
             code_with_year >>
             optional_suffix.repeat(0, 2)) |
@@ -648,11 +635,9 @@ module Pubid
             suffix.maybe >>
             reaffirmed.maybe >>
             optional_suffix.repeat(0, 2)) |
-          # 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".
+          # Standard ASHRAE pattern
           (publisher.as(:publisher) >> space >>
-            (type.as(:type) >> space).maybe >>
+            type.as(:type) >> space >>
             code >>
             (space?.maybe >> dash >> year_digits.as(:year)).maybe >>
             (space >> additional_copublisher).maybe >>
@@ -665,15 +650,6 @@ 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 Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
         # Strip leading/trailing whitespace
         cleaned = string.strip
 

data/lib/pubid/ashrae/scheme.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Guideline,
+            Identifiers::Standard,
+            Identifiers::Addendum,
+            Identifiers::Interpretation,
+            Identifiers::Errata,
+            Identifiers::CombinedAddenda,
+            Identifiers::AddendaPackage,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "ASHRAE" if abbr.nil? || abbr.to_s.empty?
+
+          typed_stage = typed_stages.detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          identifier_klass = identifiers.detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ashrae/single_identifier.rb

@@ -4,7 +4,20 @@ module Pubid
   module Ashrae
     # Base class for single (non-supplement) ASHRAE identifiers
     # Includes: Guideline, Standard
-    class SingleIdentifier < Identifier
+    class SingleIdentifier < Identifiers::Base
+      def to_s
+        parts = []
+        parts << publisher if publisher
+        parts << type.to_s if type
+        result = parts.join(" ")
+        result += " " if result.length.positive?
+        result += code.to_s
+        result += "-#{year}" if year
+        result += " (#{amendment})" if amendment
+        result += suffix if suffix
+        result += " (RA#{reaffirmed})" if reaffirmed
+        result
+      end
     end
   end
 end

data/lib/pubid/ashrae/supplement_identifier.rb

@@ -6,32 +6,17 @@ module Pubid
   module Ashrae
     # Base class for supplement identifiers (addendums, errata, interpretations)
     # Supplements modify or add to a base document
-    class SupplementIdentifier < Identifier
-      attribute :base, Identifier, polymorphic: true
+    class SupplementIdentifier < Identifiers::Base
+      attribute :base_identifier, Identifiers::Base, polymorphic: true
 
-      # Delegate publisher to base
+      # Delegate publisher to base_identifier
       def publisher
-        base&.publisher
+        base_identifier&.publisher
       end
 
-      # 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.
+      # Delegate code to base_identifier
       def code
-        base&.number
+        base_identifier&.code
       end
     end
   end

data/lib/pubid/ashrae/urn_generator.rb

@@ -3,16 +3,18 @@
 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
-        num = identifier.number || identifier.root.number
-        return nil if num.nil? || num.to_s.empty?
+        return nil unless identifier.code
 
-        num.to_s
+        identifier.code.to_s
+      end
+
+      def urn_year
+        if identifier.year
+          return identifier.year.to_s
+        end
+
+        nil
       end
 
       def urn_suffix

data/lib/pubid/ashrae.rb

@@ -2,76 +2,20 @@
 
 module Pubid
   module Ashrae
-    extend Pubid::PrefixesSupport
-
-    # ASHRAE publisher token; the ANSI/ASHRAE joint form comes from
-    # Pubid::JOINT_PREFIXES.
-    PREFIXES = ["ASHRAE"].freeze
-
     autoload :Builder, "#{__dir__}/ashrae/builder"
-    autoload :Identifier, "#{__dir__}/ashrae/identifiers/base"
+    autoload :Identifier, "#{__dir__}/ashrae/identifier"
     autoload :Identifiers, "#{__dir__}/ashrae/identifiers"
     autoload :Parser, "#{__dir__}/ashrae/parser"
-    autoload :Renderer, "#{__dir__}/ashrae/renderer"
+    autoload :Scheme, "#{__dir__}/ashrae/scheme"
     autoload :SingleIdentifier, "#{__dir__}/ashrae/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/ashrae/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/ashrae/urn_generator"
-    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 Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-      end
-
       Identifier.parse(identifier)
     end
-
-    # Auto-discover all identifier types from the Identifiers namespace
-    # @return [Array<Class>] identifier classes that define a self.type Hash
-    def self.identifier_types
-      @identifier_types ||= Identifiers.constants
-        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
-        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
-        .select { |c| c.type.is_a?(Hash) }
-    end
-
-    # Build typed stage index from identifier types
-    # @return [Array<Pubid::Components::TypedStage>] all typed stages
-    def self.all_typed_stages
-      @all_typed_stages ||= identifier_types.flat_map do |klass|
-        if klass.const_defined?(:TYPED_STAGES)
-          klass.const_get(:TYPED_STAGES)
-        else
-          []
-        end
-      end
-    end
-
-    # Lookup: type code -> identifier class
-    # @param code [String, Symbol] the type key to find
-    # @return [Class, nil] the matching identifier class
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
-    end
-
-    # Lookup: abbreviation -> typed stage
-    # @param abbr [String, Symbol] the abbreviation to find
-    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
-    def self.locate_stage(abbr)
-      abbr_str = abbr.to_s.upcase
-      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
-    end
   end
 end
 
 # Register Uashrae flavor with the registry
 Pubid::Registry.register(:ashrae, Pubid::Ashrae)
-
-# Per-flavor format registry: inherits global formats, overrides :human
-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,18 +21,9 @@ module Pubid
           identifier.publisher = "ASME"
         end
 
-        # 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.
+        # Build code component
         if parsed_hash[:designator]
-          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
+          identifier.code = build_code(parsed_hash)
         end
 
         # Set PTC suffix

data/lib/pubid/asme/components/code.rb

@@ -5,19 +5,11 @@ require "lutaml/model"
 module Pubid
   module Asme
     module Components
-      # Code component for ASME identifiers.
-      #
-      # Stays independent of Pubid::Components::Code because ASME uses
-      # +designator+ (a flavor-specific letter prefix) plus +number+.
       class Code < Lutaml::Model::Serializable
-        attribute :designator, :string
-        attribute :number, :string
+        attribute :designator, :string    # B, Y, BPVC, etc.
+        attribute :number, :string        # 16.5, 14.43, III.1.NB, etc.
 
         def to_s
-          render
-        end
-
-        def render(context: nil)
           "#{designator}#{number}"
         end
       end

data/lib/pubid/asme/identifier.rb

@@ -4,15 +4,6 @@ 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/base.rb

@@ -4,6 +4,66 @@ module Pubid
   module Asme
     module Identifiers
       class Base < SingleIdentifier
+        def to_s
+          # Handle joint published identifiers
+          parts = []
+          if first_publisher && first_code
+            # CSA B44.10/ASME A17.10 or API 579-2/ASME PTB-14 format
+            parts << first_publisher
+            parts << first_code
+            parts << "/#{second_publisher}" if second_publisher
+            parts << code.to_s if code && code.to_s != ""
+
+          elsif joint_publisher
+            # ISO/ASME or ASME/ANS format
+            parts << joint_publisher
+            parts << code.to_s if code && code.to_s != ""
+
+          else
+            # Standard ASME format
+            parts << publisher if publisher
+            parts << code.to_s if code
+
+          end
+          result = parts.join(" ")
+
+          # PTC suffix (space-separated)
+          if ptc_suffix
+            result += " #{ptc_suffix}"
+          end
+
+          # CSA dual-published (for ASME/CSA format)
+          if csa_number
+            result += "/CSA #{csa_number}"
+          end
+
+          # Handbook keyword
+          if handbook
+            result += " Handbook"
+          end
+
+          # Year
+          if draft_year
+            result += "-#{draft_year}"
+          elsif year
+            result += "-#{year}"
+          end
+
+          # Parenthetical revision (comes after year)
+          result += " #{parenthetical_revision}" if parenthetical_revision
+
+          # Language (can appear in rendered output)
+          result += " (#{language})" if language
+
+          # Reaffirmation
+          result += " (#{reaffirmation})" if reaffirmation
+
+          # Revision note
+          result += " #{revision_note}" if revision_note
+
+          # Normalize all em-dashes (–, —) and en-dashes to regular dash (-)
+          result.gsub(/[–—]/, "-")
+        end
       end
     end
   end

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

@@ -4,92 +4,8 @@ module Pubid
   module Asme
     module Identifiers
       class Standard < 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
+        # Standard extends Base with no additional attributes
+        # All functionality inherited from Base
       end
     end
   end

data/lib/pubid/asme/parser.rb

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

data/lib/pubid/asme/scheme.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          @identifiers ||= [
+            Identifiers::Standard,
+          ].freeze
+        end
+
+        def supplement_identifiers
+          @supplement_identifiers ||= [].freeze
+        end
+
+        def typed_stages
+          @typed_stages ||= [].freeze
+        end
+
+        def supplement_typed_stages
+          @supplement_typed_stages ||= [].freeze
+        end
+
+        def locate_typed_stage_by_abbr(_abbr)
+          raise ArgumentError,
+                "ASME identifiers do not use typed stages"
+        end
+
+        def locate_identifier_klass_by_type_code(_type_code)
+          raise ArgumentError,
+                "ASME identifiers do not use type codes"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/asme/single_identifier.rb

@@ -2,22 +2,13 @@
 
 module Pubid
   module Asme
-    # Descends from Pubid::Asme::Identifier (the flavor base) so every concrete
-    # ASME identifier is `is_a?(Pubid::Asme::Identifier)`.
-    class SingleIdentifier < Identifier
+    class SingleIdentifier < Pubid::Identifier
       # Generate URN for this identifier
       #
       # @return [String] URN representation
 
       attribute :publisher, :string
-      # 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 :code, Components::Code
       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.number
-          parts << identifier.number.to_s
+        if identifier.code
+          parts << identifier.code.to_s
         end
 
         part = maybe(:part)