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

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
 

data/lib/pubid/astm/identifiers/adjunct.rb

@@ -4,7 +4,22 @@ module Pubid
   module Astm
     module Identifiers
       class Adjunct < SingleIdentifier
-        attribute :designation, :string      # D2148, F3504, G0088, C062702
+        include CodeNumber
+
+        # An adjunct carries no code at all — its whole identity is the
+        # designation ("ADJD2148"). relaton-index keys on
+        # `id.root.number.to_s`, so the designation IS the number here, the
+        # same reasoning that makes a registry slug IANA's number and a draft
+        # slug IETF's.
+        #
+        # It is stored in `number` itself rather than in a separate
+        # `designation` attribute shadowed by a `def number`. Two reasons, both
+        # from CLAUDE.md: defining a `#number` method alongside the attribute is
+        # the construct that corrupts lutaml's accessor resolution, and keeping
+        # both columns made `to_hash` emit the same string twice
+        # ({"number" => "D2148", "designation" => "D2148"}) — the duplication
+        # the BIPM note warns against. The builder assigns `number` and the
+        # renderer reads it; nothing else referenced `designation`.
         attribute :ea_suffix, :boolean       # -EA
         attribute :dvd_suffix, :boolean      # DVD
       end

data/lib/pubid/astm/identifiers/code_number.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      # Installs the flat, index-friendly code columns on every CONCRETE ASTM
+      # identifier class.
+      #
+      # Why every concrete class and not Pubid::Astm::SingleIdentifier, which
+      # they all inherit from: `number` redefines the parent
+      # ::Pubid::Identifier's `attribute :number, Components::Code` as a plain
+      # :string (Astm::Components::Code is not a subclass of it). Declaring that
+      # on a class the concrete types INHERIT from resolves against the parent
+      # definition nondeterministically under multi-flavor load — it passes an
+      # ASTM-only run and can flip `root.number` to "" under the full suite (the
+      # IEEE lesson; see lib/pubid/ieee/identifiers/code_number.rb and
+      # CLAUDE.md).
+      #
+      # NOTE the module is included by `Standard` AND by `IsoDualPublished`,
+      # which inherits from Standard. That is deliberate, not redundant: a class
+      # that is itself inherited from must still declare the columns so its
+      # subclass holds its own snapshot rather than relying on the parent's.
+      # Every instantiable ASTM class declares them for itself.
+      #
+      # This matters because relaton-index sorts and bsearches every row on
+      # `id.root.number.to_s`, and ASTM kept identity in an
+      # Astm::Components::Code under a `code` attribute, so all 248 parseable
+      # fixture ids keyed "".
+      module CodeNumber
+        def self.included(base)
+          # Bare document number ("2938"), the relaton index key. `letter` is a
+          # sibling column, so E2938 and D2938 narrow to the same bucket and
+          # are then separated by the full hash — the IEEE prefix/number split.
+          base.attribute :number, :string
+          base.attribute :letter, :string
+          base.attribute :suffix, :string
+          base.attribute :subseries, :string
+          # Named for the RARE case with a false default, so the canonical
+          # to_hash drops it from every ordinary row.
+          base.attribute :dual_m, :boolean, default: -> { false }
+        end
+
+        # The composed document code, rebuilt on demand from the split columns.
+        # ASTM's renderer reads the individual fields (`code.letter`,
+        # `code.number`, `code.dual_m`) in several places, so the component has
+        # to keep its structure rather than collapsing to a string as ASME's
+        # does.
+        #
+        # Deliberately NOT an attribute and NOT memoised: the columns are
+        # writable (the base #exclude rebuilds through them), so a cached Code
+        # would go stale. nil when there is no number and no letter, preserving
+        # the nil-`code` branches the renderer and URN generator both test.
+        def code
+          return nil if number.nil? && letter.nil?
+
+          Components::Code.new(
+            letter: letter,
+            number: number,
+            suffix: suffix,
+            subseries: subseries,
+            dual_m: dual_m,
+          )
+        end
+
+        # Every field of the code is identity-bearing — Code#to_s renders all
+        # of them and they are all in the serialized hash — so all of them must
+        # reach the slug, or two distinct documents share a filename.
+        # CLAUDE.md's rule: a marker that only reaches `==` is not enough.
+        def mr_number_with_part
+          segments = [letter, number, suffix].compact
+          segments << "s#{subseries}" if subseries
+          segments << "m" if dual_m
+          return nil if segments.empty?
+
+          segments.join("-").downcase.gsub(/[^a-z0-9-]+/, "-")
+            .gsub(/\A-+|-+\z/, "")
+        end
+      end
+    end
+  end
+end

