pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

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

@@ -6,379 +6,586 @@ module Pubid
       # Forward declare component classes
     end
 
-    # Base class for all IEEE identifiers. Canonical name
-    # Pubid::Ieee::Identifier. IEEE
-    # builds its identifiers as instances of this class directly.
-    class Identifier < ::Pubid::Identifier
-      # Generate URN for this identifier
-      #
-      # @return [String] URN representation
-
-      attribute :publisher, :string, default: -> { "IEEE" }
-      attribute :copublisher, :string, collection: true # IEC, ISO, ANSI, etc.
-      # NB: there is deliberately NO `attribute :code`. IEEE's document code is
-      # serialized as the split index columns (number/prefix/parts/separator) on
-      # concrete leaf types via the CodeNumber mixin; `code`/`code_obj` remain a
-      # runtime-only representation (built in #initialize, read by the renderer).
-      # This holds for every IEEE type, including the historical AIEE/IRE and
-      # the NESC family: all three used to descend from
-      # Lutaml::Model::Serializable with their own `attribute :code`, and were
-      # reparented onto this base (with the CodeNumber mixin on their leaves).
-      attribute :year, :string
-      attribute :type, :string, default: -> { "Std" } # Std, Draft Std
-      attribute :draft_status, :string                    # Unapproved, Approved, Active Unapproved
-      attribute :draft, :string                           # Will store draft as object
-      # Numbered/lettered revision id, e.g. "2" for "P802.16Rev2", "i" for the
-      # relaton suffix "/R-i". IEEE's native inline "Rev<n>" and relaton's
-      # synthetic "/R-<x>" both feed this one attribute; rendered inline as
-      # "Rev<id>". `::Pubid::Identifier` has no `revision` attribute, so this is
-      # free of the number/stage multi-flavor collision landmine.
-      attribute :revision, :string
-      attribute :edition, :string                         # Edition 1.0
-      attribute :month, :string
-      attribute :day, :string
-      attribute :redline, :boolean, default: -> { false }
-      attribute :amendments, Identifier, collection: true # Amendment identifiers
-      attribute :corrigenda, Identifier, collection: true # Corrigendum identifiers
-      attribute :revision_of, Identifier                  # Revision relationships
-      attribute :incorporates, Identifier, collection: true # Incorporated documents
-      attribute :supersedes, Identifier, collection: true # Superseded documents
-      attribute :supplement_to, Identifier                # For supplements
-      attribute :iso_identifier, :string # For IEC/IEEE formats
-      attribute :parenthetical_content, :string           # Raw parenthetical content
-      attribute :note, :string                            # Parenthetical notes
-      attribute :adoption, :string                        # Adoption notes
-      attribute :amendment_to, :string                    # Amendment to relationships
-      attribute :edition_month, :string                   # Month part from Edition YYYY-MM
-      attribute :space_before_draft, :boolean, default: -> {
-        false
-      } # Track space before /D
-      attribute :typed_stage, Components::TypedStage # TYPED_STAGE integration
-      attribute :relationships, Components::Relationship, collection: true # Relationship metadata
-      attribute :nickname, :string # Book nickname (e.g., "[The Orange Book]")
-      attribute :interpretation, :boolean, default: -> {
-        false
-      } # /INT notation
-      attribute :ashrae_number, :string # ASHRAE Guideline number
-      attribute :ashrae_year, :string # ASHRAE Guideline year
-      attribute :crossref, :string # IEEE cross-reference (e.g., /C62.22.1-1996)
-      attribute :reaffirmed, :string # Reaffirmed year (e.g., "2010" for (R2010))
-
-      # Store actual component objects
-      attr_accessor :code_obj, :draft_obj
-
-      # Accept either keyword args (`new(number: "802")`, the normal path) or a
-      # single positional attribute hash (`new({number: "802"})`). The latter is
-      # what the base `Pubid::Identifier#exclude`/matching machinery uses when it
-      # rebuilds via `self.class.new(attrs)`; without it, `exclude`/`matches?`
-      # raised ArgumentError for every IEEE identifier.
-      # Constructor parameters that are not lutaml attributes: `code` is
-      # runtime-only (kept as `code_obj`), and the draft forms are turned into
-      # component objects below.
-      def self.extra_init_keys
-        %i[code draft draft_obj]
-      end
+    module Identifiers
+      # Base class for all IEEE identifiers
+      class Base < Pubid::Identifier
+        # Generate URN for this identifier
+        #
+        # @return [String] URN representation
+
+        attribute :publisher, :string, default: -> { "IEEE" }
+        attribute :copublisher, :string, collection: true # IEC, ISO, ANSI, etc.
+        attribute :code, :string # Will store code as object in initialize
+        attribute :year, :string
+        attribute :type, :string, default: -> { "Std" } # Std, Draft Std
+        attribute :draft_status, :string                    # Unapproved, Approved, Active Unapproved
+        attribute :draft, :string                           # Will store draft as object
+        attribute :edition, :string                         # Edition 1.0
+        attribute :month, :string
+        attribute :day, :string
+        attribute :redline, :boolean, default: -> { false }
+        attribute :amendments, Base, collection: true       # Amendment identifiers
+        attribute :corrigenda, Base, collection: true       # Corrigendum identifiers
+        attribute :revision_of, Base                        # Revision relationships
+        attribute :incorporates, Base, collection: true     # Incorporated documents
+        attribute :supersedes, Base, collection: true       # Superseded documents
+        attribute :supplement_to, Base                      # For supplements
+        attribute :iso_identifier, :string # For IEC/IEEE formats
+        attribute :parenthetical_content, :string           # Raw parenthetical content
+        attribute :note, :string                            # Parenthetical notes
+        attribute :adoption, :string                        # Adoption notes
+        attribute :amendment_to, :string                    # Amendment to relationships
+        attribute :edition_month, :string                   # Month part from Edition YYYY-MM
+        attribute :space_before_draft, :boolean, default: -> {
+          false
+        } # Track space before /D
+        attribute :typed_stage, Components::TypedStage # TYPED_STAGE integration
+        attribute :relationships, Components::Relationship, collection: true # Relationship metadata
+        attribute :nickname, :string # Book nickname (e.g., "[The Orange Book]")
+        attribute :interpretation, :boolean, default: -> {
+          false
+        } # /INT notation
+        attribute :conf_number, :string # Conformance document number
+        attribute :conf_year, :string # Conformance document year
+        attribute :ashrae_number, :string # ASHRAE Guideline number
+        attribute :ashrae_year, :string # ASHRAE Guideline year
+        attribute :crossref, :string # IEEE cross-reference (e.g., /C62.22.1-1996)
+        attribute :reaffirmed, :string # Reaffirmed year (e.g., "2010" for (R2010))
+
+        # Store actual component objects
+        attr_accessor :code_obj, :draft_obj
+
+        def initialize(**args)
+          super()
+
+          # Handle typed_stage if provided
+          if args[:typed_stage]
+            self.typed_stage = args[:typed_stage]
+          end
+
+          # Handle code as component object
+          if args[:code].is_a?(String)
+            self.code_obj = Components::Code.parse(args[:code])
+            self.code = args[:code]
+          elsif args[:code]
+            self.code_obj = args[:code]
+            self.code = args[:code].to_s
+          end
 
