pubid 2.0.0.pre.alpha.12 → 2.0.0.pre.alpha.13

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

@@ -201,6 +201,18 @@ module Pubid
         hash
       end
 
+      # Three more IEEE discriminators the default %i[date year edition
+      # version] list misses, alongside `edition`/`year`: `revision` (e.g.
+      # "2" in "P802.16Rev2"); `reaffirmed` (the "(R2010)" year, read by
+      # renderer.rb and urn_generator.rb — two reaffirmations of the same
+      # standard failed to collapse under #to_all_parts/#===); and
+      # `edition_month`, the month half of "Edition N YYYY-MM"
+      # (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]
+      end
+
       # Inverse of the to_hash compaction: expand a scalar `stage` back into the
       # `typed_stage` sub-hash (on a deep copy, recursively) before lutaml
       # deserializes, so nested bases rebuild their component too. `draft` needs
@@ -351,6 +363,14 @@ module Pubid
       def self.parse_single(input)
         # Apply legacy update_codes normalization first, before Parser's extensive preprocessing
         normalized = Core::UpdateCodes.apply(input, :ieee)
+        # UpdateCodes may introduce the "; " double-label separator
+        # ("ISO/IEC13210: 1994 (E) ANSI/IEEE Std ..." → the ISO/IEC and
+        # IEEE labels of one document), but the dispatch ran on the raw
+        # input - re-dispatch so the dual construction sees it.
+        if normalized != input && normalized.include?("; ")
+          result = PreParser.preprocess(normalized)
+          return build_dual(result.parts) if result.dispatch == :dual_semicolon
+        end
         parsed = Parser.parse(normalized) # Use class method for preprocessing
         builder = Builder.new(Identifier)
         # Pass the original input string to builder for context

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

@@ -26,6 +26,15 @@ module Pubid
         attribute :iec_year, :string            # IEC year like "2013"
         attribute :date_info, :string           # Date information like "(10/07)"
 
+        # `year_sep` only describes how a year is attached. When the reference
+        # omits the year, a subset match skips it: its default "-" would
+        # otherwise refuse a candidate printed with ":".
+        def subset_attribute_match?(name, mine, theirs)
+          return true if name == :year_sep && year.nil?
+
+          super
+        end
+
         # The printed IEC/IEEE number, rebuilt losslessly from the split
         # columns (the renderer/urn read this). Not stored — number/parts/
         # separators/year fully describe it, so the verbatim string never

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

@@ -42,6 +42,8 @@ module Pubid
         attribute :year, :string
         attribute :iso_stage, :string               # For ISO stage if present
         attribute :ieee_draft, :string              # For IEEE P/D notation if present
+        attribute :parenthetical_content, :string   # e.g. the "(E)" edition
+                                                    # marker of an ISO/IEC label
 
         # Accepts keyword args or a single positional hash (the base
         # #exclude/matching rebuild passes the latter) — see
@@ -138,14 +140,23 @@ module Pubid
             end
           end
 
-          # Code (NO P prefix in ISO format, NO draft notation)
-          code_str = code.to_s.gsub(/^P/, "")
+          # IEEE semantics: P = project (a draft); no P = a standard. The
+          # P-state is identity-bearing and prints as spelled — it is never
+          # added or stripped here.
+          code_str = code.to_s
           code_str += mark unless code_str.empty?
           parts << code_str if code_str && !code_str.empty?
 
-          # Join with space and add year with colon
+          # Join with space and add year with colon; the joint stage-draft
+          # clause ("D=WD.5") rides after the year in the ISO-led print.
           result = parts.join(" ")
           result += ":#{year}" if year
+          result += "/#{ieee_draft}" if ieee_draft && ieee_draft.start_with?("D=")
+          # Only the language/edition marker ("(E)", "(E/F)") prints; a
+          # trailing relationship narrative is metadata, not identity.
+          if parenthetical_content&.match?(%r{\A[A-Z](?:\s*[/&]\s*[A-Z])*\z})
+            result += " (#{parenthetical_content})"
+          end
 
           result
         end
@@ -159,13 +170,9 @@ module Pubid
           # Publishers (slash-separated)
           parts << publishers.join("/") if publishers && !publishers.empty?
 
-          # Build code part
-          code_str = code.to_s.gsub(/^P/, "") # Remove any existing P first
-
-          # Add P prefix for projects (IEEE format always shows P for drafts)
-          if typed_stage&.project_status || type == "P"
-            code_str = "P#{code_str}"
-          end
+          # Build code part — the P-state prints as spelled (P = project
+          # draft; no P = standard). Never added or stripped.
+          code_str = code.to_s
 
           # Mark after the number, before the draft and the year
           code_str += mark unless code_str.empty?

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

@@ -33,10 +33,17 @@ module Pubid
         # object. The "P" is reflected in the typed_stage, not in the Code
         # component itself. Accepts keyword args or a single positional hash (the
         # base #exclude/matching rebuild passes the latter).
