pubid 2.0.0.pre.alpha.12 → 2.0.0.pre.alpha.14

data/lib/pubid/jis/identifier.rb

@@ -7,6 +7,11 @@ module Pubid
     # Pubid::Jis::Identifiers descend from this class, so a parsed JIS id is an
     # instance of Pubid::Jis::Identifier.
     class Identifier < ::Pubid::Identifier
+      # JIS prints its own all-parts suffix, "（規格群）".
+      def self.all_parts_class
+        Identifiers::AllParts
+      end
+
       # JIS keeps its number flat at the top level (string, to preserve leading
       # zeros like "0205"), with the division letter in `series` and any
       # multi-level part numbers in `parts`. Supplements override `number` with
@@ -16,9 +21,6 @@ module Pubid
       attribute :parts, :string, collection: true # Optional multi-level parts
       attribute :year, :integer
       attribute :language, :string # "E" or "J"
-      # Boolean flags carry no default, so they stay nil (and are omitted from
-      # the serialized hash) unless actually set true.
-      attribute :all_parts, :boolean
       # Reaffirmation (再確認): a trailing "R" on the year marks an edition
       # that was reaffirmed without revision (e.g. ":2019R").
       attribute :reaffirmed, :boolean
@@ -50,7 +52,6 @@ module Pubid
         map "parts", to: :parts
         map "year", to: :year
         map "language", to: :language
-        map "all_parts", to: :all_parts
         map "reaffirmed", to: :reaffirmed
         # render_empty keeps a bare "SYMBOL" (empty-string value) in the hash so
         # it round-trips distinctly from "no symbol" (nil).
@@ -62,10 +63,6 @@ module Pubid
       # would otherwise fail serialization type validation.
       PUBLISHER = "JIS"
 
-      def all_parts?
-        all_parts == true
-      end
-
       def reaffirmed?
         reaffirmed == true
       end
@@ -91,23 +88,14 @@ module Pubid
         result
       end
 
-      # Comparison with all_parts logic
-      # When either identifier has all_parts=true, compare only series and number
       def ==(other)
         return false unless other.is_a?(Identifier)
 
-        if all_parts? || other.all_parts?
-          # Compare only series and number, ignore year, parts, all_parts
-          return series == other.series && number == other.number
-        end
-
-        # Normal full comparison
         series == other.series &&
           number == other.number &&
           (parts || []) == (other.parts || []) &&
           year == other.year &&
           language == other.language &&
-          all_parts? == other.all_parts? &&
           reaffirmed? == other.reaffirmed? &&
           symbol == other.symbol
       end
@@ -186,7 +174,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:jis, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/jis/identifiers/all_parts.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # Every part of one JIS document: "JIS C 0617（規格群）".
+      class AllParts < ::Pubid::Jis::Identifier
+        include ::Pubid::AllParts
+
+        SUFFIX = "（規格群）"
+
+        # The URN of the document plus the "all" slot.
+        def to_urn
+          "#{identity.to_urn}:all"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jis/identifiers.rb

@@ -3,6 +3,7 @@
 module Pubid
   module Jis
     module Identifiers
+      autoload :AllParts, "#{__dir__}/identifiers/all_parts"
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :Explanation, "#{__dir__}/identifiers/explanation"

data/lib/pubid/jis/renderer.rb

@@ -38,7 +38,6 @@ module Pubid
         result = "#{PUBLISHER} #{id.code}"
         result += ":#{id.year_with_reaffirmation}" if id.year
         result += "(#{id.language})" if id.language
-        result += "（規格群）" if id.all_parts?
         result + id.symbol_suffix
       end
 
@@ -52,7 +51,6 @@ module Pubid
         result += id.code.to_s
         result += ":#{id.year_with_reaffirmation}" if id.year
         result += "(#{id.language})" if id.language
-        result += "（規格群）" if id.all_parts?
         result += id.symbol_suffix
         result
       end

data/lib/pubid/jis/urn_generator.rb

@@ -12,7 +12,6 @@ module Pubid
 
         parts << identifier.language.to_s.downcase if identifier.language
 
