pubid 2.0.0.pre.alpha.27 → 2.0.0.pre.alpha.29

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

@@ -511,8 +511,15 @@ module Pubid
       # @param parsed_hash [Hash] parsed data with base and supplement info
       # @return [Identifiers::Corrigendum] corrigendum identifier
       def build_corrigendum_supplement(parsed_hash)
+        # The `corrigendum_identifier` rule's :base subtree binds as a
+        # top-level sequence (an Array of capture hashes — the same shape
+        # #build's dispatch merges at line 24) whenever the base carries a
+        # multi-capture narrative tail; fold it before reconstruction or
+        # reconstruct_base_string's Hash indexing crashes with TypeError.
+        base_data = parsed_hash[:base]
+        base_data = merge_parsed_array(base_data) if base_data.is_a?(Array)
         # Recursively parse the base identifier reconstructed from the subtree.
-        base = Identifier.parse(reconstruct_base_string(parsed_hash[:base]))
+        base = Identifier.parse(reconstruct_base_string(base_data))
 
         # Extract corrigendum attributes (parse-tree keys are cor_*; the
         # identifier stores them as the uniform `number`/`year`).
@@ -771,6 +778,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 +800,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 +828,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
@@ -849,6 +880,10 @@ module Pubid
         end
         attributes[:parenthetical_content] ||= extract_value(parsed[:edition_marker]) if parsed[:edition_marker]
 
+        # A joint ISO-print redline is a distinct document of the same
+        # standard — same flag semantics as the generic path (pubid#215).
+        attributes[:redline] = true if parsed[:redline]
+
         # Extract edition, from relaton's "/E-<n>" suffix. The grammar's /E
         # alternative captures the bare ordinal (nil-residue hand-off item 1).
         if parsed[:edition]
@@ -867,7 +902,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 +971,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 +983,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 +1122,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 +1413,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 +1431,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 +1488,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 +1527,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,
@@ -1485,9 +1600,29 @@ module Pubid
         # Redline
         attributes[:redline] = true if parsed[:redline]
 
+        mark_glued_month(attributes)
         attributes
       end
 
+      # Glued identity year-month provenance (pubid#517): when the input's
+      # tail is the glued "-YYYY-MM" and the identity carries no draft or
+      # revision suffix, the month belongs to the code's date clause
+      # ("ANSI/IEEE 21-1976-11", "IEEE Std PC2-2016-01") and the renderer
+      # reproduces the glued face. The same month/year attribute shape is
+      # produced by trailing print dates (", 05 2014" — whose numeric form
+      # is its own documented law) and by dash-promoted draft tails
+      # ("/R-x-2011-04"), both of which keep the comma face: the input
+      # shape, checked here at the single choke point every assignment
+      # path converges to, is what distinguishes them (the AIEE
+      # date_separator precedent).
+      def mark_glued_month(attributes)
+        return unless attributes[:month] && attributes[:year] &&
+                      attributes[:draft].nil? && attributes[:revision].nil? &&
+                      original_input.to_s.match?(/-\d{4}-\d{2}\z/)
+
+        attributes[:month_glued] = true
+      end
+
       # Determine stage abbreviation for TYPED_STAGE lookup
       # @param type_value [String] the type value (e.g., "Std", "P")
       # @param draft_status_value [String] the draft status (e.g., "Unapproved")
@@ -1638,6 +1773,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 +1795,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 +1820,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/base.rb

@@ -38,6 +38,12 @@ module Pubid
       attribute :revision, :string
       attribute :edition, :string                         # Edition 1.0
       attribute :month, :string
+      # Provenance flag (pubid#517): the month arrived glued to the identity
+      # year on the code ("ANSI/IEEE 21-1976-11", grammar
+      # date_with_month_numeric) rather than as a trailing ", 11 1976"
+      # print date. Serialization round-trips it so to_s reproduces the
+      # glued face.
+      attribute :month_glued, :boolean, default: -> { false }
       attribute :day, :string
       attribute :redline, :boolean, default: -> { false }
       attribute :amendments, Identifier, collection: true # Amendment identifiers
@@ -235,6 +241,7 @@ module Pubid
           Identifiers::Nesc::Draft,
           Identifiers::Nesc::Edition,
           Identifiers::Nesc::Handbook,
+          Identifiers::Nesc::Preprint,
           Identifiers::Nesc::Redline,
           Identifiers::Nesc::Standard,
         ]

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?
 
@@ -172,6 +177,9 @@ module Pubid
           if parenthetical_content&.match?(%r{\A[A-Z](?:\s*[/&]\s*[A-Z])*\z})
             result += " (#{parenthetical_content})"
           end
