pubid 2.0.0.pre.alpha.40 → 2.0.0.pre.alpha.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1e4c5a6889f61e535b4d05517aff5798eb5307c79bf7e318ab21822ebfe73ae
-  data.tar.gz: f129c70c4c9c646318c58e12d7a5e1097299c5698a083a0710e2866a2e7ad692
+  metadata.gz: 727766fd99f726fa80503d1b6c0a069a889b9837d100508cb94f11989b28c1c4
+  data.tar.gz: d748fad2cb8845c858a03b78aa303644f6c6f24eaeb83a3fa0803f56cb6a0039
 SHA512:
-  metadata.gz: d2e7e5cea5f0749a2aa5715521a2d6c192b43395bcb9f72470207629f6e7d1f0b9a7dbb089a1cc8e23c41a6ffc61a1e1424ce2546618249ed3eb074d611b3e4f
-  data.tar.gz: c4ee9f3166fa9caffb6f3b85d4684c11b6f08ac615ecf302af94831a9e7538a29264c2a862ffefa161fbeb4dbabc11b82405730c2435d5d666ab42c257fe2a61
+  metadata.gz: 52c2d82f4dd10de849784edc147c35a9747f1c3f77b23f3e971d976bad8f1f930e58f9b99904ed8542c7bed2be7eef94c564ded781283c0f008c9426f42e59ca
+  data.tar.gz: 0c614594edcdd773af2d5d4240362fa32ee088625bfa3a8cc819bc40d6c697904c53b0a54ccb5ca47c4f35e1f0f02a711fb55a731d5a05395d455a9b6e0be874

data/lib/pubid/bsi/CLAUDE.md

@@ -90,4 +90,4 @@ The general fix (`metanorma__pubid__exclude-recursion-depth` hand-off) promotes
 
 Verified: `spec/pubid/supplement_date_attributes_spec.rb` exercises the mechanism directly; `spec/pubid/bsi/parse_gaps_spec.rb`, `match_primitives_spec.rb` and `adoption_base_spec.rb`, and `spec/pubid/cen_cenelec/relaton_blockers_spec.rb`'s 10 pinned `:supplement_year` cases, all pass unchanged. Because the new logic only fires when `supplement_date_attributes` is non-empty, every other flavor (including ISO/IEC, which deliberately keep a supplement's year in `date` with no protection — see `lib/pubid/cen_cenelec/CLAUDE.md`) is untouched.
 
-**Open question, not resolved here: `#dated_version_of?`/`#draft_of?` on a bare BSI supplement.** Both build on `matches?(other, ignore: [:date, :year, …])`, which — like every other bare `:date`/`:year` exclusion — now protects a supplement's own date unless `:supplement_year` is also passed. Two standalone `BS 7273-4:2015+A1:2021`/`...+A1:2022` objects were `dated_version_of?` each other before this branch (BSI's old `year`-attribute dodge never protected against `exclude(:year)`) and are not after. **Whether that's the right answer is genuinely unclear and deliberately left open pending feedback** — one reading is that this just makes BSI consistent with CEN/CENELEC, which already behaved this way before this branch (its pre-existing per-flavor `#exclude` override had the same protection); the other is that these two generic relational predicates should be widened to accept a `:supplement_year`-aware `ignore` set so they can still recognize two differently-dated editions of the *same supplement* as related. Neither predicate was touched in this branch — this is recorded, not decided. Locked (as current behavior, not as a verdict) by `spec/pubid/supplement_date_attributes_spec.rb`.
+**Open question, not resolved here: `#dated_version_of?`/`#draft_of?` on a bare BSI supplement.** Both compare `exclude(:date, :year[, …])`, which — like every other bare `:date`/`:year` exclusion — now protects a supplement's own date unless `:supplement_year` is also passed. Two standalone `BS 7273-4:2015+A1:2021`/`...+A1:2022` objects were `dated_version_of?` each other before this branch (BSI's old `year`-attribute dodge never protected against `exclude(:year)`) and are not after. **Whether that's the right answer is genuinely unclear and deliberately left open pending feedback** — one reading is that this just makes BSI consistent with CEN/CENELEC, which already behaved this way before this branch (its pre-existing per-flavor `#exclude` override had the same protection); the other is that these two generic relational predicates should be widened to accept a `:supplement_year`-aware exclusion set so they can still recognize two differently-dated editions of the *same supplement* as related. (The predicates switched from `matches?(other, ignore: …)` to the equivalent `exclude(…)` comparison so NIST's asymmetric `#matches?` override no longer breaks them; BSI behavior is unchanged.) Locked (as current behavior, not as a verdict) by `spec/pubid/supplement_date_attributes_spec.rb`.

