pubid 2.0.0.pre.alpha.23 → 2.0.0.pre.alpha.25

data/lib/pubid/iec/builder.rb

@@ -362,7 +362,10 @@ module Pubid
           build(value)
 
         when :publisher
-          Components::Publisher.new(body: value)
+          # CEI is IEC's French spelling (pubid#488): a French-printed
+          # "CEI …" identifier is the IEC publisher; the canonical
+          # rendering prints IEC.
+          Components::Publisher.new(body: value == "CEI" ? "IEC" : value)
 
         when :copublishers
           if value.nil? || value.empty?

data/lib/pubid/iec/parser.rb

@@ -223,11 +223,12 @@ module Pubid
 
       rule(:language) do
         # IEC 60038:2009(en,fr)
+        # IEC 60038:2009(en-fr) (house style, pubid#491)
         # IEC 60038:2009(E/F)
         str("(") >>
           (
             # parse 2-char language codes: ru,en,fr,de,ar,es
-            (match["a-z"].repeat(1) >> str(",").maybe) |
+            (match["a-z"].repeat(1) >> (str(",") | str("-")).maybe) |
             # parse single language codes: R/E/F
             (match["EFARDS"] >> str("/").maybe)
           ).repeat.as(:languages) >>

data/lib/pubid/iec/single_identifier.rb

@@ -78,11 +78,14 @@ module Pubid
       def language_portion(lang_single: false)
         return "" unless languages&.any?
 
+        # IEC house style joins multiple language codes with '-'
+        # ("IEC 60050-103:2020(en-fr)"), not ',' (pubid#491; pubid-iec 1.x
+        # behavior, which metanorma-iec's fixtures encode).
         [
           "(",
           languages.map do |lang|
             lang.to_s(lang_single: lang_single)
-          end.join(lang_single ? "/" : ","),
+          end.join(lang_single ? "/" : "-"),
           ")",
         ].join
       end

data/lib/pubid/ieee/builder.rb

@@ -272,6 +272,51 @@ module Pubid
         # Parslet can return array of hashes - merge them
         parsed_hash = parsed.is_a?(Array) ? merge_parsed_array(parsed) : parsed
 
+        # Grammar-captured dash dates (relaton's "/D-3-2017-07" and
+        # "/R-x-2011-04" tails) land on the identifier's year/month exactly
+        # like the number's own date clause. The revision-suffix form sits at
+        # the top level; the draft tail nests under :draft — either as its
+        # own element or wrapped in a draft_version hash.
+        drafts = parsed_hash[:draft].is_a?(Array) ? parsed_hash[:draft] : [parsed_hash[:draft]].compact
+        drafts.each do |d|
+          next unless d.is_a?(Hash) && d[:draft_version].is_a?(Hash)
+          dv = d[:draft_version]
+          d[:dash_year] = dv[:dash_year] if dv[:dash_year]
+          d[:dash_month] = dv[:dash_month] if dv[:dash_month]
+          d.delete(:draft_version)
+        end
+        dash = parsed_hash[:dash_year] ? parsed_hash : nil
+        dash ||= drafts.find { |d| d.is_a?(Hash) && d[:dash_year] }
+        if dash && parsed_hash[:year].nil?
+          joined = drafts.filter_map { |d| d.is_a?(Hash) ? d[:draft_version] : nil }
+                         .map { |v| v.is_a?(Hash) ? v[:value] : v.to_s }.join
+          bare_joint_draft = parsed_hash[:joint_publishers] &&
+                             parsed_hash[:part].nil? &&
+                             parsed_hash[:iso_stage].nil? &&
+                             drafts.any? { |d| d.is_a?(Hash) && d[:draft_version] }
+          dash_led = joined.start_with?("-")
+          if bare_joint_draft && dash_led
+            parsed_hash[:part] = { value: dash[:dash_year] }
+          elsif dash[:dash_month] || dash_led
+            parsed_hash[:year] = dash[:dash_year]
+            parsed_hash[:month] = dash[:dash_month]
+          else
+            # Year-only tail embeds in the draft face ("D9-2006"), the model
+            # the relaton-pinned renders use for corrupted update_codes
+            # drafts: standard class, stage from the type word (the compound
+            # draft version misses the D-registry), no separate year.
+            host = drafts.find { |d| d.is_a?(Hash) && d[:draft_version] }
+            if host
+              host[:draft_version] = "#{joined}-#{dash[:dash_year]}"
+              dash.delete(:dash_year)
+              dash.delete(:dash_month)
+            else
+              parsed_hash[:year] = dash[:dash_year]
+              parsed_hash[:month] = dash[:dash_month]
+            end
+          end
+        end
+
         # Handle multi-numbered identifiers (cross-reference and joint standards)
         # CRITICAL: Don't recurse when building secondary identifier to prevent infinite loop
         if !building_secondary && parsed_hash[:primary_identifier] && (parsed_hash[:secondary_crossref] || parsed_hash[:secondary_joint])