+          # The redline marker is identity — the joint ISO print spells it
+          # with the space-dash form ("15289:2015(E) - Redline", pubid#215).
+          result += " - Redline" if redline
 
           result
         end
@@ -200,6 +208,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 +241,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
 
@@ -241,6 +253,7 @@ module Pubid
           result = parts.join(" ")
           result += "-#{year}" if year && !@designator_carries_year &&
                            !ieee_draft.to_s.end_with?("-#{year}")
+          result += " - Redline" if redline
 
           result
         end

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

@@ -79,7 +79,7 @@ module Pubid
           #
           # @return [Boolean]
           def draft?
-            is_a?(Nesc::Draft)
+            is_a?(Nesc::Draft) || is_a?(Nesc::Preprint)
           end
 
           # Rendering for year-first NESC identifiers (the C2-code standard form

data/lib/pubid/ieee/identifiers/nesc/preprint.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      module Nesc
+        # Preprint NESC identifier — the draft stage preceding a C2 edition.
+        # "Preprint" is a draft stage (the NESC's own terminology for its
+        # pre-edition drafts), not a variant marker: the document IS a draft
+        # of the C2 code, distinct from the published edition.
+        #
+        # @example
+        #   nesc = Pubid::Ieee.parse("IEEE Std C2.2012.Preprint")
+        #   nesc.to_s  # => "IEEE Std C2.2012.Preprint"
+        class Preprint < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-preprint"
+          end
+
+          def draft?
+            true
+          end
+
+          # Render preprint identifier. The canonical spelling is dotted
+          # (C2.2012.Preprint); the dash spelling is a non-normalized alias.
+          #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
+          # @return [String] IEEE Std C2.YYYY.Preprint
+          def to_s(trademark: false, **opts)
+            body = ["C2", year, "Preprint"].compact.join(".")
+            result = ["IEEE Std", body].join(" ")
+            result += trademark_symbol if trademark
+            annotate_plain_render(result, **opts)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,7 @@ module Pubid
         autoload :Draft, "#{__dir__}/nesc/draft"
         autoload :Edition, "#{__dir__}/nesc/edition"
         autoload :Handbook, "#{__dir__}/nesc/handbook"
+        autoload :Preprint, "#{__dir__}/nesc/preprint"
         autoload :Redline, "#{__dir__}/nesc/redline"
         autoload :Standard, "#{__dir__}/nesc/standard"
       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/nesc/builder.rb

@@ -88,6 +88,11 @@ module Pubid
         # @param parsed_hash [Hash] Parsed attributes
         # @return [Class] Identifier class to instantiate
         def determine_identifier_class(parsed_hash)
+          # Preprint — a draft STAGE of the C2 code (checked before the
+          # Standard route below: the c2-preprint tree carries :code "C2"
+          # too, and the verbose proposal forms carry none).
+          return Identifiers::Nesc::Preprint if parsed_hash[:preprint]
+
           # Draft identifiers
           return Identifiers::Nesc::Draft if parsed_hash[:draft]
 

data/lib/pubid/ieee/parser.rb

@@ -735,10 +735,19 @@ module Pubid
           (slash >> str("Amd") >> (dot | space).maybe >>
            digits.as(:amd_number) >>
            ((str(":") | dash) >> year_digits.as(:amd_year)).maybe).maybe >>
+          # Optional corrigendum tail, the ISO print's dotted spelling
+          # (pubid#215): "8802-1AC:2018/Cor.1:2020(E)". The shared
+          # corrigendum rule accepts the slash/dot/colon separators; the
+          # flat tree routes through build_flat_corrigendum.
+          corrigendum.maybe >>
           # Optional edition, from relaton's "/E-<n>" suffix normalized to
           # "Edition <n>.0[ YYYY]" (nil-residue hand-off item 1).
           edition.maybe >>
           revision_suffix.maybe >>
+          # A redline is a distinct document of the joint ISO print
+          # (pubid#215): "15289:2015(E) - Redline". Same flag semantics as
+          # the generic rules - the builder sets redline: true.
+          redline.maybe >>
           # Published joint docs print a language marker, after either the
           # year or the amendment tail: "9945:2009(E)", "...Amd.1:2014(E)".
           # The crawl sometimes spaces it ("…(E), January 2017" family,
@@ -1465,10 +1474,6 @@ module Pubid
           cleaned = "IEEE P#{cleaned}"
         end
 
-        # Part D: Suffix Normalization
-        # 5. "/Preprint" -> remove (data quality - not standard suffix)
-        cleaned = cleaned.gsub(/\/Preprint\b/, "")
-
         # Part E: Relationship Text Normalization
         # 6. "Proposed Revision of" -> "Revision of"
         cleaned = cleaned.gsub("Proposed Revision of", "Revision of")