pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/nist/parser.rb

@@ -6,27 +6,433 @@ module Pubid
   module Nist
     # Parser class for NIST identifiers
     # Single Responsibility: Parsing NIST identifier syntax
-    class Parser < ::Pubid::Parser::Grammar
-
-      # Class-level parse method with preprocessing.
-      # Delegates all string normalization to Nist::Preprocessor, then
-      # feeds the cleaned string to the Parslet grammar and stamps the
-      # detected format onto the parse tree.
+    class Parser < Parslet::Parser
+      # Class-level parse method with preprocessing
+      # Handles data quality normalization before parsing
+      # Named explicitly to avoid conflict with Parslet's built-in parse method
       def self.class_parse_with_preprocessing(input)
-        result = Preprocessor.new(input).call
-        parsed = new.parse(result.cleaned)
+        # Apply legacy update_codes normalization first, before any other preprocessing
+        cleaned = Core::UpdateCodes.apply(input.to_s.strip, :nist)
+
+        # Fix lowercase publisher at start
+        cleaned = cleaned.sub(/^nbs\b/i, "NBS")
+        cleaned = cleaned.sub(/^nist\b/i, "NIST")
+
+        # Fix publisher+series concatenation: "NISTIR" → "NIST IR", "NBSIR" → "NBS IR"
+        # Must come after lowercase publisher fix to catch "nistir" → "NISTIR" → "NIST IR"
+        cleaned = cleaned.gsub(
+          /^(NBS|NIST)(IR|FIPS|GCR|HB|MONO|MP|NCSTAR|NSRDS)/i, '\1 \2'
+        )
+
+        # Fix lowercase series (ir, sp, tn, etc.)
+        cleaned = cleaned.sub(/\b(ir|sp|tn|hb|fips|ams|vts)\b/i, &:upcase)
+
+        # Normalize LC to LCIRC (single definition of truth)
+        # Pattern: "LC" followed by space/dot/end should become "LCIRC"
+        # But don't change if already "LCIRC"
+        cleaned = cleaned.gsub(/\bLC\b(?!IRC)/, "LCIRC")
+
+        # Combine "NBS LCIRC" with space into "NBS.LCIRC" ONLY when followed by supplement marker
+        # This allows the circ_supplement_identifier rule to match the pattern
+        # Only apply to supplement cases, not regular LCIRC identifiers
+        cleaned = cleaned.gsub(/\bNBS LCIRC\b(?=.*\b(?:supp?|sup\+|r\d+\/)\d)/,
+                               "NBS.LCIRC")
+
+        # Convert MR format LCIRC supplements to space-separated format
+        # "NBS.LCIRC.145r11/1925" → "NBS LCIRC 145r11/1925" (convert series dot to space)
+        cleaned = cleaned.gsub(/\bNBS\.LCIRC\.(\d+r\d+\/\d{4})/,
+                               "NBS LCIRC \\1")
+        # Also handle without year: "NBS.LCIRC.145r11" → "NBS LCIRC 145r11"
+        cleaned = cleaned.gsub(/\bNBS\.LCIRC\.(\d+r\d+)\b/, "NBS LCIRC \\1")
+
+        # Fix Roman numerals: "1011-I-2" → keep as is, but fix spaces: "1011-I-2 0" → "1011-I-2.0"
+        cleaned = cleaned.gsub(/([-\d]+[IVX]+[-\d]+)\s+(\d+)/, '\1.\2')
+
+        # Fix rev without space: "126rev2013" → "126 rev2013" (separate number from rev+year)
+        # BUT preserve edition+revision patterns: "e2rev1908" stays as-is
+        cleaned = cleaned.gsub(/(?<!e)(\d)(rev\d{4})/, '\1 \2')
+
+        # Fix LCIRC revision with slash and year: "145r6/1925" → "145 r6/1925"
+        # BUT NOT for LCIRC series (keep "NBS LCIRC 145r11/1925" as-is for parser)
+        # The circ_supplement_identifier rule expects "145r11" (no space)
+        unless cleaned.include?("LCIRC") || cleaned.include?("CIRC")
+          cleaned = cleaned.gsub(/(\d)(r\d+\/\d{4})/, '\1 \2')
+        end
+
+        # Fix LCIRC revision with just year (no slash): "1128r1995" → "1128 r1995"
+        # BUT preserve edition+revision patterns: "13e2rev1908" stays as-is
+        # AND preserve month abbreviations in patterns like "107-Mar1985" (ar1985 contains 'r')
+        # Use word boundary to ensure 'r' is standalone, not part of a month name
+        # AND preserve "rv" (revision year) patterns: "1013rv1953" stays as-is
+        cleaned = cleaned.gsub(/\b(r(?!v)\d{4})\b/, ' \1')
+
+        # Fix month in revision: "4743rJun1992" → "4743 rJun1992" (NEW)
+        cleaned = cleaned.gsub(/(\d)(r[A-Z][a-z]{2,8}\d{4})/, '\1 \2')
+        # REMOVED: Revision with 1-2 digits + lowercase letter preprocessing
+        # This is now handled by the more comprehensive fix at lines 131-142
+        # which keeps "22r1a" together (no space) for second_number pattern matching
+
+        # CRITICAL: Normalize lowercase letter suffix to uppercase
+        # Fix dash-letter pattern: "6529-a" → "6529-A" (FIXED - was incorrect)
+        # BUT preserve lowercase for NCSTAR series when letter is followed by volume (e.g., "1-1av1")
+        cleaned = cleaned.gsub(/(\d)-([a-z])$/) { "#{$1}-#{$2.upcase}" }
+
+        # Fix direct letter suffix (no dash): "378g" → "378G", "1000a" → "1000A"
+        # MUST come after dash pattern to avoid conflicts
+        # Fix letter suffix at end: "1011-A" → "1011A", "97-3b" → "97-3B"
+        # CRITICAL: Exclude r+digit pattern (e.g., "73-197r", "6945r") from this conversion
+        # These should remain as lowercase for edition pattern matching
+        # Only match single letter at end, not part of words like "index", "sec", etc.
+        cleaned = cleaned.gsub(/(\d)([a-z&&[^r]])$/) { "#{$1}#{$2.upcase}" }
+        # Also fix r+letter patterns (e.g., "22r1a" → "22r1A") separately
+        cleaned = cleaned.gsub(/(\d)(r)(\d+)([a-z])$/) do
+          "#{$1}#{$2}#{$3}#{$4.upcase}"
+        end
+        # NEW: Fix letter suffix before r (e.g., "53ar1" → "53Ar1")
+        # For patterns like NIST SP 800-53ar1 where letter is between number and revision
+        cleaned = cleaned.gsub(/(\d)([a-z])(r\d)/) { "#{$1}#{$2.upcase}#{$3}" }
+        # NOTE: Removed uppercase letter before r rule - it was breaking 800-56Ar2 parsing
+        # The parser should handle 56Ar2 as a single unit (letter suffix + revision)
+
+        # Fix letter suffix before volume: "1-2bv1" → "1-2Bv1" (MR format)
+        # BUT preserve "rv" (revision year) patterns: "1013rv1953" stays as-is
+        # Skip for NCSTAR to preserve lowercase letters (patterns like "1-1av1" should stay lowercase)
+        is_ncstar = cleaned.include?("NCSTAR")
+        unless is_ncstar
+          cleaned = cleaned.gsub(/(\d)([a-z&&[^r]])(v\d+)/) do
+            "#{$1}#{$2.upcase}#{$3}"
+          end
+        end
+
+        # Fix space before volume number: "80-2073 2" → "80-2073 v2" (Session 219)
+        # This handles NBS IR 80-2073 2 and NBS IR 80-2073 3 as volume identifiers
+        cleaned = cleaned.gsub(/(\d{2}-\d{4})\s+(\d)$/, '\1 v\2')
+
+        # Fix draft with number: "8270-draft2" → "8270 -draft 2" (Session 253)
+        # Space BEFORE dash AND after draft to separate it from report_number
+        cleaned = cleaned.gsub(/(\d)-draft(\d)/, '\1 -draft \2')
+
+        # NEW FIX 2: Draft without dash: "8270draft2" → "8270 -draft 2"
+        # More lenient pattern to catch missing dash before draft
+        cleaned = cleaned.gsub(/(\d)draft(\d)/, '\1 -draft \2')
+
+        # Fix supplement typo: "154suprev" → "154supprev" (Session 219)
+        cleaned = cleaned.gsub(/(\d)suprev/, '\1supprev')
+
+        # Fix letter suffix + revision before draft: "140Cr1-draft2" → "140C r1-draft2" (Session 221)
+        # Must be BEFORE general draft preprocessing at line 47
+        cleaned = cleaned.gsub(/(\d{2,})([A-Z])(r\d+)([-\s]draft\d*)/,
+                               '\1\2 \3\4')
+
+        # Convert Roman numeral volumes to Arabic per NIST spec (page 7)
+        # "1011-I-2.0" → "1011 v1 ver2.0"
+        # "1011-II-1.0" → "1011 v2 ver1.0"
+        cleaned = cleaned.gsub(/(\d+)-([IVX]+)-(\d+(?:\.\d+)*)/) do
+          number = $1
+          roman = $2
+          version_part = $3
+
+          # Convert Roman to Arabic
+          arabic = roman_to_arabic(roman)
+
+          # Convert to volume+version format
+          "#{number} v#{arabic} ver#{version_part}"
+        end
+
+        # Fix LCIRC supplement with slash and year: "118supp3/1926" → "118 supp3/1926"
+        cleaned = cleaned.gsub(/(\d)(supp\d+\/\d{4})/, '\1 \2')
+
+        # Fix Pt pattern: "800-57Pt3r1" → "800-57 pt3 r1"
+        cleaned = cleaned.gsub(/(\d)Pt(\d+)(r\d+)/, '\1 pt\2 \3')
+
+        # Fix version patterns: "ver1e2006" → "ver1 e2006", "ver2v1" → "ver2 v1"
+        cleaned = cleaned.gsub(/(\d)ver(\d)/, '\1 ver \2')
+        cleaned = cleaned.gsub(/ver(\d+)e(\d{4})/, 'ver\1 e\2')
+        cleaned = cleaned.gsub(/ver(\d+)v(\d+)/, 'ver\1 v\2')
+
+        # Fix dotted version: separate from number "268v1.1" → "268 v1.1"
+        cleaned = cleaned.gsub(/(\d)(v\d+\.\d+)/, '\1 \2')
+
+        # CRITICAL: Now separate dotted versions from preceding digits: "268v1.1" → "268 v1.1" (NEW)
+        cleaned = cleaned.gsub(/(\d)(v\d+\.\d+)/, '\1 \2')
+
+        # NEW: Separate version from number AND convert spaces to dots in one step
+        cleaned = cleaned.gsub(/(\d)(v\d+)\s+(\d+)$/, '\1 \2.\3')               # Two-part: "268v1 1" → "268 v1.1"
+        cleaned = cleaned.gsub(/(\d)(v\d+)\s+(\d+)\s+(\d+)$/, '\1 \2.\3.\4')    # Three-part: "63v1 0 1" → "63 v1.0.1"
+
+        # Fix volume ranges: "535v2a-l" → "535 v2a-l", "535v2m-z" → "535 v2m-z"
+        cleaned = cleaned.gsub(/(\d)(v\d+[a-z]-[a-z])/, '\1 \2')
+
+        # NEW: Fix volume with uppercase letter: "48v3B" → "48 v3B" (Session 220)
+        cleaned = cleaned.gsub(/(\d)(v\d+[A-Z])/, '\1 \2')
+
+        # NEW: Fix volume ranges with uppercase: "v2A-L" → "v2a-l" (normalize to lowercase) (Session 220)
+        cleaned = cleaned.gsub(/(v\d+)([A-Z])-([A-Z])/, '\1\2-\3'.downcase)
+
+        # NEW: Fix edition with "ed." suffix: "2006ed." → "e2006" (V1 compatibility)
+        # Pattern appears at end of identifier: "NIST SP 260-162 2006ed."
+        cleaned = cleaned.gsub(/(\d{4})ed\./, 'e\1')
+
+        # CRITICAL: Fix revision attached to number BEFORE update patterns!
+        # "8115r1-upd" → "8115 r1-upd" so that later "r1-upd" → "r1 -upd" works
+        # But preserve r6/1925 format (don't add space before slash/year)
+        # And preserve 300-8r1/upd format (don't separate r1/upd)
+        # ENHANCED: Also handle r1a (revision with letter suffix) - "800-22r1a" → "800-22r1A"
+        # FIXED: When there's a letter suffix, keep together for second_number pattern
+        # CRITICAL: Use \d{1,2} instead of \d+ to limit revision to 1-2 digits, allowing [a-z] to match
+        # First rule: Match r+digit+letter (keep together)
+        cleaned = cleaned.gsub(/(\d+)(r\d{1,2})([a-z])(?=-|[A-Z]|$)/) do
+          num = $1
+          rev = $2
+          letter = $3
+          # Keep together when there's a letter suffix
+          "#{num}#{rev}#{letter.upcase}"
+        end
+        # Second rule: Match r+digit WITHOUT letter suffix
+        # CRITICAL: Use negative lookahead (?![a-zA-Z]) to avoid matching when there's a letter
+        # PRESERVE compact format (no space) when at end of string (NIST SP 800-53r4)
+        # ADD space only when followed by: dash+uppercase, uppercase letter, or /upd, /errata, /insert
+        cleaned = cleaned.gsub(/(\d+)(r\d{1,2})(?![a-zA-Z])(?=[A-Z]|-(?=[A-Z])|\/(?:upd|errata|insert))/) do
+          num = $1
+          rev = $2
+          # Add space when followed by dash+uppercase, uppercase, or update keyword
+          "#{num} #{rev}"
+        end
+
+        # Fix spaces in version/volume numbers: "v1 1" → "v1.1", "1011-I-2 0" → "1011-I-2.0"
+        # ENHANCED to handle multiple spaces: "v1 0 1" → "v1.0.1", "v1 0 2" → "v1.0.2"
+        # FIXED: Pattern must start with "v" or digit to avoid matching "rev 2013" as "v" + " 2013"
+        # CRITICAL: Added word boundary \b to prevent matching "v" within "rev"
+        # CRITICAL FIX: Use \b to ensure match starts at word boundary
+        cleaned = cleaned.gsub(/(\b(?:v|\d)[v\d]*[-A-Z]*)\s+(\d+)\s+(\d+)/, '\1.\2.\3') # Three parts
+        # CRITICAL FIX: Use \b to ensure match starts at word boundary
+        cleaned = cleaned.gsub(/(\b(?:v|\d)[v\d]*)\s+(\d+)/, '\1.\2') # Two parts
+
+        # Fix update patterns: ensure space before -upd or /upd (not just at end)
+        # Enhanced to handle optional digits after upd: -upd, -upd1, /upd, /upd1
+        cleaned = cleaned.gsub(/(\d+)-upd(\d*)/, '\1 -upd\2')    # -upd or -upd1
+        cleaned = cleaned.gsub(/(\d+)\/upd(\d*)/, '\1 /upd\2')   # /upd or /upd1
+        cleaned = cleaned.gsub(/([a-z]\d+)-upd/, '\1 -upd')      # r1-upd → r1 -upd
+        cleaned = cleaned.gsub(/([a-z]\d+)\/upd/, '\1 /upd')     # After revision: r1/upd → r1 /upd
+
+        # NEW FIX 3: MR format with letter suffix before update: "8286C-upd1" → "8286C -upd1"
+        # Must handle uppercase letters before -upd in MR format
+        cleaned = cleaned.gsub(/(\d+[A-Z])-upd(\d*)/, '\1 -upd\2')  # Letter suffix + update
+        cleaned = cleaned.gsub(/(\d+[A-Z])\/upd(\d*)/, '\1 /upd\2') # Letter suffix + /upd variant
+
+        # Fix supplement patterns: ensure space before supplement (1st variant)
+        # "118supp3" already handled at line 32-33, but add "sup" variant
+        cleaned = cleaned.gsub(/(\d)(sup\d)/, '\1 \2') # 100-2sup1 → 100-2 sup1
+        # Fix supplement patterns: ensure space before supplement (2nd variant)
+        cleaned = cleaned.gsub(/(\d)(sup+)(\d)/, '\1 \2\3') # 100-2sup+1 → 100-2 sup+1
+        # Fix supplement patterns: ensure space before supplement (3rd variant)
+        cleaned = cleaned.gsub(/(\d)(sup\+)(\d)/, '\1 \2\3') # 100-2sup+1 → 100-2 sup+1
+        # Fix supplement patterns: ensure space before supplement (4th variant)
+        cleaned = cleaned.gsub(/(\d)(sup\d+)/, '\1 \2') # 100-2sup1 → 100-2 sup1
+        # Fix supplement patterns: ensure space before supplement (5th variant)
+        cleaned = cleaned.gsub(/(\d)(sup\d+\b)/, '\1 \2') # 100-2sup1 → 100-2 sup1
 
