pubid 2.0.0.pre.alpha.24 → 2.0.0.pre.alpha.26

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,140 +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
-
-      # 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, "")
@@ -1390,20 +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
-        # Do NOT touch " - " (space-dash-space) which is valid formatting
-        cleaned = cleaned.gsub(/(\d)\s+-(\d{4})\b/, '\1-\2')  # "C37.101 -2006" → "C37.101-2006"
-        cleaned = cleaned.gsub(/(\d)-\s+(\d{4})\b/, '\1-\2')  # "C62.35- 2010" → "C62.35-2010"
 
         # NEW Session 171: Remove wrong ! prefix
         cleaned = cleaned.gsub(/^!IEEE /, "IEEE ")
@@ -1414,10 +1264,6 @@ module Pubid
         cleaned = cleaned.gsub("&amp;amp;", "&")   # Double-encoded ampersand
         cleaned = cleaned.gsub("&amp;", "&")       # Single-encoded ampersand
 
-        # NEW: Wrap P&V notation in parentheses (Paper & Video, etc.)
-        # Pattern: "IEEE Std 500-1984 P&V" → "IEEE Std 500-1984 (P&V)"
-        cleaned = cleaned.gsub(/\s+(P&V)\s*$/, ' (\1)')
-
         # NEW Phase 1: Fix number spacing issues (e.g., "C57.1 2.25" → "C57.12.25")
         # This handles cases where a space appears in the middle of a number
         cleaned = cleaned.gsub(/(\d+\.\d+)\s+(\d+\.)/, '\1\2')
@@ -1426,16 +1272,6 @@ module Pubid
         # Remove spaces within 4-digit years
         cleaned = cleaned.gsub(/\b(1|2)\s+(\d{3})\b/, '\1\2')
 
-        # NEW: Fix month+year spacing (e.g., "March2016" → "March 2016")
-        # Add space between month name and 4-digit year when they're concatenated
-        cleaned = cleaned.gsub(
-          /\b(January|February|March|April|May|June|July|August|September|October|November|December)(\d{4})\b/, '\1 \2'
-        )
-        # Also handle abbreviated months
-        cleaned = cleaned.gsub(
-          /\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)(\d{4})\b/, '\1 \2'
-        )
-
         # 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.24"
+  VERSION = "2.0.0.pre.alpha.26"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.alpha.24
+  version: 2.0.0.pre.alpha.26
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-03 00:00:00.000000000 Z
+date: 2026-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model