data/lib/pubid/astm/identifiers/data_series.rb

@@ -4,6 +4,8 @@ module Pubid
   module Astm
     module Identifiers
       class DataSeries < Base
+        include CodeNumber
+
         attribute :hol_suffix, :boolean # HOL suffix
       end
     end

data/lib/pubid/astm/identifiers/iso_dual_published.rb

@@ -12,6 +12,22 @@ module Pubid
       # Distinguishing feature: Starts with digit (typically 5xxxx series)
       # These are ASTM's version of standards jointly developed with ISO
       class IsoDualPublished < Standard
+        # Re-included even though Standard already does. DO NOT "clean this
+        # up" — it compiles fine without it, passes most tests, and silently
+        # reintroduces the multi-flavor `number` determinism landmine for this
+        # class alone, visible only under the full suite.
+        #
+        # Two Ruby facts make the repeat both necessary and safe:
+        #   * `included(base)` fires on EVERY `include` call, so this gives
+        #     IsoDualPublished its own `attribute :number` resolved against its
+        #     own table rather than a snapshot inherited from Standard;
+        #   * `Module#include` does NOT re-insert a module already present via
+        #     a superclass, so CodeNumber keeps the ancestor position Standard
+        #     gave it — still BELOW Standard. That is what lets
+        #     Standard#mr_number_with_part's `super` reach CodeNumber's
+        #     implementation instead of being shadowed here.
+        include CodeNumber
+
         # Inherits all behavior from Standard:
         # - sub_year (a, b, c)
         # - reapproval ((2023))

data/lib/pubid/astm/identifiers/manual.rb

@@ -4,9 +4,19 @@ module Pubid
   module Astm
     module Identifiers
       class Manual < Base
+        include CodeNumber
+
         attribute :edition, :string          # 9TH, 2ND
         attribute :supplement, :boolean      # -SUP-
         attribute :tp_designation, :string   # TP for technical publications
+
+        # Both markers distinguish real documents that share a number —
+        # "ASTM MNL15-EB" vs "ASTM MNLTP15-EB", and "ASTM MNL20-2ND-EB" vs
+        # "ASTM MNL20-2ND-SUP-EB" — so both must reach the slug, not just the
+        # hash.
+        def mr_number_with_part
+          mr_join(tp_designation&.downcase, super, (supplement ? "sup" : nil))
+        end
       end
     end
   end

data/lib/pubid/astm/identifiers/monograph.rb

@@ -4,6 +4,8 @@ module Pubid
   module Astm
     module Identifiers
       class Monograph < Base
+        include CodeNumber
+
         attribute :edition, :string # 2ND, 4TH
       end
     end

data/lib/pubid/astm/identifiers/research_report.rb

@@ -4,7 +4,17 @@ module Pubid
   module Astm
     module Identifiers
       class ResearchReport < Base
+        include CodeNumber
+
         attribute :committee, :string # A01, C09
+
+        # Research-report numbers restart per committee, so the committee is
+        # part of the identity: "ASTM RR:A01-1001" and "ASTM RR:C09-1001" are
+        # different documents. The renderer already prints it; the slug has to
+        # carry it too or they share a filename.
+        def mr_number_with_part
+          mr_join(committee&.downcase, super)
+        end
       end
     end
   end

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

@@ -4,9 +4,19 @@ module Pubid
   module Astm
     module Identifiers
       class Standard < Base
+        include CodeNumber
+
         attribute :sub_year, :string        # a, b, c
         attribute :reapproval, :string      # (2023)
+
         attribute :edition, :string # e1
