pubid 2.0.0.pre.alpha.27 → 2.0.0.pre.alpha.28

data/lib/pubid/ieee/aiee/builder.rb

@@ -38,9 +38,12 @@ module Pubid
 
           # Extract the long-form date separator ("," or ".") for rendering.
           # Named `date_separator` on the identifier to avoid colliding with the
-          # CodeNumber code-part `separator`.
+          # CodeNumber code-part `separator`. The dash-glued form ("-1928-05")
+          # carries no separator capture (its tail binds as the year/month
+          # clause itself), so a month without a separator capture IS the
+          # dash form.
           separator_str = extract_value(parsed[:separator])
-          attributes[:date_separator] = separator_str if separator_str
+          attributes[:date_separator] = separator_str || "-" if separator_str || month_str
 
           # Set original format based on parsed data
           attributes[:original_format] = if separator_str || month_str

data/lib/pubid/ieee/aiee/identifier.rb

@@ -59,20 +59,25 @@ module Pubid
           format ||= month || date_separator ? "long" : "short"
 
           if year
-            case format
-            when "short", :short
-              base += "-#{year}"
-            when "long", :long
-              sep = date_separator || "," # Default to comma for long form
-              base += "#{sep} #{"#{month} " if month}#{year}"
+            if date_separator == "-" && month
+              # The dash-glued numeric form renders whole ("No 15-1928-05")
+              base += "-#{year}-#{month}"
             else
-              base += if date_separator
-                        "#{date_separator} #{"#{month} " if month}#{year}"
-                      elsif month
-                        ", #{month} #{year}"
-                      else
-                        "-#{year}"
-                      end
+              case format
+              when "short", :short
+                base += "-#{year}"
+              when "long", :long
+                sep = date_separator || "," # Default to comma for long form
+                base += "#{sep} #{"#{month} " if month}#{year}"
+              else
+                base += if date_separator
+                          "#{date_separator} #{"#{month} " if month}#{year}"
+                        elsif month
+                          ", #{month} #{year}"
+                        else
+                          "-#{year}"
+                        end
+              end
             end
           end
 

data/lib/pubid/ieee/builder.rb

@@ -771,6 +771,11 @@ module Pubid
       def build_joint_development(parsed)
         attributes = {}
 
+        # The status-draft spelling ("IEEE Unapproved P15288/DFDIS") keeps
+        # its status word on the designator face (pubid#318: the word marks
+        # the draft).
+        attributes[:draft_status] = extract_value(parsed[:draft_status]) if parsed[:draft_status]
+
         # Extract publishers from joint_publishers
         if parsed[:joint_publishers]
           joint_pub_str = extract_value(parsed[:joint_publishers])
@@ -788,6 +793,17 @@ module Pubid
         # 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").
+        # A part whose whole value is an ISO/IEC stage token is the
+        # stage-last spelling ("29119.FDIS"), not a part: promote it to
+        # the stage slot (the #311 embedded rule covers "29119.4.FDIS";
+        # this covers the part-less form the shared part capture claims
+        # first).
+        if parsed[:iso_stage].nil? && parsed[:part] &&
+           extract_value(parsed[:part]).to_s.match?(/\A[._-]?(FDIS|FCD|CDV|DIS|CD\d?|WD|PWI|NP)\z/)
+          # the stage is the bare token; the capture carries its separator
+          parsed[:iso_stage] = extract_value(parsed[:part]).to_s.sub(/\A[._-]/, "")
+          parsed[:part] = nil
+        end
         code_parts = []
         if parsed[:part].nil? && parsed[:iso_stage].nil? && parsed[:draft_version] &&
            parsed[:printed_dash_year] && parsed[:year] &&
@@ -805,15 +821,23 @@ module Pubid
               "#{extract_value(parsed[:draft_version])}-#{extract_value(parsed[:year])}"
           end
         end
