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

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

data/lib/pubid/bipm/builder.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    # Turns the parse tree into the matching concrete identifier. Each root
+    # branch tags its subtree with a distinct key, so dispatch is a lookup on
+    # which key the parser produced.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        if data[:committee_short]
+          build_committee(data[:committee_short], form: "short")
+        elsif data[:committee_long_en]
+          build_committee(data[:committee_long_en], form: "long", language: "E")
+        elsif data[:committee_bare]
+          # Bare MRA form: no type word, so build_committee yields nil type.
+          build_committee(data[:committee_bare], form: "short")
+        elsif data[:committee_long_fr]
+          build_committee(data[:committee_long_fr], form: "long", language: "F")
+        elsif data[:meeting_en]
+          build_meeting(data[:meeting_en])
+        elsif data[:meeting_fr]
+          build_meeting(data[:meeting_fr], language: "F")
+        elsif data.key?(:metrologia)
+          build_metrologia(data[:metrologia])
+        elsif data[:si_brochure]
+          build_si_brochure(data[:si_brochure])
+        elsif data[:si_brochure_variant]
+          build_si_brochure_variant(data[:si_brochure_variant])
+        elsif data.key?(:si_brochure_section)
+          build_si_brochure_section(data[:si_brochure_section])
+        elsif data[:mep]
+          build_mep(data[:mep])
+        elsif data[:guide]
+          build_guide(data[:guide])
+        else
+          raise "Unrecognized BIPM parse tree: #{data.inspect}"
+        end
+      end
+
+      private
+
+      # `group` and `language` are normalized here, so a historic committee
+      # name (CCDS) and a two-letter language code (EN/FR) never reach an
+      # attribute — the index stores only the current name and the one-letter
+      # code BIPM prints.
+      def build_committee(node, form:, language: nil)
+        Identifiers::CommitteeDocument.new(
+          group: Identifier.normalize_group(node[:group]),
+          type_code: Identifier::TYPE_WORD_TO_CODE[node[:type_word].to_s],
+          number: node[:number]&.to_s,
+          year: node[:year]&.to_s&.to_i,
+          language: Identifier.normalize_language(language || node[:language]),
+          form: form,
+        )
+      end
+
+      def build_meeting(node, language: nil)
+        Identifiers::Meeting.new(
+          group: Identifier.normalize_group(node[:group]),
+          number: node[:number].to_s,
+          year: node[:year]&.to_s&.to_i,
+          language: Identifier.normalize_language(language || node[:language]),
+        )
+      end
+
+      # `number` is the volume, so every article of a volume clusters into one
+      # relaton-index bucket (the IETF draft-slug / IANA registry-slug
+      # convention). It is nil only for the journal-level record, which carries
+      # no volume at all.
+      #
+      # It is deliberately redundant with `volume`, which stays because the
+      # renderer and the URN generator read it. Two limits of that redundancy,
+      # both accepted rather than engineered around (see the note above
+      # NUMBER_SOURCE_ATTRIBUTES in identifier.rb for the half that IS
+      # handled):
+      #
+      #   * THE BUILDER IS THE CONSTRUCTOR OF RECORD. A caller that bypasses it
+      #     — `MetrologiaArticle.new(volume: 51, …)` — gets a nil `number` and
+      #     so an empty index key. Deriving it in `initialize` instead would
+      #     cover that, but `#exclude` rebuilds through `self.class.new`, so it
+      #     would also silently re-fill a `number` the caller just excluded.
+      #   * NO SELF-HEALING ACROSS from_hash. lutaml assigns attributes AFTER
+      #     `initialize`, so a legacy pre-`number` index row (one carrying only
+      #     `volume`) deserializes with `number` nil and no error at all —
+      #     lutaml ignores unknown keys and relaton's `id_supported?` skips its
+      #     round-trip check for concrete subclasses, which every BIPM id is.
+      #     relaton-data-bipm must regenerate index-v2 to gain the key. This is
+      #     weaker than the IEEE `CodeNumber` mixin, which rebuilds `code_obj`
+      #     from its split columns after `from_hash`.
+      def build_metrologia(node)
+        node = {} unless node.is_a?(Hash)
+        Identifiers::MetrologiaArticle.new(
+          number: node[:volume]&.to_s,
+          issue: node[:issue]&.to_s,
+          article: node[:article]&.to_s,
+        )
+      end
+
+      # The SI Brochure has no document number of its own, so the edition is
+      # the index key — it clusters the English and French records of one
+      # edition. The grammar makes `edition` mandatory here, so it is never nil.
+      def build_si_brochure(node)
+        Identifiers::SiBrochure.new(
+          number: node[:edition].to_s,
+          edition: node[:edition].to_s,
+          version: node[:version].to_s,
+          years: node[:years].to_s,
+          language: Identifier.normalize_language(node[:language]),
+        )
+      end
+
+      # The derived products (Appendix N, Concise, FAQ) carry no edition, so
+      # the variant name is their key. The grammar makes it mandatory here.
+      def build_si_brochure_variant(node)
+        variant = node[:variant].to_s
+        Identifiers::SiBrochure.new(number: variant, variant: variant)
+      end
+
+      # A bare or sectioned reference names no edition, so it gets no key: it is
+      # a partial reference that wildcards every edition. The bare form captures
+      # nothing, so the parser hands back a slice rather than a hash.
+      def build_si_brochure_section(node)
+        node = {} unless node.is_a?(Hash)
+        Identifiers::SiBrochure.new(part: node[:part]&.to_s)
+      end
+
+      # The Appendix/Annex/Part tail is the full-content spelling of the SAME
+      # document, so it stays out of the key.
+      def build_mep(node)
+        Identifiers::Mep.new(
+          **mep_codes(node),
+          appendix: node[:appendix]&.to_s,
+          annex: node[:annex]&.to_s,
+          part: node[:part]&.to_s,
+        )
+      end
+
+      # A MEP is identified by its unit code, or by the report code for the
+      # `Rapport BIPM-YYYY/NN` variant; exactly one of the two is set, and
+      # whichever it is becomes the relaton index key.
+      def mep_codes(node)
+        mep_code = node[:mep_code]&.to_s
+        report_code = node[:report_code]&.to_s
+        { number: mep_code || report_code, mep_code: mep_code,
+          report_code: report_code }
+      end
+
+      def build_guide(node)
+        Identifiers::Guide.new(
+          group: Identifier.normalize_group(node[:group]),
+          guide_kind: node[:guide_kind].to_s,
+          number: node[:number].to_s,
+          appendix: node[:appendix]&.to_s,
+          part: node[:part]&.to_s,
+        )
+      end
+    end
+  end
+end