pubid 2.0.0.pre.alpha.17 → 2.0.0.pre.alpha.19

data/lib/pubid/ieee/CLAUDE.md

@@ -95,3 +95,5 @@ The lesson BSI paid for: a wrapper's hand-written `#number` delegation makes the
 - **`all_parts_edition_keys` missed `revision`, `reaffirmed` AND `edition_month` — three gaps, found in two passes.** `Identifier.all_parts_edition_keys` defaults to `%i[date year edition version]`. A first pass fixed IEEE's `revision` attribute (the numbered/lettered draft revision id — "2" in "P802.16Rev2"), a separate discriminator from `edition`/`year` that this list never covered, so `"IEEE P802.16Rev2".to_all_parts === "IEEE P802.16Rev3"` was `false` — two revisions of the same draft failed to collapse. Code review of that same change then found it had stopped one attribute too early: `reaffirmed` (the "(R2010)" year, read by `renderer.rb` and `urn_generator.rb`) meant two reaffirmations of the same standard — `"IEEE Std 218-1956 (R1980) …"` vs `"… (R1990) …"` — also failed to collapse; and `edition_month`, the month half of the `"Edition N YYYY-MM"` rendering (`renderer.rb`'s `"Edition #{edition} #{year}-#{edition_month}"`), survived even though its sibling `year` is already in the default list, so `"IEEE Std 802.11 Edition 3.0 2015-03"` didn't match `"… 2015-06"`. All three fixed together: `Pubid::Ieee::Identifier.all_parts_edition_keys` is `super + %i[revision reaffirmed edition_month]`. Not on the original hand-off's audit list (which didn't cover IEEE); found during code review of the OGC/3GPP/NIST fix for the same class of bug. **Lesson**: finding one missed attribute on a flavor does not mean the audit of that flavor is finished — check every date/edition/version/revision/reaffirmation-shaped attribute against the renderer and builder, not just the one the bug report named (see the root `CLAUDE.md` bullet). Locked by `spec/pubid/all_parts_edition_keys_audit_spec.rb`.
 
 - **The project designator format, and the bare-P parse that dropped it (pubid#18).** IEEE's own draft documents are cited by their short designator — "P1201/D0.3", "P10000/D1.2" — and metanorma-ieee had to post-process the full rendering to produce it. Two edits. **(1) `format: :project`** registers `Pubid::Ieee::ProjectRenderer` in the IEEE format registry: the code (with parts), a PREPENDED "P" when the identifier is a project but the code does not already carry it, and "/D<draft>"; no publisher, no type word, no date. "Project" is detected in all three places a marker can live depending on the building path — `code_obj.prefix` (the bare spelling), the "P" type code, or a `typed_stage` with `project_status` (D1-D6). **(2) The bare-P data loss**: `ieee_p_identifier` consumed its leading "P" with a bare `str("P")`, so "P1201/D0.3" parsed WITHOUT its P anywhere (the number was "1201", prefix nil) — the issue's complaint verbatim. The rule now lets `number` capture the P (the #318 pattern), so `code.prefix` survives and the designator has something to read. The DEFAULT rendering is unchanged — the corpus keeps the P in every unapproved-draft canonical, and #318's idempotence work locked that; the issue's suggestion that the default drop the P predates the corpus and is not adopted. A published (non-project) id renders its bare number under `:project` — the format is a draft-designator view.
+
+- **Joint stage-first forms are lead ISO, and the ISO face is lossless (pubid#477)**: a stage word printed in the ISO position (`IEEE FCD 15026.3:2010`, `IEEE/IEC CD2 P62582-2017-05`) parses as printed (#469): `Builder#build_joint_development` sets `lead_party "ISO"` whatever the publisher order, so `canonical_format` is `:iso`. PR #472 had made the lead the first printed publisher and rendered an IEEE-first form in the `D=` face — but the grammar artifact cannot parse most of those renders (`D=FCD`, `D=CD.2`, a non-P number, a month), and `D=CD-2020` parses into a *different* id (`ieee_draft`, no `iso_stage`), so 19 published `relaton-data-ieee` rows stopped matching themselves. The `D=` face now prints only for an id that carries a `D=` designator, or on an explicit `to_s(format: :ieee)`. `JointDevelopment#to_iso_format` prints `iso_stage` as stored (`DIS2`, `CD4` — #472's bare `CD` lost the iteration) and the date in the spelling that parses back (`#iso_date_suffix`: `:2018`, `-2018-05`, `, April 2019`). **The test is `parse(to_s) == id`, not a stable `to_s`**: a lossy render reaches a fixed point and round-trips its *hash* (`iso_stage_spellings_spec` held both while dropping `CD4`→`CD`), yet the reparse is a different identifier. Measured over the 118 joint stage rows of `relaton-data-ieee`: `to_s` stable 100 → 118, `==` 51 → 106; the other 12 carry an `ieee_draft` or an edition that the ISO face still drops. **PARG separator-in-capture, again (#471)**: the draft `revision` capture is `".12"`, and `Draft#to_s` adds its own dot, so `handle_draft` strips the leading dot (`D2022.10.12` rendered `D2022.10..12`). Check every capture a renderer re-joins with a separator. Locked by `spec/pubid/ieee/joint_stage_roundtrip_spec.rb` (stored index hashes → `parse(to_s) == row`).

data/lib/pubid/ieee/builder.rb

@@ -861,26 +861,14 @@ module Pubid
 
         # Detect lead party based on pattern
         if parsed[:iso_stage]
-          # ISO stage word present. The lead party is the PRINTED first
-          # publisher (pubid#469: the arrangement is the organization's
-          # perspective, shown by the print) — "IEEE/ISO/IEC CD P42010"
-          # is IEEE-led even though the stage word is ISO's.
-          attributes[:lead_party] = attributes[:publishers]&.first || "ISO"
+          # ISO stage word present: the reference is printed in the ISO
+          # position ("IEEE FCD 15026.3:2010"), so it parses as printed
+          # (pubid#469) - lead ISO, ISO face, whatever the publisher
+          # order. The printed first publisher is not the arrangement, and
+          # the published relaton-data-ieee rows carry lead ISO (pubid#477).
+          attributes[:lead_party] = "ISO"
           attributes[:iso_stage] = extract_value(parsed[:iso_stage])
 
-          # A digit-suffixed stage word ("CD4", "DIS2") from a stage-FIRST
-          # spelling prints bare in the ISO face (every
-          # iso_stage_spellings_spec expectation: the iteration is draft
-          # machinery, not identity). The embedded/stage-last form keeps
-          # its "CD3" whole — its trailing token IS the identity the
-          # embedded corpus keys on (embedded_iso_stage_spec) — and
-          # serialized rows keep theirs verbatim (#477).
-          # the marker is a zero-length capture: presence is the signal
-          embedded = !parsed[:stage_embedded].nil?
-          if !embedded && attributes[:iso_stage]&.match?(/\A[A-Z]+\d+\z/)
-            attributes[:iso_stage] = attributes[:iso_stage][/\A[A-Z]+/]
-          end
-
           # Create typed_stage for ISO stage
           stage_abbr = attributes[:iso_stage]
           if stage_abbr
@@ -1484,7 +1472,12 @@ module Pubid
             version = version.sub(/\A-/, "") if version
           end
 
-          revision = extract_value(draft_data[:revision]) if draft_data[:revision]
+          # The PARG capture carries its separator (".12", the #471
+          # convention); Draft#to_s prints the dot itself, so keep only
+          # the digits or "D2022.10.12" renders "D2022.10..12" (pubid#477).
+          if draft_data[:revision]
+            revision = extract_value(draft_data[:revision])&.delete_prefix(".")
+          end
 
           # The compound both-systems form (docs/IEEE-DRAFT-STAGES.md
           # §1.3): the stage half of "=DDIS.3".

data/lib/pubid/ieee/identifiers/joint_development.rb

@@ -69,6 +69,10 @@ module Pubid
           # Set lead_party if not provided - default to first publisher
           if args[:lead_party]
             self.lead_party = args[:lead_party]
+          elsif iso_stage
+            # A stage-first reference is lead ISO, as the builder sets it
+            # (pubid#477) — a hand-built id must agree with a parsed one.
+            self.lead_party = "ISO"
           elsif publishers && !publishers.empty?
             # Lead party defaults to first publisher if not explicitly set
             # Builder should override this with detected lead party
@@ -79,20 +83,10 @@ module Pubid
         # Canonical format based on lead party
         # @return [Symbol] :ieee or :iso
         def canonical_format
-          # A PARSED stage-tracked D= designator is IEEE draft notation —
-          # its canonical face is the designator spelling (§1.3 spelling 7:
-          # "JOINT PNUMBER/D=<STAGE>[:year]"). Rows that carry an ISO stage
-          # word (from_hash, or stage-led parses) keep the stage-word face
-          # no matter what the render derives: their published spelling is
-          # "IEEE FCD 15026.3:2010", not a designator (#477).
-          if ieee_draft.to_s.start_with?("D=") && iso_stage.to_s.empty?
-            return :ieee
-          end
-          # A stage-word row (parsed stage-led spelling, or a serialized
-          # row carrying iso_stage) prints the stage-word face whatever
-          # the lead party — the stage word is the printed identity
-          # ("IEEE FCD 15026.3:2010", #477).
-          return :iso unless iso_stage.to_s.empty?
+          # A stage-tracked D= designator is IEEE draft notation — its
+          # canonical face is the designator spelling (§1.3 spelling 7:
+          # "JOINT PNUMBER/D=<STAGE>[:year]"), whatever the lead party.
+          return :ieee if ieee_draft.to_s.start_with?("D=")
 
           case lead_party
           when "IEEE", "AIEE"
@@ -147,23 +141,14 @@ module Pubid
 
           # The stage word is the ISO format's own position convention —
           # it prints whenever the identifier carries one, regardless of
-          # lead party (the format face decides, not the arrangement). A
-          # stage-tracked D= designator decomposes into its stage word
-          # and date ("D=CD.2-2020" → "CD2", 2020); the iteration glues
-          # onto the word only for the stages whose printed ISO spellings
-          # carry it (CD2, DIS2 — the grammar's multi-digit families);
-          # the P project stage is IEEE convention and never prints here.
-          # The stage word prints verbatim: parsed digit-suffixed
-          # spellings ("CD4") are normalized to the bare word with the
-          # iteration carried separately at build time, while serialized
-          # rows keep the full "DIS2" — both must round-trip (#477).
-          stage_word = iso_stage
-          stage_word = nil if stage_word.to_s.empty?
-          # A serialized row's stage iteration is identity: re-attach it
-          # to the printed word ("DIS2 24748.4:2015", #477). The parse
-          # path never sets stage_iteration for digit-suffixed spellings.
-          iter = stage_iteration.respond_to?(:number) ? stage_iteration.number : stage_iteration
-          stage_word = "#{stage_word}#{iter}" if stage_word && iter.to_s.match?(/\A\d+\z/)
+          # lead party (the format face decides, not the arrangement).
+          # The stage prints as stored, iteration included ("DIS2",
+          # "CD4"): the face is lossless, so parse(to_s) == self
+          # (pubid#477). A stage-tracked D= designator decomposes into its
+          # stage word and date ("D=CD-2020" → "CD", 2020); the P project
+          # stage is IEEE convention and never prints here.
+          stage_word = iso_stage.to_s
+          stage_word = nil if stage_word.empty?
           draft_year = nil
           if stage_word.nil? &&
              ieee_draft.to_s.match(/\AD=([A-Z]+)(?:\.(\d+[a-z]?))?(?:[-:](\d{4}))?\z/)
@@ -179,24 +164,33 @@ module Pubid
           code_str += mark unless code_str.empty?
           parts << code_str if code_str && !code_str.empty?
 
-          # Join with space and add year with colon (the ISO position
-          # convention; a decomposed D= date rides here as the year).
-          result = parts.join(" ")
-          result += ":#{year || draft_year}" if year || draft_year
+          # Join with space and add the date (a decomposed D= date rides
+          # here as the year).
+          result = parts.join(" ") + iso_date_suffix(year || draft_year)
           # Only the language/edition marker ("(E)", "(E/F)") prints; a
           # trailing relationship narrative is metadata, not identity.
           if parenthetical_content&.match?(%r{\A[A-Z](?:\s*[/&]\s*[A-Z])*\z})
             result += " (#{parenthetical_content})"
           end
 
-          # The revision narrative prints after the code: published joint
-          # rows carry it as identity spelling ("…:2012(E) Revision of
-          # IEEE Std C37.082-1982", #477).
-          result += " #{relationships.map(&:to_s).join(' ')}" if relationships && !relationships.empty?
-
           result
         end
 
+        # The ISO-face date, in the spelling that parses back to the same
+        # year and month: the colon year (":2018"); a numeric month glued
+        # with dashes ("-2018-05"); a text month as ", February 2015".
+        def iso_date_suffix(date_year)
+          return "" unless date_year
+          return ":#{date_year}" unless month
+
+          if month.match?(/\A\d+\z/)
+            # The grammar reads only a two-digit month ("05", never "5").
+            "-#{date_year}-#{month.rjust(2, '0')}"
+          else
+            ", #{month} #{date_year}"
+          end
+        end
+
         # Convert to IEEE format representation
         # ISO/IEC/IEEE P26511/D8-2018
         # @return [String] IEEE format string
@@ -215,8 +209,9 @@ module Pubid
 
           # Add IEEE draft notation if available (e.g., /D8). An ISO stage
           # word renders in IEEE's stage-tracked position as the ordinal-less
-          # stage draft (docs/IEEE-DRAFT-STAGES.md §1.3, spelling 7):
-          # "IEEE/ISO/IEC CD P42010:2020" → "IEEE/ISO/IEC P42010/D=CD-2020".
+          # stage draft (docs/IEEE-DRAFT-STAGES.md §1.3, spelling 7) — only
+          # on an explicit to_s(format: :ieee): a stage-first reference is
+          # lead ISO, so its canonical face is the ISO one (pubid#477).
           # The iso_stage branch is checked FIRST — the typed_stage registry
           # lookup for a stage word answers a draft-equivalent ordinal ("D2"),
           # which is not the canonical stage-tracked spelling.
@@ -230,9 +225,11 @@ module Pubid
           elsif ieee_draft
             code_str += "/#{ieee_draft}"
           elsif iso_stage
-            # A stage word never converts to a designator on the IEEE
-            # face: published stage rows print the stage-word face
-            # ("IEEE FCD 15026.3:2010", #477).
+            # The ordinal-less stage draft: an iteration glued onto the
+            # printed word ("CD2") renders in the doctrine's ".iter" slot
+            # ("D=CD.2" — docs/IEEE-DRAFT-STAGES.md §1.3).
+            stage = iso_stage.match(/\A([A-Z]+?)(\d+)\z/)
+            code_str += stage ? "/D=#{stage[1]}.#{stage[2]}" : "/D=#{iso_stage}"
           elsif typed_stage&.ieee_draft_equivalent
             code_str += "/#{typed_stage.ieee_draft_equivalent}"
           end

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.0.pre.alpha.17"
+  VERSION = "2.0.0.pre.alpha.19"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.alpha.17
+  version: 2.0.0.pre.alpha.19
 platform: ruby
 authors:
 - Ribose Inc.
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.57
+        version: 1.3.62
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.57
+        version: 1.3.62
 description: PubID is a Ruby library for parsing and generating international publication
   identifiers (PubIDs). It provides a simple and flexible API for working with PubIDs,
   allowing developers to easily create, manipulate, and validate PubIDs in their applications.