-      def initialize(args = {}, **kwargs)
-        args = args.merge(kwargs) unless kwargs.empty?
-        # This override calls `super()` with no attributes and assigns through
-        # setters instead, so it bypasses the base constructor's coercion and
-        # unknown-key check. Apply them here to keep the cross-flavor contract.
-        args = self.class.normalize_init_attributes(args)
-        super()
-
-        # Handle typed_stage if provided
-        if args[:typed_stage]
-          self.typed_stage = args[:typed_stage]
+          # Handle draft as component object
+          if args[:draft_obj]
+            self.draft_obj = args[:draft_obj]
+            self.draft = args[:draft_obj].to_s
+          elsif args[:draft]
+            # If draft is passed as string, try to create Draft object
+            if args[:draft].is_a?(String)
+              # Try to parse the string to extract version/revision
+              if args[:draft] =~ /^D(\d+)(?:\.(\d+))?/
+                version = $1
+                revision = $2
+                self.draft_obj = Components::Draft.new(version: version,
+                                                       revision: revision)
+              else
+                # Simple case - treat as version
+                self.draft_obj = Components::Draft.new(version: args[:draft])
+              end
+              self.draft = draft_obj.to_s
+            else
+              self.draft_obj = args[:draft]
+              self.draft = args[:draft].to_s
+            end
+          end
+
+          # Set other attributes
+          attrs = self.class.attributes
+          args.each do |key, value|
+            next if %i[code draft draft_obj typed_stage].include?(key)
+
+            setter = :"#{key}="
+            public_send(setter, value) if attrs.key?(key)
+          end
         end
 
-        # Handle code as component object. `code` is runtime-only (not a lutaml
-        # attribute) — we keep the parsed Components::Code in code_obj; every
-        # leaf serializes the split index columns (number/prefix/parts/separator)
-        # via the CodeNumber mixin instead of a `code` string. The renderer reads
-        # code_obj (base #code returns it).
-        if args[:code].is_a?(String)
-          self.code_obj = Components::Code.parse(args[:code])
-        elsif args[:code]
-          self.code_obj = args[:code]
+        # Override accessors to return component objects
+        def code
+          code_obj
         end
 
