pubid 2.0.0.pre.alpha.29 → 2.0.0.pre.alpha.31

data/lib/pubid/ieee/builder.rb

@@ -5,6 +5,17 @@ module Pubid
     # Builder class for constructing IEEE identifier scheme from parsed data
     # Single Responsibility: Transform parsed data into identifier objects
     class Builder
+      # The month_name vocabulary the REV date embed canonicalizes numeric
+      # (the parg rule's exact spellings, dots already stripped).
+      REV_MONTH_NUMBERS = {
+        "January" => "01", "February" => "02", "March" => "03",
+        "April" => "04", "May" => "05", "June" => "06", "July" => "07",
+        "August" => "08", "September" => "09", "Sept" => "09",
+        "October" => "10", "November" => "11", "December" => "12",
+        "Jan" => "01", "Feb" => "02", "Mar" => "03", "Apr" => "04",
+        "Jun" => "06", "Jul" => "07", "Aug" => "08", "Sep" => "09",
+        "Oct" => "10", "Nov" => "11", "Dec" => "12",
+      }.freeze
       attr_accessor :original_input
       attr_reader :identifier_class
 
@@ -287,7 +298,29 @@ module Pubid
         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?
+        if dash.nil? && parsed_hash[:draft]
+          # A numeric month trailing a draft is the draft's own date: it
+          # embeds in the designator ("D09, 04 2011" -> "D09-2011-04")
+          # rather than printing the long-format comma face (a month name
+          # keeps the comma, "D7.2, Nov 2006") — pubid ruling 2026-10-13.
+          m = parsed_hash[:month] || parsed_hash[:trailing_month]
+          y = parsed_hash[:year] || parsed_hash[:trailing_year]
+          if m.to_s.match?(/\A\d{1,2}\z/) && y
+            host = drafts.find { |d| d.is_a?(Hash) && d[:draft_version] }
+            if host
+              host[:draft_version] = [host[:draft_version], y, m].compact.join("-")
+              parsed_hash.delete(:month)
+              parsed_hash.delete(:year)
+              parsed_hash.delete(:trailing_month)
+              parsed_hash.delete(:trailing_year)
+            end
+          end
+        end
+        # The draft's own dash date embeds onto the draft even when a
+        # base identity year is present ("…-2011/D4-2015-07": the 2011
+        # is the base's year, the 2015-07 the draft's); only the
+        # root-year assignment waits for an unoccupied year slot.
+        if dash
           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] &&
@@ -297,7 +330,16 @@ module Pubid
           dash_led = joined.start_with?("-")
           if bare_joint_draft && dash_led
             parsed_hash[:part] = { value: dash[:dash_year] }
-          elsif dash[:dash_month] || dash_led
+          elsif dash[:dash_month] &&
+                (host = drafts.find { |d| d.is_a?(Hash) && d[:draft_version] })
+            # The draft's own numeric date embeds in the designator
+            # ("D2-2015-04") — the "D2, 04 2015" comma spelling
+            # normalizes onto it (pubid ruling 2026-10-13).
+            host[:draft_version] =
+              [joined, dash[:dash_year], dash[:dash_month]].compact.join("-")
+            dash.delete(:dash_year)
+            dash.delete(:dash_month)
+          elsif (dash[:dash_month] || dash_led) && parsed_hash[:year].nil?
             parsed_hash[:year] = dash[:dash_year]
             parsed_hash[:month] = dash[:dash_month]
           else
@@ -307,9 +349,16 @@ module Pubid
             # 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]}"
+              # The draft's own numeric date embeds in the designator
+              # ("D9-2006", and with its month "D2-2015-04") — the
+              # "D2, 04 2015" comma spelling normalizes onto it.
+              host[:draft_version] =
+                [joined, dash[:dash_year], dash[:dash_month]].compact.join("-")
               dash.delete(:dash_year)
               dash.delete(:dash_month)
