pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.11

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

@@ -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
@@ -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
@@ -205,7 +217,7 @@ 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)
@@ -228,7 +240,7 @@ 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)
@@ -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]
@@ -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]
@@ -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
 
@@ -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/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"],

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"],

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

@@ -8,16 +8,25 @@ module Pubid
       # 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.
@@ -25,6 +34,74 @@ module Pubid
       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
@@ -38,6 +115,5 @@ module Pubid
         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"],

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/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)
@@ -655,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
@@ -63,7 +63,7 @@ module Pubid
         if id.copublisher
           "#{id.copublisher} Addendum #{id.addendum_code} to #{id.base}"
         else
-          result = "ASHRAE Addendum #{id.addendum_code} to #{base_type} #{id.base.code}"
+          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 }
@@ -73,7 +73,7 @@ module Pubid
       def render_addenda_package(id)
         return id.base.to_s unless id.base
 
-        result = "ASHRAE #{id.base.type || 'Standard'} #{id.base.code}"
+        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
@@ -85,9 +85,9 @@ module Pubid
 
         base_type = id.base.type || "Standard"
         if id.addendum_codes
-          result = "ASHRAE Addenda #{id.addendum_codes} to #{base_type} #{id.base.code}"
+          result = "ASHRAE Addenda #{id.addendum_codes} to #{base_type} #{id.base.number}"
         else
-          result = "ASHRAE Addenda to #{base_type} #{id.base.code}"
+          result = "ASHRAE Addenda to #{base_type} #{id.base.number}"
         end
         result += "-#{id.base.year}" if id.base.year
         result
@@ -108,7 +108,7 @@ module Pubid
         return id.base.to_s unless id.base
 
         base_type = id.base.type || "Standard"
-        result = "Interpretations for #{base_type} #{id.base.code}"
+        result = "Interpretations for #{base_type} #{id.base.number}"
         result += "-#{id.base.year}" if id.base.year
         result
       end

data/lib/pubid/ashrae/supplement_identifier.rb

@@ -14,9 +14,24 @@ module Pubid
         base&.publisher
       end
 
-      # Delegate code to base
+      # 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&.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
@@ -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)

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