+        attribute :project_marker, :boolean, default: -> { false }
+
         def initialize(args = {}, **kwargs)
           args = kwargs.empty? ? args.dup : args.merge(kwargs)
-          # If code is provided with "P" prefix (e.g., "P1234"), strip it
+          # If code is provided with "P" prefix (e.g., "P1234"), strip it.
+          # P = project (the document is a draft): the marker is
+          # identity-bearing, so its presence is remembered for the render —
+          # stripping the letter must not strip the fact (docs/
+          # IEEE-DRAFT-STAGES.md §1.1).
           if args[:code].is_a?(String) && args[:code].start_with?("P")
+            args[:project_marker] = true unless args.key?(:project_marker)
             args[:code] = args[:code][1..] # Strip leading "P"
           end
 

data/lib/pubid/ieee/parser.rb

@@ -269,6 +269,10 @@ module Pubid
       rule(:draft_date) do
         # Enhanced to handle: ", Sept 2008" or " Sept 2008" or ", Month Year"
         ((comma | space) >> month_name.as(:month) >> space >> year_digits.as(:year)) |
+          # Space-separated bare year after the draft designator
+          # ("IEEE Draft Std P14764/D1 2004, Nov 2004" - the "D1 2004" draft
+          # carries its own year, with the print date still trailing).
+          (space >> year_digits.as(:year)) |
           # Numeric-month form ", 05 2007" / " 05 2007" — no text month name. The
           # year separator may be a dash: preprocessing (parser.rb ~1278) rewrites
           # a trailing " <digits> <year>" to "<digits>-<year>", so "05 2007"
@@ -302,6 +306,15 @@ module Pubid
       rule(:draft) do
         (draft_prefix >> draft_version.repeat(1, 2) >>
          (dot >> digits.as(:revision)).maybe >>
+         # The compound both-systems form (docs/IEEE-DRAFT-STAGES.md
+         # §1.3): "=DDIS.3" - IEEE draft ordinal = draft of the ISO/IEC
+         # stage, with its iteration. The glued "=DDIS3" / "=DDIS-3"
+         # spellings are accepted aliases of "=DDIS.3".
+         (str("=") >> (str("D") >> (str("FDIS") | str("CDV") | str("PWI") |
+            str("DIS") | str("WD") | str("NP") | str("CD")) |
+           (str("FDIS") | str("CDV") | str("PWI") | str("DIS") | str("WD") |
+            str("NP") | str("CD"))).as(:draft_iso_stage) >>
+           (dot | dash).maybe >> digits.as(:draft_iso_iteration).maybe).maybe >>
          draft_date.maybe).as(:draft)
       end
 
@@ -532,7 +545,9 @@ module Pubid
 
       # Additional parameters (inside parentheses)
       rule(:additional_parameters) do
-        (space.maybe >> str("(") >> # Make space before '(' optional
+        (space.maybe >> str("(") >> space.maybe >> # Space before/after '(' optional
+         # ("( Revision of …)" - a crawl space inside the paren must not push
+         # the narrative to the catch-all and into the render).
          (reaffirmed |
           # Handle "Revision of IEEE Std ..." with optional space after Std
           (str("Revision of IEEE Std ") >> space.maybe >> match("[^)]").repeat(1).as(:revision_of)) |
@@ -582,15 +597,32 @@ module Pubid
         # ALSO handle: IEEE/CSA P844.1/293.1/D2 (CSA dual numbering)
         (str("ISO/IEC/IEEE") | str("ISO/IEEE") | str("IEC/IEEE") | str("IEEE/CSA")).as(:joint_publishers) >>
           space >>
-          str("P") >> # P indicates IEEE-led
+          # P = project (the document is a draft): identity-bearing, so it
+          # is captured and preserved, never silently consumed.
+          str("P").as(:project_marker) >>
           digits.as(:number) >>
           ((dot | dash) >> digits.as(:part)).maybe >> # Optional part like .1 or -1
           # CSA dual numbering: /293.1 (second number)
           (slash >> digits >> (dot >> digits).maybe >> (dash >> digits.as(:draft_version)).maybe).maybe >>
           (
-            # Variant 1: /D8 notation (original)
-            (slash >> str("D") >> digits.as(:draft_version)) |
-            # Variant 2: , CDV1 notation (comma before stage code)
+            # Variant 1b: the ordinal-less stage draft "D=CDV[:2020]" -
+            # D (draft) = CDV (the IEC stage it drafts). The year rides in
+            # the draft clause (a distinct key, so the builder keeps the
+            # date inside the designator).
+            (slash >> str("D") >> str("=") >>
+              (str("CDV") | str("FDIS") | str("PWI") | str("WD") |
+               str("NP") | str("DIS") | str("CD")).as(:draft_iso_stage) >>
+              (str(":") >> year_digits.as(:draft_stage_year)).maybe) |
+            # Variant 1: /D8 notation (original), with the compound
+            # both-systems suffix "=DDIS.3" (docs/IEEE-DRAFT-STAGES.md §1.3)
+            (slash >> str("D") >> digits.as(:draft_version) >>
+              (str("=") >> (str("D") >> (str("FDIS") | str("CDV") | str("PWI") |
+                 str("DIS") | str("WD") | str("NP") | str("CD")) |
+               (str("FDIS") | str("CDV") | str("PWI") | str("DIS") | str("WD") |
+                str("NP") | str("CD"))).as(:draft_iso_stage) >>
+               (dot | dash).maybe >> digits.as(:draft_iso_iteration).maybe).maybe) |
+            # Variant 2: , CDV1 notation (comma before stage code) —
+            # the stage draft of the named ISO/IEC stage, its iteration
             (comma >> (str("CDV") | str("FDIS") | str("CD") | str("DIS")).as(:iec_stage) >> digits.maybe.as(:stage_iteration))
           ).maybe >>
           # Optional edition, from relaton's "/E-<n>" suffix normalized to
@@ -636,18 +668,30 @@ module Pubid
             str("").as(:iso_published) >> space.maybe)) |
           (staged_only.as(:joint_publishers) >> space >>
             iso_stage >> std_noise >> space)) >>