-        parts << "all" if identifier.all_parts?
 
         if identifier.is_a?(SupplementIdentifier) && identifier.supplement_notation
           parts << identifier.supplement_notation.to_s.downcase

data/lib/pubid/nist/CLAUDE.md

@@ -0,0 +1,56 @@
+# NIST flavor notes
+
+NIST rendering formats and annotated output.
+
+Read this before you change `lib/pubid/nist/` or `spec/pubid/nist/`. The root
+`CLAUDE.md` keeps the cross-flavor contract that every flavor obeys.
+
+- **Six NIST types rendered plain under `to_s(annotated: true)`, and two
+  more carried a latent corruption.** NIST's `to_s` takes a **positional**
+  `format`, which Ruby fills with a Hash when a caller passes `annotated:`;
+  `Identifiers::Base#to_s` already handles that and annotates. The six that
+  did not — `CommercialStandardsMonthly`, `CrplReport`, `InteragencyReport`,
+  `MiscellaneousPublication`, `Monograph`, `Report` — either compose their
+  own string or hand `super` a **Symbol**, which drops the flag. Each now
+  pulls `annotated` out of the Hash itself and wraps its result.
+
+  **`Circular` and `Handbook` are the interesting half.** Both did
+  `result = super` — which annotates — and then rewrote the edition with a
+  **`$`-anchored** regex. Once the string ends in `</span>` the anchor
+  cannot match, so the rewrite silently stops applying. Both now strip the
+  flag before `super`, rewrite, then annotate.
+
+  **An output assertion cannot catch that**, and this is the lesson: for
+  both fixture references (`NBS CIRC 11e2-1915`, `NBS HB 44e2-1955`) the
+  annotator matches only the leading publisher, so the tail is bare and the
+  wrong order still produces the right string. The spec asserts the
+  **ordering** instead — it wraps `annotate_plain_render` and checks the
+  string handed to it is already rewritten and carries no span — and that
+  assertion was verified to fail when the order is reverted.
+
+  `CircularSupplement` and `SupplementIdentifier` were also normalised:
+  both had a date-range branch that returned a hand-composed string without
+  ever reaching `super`. `SupplementIdentifier` has four exits, so its
+  composition moved into a private `render_plain`; **`super` is not
+  reachable from a private method**, so `to_s` hands it in as a block —
+  `render_plain(format) { super(format) }`.
+
+- **`all_parts_edition_keys` needed `update`/`update_component`, not
+  `edition_year`.** `Identifier.all_parts_edition_keys` defaults to
+  `%i[date year edition version]`; NIST's primary edition carrier
+  (`edition`, a `Components::Edition`) is already covered, but the Letter
+  Circular / Circular "rJun1992"-style revision (`Builder` around the
+  "Convert revision with month+year to update component" comment) parses
+  into a **separate** attribute, `update`/`update_component`
+  (`Components::Update`: number+year+month), which the default list
+  missed entirely — `"NBS LC 800 rJun1992"` and `"NBS LC 800 rJul1995"`
+  failed to collapse under `#to_all_parts`/`#===`. Fixed with
+  `Pubid::Nist::Identifier.all_parts_edition_keys` (`super + %i[update
+  update_component]`). **`edition_year` and `revision_year`/
+  `revision_month` were investigated and are NOT added**: `Builder` only
+  ever sets `edition_year` alongside the real `edition` component (never
+  as its sole carrier, e.g. the TechnicalNote "date IS edition" branch),
+  and `revision_year`/`revision_month` are transient — converted into
+  `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`.

data/lib/pubid/nist/builder.rb

@@ -87,6 +87,7 @@ module Pubid
         # Note: :base_portion is lost during parser merge, so check for supplement indicators
         if parsed_hash[:supplement_date_range] || parsed_hash[:supplement_slash_year] ||
             parsed_hash[:supplement_month_year] || parsed_hash[:supplement_year] ||
+            parsed_hash[:supplement_empty] ||
             parsed_hash[:supplement] || parsed_hash[:base_portion]
           return build_circular_supplement(parsed_hash)
         end
@@ -479,3 +480,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Nist::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/nist/components/edition.rb