-        if parsed.is_a?(Hash)
-          parsed.merge(parsed_format: result.format)
-        elsif parsed.is_a?(Array)
-          merged = parsed.each_with_object({}) do |hash, acc|
+        # Fix letter suffix + supplement: "378Gsup" → "378Gsupp" (NEW for LCIRC patterns)
+        # Normalize "sup" to "supp" for letter suffix patterns to match circ_supplement_identifier rule
+        cleaned = cleaned.gsub(/(\d+[A-Z])sup(\b)/, '\1supp\2') # 378Gsup → 378Gsupp
+
+        # Fix LCIRC supplement without letter suffix: "118sup12/1926" → "118supp12/1926"
+        # Normalize "sup" to "supp" for LCIRC patterns to match circ_supplement_identifier rule
+        cleaned = cleaned.gsub(/(\d+)sup(\d+\/\d{4})/, '\1supp\2') # 118sup12/1926 → 118supp12/1926
+
+        # REMOVED: Revision letter patterns that add space before revision with letter
+        # These conflicted with the fix at lines 131-142 which keeps "22r1a" together
+        # for second_number pattern matching. The comprehensive fix now handles:
+        # - "800-22r1a" → "800-22r1A" (kept together, uppercase letter)
+        # - "800-22r1" → "800-22 r1" (space added when no letter suffix)
+
+        # Fix number with letter suffix followed by standalone 'r': "56ar" → "56a r" (NEW)
+        cleaned = cleaned.gsub(/(\d[a-z])r\b/, '\1 r')
+
+        # Fix revision followed by language code: "r1es" → "r1 es", "r1pt" → "r1 pt" (NEW)
+        cleaned = cleaned.gsub(/(r\d+)(es|pt|chi|viet|port|esp)\b/, '\1 \2')
+
+        # Fix MR format translation codes: ".spa" → " spa", ".por" → " por", ".ind" → " ind" (NEW)
+        # Prevents 3-letter translation codes from being parsed as letter suffixes
+        # "NIST.SP.1262.spa" → "NIST.SP.1262 spa" (convert dot to space)
+        cleaned = cleaned.gsub(/^([A-Z]+)\.SP\.(\d+)\.([a-z]{2,4})$/,
+                               '\1.SP.\2 \3')
+        cleaned = cleaned.gsub(/^([A-Z]+)\.([A-Z]+)\.(\d+)\.([a-z]{2,4})$/,
+                               '\1.\2.\3 \4')
+
+        # ENHANCEMENT 1: Edition year normalization (-YYYY → eYYYY)
+        # Per NIST spec, trailing -YYYY should normalize to eYYYY format
+        # Pattern: number (optionally with non-e letter suffix) followed by dash and 4-digit year
+        # Examples: "330-2019" → "330e2019", "304a-2017" → "304Ae2017"
+        # Must NOT match existing edition patterns like "11e2-1915" (e2 is edition, -1915 is separate)
+        # Must be at end or before space to avoid breaking number-number patterns like "800-53"
+        # Negative lookbehind (?<![eE-]) prevents matching after e/E or dash (avoids e2-1915 and 105-1-1990)
+        # EXCLUSION: Do NOT convert -YYYY for HB series (handbooks) - preserve original format
+        # Example: "NBS HB 130-1979" should stay as "NBS HB 130-1979" (not convert to e1979)
+        # EXCLUSION: Do NOT convert -YYYY when preceded by "e\d+" (edition+year pattern like "44e2-1955")
+        # EXCLUSION: Only convert years in NBS (1901-1988) or NIST (1988-2099) range
+        # Numbers outside this range are part numbers, not edition years (e.g., SP 250-1039)
+        # Use a more specific pattern: only convert when NOT preceded by "e" + digits (edition)
+        # AND only convert when year is in valid range (1901-2099)
+        cleaned = cleaned.gsub(/(?<!e\d)(?<![eE-])(\d(?:[A-DF-Z]?))-(\d{4})(?=\s|$)/) do |match|
+          prefix = $1 # Number with optional letter
+          year = $2.to_i
+          # Only convert to edition format if year is in valid range
+          if year.between?(1901, 2099)
+            "#{prefix}e#{year}"
+          else
+            match # Keep dash format for part numbers (e.g., 250-1039)
+          end
+        end
+        # Revert the conversion for HB series to preserve -YYYY format
+        # Matches both "HB 130e1979" and "HB 105-1e1990" patterns
+        # Use [^:\s.]*? (exclude dots) to avoid consuming MR format dot separators
+        # This prevents "NIST.HB.135e2022" from being incorrectly reverted
+        cleaned = cleaned.gsub(/\b(HB|HB\s+)[^:\s.]*?(\d+)e(\d{4})(?=\s|$)/,
+                               '\1\2-\3')
+        # Revert the conversion for OWMWP series to preserve date format MM-DD-YYYY
+        # OWMWP uses date as the number: "06-13-2018" (not an edition)
+        # Pattern: "OWMWP 06-13e2018" → "OWMWP 06-13-2018"
+        cleaned = cleaned.gsub(
+          /\b(OWMWP|OWMWP\s*)[^:\s]*?(\d{2})-(\d{2})e(\d{4})(?=\s|$)/, '\1\2-\3-\4'
+        )
+        # Revert the conversion for RPT series to preserve year range format YYYY-YYYY
+        # Report series uses year ranges as the number: "1946-1947" (not an edition)
+        # Pattern: "RPT 1946e1947" → "RPT 1946-1947"
+        # Note: This must check that first year < second year (forward range)
+        cleaned = cleaned.gsub(/\b(RPT|RPT\s*)([^:\s]*?)(\d{4})e(\d{4})(?=\s|$)/) do |match|
+          prefix = $1 # "RPT" or "RPT "
+          separator = $2 # "." or "" or other non-colon, non-space chars
+          first_year = $3.to_i
+          second_year = $4.to_i
+          # Only revert if first < second (year range like 1946-1947)
+          if first_year < second_year
+            "#{prefix}#{separator}#{first_year}-#{second_year}"
+          else
+            match # Keep e format for editions like e2018e2019
+          end
+        end
+
+        # ENHANCEMENT 2: Version normalization (v1.1 → ver1.1, Ver. 2.0 → ver2.0)
+        # Normalize short v format to verbose ver format per NIST spec
+        # Already handled in version rule, but normalize in preprocessing for consistency
+
+        # CRITICAL: MR format version normalization must come BEFORE general v normalization
+        # Pattern: "NIST.SP.500-281-v1.0" → "NIST.SP.500-281.ver1.0"
+        # This allows report_number to match "500-281" and version rule to match ".ver1.0"
+        cleaned = cleaned.gsub(/-v(\d+\.\d+)/, '.ver\1')
+
+        # Handle Ver. with period: "Ver. 2.0" → "ver2.0" (remove period and space)
+        cleaned = cleaned.gsub(/\bVer\.\s+(\d+(?:\.\d+)*)/, 'ver\1')
+        # Handle verbose "v" to "ver": "v1.1" → "ver1.1" (only with dots - versions have dots)
+        cleaned = cleaned.gsub(/\bv(\d+\.\d+(?:\.\d+)*)/, 'ver\1')
+
+        # Fix uppercase P for part: "428P1" → "428 p1", "647P2" → "647 p2" (NEW)
+        cleaned = cleaned.gsub(/(\d)P(\d)/, '\1 p\2')
+
+        # Normalize part notation: "p1" → "pt1", "n1" → "pt1" for consistency
+        # This handles patterns like "61p1" → "61pt1" and "467n1" → "467pt1"
+        # MUST come AFTER uppercase P normalization
+        # EXCLUDE pattern: {number}p{digit}{4-digit-year} like "28p11969" (part + year, not part notation)
+        # Use negative lookahead to avoid matching when p/n + digit is followed by exactly 4 digits (year)
+        cleaned = cleaned.gsub(/\b([pn])(\d+)(?!\d{4}\b)/, 'pt\2')
+
+        # Fix complex part patterns in MR format: ensure space before part
+        cleaned = cleaned.gsub(/(\d)([pP]\d+)/, '\1 \2') # .467p1adde1 → .467 p1adde1, 800-57p1 → 800-57 p1
+
+        # Fix CRPL-F series: ensure space after series (e.g., "CRPL-F-B150" → "CRPL-F-B 150")
+        cleaned = cleaned.gsub(/(NBS CRPL-F-[AB])(\d)/, '\1 \2')
+        cleaned = cleaned.gsub(/(CRPL-F-[AB])(\d)/, '\1 \2')
+
+        # Extract volume from number: "17-917v3" → "17-917 v3", "1-1v1" → "1-1 v1"
+        # Pattern: digits-digits followed by v and digits (GCR, NCSTAR patterns)
+        # MUST be specific to avoid breaking existing "v1.1" patterns
+        cleaned = cleaned.gsub(/(\d+-\d+)(v\d+)(?![.\d])/, '\1 \2') # Negative lookahead for dots
+
+        # pd_suffix rule handles " 2pd" directly (space >> digits >> str("pd"))
+        # No preprocessing needed - adding space before "pd" breaks the parser
+
+        # Fix "Suppl" with space: "955 Suppl" → "955Suppl"
+        cleaned = cleaned.gsub(/(\d+)\s+Suppl\b/, '\1Suppl')
+
+        # Fix verbose "Version" format: " Version 2" → " ver 2"
+        cleaned = cleaned.gsub(/\s+Version\s+(\d+)/, ' ver \1')
+
+        # Fix verbose "Revision" format: " Revision (r)" → " r"
+        cleaned = cleaned.gsub(/\s+Revision\s+\(r\)/, " r")
+
+        # Fix verbose "rev YYYY" format: "126 rev 2013" → "126r2013"
+        # Removes space between number and "rev", and converts to "r" prefix
+        # Handles patterns like "NIST SP 260-126 rev 2013" → "NIST SP 260-126r2013"
+        cleaned = cleaned.gsub(/(\d+)\s+rev\s+(\d{4})/, '\1r\2')
+
+        # Fix historical "report ;" format: "NBS report ; 8079" → "NBS RPT 8079"
+        # The semicolon and "report" (spelled out) are historical formats
+        cleaned = cleaned.gsub(/\breport\s*;\s*/, "RPT ")
+        cleaned = cleaned.gsub(/\breport\b/, "RPT")
+
+        # REMOVED: Incorrect dot preprocessing that treated dots as number separators
+        # This was semantically wrong - dots are PART separators in NIST!
+        # DELETE: cleaned = cleaned.gsub(/(\d{3,})\.(\d{1,4})(?=\s|$)/, '\1_\2')
+
+        # REMOVED: Incorrect space-to-underscore that treated as single number
+        # DELETE: cleaned = cleaned.gsub(/(\d{3,})\s+(\d{1,2})$/, '\1_\2')
+
+        # Detect format before parsing
+        format = detect_format(input.to_s)
+
+        # Use parslet parser instance
+        result = new.parse(cleaned)
+
+        # Add format to result
+        if result.is_a?(Hash)
+          result.merge(parsed_format: format)
+        elsif result.is_a?(Array)
+          # For array results, merge all hashes into one
+          # This handles cases where identifier rule returns multiple components (e.g., compound_series + edition)
+          merged = result.inject({}) do |acc, hash|
             next acc unless hash.is_a?(Hash)
 