-        # Handle draft as component object
-        if args[:draft_obj]
-          self.draft_obj = args[:draft_obj]
-          self.draft = args[:draft_obj].to_s
-        elsif args[:draft].is_a?(String)
-          self.draft_obj = Components::Draft.parse(args[:draft])
-          self.draft = draft_obj.to_s
-        elsif args[:draft]
-          self.draft_obj = args[:draft]
-          self.draft = args[:draft].to_s
+        def draft
+          draft_obj
         end
 
-        # Set other attributes.
-        #
-        # A key the class accepts but does not declare as a lutaml attribute
-        # (see `extra_init_keys`) is assigned through its plain accessor.
-        # Without that, `CsaDualPublished#csa_identifier` — an `attr_accessor`
-        # by design, "stored as-is (not a Lutaml model type)" — was never
-        # assigned at all, and `renderer.rb` read nil from it:
-        # `IEEE Std 844.1-2017/CSA C22.2 No. 293.1-17` rendered back as
-        # `IEEE Std 844.1-2017/CSA`, losing the CSA designation entirely.
-        attrs = self.class.attributes
-        extra = self.class.extra_init_keys
-        args.each do |key, value|
-          next if %i[code draft draft_obj typed_stage].include?(key)
-
-          setter = :"#{key}="
-          if attrs.key?(key)
-            public_send(setter, value)
-          elsif extra.include?(key) && respond_to?(setter)
-            public_send(setter, value)
-          end
+        # Expose numeric month from draft if available
+        def draft_month
+          return nil unless draft_obj.is_a?(Components::Draft)
+
+          draft_obj.numeric_month
         end
-      end
 
-      # Override accessors to return component objects.
-      def code
-        code_obj
-      end
+        # Parse IEEE identifier string
+        def self.parse(input)
+          # Preprocessing: Convert comma-separated dual standards to "and" format
+          # This must happen BEFORE the "and" check below
+          # Pattern: "IEEE Std 960-1989, Std 1177-1989" -> "IEEE Std 960-1989 and IEEE Std 1177-1989"
+          input = input.gsub(/(\d{4}),\s+Std\s/, '\1 and IEEE Std ')
+
+          # Check for AIEE identifiers (but NOT those with parentheses which have relationships/adoptions)
+          # AIEE has its own parser/builder for simple identifiers
+          # AIEE inputs with parentheses are handled by IEEE parser for relationship/adoption parsing
+          if input.start_with?("AIEE ") && !input.include?("(")
+            return Aiee::Identifier.parse(input)
+          end
 
-      def draft
-        draft_obj
-      end
+          # Check for IEC/IEEE copublished patterns first (before other checks)
+          if input.start_with?("IEC/IEEE ")
+            return parse_single(input)
+          end
 
-      # Lazily rebuild the parsed component objects from the underlying string
-      # attributes. After from_hash, lutaml restores the :code/:draft strings
-      # (@code/@draft) but not these objects; the renderer reads code_obj/
-      # draft_obj directly, so rebuild on demand to render a deserialized
-      # identifier identically to the parsed one. On the parse path code_obj/
-      # draft_obj are already set, so the `||=` returns them unchanged.
-      def code_obj
-        @code_obj ||=
-          (Components::Code.parse(@code.to_s) unless @code.nil? || @code.to_s.empty?)
-      end
+          # Check for semicolon-separated dual identifiers (IEC-first patterns)
+          # Pattern: "IEC 61523-3 First edition 2004-09; IEEE 1497"
+          if input.include?("; ")
+            parts = input.split("; ")
+            if parts.length == 2
+              # Try to parse both parts
+              begin
+                first = parse_single(parts[0].strip)
+                second = parse_single(parts[1].strip)
+
+                return Identifiers::DualPublished.new(
+                  first_identifier: first,
+                  second_identifier: second,
+                )
+              rescue Parslet::ParseFailed
+                # If parsing fails, continue with normal flow
+              end
+            end
+          end
 
-      def draft_obj
-        @draft_obj ||=
-          (Components::Draft.parse(@draft.to_s) unless @draft.nil? || @draft.to_s.empty?)
-      end
+          # PREPROCESS: Handle (R####) (Revision of...) pattern
+          # Convert to single parenthetical: (Reaffirmed ####, Revision of...)
+          # This allows parser to capture both in one parenthetical
+          if input =~ /\(R(\d{4})\)\s*\(Revision of ([^)]+)\)/
+            year = $1
+            $2
+            # Replace the two parentheticals with reaffirmed info extracted
+            # Parse normally but capture year first
+            input_modified = input.sub(
+              /\(R(\d{4})\)\s*\(Revision of ([^)]+)\)/, "(Revision of \\2)"
+            )
+
+            # Parse the modified input
+            result = parse_single(input_modified)
+            # Add reaffirmed attribute
+            if result.class.attributes.key?(:reaffirmed)
+              result.reaffirmed = year
+            end
+            return result
+          end
 