@@ -739,8 +784,27 @@ module Pubid
           attributes[:copublisher] = pubs.drop(1)
         end
 
-        # Build code with parts if present
+        # Build code with parts if present. A bare-P joint draft's dash
+        # date ("P42010/D-4-2019") rides the code as a year-part
+        # ("P42010.2019/D4") — the face the relaton fixtures pin — while
+        # stage-first joints keep the top-level year ("FDIS P15289:2017").
         code_parts = []
+        if parsed[:part].nil? && parsed[:iso_stage].nil? && parsed[:draft_version] &&
+           parsed[:printed_dash_year] && parsed[:year] &&
+           (parsed[:year].is_a?(Hash) ? parsed[:year][:value] : parsed[:year]).to_s.match?(/\A(19|20)\d\d\z/)
+          # A dash-led draft ("P42010/D-4-2019") takes the year-part face;
+          # an undashed one ("P26511/D8-2018") embeds the date in the draft
+          # face.
+          if extract_value(parsed[:draft_dash]).to_s == "-"
+            code_parts << extract_value(parsed[:year])
+            parsed[:year] = nil
+          else
+            # The year stays: the IEEE face suppresses it while a draft is
+            # attached, and the ISO face renders it ("P26511:2018").
+            parsed[:draft_version] =
+              "#{extract_value(parsed[:draft_version])}-#{extract_value(parsed[:year])}"
+          end
+        end
         code_parts << extract_value(parsed[:part]) if parsed[:part]
 
         code_str = extract_value(parsed[:number])
@@ -785,9 +849,13 @@ module Pubid
         end
         attributes[:parenthetical_content] ||= extract_value(parsed[:edition_marker]) if parsed[:edition_marker]
 
-        # Extract edition, from relaton's "/E-<n>" suffix (normalized to
-        # "Edition <n>.0"). nil-residue hand-off item 1.
-        attributes[:edition] = extract_value(parsed[:edition]) if parsed[:edition]
+        # Extract edition, from relaton's "/E-<n>" suffix. The grammar's /E
+        # alternative captures the bare ordinal (nil-residue hand-off item 1).
+        if parsed[:edition]
+          attributes[:edition] = extract_value(parsed[:edition])
+        elsif parsed[:edition_e]
+          attributes[:edition] = "#{extract_value(parsed[:edition_e])}.0"
+        end
         if parsed[:edition_month]
           attributes[:edition_month] = extract_value(parsed[:edition_month])
         end
@@ -1458,9 +1526,10 @@ module Pubid
                         extract_value(dv)
                       end
 
-            # Construct draft notation like "D1", "D2", etc.
             if version
-              draft_abbr = "D#{version}"
+              # relaton's hyphenated "/D-2" spelling captures the dash inside
+              # draft_version; the stage registry keys on "D2".
+              draft_abbr = "D#{version.to_s.sub(/\A-/, "")}"
               # Check if this specific draft stage is in registry
               stage = Pubid::Ieee.locate_stage(draft_abbr)
               return draft_abbr if stage&.abbr&.include?(draft_abbr)