-        code_parts << extract_value(parsed[:part]) if parsed[:part]
+        # The part/subpart captures carry their printed separator
+        # (C1: the part binds before the draft status and the year,
+        # separator-in-capture), so they concatenate verbatim - a
+        # synthetic separator here is what produced "61850..9".
+        # The 8802-family IEC label binds its part with a dash the
+        # grammar consumes separately (iec_label_dash): "8802-9", not
+        # the dot join a bare part would get.
+        if parsed[:part] && parsed[:iec_label_dash]
+          code_parts << "-#{extract_value(parsed[:part])}"
+        elsif parsed[:part]
+          code_parts << extract_value(parsed[:part])
+        end
+        code_parts << extract_value(parsed[:subpart]) if parsed[:subpart]
 
         code_str = extract_value(parsed[:number])
         if code_str && !code_parts.empty?
-          # The ISO/IEC label's part may be dash-joined ("8802-9") - keep
-          # the printed separator (the iso-format route's :part_dash
-          # prints as a dot in the joint code).
-          sep = parsed[:iec_label_dash] ? "-" : "."
-          code_str += "#{sep}#{code_parts.join(sep)}"
+          code_str += code_parts.map { |p| p.to_s.start_with?(".", "-", "_") ? p : ".#{p}" }.join
         end
         # P = project (a draft): identity-bearing, preserved as spelled.
         code_str = "P#{code_str}" if parsed[:project_marker] && code_str
@@ -867,7 +891,34 @@ module Pubid
           draft_ver = extract_value(parsed[:draft_version])
           # Remove leading 'D' if present since draft_version already has it
           draft_ver = draft_ver.sub(/^D/, "") if draft_ver
-          attributes[:ieee_draft] = "D#{draft_ver}" if draft_ver
+          if draft_ver
+            # A date trailing the draft ("/D8, June 2010") belongs to the
+            # draft component (canonical month, comma form), and the
+            # identity year/month the earlier promotion filled from the
+            # same captures are vacated. Stage-first ISO rows are
+            # 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/}, "")
+              attributes.delete(:year) if parsed[:year].nil?
+              attributes.delete(:month) if parsed[:month].nil?
+            elsif parsed[:draft_year] && parsed[:iso_stage].nil?
+              # The artifact's comma-year tail captures its separator
+              # with the value (", 2015") — strip it (the #471
+              # separator-in-capture rule: every capture a renderer
+              # re-joins gets checked).
+              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?
+            else
+              attributes[:ieee_draft] = "D#{draft_ver}"
+            end
+          end
         end
 
         # The joint stage-draft clause (docs/IEEE-DRAFT-STAGES.md §1.3):
@@ -909,7 +960,9 @@ module Pubid
         # must not become a printed Standard (which keeps the code's P).
         numeric_draft = parsed[:draft_version] &&
                         extract_value(parsed[:draft_version]).to_s.match?(/\A\d/)
-        printed_joint = parsed[:iso_published] &&
+        # A promoted stage ("29119.FDIS") is printed identity - the joint
+        # model carries it, never the printed Standard face.
+        printed_joint = parsed[:iso_published] && parsed[:iso_stage].nil? &&
                         (parsed[:printed_dash_year] || parsed[:printed_month_year] ||
                          (numeric_draft && parsed[:draft_month]) ||
                          # A date-less stage-less joint reference carrying only a
@@ -919,9 +972,18 @@ module Pubid
                          (parsed[:year].nil? && parsed[:parameters].is_a?(Hash) &&
                           parsed[:parameters][:parenthetical_content]))
         if printed_joint