+              # the hyphenated "/D-2-2007" spelling's year the spine
+              # captured at top level is the draft's own — vacate it
+              parsed_hash.delete(:year) if parsed_hash[:year] == dash[:dash_year]
             else
               parsed_hash[:year] = dash[:dash_year]
               parsed_hash[:month] = dash[:dash_month]
@@ -910,12 +959,23 @@ module Pubid
             # exempt: their canonical is the ISO face, which prints the
             # date from the identity slots (", March 2017", pubid#216).
             if parsed[:draft_month] && parsed[:iso_stage].nil?
-              draft = Components::Draft.new(
-                version: draft_ver,
-                month: extract_value(parsed[:draft_month]),
-                year: extract_value(parsed[:draft_year]))
-              draft.comma_before_month = true
-              attributes[:draft] = draft.to_s.sub(%r{\A/}, "")
+              dm = extract_value(parsed[:draft_month]).to_s
+              dy = extract_value(parsed[:draft_year]).to_s
+              num = REV_MONTH_NUMBERS[dm.delete(".")]
+              if attributes[:publishers] == %w[IEEE CSA] && num && !dy.empty?
+                # The joint IEEE/CSA drafts glue their date into the
+                # designator with the month numeric (pubid ruling
+                # 2026-10-14: no comma dates on these rows).
+                draft = Components::Draft.new(version: "#{draft_ver}-#{dy}-#{num}")
+                attributes[:draft] = draft.to_s.sub(%r{\A/}, "")
+              else
+                draft = Components::Draft.new(
+                  version: draft_ver,
+                  month: dm,
+                  year: dy)
+                draft.comma_before_month = true
+                attributes[:draft] = draft.to_s.sub(%r{\A/}, "")
+              end
               attributes.delete(:year) if parsed[:year].nil?
               attributes.delete(:month) if parsed[:month].nil?
             elsif parsed[:draft_year] && parsed[:iso_stage].nil?
@@ -926,6 +986,19 @@ module Pubid
               draft_year = extract_value(parsed[:draft_year]).to_s.sub(/\A[, ]+/, "")
               attributes[:draft] = "D#{draft_ver}, #{draft_year}"
               attributes.delete(:year) if parsed[:year].nil?
+            elsif attributes[:publishers] == %w[IEEE CSA] &&
+                  parsed[:iso_stage].nil? &&
+                  extract_value(parsed[:year]).to_s.match?(/\A(19|20)\d\d\z/) &&
+                  extract_value(parsed[:month]).to_s.match?(/\A\d{1,2}\z/)
+              # The glued face re-parses with the date in the identity
+              # slots ("D2-2016-09" -> year/month + a bare D2): it
+              # normalizes back onto the draft-embedded date so the
+              # round trip closes on the CSA canonical.
+              draft = Components::Draft.new(
+                version: "#{draft_ver}-#{extract_value(parsed[:year])}-#{extract_value(parsed[:month])}")
+              attributes[:draft] = draft.to_s.sub(%r{\A/}, "")
+              attributes.delete(:year)
+              attributes.delete(:month)
             else
               attributes[:ieee_draft] = "D#{draft_ver}"
             end
@@ -1548,6 +1621,8 @@ module Pubid
         # Optional attributes (excluding part/subpart since they're in code)
         extract_optional(parsed, attributes, :edition)
         extract_optional(parsed, attributes, :revision)
+        extract_optional(parsed, attributes, :rev_sep)
+        attributes[:rev_bare] = true if parsed[:rev_bare]
 
         # Month/day - always extract if present (but not if already extracted from year)
         unless attributes[:edition_month]
@@ -1663,8 +1738,9 @@ module Pubid
 
             if 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-/, "")}"
+              # draft_version; the stage registry keys on "D2". A date-embedded
+              # version ("3-2017-07") keys on its leading ordinal.
+              draft_abbr = "D#{version.to_s.sub(/\A-/, "").sub(/-\d{4}(-\d{2})?\z/, "")}"
               # 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)