data/lib/pubid/identifier.rb

@@ -1177,10 +1177,46 @@ module Pubid
 
     # Self and +other+ refer to the same document but differ only in the
     # trailing date / year — the "dated vs undated" reference pattern.
+    # Compares #exclude, not #matches?: NIST overrides #matches? as an
+    # asymmetric wildcard query (and takes no ignore: keyword).
     def dated_version_of?(other)
       return false unless other.is_a?(::Pubid::Identifier)
 
-      matches?(other, ignore: [:date, :year]) && self != other
+      exclude(:date, :year) == other.exclude(:date, :year) && self != other
+    end
+
+    # The attributes that carry a revision marker. Flavors spell it
+    # differently: OGC and IEEE hold a string (+revision+), NIST folds the
+    # lettered revision and its date into an +update+ component.
+    REVISION_ATTRIBUTES = %i[revision update update_component].freeze
+
+    # The revision marker this identifier carries, or nil. See
+    # REVISION_ATTRIBUTES.
+    # @return [String, Components::Update, nil]
+    def revision_marker
+      REVISION_ATTRIBUTES.each do |name|
+        next unless self.class.attributes.key?(name)
+
+        value = public_send(name)
+        return value unless value.nil? || value == ""
+      end
+      nil
+    end
+
+    # Self is a revision of +other+: the same document, where self carries a
+    # revision marker ("OGC 06-121r9", "NBS LC 800 rJun1992") that +other+
+    # lacks or spells differently. A document whose revision is modelled as
+    # an edition is covered by #edition_of? instead.
+    def revision_of?(other)
+      return false unless other.is_a?(::Pubid::Identifier)
+      return false if self == other
+      return false if revision_marker.nil?
+
+      # #exclude, not #matches?: NIST overrides #matches? as an asymmetric
+      # wildcard query (and takes no ignore: keyword), which would compare a
+      # query against a candidate rather than two concrete documents.
+      exclude(*REVISION_ATTRIBUTES) == other.exclude(*REVISION_ATTRIBUTES) &&
+        revision_marker != other.revision_marker
     end
 
     # The document a wrapper stands in front of: a supplement's base, or
@@ -1289,7 +1325,8 @@ module Pubid
 
       root == other.root &&
         self != other &&
-        matches?(other, ignore: [:date, :year, :stage, :typed_stage])
+        exclude(:date, :year, :stage, :typed_stage) ==
+          other.exclude(:date, :year, :stage, :typed_stage)
     end
 
     # Self and +other+ are editions of the same document: the edition-year
@@ -1315,7 +1352,7 @@ module Pubid
     # Any relational predicate holds.
     def related_to?(other)
       %i[supplement_of? has_supplement? dated_version_of? edition_of?
-         sibling_of? includes? draft_of?].any? do |m|
+         revision_of? sibling_of? includes? draft_of?].any? do |m|
         public_send(m, other)
       end
     end

data/lib/pubid/nist/CLAUDE.md

@@ -54,3 +54,21 @@ Read this before you change `lib/pubid/nist/` or `spec/pubid/nist/`. The root
   `update`/`update_component` and cleared to `nil` before the object is
   returned. Neither carries live information `edition`/`update` doesn't
   already cover. Locked by `spec/pubid/all_parts_edition_keys_audit_spec.rb`.
