pubid 2.0.0.pre.alpha.30 → 2.0.0.pre.alpha.32

data/lib/pubid/errors.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-require "pubid"
+# no `require "pubid"` here: errors.rb loads from pubid.rb itself, and
+# the umbrella self-require is a circular load whose failure order is
+# platform-dependent (windows raises mid-cycle where linux tolerates it)
 require "parslet"
 
 module Pubid

data/lib/pubid/ieee/builder.rb

@@ -316,7 +316,11 @@ module Pubid
             end
           end
         end
-        if dash && parsed_hash[:year].nil?
+        # 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] &&
@@ -335,7 +339,7 @@ module Pubid
               [joined, dash[:dash_year], dash[:dash_month]].compact.join("-")
             dash.delete(:dash_year)
             dash.delete(:dash_month)
-          elsif dash[:dash_month] || dash_led
+          elsif (dash[:dash_month] || dash_led) && parsed_hash[:year].nil?
             parsed_hash[:year] = dash[:dash_year]
             parsed_hash[:month] = dash[:dash_month]
           else
@@ -955,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?
@@ -971,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
@@ -1850,13 +1878,18 @@ 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]) && month && year
+          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}"
@@ -1991,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/parser.rb

@@ -1273,6 +1273,63 @@ 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 same redundant word rides the wider joint lists
+        # ("IEEE//ISO/IEC Draft P29119-2/D=DIS-201112"); the crawl also
+        # doubles the publisher slash (the 2026-10-14 ruling: the list
+        # normalizes to single slashes). Drop the word and collapse the
+        # slash before the joint route sees either.
+        # Scoped to the D= stage-draft tail: the doubled-D ("DDIS2") and
+        # stage-month ("DFDIS_March") tails route elsewhere until the
+        # grammar carries them - dropping the word there would route
+        # them to the generic standard face with a slashed copublisher.
+        cleaned = cleaned.gsub(%r{((?:IEEE|ISO|IEC)(?:/(?:IEEE|ISO|IEC|CSA))+)\s+Draft\s+(P[A-Z0-9][A-Z0-9.-]*/D=[A-Z])}, '\1 \2')
+        cleaned = cleaned.gsub(%r{(IEEE|ISO|IEC)//}, '\1/')
+        # The lettered REV spellings glue to the number ("P1310Rev3",
+        # "P1722Rev1") or carry an after-word separator ("REV.ma",
+        # "REV-ma"); the rev rules read a space or a bare word
+        # respectively, so the boundary normalizes (the render keeps the
+        # glued face - "IEEE P1310 Rev3/D2-2011-02" parses to
+        # "IEEE P1310Rev3/D2-2011-02"). The before-word separator the
+        # Rev doctrine carries ("-REVmc") is untouched.
+        cleaned = cleaned.gsub(%r{(REV|Rev|rev)[.\-](?=[A-Za-z])}, '\1')
+        cleaned = cleaned.gsub(%r{(\d)(REV|Rev|rev)}, '\1 \2')
+
+        # 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,7 +195,8 @@ 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
 

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

@@ -51,6 +51,13 @@ module Pubid
         COMPACT_FLAT_VALUES.each do |key|
           out[key] = { "value" => out[key] } if out[key].is_a?(::String)
         end
+        # Legacy index rows (the pre-flattening component era) carry the
+        # number as a {"value" => …} Hash; the attribute is a plain
+        # string now, so the Hash collapses to its scalar before the
+        # assignment dumps it (pubid#540).
+        if out["number"].is_a?(::Hash) && out["number"].key?("value")
+          out["number"] = out["number"]["value"]
+        end
         out
       end
 

data/lib/pubid/version.rb

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

metadata

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