pubid 2.0.0.pre.alpha.12 → 2.0.0.pre.alpha.13

data/lib/pubid/amca/urn_parser.rb

@@ -5,23 +5,49 @@ module Pubid
     # Parses AMCA URNs back into identifiers.
     #
     # UrnGenerator emits:
-    #   urn:amca:{number}:{year}[:{copub.publisher}[:{other tokens}]]
+    #   urn:amca:{number}[:{year}][:{keyed tokens}][:{type}]
     #
-    # The current generator can leak the Type Hash literal into the URN
-    # (e.g., `copub.amca:{:key => :standard, ...}`). This parser filters
-    # any token containing `{` so round-trip works for the common case.
+    # The keyed tokens are `interp.<code>`, `rev.<revision>`,
+    # `reaff.<year>` and `copub.<publisher>`; the type is the key of the
+    # identifier class. The parser rebuilds the printed form from them and
+    # parses that, so the identifier comes back as the same class.
     #
     # Examples:
-    # - urn:amca:210:08              → AMCA 210-08
+    # - urn:amca:210:08                             → AMCA 210-08
+    # - urn:amca:211:22:rev.01-23:copub.amca:publication
+    #                            → AMCA Publication 211-22 (Rev. 01-23)
+    # - urn:amca:99:interp.jw:copub.amca:interpretation → AMCA 99 JW Interp
     class UrnParser < Pubid::UrnParser::Base
+      TYPE_TITLES = {
+        "standard" => "Standard",
+        "publication" => "Publication",
+      }.freeze
+
       def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body).reject { |p| p.include?("{") }
+        number, *rest = split_parts(strip_namespace(urn))
+        year = rest.shift if rest.first&.match?(/\A\d+\z/)
+        keyed = rest.grep(/\./).to_h { |token| token.split(".", 2) }
+        type = (rest - keyed.map { |k, v| "#{k}.#{v}" }).last
+
+        flavor_parse(printed(number, year, keyed, type))
+      end
+
+      private
 
-        number, year = parts
-        text = "AMCA #{number}"
+      def printed(number, year, keyed, type)
+        publisher = keyed.fetch("copub", "amca").upcase
+        return interpretation(publisher, number, keyed) if type == "interpretation"
+
+        text = [publisher, TYPE_TITLES[type], number].compact.join(" ")
         text += "-#{year}" if year
-        flavor_parse(text)
+        text += " (Rev. #{keyed['rev']})" if keyed["rev"]
+        text += " (R#{keyed['reaff']})" if keyed["reaff"]
+        text
+      end
+
+      def interpretation(publisher, number, keyed)
+        code = keyed["interp"]&.upcase
+        [publisher, number, code, "Interp"].compact.join(" ")
       end
     end
   end

data/lib/pubid/ansi/builder.rb

@@ -45,6 +45,10 @@ module Pubid
           value.to_s.split(",").map do |lang|
             Components::Language.new(code: lang.strip)
           end
+        when :all_parts
+          # The shared Grammar marks the tree; the prepended AllPartsWrap
+          # routes the wrap, so the marker itself carries no component.
+          nil
         else
           raise ArgumentError, "Unknown parameter type: #{type}"
         end
@@ -52,3 +56,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Ansi::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/api/CLAUDE.md