data/lib/pubid/ieee/identifiers/joint_development.rb

@@ -239,7 +239,8 @@ module Pubid
           # Join with space and add year with dash — unless the D=
           # designator face already carried it above.
           result = parts.join(" ")
-          result += "-#{year}" if year && !@designator_carries_year
+          result += "-#{year}" if year && !@designator_carries_year &&
+                           !ieee_draft.to_s.end_with?("-#{year}")
 
           result
         end

data/lib/pubid/ieee/parser.rb

@@ -701,9 +701,8 @@ module Pubid
             ((comma | space) >> month_name.as(:month) >> space >>
              year_digits.as(:year) >> str("").as(:printed_month_year))
           ).maybe >>
-          # Optional /D<draft> tail. normalize_relaton_suffixes repositions the
-          # historical "…/D-3-2017" onto the number as "…-2017/D3", so by the
-          # time this rule runs the draft usually trails the date (bucket 5);
+          # Optional /D<draft> tail; the historical hyphenated form
+          # "…/D-3-2017" carries its date inside the draft clause (bucket 5);
           # a date-less "/D-4" keeps its hyphen (bucket 7), hence dash.maybe.
           # A text date may trail the DRAFT itself (pubid#216:
           # "CD P26515/D1, March 2017", "FDIS P15289/D3, 2017") — distinct
@@ -912,7 +911,7 @@ module Pubid
           revision_suffix.maybe >>
           # …and the print date may also trail the repositioned revision
           # ("IEEE Unapproved Draft P802.16Rev2/D9a, March 2009" reaches the
-          # grammar as "…/D9a/R-2, March 2009" via normalize_revision_notation).
+          # grammar with its inline revision parsed natively).
           (comma >> space? >> month_name.as(:trailing_month) >> space >>
             year_digits.as(:trailing_year)).maybe >>
           # Trailing corrigendum after the draft ("…/D2.0/Cor. 1", or
@@ -1046,9 +1045,8 @@ module Pubid
           (str(".") >> year_digits.as(:year)).maybe >>
           # The date and the draft appear in EITHER order: the legacy
           # spelling puts the draft first ("PSI 10/D2, October 2015"),
