pubid 2.0.21 → 2.0.22

data/lib/pubid/iso/builder.rb

@@ -151,6 +151,16 @@ module Pubid
         # reason). The document itself holds no all-parts mark.
         all_parts = parsed_hash.delete(:all_parts)
 
+        # Historic TYPE-first ballot face ("ISO/IEC FDAM 1 14496-12:2004",
+        # "ISO/PDAM 19973-2", "ISO 15877-5:2009 FDAM 1"): the ballot_* keys
+        # are one amendment layer over the whole base, never a second
+        # supplement layer (the stored twins keep one level), so the layer
+        # is assembled here, before the supplement-prefix peel could read
+        # the ballot token as an outer wrapper.
+        if parsed_hash.key?(:ballot_type_with_stage)
+          return build_ballot_supplement(parsed_hash, all_parts)
+        end
+
         # The copublisher tail captures as one scalar span ("/IEC/IEEE");
         # split it into the {copublisher:} element hashes the merge and
         # the :copublishers cast consume. A pre-built array (the URN
@@ -261,6 +271,10 @@ module Pubid
           identifier.type = default_typed_stage.to_type
         end
 
+        # The owner's no-number rule: a numberless DAM-family ballot-stage
+        # amendment is Amendment 1 (see the method comment).
+        apply_implied_amendment_number(identifier)
+
         all_parts ? identifier.to_all_parts : identifier
       end
 
@@ -306,6 +320,69 @@ module Pubid
         build(inner)
       end
 
+      # Historic TYPE-first ballot face (owner ruling 2026-11-12, Option B
+      # decode-to-modern): "[P|F]?DAM [N] BASE [stamp]" decodes to ONE
+      # amendment over the WHOLE base, rendered as the canonical on-base
+      # slash face. The stage comes from the ballot token; the number from
+      # the TYPE token, then the on-base stamp, then the owner's no-number
+      # rule (a ballot face with no number anywhere names Amendment 1 —
+      # identity-bearing, so it is set here at build time and serialized,
+      # not at render time); the stamp's date is the ballot supplement's
+      # date. The base keeps every component it carried: a legacy
+      # slash-part stays a part of the base number ("ISO/IEC FPDAM 9075/1"
+      # → base "9075-1"), and the base's own type token stays the base's
+      # ("ISO/IEC PDAM TR 9573-11" → base "TR 9573-11") — nothing migrates
+      # into the supplement slot. The stamp's token letters (Amd/Am/…) are
+      # decode-away: the ballot's stage is the TYPE token's.
+      #
+      # The rest of the hash — prefix, copublishers, the base's
+      # type_with_stage / number_with_part / date — is exactly the builder
+      # input of the base document, so it nests as :base and re-enters
+      # build.
+      def build_ballot_supplement(hash, all_parts)
+        fields = { type_with_stage: hash.fetch(:ballot_type_with_stage) }
+
+        number = hash[:ballot_number] ||
+                 hash[:ballot_stamp_number] ||
+                 hash[:ballot_stamp_dot_number] ||
+                 "1"
+        fields[:number_with_part] = number
+
+        if (stamp_date = hash[:ballot_stamp_date])
+          fields[:date] = stamp_date
+        end
+        if hash[:ballot_stamp_undated_marker]
+          fields[:undated_marker] = hash[:ballot_stamp_undated_marker]
+        end
+
+        rest = hash.except(:ballot_type_with_stage, :ballot_number,
+                           :ballot_stamp_number, :ballot_stamp_dot_number,
+                           :ballot_stamp_date, :ballot_stamp_undated_marker)
+
+        inner = { **fields, base: rest }
+        inner[:all_parts] = all_parts if all_parts
+        build(inner)
+      end
+
+      # The owner's no-number rule, applied on every construction path that
+      # routes through this builder (parse, URN, joint/bundle members): a
+      # DAM-family ballot-stage amendment token with no number anywhere
+      # names Amendment 1 ("ISO 19973-2/PDAM", "ISO/IEC PDAM 12207"). The
+      # number is identity-bearing, so the default lands at build time and
+      # to_hash serializes it — parse and from_hash(to_hash) agree because
+      # both carry the filled number. The ballot stages are matched by
+      # TypedStage#code (the per-typed-stage key) — PDAM's #stage_code is
+      # :cd, the harmonized range it lives in.
+      BALLOT_STAGE_CODES = %i[pdam damd fdamd fpdam].freeze
+
+      def apply_implied_amendment_number(identifier)
+        return unless identifier.is_a?(Identifiers::Amendment)
+        return unless identifier.number.nil?
+        return unless BALLOT_STAGE_CODES.include?(identifier.typed_stage&.code&.to_sym)
+
+        identifier.number = "1"
+      end
+
       def build_directive_supplement(hash, all_parts)
         fields = rekey_prefix(hash.slice(*DSUPP_KEYS), "dsupp_")
         rest = hash.except(*DSUPP_KEYS)