-            acc.merge!(hash)
+            acc.merge(hash)
           end
-          merged.merge(parsed_format: result.format)
+          merged.merge(parsed_format: format)
         else
-          parsed
+          result
+        end
+      end
+
+      # Detect format from input string
+      # :mr if contains dots (machine-readable: NIST.SP.800-53)
+      # :short otherwise (default: NIST SP 800-53)
+      def self.detect_format(input)
+        # Check if it has dot separators (MR format pattern)
+        # Patterns include:
+        # - "NIST.SP.800-53" (publisher.series.number)
+        # - "FIPS.46e1977" (series.numberWithEdition)
+        # - "NBS.HB.28pt1e1969" (publisher.series.part.edition)
+        # Key indicator: dots between components instead of spaces
+        if input.include?(".") && !input.match?(/\s/)
+          :mr
+        else
+          :short
+        end
+      end
+
+      # Convert Roman numerals to Arabic numbers
+      # I→1, II→2, III→3, IV→4, V→5, VI→6, VII→7, VIII→8, IX→9, X→10
+      def self.roman_to_arabic(roman)
+        case roman
+        when "I" then "1"
+        when "II" then "2"
+        when "III" then "3"
+        when "IV" then "4"
+        when "V" then "5"
+        when "VI" then "6"
+        when "VII" then "7"
+        when "VIII" then "8"
+        when "IX" then "9"
+        when "X" then "10"
+        else roman # Fallback for unexpected patterns
         end
       end
 
