pubid 2.0.13 → 2.0.15

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

@@ -237,16 +237,114 @@ module Pubid
       # deserializes, so nested bases rebuild their component too. `draft` needs
       # no expansion (Draft.parse accepts the slashless form).
       def self.from_hash(data, options = {})
-        data = Compaction.expand(Compaction.deep_dup(data)) if data.is_a?(::Hash)
+        if data.is_a?(::Hash)
+          # The canonical comparison reads the wire AS STORED — the expand
+          # below rewrites `stage` into the typed_stage sub-hash that
+          # to_hash re-collapses, so the expanded form never equals a
+          # to_hash and would brand every canonical row legacy.
+          original_wire = Compaction.deep_dup(data)
+          # expand mutates its argument, so it works on another dup —
+          # original_wire must stay as the wire was stored.
+          data = Compaction.expand(Compaction.deep_dup(data))
+        end
         identifier = super
         # == compares the raw ivars: a rebuild whose lazy readers have not
         # run carries @code_obj/@draft_obj nil while a parse has them set,
         # so the objects compare unequal although their serialized hashes
         # agree (pubid#596). Materialize the runtime components eagerly.
         identifier.materialize_runtime_components
+        if original_wire
+          identifier = normalize_legacy_wire_shape(identifier, original_wire)
+        end
         identifier
       end
 
+      # The legacy crawls stored shapes the 1.3.x-era renderer printed that
+      # the current grammar reads differently (the stage-token drafts the D=
+      # designator face superseded — "DCD1" —, the project drafts stored as
+      # plain standards, the draft-less month dates the joint IEEE face now
+      # prints). A row whose deserialized canonical hash differs from the
+      # wire hash it came from is such a legacy shape: re-derive the
+      # identifier from its own render — the shape a parse of the printed
+      # form produces — so the deserialized row answers the corpus laws
+      # (render(parse(x)) == x, parse(render(x)) == x) like every
+      # parse-built one. The re-derived shape is accepted only when it is
+      # itself stable (parse∘render idempotent on string and hash), so the
+      # normalization never lands on a drifting spelling. A canonical wire
+      # hash — the current serializer's output, `to_hash == wire` — never
+      # heals, so `from_hash(to_hash(id)) == id` keeps holding for every
+      # parse-built identifier (the relaton-index round-trip invariant).
+      MAX_NORMALIZE_CYCLES = 3
+
+      def self.normalize_legacy_wire_shape(identifier, wire_hash)
+        # The base class dispatches this hash to the concrete class's
+        # from_hash AFTER expand rewrote `stage` into the typed_stage
+        # sub-hash, so the comparison collapses the wire back to the
+        # serialized shape to_hash emits (collapse is lossless and a no-op
+        # on an already-collapsed wire).
+        wire = canonical_wire_hash(wire_hash)
+        return identifier if identifier.to_hash == wire
+
+        original = identifier
+        MAX_NORMALIZE_CYCLES.times do
+          round = reparse(identifier)
+          return original unless round
+
+          same = round.to_s == identifier.to_s &&
+            round.to_hash == identifier.to_hash
+          return identifier if same
+
+          # Land only on a shape that is itself parse∘render-stable, so the
+          # healed identifier satisfies the corpus laws; an unstable round
+          # becomes the vantage of the next cycle, and an exhausted cycle
+          # budget keeps the legacy shape (never a drifting spelling).
+          return round if stable_shape?(round)
+
+          identifier = round
+        end
+        original
+      end
+
+      # The wire as the canonicalizer emits it: key-normalized (string and
+      # symbol callers alike) and collapsed back from the expand rewrite.
+      def self.canonical_wire_hash(wire_hash)
+        normalized = normalize_wire_keys(Compaction.deep_dup(wire_hash))
+        Compaction.collapse(normalized)
+      end
+
+      # One parse of the identifier's own render, or nil when the render is
+      # not grammar-readable (the legacy shape is kept, as recorded).
+      def self.reparse(identifier)
+        Pubid::Ieee::Identifier.parse(identifier.to_s)
+      rescue StandardError
+        nil
+      end
+
+      # A shape is landable when parse∘render is idempotent on it, string
+      # and hash — the Law 1a + Law 1b pair the corpus gate asserts.
+      def self.stable_shape?(round)
+        again = reparse(round)
+        !again.nil? && again.to_s == round.to_s &&
+          again.to_hash == round.to_hash
+      end
+
+      # Wire hashes arrive string-keyed (the published indexes) or
+      # symbol-keyed (direct spec calls); to_hash emits string keys, so the
+      # canonical comparison normalizes the wire keys the same way,
+      # recursing into nested bases.
+      def self.normalize_wire_keys(node)
+        case node
+        when ::Hash
+          node.each_with_object({}) do |(key, value), out|
+            out[key.to_s] = normalize_wire_keys(value)
+          end
+        when ::Array
+          node.map { |item| normalize_wire_keys(item) }
+        else
+          node
+        end
+      end
+
       # Rebuild the runtime components from the wire strings. Safe on every
       # construction path: the readers' ||= no-ops when already set, and the
       # CodeNumber rebuild covers the split-column rows that carry no code

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