-          sep = parsed[:part_dash] ? "-" : "."
-          printed_code = [extract_value(parsed[:number]),
-                          extract_value(parsed[:part])].compact.join(sep)
+          # The part capture carries its own separator (C1
+          # separator-in-capture); join verbatim, synthesizing one only
+          # for a bare capture.
+          part_val = extract_value(parsed[:part])
+          printed_code = extract_value(parsed[:number]).to_s
+          if part_val
+            printed_code += if part_val.start_with?(".", "-", "_")
+                              part_val
+                            else
+                              "#{parsed[:part_dash] ? "-" : "."}#{part_val}"
+                            end
+          end
           # P = project: the marker is identity, preserved as spelled.
           printed_code = "P#{printed_code}" if parsed[:project_marker]
           printed_attrs = { publisher: attributes[:publisher],
@@ -1049,6 +1111,24 @@ module Pubid
             Pubid::Ieee.locate_stage("P")
         end
 
+        # A plain IEEE-designator draft on joint publishers ("/D8,
+        # June 2010") carries no ISO stage machinery: it is the same
+        # document family as its bare-IEEE twin and the D= designator
+        # rows, so it builds as the project draft they pin (pubid#430)
+        # rather than the joint-development model.
+        if attributes[:draft] && parsed[:iso_stage].nil? &&
+           parsed[:iec_stage].nil? && parsed[:amd_number].nil?
+          draft_attrs = { code: attributes[:code],
+                          draft: attributes[:draft] }
+          if attributes[:publishers]
+            draft_attrs[:publisher] = attributes[:publishers].first
+            rest = attributes[:publishers][1..]
+            draft_attrs[:copublisher] = rest if rest
+          end
+          draft_attrs[:draft_status] = attributes[:draft_status] if attributes[:draft_status]
+          return Identifiers::ProjectDraftIdentifier.new(**draft_attrs)
+        end
+
         joint = Identifiers::JointDevelopment.new(**attributes)
 
         # Amendment tail on the joint ISO-format form (pubid#317:
@@ -1322,6 +1402,11 @@ module Pubid
         # standards ("IEEE No148" prints "IEEE Std 148").
         type_value = "Std" if type_value&.match?(/\ANo\.?\z/) &&
                                original_input.to_s.match?(/\AIEEE\s/)
+        # The canonical type word is the short form (C2 ruling):
+        # "IEEE Standard 495-2007" and "IEEE Std 495-2007" are the same
+        # identifier, so the model normalizes to Std and matches? unifies
+        # the spellings; the long word is a render option (:long).
+        type_value = "Std" if type_value == "Standard"
         draft_status_value = extract_value(parsed[:draft_status])
 
         # Handle case where parser captured number without "P" prefix
@@ -1335,6 +1420,10 @@ module Pubid
         if !type_value && original_input&.match?(/ANSI\s+P/)
           # Extract P as type since it was in the original but parser stripped it
           type_value = "P"
+          # The P is identity on a non-IEEE-led publisher too (the C1
+          # ruling): record the marker so the render prepends it —
+          # "ANSI PN42.34/D9a, 2015" round-trips.
+          attributes[:project_marker] = true
         end
 
         # NOTE: "P" is a project/draft stage indicator, NOT a code prefix
@@ -1388,6 +1477,15 @@ module Pubid
         if parsed[:year]
           year_str = extract_value(parsed[:year])
           attributes[:year] = year_str
+          # AIEE dash-glued date ("No 15-1928-05"): the tail binds as the
+          # year/month clause with no separator capture, and the AIEE
+          # long-form render is the dash form (a plain numeric month alone
+          # would render ", 05 1928").
+          if attributes[:publisher] == "AIEE" &&
+             original_input.to_s.match?(/-\d{4}(?:-\d{2})?\z/) &&
+             parsed[:month] && year_str.match?(/\A(19|20)\d\d\z/)
+            attributes[:date_separator] = "-"
+          end
         elsif parsed[:edition_year]
           # The `edition` rule captures its own year under :edition_year (not
           # :year) so it never collides with the base -YYYY (see parser.rb).
@@ -1418,7 +1516,13 @@ module Pubid
         # Set type attribute for backward compatibility (after P extraction)
         # NOTE: "P" IS a type code that maps to ProjectDraftIdentifier via flavor module
         # Type can be: "Std", "No", "P" (project draft), etc.
-        attributes[:type] = type_value if type_value
+        # A DRAFT type word never reaches the hash: the draft-ness is
+        # carried by draft_status and the draft component (the C2 ruling
+        # - a draft is a Draft, "Draft Std" is banned from canonical
+        # output), so an alias spelling and its canonical hash equal.
+        # The value still feeds determine_stage_abbr below (the
+        # version-less D1 fabrication, pubid#318).
+        attributes[:type] = type_value if type_value && type_value !~ /\ADraft/
 
         # Lookup typed_stage from registry
         typed_stage_abbr = determine_stage_abbr(type_value, draft_status_value,
@@ -1638,6 +1742,17 @@ module Pubid
             # Normalize a leading hyphen ("/D-3.0" -> "3.0"); the draft
             # designator is otherwise held verbatim so no digit is lost.
             version = version.sub(/\A-/, "") if version
+
+            # FDIS/CDV/… are ISO/IEC stage tokens, not draft ordinals (C1
+            # ruling, testsuite#2). "/DDIS" and "/DFDIS" are hallucinated
+            # concatenations — the designator D does not merge onto a
+            # stage word, and IEEE speak has no such token. The draft of
+            # a stage rides the iso_stage slot, which Draft#to_s renders
+            # as the D= designator face ("…/D=DIS-2020").
+            if version.match?(/\A(FDIS|FCD|CDV|DIS|CD|WD|PWI|NP)\z/)
+              iso_stage = version
+              version = nil
+            end
           end
 
           # The PARG capture carries its separator (".12", the #471
@@ -1649,7 +1764,7 @@ module Pubid
 
           # The compound both-systems form (docs/IEEE-DRAFT-STAGES.md
           # §1.3): the stage half of "=DDIS.3".
-          iso_stage = extract_value(draft_data[:draft_iso_stage]) if draft_data[:draft_iso_stage]
+          iso_stage ||= extract_value(draft_data[:draft_iso_stage]) if draft_data[:draft_iso_stage]
           iso_iteration = extract_value(draft_data[:draft_iso_iteration]) if draft_data[:draft_iso_iteration]
 
           # Extract date information from draft data
@@ -1674,9 +1789,12 @@ module Pubid
           version = extract_value(draft_data)
         end
 
+        # A stage-token draft's month rides the D= designator zero-padded
+        # ("-202007", the pubid#203 convention) — it must not drop.
+
         # Create Draft component object if we have version info (or a
         # compound stage half without an ordinal, "D=CDV:2020")
-        if version || draft_data.is_a?(Hash) && draft_data[:draft_iso_stage]
+        if version || iso_stage || draft_data.is_a?(Hash) && draft_data[:draft_iso_stage]
           draft_obj = Components::Draft.new(
             version: version,
             revision: revision,

data/lib/pubid/ieee/components/draft.rb

@@ -44,7 +44,11 @@ day: nil, iso_stage: nil, iso_iteration: nil)
           self.version = version
           self.revision = revision
           self.year = year
-          self.original_month = month # Store original format
+          # The canonical month form is the IEEE crawl abbreviation
+          # (C2 ruling: "Aug 2007" and "August 2007" are the same
+          # document, so the model normalizes and matches? unifies the
+          # spellings; the long face spells the name back out).
+          self.original_month = month && CANONICAL_ABBREVIATIONS[month.sub(/\.\z/, "")] || month
           self.month = convert_month(month)
           self.day = day
           # The grammar's ordered alternation captures the stage WITH its
@@ -58,6 +62,16 @@ day: nil, iso_stage: nil, iso_iteration: nil)
           self.iso_iteration = iso_iteration
         end
 
+        # Canonical month spelling: the crawl abbreviation. Full names
+        # normalize onto these ("August" → "Aug"); "September" keeps its
+        # IEEE "Sept" form, so the 3-letter "Sep" folds onto it too.
+        CANONICAL_ABBREVIATIONS = {
+          "January" => "Jan", "February" => "Feb", "March" => "Mar",
+          "April" => "Apr", "June" => "Jun", "July" => "Jul",
+          "August" => "Aug", "September" => "Sept", "October" => "Oct",
+          "November" => "Nov", "December" => "Dec", "Sep" => "Sept",
+        }.freeze
+
         # Month names as an alternation, longest-first so "September" wins over
         # "Sep"; each may carry a trailing period ("Sept."). Used to split a
         # rendered draft's trailing date back out.
@@ -67,7 +81,7 @@ day: nil, iso_stage: nil, iso_iteration: nil)
         private_constant :MONTH_ALTERNATION
 
         DATE_SUFFIX =