-          str("P").maybe >> # optional project marker on the number
+          str("P").as(:project_marker).maybe >> # project marker (P =
+                                                # project/draft; its
+                                                # presence is identity)
           digits.as(:number) >>
-          # part must not swallow the trailing year (year_digits.absent?)
-          ((dot | dash) >> year_digits.absent? >> digits.as(:part)).maybe >>
+          # part must not swallow the trailing year (year_digits.absent?). A
+          # DASH-joined part is tagged (:part_dash) - the catalogue-printed
+          # joint form spells the part with a dash ("21451-7") where the ISO
+          # form uses the dot.
+          ((dot >> year_digits.absent? >> digits.as(:part)) |
+           (dash >> str("").as(:part_dash) >> year_digits.absent? >>
+             digits.as(:part))).maybe >>
           (
             (str(":") >> year_digits.as(:year)) |
+            # The dash-year (and ", Month YYYY" text date below) spellings are
+            # the catalogue-PRINTED joint form; tag them (:printed_form) so the
+            # builder routes to a Standard instead of the ISO joint reference.
             (dash >> year_digits.as(:year) >>
-             (dash >> month_numeric.as(:month)).maybe) |
+             (dash >> month_numeric.as(:month)).maybe >>
+             str("").as(:printed_dash_year)) |
             # Trailing text date ", April 2015" / " April 2015" (build_joint_development
             # already reads :month/:year). No :year collision — the iso rule has no
             # other :year capture (edition uses :edition_year).
-            ((comma | space) >> month_name.as(:month) >> space >> year_digits.as(:year))
+            ((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
@@ -658,11 +702,26 @@ module Pubid
           # keys (:draft_month/:draft_year), because a plain :month/:year
           # here collides with the date clause above and parslet drops the
           # subtree with a "Duplicate subtrees" warning.
+          # The ISO/IEC edition marker may sit between the year and an
+          # amendment/draft tail: "8802.11:2012 (E)/Amd 1-2014". A distinct
+          # key - a second :parameters capture here collides with the
+          # trailing parenthetical slot (parslet drops duplicate subtrees).
+          (space.maybe >> str("(") >>
+           match("[^)]").repeat(1).as(:edition_marker) >> str(")")).maybe >>
+          # The stage-draft clause of the ISO-led print: "/D=WD.5" -
+          # D (draft) = the ISO/IEC stage it drafts, with its iteration
+          # (docs/IEEE-DRAFT-STAGES.md §1.2).
+          ((slash >> str("D") >> str("=") >>
+           (str("FDIS") | str("FCD") | str("CDV") |
+            (str("DIS") >> digit.maybe) |
+            (str("CD") >> digit.maybe) |
+            str("WD") | str("PWI") | str("NP")).as(:draft_iso_stage) >>
+           (dot >> (digits >> match("[A-Za-z]").repeat(0, 1)).as(:draft_iso_iteration)).maybe) |
           (slash >> str("D") >> dash.maybe >>
            match('[0-9.]').repeat(1).as(:draft_version) >>
            (((comma | space) >> month_name.as(:draft_month) >> space >>
                year_digits.as(:draft_year)) |
-             (comma >> year_digits.as(:draft_year))).maybe).maybe >>
+             (comma >> year_digits.as(:draft_year))).maybe).maybe).maybe >>
           # Optional amendment tail (pubid#317:
           # "8802-11:2012/Amd.1:2014(E)") - the flat tree keys reuse
           # build_flat_amendment.
@@ -678,7 +737,6 @@ module Pubid
           # The crawl sometimes spaces it ("…(E), January 2017" family,
           # pubid#216), and a relationship parenthetical may follow
           # ("…CD2 P15288-2013-09 (Revision of …)").
-          space.maybe >> (str("(E)") | str("(F)")).maybe >>
           parenthetical.maybe
       end
 