-      # Expose numeric month from draft if available
-      def draft_month
-        return nil unless draft_obj.is_a?(Components::Draft)
+          # PREPROCESS: Handle (Reaffirmed ####) (Revision of...) pattern (full word format)
+          # Pattern: "ANSI/IEEE Std 101-1987 (Reaffirmed 2010) (Revision of IEEE Std 101-1972)"
+          if input =~ /\(Reaffirmed\s+(\d{4})\)\s*\(Revision of ([^)]+)\)/
+            year = $1
+            $2
+            # Replace the two parentheticals
+            input_modified = input.sub(
+              /\(Reaffirmed\s+(\d{4})\)\s*\(Revision of ([^)]+)\)/, "(Revision of \\2)"
+            )
+
+            # Parse the modified input
+            result = parse_single(input_modified)
+            # Add reaffirmed attribute
+            if result.class.attributes.key?(:reaffirmed)
+              result.reaffirmed = year
+            end
+            return result
+          end
 
-        draft_obj.numeric_month
-      end
+          # NEW Session 174: Check for IRE dual published pattern
+          # Pattern after preprocessing: "IEEE Std 218-1956 (R1980) (56 IRE 28.S2)"
+          # First parenthetical: (Rxxx) reaffirmed
+          # Second parenthetical: IRE identifier
+          if /\(R\d{4}\)\s*\((\d+\s+IRE[^)]+)\)/.match?(input)
+            main_part = input.split(" (R").first.strip # Get "IEEE Std 218-1956"
+            reaffirmed_year = input.match(/\(R(\d{4})\)/)[1]
+            ire_part = input.match(/\((\d+\s+IRE[^)]+)\)/)[1]
+
+            begin
+              # Parse main identifier
+              ieee_id = parse_single(main_part)
+              # Add reaffirmed year
+              ieee_id.reaffirmed = reaffirmed_year if ieee_id.class.attributes.key?(:reaffirmed)
+
+              # Parse IRE identifier
+              ire_id = parse_single(ire_part)
+
+              return Identifiers::DualPublished.new(
+                first_identifier: ieee_id,
+                second_identifier: ire_id,
+              )
+            rescue Parslet::ParseFailed
+              # If parsing fails, fall through to regular processing
+            end
+          end
 