@@ -1802,8 +1878,25 @@ module Pubid
           month_slice = draft_data[:month]
           month = extract_value(month_slice) if month_slice
           year = extract_value(draft_data[:year]) if draft_data[:year]
+          # The apostrophe-year catalogue convention ("P1484.20.1/D7,
+          # May 07"): the 2-digit year expands with the <30 pivot so the
+          # hash carries an unambiguous year.
+          year = "#{year.to_i < 30 ? 20 : 19}#{year}" if year.to_s.match?(/\A\d{2}\z/)
           day = extract_value(draft_data[:day]) if draft_data[:day]
 
+          # A REV-carrying draft embeds its print date into the designator
+          # with the month canonicalized numeric (pubid ruling 2026-10-14):
+          # "P802.11-REVmc/D8.0, Aug 2016" renders ".../D8.0-2016-08".
+          # Drafts without a REV keep the comma face.
+          if (attributes[:revision] || attributes[:rev_bare] ||
+              attributes[:cor_number] || attributes[:cor_year]) && month && year
+            number = REV_MONTH_NUMBERS[month.to_s.delete(".")]
+            if number && version
+              version = "#{version}-#{year}-#{number}"
+              month = year = day = nil
+            end
+          end
+
           # Detect comma before month and space before draft by checking the original input
           if original_input
             if month
@@ -1931,8 +2024,17 @@ module Pubid
           end
 
           if param_data[:revision_of]
-            attributes[:revision_of] =
-              extract_value(param_data[:revision_of])
+            target = extract_value(param_data[:revision_of]).to_s.strip
+            begin
+              # The model types revision_of as an Identifier (the printed
+              # target parses as one); feeding the raw string crashes
+              # to_hash with Lutaml::Model::IncorrectModelError.
+              attributes[:revision_of] = Identifier.parse(target)
+            rescue Pubid::Errors::ParseError, StandardError
+              # An unparseable printed target stays on the parenthetical
+              # surface instead of poisoning the hash.
+              attributes[:parenthetical_content] ||= target
+            end
           end
           if param_data[:amendment_to]
             attributes[:amendment_to] =

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

@@ -36,6 +36,12 @@ module Pubid
       # "Rev<id>". `::Pubid::Identifier` has no `revision` attribute, so this is
       # free of the number/stage multi-flavor collision landmine.
       attribute :revision, :string
+      # The lettered revision's printed separator ("P802.11-REVmc" keeps its
+      # dash; a glued "REVi" stays glued) and the bare-word marker (no id
+      # after "Rev" — "802.1AR-Rev/D2.2" keeps "Rev"). pubid ruling
+      # 2026-10-14.
+      attribute :rev_sep, :string
+      attribute :rev_bare, :boolean
       attribute :edition, :string                         # Edition 1.0
       attribute :month, :string
       # Provenance flag (pubid#517): the month arrived glued to the identity
@@ -216,7 +222,7 @@ module Pubid
       # (renderer.rb's `"Edition #{edition} #{year}-#{edition_month}"`),
       # which survived even though its sibling `year` is already stripped.
       def self.all_parts_edition_keys
-        super + %i[revision reaffirmed edition_month]
+        super + %i[revision rev_sep rev_bare reaffirmed edition_month]
       end
 
       # Inverse of the to_hash compaction: expand a scalar `stage` back into the

data/lib/pubid/ieee/parser.rb

@@ -1273,6 +1273,43 @@ module Pubid
         cleaned = cleaned.gsub("&", "&")   # Double-encoded ampersand
         cleaned = cleaned.gsub("&", "&")       # Single-encoded ampersand
 