-          /(?:(, | )(#{MONTH_ALTERNATION})(?: (\d{1,2}))?(?:, | )| )((?:19|20)\d{2}[a-z]{0,2})\z/
+          /(?:(, | )(#{MONTH_ALTERNATION})(?: (\d{1,2}))?(?:, | )|, | )((?:19|20)\d{2}[a-z]{0,2})\z/
         private_constant :DATE_SUFFIX
 
         # Parse a rendered draft such as "/D3", "/D3.4", "/D7 Jul 2019", or a
@@ -151,6 +165,15 @@ day: nil, iso_stage: nil, iso_iteration: nil)
                     end if revision
 
           if year
+            if iso_stage
+              # The D= designator face dash-joins its date in IEEE's
+              # convention: the year, and a draft month rides the
+              # designator zero-padded ("D=FDIS-201008", pubid#203).
+              result += "-#{year}"
+              result += format("%02d", month.to_i) if month
+              return result
+            end
+
             # Use original month format to preserve abbreviated vs full names
             display_month = original_month
 
@@ -173,7 +196,10 @@ day: nil, iso_stage: nil, iso_iteration: nil)
                           ", #{year}"
                         end
             else
-              result += " #{year}"
+              # The year-only date joins with its comma - the grammar's
+              # comma-year draft tail (pubid-grammar 17244fc) - so the
+              # render re-parses through the same clause.
+              result += ", #{year}"
             end
           end
 

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

@@ -159,8 +159,13 @@ module Pubid
 
           # The P project marker is identity-bearing and prints on both
           # faces (the standing trademark_leaf_to_s_spec contract:
-          # "ISO/IEC/IEEE P26511:2018").
+          # "ISO/IEC/IEEE P26511:2018"). A P-prefixed joint project
+          # prints its parts dot-joined on the ISO face ("ISO/IEEE DIS
+          # P11073.10418", #216); a plain ISO/IEC number keeps the
+          # printed separator ("IEC/IEEE FDIS 60079-30-2", "ISO/IEC
+          # 8802-3").
           code_str = code.to_s
+          code_str = code_str.tr("-", ".") if code_str.start_with?("P")
           code_str += mark unless code_str.empty?
           parts << code_str if code_str && !code_str.empty?
 
@@ -200,6 +205,9 @@ module Pubid
           # Publishers (slash-separated)
           parts << publishers.join("/") if publishers && !publishers.empty?
 
+          # A status word ("Unapproved") marks the draft (pubid#318)
+          parts << draft_status if draft_status
+
           # Build code part — the P-state prints as spelled (P = project
           # draft; no P = standard). Never added or stripped.
           code_str = code.to_s
@@ -230,7 +238,8 @@ module Pubid
             # ("D=CD.2" — docs/IEEE-DRAFT-STAGES.md §1.3).
             stage = iso_stage.match(/\A([A-Z]+?)(\d+)\z/)
             code_str += stage ? "/D=#{stage[1]}.#{stage[2]}" : "/D=#{iso_stage}"
-          elsif typed_stage&.ieee_draft_equivalent
+          elsif typed_stage&.ieee_draft_equivalent &&
+                !code_str.start_with?(typed_stage.ieee_draft_equivalent)
             code_str += "/#{typed_stage.ieee_draft_equivalent}"
           end
 

data/lib/pubid/ieee/long_renderer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    # The long face (C2 ruling): one uniform format dimension for every
+    # IEEE identifier. Expands the type words an identifier actually
+    # carries — Std → Standard on a published standard — and spells
+    # draft months out ("August 2007"). A draft carries no Std/Standard
+    # word, so both faces render `Draft`; there are no draft-specific
+    # render rules.
+    class LongRenderer < Renderer
+      def render(context: nil, **opts)
+        @long = true
+        super
+      end
+    end
+  end
+end

data/lib/pubid/ieee/renderer.rb

@@ -24,7 +24,29 @@ module Pubid
         # (Pubid::Identifier#render), so the flag is safe as instance state.
         @trademark = opts[:trademark]
 
-        render_id(@id)
+        result = render_id(@id)
+        # The long face spells draft months out ("Aug" → "August") over the
+        # bounded identifier — no title prose is ever in the string.
+        result = expand_months(result) if @long
+        result
+      end
+
+      # The long-form month names, longest key first ("Sept" before "Sep").
+      LONG_MONTHS = {
+        "Sept" => "September", "Jan" => "January", "Feb" => "February",
+        "Mar" => "March", "Apr" => "April", "Jun" => "June",
+        "Jul" => "July", "Aug" => "August", "Sep" => "September",
+        "Oct" => "October", "Nov" => "November", "Dec" => "December",
+      }.freeze
+      private_constant :LONG_MONTHS
+
+      # Expand abbreviated draft months to their long names (\b-bounded, so
+      # only whole month tokens move).
+      def expand_months(str)
+        LONG_MONTHS.each do |abbr, full|
+          str = str.gsub(/\b#{abbr}\b/, full)
+        end
+        str
       end
 
       private
@@ -125,6 +147,15 @@ module Pubid
             !id.draft_status.to_s.match?(/unapproved/i)
           type_str = id.type.dup
           type_str = type_str.sub(/^P/, "") if type_str.start_with?("P")
+          # A draft carries the word Draft alone in every face (the C2
+          # ruling): Std/Standard never renders on a draft, whatever
+          # spelling the source used — a status-less draft ("IEEE Draft
+          # Std P802.3/D2.0") renders "IEEE Draft P802.3/D2.0".
+          type_str = "Draft" if id.draft_obj && !id.draft_status
+          # The long face expands the type word ("IEEE Standard 495-2007");
+          # a draft never takes Std/Standard in any face, so the expansion
+          # only ever sees the published word.
+          type_str = "Standard" if @long && type_str == "Std"
           parts << type_str unless type_str.strip.empty?
         end
 
@@ -151,8 +182,14 @@ module Pubid
                          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
+          # A base year dash-attaches to the code when nothing else
+          # carries it: no edition, no identity-month date - and either
+          # no draft at all, or a draft that carries its OWN date (the
+          # draft+corrigendum family: "PC37.09-1999/D7.2, Nov 2006" -
+          # the 1999 is the base's year, the Nov 2006 the draft's).
+          year_on_code = id.year && !id.edition && !id.month &&
+                         (!id.draft_obj || id.draft_obj&.year)
+          result += "-#{id.year}" if year_on_code
 
           # Append the numbered/lettered revision inline, in IEEE's native
           # position — right after the code number and before the draft
@@ -232,6 +269,14 @@ module Pubid
           if id.year && !id.edition
             result += " #{id.year}"
           end
+        elsif id.year && id.draft_obj && !id.edition && !year_on_code &&
+              !(id.publisher == "IEC" && id.copublisher == ["IEEE"])
+          # A year-only date trailing the draft ("ANSI N42.34/D9a,
+          # 2015") keeps its comma form - the grammar's comma-year
+          # draft tail - instead of being silently dropped. A year
+          # that dash-attached to the code above (the base year of a
+          # dated-draft family) does not repeat here.
+          result += ", #{id.year}"
         end
 
         # Bounded parenthetical markers only. The unbounded relationship/

data/lib/pubid/ieee.rb

@@ -21,6 +21,7 @@ module Pubid
     autoload :PreParser, "#{__dir__}/ieee/pre_parser"
     autoload :Compaction, "#{__dir__}/ieee/compaction"
     autoload :ProjectRenderer, "#{__dir__}/ieee/project_renderer"
+    autoload :LongRenderer, "#{__dir__}/ieee/long_renderer"
     autoload :Renderer, "#{__dir__}/ieee/renderer"
     autoload :TypedStages, "#{__dir__}/ieee/typed_stages"
     autoload :UrnGenerator, "#{__dir__}/ieee/urn_generator"
@@ -164,3 +165,4 @@ Pubid::Registry.register(:ieee, Pubid::Ieee)
 Pubid::Ieee::Identifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
 Pubid::Ieee::Identifier.format_registry.register(:human, renderer: Pubid::Ieee::Renderer)
 Pubid::Ieee::Identifier.format_registry.register(:project, renderer: Pubid::Ieee::ProjectRenderer)
+Pubid::Ieee::Identifier.format_registry.register(:long, renderer: Pubid::Ieee::LongRenderer)

data/lib/pubid/nist/components/edition.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "date"
 require "lutaml/model"
 
 module Pubid
@@ -81,6 +82,10 @@ module Pubid
               # For letter suffixes, append uppercase letter directly: " r5A" or "r5A"
               if additional_text.match?(/^[A-Za-z]$/)
                 result += additional_text.upcase
+              elsif additional_text.match?(/\Ar\d+\z/)
+                # A revision marker rides attached ("e2001r3"), the 1.x
+                # corpus form
+                result += additional_text
               else
                 # For other additional text (years, etc.), use dot separator
                 result += ".#{additional_text}"
@@ -106,6 +111,10 @@ module Pubid
             # Use UPPERCASE for consistency: "r5A" for SP patterns like 800-53r5a
             elsif additional_text.match?(/^[A-Za-z]$/)
               result += additional_text.upcase # Normalize to UPPERCASE: r5A
+            elsif additional_text.match?(/\Ar\d+\z/)
+              # A revision marker rides attached ("e2001r3"), the 1.x
+              # corpus form
+              result += additional_text
             else
               # For ALL years (2-digit or 4-digit) and month+year, use DOT separator
               # Examples: e2.50, e2.1915, e2.June1908
@@ -119,8 +128,20 @@ module Pubid
         # Build long format: "Edition 2021", "Revision 5", etc.
         def build_long_format
           case type
+          # An edition date renders as the parenthesised date
+          # ("1000e2021" long: "... (2021)", "ABCe20130101" long:
+          # "... (January 01, 2013)"), the 1.x corpus form; a numbered
+          # edition keeps its worded form ("Edition 2")
           when "e"
-            "Edition #{id}"
+            case id.to_s
+            when /\A\d{4}\z/ then "(#{id})"
+            when /\A(\d{4})(\d{2})(\d{2})\z/
+              "(#{::Date.new(Regexp.last_match[1].to_i,
+                             Regexp.last_match[2].to_i,
+                             Regexp.last_match[3].to_i)
+                   .strftime('%B %d, %Y')})"
+            else "Edition #{id}"
+            end
           when "r"
             "Revision #{id}"
           when "-"

data/lib/pubid/nist/components/translation.rb

@@ -31,11 +31,13 @@ module Pubid
 
           case format
           when :short, :long
-            " #{code}"
+            # 1.x corpus shape: the trailing parenthesised suffix
+            # "(en)" (pubid#497), not a leading segment.
+            "(#{code})"
           when :mr
             ".#{code}"
           else
-            " #{code}"
+            "(#{code})"
           end
         end
       end