-      # IEEE stores its publication date as separate `year`/`month`/`day`
-      # :string attributes, not a Components::Date, so the base #exclude's
-      # `:year`->`:date` remap can't reach them (it would nil an unused `date`
-      # component and leave the strings). After the base rebuild, nil the whole
-      # date cluster when `:year`/`:date` is excluded, so a date-less reference
-      # matches every date in the bucket (relaton partial-ref matching). NB: the
-      # base #exclude also previously raised for every IEEE id (positional
-      # `self.class.new(attrs)` vs the keyword initialize) — fixed by
-      # Identifier#initialize accepting a positional hash.
-      def exclude(*args)
-        result = super
-        if args.intersect?(%i[year date])
-          %i[year month day].each do |attr|
-            result.public_send("#{attr}=", nil) if result.respond_to?("#{attr}=")
+          # Check for space-separated dual identifiers (e.g., "IEC 62014-5 IEEE Std 1734-2011")
+          # This must be checked before " and " pattern
+          # Look for pattern where a second publisher appears after the first complete identifier
+          # Publishers: IEEE, AIEE, ANSI, ASA, IEC, ISO, ASTM, NACE, NSF, ASHRAE, NCTA, AESC
+          publishers = %w[IEEE AIEE ANSI ASA IEC ISO ASTM NACE NSF ASHRAE NCTA
+                          AESC]
+
+          # Find all positions where publishers appear (but NOT inside parentheses)
+          # Publishers inside parentheses are part of relationship clauses, not dual published patterns
+          publisher_positions = []
+          publishers.each do |pub|
+            # Look for publisher at word boundaries (preceded by space or start of string)
+            regex = /(?:^|\s)(#{Regexp.escape(pub)})(?:\s|\/)/
+            input.scan(regex) do
+              match_pos = Regexp.last_match.begin(1)
+
+              # Check if this publisher is inside parentheses (relationship clause)
+              # Count parens before this position
+              before_match = input[0...match_pos]
+              paren_count = before_match.count("(") - before_match.count(")")
+
+              # Skip publishers inside parentheses - they're part of relationship clauses
+              next if paren_count.positive?
+
+              publisher_positions << { pos: match_pos, publisher: pub }
+            end
           end
-        end
-        result
-      end
 
-      # Compact the serialized hash (recursively, so nested Corrigendum bases
-      # are compacted too) after the normal serialize + canonicalize: collapse
-      # `typed_stage` to a scalar `stage` and strip the `/` off `draft`. See
-      # Compaction for why this is a hash transform, not lutaml attributes.
-      def to_hash(*args)
-        hash = super
-        Compaction.collapse(hash) if hash.is_a?(::Hash)
-        hash
-      end
+          # If we have 2 or more publishers at distinct positions (not co-publishers with /)
+          if publisher_positions.length >= 2
+            # Sort by position
+            publisher_positions.sort_by! { |p| p[:pos] }
+
+            # Check if they're not part of a co-published pattern (Publisher1/Publisher2)
+            # by ensuring there's no slash between them
+            first_pub = publisher_positions[0]
+            second_pub = publisher_positions[1]
+
+            # Get the substring between the two publishers
+            between = input[first_pub[:pos]..(second_pub[:pos] - 1)]
+
+            # If there's no slash and no " and ", this might be space-separated dual
+            if !between.include?("/") && !between.include?(" and ")
+              # Try to split at the second publisher position
+              # Back up to find the space before the second publisher
+              split_pos = second_pub[:pos]
+              while split_pos.positive? && input[split_pos - 1] == " "
+                split_pos -= 1
+              end
+
+              first_part = input[0...split_pos].strip
+              second_part = input[split_pos..].strip
+
+              # Try to parse both parts
+              begin
+                first = parse_single(first_part)
+                second = parse_single(second_part)
+
+                # Only treat as dual if both parse successfully
+                return Identifiers::DualPublished.new(
+                  first_identifier: first,
+                  second_identifier: second,
+                )
+              rescue Parslet::ParseFailed
+                # If parsing fails, continue with normal flow
+              end
+            end
+          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
-      # no expansion (Draft.parse accepts the slashless form).
-      def self.from_hash(data, options = {})
-        data = Compaction.expand(Compaction.deep_dup(data)) if data.is_a?(::Hash)
-        super
-      end
+          # Check for dual published patterns with " and "
+          if input.include?(" and ")
+            # DON'T split if " and " is inside parentheses (likely a relationship clause)
+            # Check if parentheses are balanced and " and " is inside them
+            paren_count = 0
+            and_outside_parens = false
+            and_position = nil
+
+            input.each_char.with_index do |char, i|
+              paren_count += 1 if char == "("
+              paren_count -= 1 if char == ")"
+
+              # Check if " and " starts at this position and we're outside parens
+              if paren_count.zero? && input[i..(i + 4)] == " and "
+                and_outside_parens = true
+                and_position = i
+                break
+              end
+            end
+
+            # Only split if " and " is outside parentheses
+            if and_outside_parens && and_position
+              # Split at the found position only (not at all " and " occurrences)
+              first_part = input[0...and_position].strip
+              second_part = input[(and_position + 5)..].strip
+
+              # Parse each part separately
+              first = parse_single(first_part)
+              second = parse_single(second_part)
+
+              return Identifiers::DualPublished.new(
+                first_identifier: first,
+                second_identifier: second,
+              )
+            end
+          end
 
-      # Register the identifier classes the automatic `Identifiers::*` scan
-      # cannot see, so `Pubid::Ieee::Identifier.from_hash` can route their rows
-      # back. The scan only looks at classes declared *directly* under
-      # `Identifiers`, which misses both AIEE and IRE (they live under their own
-      # `Aiee`/`Ire` namespaces) and the whole NESC family (nested one level
-      # deeper, under `Identifiers::Nesc`).
-      def self.additional_identifier_classes
-        [
-          Aiee::Identifier,
-          Ire::Identifier,
-          Identifiers::Nesc::Draft,
-          Identifiers::Nesc::Edition,
-          Identifiers::Nesc::Handbook,
-          Identifiers::Nesc::Redline,
-          Identifiers::Nesc::Standard,
-        ]
-      end
+          # NEW Session 171: Check for dual published patterns with " & " (ampersand)
+          if input.include?(" & ")
+            # DON'T split if " & " is inside parentheses
+            paren_count = 0
+            ampersand_outside_parens = false
+
+            input.each_char.with_index do |char, i|
+              paren_count += 1 if char == "("
+              paren_count -= 1 if char == ")"
+
+              # Check if " & " starts at this position and we're outside parens
+              if paren_count.zero? && input[i..(i + 2)] == " & "
+                ampersand_outside_parens = true
+                break
+              end
+            end
+
+            # Only split if " & " is outside parentheses
+            if ampersand_outside_parens
+              parts = input.split(" & ")
+              if parts.length == 2
+                # Parse each part separately
+                first = parse_single(parts[0].strip)
+                second = parse_single(parts[1].strip)
+
+                return Identifiers::DualPublished.new(
+                  first_identifier: first,
+                  second_identifier: second,
+                )
+              end
+            end
+          end
 
-      # Parse IEEE identifier string.
-      #
-      # PreParser owns all regex/dispatch logic; this method is a thin
-      # orchestrator that consumes a PreParser::Result and routes to the
-      # correct builder.
-      def self.parse(input)
-        unless input.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
+          # Special case: AIEE identifiers with ASA parenthetical references
+          # Pattern: "AIEE No 18-1934 (ASA C55 1934)"
+          if input.match?(/^AIEE\s+/) && input.include?("(") && input.include?("ASA")
+            main_part = input.split("(").first.strip
+            adoption_match = input.match(/\((ASA[^)]+)\)/)
+
+            if adoption_match
+              adoption_part = adoption_match.captures.first
+              # Parse the main AIEE identifier
+              begin
+                aiee_id = parse_single(main_part)
+                # Parse the ASA identifier
+                asa_id = parse_single(adoption_part)
+
+                return Identifiers::AdoptedStandard.new(
+                  ieee_identifier: aiee_id,
+                  adopted_identifier: asa_id,
+                )
+              rescue Parslet::ParseFailed
+                # If parsing fails, fall through to regular processing
+              end
+            end
+          end
+
+          # Check for adopted standards (parenthetical adoptions)
+          # Only consider it an adoption if the parenthetical content looks like an identifier
+          if input.include?("(") && input.include?(")") && !input.start_with?("IEC/IEEE ")
+            # Extract the part before parentheses and the adoption part
+            main_part = input.split("(").first.strip
+            adoption_match = input.match(/\(([^)]+)\)/)
+            adoption_part = adoption_match&.captures&.first
+
+            # Check if adoption_part looks like an identifier (contains publisher or type keywords)
+            # BUT exclude revision/amendment/supersedes notes
+            # AND exclude Pattern 4 relationship types
+            if main_part && adoption_part &&
+                !adoption_part.match?(/^\s*(Revision|Revison|Amendment|Corrigendum|Corrigenda|incorporates|Incorporating|Incorporates|Adoption|Supplement|Draft Amendment|DRAFT Amendment|Draft Revision|Reaffirmation|Redesignation|redesignated as|Supersedes|Supercedes|Includes|Previously designated as|Notebooks|Standard Newspaper)/i) &&
+                (adoption_part.match?(/\b(ANSI|ISO|IEC|IEEE|AIEE|IRE|ASA|ASTM|CSA|ASME|NACE|NSF|ASHRAE|NCTA|AESC)\s/) ||
+                 adoption_part.match?(/^\s*(ANSI|ISO|IEC|IEEE|AIEE|IRE|ASA|ASTM|CSA|ASME|NACE|NSF|ASHRAE|NCTA|AESC)\b/) ||
+                 adoption_part.match?(/\bStd\s+\d+/))
+              # Parse the main IEEE identifier
+              ieee_id = parse_single(main_part)
+
+              # Parse comma-separated adopted identifiers
+              adopted_parts = adoption_part.split(",").map(&:strip)
+              adopted_ids = adopted_parts.map do |part|
+                if part.strip.start_with?("IEC")
+                  # Use IEC parser for IEC adoptions
+                  # Preprocess to convert "Edition X.Y" to IEC format
+                  # Pattern: "IEC 60255-24 Edition 2.0 2013-04" → "IEC 60255-24:2013-04 ED2.0"
+                  iec_part = part.dup
+                  # Replace " Edition X.Y YYYY-MM" (or similar) with ":YYYY-MM EDX.Y"
+                  iec_part.gsub!(/\s+Edition\s+([0-9.]+)\s+([0-9-]+)/,
+                                 ':\2 ED\1')
+                  # Replace " Edition X.Y" at end (no date)
+                  iec_part.gsub!(/\s+Edition\s+([0-9.]+)\s*$/, ' ED\1')
+                  Pubid::Iec.parse(iec_part)
+                elsif part.strip.start_with?("ANSI")
+                  # Use ANSI parser for ANSI adoptions
+                  Pubid::Ansi.parse(part)
+                else
+                  # Use IEEE parser for other adoptions
+                  parse_single(part)
+                end
+              end
+
+              return Identifiers::AdoptedStandard.new(
+                ieee_identifier: ieee_id,
+                adopted_identifiers: adopted_ids,
+              )
+            end
+            # If it doesn't look like an identifier, let the parser handle it as additional_parameters
+          end
 