-          # while normalize_relaton_suffixes repositions the rawbib
-          # hyphenated form onto the number ("PSI 10/D-3-2010" →
-          # "PSI 10-2010/D3"). Draft-first is tried first so the legacy
+          # the rawbib hyphenated form ("PSI 10/D-3-2010") parses in place
+          # with its date on the draft clause. Draft-first is tried first so the legacy
           # comma-date keeps its original match; each side is optional so
           # a date-only or draft-less form still parses.
           (
@@ -1243,242 +1241,6 @@ module Pubid
       end
 
       root(:identifier)
-
-      # Rewrite relaton's historical IEEE serialization into canonical pubid
-      # spellings. relaton's own formatter (Relaton::Ieee::PubId::Id#to_s) emits
-      # suffix tokens that differ from pubid's grammar:
-      #
-      #   /D-N-YYYY[-MM]  draft + trailing numeric date  (the dominant form)
-      #   /E-N[-YYYY[-MM]] edition
-      #   /R-N[-YYYY]      revision (pubid has no revision suffix)
-      #   " Redline"       redline suffix without the " - " pubid expects
-      #
-      # The draft/edition trailing date is repositioned onto the document number
-      # as a base year/month (a form pubid already parses), which also keeps the
-      # draft component clean so it round-trips through to_hash/from_hash.
-      def self.normalize_relaton_suffixes(cleaned)
-        # NOTE: the trailing " Redline"/" - Redline" suffix is NO LONGER stripped
-        # here — the grammar's `redline` rule captures it into a redline flag so
-        # a redline id stays distinct from its base standard.
-
-        # Combined draft + corrigendum: relaton emits "…/D-N/CorM-YYYY" (draft
-        # then corrigendum), but pubid's grammar accepts the corrigendum first.
-        # Swap them so the corrigendum keeps its own year and the draft trails.
-        # The hyphen after "D" is mandatory here: relaton's formatter always
-        # emits "/D-<draft>", whereas pubid's own canonical joint-development
-        # form is "/D<draft>-<year>" (no hyphen, year kept on the draft) — which
-        # already parses and must not be repositioned. A trailing corrigendum
-        # month (the "-MM" in "/CorM-YYYY-MM") is intentionally dropped: pubid's
-        # corrigendum model carries only a year.
-        cleaned = cleaned.sub(
-          %r{\A(.*)/D-([0-9A-Za-z][0-9A-Za-z.+]*?)/Cor\.?[ ]?(\d+)(?:-((?:19|20)\d\d))?(?:-\d\d)?\z},
-        ) do
-          base, draft, cor, year = Regexp.last_match.captures
-          "#{base}/Cor #{cor}#{year ? "-#{year}" : ''}/D#{draft}"
-        end
-
-        # Combined draft + revision, and the empty-draft revision-only form:
-        #   "…/D-<d>/R-<x>-YYYY[-MM]"  and  "…/D-/R-<x>-YYYY"   (nil-residue #2).
-        # Reposition the base publication date onto the number (pubid's
-        # "-YYYY[-MM]" shape), keep the draft as "/D<d>" (dropped when the draft
-        # is empty), and leave a trailing "/R-<x>" the grammar captures as the
-        # revision. Runs before the plain "/D-…" reposition, which the embedded
-        # "/R-" would otherwise defeat.
-        cleaned = cleaned.sub(
-          %r{\A(.*?)/D-([0-9A-Za-z.+]*)/R-([0-9A-Za-z]+)(?:-((?:19|20)\d\d)(?:-(0[1-9]|1[0-2]))?)?\z},
-        ) do
-          base, draft, rev, year, month = Regexp.last_match.captures
-          date = year ? "-#{year}#{month ? "-#{month}" : ''}" : ""
-          draft_part = draft.to_s.empty? ? "" : "/D#{draft}"
-          "#{base}#{date}#{draft_part}/R-#{rev}"
-        end
-
-        # /D-N drafts with a trailing numeric date, when the draft is the last
-        # suffix: reposition the -YYYY[-MM] date onto the number. A following
-        # /Cor, /Amd, /R or /E suffix carries its own year, so the `\z` anchor
-        # keeps this from firing on those combined forms.
-        cleaned = cleaned.sub(
-          %r{\A(.*)/D-([0-9A-Za-z][0-9A-Za-z.+]*?)-((?:19|20)\d\d)(?:-(0[1-9]|1[0-2]))?\z},
-        ) do
-          base, draft, year, month = Regexp.last_match.captures
-          "#{base}-#{year}#{month ? "-#{month}" : ''}/D#{draft}"
-        end
-
-        # /E-N editions: relaton's "/E-2-2023-02" → pubid's "Edition 2.0 2023-02".
-        cleaned = cleaned.sub(
-          %r{\A(.*?)/E-(\d+)(?:-((?:19|20)\d\d)(?:-(0[1-9]|1[0-2]))?)?\z},
-        ) do
-          base, edition, year, month = Regexp.last_match.captures
-          date = year ? " #{year}#{month ? "-#{month}" : ''}" : ""
-          "#{base} Edition #{edition}.0#{date}"
-        end
-
-        # /R-N revisions: PRESERVE them (the grammar's revision_suffix rule now
-        # captures a trailing "/R-<x>" into the `revision` attribute). Just
-        # reposition any trailing publication year onto the number, keeping the
-        # "/R-<x>" in place for the grammar.
-        cleaned.sub(
-          %r{\A(.*?)/R-([0-9A-Za-z]+)(?:-((?:19|20)\d\d))?\z},
-        ) do
-          base, rev, year = Regexp.last_match.captures
-          "#{year ? "#{base}-#{year}" : base}/R-#{rev}"
-        end
-      end
-
-      # Strip the IEEE rawbib revision-notation dialects. `REV`/`Rev`
-      # (case-insensitive) + a trailing revision id `[A-Za-z0-9]+`, glued to the
-      # number or separated by `-`, `/`, `_`, `.`, or a space, and preceding the
-      # draft. pubid's canonical "<num>/D<n>/R-<x>" form already drops the
-      # revision on render (normalize_relaton_suffixes strips a trailing /R-x),
-      # so the revision-less result is *the same identifier* — and stripping
-      # (rather than reordering) leaves any trailing date/parenthetical intact,
-      # which is why forms that already parse (`Draft P…-REVmb/D3.0, Mar 2010`)
-      # are NOT disturbed. Examples:
-      #   "P802.16.2-REVa/D8" -> "P802.16.2/D8"
-      #   "P802.16/REVd/D5"   -> "P802.16/D5"
-      #   "P802.15.1REVa/D5"  -> "P802.15.1/D5"
-      #   "P802.11REVmb"      -> "P802.11"   (no draft)
-      def self.normalize_revision_notation(cleaned)
-        # NUMBERED revisions ("Rev<digits>") are PRESERVED — repositioned to a
-        # trailing "/R-<n>" suffix the grammar captures as the `revision`
-        # attribute (IEEE's native inline spelling; numbered-revision hand-off).
-        # A "\d+" right after "Rev" both selects the numbered subset and keeps
-        # these off the English word "Revision". Three source positions:
-        #   after a draft : "PC37.30.2/D043 Rev 18" -> ".../D043/R-18"
-        # The draft captures accept relaton's hyphenated "/D-<n>" spelling
-        # (pubid#316): without the "-?" the before-draft regex matched only
-        # "/D" of "/D-3" and emitted the garbage "/D/R-2-3-2008-02".
-        cleaned = cleaned.sub(
-          %r{(/D-?[0-9A-Za-z.]+)\s+[Rr][Ee][Vv]\s*(\d+)}, '\1/R-\2'
-        )
-        #   before a draft: "P802.16Rev2/D3" -> "P802.16/D3/R-2"
-        cleaned = cleaned.sub(
-          %r{[-/_.]?\s?[Rr][Ee][Vv][-\s]?(\d+)(/D-?[0-9A-Za-z.]+)}, '\2/R-\1'
-        )
-        #   no draft, trailing: "P1722-rev1" -> "P1722/R-1"
-        cleaned = cleaned.sub(
-          %r{(\d)[-._]?\s?[Rr][Ee][Vv]\s*(\d+)\s*\z}, '\1/R-\2'
-        )
-
-        # LETTERED inline revisions ("REVa", "REVmb") have no pubid model and are
-        # still STRIPPED (unchanged behaviour). The numbered forms above already
-        # became "/R-<n>", so these regexes only see the lettered residue.
-        # Revision token that PRECEDES a draft: drop it (keep the /D…).
-        cleaned = cleaned.sub(
-          %r{[-/_.]?\s?[Rr][Ee][Vv][-\s]?[A-Za-z0-9]+(?=/D-?[0-9A-Za-z])},
-          "",
-        )
-        # Trailing revision glued to the number with no draft ("P802.11REVmb");
-        # a digit must immediately precede REV so a trailing English word like
-        # "…Revision" can't match.
-        cleaned.sub(%r{(\d)[Rr][Ee][Vv][A-Za-z0-9]+\s*\z}, '\1')
-      end
-
-      # Rewrite the mechanical spellings of the joint ISO-stage forms that no
-      # grammar branch reaches (pubid#216 residuals). Two safety rules keep
-      # this from stealing inputs other rules already parse:
-      #   1. only BROKEN separators fire — underscore/space glue between
-      #      number, draft and stage, a slash-SPACE before the stage, a
-      #      dash/underscore month after it. A plain "/FDIS" tail is
-      #      natively accepted by ieee_p_identifier (fdraft) and the
-      #      stage-LAST embedded rule, so it is never rewritten.
-      #   2. the number carries at most ONE part — joint_development_iso_format
-      #      reads a single optional part, while ieee_p_identifier takes
-      #      multi-part numbers ("P62271-37-013"); a rewrite that moved a
-      #      multi-part number onto the joint rule would break it.
-      def self.normalize_joint_stage_spellings(cleaned)
-        # The separator (slash-optional-space or a space) is INSIDE the
-        # capture so a rewrite re-emits it — an uncaptured separator was
-        # silently eaten, gluing the publisher to the stage.
-        pubs = %r{((?:ISO/IEC/IEEE|IEEE/ISO/IEC|IEEE/IEC/ISO|ISO/IEEE|IEC/IEEE|IEEE/IEC|ISO/IEC|IEEE)(?:/ ?| ))}
-        stage = /(FDIS|FCD|CDV|DIS\d?|CD\d?|WD|PWI|NP)/
-        num = /(P?\d+(?:[.-]\d+)?)/
-        # What the joint grammar can finish reading AFTER the stage: the end
-        # of the string, a (comma-)month-year date, or a dash-year[-month].
-        # Captured and re-emitted so a rewrite never drops the date.
-        tail = /(,? (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)[a-z]* \d{4}|\z|-\d{4}(?:-\d\d)?)/
-
-        # Draft glued to the number with an underscore: "P15289_D3" →
-        # "P15289/D3" (a digit must precede the underscore; "_FDIS" is the
-        # stage, not a draft, and is already slash-rewritten earlier).
-        cleaned = cleaned.gsub(%r{(\d)_D(\d)}, '\1/D\2')
-
-        # Crawl typo: a comma with no space before a month (",March 2021").
-        # In these identifiers a comma is always a date separator, so
-        # spacing it is safe.
-        cleaned = cleaned.sub(/,(?=[A-Za-z])/, ", ")
-
-        # Stage AFTER the draft, both glued with underscores (the early
-        # stage gsub already turned "_CD" into "/CD"):
-        # "…P24748-3/D3/FDIS, April 2020 (E)" → "…FDIS P24748-3/D3, …"
-        cleaned = cleaned.sub(
-          %r{\A#{pubs}#{num}/(D[\d.]+)/ ?#{stage}\b},
-          '\1\4 \2/\3',
-        )
-
-        # Slash-SPACE before the stage ("…P16085/ FDIS, August 2020" —
-        # ieee_p's fdraft has no inner space, so this spelling has no other
-        # home): → "…FDIS P16085, August 2020"
-        cleaned = cleaned.sub(
-          %r{\A#{pubs}#{num}/ #{stage}#{tail}},
-          '\1\3 \2\4',
-        )
-
-        # A space-year after a slash-stage ("…P26511.2/FDIS 2018" — no rule
-        # reads "/FDIS 2018"): → "…FDIS P26511.2-2018" (dash-year clause).
-        cleaned = cleaned.sub(
-          %r{\A#{pubs}#{num}/#{stage} (\d{4})\b},
-          '\1\3 \2-\4',
-        )
-
-        # Stage separated from the number by a SPACE ("IEC/IEEE P63113 CD4,
-        # April 2019"): → "IEC/IEEE CD4 P63113, April 2019". The tail guard
-        # keeps "…FDIS March 2019" (space-month-year, readable after the
-        # swap) while leaving prose suffixes alone.
-        cleaned = cleaned.sub(
-          %r{\A#{pubs}#{num} #{stage}#{tail}},
-          '\1\3 \2\4',
-        )
-
-        # The same space-stage with a space-DRAFT chained after it
-        # ("IEC/IEEE P60980-344 CDV D1, June 2019"): → stage-first with a
-        # slash draft ("…CDV P60980-344/D1, June 2019").
-        cleaned = cleaned.sub(
-          %r{\A#{pubs}#{num} #{stage} (D\d+)\b},
-          '\1\3 \2/\4',
-        )
-
-        # Slash-stage carrying a dash-date ("…P15288/CD2-2013-09 …" — the
-        # dash-year tail is what the joint grammar reads after the number, so
-        # this cannot steal the plain "/FDIS, June 2021" spellings
-        # ieee_p_identifier finishes): → "…CD2 P15288-2013-09 …". The date
-        # must be a plausible year — a 4-digit monthcode (YYMM, e.g.
-        # "…P24748-4/DIS-1404" = April 2014) is a DRAFT designator, not a
-        # dash-date, and rewriting it onto the number breaks the parse.
-        cleaned = cleaned.sub(
-          %r{\A#{pubs}#{num}/ ?#{stage}(-(?:19|20)\d\d(?:-\d\d)?)},
-          '\1\3 \2\4',
-        )
-
-        # Draft separated from a stage-first number by a SPACE:
-        # "…DIS P11073-10418 D13, January 2011" → "…DIS P11073-10418/D13, …"
-        cleaned = cleaned.sub(
-          %r{\A#{pubs}#{stage} #{num}/? ?(D\d+)\b},
-          '\1\2 \3/\4',
-        )
-
-        # NOT rewritten: a month glued to the stage with a dash/underscore
-        # ("…/FDIS_Dec 2012", "…/FDIS-Dec 2015"). Even routed onto the joint
-        # grammar, the joint render of a month+draft is itself not yet
-        # idempotent, and the bare-IEEE fdraft path drops the stage and the
-        # date from to_hash — rewriting would trade a visible parse failure
-        # for silent garbage. Deferred with the pubid#216 semantic residue.
-        cleaned
-      end
-
-      # Pre-parse ingestion normalizations (R2): every parse path —
-      # parslet and PG artifact alike — feeds the grammar the same
-      # normalized string.
       def self.normalize_input(string)
         # Strip .pdf extension if present (Pattern 3: File Extensions)
         cleaned = string.sub(/\.pdf$/i, "")
@@ -1492,14 +1254,6 @@ module Pubid
         # No valid IEEE identifier pattern needs more than 1 space
         cleaned = cleaned.gsub(/\s+/, " ")
 
-        # Rewrite the rawbib revision-notation dialects (REVa/REVd/glued) into
-        # the canonical /R-<x> form before the suffix normalization below.
-        cleaned = normalize_revision_notation(cleaned)
-
-        # Normalize relaton's bespoke historical serialization (the spellings
-        # emitted by Relaton::Ieee::PubId::Id#to_s) into canonical pubid forms
-        # so `relaton-data-ieee` parses. See #normalize_relaton_suffixes.
-        cleaned = normalize_relaton_suffixes(cleaned)
 
         # NEW Session 171: CONSERVATIVE data quality fixes for TODO.IEEE-MUST-DO.txt
         # Only fix clear typos: space before dash + 4-digit year, OR dash + space + 4-digit year
@@ -1538,11 +1292,6 @@ module Pubid
           /\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)(\d{4})\b/, '\1 \2'
         )
 
-        # Rewrite the joint ISO-stage glued spellings (pubid#216) AFTER the
-        # month unglue above, so "Dec2015" is already spaced when the
-        # dash-month rewrite looks for it.
-        cleaned = normalize_joint_stage_spellings(cleaned)
-
         # NEW: Convert IEC/IEEE space-separated to semicolon format
         # Pattern: "IEC 61523-3 First edition 2004-09; IEEE 1497" → already semicolon
         # Pattern: "IEC 62539 First Edition 2007-07 IEEE 930" → needs semicolon

data/lib/pubid/version.rb

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

metadata

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