@@ -116,9 +522,7 @@ module Pubid
           str("AI") | str("CIRC") | str("CS") | str("CSM") |
           str("CRPL") | str("LCIRC") | str("OWMWP") | str("PC") | str("RPT") |
           str("SIBS") | str("TIBM") | str("TTB") | str("EAB") |
-          str("JPCRD") | str("JRES") |
-          # NEW - CHIPS Act, NWIRP, and Research Brief series
-          str("CHIPS") | str("NWIRP") | str("RB")
+          str("JPCRD") | str("JRES")
         ).as(:series)
       end
 
@@ -218,14 +622,6 @@ module Pubid
           # Note: Preprocessing converts content inside parentheses to uppercase
           # Use specific patterns to avoid consuming other parenthetical content
           (digits.as(:number) >> str("(") >> (str("SP") | str("PT") | str("ES")).as(:language_code) >> str(")")) |
-          # Number with letter suffix followed by revision (e.g., "8278Ar1", "256Ar1930")
-          # CRITICAL: Must come BEFORE digits_with_suffix because number_suffix's
-          # str("r").absent? guard rejects any letter followed by 'r' (would
-          # otherwise drop the letter and parse "256" + "Ar1930" as garbage).
-          (digits.as(:number) >>
-           upper_letter.as(:letter_suffix) >>
-           str("r") >>
-           digits.as(:revision_id)).as(:number_with_letter_revision) |
           # Regular number with optional suffix (original) - includes letters like "A"
           digits_with_suffix
         ).as(:first_number)