-        if input.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+          # Fall back to single identifier parsing
+          parse_single(input)
         end
 
-        result = PreParser.preprocess(input)
-
-        case result.dispatch
-        when :aiee_simple
-          return Aiee::Identifier.parse(result.input)
-        when :iec_ieee_copublished
-          return parse_single(result.input)
-        when :dual_semicolon
-          return build_dual(result.parts)
-        when :dual_reaffirmed
-          return build_reaffirmed(result)
-        when :dual_ire
-          return build_dual_with_reaffirmed(result)
-        when :dual_space_separated
-          return build_dual(result.parts)
-        when :dual_and
-          return build_dual(result.parts)
-        when :dual_ampersand
-          return build_dual(result.parts)
-        when :aiee_asa_adoption
-          return build_aiee_asa_adoption(result.parts)
-        when :adopted
-          return build_adopted(result.parts)
-        else
-          parse_single(result.input)
+        # Parse a single IEEE identifier
+        def self.parse_single(input)
+          # Apply legacy update_codes normalization first, before Parser's extensive preprocessing
+          normalized = Core::UpdateCodes.apply(input, :ieee)
+          parsed = Parser.parse(normalized) # Use class method for preprocessing
+          builder = Builder.new(Base)
+          # Pass the original input string to builder for context
+          builder.original_input = input
+          builder.build(parsed)
         end