data/lib/pubid/iso/identifiers/amendment.rb

@@ -112,7 +112,7 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :published,
-            abbr: ["Amd", "AMD", "Amd."],
+            abbr: ["Amd", "AMD", "Amd.", "Am"],
             short_abbr: "AMD",
             long_abbr: "Amd",
             type_code: :amd,

data/lib/pubid/iso/single_identifier.rb

@@ -36,7 +36,13 @@ module Pubid
         return false unless typed_stage
 
         ts = typed_stage
-        if ts.long_abbr && ts.original_abbr&.start_with?(ts.long_abbr)
+        original = ts.original_abbr
+        if ts.long_abbr && original && (original.start_with?(ts.long_abbr) ||
+                                        ts.long_abbr.start_with?(original))
+          # The long family: the canonical long spelling, its punctuated
+          # forms ("Amd." of "Amd"), and shorter long-family spellings
+          # ("Am" — the alias of "Amd" the owner ruled renders canonical).
+          # The short family ("AMD") matches neither direction.
           true
         elsif ts.long_abbr && ts.original_abbr&.include?("Directives")
           true

data/lib/pubid/nist/CLAUDE.md

@@ -136,13 +136,51 @@ Read this before you change `lib/pubid/nist/` or `spec/pubid/nist/`. The root
   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.
 