@@ -238,11 +634,6 @@ module Pubid
           # NEW: Exclude "draft" keyword
           str("draft").absent? >>
           (
-            # Trailing bare supplement marker on a compound second number
-            # (e.g. "800-53sup") so it isn't split into "53s" + "up". Builder
-            # strips the marker and sets supplement="" (canonical "sup").
-            (digits >> (str("supp") | str("sup")) >>
-              (digit.absent? >> letter.absent?)) |
             # NEW: Revision pattern with U+letter suffix (e.g., "22r1Ua", "38Ua")
             # MUST come BEFORE general letter suffix to avoid matching just "U" from "Ua"
             (digits >> str("r") >> digits >> str("U") >> lower_letter) |
@@ -330,32 +721,6 @@ module Pubid
         ).as(:date)
       end
 
-      # ISO date token (YYYY-MM-DD) for date-style identifiers
-      rule(:iso_date) do
-        (match("[0-9]").repeat(4, 4).as(:date_year) >> dash >>
-         match("[0-9]").repeat(2, 2).as(:date_month) >> dash >>
-         match("[0-9]").repeat(2, 2).as(:date_day))
-      end
-
-      # Date-style identifier with no series (e.g. "NIST 2022-04-15 001",
-      # "NIST.2022-04-15.001" — DOI 10.6028/NIST.2022-04-15.001)
-      rule(:dated_identifier) do
-        hash_prefix.maybe >>
-          publisher >> (space | dot) >>
-          iso_date.as(:dated_date) >> (space | dot) >>
-          match("[0-9]").repeat(1).as(:dated_seq)
-      end
-
-      # "NIST Research Library (YYYY)" — one-off NIST publication that doesn't
-      # fit the standard series+number shape (no report number, year in parens).
-      # See pubid/pubid#151.
-      rule(:research_library_identifier) do
-        publisher >> space >>
-          str("Research Library").as(:series) >>
-          (space >> str("(") >>
-            match("[0-9]").repeat(4, 4).as(:year) >> str(")")).maybe
-      end
-
       # LEGACY EDITION PATTERNS (for backward compatibility during migration)
       # These will be gradually replaced as we migrate to proper Edition/Date components
       rule(:legacy_edition) do
