pubid 2.0.13 → 2.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c7661b8db16717e43163b2e4cfde8d3f3a922589ac9d075dddecdc529526f2e
-  data.tar.gz: f7564b3039961555f1d54287638c4c3bec2e8efd9e3786e481be99c369c078fa
+  metadata.gz: 6a4c789f24390c6ea74355b629d16fe84521294e4aba851d074ecc0418196320
+  data.tar.gz: b80a6d4cc6167f7b6b53097dd5977fa754b27665be215fc2eb728d143d4e45fa
 SHA512:
-  metadata.gz: e54ac7d08d541dedb44056a36f256ef1fe113a8ae3d97a91d6bb23de145931aeb7dbfcdac5ec34445afcff1f811591321f2c4c37b9303859f68dbb40139e58b5
-  data.tar.gz: 0b87dd3af21db4708d6d9784a98f051fdfc338e3de106bd4982b508a95433f8b968caf005067febd01aa598420a89b070838ba5bcba39c017f21372ab35fb3b1
+  metadata.gz: b3e37160d1874aa2d56a13689c627488e20788a33a61dddbf9a80e6c8c9c3283684f85c74c4dd71220a4a207e65af2d5e9e342284623a0a06a53ba2d1ba26005
+  data.tar.gz: dc678f6348adfb5be0b429297a3ba126df534ff531178e63fedfd2c7ba4c2c96a208af33b6f9dce35c7bf49fc29b14c21179ce4d9f43b5c42d839434b85dcfc1

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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.13
+  version: 2.0.14
 platform: ruby
 authors:
 - Ribose Inc.