@@ -28,6 +28,8 @@ module Pubid
       #   Edition.new(type: "r", id: "5").to_s                              # => "r5"
       #   Edition.new(type: "r", id: "5", original_prefix: " Rev. ").to_s    # => "Rev. 5"
       class Edition < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :type, :string            # "-", "e", or "r"
         attribute :id, :string              # Edition ID (number or year)
         attribute :additional_text, :string # Text after "rev" (WITHOUT "rev" prefix)

data/lib/pubid/nist/components/issue_number.rb

@@ -8,6 +8,8 @@ module Pubid
       # IssueNumber component for NIST identifiers
       # Represents the issue/number designation (e.g., "No. 12" in "Vol. 6, No. 12")
       class IssueNumber < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :number, :string
 
         # Short form rendering: "n12"

data/lib/pubid/nist/components/part.rb

@@ -23,6 +23,8 @@ module Pubid
       #   - SP: Part number (pt1)
       #   - Letter suffixes (A, B, C, etc.)
       class Part < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :type, :string   # "pt" for part notation, "n" for issue, "" for letter suffix
         attribute :value, :string  # Part number or letter (1, 2, A, B, etc.)
 

data/lib/pubid/nist/components/stage.rb

@@ -13,6 +13,8 @@ module Pubid
       #   Stage.new(id: "i", type: "pd").to_s(:short) # => "ipd"
       #   Stage.new(id: "f", type: "pd").to_s(:long)  # => "(Final Public Draft)"
       class Stage < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :id, :string          # i, f, 1-9
         attribute :type, :string        # pd, wd, prd
 

data/lib/pubid/nist/components/supplement.rb

@@ -15,6 +15,8 @@ module Pubid
       #   Supplement.new(month: "Jan", year: "1924").to_s(:short) # => "supJan1924"
       #   Supplement.new(has_revision: true).to_s(:short)        # => "suprev"
       class Supplement < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :number, :string           # Supplement number (e.g., "2" in "supp2")
         attribute :year, :string             # Year (4 digits); range START year
         attribute :month, :string            # Month abbreviation; range START month

data/lib/pubid/nist/components/translation.rb

@@ -13,6 +13,8 @@ module Pubid
       #   Translation.new(code: "por").to_s(:mr)    # => ".por"
       #   Translation.new(code: "ind").to_s(:short) # => " ind"
       class Translation < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :code, :string # 3-letter ISO 639-2 code: spa, por, ind, etc.
 
         # Backward compatibility: language method returns code

data/lib/pubid/nist/components/update.rb

@@ -15,6 +15,8 @@ module Pubid
       #   Update.new(number: 1, year: 2021, month: 2).to_s(:mr)    # => "-upd1-202102"
       #   Update.new(number: 1, prefix: "dash").to_s(:short)       # => "-upd1" (preserves original prefix)
       class Update < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :number, :string   # Update number as string
         attribute :year, :string     # Year (4 digits as string)
         attribute :month, :string    # Month (01-12 as string, optional)

data/lib/pubid/nist/components/version.rb

@@ -12,6 +12,8 @@ module Pubid
       #   Version.new(value: "1.0.2").to_s(:short) # => "ver1.0.2"
       #   Version.new(value: "2.0").to_s(:long)    # => "Version 2.0"
       class Version < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :value, :string # Dotted notation: "1.0.2"
 
         # Render version in specified format

data/lib/pubid/nist/components/volume.rb

@@ -16,6 +16,8 @@ module Pubid
       #   - CSM (Commercial Standards Monthly): Volume 6, Issue 1
       #   - CIRC (Circular): Volume 539
       class Volume < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :value, :string
 
         def to_s

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

@@ -223,6 +223,30 @@ module Pubid
 
       alias eql? ==
 
