pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

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

@@ -6,586 +6,251 @@ module Pubid
       # Forward declare component classes
     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
-
-          # 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
+    # Base class for all IEEE identifiers. Canonical name
+    # Pubid::Ieee::Identifier (Identifiers::Base is a back-compat alias). 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.
+      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, 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 :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
 
-        # Override accessors to return component objects
-        def code
-          code_obj
+        # 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 draft
-          draft_obj
+        # 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
         end
 
-        # Expose numeric month from draft if available
-        def draft_month
-          return nil unless draft_obj.is_a?(Components::Draft)
+        # Set other attributes
+        attrs = self.class.attributes
+        args.each do |key, value|
+          next if %i[code draft draft_obj typed_stage].include?(key)
 
-          draft_obj.numeric_month
+          setter = :"#{key}="
+          public_send(setter, value) if attrs.key?(key)
         end
+      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
-
-          # Check for IEC/IEEE copublished patterns first (before other checks)
-          if input.start_with?("IEC/IEEE ")
-            return parse_single(input)
-          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
-
-          # 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
-
-          # 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
-
-          # 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
-
-          # 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
-
-          # 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
-
-          # 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
-
-          # 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
-
-          # 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)
+      # Override accessors to return component objects.
+      def code
+        code_obj
+      end
 
-                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
+      def draft
+        draft_obj
+      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
+      # 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 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)
+      def draft_obj
+        @draft_obj ||=
+          (Components::Draft.parse(@draft.to_s) unless @draft.nil? || @draft.to_s.empty?)
+      end
 
-              # 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
+      # Expose numeric month from draft if available
+      def draft_month
+        return nil unless draft_obj.is_a?(Components::Draft)
 
-              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
+        draft_obj.numeric_month
+      end
 
-          # Fall back to single identifier parsing
-          parse_single(input)
+      # 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)
+        if input.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        # 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)
+        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)
         end
+      rescue Parslet::ParseFailed
+        parse_single(input)
+      end
 
-        def to_s
-          parts = []
-
-          # 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
-            parts << publisher
-          end
-
-          # Draft status
-          parts << draft_status if draft_status
-
-          # Type - only render for IEEE/AIEE publishers, and only for non-projects
-          # Must come BEFORE code
-          should_render_type = publisher&.match?(/^(IEEE|AIEE)/)
-
-          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
-
-          # 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 = []
+      # ---- dispatch constructors (used by parse) ----
 
-          reaff = reaffirmed
-          if reaff && !reaff.to_s.strip.empty?
-            parentheticals << "(R#{reaff})"
-          end
+      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
 
-          # 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})"
+      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])
+        Identifiers::AdoptedStandard.new(
+          ieee_identifier: aiee_id,
+          adopted_identifier: 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)
+          else
+            parse_single(part)
           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
+        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
     end
+
+    module Identifiers
+      # Backward-compatible alias: IEEE's base class used to be
+      # Pubid::Ieee::Identifiers::Base. It is now Pubid::Ieee::Identifier.
+      Base = Pubid::Ieee::Identifier
+    end
   end
 end