@@ -692,6 +750,28 @@ module Pubid
       # the trailing `.FDIS` is the ISO stage, NOT a second part. Routes through
       # the same build_joint_development (via :joint_publishers/:iso_stage), so the
       # stage is modeled correctly and the numeric part stays separate.
+      # The stage-less ISO/IEC label with a colon year and the ISO/IEC
+      # edition marker: "ISO/IEC 13210:1994 (E)" - the ISO/IEC portion of a
+      # double-labeled standard. The (E) parenthetical is REQUIRED: without
+      # it this spelling is the ISO flavor's own form and must not be
+      # stolen. Routes through build_joint_development like every ISO-led
+      # joint reference.
+      rule(:joint_development_iso_iec_edition) do
+        str("ISO/IEC").as(:joint_publishers) >> space >>
+          str("").as(:iso_published) >>
+          str("P").as(:project_marker).maybe >>
+          digits.as(:number) >>
+          # The part may be dot- or dash-joined ("8802-9"); a dash-year
+          # ("1234-2012") is not a part.
+          # A distinct key: the iso-format route's :part_dash prints as a
+          # dot in the joint code (the "P24748.2:2018" convention); only
+          # the ISO/IEC LABEL keeps its printed dash.
+          ((dot | (dash >> str("").as(:iec_label_dash) >> year_digits.absent?)) >>
+            digits.as(:part)).maybe >>
+          (str(":") >> space.maybe >> year_digits.as(:year)) >>
+          space.maybe >> parenthetical
+      end
+
       rule(:joint_development_embedded_stage) do
         # publisher set mirrors joint_development_iso_format (incl. bare IEEE);
         # longest token first.
@@ -699,7 +779,9 @@ module Pubid
          str("ISO/IEEE") | str("IEC/IEEE") | str("IEEE/IEC") | str("ISO/IEC") |
          str("IEEE")).as(:joint_publishers) >>
           space >>
-          str("P").maybe >> # optional project marker on the number
+          str("P").as(:project_marker).maybe >> # project marker (P =
+                                                # project/draft; its
+                                                # presence is identity)
           digits.as(:number) >>
           # optional numeric part (dot or dash); must not swallow a year
           ((dot | dash) >> year_digits.absent? >> digits.as(:part)).maybe >>
@@ -814,7 +896,17 @@ module Pubid
           ((space >> month_name.as(:trailing_month) >> space >> year_digits.as(:trailing_year)) |
            (space >> month_numeric.as(:trailing_month) >> (space | dash) >> year_digits.as(:trailing_year))).maybe >>
           draft.maybe >>
+          # A print date may trail a draft that carries its own date
+          # ("IEEE Unapproved Draft 24765/D1 2009, Oct 2009" - the draft's
+          # year is "2009", the print date is ", Oct 2009").
+          (comma >> space? >> month_name.as(:trailing_month) >> space >>
+            year_digits.as(:trailing_year)).maybe >>
           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).
+          (comma >> space? >> month_name.as(:trailing_month) >> space >>
+            year_digits.as(:trailing_year)).maybe >>
           # Trailing corrigendum after the draft ("…/D2.0/Cor. 1", or
           # "…/D1.0, Dec 2007/Cor. 1" where the draft's own draft_date consumes
           # the date, leaving "/Cor. N"). The flat corrigendum+draft tree (no
@@ -899,10 +991,17 @@ module Pubid
           # Draft NESC pattern
           (str("Draft") >> space >> (str("NESC") | str("National Electrical Safety Code"))) |
           # Name-first pattern (NEW)
-          (str("National Electrical Safety Code") >> str(",") >> space >> str("C2-"))
+          (str("National Electrical Safety Code") >> str(",") >> space >> str("C2-")) |
+          # Catalogue form: "IEEE Std YYYY NESC ..." / "IEEE Std YYYY National
+          # Electrical Safety Code" - the prefix is consumed here (the NESC
+          # renderer prepends "IEEE Std" itself) but must not fall through to
+          # the generic standard grammar, which would read YYYY as a number.
+          (str("IEEE") >> space >> str("Std") >> space >> year_digits >> space >>
+            (str("NESC") | str("National Electrical Safety Code")))
         ).present? >>
           # Delegate to NESC parser if pattern detected
-          Nesc::Parser.new.nesc_identifier.as(:nesc)
+          ((str("IEEE") >> space >> str("Std") >> space).maybe >>
+            Nesc::Parser.new.nesc_identifier).as(:nesc)
       end
 
       # Draft notation for PSI (e.g., /D2, /D3, rawbib's /D-2)