+
+        # A reapproved edition is a distinct document — "ASTM C1870-18(2024)"
+        # and "ASTM C1870-18" have different hashes — so the marker has to
+        # reach the slug as well as `==`, or they share a filename.
+        def mr_number_with_part
+          mr_join(super, (reapproval ? "r#{reapproval}" : nil))
+        end
       end
     end
   end

data/lib/pubid/astm/identifiers/technical_report.rb

@@ -4,6 +4,8 @@ module Pubid
   module Astm
     module Identifiers
       class TechnicalReport < Base
+        include CodeNumber
+
       end
     end
   end

data/lib/pubid/astm/identifiers/work_in_progress.rb

@@ -4,6 +4,8 @@ module Pubid
   module Astm
     module Identifiers
       class WorkInProgress < Base
+        include CodeNumber
+
       end
     end
   end

data/lib/pubid/astm/identifiers.rb

@@ -4,6 +4,7 @@ module Pubid
   module Astm
     module Identifiers
       autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
       autoload :Standard, "#{__dir__}/identifiers/standard"
       autoload :IsoDualPublished, "#{__dir__}/identifiers/iso_dual_published"
       autoload :Manual, "#{__dir__}/identifiers/manual"

data/lib/pubid/astm/parser.rb

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

data/lib/pubid/astm/renderer.rb

@@ -131,7 +131,7 @@ module Pubid
       def render_adjunct(id)
         result = []
         result << id.publisher if id.publisher && !id.ea_suffix && !id.dvd_suffix
-        result << "ADJ#{id.designation}#{'-EA' if id.ea_suffix}#{'DVD' if id.dvd_suffix}"
+        result << "ADJ#{id.number}#{'-EA' if id.ea_suffix}#{'DVD' if id.dvd_suffix}"
         result.compact.join(" ")
       end
 

data/lib/pubid/astm/single_identifier.rb

@@ -9,9 +9,39 @@ module Pubid
       #
       # @return [String] URN representation
       attribute :publisher, :string, default: -> { "ASTM" }
-      attribute :code, Components::Code
+      # The document code lives on every concrete class as flat index columns
+      # (Identifiers::CodeNumber) — `number` is what relaton-index keys on. It
+      # cannot be declared here: SingleIdentifier is inherited by every ASTM
+      # type, and retyping the inherited `number` on an inherited-from class
+      # resolves nondeterministically under multi-flavor load.
       attribute :year, :string
       attribute :format_suffix, :string # -EB for eBook
+
+      # --- MR slug hooks -------------------------------------------------
+      #
+      # ASTM defined none, so the base hooks looked for an inherited
+      # `typed_stage`, `date` and `Components::Edition` that ASTM does not use.
+      # Two consequences, both measured on the corpus before this change:
+      # 201 of 248 ids shared the single slug "astm", and 40 of them RAISED —
+      # `mr_edition` calls `edition.number`, but ASTM's `edition` is a plain
+      # String. That is the same crash BIPM had, recorded in CLAUDE.md.
+      # `to_slug` is what consumers use as an output filename.
+      def mr_edition
+        edition&.to_s&.downcase
+      end
+
+      # ASTM keeps its edition year in a plain `year` string, not the
+      # inherited `date`.
+      def mr_year
+        year&.to_s
+      end
+
+      # The document type is the class, not a typed_stage: without it a
+      # Manual, a DataSeries and a Standard numbered alike share a filename.
+      def mr_type
+        self.class.name.split("::").last
+          .gsub(/([a-z])([A-Z])/, '\1-\2').downcase
+      end
     end
   end
 end

data/lib/pubid/astm/urn_generator.rb

@@ -17,11 +17,13 @@ module Pubid
           parts << identifier.code.to_s
         end
 
-        number = maybe(:number)
-        if number
-          num = number.to_s
-          parts << num
-        end
+        # `number` is deliberately NOT emitted here. It used to be dead code —
+        # ASTM kept everything in `code` and never set the `number` inherited
+        # from ::Pubid::Identifier, so `maybe(:number)` always returned nil.
+        # Now that `number` is the real index column and `code` is composed
+        # from it, emitting both would double the segment
+        # ("urn:astm:std:D2148:2148:22"). `code` already renders the number
+        # along with the letter and the suffixes.
 
         part = maybe(:part)
         if part

data/lib/pubid/astm.rb

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