pubid 2.0.0.pre.alpha.11 → 2.0.0.pre.alpha.13

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

@@ -19,6 +19,8 @@ module Pubid
       # - Approved Draft: Board-approved but unpublished (D7-D9)
       # - Published: Final standards (no P prefix)
       class TypedStage < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         # All recognized abbreviations for this stage
         # First in array is canonical abbreviation
         attribute :abbr, :string, collection: true

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/identifiers/si_standard.rb

@@ -30,8 +30,11 @@ module Pubid
         # Format: "IEEE/ASTM SI 10-1997" (published)
         #     or: "IEEE/ASTM PSI 10/D2, October 2015" (draft)
 
-        # Use proper Draft component (Lutaml::Model object)
-        attr_accessor :draft_obj
+        # NOTE: no `attr_accessor :draft_obj` here — it would shadow the
+        # base's lazy `draft_obj` reader (base.rb), which rebuilds the
+        # component from the `draft` attribute after from_hash. The plain
+        # accessor made every deserialized PSI draft render (and re-emit
+        # in to_hash) without its "/D<n>".
       end
     end
   end

data/lib/pubid/ieee/ire/parser.rb

@@ -73,7 +73,7 @@ module Pubid
         end
 
         # Complete IRE identifier - YEAR FIRST format
-        rule(:ire_identifier) do
+        rule(:ire_identifier_year_first) do
           # Format: "52 IRE 7.S2" or "1952 IRE 7.S2"
           year.as(:year) >>
             space >>
@@ -84,6 +84,24 @@ module Pubid
             (space? >> (dash | str(",")).maybe >> space? >> year_full.as(:full_year)).maybe
         end
 
+        # Prefix-first format: "IRE 7.S2-1952" (pubid#316 family 2) — the
+        # year trails the designation instead of leading the identifier.
+        # The renderer always emits the year-first short-year form, so this
+        # spelling canonicalizes onto it ("IRE 7.S2-1952" → "52 IRE 7.S2").
+        rule(:ire_identifier_prefix_first) do
+          ire_prefix >>
+            space >>
+            (ire_type >> space).maybe >>
+            number >>
+            date
+        end
+
+        # Year-first is tried first so the original spellings keep their
+        # match; prefix-first claims only what year-first cannot.
+        rule(:ire_identifier) do
+          ire_identifier_year_first | ire_identifier_prefix_first
+        end
+
         root(:ire_identifier)
       end
     end