-      rescue Parslet::ParseFailed
-        parse_single(input)
-      end
 
-      # ---- dispatch constructors (used by parse) ----
+        def to_s
+          parts = []
 
-      def self.build_dual(parts)
-        first = parse_single(parts[0])
-        second = parse_single(parts[1])
-        Identifiers::DualPublished.new(
-          first_identifier: first,
-          second_identifier: second,
-        )
-      end
-      private_class_method :build_dual
-
-      def self.build_reaffirmed(result)
-        parsed = parse_single(result.input)
-        parsed.reaffirmed = result.metadata[:reaffirmed] if parsed.class.attributes.key?(:reaffirmed)
-        parsed
-      end
-      private_class_method :build_reaffirmed
-
-      def self.build_dual_with_reaffirmed(result)
-        ieee_id = parse_single(result.parts[0])
-        ieee_id.reaffirmed = result.metadata[:reaffirmed] if ieee_id.class.attributes.key?(:reaffirmed)
-        ire_id = parse_single(result.parts[1])
-        Identifiers::DualPublished.new(
-          first_identifier: ieee_id,
-          second_identifier: ire_id,
-        )
-      end
-      private_class_method :build_dual_with_reaffirmed
-
-      def self.build_aiee_asa_adoption(parts)
-        aiee_id = parse_single(parts[0])
-        asa_id = parse_single(parts[1])
-        # `adopted_identifierS` — AdoptedStandard declares a collection. The
-        # singular spelling was not an attribute, so lutaml dropped it without
-        # a word and the ASA half of these 13 identifiers was never stored:
-        # `AIEE No 18-1934 (ASA C55 1934)` rendered back as `AIEE No 18-1934`.
-        # The unknown-key contract turned that silent loss into a raise, which
-        # is how it was found.
-        Identifiers::AdoptedStandard.new(
-          ieee_identifier: aiee_id,
-          adopted_identifiers: [asa_id],
-        )
-      end
-      private_class_method :build_aiee_asa_adoption
-
-      def self.build_adopted(parts)
-        ieee_id = parse_single(parts[0])
-        adopted_parts = parts[1].split(",").map(&:strip)
-        adopted_ids = adopted_parts.map do |part|
-          if part.start_with?("IEC")
-            Pubid::Iec.parse(normalize_iec_adoption(part))
-          elsif part.start_with?("ANSI")
-            Pubid::Ansi.parse(part)
+          # Publisher(s) - handle copublisher array properly
+          if copublisher && !copublisher.empty?
+            # Copublisher is an array, join all publishers with single slash
+            parts << [publisher, *copublisher].join("/")
           else
-            parse_single(part)
+            parts << publisher
           end
-        end
-        Identifiers::AdoptedStandard.new(
-          ieee_identifier: ieee_id,
-          adopted_identifiers: adopted_ids,
-        )
-      end
-      private_class_method :build_adopted
-
-      # "IEC 60255-24 Edition 2.0 2013-04" → "IEC 60255-24:2013-04 ED2.0"
-      def self.normalize_iec_adoption(part)
-        iec_part = part.dup
-        iec_part.gsub!(/\s+Edition\s+([0-9.]+)\s+([0-9-]+)/, ':\2 ED\1')
-        iec_part.gsub!(/\s+Edition\s+([0-9.]+)\s*$/, ' ED\1')
-        iec_part
-      end
-      private_class_method :normalize_iec_adoption
-
-      # Parse a single IEEE identifier
-      def self.parse_single(input)
-        # Apply legacy update_codes normalization first, before Parser's extensive preprocessing
-        normalized = Core::UpdateCodes.apply(input, :ieee)
-        parsed = Parser.parse(normalized) # Use class method for preprocessing
-        builder = Builder.new(Identifier)
-        # Pass the original input string to builder for context
-        builder.original_input = input
-        builder.build(parsed)
-      end
 