@@ -392,8 +757,6 @@ module Pubid
       rule(:report_number) do
         first_number >>
           (
-            # Underscore edition-year (space-form mirror of mr_identifier): "1648_2009"
-            (str("_") >> digits.as(:edition_year)) |
             # Month abbreviation as edition (e.g., 107-Mar1985, 11-Jan1925)
             # MUST BE FIRST to catch -MonthYear patterns before they're
             # incorrectly parsed as other alternatives
@@ -413,13 +776,6 @@ module Pubid
               (str("U") >> lower_letter.as(:letter_suffix_extra)) |
               upper_letter
             ).as(:letter_suffix)).as(:letter_number) |
-            # Dash-SEPARATED letter suffix on a numbered part (e.g., 21-4-B,
-            # 173-1-B for FIPS, and the reparseable form of letter_number's own
-            # rendered output 200-30-B). The month_abbrev guard keeps FIPS date
-            # forms like 11-1-Sep1977 with the earlier patterns; the trailing
-            # guard restricts to a single clean letter so GCR -200-30B is unaffected.
-            (dash >> digits.as(:letter_base) >> dash >> month_abbrev.absent? >>
-             upper_letter.as(:letter_suffix) >> (letter | digit).absent?).as(:letter_number) |
             # Edition dash-year pattern (e.g., -1979 for handbooks like "NBS HB 130-1979")
             # Matches any 4-digit sequence - the builder decides if it's a year or second_number
             (dash >> match("[0-9]").repeat(4,
@@ -448,12 +804,7 @@ module Pubid
 
       # Volume
       rule(:volume) do
-        # Long-form "Vol." comes FIRST so PEG ordered choice doesn't commit to
-        # the bare "v" alternative after consuming the leading space via
-        # space.maybe (which would then starve the " Vol. " form). Both
-        # "Vol. 4" (period + space) and "Vol.4" (period only) are accepted.
-        (space.maybe >>
-          (str("Vol. ") | str("Vol.") | str("v"))) >>
+        (space.maybe >> (str("v") | str(" Vol. "))) >>
           (digits >>
            # Support letter ranges (lowercase normalized in preprocessing)
            (str("a-l") | str("m-z") | str("A-L") | str("M-Z")).maybe >>
@@ -463,8 +814,7 @@ module Pubid
 
       # Part - enhanced to support patterns like p1adde1 AND pt3r1 (part with revision)
       rule(:part) do
-        (str(" Part. ") | str(" Part.") | str(" Part ") |
-         (space.maybe >> (str("pt") | str("p") | str("P")))) >>
+        ((space.maybe >> (str("pt") | str("p") | str("P"))) | str(" Part ")) >>
           (digits >>
            # NEW: Revision after part number: pt3r1, p1r1 (space.maybe for preprocessing)
            (space.maybe >> str("r") >> digits).maybe >>
@@ -490,8 +840,7 @@ module Pubid
           # Enhanced to accept letter-only revisions and space before r
           # ENHANCED: Accept BOTH lowercase and uppercase letters in suffix
           # ENHANCED: Capture original format prefix for format preservation (e.g., " Rev. 5")
-          ((str(" rev ") | str("rev") | str(" r") | str("r") | str(" Rev. ") | str(" Rev.") | str(" Revision (r)")).as(:revision_prefix) >>
-           space.maybe >>
+          ((str(" rev ") | str("rev") | str(" r") | str("r") | str(" Rev. ") | str(" Revision (r)")).as(:revision_prefix) >>
             ((digits >> match("[a-zA-Z]").maybe) | match("[a-zA-Z]").repeat(1)).as(:revision_id)).as(:revision) |
           # NEW: Standalone 'r' - MUST BE LAST to avoid consuming from other patterns
           # Matches " r" at end of input (after preprocessing: "800-56a r", "800-27 r")
@@ -526,18 +875,8 @@ module Pubid
           (
             digits.as(:update_number).maybe >>
             (dash >>
-              (
-                # Real updates: 4-digit year + optional 2-digit month
-                # (e.g. /Upd1-2015, /Upd3-202102).
-                (match("[0-9]").repeat(4, 4).as(:update_year) >>
-                 match("[0-9]").repeat(2, 2).as(:update_month)) |
-                # Fallback: capture the whole digit run as the year. Handles the
-                # unpadded CIRC/LCIRC supplement form pubid emits, where year and
-                # revision are fused without a 2-digit month boundary
-                # (e.g. /Upd1-19256 = 1925 + revision 6). Keeps these strings
-                # re-parseable so generated ids round-trip.
-                match("[0-9]").repeat(4).as(:update_year)
-              )
+              match("[0-9]").repeat(4, 4).as(:update_year) >>
+              match("[0-9]").repeat(2, 2).as(:update_month).maybe
             ).maybe
           ).as(:update)
       end
@@ -602,8 +941,8 @@ module Pubid
         (str("(") >> match('\w').repeat(3, 3).as(:translation) >> str(")")) |
           # Space-prefix format: " spa"
           (space >> match('\w').repeat(3, 3).as(:translation)) |
-          # Dot-prefix format: ".spa" (machine-readable), optional leading space: " .spa"
-          (space.maybe >> dot >> match('\w').repeat(3, 3).as(:translation))
+          # Dot-prefix format: ".spa" (machine-readable)
+          (dot >> match('\w').repeat(3, 3).as(:translation))
       end
 
       # Public draft suffix - for patterns like 2pd, 3pd
@@ -671,9 +1010,7 @@ module Pubid
       # Try compound series first (longest match), then publisher + simple series
       rule(:identifier) do
         circ_supplement_identifier |
-          dated_identifier |
           mr_identifier |
-          research_library_identifier |
           (
             # Compound series (includes publisher in series name)
             compound_series >> (space | dot) >>
@@ -708,11 +1045,6 @@ module Pubid
             # Date range supplement (no base number)
             (str("supp") >> month_abbrev.as(:supp_month_start) >> digits.as(:supp_year_start) >>
              dash >> month_abbrev.as(:supp_month_end) >> digits.as(:supp_year_end)).as(:supplement_date_range) |
-            # Year-only date range supplement to the whole series, no months
-            # (e.g. "NBS CIRC sup1925-1926" — pubid/pubid#152). Requires two
-            # 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) |
             # With base identifier + supplement
             (
               # Capture base portion (everything before "supp" or "sup" or slash+year)