@@ -0,0 +1,23 @@
+# API flavor notes
+
+API rendering repairs and the `number` retype residue.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/api/` or `spec/pubid/api/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+## From the root note "`number`/`part`/`subpart` retyped to `:string` — tranche 1 of 3 (ansi, api, bsi, cen_cenelec, idf, jcgm)"
+
+**The six flavors have no fixture net of their own**: every one of their `fixtures_spec.rb` files reports **0 examples** (the `../../../fixtures` glob has one `..` too many; api and idf also use an uppercase directory — hand-off `ten-dead-fixture-specs`), and ANSI's sole assertion is `expect(fixtures.size).to be > 0`. Fixing those globs would drag in unrelated stale-fixture failures, so the new spec's corpus sweep reads the same files directly — the ashrae/csa/etsi/oiml precedent. **One pre-existing defect repaired in passing**: `API COS 1-07/RP 75, 4th edition` put a raw `Parslet::Slice` into `root.number` (the hand-off warned it would look like a migration failure); `Api::Builder#cast` now returns `value.to_s`, so it is a real String. **One severe API defect repaired here — the ONLY deliberate `to_s` change in this branch.** `Pubid::Api::Identifier.parse("API RP 500").to_s` was `"API"`: **163 of API's 193 corpus ids rendered as the bare publisher**, and since `to_s` is the document number *and* the output filename, all 163 collapsed onto one another. Two independent **dead reads**, both found by pulling on the `code` thread this retype exposed: (1) `Api::Renderer#code_portion` read an `id.code` attribute that **nothing ever assigns** — the parser emits no `:code` key and `Builder#cast` never sets one — while the number the builder does populate sits in `number`; (2) the type token was gated on `id.class.attributes.key?(:type_string)`, but `type_string` is a plain **method** on each leaf, never a lutaml attribute, so that guard was always false. The fix is two reads (`number`, and `respond_to?(:type_string)`), plus deleting the `code` attribute and the three dead `code_portion` methods (`SingleIdentifier`'s and `Mpms`'s were never called at all — the renderer has its own). **`render_mpms` never consulted `code_portion`, which is exactly why MPMS was the one form that always rendered correctly.** Byte-exact `to_s` goes from **29/193 to 190/193**, and the 3 residuals are precisely the normalizing parses the generated fixtures already mark `!input!rendered`. **The strongest evidence that this restores intent rather than inventing output: regenerating the fixtures (`rake "validation:classify[api]"`) changed exactly ONE line** — a stale `!… !API` corrected to `!… !API 75-07`. The corpus had recorded the correct renderings all along; the code had drifted away from them silently, because API's `fixtures_spec.rb` matches no files and reports 0 examples and its other specs are `respond_to?(:parse)` stubs. Re-adding a `code` attribute would silently reopen the defect, so `spec/pubid/api/rendering_gaps_spec.rb` asserts it is absent from the whole hierarchy. **Note `maybe(:code)` in `urn_generator/base.rb#urn_number` is safe** — `maybe` guards on `attributes.key?`, so the removed attribute simply never matches. Measured over the corpus, the repair is **purely additive**: of 193 ids, 163 grew and **0 shrank**, and every new rendering *extends* the old one (`to_urn`, `to_hash` and `root.number` are untouched) — the ASHRAE invariant, which is stronger than byte-identity for a fix. **An MR gap this branch pinned was closed mid-flight by PR #354, and the pin is what caught it** — a worked example of why these "assert the CURRENT behaviour" blocks earn their place. When written, all **30** MPMS ids slugged to the bare `"api"` because MPMS kept its locator in a `chapter` attribute and had no `number` at all. #354 then moved the chapter into the inherited `number` (it *is* the document number) and this branch retyped that `number` to `:string`; **composed, they close the collapse** — 0 ids now slug to bare `"api"`, and `API MPMS CH 12.2` keys `"12"` as a String. Merging `main` turned the pin red exactly as designed, and it was rewritten to assert the repair. **A narrower gap remains and is re-pinned**: the MR slug is built from `number` alone, so the sections of one chapter still share it (`CH 14.4` and `CH 14.6` both → `api.14`, 11 colliding slugs corpus-wide, and `to_slug` is a filename). Closing that needs an `Mpms#mr_number_with_part` appending section/subsection (the BIPM/OIML shape). **Merge note for whoever does tranche 2/3**: #354's `Builder#handle_key` routes the MPMS `:chapter` parse key into the `number` *attribute*, and `assign_attributes` hands `handle_key` the **already-cast** value — so the `cast` arm must be `when :number, :chapter then value.to_s`, not a `Components::Code`, or MPMS silently regains a boxed number. (hand-off: retype-number-to-string; remaining: tranche 2 = CSA, tranche 3 = ISO and NIST on separate branches, then flip `identifier.rb:136-138` and delete the leaf `:string` redeclarations and the twelve tripwire blocks.)
+
+## From the root note "Parse-failure error contract — uniform across every flavor"
+
+**`Identifier.parse` was the one public parse in the gem that could return `nil`.** `lib/pubid/api/identifier.rb` opened with
+
+```ruby
+return nil if input.start_with?("#")   # "Filter out comments"
+```
+
+a **fixture-file concern living in a public API**. A caller passing a `#`-leading string got `nil` back and discovered it as a `NoMethodError` on `.to_s`, far from the cause. `lib/pubid/csa/identifier.rb` even carried a comment noting that every flavor "but `api`" honoured the raise-or-return-an-identifier contract, so this was known and unfixed.
+
+Deleting it cost nothing: **both** API fixture loaders already reject `#` lines themselves (`spec/pubid/api/fixtures_spec.rb`, `spec/pubid/api/root_number_spec.rb`), so nothing depended on the nil. A comment line is not an identifier and now raises `Parslet::ParseFailed` like any other unparseable string. The `rescue Parslet::ParseFailed => e; raise e` that followed it was a no-op and went too, and API gained the input guards it had never had (it was one of the 14 flavors an over-long string reached the parser in).
+
+**Rule this illustrates:** a filter that exists for *how the test corpus is stored* belongs in the corpus loader, never in `parse`.

data/lib/pubid/api/builder.rb

@@ -56,3 +56,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Api::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/ashrae/CLAUDE.md