-      # IEEE stores identity in `code` (prefix/number/parts) rather than the
-      # generic `number`, has its own `type` string ("Std", "Draft Std"), and
-      # carries `year` as a bare string — none of which the generic MrString
-      # renderer knows about. Override the lossless MR template directly so
-      # every IEEE identifier round-trips (issue #142). Supplements append
-      # `_{type}.{number}.{year}` recursively via mr_supplement_suffix.
-      # Lowercased to match the all-lowercase MR convention.
-      def mr_publisher
-        publisher&.to_s&.downcase
-      end
+          # Draft status
+          parts << draft_status if draft_status
 
-      def mr_type
-        type&.downcase
-      end
+          # Type - only render for IEEE/AIEE publishers, and only for non-projects
+          # Must come BEFORE code
+          should_render_type = publisher&.match?(/^(IEEE|AIEE)/)
 
-      def mr_number_with_part
-        code_obj&.to_s&.downcase
-      end
+          if should_render_type && !typed_stage&.project_status && type && !type.to_s.strip.empty? && type != "P"
+            # Non-project with explicit type (Std, No, etc.)
+            type_str = type.dup
+            # Remove P prefix if somehow present
+            type_str = type_str.sub(/^P/, "") if type_str.start_with?("P")
+            parts << type_str unless type_str.strip.empty?
+          end
 
-      def mr_year
-        year&.to_s
+          # Code - with P prefix for projects (concatenated, not separated)
+          if code_obj
+            result = code_obj.to_s
+
+            # Prepend P if this is a project AND code doesn't already have P
+            if typed_stage&.project_status && should_render_type && !result.start_with?("P")
+              result = "P#{result}"
+            end
+
+            # Only attach year to code if there's no edition, no month, and no draft
+            result += "-#{year}" if year && !draft_obj && !edition && !month
+
+            # Append draft to code - with or without space based on original format
+            if draft_obj
+              result += space_before_draft ? " #{draft_obj}" : draft_obj.to_s
+            end
+
+            # Append interpretation notation (/INT)
+            result += "/INT" if interpretation
+
+            # Append conformance notation (/ConformanceNN-YYYY)
+            if conf_number
+              result += "/Conformance#{conf_number}"
+              result += "-#{conf_year}" if conf_year
+            end
+
+            # Append ASHRAE joint publication (/ASHRAE Guideline NN-YYYY)
+            if ashrae_number
+              result += "/ASHRAE Guideline #{ashrae_number}"
+              result += "-#{ashrae_year}" if ashrae_year
+            end
+
+            # Append IEEE cross-reference (/C62.22.1-1996)
+            result += crossref if crossref
+
+            parts << result
+          elsif should_render_type && typed_stage&.project_status
+            # No code but is a project - add standalone P
+            parts << "P"
+          end
+
+          # Edition - with year if present (IEC style)
+          if edition
+            edition_str = "Edition #{edition}"
+            if year
+              edition_str += " #{year}"
+              edition_str += "-#{edition_month}" if edition_month
+            end
+            parts << edition_str
+          end
+
+          # Build the main identifier (without month yet)
+          result = parts.join(" ")
+
+          # Month/Day - append directly to avoid extra space before comma
+          if month
+            # Format: ", Month Day, Year" or ", Month, Year"
+            result += ", #{month}"
+            result += " #{day}" if day
+            if year && !edition
+              # Add comma after month if year follows
+              result += ", #{year}"
+            end
+          end
+
+          # Add parenthetical content if present
+          # Handle multiple parenthetical clauses (reaffirmed + relationships/revision)
+          parentheticals = []
+
+          reaff = reaffirmed
+          if reaff && !reaff.to_s.strip.empty?
+            parentheticals << "(R#{reaff})"
+          end
+
+          # Then add relationships/revision/amendment as second parenthetical
+          if parenthetical_content
+            parentheticals << "(#{parenthetical_content})"
+          elsif relationships && !relationships.empty?
+            # Render relationships (multiple separated by /)
+            relationship_str = relationships.join(" / ")
+            parentheticals << "(#{relationship_str})"
+          elsif revision_of
+            parentheticals << "(Revision of IEEE Std #{revision_of})"
+          elsif amendment_to
+            parentheticals << "(Amendment to IEEE Std #{amendment_to})"
+          elsif adoption
+            parentheticals << "(Adoption of #{adoption})"
+          elsif note && !note.to_s.strip.empty?
+            # Only add note if it doesn't duplicate other content
+            parentheticals << "(#{note})"
+          end
+
+          # Append all parentheticals with space separation
+          result += " #{parentheticals.join(' ')}" unless parentheticals.empty?
+
+          # Book nickname - outside parentheses in square brackets
+          result += " [#{nickname}]" if nickname && !nickname.to_s.strip.empty?
+
+          # Redline suffix
+          result += " - Redline" if redline
+
+          result
+        end
       end
     end
-
   end
 end