+
+- **The URN parser must rebuild the human face the generator started from,
+  field for field.** `UrnGenerator` dot-joins identity fields after the
+  number (`urn:nist:sp:304.e2017.A.supp`), and `UrnParser#parse_payload`
+  splits them back: the edition/volume/revision glue onto the number, a
+  single capital-letter token is a **part** glued to the code
+  (`304A`), an edition's additional text keeps its dot (`13e2.June1908` —
+  the token after `eN`), `insert`/`errata`/`add` markers glue verbatim,
+  the bare `.supp` is supplementability (non-identity) and a valued
+  `.supp-<v>` is `sup<v>`. The rebuild is only correct if the flavor's own
+  grammar accepts it, so every branch is measured against the corpus —
+  before this, the five rows with a part letter, an edition additional
+  text, or an addendum marker failed to re-parse and the reference's own
+  `parse_urn` raised on its own output. The ts mirror must reproduce
+  Ruby's `String#split` behaviour and drop **trailing** empty fields
+  (`"800-38.A.supp.add."` splits with a trailing `""` in JS but not in
+  Ruby; keeping it appends a stray `.`). Locked by
+  `spec/pubid/nist/urn_parser_spec.rb`.

data/lib/pubid/nist/urn_parser.rb

@@ -40,10 +40,10 @@ module Pubid
         parts = split_parts(body)
 
         type_token, payload = parts
-        code, revision = parse_payload(payload)
+        code, suffix = parse_payload(payload)
 
         text = "#{publisher_for(type_token)} #{type_label(type_token)} #{code}"
-        text += revision if revision
+        text += suffix
         flavor_parse(text)
       end
 
@@ -58,14 +58,42 @@ module Pubid
         NBS_SERIES.include?(type_token.downcase) ? "NBS" : "NIST"
       end
 
+      # The generator dot-joins the identity's fields after the number
+      # ("urn:nist:circ:25.e1924.supp", "urn:nist:circ:539.v10.supp",
+      # "urn:nist:circ:24.supp-1"). Reassemble the human spelling the
+      # flavor parser reads: the edition and volume glue onto the number,
+      # a revision glues after them, the bare ".supp" marks
+      # supplementability (non-identity) and a valued ".supp-<v>" is the
+      # supplement's "sup<v>" face.
       def parse_payload(payload)
-        # Strip the trailing ".supp" supplement marker.
-        stripped = payload.sub(/\.supp\z/, "")
-        # Split revision suffix from code (e.g., "800-53.r5" → ["800-53", "r5"]).
-        match = stripped.match(/^(.*)\.(r\d+)$/i)
-        return [stripped, nil] unless match
+        tokens = payload.split(".")
+        code = tokens.shift.to_s
+        suffix = +""
+        part = nil
+        edition = nil
+        volume = nil
+        revision = nil
+        supplement = nil
 
-        [match[1], match[2]]
+        tokens.each do |token|
+          case token
+          when /\Ar\d+\z/i then revision = token
+          when /\Ae[\w]+\z/i then edition = token
+          when /\Av\d+\z/i then volume = token
+          when /\Asupp-(.+)\z/im then supplement = Regexp.last_match(1)
+          when "supp" then next # supplementability marker, not identity
+          when "insert", "errata" then suffix << token # glued in the human
+          when /\A[A-Z]\z/ then part = token # part letter, glued to the code
+          when /\A[A-Z][a-z]+\d{4}\z/ # edition's additional text ("13e2.June1908")
+            edition = "#{edition}.#{token}" if edition
+          else suffix << ".#{token}" # unknown marker: keep verbatim
+          end
+        end
+
+        code << part.to_s
+        suffix << edition.to_s << volume.to_s << revision.to_s
+        suffix << "sup#{supplement}" if supplement
+        [code, suffix]
       end
 
       def type_label(token)

data/lib/pubid/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.alpha.40
+  version: 2.0.0.pre.alpha.42
 platform: ruby
 authors:
 - Ribose Inc.