+      # A subset match skips the same attributes: `to_hash` drops the build
+      # artifacts, so an index row rebuilt by `from_hash` never has them.
+      def self.subset_ignored_attributes
+        EQUALITY_IGNORED_ATTRS
+      end
+
+      # `edition` is the primary edition/revision carrier and is already in
+      # the default %i[date year edition version] list. `update`/
+      # `update_component` (Components::Update: number+year+month) is a
+      # SEPARATE, currently-live discriminator the default list misses — the
+      # Letter Circular / Circular "rJun1992"-style revision parses into it,
+      # not into `edition` (see Builder#build_dated_identifier), so e.g.
+      # "NBS LC 800 rJun1992" and "NBS LC 800 rJul1995" failed to collapse
+      # under #to_all_parts/#=== before this override. (`edition_year` and
+      # `revision_year`/`revision_month` are NOT added here: the builder
+      # always sets `edition_year` alongside the real `edition` component
+      # (never alone), and `revision_year`/`revision_month` are transient —
+      # converted into `update`/`update_component` and cleared to nil before
+      # the object is returned — so neither carries live information outside
+      # what `edition`/`update` already do.)
+      def self.all_parts_edition_keys
+        super + %i[update update_component]
+      end
+
       def hash
         vals = self.class.attributes.each_key.reject do |name|
           EQUALITY_IGNORED_ATTRS.include?(name)
@@ -413,8 +437,6 @@ module Pubid
         match ? match[1].to_i : nil
       end
 
-      public
-
       def to_full_style
         # "National Institute of Standards and Technology Special Publication 800-27, Revision A"
         result = publisher_full_name
@@ -674,14 +696,25 @@ module Pubid
           result += "#{vol_str}n#{issue_number.number}"
         end
 
-        # Use edition component - NO space before edition in MR format (per NIST spec)
-        result += edition.to_s if edition
+        # With a number, the edition glues to it per the NIST spec
+        # ("800-53r5"); series-only editions take a dot separator
+        # ("NBS.CIRC.e2" — the attested raw spelling; testsuite#5 C4/C5).
+        result += if edition
+                    number ? edition.to_s : ".#{edition}"
+                  else
+                    ""
+                  end
 
         # Use version_component
         result += version_component.to_s(:mr) if version_component
 
-        # Supplement (e.g. ".9981sup7") - keep distinct documents distinct
-        result += supplement_short
+        # Supplement (e.g. ".9981sup7") - keep distinct documents distinct;
+        # a series-only supplement ("NBS.CIRC.sup") takes the dot itself.
+        result += if supplement
+                    number ? supplement_short : ".#{supplement_short}"
+                  else
+                    ""
+                  end
 
         # Use update_component
         result += update_component.to_s(:mr) if update_component
@@ -746,6 +779,5 @@ module Pubid
         "NIST"
       end
     end
-
   end
 end

data/lib/pubid/nist/parser.rb

@@ -13,8 +13,20 @@ module Pubid
       # feeds the cleaned string to the Parslet grammar and stamps the
       # detected format onto the parse tree.
       def self.class_parse_with_preprocessing(input)
+        # The shared Grammar strips a trailing "(all parts)", but the NIST
+        # preprocessor runs first and would swallow it — strip before it and
+        # carry the marker to the tree like Grammar#parse does.
+        all_parts = input.is_a?(String) && input.match?(::Pubid::Parser::Grammar::ALL_PARTS_SUFFIX)
+        input = input.sub(::Pubid::Parser::Grammar::ALL_PARTS_SUFFIX, "") if all_parts
         result = Preprocessor.new(input).call
         parsed = new.parse(result.cleaned)
+        if all_parts
+          parsed = case parsed
+                   when Hash then parsed.merge(all_parts: true)
+                   when Array then parsed.map { |h| h.merge(all_parts: true) }
+                   else parsed
+                   end
+        end
 
         if parsed.is_a?(Hash)
           parsed.merge(parsed_format: result.format)
@@ -651,8 +663,9 @@ module Pubid
       rule(:mr_identifier) do
         hash_prefix.maybe >>
           publisher >> dot >>
-          simple_series >> dot >>
-          report_number >>
+          # The catalogue also lists bare series identities with no
+          # report number ("NBS.CIRC").
+          simple_series >> dot.maybe >> report_number.maybe >>
           # Edition with underscore separator (MR format: 1648_2009)
           (str("_") >> digits.as(:edition_year)).maybe >>
           # Support letter suffix before update (e.g., 8286C-upd1) - Session 219