@@ -253,11 +253,24 @@ module Pubid
 
           parts << code_str if code_str && !code_str.empty?
 
-          # Join with space and add year with dash — unless the D=
-          # designator face already carried it above.
+          # Join with space and add the date — unless the D= designator face
+          # already carried the year. The month face follows the standing
+          # month rule: a text month is the comma long form (", February
+          # 2018", which re-parses through the joint date clause), a numeric
+          # month the glued short form ("-2018-05"); dropping the month
+          # published a different date ("P90003, February 2018 (E)" printed
+          # as "P90003-2018").
           result = parts.join(" ")
-          result += "-#{year}" if year && !@designator_carries_year &&
-                           !ieee_draft.to_s.end_with?("-#{year}")
+          if year && !@designator_carries_year &&
+             !ieee_draft.to_s.end_with?("-#{year}")
+            result += if month.to_s.match?(/\A\d+\z/)
+                        "-#{year}-#{month.to_s.rjust(2, '0')}"
+                      elsif month
+                        ", #{month} #{year}"
+                      else
+                        "-#{year}"
+                      end
+          end
           # Lossless on the IEEE face too: the parenthetical rides after
           # the year, before the redline marker.
           result += " (#{parenthetical_content})" if parenthetical_content

data/lib/pubid/ieee/renderer.rb

@@ -146,7 +146,16 @@ module Pubid
         should_render_type = id.publisher&.match?(/^(IEEE|AIEE)/) ||
                              id.is_a?(Identifiers::ProjectDraftIdentifier)
 
-        if should_render_type && !id.typed_stage&.project_status &&
+        # An ISO/IEC stage-token draft (CD1, FDIS — the draft_obj carries the
+        # stage) is its own draft marker: the designator face it renders
+        # ("…/D=CD1", pubid#203) never takes the word Draft, so the type word
+        # is skipped whatever the publisher arrangement — the joint rows
+        # ("IEEE/IEC Draft P60076-57-129/D=FDIS-201707") would otherwise print
+        # Draft on one construction path and drop it on the re-parsed
+        # designation path, and the render would not re-parse to itself.
+        stage_draft = id.draft_obj&.iso_stage && true
+
+        if should_render_type && !stage_draft && !id.typed_stage&.project_status &&
            ((id.type && !id.type.to_s.strip.empty? && id.type != "P") ||
             id.is_a?(Identifiers::ProjectDraftIdentifier)) &&
             !id.draft_status.to_s.match?(/unapproved/i)

data/lib/pubid/nist/CLAUDE.md

@@ -112,3 +112,26 @@ Read this before you change `lib/pubid/nist/` or `spec/pubid/nist/`. The root
   `from_hash` now derives it by the Builder's own condition and rules
   (`derive_subseries_code`, sharing SP_SUBSERIES). Locked by
   `spec/pubid/nist/from_hash_shapes_spec.rb`.
+
+- **The bare compound series is the SERIES REFERENCE (owner ruling on the
+  relaton fuzz gate's `NBS CS` mutant).** The compound-series branch of the
+  grammar demanded a separator after the series token, so the bare
+  abbreviation of a named series failed to parse; the fuzz gate drops the
+  edition from a published `NBS CS e15`-style row and kept recording the
+  mutant. The ruling: the bare form is a legitimate identity — the v1
+  pubid-nist `series.yaml` names CS as Commercial Standards, CSM as
+  Commercial Standards Monthly, CIS as Consumer Information Series, CS-E
+  as the emergency form — the same partial/bare-reference pattern as
+  BIPM's `SI Brochure`. The grammar (pubid-grammar, fleet compiler
+  1.3.121) makes the compound branch's separator+tail one optional group,
+  so every previously accepted form parses byte-identically and exactly
+  the bare compound-series forms join the accept set; simple-series bare
+  forms (`CS` alone, no publisher) are deliberately NOT covered. The bare
+  forms route through the normal series classes (`NBS CS` →
+  CommercialStandard …, `NBS CIS`/`NIST PS`/`NIST DCI` → the base
+  `Identifier`), render the short face as the abbreviation and the MR
+  face per the v1 series table (`NBS.CS`), and match their series members
+  as wildcard queries (`#matches?`). Locked by
+  `spec/pubid/nist/bare_series_reference_spec.rb`; the corpus round froze
+  the six rows (`NBS CS`, `NBS CSM`, `NBS CIS`, `NBS CS-E`, `NIST PS`,
+  `NIST DCI`) into the testsuite with the gem twin in lockstep.

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.13"
+  VERSION = "2.0.15"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.13
+  version: 2.0.15
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-07 00:00:00.000000000 Z
+date: 2026-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model