@@ -0,0 +1,13 @@
+# ASHRAE flavor notes
+
+ASHRAE index key, the identifiers that lost their number, the errata date, and interpretations.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/ashrae/` or `spec/pubid/ashrae/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **ASHRAE index key (`root.number`), and the 246 identifiers that were losing their number**: ASHRAE kept its document code in a `code` :string on the shared base and never set the inherited `number`, so all 2,103 fixture identifiers keyed `""`. Worse, **246 of them had no number to key on**: they parsed *successfully* and rendered as nonsense — 160 Errata as the identical `"ASHRAE Standard  Errata"` (note the double space, the BIPM `Declaration` corruption signature), the addendum forms as `"ASHRAE Standard "` or `"… to ASHRAE Standard -2024"`. Triaged over the whole corpus, that was **not one bug but three**, and the hand-off's guess ("the parser discards the number") was wrong about the largest: **(1) The BUILDER, 223 ids — the real cause.** The grammar captured everything; the parse tree for an erratum is `{base: {publisher, type, code, year}, errata_keyword: …}`. But `build_errata` and the addendum builders passed the **whole** parse hash to `#extract_base_attributes`, which reads `parsed[:publisher]`/`[:type]`/`[:code]` — all nil, because they sit under `parsed[:base]`. `Builder#build` unwraps at its own entry (`if parsed_hash[:base]`); the five other call sites never did. Fixed **inside `extract_base_attributes`**, which covers all five at once rather than repeating the unwrap. Two grammar rules — `:addendum` and `:publisher_base_addendum` — additionally had **no dispatch branch at all**, so they fell through to the plain-identifier path, which looks for publisher/type/code at the top of the hash, found only the wrapper key, and built an empty Standard (63 of the 223, which were additionally the WRONG CLASS — a bare `Standard` where an `Addendum` was meant). Both subtrees are flat and carry exactly what `build_addendum_from_identifier` already reads. **(2) The GRAMMAR, 23 ids — one missing capture.** `rule(:code_with_year)` matched the code digits and then **discarded** them: only `year_digits.as(:year)` was named. Wrapping the code portion in `.as(:code)` is the whole fix, and the builder was already reading `code_with_year[:code]` — it had been waiting for a value the grammar never produced. **(3) The index key.** `attribute :code, :string` moved off `Pubid::Ashrae::Identifier` and became `attribute :number, :string` on the **two single-document leaves** (`Standard`, `Guideline`). Leaf placement is load-bearing in the CSA counter-shape here: that base is inherited by **both** `SingleIdentifier` and `SupplementIdentifier`. The five supplement types carry **no number of their own** and reach the key through `#root`, which walks `base` — so `UrnGenerator#urn_number` needed an `identifier.number || identifier.root.number` fallback, without which every supplement URN silently lost its number when the attribute moved. **Landmine when renaming `code` → `number` in a flavor whose builder reads Parslet output: the builder holds BOTH attribute keys and parse-TREE keys under the same name.** A blanket `s/\bcode\b/number/` through `builder.rb` renames `parsed[:code]` too and breaks every lookup; the rename must be surgical (`attributes[:code]`, `base_attrs[:code]`, `code: extract_value`) while `parsed[:code]` / `code_year_data[:code]` stay. (`renderer.rb` and `urn_generator.rb` read only attributes, so a blanket rename is safe there.) Also note **BSD `sed` does not support `\b`** — an `sed -i '' 's/\bcode\b/…/'` on macOS silently changes nothing; use `perl -pi -e`. **(4) The MR slug, the worst collapse measured in the gem: ALL 2,103 ids shared the single slug `"ashrae"`.** Every base hook looked for something ASHRAE does not use (`mr_type` a typed_stage, `mr_year` a `Components::Date`), and with `number` nil too there was nothing left. The base now supplies `mr_type`/`mr_year`/`mr_publisher`/`mr_number_with_part`/`mr_sanitize`, and the four **reachable** supplement types define `mr_supplement_suffix` so `Renderers::MrString` recurses into `base` instead of slugging flat. Every identity-bearing marker was chased in until distinct identifiers got distinct slugs: `type` (Guideline 0 ≠ Standard 0), `copublisher` (`ANSI/ASHRAE` ≠ `ASHRAE` — their hashes differ, so their filenames must), `reaffirmed` (`RA 2017`), `suffix` (`R`/`P`), and the addendum letters. `mr_sanitize` filters **by charset** (the BIPM precedent): an ASHRAE code carries commas (`90A,B,C`) and the copublisher a slash, both outside the `[a-z0-9.-]` charset `MrString` documents. Result: **2,062 distinct slugs for 2,103 ids, 0 unsafe characters, 0 clashes between distinct identifiers** (the 41 collapses are pairs whose hashes are genuinely equal). **Verified** by replaying a baseline captured on `main` over every real fixture input: `to_s` **shrank for 0 of 2,103** (every rendering only gained content — the right invariant for a repair, stronger than byte-identity), 0 empty `root.number` (was 2,103), 0 renderings with a double space (was 160) or without a digit (was 223), 0 round-trip failures, and `to_urn` changed for exactly the 246 repaired ids (243 gained their number; 3 replaced the garbage `urn:ashrae:standard`, which carried only a wrongly-defaulted type, with `urn:ashrae:28`). **COUNT IN IDENTIFIERS, NOT FIXTURE LINES**: the first revision of this entry said 3,619 and 489, because a `pass/` line for a normalizing parse is written `!input!rendered` and the ASHRAE grammar is loose enough to *parse* that doubled string — so 1,518 of them were counted, and swept, as identifiers. `spec/pubid/ashrae/root_number_spec.rb` now splits the marker. **Two review findings worth keeping.** The `code` -> `number` rename left `SupplementIdentifier#code` (`def code; base&.code; end`) pointing at a method that no longer exists, so it **raised NoMethodError on every supplement instance** — and nothing inside `lib/pubid/ashrae` calls it, which is exactly why the whole suite stayed green while a public method on five types was broken. Its body is now `base&.number`, and **the method is deliberately still named `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. (The same trap as the ASTM `Adjunct#number` above; `code` is free to be a plain reader precisely because it is not an attribute anywhere.) Second, `mr_number_with_part` now goes through the shared `#mr_join` rather than a bare `compact.join("-")`, so it degrades to nil rather than `""`. **Three known gaps, all pre-existing and all pinned by specs asserting the CURRENT behaviour, so a fix trips them rather than passing silently.** **(a) Interpretations — FIXED since (see the interpretation bullet below).** An `"Interpretations for Standard 15.2-2022"` reference builds a plain `Standard` **identical** to the standard it interprets (same class, `to_s`, hash, URN and slug), and all 51 corpus rows already behaved this way on `main`. **The cause is NOT alternation ordering** — the first revision of this entry said it was. `rule(:interpretation_identifier)` *is* reached and *does* match (dump the tree: `{base: {type: "Standard", code: "15.2", year: "2022"}}`, prefix consumed); what it never does is **tag** itself, having no `.as(:interpretation_identifier)` wrapper — so `Builder#build`'s `elsif parsed_hash[:interpretation_identifier]` is unreachable dead code and the tree falls through to the plain path. `Identifiers::Interpretation` is therefore unreachable, which is why it alone got no `mr_supplement_suffix`. **(b) The errata date — FIXED since (see the errata-date bullet below).** `Addendum#addendum_date` still has the always-nil extractor (making `render_addendum`'s date branch dead), and `AddendaPackage`'s `package_year`/`target_year` and `CombinedAddenda`'s `connector` are still captured by the grammar and never read by the builder. **(c) The supplement URN — FIXED since (see the supplement-URN bullet below).** **Also stale, deliberately**: `spec/fixtures/ashrae/identifiers/pass/*.txt` was generated on `main`, so it still records the corrupt renderings as expected output (`!… Errata (September 28, 2011) (PDF)!ASHRAE Standard  Errata`). Inert while `fixtures_spec.rb`'s glob is dead, but it will fail the moment that glob is fixed; regenerate with `bundle exec rake "validation:classify[ashrae]"`, which rewrites `pass/` and `fail/` wholesale (the CSA precedent above). Locked by `spec/pubid/ashrae/root_number_spec.rb` — structural tripwire (the two numbered leaves resolve `number` to `String`, the three inherited-from classes still resolve to `Components::Code`, and the supplements deliberately have no number of their own), a recovered-identifier table naming one example per defect shape, and a corpus sweep asserting non-empty keys, no double space, at least one digit, round-trip, and slug distinctness. **That sweep is ASHRAE's only fixture net**: `spec/pubid/ashrae/fixtures_spec.rb` globs `../../../fixtures/ASHRAE/…` and reports 0 examples (hand-off `ten-dead-fixture-specs`). (hand-off: ashrae-parser-drops-the-number; follow-ups: ashrae-interpretation-collapses-onto-base, ashrae-errata-date-dropped, ashrae-supplement-urn-collapse.)
+
+- **The errata date is captured, because ASHRAE identifies an erratum by its date.** `ASHRAE Guideline 14-2002 Errata (October 10, 2008)` and `… (October 20, 2008)` are two documents with different content (the October 10 sheet applies to all copies; the October 20 sheet applies only to the downloaded PDF). Before this change they had one `to_s`, `to_hash`, `==` and slug. **There were three causes, and the hand-off named only two.** The builder stub returned nil, and the rule named only `:errata_year`. The third cause is the one to remember: `rule(:errata_date)` started with `lparen` and had **no leading space**, so after `Errata` it never matched, and `optional_suffix` (a generic `" (…)"` eater) took the date instead. The parse tree showed it: `optional_suffixes: " (October 10, 2008)"`. **A generic suffix rule after an optional capture hides a capture that does not match**: the parse still succeeds, so no test fails. The rule now starts with `space.maybe` and names `:month`, `:day`, `:errata_year` and `:numeric_date`. The three `errata_identifier` branches now share one `rule(:errata_date_and_suffix)`: the plain-publisher branch had only the date-first order, so `ASHRAE Standard 55-2004 Errata – Spanish Edition (June 2, 2010)` lost its date the same way (a code review found it; no corpus row has that shape). **The date lives in the `date` component `Errata` inherits, not in a flavor-named attribute.** The first version of this fix (PR #405) declared `attribute :errata_date, :string`. That is the GB shape: two attributes describing one value, and the flavor-named one is invisible to every shared surface, which reads `date`. `Builder#extract_errata_date` now returns a `Components::Date`, so one date has one value whatever the input spelled — `October 10, 2008`, `October 10,2008` and `10-10-2008` all give `year: "2008", month: "10", day: "10"`. **The month and the day are padded to two digits**, so two identifiers cannot differ by a leading zero; `Renderer#long_date` inverts the mapping and prints the day unpadded, in the long form the ASHRAE PDF headers use. `to_s` is byte-identical to the string form for every corpus row, and a numeric date now prints as `(July 17, 2003)`. The slug takes the sortable form: `ashrae.guideline.14.2002_errata.2008-10-10`. **One override was needed, and it is the price of using the shared name**: `UrnGenerator::Base#urn_year` reads `date` first, so an erratum would have emitted `urn:ashrae:14:2008` — the erratum year in the slot that holds the edition year of the standard. `Ashrae::UrnGenerator#urn_year` reads the `year` attribute only, and every ASHRAE URN stays as it was. A second consequence is intended and recorded in the spec: the base `#exclude` adds `:date` to `:year`, so `matches?(other, ignore: [:year])` now ignores the erratum date as well. **Measured** by a replay of all 2,103 inputs in `spec/fixtures/ashrae/identifiers/full/` against a `main` baseline: exactly the 160 `Errata` rows changed `to_s`, `to_hash` and slug; every changed `to_s` only gained the date; the class and `to_urn` did not change for any row; `from_hash(to_hash) == id` holds for all. **Not changed, on purpose:** the URN, which had no supplement marker at the time (fixed since — see the supplement-URN bullet below); the 34 `Addendum … Errata (date)` inputs, which parse through `errata_suffix_on_addendum` and build a plain `Addendum` without the errata; and the `– Spanish Edition` errata suffix, which is still dropped. **A bare `ASHRAE Guideline 14-2002 Errata` still parses, with `date` nil** (the partial-reference contract), and `matches?(other, ignore: [:date])` matches every erratum of the standard. It names no single document, and neither erratum supersedes the other, so **a consumer must treat a bare reference as ambiguous and must not resolve it to the latest erratum**. No relaton consumer of ASHRAE exists today. Locked by `spec/pubid/ashrae/identifiers/errata_spec.rb` and the flipped block "two errata of one standard are two identifiers" in `spec/pubid/ashrae/root_number_spec.rb`. (hand-off: ashrae-errata-date-dropped.)
+
+- **An interpretation is an `Interpretation`, not the standard it interprets.** `Interpretations for Standard 15.2-2022` built a plain `Standard` with the `to_s`, `to_hash`, `==` and slug of `ASHRAE Standard 15.2-2022`, for all 51 corpus rows. The builder, the class, the renderer and `mr_supplement_suffix` were all correct; only the grammar tag was missing. `rule(:interpretation_identifier)` now wraps its output in `.as(:interpretation_identifier)`, so the `Builder#build` branch for that key is reached. **Lesson: a `Builder#build` branch that dispatches on a parse-tree key is dead code unless some rule emits that key** — grep the parser for the `.as(:key)` before you trust the branch. The `:addendum_identifier` branch has the same shape; it is harmless, because each sub-alternative emits its own key and has its own branch. **Measured** by a replay of all 2,103 inputs against a `main` baseline: exactly the 51 interpretation rows changed; each renders byte-exact (`Interpretations for Standard 15.2-2022`), keeps its `root.number`, round-trips through `from_hash`, and has a unique slug (`ashrae.standard.15.2.2022_interp`). The URN changed from the standard's own URN to the bare supplement URN `urn:ashrae:15.2`, which every other supplement of that base shared; it is now `urn:ashrae:15.2:2022:standard:interp` (see the supplement-URN bullet below). The interpretations still sit in `spec/fixtures/ashrae/identifiers/pass/standard.txt` until the next `validation:classify[ashrae]` run. Locked by the flipped block "interpretations are distinct from their base standard" in `spec/pubid/ashrae/root_number_spec.rb`. (hand-off: ashrae-interpretation-collapses-onto-base.)
+
+- **A supplement URN is the URN of its base plus one supplement marker.** `UrnGenerator#generate` read `year`, `type` and `suffix` off the identifier, and a supplement keeps them on `base`. So every Addendum, Errata, Interpretation and package of one document shared the bare `urn:ashrae:<number>`, which was not the base's own URN either. `urn_addendum` read `maybe(:addendum)`, an attribute no class declares, so the addendum letter never reached a URN. `#generate` now sends a supplement with a `base` to `#supplement_urn`: the base URN (recursive, through `self.class.new(base)`), then `mr_supplement_suffix` — `urn:ashrae:28:2016:guideline:add.e`, `urn:ashrae:14:2002:guideline:errata.2008-10-10`, `urn:ashrae:15.2:2022:standard:interp`. **The marker is the MR slug marker on purpose**, so the two identity surfaces cannot drift, and it is already filtered to `[a-z0-9.-]`. The dead `urn_addendum` is gone. A supplement `copublisher` equals its base `copublisher` for every corpus row, so the base URN loses nothing; the `copub.` segment now sits after the year and the type, where the base puts it. **Measured** by a replay of all 2,103 inputs against a `main` baseline: `to_s`, `to_hash`, the class and the slug did not change for any row; the URN changed for exactly the 1,649 supplements; distinct URNs went from 562 to 2,088, and URNs shared by different hashes went from 71 to 0. No `relaton-data-ashrae` exists, so no published index holds an ASHRAE URN. **Not changed:** `UrnParser` still reads only `number:year` into a plain `Standard`, so a supplement URN does not parse back (it did not before either); and a base number or copublisher can put a comma, a slash or a capital letter into a URN (`urn:ashrae:90A,B,C:standard`, `copub.ansi/ashrae`). Locked by `spec/pubid/ashrae/supplement_urn_spec.rb` and the corpus example "gives distinct identifiers distinct URNs" in `spec/pubid/ashrae/root_number_spec.rb`. (hand-off: ashrae-supplement-urn-collapse.)

data/lib/pubid/ashrae/builder.rb

@@ -5,6 +5,13 @@ module Pubid
     # Builder class for constructing ASHRAE identifier scheme from parsed data
     # Single Responsibility: Transform parsed data into identifier objects
     class Builder
+      # Month names, in the order the parser matches them. The index gives the
+      # month number the date component stores, and the renderer inverts it.
+      MONTH_NAMES = %w[
+        January February March April May June July August September October
+        November December
+      ].freeze
+
       attr_reader :identifier_class
 
       def initialize(identifier_class = Identifier)
@@ -172,11 +179,9 @@ module Pubid
         base_class = determine_identifier_class(base_attrs)
         base = base_class.new(**base_attrs)
 
-        errata_date = extract_errata_date(parsed[:errata_date])
-
         Identifiers::Errata.new(
           base: base,
-          errata_date: errata_date,
+          date: extract_errata_date(parsed[:errata_date]),
         )
       end
 
@@ -388,7 +393,10 @@ module Pubid
 
         # Build the addendum_codes string from first code and additional codes
         first_code = extract_value(parsed[:addendum_code])
+        # The "a through z" range form yields a single Hash, not an
+        # Array; iterating it would emit the key name into the codes.
         additional_codes = parsed[:additional_codes]
+        additional_codes = [additional_codes] if additional_codes.is_a?(Hash)
 
         # Handle Format 4: "ASHRAE Addenda to Standard" (no specific codes)
         if first_code.nil? && additional_codes.nil?
@@ -490,19 +498,53 @@ module Pubid
         attributes
       end
 
-      # Extract errata date from parsed errata_date data
+      # Extract the errata date into the inherited `date` component.
+      # The component holds numbers, so every spelling of one date — "October
+      # 10, 2008", "October 10,2008", "10-10-2008" — gives one value, and the
+      # renderer writes the long form ASHRAE prints. The month and the day are
+      # padded to two digits, so two identifiers cannot differ by a leading
+      # zero. A date with no year keeps the month and the day.
       # @param errata_date [Hash] the parsed errata_date hash
-      # @return [String, nil] the formatted errata date string
+      # @return [Pubid::Components::Date, nil] the date, or nil when absent
       def extract_errata_date(errata_date)
-        return nil unless errata_date
-
-        # errata_date contains { month_name: "...", errata_year: "..." }
-        # We need to format this as "Month Day, Year"
-        extract_value(errata_date[:month_name])
-        extract_value(errata_date[:errata_year])
-        # Note: day is captured as digit.repeat(1,2) but not named in the parser
-        # We'll need to reconstruct from the raw string or enhance parser
-        nil # For now, return nil - parser enhancement needed
+        return nil unless errata_date.is_a?(Hash)
+
+        numeric = extract_value(errata_date[:numeric_date])
+        return numeric_errata_date(numeric) if numeric
+
+        month = month_number(extract_value(errata_date[:month]))
+        day = extract_value(errata_date[:day])
+        return nil unless month && day
+
+        date(extract_value(errata_date[:errata_year]), month, day)
+      end
+
+      # "7-17-2003" (the parser also accepts "7-17- 2003") is month, day, year.
+      # @param value [String] the numeric date as written
+      # @return [Pubid::Components::Date]
+      def numeric_errata_date(value)
+        month, day, year = value.delete(" ").split("-")
+        date(year, month, day)
+      end
+
+      # @param name [String, nil] a month name the parser matched
+      # @return [Integer, nil] the month number
+      def month_number(name)
+        index = MONTH_NAMES.index(name)
+        index && index + 1
+      end
+
+      # @return [Pubid::Components::Date] the date, with padded month and day
+      def date(year, month, day)
+        Pubid::Components::Date.new(
+          year: year, month: pad2(month), day: pad2(day),
+        )
+      end
+
+      # @param value [String, Integer] a month or day number
+      # @return [String] the number with two digits
+      def pad2(value)
+        value.to_s.to_i.to_s.rjust(2, "0")
       end
 
       # Extract addendum date from parsed addendum_year data
@@ -517,3 +559,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Ashrae::Builder.prepend(Pubid::Builder::AllPartsWrap)

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

@@ -11,17 +11,29 @@ module Pubid
       # - ASHRAE Guideline 0-2005 Errata (September 28, 2011)
       # - ANSI/ASHRAE Standard 62.1-2004 Errata (May 4, 2007)
       class Errata < SupplementIdentifier
-        attribute :errata_date, :string
+        # The date of the erratum lives in the `date` component this class
+        # inherits from ::Pubid::Identifier. A flavor-named second attribute
+        # (the old `errata_date` :string) described the same value under a
+        # name no shared code reads — the GB lesson in CLAUDE.md. The base
+        # standard keeps its own edition year in `base.year`.
 
         # 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)]
+          ["errata", mr_sanitize(date_slug)]
             .compact.reject(&:empty?).join(".")
         end
 
+        # The sortable form of the date, for the slug only: "2008-10-10", or
+        # "08-27" for the one shape that carries no year.
+        def date_slug
+          return nil unless date
+
+          [date.year, date.month, date.day].compact.join("-")
+        end
+
         TYPED_STAGES = [
           Components::TypedStage.new(
             abbr: ["Errata"],

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

@@ -13,16 +13,8 @@ module Pubid
       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.
+        # does not have, instead of recursing into `base`. An interpretation
+        # carries no field of its own, so the marker alone is the suffix.
         def mr_supplement_suffix
           "interp"
         end

data/lib/pubid/ashrae/parser.rb

@@ -120,17 +120,22 @@ module Pubid
           str("November") | str("December")
       end
 
+      # The date is what tells two errata of one standard apart, so every part
+      # of it is named. The leading space is part of the rule: without it the
+      # date never matched after "Errata", and optional_suffix took it instead.
       rule(:errata_date) do
         # Full date: (Month Day, Year)
-        (lparen >> month_name >> space >> digit.repeat(1,
-                                                       2) >> comma.maybe >> (space | comma.maybe) >>
+        (space.maybe >> lparen >> month_name.as(:month) >> space >>
+         digit.repeat(1, 2).as(:day) >> comma.maybe >> (space | comma.maybe) >>
          year_digits.as(:errata_year) >> rparen).as(:errata_date) |
           # Month+day without year: (August 27)
-          (lparen >> month_name >> space >> digit.repeat(1,
-                                                         2) >> rparen).as(:errata_date) |
+          (space.maybe >> lparen >> month_name.as(:month) >> space >>
+           digit.repeat(1, 2).as(:day) >> rparen).as(:errata_date) |
           # Numeric date with dash: (7-17- 2003) or (7-17-2003)
-          (lparen >> digit.repeat(1, 2) >> dash >> digit.repeat(1,
-                                                                2) >> dash >> space.maybe >> year_digits.as(:errata_year) >> rparen).as(:errata_date)
+          (space.maybe >> lparen >>
+           (digit.repeat(1, 2) >> dash >> digit.repeat(1, 2) >> dash >>
+            space.maybe >> year_digits).as(:numeric_date) >>
+           rparen).as(:errata_date)
       end
 
       # Errata suffix pattern - handles descriptive text like "– Spanish Edition" after "Errata"
@@ -141,6 +146,17 @@ module Pubid
         )
       end
 
+      # The date and the descriptive suffix after "Errata", in either order. All
+      # three errata_identifier branches share this rule: the publisher branch had
+      # only the date-first order, so "Errata – Spanish Edition (June 2, 2010)"
+      # lost its date to optional_suffix.
+      rule(:errata_date_and_suffix) do
+        (errata_suffix >> errata_date) |
+          (errata_date >> errata_suffix) |
+          errata_date |
+          errata_suffix
+      end
+
       # Errata suffix on addendum (e.g., "ASHRAE Addendum a to Standard 15-2001 Errata (July 6, 2021)")
       rule(:errata_suffix_on_addendum) do
         space >> str("Errata").as(:errata_keyword) >>
@@ -179,12 +195,7 @@ module Pubid
         ).as(:base) >>
           space >>
           str("Errata").as(:errata_keyword) >>
-          (
-            (errata_suffix >> errata_date) |
-            (errata_date >> errata_suffix) |
-            errata_date |
-            errata_suffix
-          ).maybe >>
+          errata_date_and_suffix.maybe >>
           optional_suffix.repeat(0, 2).as(:optional_suffixes)) |
           # Format with copublisher, missing type: ANSI/ASHRAE 51-1999 Errata (May 23, 2014)
           ((
@@ -201,12 +212,7 @@ module Pubid
           ).as(:base) >>
             space >>
             str("Errata").as(:errata_keyword) >>
-            (
-              (errata_suffix >> errata_date) |
-              (errata_date >> errata_suffix) |
-              errata_date |
-              errata_suffix
-            ).maybe >>
+            errata_date_and_suffix.maybe >>
             optional_suffix.repeat(0, 2).as(:optional_suffixes)) |
           # Format with publisher: ASHRAE Guideline 0-2005 Errata (September 28, 2011)
           ((
@@ -220,16 +226,22 @@ module Pubid
           ).as(:base) >>
             space >>
             str("Errata").as(:errata_keyword) >>
-            errata_date.maybe >>
-            errata_suffix.maybe >>
+            errata_date_and_suffix.maybe >>
             optional_suffix.repeat(0, 2).as(:optional_suffixes))
       end
 
       # Interpretation pattern ("Interpretations for Standard X-YYYY")
+      #
+      # The `.as(:interpretation_identifier)` tag is what Builder#build
+      # dispatches on. Without it the tree is a bare `{base: …}`, the builder
+      # takes the plain-identifier path, and the interpretation becomes the
+      # standard it interprets.
       rule(:interpretation_identifier) do
-        str("Interpretations") >> space >>
+        (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))
+          .as(:interpretation_identifier)
       end
 
       # Combined Addenda pattern (multiple addendums grouped together)
@@ -242,9 +254,9 @@ module Pubid
           (
             (comma >> space >> str("and") >> space >> addendum_code) | # ", and b"
             (space >> str("and") >> space >> addendum_code) |  # "and b"
-            (comma >> space >> addendum_code).repeat(1, 10) |  # comma-separated: "a, b, c"
-            (comma >> addendum_code).repeat(1, 10) # comma without space: "a,b,c"
-          ).repeat(0, 3).as(:additional_codes) >> # Multiple groups of codes (0-3 to allow single code)
+            (comma >> space >> addendum_code).repeat(1, 50) |  # comma-separated: "a, b, c"
+            (comma >> addendum_code).repeat(1, 50) # comma without space: "a,b,c"
+          ).repeat(0, 20).as(:additional_codes) >> # Multiple groups of codes
           space >>
           (str("to") | str("for")) >> space >>
           ((str("ANSI") >> slash >> str("ASHRAE") >> (slash >> letter.repeat(3, 10)).repeat(
@@ -348,11 +360,11 @@ module Pubid
               # Range pattern: "a through z"
               (space >> str("through") >> space >> addendum_code) |
               # Space or comma separated codes (handles typos like "bl bq")
-              ((space | (comma >> space)) >> addendum_code).repeat(1, 50) |
+              ((space | (comma >> space)) >> addendum_code).repeat(1, 200) |
               # Just match all comma-separated values
-              (comma >> space >> addendum_code).repeat(1, 50) |
+              (comma >> space >> addendum_code).repeat(1, 200) |
               # Or comma without space
-              (comma >> addendum_code).repeat(1, 50)
+              (comma >> addendum_code).repeat(1, 200)
             ).as(:additional_codes).maybe >>
             (space >> additional_copublisher).maybe >>
             addendum_date_suffix.maybe >>
@@ -486,6 +498,28 @@ module Pubid
             errata_suffix_on_addendum.maybe >>
             optional_suffix.repeat(0, 2)
           ).as(:publisher_base_addendum) |
+          # Format: [ANSI/ASHRAE] Addendum X to/for ASHRAE Standard/Guideline
+          # X-YYYY (leading copublisher + publisher-led base)
+          (
+            (
+              (str("ANSI") >> slash >> str("ASHRAE") >> (slash >> letter.repeat(3, 10)).repeat(
+                0, 10
+              )).as(:copublisher) >>
+              space
+            ).maybe >>
+            str("Addendum") >> space >>
+            addendum_code >>
+            space >>
+            (str("to") | str("for")) >> space >>
+            publisher.as(:base_publisher) >> space >>
+            type.as(:type) >> space >>
+            code >>
+            (dash >> year_digits.as(:year)).maybe >>
+            additional_copublisher.maybe >>
+            addendum_date_suffix.maybe >>
+            errata_suffix_on_addendum.maybe >>
+            optional_suffix.repeat(0, 2)
+          ).as(:publisher_base_addendum) |
           # Format: ASHRAE Addendum X to ANSI/ASHRAE Standard/Guideline X-YYYY (ASHRAE publisher + copublisher base)
           (
             publisher.as(:publisher) >> space >>

data/lib/pubid/ashrae/renderer.rb

@@ -99,10 +99,41 @@ module Pubid
 
         result = id.base.to_s
         result += " Errata"
-        result += " (#{id.errata_date})" if id.errata_date
+        date = long_date(id.date)
+        result += " (#{date})" if date
         result
       end
 
+      # The long date form ASHRAE prints on an errata sheet: "October 10,
+      # 2008". The component stores padded numbers, so the day loses its
+      # leading zero here.
+      #
+      # The parser always gives a month and a day together, so only the first
+      # two shapes come from a reference string. The others can come from a
+      # hand-built identifier or from a hash: a date with no day gives "June
+      # 2016", a date with only a year gives "2016", and a month number
+      # outside 1-12 falls back to the component's own "2016-13-01" form.
+      # They must all print something, because the date reaches `to_hash` and
+      # the MR slug, and a surface that drops it silently disagrees with them.
+      def long_date(date)
+        return nil unless date
+        return date.year&.to_s unless date.month
+
+        month = Builder::MONTH_NAMES[date.month.to_i - 1]
+        return date.to_s unless month
+
+        long_date_with_month(date, month)
+      end
+
+      # @param month [String] the month name
+      # @return [String] the date, with the day when the date carries one
+      def long_date_with_month(date, month)
+        return "#{month} #{date.year}".strip unless date.day
+
+        day = "#{month} #{date.day.to_i}"
+        date.year ? "#{day}, #{date.year}" : day
+      end
+
       # Interpretation: "Interpretations for Standard 15.2-2022"
       def render_interpretation(id)
         return id.base.to_s unless id.base

data/lib/pubid/ashrae/urn_generator.rb

@@ -5,9 +5,9 @@ module Pubid
     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.
+      # walks `base` to the standard the supplement attaches to. #generate
+      # sends a supplement with a `base` to #supplement_urn, so only a
+      # supplement without a `base` reaches this fallback.
       def urn_number
         num = identifier.number || identifier.root.number
         return nil if num.nil? || num.to_s.empty?
@@ -15,6 +15,14 @@ module Pubid
         num.to_s
       end
 
+      # ASHRAE keeps the edition of a document in its own `year` string. The
+      # base hook reads the inherited `date` first, which on an Errata holds
+      # the date of the erratum — a different thing from the edition year of
+      # the standard, and misleading in the year slot. Read `year` only.
+      def urn_year
+        identifier.year&.to_s
+      end
+
       def urn_suffix
         identifier.suffix&.to_s&.downcase
       end
@@ -31,12 +39,17 @@ module Pubid
         "copub.#{identifier.copublisher.to_s.downcase}" if identifier.copublisher
       end
 
-      def urn_addendum
-        val = maybe(:addendum)
-        "add.#{val}" if val
+      def generate
+        supplement? ? supplement_urn : document_urn
       end
 
-      def generate
+      private
+
+      def supplement?
+        identifier.is_a?(SupplementIdentifier) && !identifier.base.nil?
+      end
+
+      def document_urn
         parts = ["urn", "ashrae"]
         parts << urn_number if urn_number
         parts << urn_year if urn_year
@@ -48,10 +61,20 @@ module Pubid
 
         parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
 
-        parts << urn_addendum if urn_addendum
-
         parts.join(":")
       end
+
+      # A supplement keeps the year, the type and the suffix on its `base`.
+      # Its URN is the URN of that base plus one segment that names the
+      # supplement ("add.e", "errata.2008-10-10", "interp"). The segment is
+      # the marker the MR slug uses, so the two surfaces cannot drift apart.
+      # Without this, every supplement of one document had the same bare
+      # "urn:ashrae:<number>" (hand-off ashrae-supplement-urn-collapse).
+      def supplement_urn
+        marker = identifier.mr_supplement_suffix
+        [self.class.new(identifier.base).generate, marker]
+          .reject { |part| part.nil? || part.empty? }.join(":")
+      end
     end
   end
 end

data/lib/pubid/asme/CLAUDE.md

@@ -0,0 +1,25 @@
+# ASME flavor notes
+
+ASME index key and MR slug.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/asme/` or `spec/pubid/asme/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+## From the root note "AMCA / ASME / ASTM index key (`root.number`): three flavors, three different shapes"
+
+**(2) ASME — the whole printed code, not a split.** `Asme::Components::Code` is designator+number, so the IEEE split looks right — but **152 of 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 keyed `""`. So `number` holds the whole code (`"B18.3"`), declared on the leaf `Identifiers::Standard`. **`Asme::Components::Code` is now unused on the identifier path and there is no `#code` reader**: an earlier draft composed one so the renderer and URN generator would not have to change, but since `number` already holds the whole code that Code never carried a designator and `code.to_s` equalled `number` for all 731 ids — a string wrapped in an object whose only job was to unwrap to the same string. Both readers use `number` directly. **Contrast ASTM, which keeps its composed `#code`**: its renderer reads `code.letter`/`code.dual_m` field-by-field, so there the component carries real structure. The test for whether a derived `#code` earns its place is whether any caller reads a *field* of it rather than just `to_s`.
+
+## The trailing year and the BPVC designator (hand-off `asme-bpvc-and-amca-residue`)
+
+**A designator with no number lost its year.** The dash branch of `number_part` (`dash >> [0-9A-Z]+`, there for `BTH-1` and `CA-1`) also matched the year in `BPVC.I-2021`, so `-2021` became the number. For a BPVC code the builder then discarded the number, so all 150 BPVC ids had no year and the 2021, 2023 and 2025 editions of one document had the same hash, `to_s`, URN and slug. For `BPE-2012`, `OM-2017` and `PASE-2019` (13 ids) the year stayed inside `number` (`"BPE-2012"`). The `trailing_year` guard in `lib/pubid/asme/parser.rb` refuses that branch for a dash, a 4-digit or draft year, and no further code character. `BTH-1-2020` still parses as `BTH-1`.
+
+**Two BPVC render corruptions were in the same builder.** The case sub-code kept its leading dot (`BPVC.CC.BPV..I`, 15 ids), and the builder read the SSC sections one level above where the grammar put them (`BPVC.SSC.`, 2 ids). Every BPVC id now renders as it was written.
+
+**`BPVC-CC-BPV` and `BPVC.CC.BPV` are two documents, not two spellings.** The hand-off suggested normalizing one to the other, and a draft of this branch did that. It was reverted: the ASME catalogue (asme.org, "Find codes & standards") lists both as separate documents: `BPVC.CC.BPV` is the code-case book, and `BPVC-CC-BPV` is the designation of each 2019 code-case supplement ("BPVC Code Cases 2019-Boilers and Pressure Vessels, Supplement 7"; the supplement number is only in the title, so pubid cannot tell the supplements apart). Each keeps its own spelling, index key, `to_s` and URN.
+
+**The MR slug writes a literal `-` as `--`.** `mr_sanitize` wrote `.` and `-` both as `-`, so `BPVC.CC.BPV-2019` and `BPVC-CC-BPV-2019` shared `asme.bpvc-cc-bpv.2019`. Now the dash form is `asme.bpvc--cc--bpv.2019`. **`_` was the obvious choice and is wrong:** the MR format reserves `_` for supplement layers, and `Pubid::Parsers::MrString` splits on it first. The change moves only the slug, and only for the 113 corpus ids whose code has a literal dash (`BTH-1` → `bth--1`); `B18.3` stays `b18-3`.
+
+**The SSC codes of the ASME catalogue all parse.** `BPVC.SSC.XI.II.V.IX` (Sections XI, II, V, IX) and `BPVC.SSC.VIII.XII.II.V.IX` (Sections VIII, XII, II, V, IX) are different documents; the spec table carries every SSC code the catalogue lists.
+
+**Measured against a `main` baseline of the 731 fixture ids:** only the 150 BPVC ids and the 13 BPE/OM/PASE ids moved. No id stopped parsing. The `pubid-testsuite` corpus records the old outputs as debt (`tests/asme/_status.yaml` is `clean: false`), so it needs a re-export (hand-off `pubid__pubid-testsuite__asme-amca-reexport`).
+
+**Not fixed, pre-existing:** `ASME PTC 1-2015` renders `ASME PTC1-2015` (the space before a PTC number is lost).