-- **"FIPS PUB <number>" is a preprocessor alias, not a grammar face
-  (pubid#697).** NIST prints the series as "FIPS PUB <number>" but the
-  grammar reads "NIST FIPS <number>", so `normalize_fips_pub_alias!`
-  (head-anchored, immediately after the publisher/series stage) rewrites
-  the printed prefix and the parse lands on exactly the canonical model —
-  hash-, render-, URN- and MR-identical to "NIST FIPS <number>". The
-  hyphenated numbers and the revision forms the grammar models
-  ("FIPS PUB 199 Rev. 1" with its `original_prefix` facet, compact
-  "rev1") ride the prefix alias; bare "FIPS <number>"
-  (publisher_was_parsed: false) and NBS FIPS are untouched.
+- **"FIPS PUB <number>" is the official RENDER face; the preprocessor
+  alias exists so the spellings parse (pubid#697; owner ruling
+  2026-11-12).** FIPS is government-published and "PUB" (Federal
+  Information Processing Standards PUBlication) is part of the official
+  designation, so
+  `FederalInformationProcessingStandards#fips_render_lead` renders the
+  spelled-NIST-publisher rows as "FIPS PUB <number>" with the tails
+  riding the lead; the lead reads `printed_publisher`, so the
+  series-default NIST a bare parse fills (#704) is not a printed
+  publisher and the bare face stays bare. The grammar reads "NIST FIPS
+  <number>", so `normalize_fips_pub_alias!` (head-anchored, immediately
+  after the publisher/series stage) folds every printed spelling —
+  "FIPS PUB 205" and the publisher-prefixed "NIST FIPS PUB 205"
+  (pubid#702) — onto that canonical model, and all the spellings
+  converge on one identity: hash-, URN- and MR-identical, and one
+  render. The hyphenated numbers and the revision forms the grammar
+  models ("FIPS PUB 199 Rev. 1" with its `original_prefix` facet,
+  compact "rev1") ride the prefix alias; bare "FIPS <number>"
+  (publisher_was_parsed: false), the historical NBS-prefixed rows, and
+  the MR face ("NIST.FIPS.197", an identity surface) are untouched.
+
+- **A bare "FIPS <number>" carries the series' NIST publisher (hand-off
+  nist-bare-fips-publisher, metanorma-pdfa#114).** relaton keeps a CSRC hit
+  only when the parsed citation is `==` to the row, and every row is
+  "NIST FIPS …", so a bare "FIPS 197" (publisher nil) answered "Not found".
+  The Builder now fills `identifier.class.series_default_publisher`
+  ("NIST" on `FederalInformationProcessingStandards`, nil on the base)
+  **after** it records `publisher_was_parsed: false`. The flag is
+  `equality_ignored`, so the two spellings are `==`; the short and MR faces
+  print the publisher only when it was spelled (`printed_publisher`), so the
+  bare face still renders `FIPS 197` / `FIPS.197`. The long and abbreviated
+  styles now name NIST (before, they began with a stray space). "NBS FIPS"
+  keeps its parsed NBS and is not `==` to the bare form. **NBS-era ruling**:
+  `#matches?` treats a publisher the query did not spell as a wildcard (and
+  no longer compares `publisher_was_parsed`, a spelling), so the query
+  "FIPS 46" still finds "NBS FIPS 46" — before this, a bare query matched
+  neither the NIST nor the NBS row. `===` needs the same rule
+  (`subset_skipped_attributes`), because the filled publisher is no longer
+  the nil the subset match read as "anything"; **the two primitives must
+  agree, so change them together.** `to_hash` of a bare parse gains
+  `publisher: NIST`; the 21,365-id `full/` corpus has no bare FIPS row, so
+  no fixture output moved. `from_hash` fills the default by the same rule
+  (`apply_series_default_publisher`, shared with the Builder), so a row
+  stored before this change (`publisher_was_parsed: false`, no publisher)
+  is still `==` to the parse. Not covered: `new(series:, number:)` fills
+  nothing (its flag defaults to true, so it means a spelled form anyway).
+  Locked by
+  `spec/pubid/nist/bare_fips_publisher_spec.rb`.

data/lib/pubid/nist/builder.rb

@@ -422,6 +422,11 @@ module Pubid
         # to_hash) when one was. Keeps the common publisher-bearing id lean.
         identifier.publisher_was_parsed = false unless identifier.publisher
 
+        # A series that implies its publisher (bare "FIPS 197" is
+        # "NIST FIPS 197") gets it now, after the flag above, so the two
+        # spellings are == while the bare face keeps rendering bare.
+        identifier.apply_series_default_publisher
+
         # NEW: Convert revision with month+year to update component (V1 compatibility)
         # Patterns like "NIST IR 4743rJun1992" should be rendered as "NIST IR 4743/Upd1-199206"
         if parsed_hash[:revision_month] && parsed_hash[:revision_year]

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

@@ -39,6 +39,10 @@ module Pubid
         id = super(normalize_deserialized_shapes(expand_compact_hash(data)),
                    options)
         derive_subseries(id)
+        # A bare-FIPS row written before the series default existed holds
+        # `publisher_was_parsed: false` and no publisher; parse now fills
+        # it, so from_hash must too, or the row is no longer == the parse.
+        id.apply_series_default_publisher if id.is_a?(Identifier)
         id
       end
 
@@ -291,6 +295,29 @@ module Pubid
         super + %i[update update_component]
       end
 
+      # The publisher a series implies when the input spells none. The
+      # Builder fills it after it records `publisher_was_parsed: false`, so
+      # the bare face still renders without the prefix. nil: no default.
+      def self.series_default_publisher
+        nil
+      end
+
+      # Fill the series default publisher on an id whose input spelled
+      # none. Shared by the Builder and from_hash, so both construction
+      # paths agree.
+      def apply_series_default_publisher
+        return if publisher || publisher_was_parsed
+
+        self.publisher = self.class.series_default_publisher
+      end
+
+      # `===` (subset match) follows #matches?: a publisher the reference
+      # did not spell is a wildcard, so bare "FIPS 46" finds "NBS FIPS 46".
+      def subset_skipped_attributes
+        skipped = super
+        publisher_was_parsed ? skipped : skipped | [:publisher]
+      end
+
       # Wildcard / partial-identifier match. Treats +self+ as a QUERY pattern
       # and +candidate+ as a concrete document: every ID part SET on the query
       # must equal the candidate's, while parts left unset (nil/empty) are
@@ -301,11 +328,16 @@ module Pubid
       # Asymmetric (unlike ==): "NBS CIRC 25".matches?("NBS CIRC 25sup1924")
       # is true, but not the reverse. The candidate must be the same class or
       # a subclass so series-level identity still holds.
+      #
+      # `publisher_was_parsed` records only how the query was spelled, so it
+      # is never a criterion; and a publisher the query did not spell (the
+      # series default a bare "FIPS 46" fills in) is a wildcard, so the bare
+      # query still finds the NBS-era "NBS FIPS 46".
       def matches?(candidate)
         return false unless candidate.is_a?(self.class)
 
         self.class.attributes.each_key.all? do |name|
-          next true if EQUALITY_IGNORED_ATTRS.include?(name)
+          next true unless match_criterion?(name)
 
           query_val = public_send(name)
           next true if query_val.nil?
@@ -316,6 +348,15 @@ module Pubid
         end
       end
 
+      # Whether #matches? compares attribute +name+ at all.
+      def match_criterion?(name)
+        return false if EQUALITY_IGNORED_ATTRS.include?(name)
+        return false if name == :publisher_was_parsed
+
+        name != :publisher || publisher_was_parsed
+      end
+      private :match_criterion?
+
       # NIST inherits Pubid::Identifier#exclude directly: it now rebuilds via
       # `self.class.new(**attrs)`, so NIST's keyword-only initialize
       # (initialize(**attributes)) works without a local override, and the base

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

@@ -6,7 +6,9 @@ module Pubid
       # NIST Federal Information Processing Standards (FIPS)
       # Examples:
       # - "FIPS 140-3" (no NIST prefix)
-      # - "NIST FIPS 140-3" (also accepted, normalizes to FIPS 140-3)
+      # - "NIST FIPS 140-3" / "FIPS PUB 140-3" (also accepted; both parse
+      #   to the same identity, and the NIST-published face renders as
+      #   "FIPS PUB 140-3")
       class FederalInformationProcessingStandards < Identifier
         TYPED_STAGES = [
           Pubid::Components::TypedStage.new(
@@ -21,6 +23,13 @@ module Pubid
             TYPED_STAGES
           end
 
+          # Bare "FIPS 197" names the NIST document (NIST/CSRC list every
+          # FIPS, NBS-era ones included, as "NIST FIPS"). A parsed "NBS"
+          # stays NBS.
+          def series_default_publisher
+            "NIST"
+          end
+
           def type
             { key: :fips,
             web: :federal_information_processing_standards, title: "Federal Information Processing Standards",
@@ -41,8 +50,10 @@ module Pubid
         def to_mr_style
           # "NIST.FIPS.197" keeps a parsed publisher (the DOI suffix NIST
           # publishes); "FIPS.46e1977" has none and invents none.
+          # A bare "FIPS 197" carries the series default publisher NIST but
+          # did not spell it, so it prints no prefix either.
           # Note: edition is appended directly to number without dot for FIPS
-          result = [publisher, series_code].compact.join(".")
+          result = [printed_publisher, series_code].compact.join(".")
           result += ".#{number}" if number
 
           # FIPS uses dash notation for parts; render here and skip the generic
@@ -58,10 +69,30 @@ module Pubid
 
         public
 
+        # The short-face lead: the official printed "FIPS PUB" for a spelled
+        # NIST publisher (owner ruling 2026-11-12), the spelled historical
+        # publisher for NBS rows, and the bare series code when the input
+        # spelled no publisher — the series-default NIST a bare parse fills
+        # (#704) is not a printed publisher, so the bare face stays bare.
+        def fips_render_lead
+          lead_publisher = printed_publisher
+          return "FIPS PUB" if lead_publisher == "NIST"
+
+          spelled = lead_publisher && !lead_publisher.empty?
+          return "#{lead_publisher} #{series_code}" if spelled
+
+          series_code.to_s
+        end
+
         def to_short_style
-          # FIPS format: "FIPS 14e1971" or "NIST FIPS 140-3" (preserve publisher if set)
-          result = publisher ? "#{publisher} " : ""
-          result += series_code
+          # The official published face is "FIPS PUB <number>": FIPS is
+          # government-published, and "PUB" (Federal Information Processing
+          # Standards PUBlication) is part of the official designation
+          # (owner ruling 2026-11-12). The tail (volume/part/edition/
+          # supplement/update/draft) rides the lead unchanged, and the MR
+          # face ("NIST.FIPS.197") is an identity surface that does not
+          # move.
+          result = fips_render_lead
 
           if number
             # Convert dash-year patterns to edition format for FIPS
@@ -90,6 +121,14 @@ module Pubid
 
           result
         end
+
+        private
+
+        # The publisher the short and MR faces print: only one the input
+        # spelled, never the series default.
+        def printed_publisher
+          publisher if publisher_was_parsed
+        end
       end
     end
   end

data/lib/pubid/nist/preprocessor.rb

@@ -125,19 +125,21 @@ module Pubid
         @cleaned = @cleaned.gsub(/\bLC\b(?!IRC)/, "LCIRC")
       end
 
-      # The FIPS series' own printed face: NIST prints the series as
-      # "FIPS PUB <number>" (document cover and catalogue style), so the
-      # grammar accepts the publisher-prefixed canonical form only through
-      # this alias (pubid#697). Rewrites the prefix to "NIST FIPS", the
-      # spelling the grammar already reads, and the printed-form parse
-      # therefore lands on exactly the model "NIST FIPS <number>" builds
-      # (same to_hash, same render, revision spellings like
-      # "FIPS PUB 199 Rev. 1" included). Anchored at the head and run
-      # before every other stage so later digit/marker stages see the
-      # canonical face; "FIPS" alone (publisher_was_parsed: false) is
-      # untouched.
+      # The FIPS series' official printed face: FIPS is government-published
+      # and "PUB" (Federal Information Processing Standards PUBlication) is
+      # part of the official designation, so the RENDERER emits
+      # "FIPS PUB <number>" directly (owner ruling 2026-11-12). The grammar
+      # itself reads the publisher-bearing spelling only through this alias
+      # (pubid#697): it folds the printed spellings — "FIPS PUB 205" and the
+      # publisher-prefixed "NIST FIPS PUB 205" (pubid#702/#703) — onto the
+      # one model "NIST FIPS <number>" the grammar already builds (same
+      # to_hash, same URN, same MR string; revision spellings like
+      # "FIPS PUB 199 Rev. 1" included), while the renderer owns the printed
+      # face the fold converges to. Anchored at the head and run before
+      # every other stage so later digit/marker stages see the canonical
+      # spelling; "FIPS" alone (publisher_was_parsed: false) is untouched.
       def normalize_fips_pub_alias!
-        @cleaned = @cleaned.sub(/\AFIPS PUB\b/i, "NIST FIPS")
+        @cleaned = @cleaned.sub(/\A(?:NIST )?FIPS PUB\b/i, "NIST FIPS")
       end
 
       # LCIRC series: combine with NBS prefix when a supplement marker

data/lib/pubid/nist/urn_parser.rb

@@ -14,7 +14,7 @@ module Pubid
     # Examples:
     # - urn:nist:sp:800-53.supp        → NIST SP 800-53
     # - urn:nist:sp:800-53.r5.supp     → NIST SP 800-53r5
-    # - urn:nist:fips:199.supp         → NIST FIPS 199
+    # - urn:nist:fips:199.supp         → FIPS PUB 199
     class UrnParser < Pubid::UrnParser::Base
       TYPE_UPCASE = {
         "sp" => "SP",

data/lib/pubid/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.21
+  version: 2.0.22
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-11 00:00:00.000000000 Z
+date: 2026-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -68,10 +68,12 @@ files:
 - conformance/pending.yaml
 - data/bipm/update_codes.yaml
 - data/ccsds/update_codes.yaml
+- data/iec/legacy-notation.md
 - data/iec/stage-codes.md
 - data/iec/update_codes.yaml
 - data/ieee/update_codes.yaml
 - data/iho/s4-reserved-specs.yaml
+- data/iso/historic-schemes.md
 - data/iso/update_codes.yaml
 - data/nist/series.yaml
 - data/nist/stages.yaml
@@ -142,6 +144,7 @@ files:
 - data/parg/tables/organizations.yaml
 - data/parg/tables/tc_types.yaml
 - data/parg/tables/typed_stages.yaml
+- data/parg/tables/typed_stages_ballots.yaml
 - data/parg/tables/typed_stages_supplements.yaml
 - data/parg/tables/wg_types.yaml
 - data/parg/tgpp.json