+        # The joint IEEE/CSA catalogue spells the type word before the
+        # project number ("IEEE/CSA Draft P844.1/D2, Sept, 2016"): the P
+        # already carries the project semantics (docs/IEEE-DRAFT-STAGES.md
+        # §1.1), so the redundant word drops and the joint route parses.
+        cleaned = cleaned.gsub(%r{IEEE/CSA Draft (P[A-Z0-9])}, 'IEEE/CSA \1')
+
+        # The corrigendum's own draft follows the ordinal after a comma
+        # ("P11073-10418-2011/Cor 1, D4, July 2015"): re-spell the comma as
+        # the draft separator so the cor route's draft slot reaches it.
+        cleaned = cleaned.gsub(%r{/Cor(?:rigendum)? (\d+), (D[A-Z0-9])}, '/Cor \1/\2')
+
+        # The corrigendum's own draft rides before the ordinal in the
+        # house order ("PC37.101-2006/D2, 2007/Cor. 1"): the catalogue
+        # spellings "…/Cor 1, D4, July 2015" and "…/Cor 1-201x/D5,
+        # April 2012" re-order into it, with the draft's date glued
+        # -YYYY-MM (pubid ruling 2026-10-14: no comma dates).
+        cleaned = cleaned.gsub(
+          %r{/Cor(?:rigendum)? (\d+(?:-[0-9xX]{4})?)/(D[A-Z0-9][^,]*), ([A-Za-z]+) (\d{4})}
+        ) do
+          month = ::Pubid::Ieee::Builder::REV_MONTH_NUMBERS[Regexp.last_match(3).capitalize]
+          if month
+            "/#{Regexp.last_match(2)}-#{Regexp.last_match(4)}-#{month}/Cor. #{Regexp.last_match(1)}"
+          else
+            Regexp.last_match(0)
+          end
+        end
+        cleaned = cleaned.gsub(
+          %r{/Cor(?:rigendum)? (\d+), (D[A-Z0-9][^,]*), ([A-Za-z]+) (\d{4})}
+        ) do
+          month = ::Pubid::Ieee::Builder::REV_MONTH_NUMBERS[Regexp.last_match(3).capitalize]
+          if month
+            "/#{Regexp.last_match(2)}-#{Regexp.last_match(4)}-#{month}/Cor. #{Regexp.last_match(1)}"
+          else
+            Regexp.last_match(0)
+          end
+        end
+
         # 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')

data/lib/pubid/ieee/renderer.rb

@@ -195,14 +195,19 @@ module Pubid
           glued_month = id.month.to_s.match?(/\A\d{1,2}\z/)
           year_on_code = id.year && !id.edition &&
                          (!id.month || glued_month) &&
-                         (!id.draft_obj || id.draft_obj&.year)
+                         (!id.draft_obj || id.draft_obj&.year ||
+                          id.draft_obj&.version.to_s.match?(/-\d{4}-\d{2}\z/))
           result += "-#{id.year}" if year_on_code
           result += "-#{id.month}" if glued_month
 
           # Append the numbered/lettered revision inline, in IEEE's native
           # position — right after the code number and before the draft
-          # ("P802.16Rev2/D3"). Keeps a revision distinct from its base standard.
-          result += "Rev#{id.revision}" if id.revision
+          # ("P802.16Rev2/D3"). Keeps a revision distinct from its base
+          # standard. The lettered id keeps its printed separator
+          # ("P802.11-REVmc" renders "P802.11-Revmc"); the bare word with
+          # no id still prints "Rev" (pubid ruling 2026-10-14).
+          result += "#{id.rev_sep}Rev#{id.revision}" if id.revision
+          result += "#{id.rev_sep}Rev" if id.rev_bare
 
           # Append draft to code - with or without space based on original
           # format. An exactly-IEC/IEEE co-published reference prints only the

data/lib/pubid/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.alpha.29
+  version: 2.0.0.pre.alpha.31
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-12 00:00:00.000000000 Z
+date: 2026-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -484,6 +484,8 @@ files:
 - lib/pubid/evs/builder.rb
 - lib/pubid/evs/identifier.rb
 - lib/pubid/evs/identifiers.rb
+- lib/pubid/evs/identifiers/estonian_standard.rb
+- lib/pubid/evs/identifiers/international_adoption.rb
 - lib/pubid/evs/identifiers/national_adoption.rb
 - lib/pubid/evs/parser.rb
 - lib/pubid/evs/renderer.rb