@@ -713,6 +726,15 @@ module Pubid
             # 4-digit years so it can't swallow "sup3/1926" or a base number.
             ((str("supp") | str("sup")) >> match("[0-9]").repeat(4, 4).as(:supp_year_start) >>
              dash >> match("[0-9]").repeat(4, 4).as(:supp_year_end)).as(:supplement_date_range) |
+            # Bare supplement marker to the whole series, no base number
+            # ("NBS.CIRC.sup" — testsuite#5 C4): the marker alone is the
+            # supplement.
+            ((str("supp") | str("sup")) >>
+              (
+                (month_abbrev >> digits).as(:supplement_month_year) |
+                (digits.as(:supp_number) >> slash >> digits.as(:supp_year)).as(:supplement_slash_year) |
+                str("").as(:supplement_empty)
+              ).maybe) |
             # With base identifier + supplement
             (
               # Capture base portion (everything before "supp" or "sup" or slash+year)

data/lib/pubid/nist/preprocessor.rb

@@ -37,6 +37,11 @@ module Pubid
       def initialize(input)
         @input = input.to_s.strip
         @cleaned = Core::UpdateCodes.apply(@input, :nist)
+        # The format describes the string the parser will see: capture
+        # it right after the update-codes remap, before the stages'
+        # cosmetic spacing (a dotted catalogue alias that remaps to the
+        # space form renders short; the dotted originals stay :mr).
+        @format = @cleaned.include?(".") && !@cleaned.match?(/\s/) ? :mr : :short
       end
 
       # Run every normalization stage and return a Result.
@@ -53,6 +58,14 @@ module Pubid
       # Extracted so rubocop can scope length/ABC metrics narrowly.
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       def run_stages
+        # Short-form "supprev" is the catalogue spelling of the plain
+        # supplement ("NBS CIRC 154supprev" ≡ "NBS CIRC 154sup"; the
+        # revision-bearing identity is the mr spelling "154suprev").
+        # Rewrite before the supplement/revision stages; the mr form is
+        # untouched.
+        if detected_format == :short
+          @cleaned = @cleaned.gsub("supprev", "sup")
+        end
         normalize_spurious_u_suffix!
         normalize_publisher_and_series!
         normalize_lcirc_supplement_contexts!
@@ -75,12 +88,14 @@ module Pubid
         normalize_part_notation!
         normalize_series_specific_spacing!
         normalize_verbose_keywords!
+        normalize_legacy_corpus_spellings!
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-      # Detect input format: :mr (dot-separated machine-readable) or :short.
+      # Detect input format: :mr (dot-separated machine-readable) or
+      # :short. Frozen in #initialize (post update-codes, pre-stages).
       def detected_format
-        @input.include?(".") && !@input.match?(/\s/) ? :mr : :short
+        @format
       end
 
       private
@@ -167,12 +182,21 @@ module Pubid
       # Trailing "-a" → "-A" at end of identifier.
       def uppercase_dash_letter!
         @cleaned = @cleaned.gsub(/(\d)-([a-z])$/) { "#{$1}-#{$2.upcase}" }
+        # Same letter when a part tail follows ("-add", " Add."), so the
+        # canonical case survives; lowercase update/translation codes
+        # ("-upd", ".uppl") never match (next char is a letter).
+        @cleaned = @cleaned.gsub(/(\d)-([a-z])(?=[-.\s])/) { "#{$1}-#{$2.upcase}" }
       end
 
       # Trailing "a" → "A" when attached directly to a digit (excludes
       # "r" to preserve revision+year patterns like "73-197r").
       def uppercase_trailing_letter!
         @cleaned = @cleaned.gsub(/(\d)([a-z&&[^r]])$/) { "#{$1}#{$2.upcase}" }
+        # Same letter when an addendum tail follows ("-add", " Add."),
+        # so the canonical part case survives ("800-38a-add" ->
+        # "800-38A"); part digits ("800-85a-1") and update/translation
+        # codes ("-upd", ".uppl") never match.
+        @cleaned = @cleaned.gsub(/(\d)([a-z&&[^r]])(?=\s*[-.\s]\s*[aA]dd)/) { "#{$1}#{$2.upcase}" }
       end
 
       # Letter suffix on revision: "22r1a" → "22r1A".
@@ -336,6 +360,33 @@ module Pubid
         end
       end
 
+      # Legacy corpus spellings: catalogue forms the mr grammar and the
+      # renderers cannot round-trip on their own. Each rule mirrors an
+      # already-parseable spelling of the same document.
+      def normalize_legacy_corpus_spellings!
+        # The mr renderer prints the translation code with its own
+        # leading dot ("955-S..uppl"); the parser wants one dot.
+        @cleaned = @cleaned.gsub("..", ".")
+        # Trailing-dot addendum spelling; the canonical render comes from
+        # the lowercase ".add" parse ("NBS.TN.467pt1.Add." -> ".add").
+        @cleaned = @cleaned.gsub(/\.Add\.\z/, ".add")
+        # Edition glued to the series in mr form ("NBS.CIRCe2" is
+        # "NBS.CIRC.e2"; digits before "e" are untouched: "24e7", and
+        # the short form never glues an edition to a letter part:
+        # "150-1Ae2009").
+        if detected_format == :mr
+          @cleaned = @cleaned.gsub(/([A-Z])e(\d)/, '\1.e\2')
+        end
+        # Update markers without a number render a phantom "1";
+        # "…-upd" is the numberless spelling of "…-upd1".
+        @cleaned = @cleaned.gsub(/-upd\z/, "-upd1")
+        # Handbook legacy renumbering in the all-dash spelling: the
+        # e-form stage already eats the prefix generically ("HB
+        # 150-1e2017" -> "HB 1-2017"); the all-dash form carries the
+        # same 105-/150- prefixes.
+        @cleaned = @cleaned.gsub(/\b(NIST HB\s+)(?:105|150)-(\d+)-(\d{4})(?=\s|\z)/, '\1\2-\3')
+      end
+
       # Series-specific reverts: HB handbooks, OWMWP dates, and RPT year
       # ranges use dash-year structurally (not as an edition marker), so
       # the broad convert_dashyear_to_edition! rule would corrupt them.

data/lib/pubid/nist/urn_parser.rb

@@ -42,13 +42,22 @@ module Pubid
         type_token, payload = parts
         code, revision = parse_payload(payload)
 
-        text = "NIST #{type_label(type_token)} #{code}"
+        text = "#{publisher_for(type_token)} #{type_label(type_token)} #{code}"
         text += revision if revision
         flavor_parse(text)
       end
 
       private
 
+      # The NBS-era series carry the NBS imprint in their canonical form
+      # ("NBS CSM 1") — the rebuild must name the publisher the document
+      # carries, or the flavor parse rejects its own URN's rebuild.
+      NBS_SERIES = ["csm"].freeze
+
+      def publisher_for(type_token)
+        NBS_SERIES.include?(type_token.downcase) ? "NBS" : "NIST"
+      end
+
       def parse_payload(payload)
         # Strip the trailing ".supp" supplement marker.
         stripped = payload.sub(/\.supp\z/, "")

data/lib/pubid/oasis/CLAUDE.md

@@ -0,0 +1,19 @@
+# OASIS flavor notes
+
+OASIS verbatim slugs, the index key, the MR slug and partial-reference matching.
+
+Read them before you change `lib/pubid/oasis/` or `spec/pubid/oasis/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **The identity is the verbatim slug; the decomposition is a lossy projection of it**: an OASIS identifier is a free-form slug with no fixed internal order (`OSLC-CoreShapes-3.0-PS01-Pt8`, `OSLC-AM-3.0-Part1-PS01`, `amqp-core`), three part spellings and mixed case. The grammar therefore captures the whole slug with `any.repeat(1)` and only strips the `OASIS ` prefix; `Builder#decompose` then classifies each *whole* dash-separated fragment into `number` / `version` / `stage` / `part` / `label`. **`original` holds the printed slug verbatim and alone drives `to_s` and `to_urn`** — `Renderer#render` is a pure echo of it — so the printed form round-trips byte-exactly whatever the classifier makes of it. The decomposition is **not** an identity and cannot be one: it loses fragment order (`x-1.0-os-Pt1` and `x-1.0-Pt1-os` decompose alike) and keeps only the first fragment of each recognized kind, so a repeated one is dropped. That is not hypothetical — **7 of the 605 published `relaton-data-oasis` ids already lose a fragment** (`OASIS xacml-3.0-hierarchical-v1.0-CS02` keeps `3.0` and drops `v1.0`). Every design decision below follows from that asymmetry.
+
+- **`spec` → `number`, the index key (PR #359)**: `Relaton::Index::Type#candidates_by_number` sorts every row and binary-searches it on `id.root.number.to_s`. OASIS kept the specification name in a bespoke `attribute :spec, :string` and never set the `number` it inherits from `::Pubid::Identifier`, so **all 605 published rows shared the empty key `""`** and the search degraded to a linear scan, silently. The attribute is **renamed**, not shadowed by a derived reader: `attribute :number, :string` plus `map "number", to: :number`, and `Builder#decompose` returns `number:`. **`spec` is dropped with no alias and no reader** — one name for one value, the W3C `code` → `number` precedent. A derived `#spec` was written first and then removed: nothing in `lib/` read it, and `relaton-oasis` has no pubid dependency at all, so it had no consumer to preserve. That is what separates this case from IANA's `#registry`, IETF's `#series` and BIPM's `#volume`, which do have one. `root_number_spec.rb` asserts the identifier does **not** respond to `spec`, so the name cannot creep back. The key **clusters**: every version, stage and part of one specification shares it — 309 buckets over 605 ids, median 1, max 25 (`STIX`) — the shape of an IETF draft slug or an IANA registry slug, not an exact key.
+
+- **Why the `number` declaration sits on the base here**: `attribute :number, :string` redefines the parent's `Components::Code number` on a class `Identifiers::Standard` inherits from, which is the recorded determinism landmine. It is safe for the same reason W3C's is: lutaml deep-dups the parent attribute table into each subclass at class-definition time, so a subclass holds a snapshot, and Ruby resolves the superclass constant to completion before opening a leaf body. **`Pubid::Oasis::Identifier`'s class body lives in one file and is never reopened**, so the snapshot is always complete. `stage` and `part` in that same body have relied on this since the flavor landed, overriding `Components::Stage` and `Components::Code`. **Split this class across two files and the landmine comes back** — IEEE is the counter-shape, its base reachable through two paths. `spec/pubid/oasis/root_number_spec.rb` carries the structural tripwire (the base *and* the leaf must resolve `number` to `Lutaml::Model::Type::String`) and is only meaningful under the full `bundle exec rake`.
+
+- **MR slug**: OASIS supplied no `mr_*` hook, and every base hook looks for something the flavor does not use — the publisher is the `PUBLISHER` constant rather than a lutaml attribute, there is no `Components::Date` and no `typed_stage`. With `number` nil as well, **`to_mr_string` was `""` for all 605 ids**, and `to_slug` is what consumers use as an output **filename**. The base now supplies `mr_publisher` (`"oasis"`) and `mr_number_with_part`, which returns the sanitized **`original`** — not the five decomposed fields, because those assemble `x-1.0-os-Pt1` and `x-1.0-Pt1-os` into one slug, while `original` cannot collide. A private `mr_sanitize` filters **by charset**, so a field added later cannot leak an unsafe character. It uses **BIPM's `[^a-z0-9]+` form, not ETSI's `[^a-z0-9-]+`**: a run of non-alphanumerics collapses to one `-`, without which `v3.0]-PS01` prints a bare `--`. Three characters need the filter today — the `.` in every version (`Renderers::MrString` joins *segments* with `.`, so a dot inside one breaks the documented structure), plus the space and `]` of a few malformed records. Result: **605 distinct slugs for the 605 published ids, 0 raises, 0 characters outside `[a-z0-9._-]`**. One caveat, the same one BIPM records: `-` is both the intra-slug join and the substitute, so two slugs differing only in which non-slug character they use collapse. The corpus has exactly one such pair — the malformed `OpenC2-MQTT-v1.0] -CS01` spelled once with a normal space and once with a non-breaking one, two spellings of one document.
+
+- **`#exclude` clears `original`, so a partial reference can widen**: `#matches?` is `exclude(*ignore) == other.exclude(*ignore)`, and `original` spells out verbatim the very component the caller is ignoring. So it survived the exclusion and a bare `OASIS WSDM` could **never** match `OASIS WSDM-v1.1`, however much was ignored — relaton would narrow to the right index bucket and then match nothing in it. `Pubid::Oasis::Identifier#exclude` now nils `original` when the excluded set intersects `DECOMPOSITION_KEYS` (`number version stage part label`), the "reset the whole cluster" rule CSA applies to its year-format siblings. **A plain `==` still compares `original`, deliberately**: an excluded copy is a comparison token, never a rendered document, so widening happens only when the caller asks for it. Dropping `original` from `==` outright was considered and rejected — it costs nothing on today's corpus (no two ids collide) but it exposes those 7 lossy ids to a silent collision with a future sibling, and it would let two different printed identifiers be equal. `spec/pubid/oasis/partial_ref_spec.rb` locks both halves.
+
+- **relaton note**: nothing published needs migrating. `relaton-oasis` has no pubid dependency and its `index-v1.yaml` is string-keyed (`:id: OASIS amqp-core`), which is why the serialized shape was changed properly rather than patched. There is **no alias** for the old `spec` key, and a pre-`number` row would deserialize with a nil `number` and no error (lutaml ignores unknown keys), so a future pubid index must be crawled *after* this. Rendering is the loud failure if it is not.
+
+- **Verification and the fixture net**: the change was verified by replaying a `main` baseline over all 605 published ids plus the fixture lines — `to_s`, `to_urn`, identifier class and parse errors **byte-identical**, `to_hash` differing **only** by the key rename, empty index keys 607 → 0, distinct MR slugs 1 → 606 of 607, and `from_hash(to_hash) == id` for all 605 with **0** pairs of distinct ids equal. `spec/pubid/oasis/fixtures_spec.rb` is live — its glob is correct, so OASIS is not on the `ten-dead-fixture-specs` list — and `root_number_spec.rb` adds a corpus sweep over the same file. **Do not run `rake "validation:classify[oasis]"`**: there is no `spec/fixtures/oasis/identifiers/full/`, so the generator would delete `pass/oasis.txt` and rebuild nothing. (hand-off: oasis-index-number.)

data/lib/pubid/oasis/builder.rb

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

data/lib/pubid/oasis/identifier.rb

@@ -36,6 +36,18 @@ module Pubid
       # building the table before `Identifiers::Standard` snapshots it — DO NOT
       # split this class across two files.
       attribute :number, :string
+
+      # `original` alone drives #to_s, and the shared exclude-copy loses it
+      # (the redefined attribute does not survive the rebuild). An all-parts
+      # copy is therefore dup-based: nil the part and edition-ish attributes
+      # in place, keeping the printed slug verbatim.
+      def without_parts(*extra)
+        copy = dup
+        (::Pubid::Identifier::PART_ATTRIBUTES + extra).each do |name|
+          copy.public_send(:"#{name}=", nil) if copy.respond_to?(:"#{name}=")
+        end
+        copy
+      end
       attribute :version, :string
       attribute :stage, :string
       attribute :part, :string
@@ -91,6 +103,13 @@ module Pubid
         result
       end
 
+      # The same reason applies to a subset match: `original` spells out the
+      # parts a partial reference omits, so `===` compares the decomposition
+      # only. Two slugs that decompose alike therefore match each other.
+      def self.subset_ignored_attributes
+        %i[original]
+      end
+
       # MR string hooks. `to_slug` delegates to `to_mr_string` and consumers
       # use it as an output FILENAME, so the slug must be unique per document.
       #
@@ -127,7 +146,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:oasis, identifier)
         Builder.build(parsed)
       end