@@ -1056,13 +1155,13 @@ module Pubid
           str("CSA") >> space >>
           # CSA number formats (various patterns observed)
           (
-            # Format 1: C22.2 No. 293.1-17 (with NO.)
-            (str("C") >> digit.repeat(2) >> dot >> digit >> space >> str("No") >> dot >> space >>
+            # Format 1: C22.2 No. 293.1-17 (with NO., either case)
+            (str("C") >> digit.repeat(2) >> dot >> digit >> space >> (str("No") | str("NO")) >> dot >> space >>
              match("[0-9.]").repeat(1) >> (dash | str(":")) >> digit.repeat(2)) |
             # Format 2: C293.2-17 (without NO., dash year)
             (str("C") >> match("[0-9.]").repeat(1) >> dash >> digit.repeat(2)) |
-            # Format 3: C22.2 No. 293.3:19 (with NO., colon year)
-            (str("C") >> digit.repeat(2) >> dot >> digit >> space >> str("No") >> dot >> space >>
+            # Format 3: C22.2 No. 293.3:19 (with NO., either case, colon year)
+            (str("C") >> digit.repeat(2) >> dot >> digit >> space >> (str("No") | str("NO")) >> dot >> space >>
              match("[0-9.]").repeat(1) >> str(":") >> digit.repeat(2)) |
             # Format 4: C293.4:19 (without NO., colon year)
             (str("C") >> match("[0-9.]").repeat(1) >> str(":") >> digit.repeat(2))
@@ -1085,6 +1184,8 @@ module Pubid
           conformance_identifier | # NEW: Try conformance identifier before generic patterns
           joint_development_ieee_format |
           joint_development_iso_format |
+          joint_development_iso_iec_edition | # stage-less ISO/IEC label with (E) - double-label portion
+
           joint_development_embedded_stage | # stage-LAST embedded form (before generic)
           iec_ieee_copublished |
           number_first_identifier |
@@ -1110,6 +1211,15 @@ module Pubid
           # never collides with the base -YYYY identity year (see
           # ieee_p_identifier). The builder promotes it only when no base year.
           trailing_month_year.maybe >>
+          # The ASHRAE joint suffix may also trail a draft+date
+          # ("IEEE P1635/D13, December, 2017/ASHRAE Guideline 21"), so a
+          # second slot catches it after the date.
+          ashrae_copub.maybe >>
+          # A bracketed narrative may sit between the base and a trailing
+          # corrigendum: "IEEE Std 671-1985 [Corrigendum to IEEE Std 671-1985
+          # (Reaff 2008)]/Cor. 1-2010" captures the bracket as the base's
+          # nickname before the wrapper is parsed.
+          book_nickname.maybe >>
           # Trailing corrigendum after the draft+date ("IEEE Approved P1015/D1,
           # Jan 2007/Cor. 1"): the generic bucket is the only path a status-word
           # form reaches. Routes via build_flat_corrigendum (disjoint from the
@@ -1333,9 +1443,12 @@ module Pubid
         # 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 …"
+        # 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}(-\d{4}(?:-\d\d)?)},
+          %r{\A#{pubs}#{num}/ ?#{stage}(-(?:19|20)\d\d(?:-\d\d)?)},
           '\1\3 \2\4',
         )
 

data/lib/pubid/ieee/renderer.rb

@@ -128,12 +128,20 @@ module Pubid
           parts << type_str unless type_str.strip.empty?
         end
 
-        # Code - with P prefix for projects (concatenated, not separated)
+        # Code - with P prefix for projects (concatenated, not separated).
+        # IEEE semantics (normative): P = project = the document is a
+        # draft; no P = it has become a standard. The P-state is
+        # identity-bearing, so the renderer never adds or drops it —
+        # whatever the source spelling carries round-trips.
         if id.code_obj
           result = id.code_obj.to_s
 
-          # Prepend P if this is a project AND code doesn't already have P
-          if id.typed_stage&.project_status && should_render_type && !result.start_with?("P")
+          # Prepend P if this is a project AND code doesn't already have P.
+          # A recorded project marker (the source spelled the P on a
+          # non-IEEE-led publisher) prints regardless of the publisher.
+          if (id.typed_stage&.project_status && should_render_type ||
+              id.is_a?(Identifiers::ProjectDraftIdentifier) &&
+              id.project_marker) && !result.start_with?("P")
             result = "P#{result}"
           end
 
@@ -142,6 +150,7 @@ module Pubid
           result += mark(id.code_obj.number, id.code_obj.prefix,
                          publishers: publishers_of(id))
 
+
           # Only attach year to code if there's no edition, no month, and no draft
           result += "-#{id.year}" if id.year && !id.draft_obj && !id.edition && !id.month
 
@@ -150,9 +159,29 @@ module Pubid
           # ("P802.16Rev2/D3"). Keeps a revision distinct from its base standard.
           result += "Rev#{id.revision}" if id.revision
 
-          # Append draft to code - with or without space based on original format
+          # Append draft to code - with or without space based on original
+          # format. An exactly-IEC/IEEE co-published reference prints only the
+          # draft DESIGNATOR - a comma-separated project date ("IEC/IEEE
+          # 61886-1/D2, May 2020" prints as "…/D2") is catalogue metadata, not
+          # identity. Wider sets ("IEC/ISO/IEEE P82079-1/D1, June 2016") print
+          # the date; a space-separated date always stays ("…/DCDV July 2015").
+          # IEEE-published drafts normalize the comma date to the long form
+          # ("D08, September, 2018").
           if id.draft_obj
-            result += id.space_before_draft ? " #{id.draft_obj}" : id.draft_obj.to_s
+            printed = id.draft_obj.to_s
+            if id.publisher == "IEC" && id.copublisher == ["IEEE"]
+              printed = printed.split(", ").first
+            elsif id.publisher == "IEEE" && id.draft_status.to_s.empty?
+              # The long comma form is for dated project drafts; an
+              # unapproved-draft render keeps its pinned single-comma form
+              # (pubid#318 idempotence).
+              printed = printed.sub(/, ([A-Z][a-z]+) (\d{4})\z/, ', \1, \2')
+            end
+            # A space-separated draft year with no print date trailing is
+            # IEEE's dash form ("…/D1-2006"); with a trailing print date the
+            # space stays ("…/D1 2004, Nov 2004").
+            printed = printed.sub(/\A(D\d+) (\d{4})\z/, '\1-\2')
+            result += id.space_before_draft ? " #{printed}" : printed
           end
 
           # Append interpretation notation (/INT)
@@ -190,8 +219,12 @@ module Pubid
         # Build the main identifier (without month yet)
         result = parts.join(" ")
 
-        # Month/Day - append directly to avoid extra space before comma
-        if id.month
+
+        # Month/Day - append directly to avoid extra space before comma.
+        # An exactly-IEC/IEEE co-published reference drops the comma date
+        # entirely (same catalogue-metadata rule as the draft date above):
+        # "IEC/IEEE P60076-16, May 2016" prints as "IEC/IEEE 60076-16".
+        if id.month && !(id.publisher == "IEC" && id.copublisher == ["IEEE"])
           result += ", #{id.month}"
           result += " #{id.day}" if id.day
           if id.year && !id.edition

data/lib/pubid/ieee/urn_generator.rb

@@ -127,6 +127,10 @@ module Pubid
       end
 
       def publisher_component
+        # The IEC/IEEE co-published pair is definitional to the class and
+        # was previously lost ("urn:ieee:ieee" — no number, no draft).
+        return "iec-ieee" if identifier.is_a?(Identifiers::IecIeeeCopublished)
+
         pub = normalized_publisher
 
         if identifier.copublisher&.any?
@@ -150,6 +154,14 @@ module Pubid
       end
 
       def type_component
+        # A joint stage draft carries the stage in its draft clause and the
+        # project P inside the code — a separate type segment would
+        # duplicate both.
+        if identifier.is_a?(Identifiers::JointDevelopment) &&
+           identifier.ieee_draft.to_s.start_with?("D=")
+          return nil
+        end
+
         return nil unless identifier.type
 
         type = identifier.type
@@ -159,6 +171,16 @@ module Pubid
       end
 
       def code_component
+        # The co-published code is number+parts+separators (no year — its
+        # own segment), e.g. "61886-1".
+        if identifier.is_a?(Identifiers::IecIeeeCopublished)
+          return nil if identifier.number.to_s.empty?
+
+          # Year-less: the publication year is its own URN segment (the
+          # rebuilt copublished_number would double-emit it).
+          return "#{identifier.number}#{identifier.parts_suffix}"
+        end
+
         return nil unless identifier.code_obj
 
         identifier.code_obj.to_s
@@ -182,6 +204,15 @@ module Pubid
       end
 
       def draft_component
+        if identifier.is_a?(Identifiers::JointDevelopment) &&
+           identifier.ieee_draft.to_s.start_with?("D=")
+          return "draft.#{identifier.ieee_draft}"
+        end
+
+        if identifier.is_a?(Identifiers::IecIeeeCopublished)
+          return identifier.draft_info ? "draft.#{identifier.draft_info}" : nil
+        end
+
         return nil unless identifier.draft_obj
 
         "draft.#{identifier.draft_obj}"

data/lib/pubid/ietf/CLAUDE.md

@@ -0,0 +1,7 @@
+# IETF flavor notes
+
+IETF readiness for the unified relaton index.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/ietf/` or `spec/pubid/ietf/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **IETF readiness for the unified relaton index (`relaton-data-ietf`)**: relaton is collapsing RFCs, the RFC sub-series (BCP/STD/FYI) and Internet-Drafts into **one** index keyed on the structured pubid hash (`pubid_class: ::Pubid::Ietf::Identifier`). That index is **all-or-nothing** — `Relaton::Index::FileIO#deserialize_id` raises on the *first* unparseable row and `#load_index` then rejects the whole index — so one bad id out of 176,862 means no consumer resolves *any* IETF reference. Four changes, all verified against the published corpora (`relaton-data-{rfcs,rfcsubseries,ids}`, branch `v2`). **(1) `draft_rest` accepts `.` and `A-Z`** (`match['a-zA-Z0-9+_.\-']`): exactly 50 of the 166,740 published draft ids failed without them (21 dotted `draft-ietf-pilc-2.5g3g-12`, 29 uppercase `draft-chapin-clnp-ISO8473-00`, 0 both), and a character census confirms the class now covers the corpus **exactly** — the only chars outside `[a-z0-9-]` anywhere in it are `. _ +` and `A-Z`. Widening is safe because the top-level alternation is keyed on the leading token (`RFC`/`BCP|STD|FYI`/`draft-`), so a wider draft tail can never make another branch match; `Builder#split_draft_version` needed no change (it inspects only the last three characters). The set stays **closed** — a space, `/` or `&` in a slug is crawler junk and still fails (pinned by negative examples). **(2) Zero-padded ids parse, grammar-level**: `rfc-index.xml` writes sub-series membership as `<is-also><doc-id>STD0066</doc-id></is-also>` (369 padded doc-ids) and RFCs as `RFC0001`, and relaton#109 forbids relaton normalizing them itself. The space is `.maybe` on both the `rfc` and `subseries` rules and `Builder#unpad` strips the pad (`/\A0+(?=\d)/`, a look-ahead so an all-zero number keeps its last digit), so `STD0066`/`STD 0066`/`STD66` all render the canonical `STD 66`. `unpad` is applied unconditionally, so the **spaced** padded form is normalized too — `RFC 0001` previously parsed and rendered back verbatim, and now renders `RFC 1` with a correspondingly changed hash and URN. That is deliberate (one canonical spelling per document) and has **zero** effect on the published corpora, which contain no padded row. **This is a normalizing parse, so the padded spellings must NEVER go into the byte-exact `spec/fixtures/ietf/identifiers/pass/`** — they live in `spec/pubid/ietf/zero_padded_spec.rb`, the BIPM `CIPM/2005-06(REV)` precedent. **(3) The Internet-Draft slug moved from `name` into `number`, and `series` became derived**: relaton bsearches on `id.root.number.to_s`, so with the slug in `name` all 166,740 drafts keyed to `""` and the narrowing bought nothing (with the slug: 43,564 buckets, median 2, worst 101). `name` is **dropped entirely** (no alias); the slug — leading `draft-` included — is the key, deliberately shared by a draft's unversioned aggregator row and every one of its versions so a document and its variants cluster. `series` is likewise **not stored**: `_type: pubid:ietf:std` already encodes it, so `Bcp`/`Std`/`Fyi` expose a `SERIES` constant + a plain `#series` reader (safe — `::Pubid::Identifier` declares no `series` attribute and nothing generic reads `.series`) and `build_subseries` stops passing it. The whole serialized vocabulary is now **three keys**: `_type` + `number` always, `version` only on a versioned draft — a sub-series row (`{_type, number}`) has the same shape as an RFC's. **The attributes live on the five LEAVES, not the shared `Pubid::Ietf::Identifier`**, via the `Identifiers::Serialization` mixin (`number` + the `key_value` block; `InternetDraft` merges its own `version` mapping on top — lutaml combines a mixin-installed block with a second in-class one, the ITU precedent). This is the IEEE `number` determinism landmine: a `:string` redefinition of the parent's `Components::Code number` on a class the leaves *inherit* from resolves nondeterministically under multi-flavor load. It was invisible while drafts left `number` nil; it is load-bearing now. The base deliberately carries **no** `key_value` block — one there would be inherited-and-merged by every leaf. `spec/pubid/ietf/root_number_spec.rb` is the tripwire (asserts `number` is a `String`, the exact keys, the exact `to_hash` key sets) and **must run under the full `rake` suite** to mean anything. **(4) Round-trip is validated here because relaton structurally cannot**: `FileIO#id_supported?` **skips** its `to_hash`/`from_hash` check whenever the object is a concrete subclass (`return true unless obj.instance_of?(@pubid_class)`), and *every* IETF id is a subclass — so a lossy round-trip would pass validation silently and produce wrong lookups. Three layers: `fixtures_spec.rb` is now **zero-failure** (was a 90% threshold — wrong for an all-or-nothing index) and checks `to_s` byte-exactness, `from_hash(to_hash)` fidelity in both `to_s` and `to_hash`, **and** a non-empty `root.number` for every fixture line; the fixtures grew to ~2,500 lines (the complete 365-row sub-series corpus, a 139-id structural edge set, a deterministic 1-in-84 draft sample — each file's header records the regeneration command); and `spec/pubid/ietf/corpus_round_trip_spec.rb` runs the same four checks over all 176,862 published ids, **opt-in** via `PUBID_IETF_CORPUS=<dir with the three relaton-data checkouts> bundle exec rake test:corpus_ietf` (self-skips otherwise; ~100s; verified 0 failures). **relaton note — the indexes must be regenerated, there is no alias**: `name` and `series` are gone as serialized keys, so a pre-`number` row (`{_type, name, version}`) deserializes with **`number` nil** and no error at all — lutaml ignores unknown keys, and relaton's subclass skip means `id_supported?` won't catch it either, leaving every draft keyed under `""`. Rendering is therefore the loud failure: `Renderer#require_number!` raises `ArgumentError` on a nil/empty `number` rather than returning `nil` or `"-02"`, and the renderer's sub-series arm is an explicit `when Bcp, Std, Fyi` with an `else raise` instead of a catch-all (a bare `Pubid::Ietf::Identifier` has no `series` reader). Pinned by the "legacy `name`-shaped hash" block in `root_number_spec.rb`. **Pre-existing bug fixed in passing**: `UrnParser`'s bare `Errors::ParseError` does not resolve — `Errors` lives under `Pubid::UrnParser` (the module), which is neither in the lexical scope of `Pubid::Ietf::UrnParser` nor an ancestor of `Base` — so an invalid URN raised `NameError` instead, and the spec's `raise_error(StandardError)` accepted it. Now fully qualified as `Pubid::UrnParser::Errors::ParseError` (the adobe/easc/gost/iala convention) with the spec asserting that exact class. **`Pubid::Iec::UrnParser` has the identical bug and is untouched here.** Also: `Identifier.parse` gained the inline `MAX_INPUT_LENGTH` guard — relaton reaches that class-level funnel directly through `pubid_class:`, bypassing `Pubid::Ietf.parse` — and IETF was added to the three cross-flavor tables it was missing from (`identifier_roundtrip_spec`, `uniform_identifier_handle_spec`, `redos_guard_spec`), which is what exercises the leaf `number` under real multi-flavor load. (hand-off: ietf-index-readiness.)

data/lib/pubid/ietf/builder.rb

@@ -76,3 +76,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Ietf::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/iho/builder.rb

@@ -35,3 +35,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Iho::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/isbn/builder.rb

@@ -42,3 +42,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Isbn::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/iso/CLAUDE.md

@@ -0,0 +1,47 @@
+# ISO flavor notes
+
+- **No identifier attribute holds a `Components::Code` any more**: `number`,
+  `part` and `subpart` on `Pubid::Iso::Identifier`, the committee structure on
+  `Identifiers::TcDocument` (`tc_type`/`tc_number`/`sc_type`/`sc_number`/
+  `wg_type`/`wg_number`), `Identifiers::Directives#subgroup` and the
+  `edition.number` the builder writes are all plain strings, and
+  `Pubid::Iso::Components::Code` is deleted.
+  **The component was degenerate everywhere it was used.** Measured over the
+  whole 7,613-id pass corpus: no ISO Code carries `prefix`, `part`, `subpart`
+  or `parts`, `parts` is never written anywhere in `lib/pubid/iso`, and no Code
+  renders differently from its own `value`. ISO's part and subpart are sibling
+  attributes of the identifier, not fields of the number — the `-` join in
+  `Code#to_s` was unreachable.
+  **`edition.number` was worse than degenerate: it leaked a live object.**
+  `Components::Edition#number` is typed `Lutaml::Model::Type::Value`, so lutaml
+  never serialized it — `to_hash` returned the `Components::Code` instance
+  itself, and `to_yaml` emitted `!ruby/object:Pubid::Components::Code` with its
+  internal ivars, which `YAML.safe_load` refuses. An edition now serializes
+  `{"number" => "13", "original_text" => "Ed 13"}`.
+  **The TC converters are gone with it**: twelve `*_to_kv`/`*_from_kv` helpers
+  were replaced by plain `map "tc_type", to: :tc_type` declarations (the
+  ETSI/OIML shape), because a String needs no converter to flatten.
+  **Two shared surfaces needed a change, and both are the documented shims**:
+  `Renderers::DirectivesRenderer` called `subgroup.render(context:)` directly
+  and now reads through `render_component`; `Pubid::Iso.build_code` returned a
+  Code and now returns the string (ASTM's `to_iso_identifier` goes through it,
+  which is how one ASTM example caught the `NameError` after the class was
+  deleted).
+  **Verification — replay a baseline, do not trust the suite alone.** Against
+  all 7,621 pass-fixture ids captured on the parent commit, `to_s`, `to_urn`,
+  `to_mr_string`, `root.number` and the identifier class are **byte-identical**,
+  and `to_hash` differs for exactly **12** ids: the 9 `subgroup` rows and the 3
+  editions below. The first replay also caught a real regression the specs did
+  not — `directives.rb` still called `part.value.downcase`, so 4 Directives
+  URNs raised.
+  **relaton note — `relaton-data-iso` needs a re-crawl, and only for one key.**
+  `subgroup` flattens from `{"value" => "JTC 1"}` to `"JTC 1"`, and the
+  published `index-v2.yaml` (branch `v2`) carries **5 such rows**, all ISO/IEC
+  JTC 1 directives. **No compatibility shim is kept** — a stored nested
+  `subgroup` will not deserialize. The edition change reaches nothing stored:
+  `grep -c edition` over that index returns **0**.
+  **Spec fallout is the shape to expect for the remaining flavors**: 592
+  assertions across 25 files read `.number.value` / `.part.value`. The rewrite
+  needs a lookbehind, because `tc_number.value` and `edition.number.value` are
+  different attributes — the first pass stripped `edition.number.value` too,
+  and two corrigendum examples caught it.