pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/csa/composite_identifier.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Csa
+    # CompositeIdentifier is the base class for identifiers that contain
+    # collections of other identifiers or package materials.
+    #
+    # Examples:
+    #   - PackageIdentifier: Base + package materials
+    #   - Future: BundleIdentifier refactor to use composite
+    #
+    # This follows the Composite pattern where an identifier can contain
+    # other identifiers or additional metadata as a collection.
+    class CompositeIdentifier < Lutaml::Model::Serializable
+      # The primary/base identifier
+      # Use attr_accessor since it can be any identifier object
+      attr_accessor :base_identifier
+
+      # Subclasses MUST implement to_s to define how they render
+      def to_s
+        raise NotImplementedError, "Subclasses must implement to_s method"
+      end
+    end
+  end
+end

data/lib/pubid/csa/identifier.rb

@@ -0,0 +1,513 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    class Identifier
+      # Factory that builds a CSA identifier from a hash of primitives.
+      # Default is {Identifiers::Standard}.
+      TYPE_KEY_TO_KLASS = {
+        standard:         "Standard",
+        bundled:          "Bundled",
+        canadian_adopted: "CanadianAdopted",
+        cec:              "Cec",
+        combined:         "Combined",
+        csa_adopted:      "CsaAdopted",
+        package:          "Package",
+        series:           "Series",
+      }.freeze
+
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts, klass: klass))
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Standard if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown CSA type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.coerce_create_attrs(opts, klass:)
+        attrs = {}
+
+        if (v = opts[:code] || opts[:number])
+          attrs[:code] = Pubid::Components::Code.new(value: v.to_s)
+        end
+
+        if opts[:year]
+          year_str = opts[:year].to_s
+          attrs[:year] = year_str
+          # Preserve 4-digit year rendering (e.g. "B51:2024") rather than
+          # collapsing to "B51:24".
+          attrs[:original_year_4digit] = year_str.length == 4 unless opts.key?(:original_year_4digit)
+        end
+        attrs[:original_year_4digit] = opts[:original_year_4digit] if opts.key?(:original_year_4digit)
+        attrs[:year_format] = opts[:year_format].to_s if opts[:year_format]
+        attrs[:year_prefix] = opts[:year_prefix].to_s if opts[:year_prefix]
+        attrs[:reaffirmation] = opts[:reaffirmation].to_s if opts[:reaffirmation]
+        attrs[:french] = opts[:french] if opts.key?(:french)
+        attrs[:has_publisher] = opts.fetch(:has_publisher, true)
+        attrs[:publisher_prefix] = opts[:publisher_prefix].to_s if opts[:publisher_prefix]
+        attrs[:series_prefix] = opts[:series_prefix].to_s if opts[:series_prefix]
+        attrs[:series] = opts[:series] if opts.key?(:series) && [true, false].include?(opts[:series])
+        attrs[:package] = opts[:package].to_s if opts[:package]
+        attrs[:no_number] = opts[:no_number].to_s if opts[:no_number]
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
+
+      def self.parse(input)
+        # Filter out comments
+        return nil if input.start_with?("#")
+
+        # Filter out non-standards
+        return nil if input.match?(/^CSA (Communities|Group|Learning|OnDemand|Update)/)
+
+        # Preprocessing: normalize CEI to IEC (French name)
+        input = input.gsub("CEI/IEC", "IEC").gsub(/\bCEI\b/, "IEC")
+
+        # Detect CAN/ wrapper (Canadian adoption)
+        if input.start_with?("CAN/")
+          # Check if this is actually a bundled/combined identifier with + or /
+          # that should NOT be wrapped in CanadianAdopted
+          wrapped_input = input.sub(/^CAN\//, "")
+
+          # Check for bundled (+) or combined (/ or ,) patterns that should remain as-is
+          # These should be parsed normally, with publisher prefix applied to each part
+          # Patterns to detect:
+          # 1. Bundled: + separator (e.g., "CSA B127.1:99 + B127.2:99")
+          # 2. Combined with space: / separator with space before CSA- (e.g., "CSA A23.1:24/CSA A23.2:24")
+          # 3. Combined with CAN/CSA-: / separator with CSA- appearing multiple times (e.g., "CSA-B138.1-17/CSA-B138.2-17")
+          if wrapped_input.include?("+") ||
+              (wrapped_input.include?("/") && wrapped_input.match?(/\s+CSA-/)) ||
+              (wrapped_input.include?("/") && wrapped_input.scan("CSA-").length > 1)
+            # This is a bundled or combined identifier - parse normally and add prefix
+            # Normalize CSA- to CSA (with space) for parsing
+            normalized = wrapped_input.sub(/^CSA-/, "CSA ")
+            normalized = normalized.gsub("CAN/CSA-", "CSA ").gsub("CAN3-",
+                                                                  "CSA ")
+            normalized = normalized.gsub(/\s+/, " ").strip
+
+            # Parse normally (will create Bundled or Combined identifier)
+            tree = Parser.new.parse(normalized)
+            result = Builder.new.build(tree)
+
+            # Apply CAN/CSA- prefix to the appropriate parts
+            if result
+              set_publisher_prefix(result, "CAN/CSA-")
+
+              # Handle reaffirmation if present
+              if (wrapped_input =~ /\(R(\d{4})\)/) && result.class.attributes.key?(:reaffirmation)
+                result.reaffirmation = $1
+              end
+            end
+
+            return result
+          end
+
+          # This is a standard single identifier wrapped in CanadianAdopted
+          # Remove CAN/ prefix (already done above)
+
+          # Extract reaffirmation FIRST (before any other processing)
+          reaffirm_year = nil
+          reaffirmation_was_4digit = false # Track original format
+          if wrapped_input =~ /\(R(\d{2,4})\)/
+            reaffirm_year = $1
+            reaffirmation_was_4digit = ($1.length == 4) # Track if original was 4-digit
+            # Convert 2-digit year to 4-digit if needed
+            if reaffirm_year.length == 2
+              year_int = reaffirm_year.to_i
+              reaffirm_year = year_int < 50 ? "20#{reaffirm_year}" : "19#{reaffirm_year}"
+            end
+            wrapped_input = wrapped_input.sub(/\s*\(R\d{2,4}\)/, "")
+          end
+
+          # Detect and preserve original format (CSA- vs CSA)
+          # Also track that this is a CAN/CSA- identifier (not just CSA-)
+          original_prefix = if wrapped_input.start_with?("CSA-")
+                              "CSA-"
+                            elsif wrapped_input.start_with?("CSA ")
+                              "CSA"
+                            end
+          is_can_csa = true # Track that this has the CAN/ wrapper
+
+          # Normalize CSA- to CSA  (with space) for parsing
+          wrapped_input = wrapped_input.sub(/^CSA-/, "CSA ")
+
+          # Parse the wrapped identifier recursively
+          wrapped_identifier = parse(wrapped_input)
+          return nil unless wrapped_identifier
+
+          # NOTE: Series identifiers should be wrapped in CanadianAdopted when
+          # they have CAN/CSA- prefix. The Series will handle rendering correctly.
+          # Do NOT return Series directly - always wrap in CanadianAdopted.
+
+          # Set publisher prefix on wrapped identifier
+          # For Series identifiers with CAN/ wrapper, use full "CAN/CSA-" prefix
+          # For other identifiers, use the detected original_prefix ("CSA-" or "CSA")
+          if wrapped_identifier.class.attributes.key?(:publisher_prefix)
+            if is_can_csa && wrapped_identifier.is_a?(Identifiers::Series)
+              # Series gets full "CAN/CSA-" prefix for proper rendering
+              wrapped_identifier.publisher_prefix = "CAN/CSA-"
+            elsif original_prefix
+              # For Combined identifiers, set on first identifier
+              if wrapped_identifier.is_a?(Identifiers::Combined) && wrapped_identifier.first
+                wrapped_identifier.first.publisher_prefix = original_prefix if wrapped_identifier.first.class.attributes.key?(:publisher_prefix)
+              else
+                # For non-Combined identifiers, set directly
+                wrapped_identifier.publisher_prefix = original_prefix
+              end
+            end
+          end
+
+          # Set reaffirmation on wrapped_identifier if it has the attribute
+          if wrapped_identifier.class.attributes.key?(:reaffirmation) && reaffirm_year
+            wrapped_identifier.reaffirmation = reaffirm_year
+            if wrapped_identifier.class.attributes.key?(:original_reaffirmation_4digit)
+              wrapped_identifier.original_reaffirmation_4digit = reaffirmation_was_4digit
+            end
+          end
+
+          # Create CanadianAdoptedIdentifier wrapper
+          result = Identifiers::CanadianAdopted.new
+          result.wrapped_identifier = wrapped_identifier
+          result.reaffirmation = reaffirm_year if reaffirm_year
+
+          return result
+        end
+
+        # Detect CAN3- wrapper (historical Canadian adoption)
+        if input.start_with?("CAN3-")
+          # This is a historical Canadian adoption - parse as wrapper
+          # Remove CAN3- prefix
+          wrapped_input = input.sub(/^CAN3-/, "CSA ")
+
+          # Detect year format before normalization (CAN3- standards use dash format)
+          # Format: CAN3-Z299.0-86 (uses dash, not colon)
+          has_dash_year = wrapped_input.match?(/-\d{2}\b/) # Match -86, -05, etc. (2-digit years)
+
+          # Extract reaffirmation FIRST (before any other processing)
+          reaffirm_year = nil
+          reaffirmation_was_4digit = false # Track original format
+          if wrapped_input =~ /\(R(\d{2,4})\)/
+            reaffirm_year = $1
+            reaffirmation_was_4digit = ($1.length == 4) # Track if original was 4-digit
+            # Convert 2-digit year to 4-digit if needed
+            if reaffirm_year.length == 2
+              year_int = reaffirm_year.to_i
+              reaffirm_year = year_int < 50 ? "20#{reaffirm_year}" : "19#{reaffirm_year}"
+            end
+            wrapped_input = wrapped_input.sub(/\s*\(R\d{2,4}\)/, "")
+          end
+
+          # Parse the wrapped identifier recursively
+          wrapped_identifier = parse(wrapped_input)
+          return nil unless wrapped_identifier
+
+          # Set year_format for dash format identifiers (preserve original 2-digit year)
+          if has_dash_year && wrapped_identifier.class.attributes.key?(:year_format)
+            wrapped_identifier.year_format = "dash"
+            # Mark original year as 2-digit so renderer converts back (1986 → 86)
+            if wrapped_identifier.class.attributes.key?(:original_year_4digit)
+              wrapped_identifier.original_year_4digit = false
+            end
+          end
+
+          # Check if this is a Series identifier - return it directly with CAN3- prefix
+          # Series identifiers are complete identifier types and handle the prefix themselves
+          # They don't need to be wrapped in CanadianAdopted
+          if wrapped_identifier.is_a?(Identifiers::Series)
+            wrapped_identifier.publisher_prefix = "CAN3-"
+            wrapped_identifier.reaffirmation = reaffirm_year if reaffirm_year
+            wrapped_identifier.original_reaffirmation_4digit = reaffirmation_was_4digit
+            return wrapped_identifier
+          end
+
+          # Set CAN3- as publisher prefix on wrapped identifier
+          if wrapped_identifier.class.attributes.key?(:publisher_prefix)
+            wrapped_identifier.publisher_prefix = "CAN3-"
+          end
+
+          # Set reaffirmation on wrapped_identifier if it has the attribute
+          if wrapped_identifier.class.attributes.key?(:reaffirmation) && reaffirm_year
+            wrapped_identifier.reaffirmation = reaffirm_year
+            if wrapped_identifier.class.attributes.key?(:original_reaffirmation_4digit)
+              wrapped_identifier.original_reaffirmation_4digit = reaffirmation_was_4digit
+            end
+          end
+
+          # Create CanadianAdoptedIdentifier wrapper
+          result = Identifiers::CanadianAdopted.new
+          result.wrapped_identifier = wrapped_identifier
+          result.reaffirmation = reaffirm_year if reaffirm_year
+
+          return result
+        end
+
+        # Detect CSA adoption of international standards
+        # Examples: CSA ISO/IEC TR 12785-3:15, CSA CISPR 16-1-1:18, CSA IEC 60601-1:08
+        #          CSA CEI/IEC 61000-4-28-01 (bilingual)
+        if input.match?(/^CSA (ISO\/IEC|CEI\/IEC|CISPR|IEC|CEI|ISO)\s/)
+          # This is CSA adoption of international standard
+          # Extract the wrapped standard portion
+          wrapped_input = input.sub(/^CSA\s+/, "")
+
+          # Extract reaffirmation FIRST (before parsing)
+          reaffirm_year = nil
+          if wrapped_input =~ /\(R(\d{2,4})\)/
+            reaffirm_year = $1
+            # Convert 2-digit year to 4-digit if needed
+            if reaffirm_year.length == 2
+              year_int = reaffirm_year.to_i
+              reaffirm_year = year_int < 50 ? "20#{reaffirm_year}" : "19#{reaffirm_year}"
+            end
+            wrapped_input = wrapped_input.sub(/\s*\(R\d{2,4}\)/, "")
+          end
+
+          # Convert 2-digit years to 4-digit for external parser
+          # :15 → :2015, :04 → :2004
+          if wrapped_input =~ /:(\d{2})\b/
+            short_year_str = $1 # Keep as string "04", "15", etc.
+            short_year_int = short_year_str.to_i
+            # Determine century: 00-49 → 2000s, 50-99 → 1900s
+            full_year = short_year_int < 50 ? "20#{short_year_str}" : "19#{short_year_str}"
+            wrapped_input = wrapped_input.sub(/:#{short_year_str}\b/,
+                                              ":#{full_year}")
+          end
+
+          # Convert CSA amendment format to ISO/IEC format
+          # /A1:22 → /Amd 1:2022, /A1-22 → /Amd 1-2022
+          # Also handle 2-digit and 4-digit amendment years (convert to 4-digit)
+          # Note: In gsub blocks with string regex, we must use $1, $2, $3
+          # because the block receives a String, not MatchData
+          wrapped_input = wrapped_input.gsub(%r{/A(\d+)([:/-])(\d{2,4})\b}) do
+            amendment_num = $1
+            separator = $2
+            amend_year_str = $3
+            amend_year_int = amend_year_str.to_i
+            # Convert 2-digit year to 4-digit if needed
+            if amend_year_str.length == 2
+              amend_full_year = amend_year_int < 50 ? "20#{amend_year_str}" : "19#{amend_year_str}"
+            else
+              amend_full_year = amend_year_str
+            end
+            "/Amd #{amendment_num}#{separator}#{amend_full_year}"
+          end
+
+          # Parse with appropriate flavor parser
+          wrapped_identifier = parse_external_standard(wrapped_input)
+          return nil unless wrapped_identifier
+
+          # Create CsaAdoptedIdentifier wrapper
+          result = Identifiers::CsaAdopted.new
+          result.wrapped_identifier = wrapped_identifier
+          result.reaffirmation = reaffirm_year if reaffirm_year
+
+          return result
+        end
+
+        # Detect package identifiers
+        # Examples: CSA Z662:23 PACKAGE INCLUDES: +1 (PDF & ESA)
+        #           CSA B149.1:25 Code, Handbook & Training Package (materials BEFORE keyword)
+        #           CSA B149.1:20 PACKAGE (PDF + PRINT) (no materials)
+        #           CSA B108:23 PACKAGE (no trailing space)
+        if input.match?(/\sPACKAGE\b/i)
+          # Handle two formats:
+          # 1. {base} PACKAGE {materials} - materials after keyword
+          # 2. {base} {materials} PACKAGE - materials before keyword
+
+          # Check if materials come after PACKAGE keyword
+          # Match: "CSA Z662:23 PACKAGE INCLUDES: +1" or "CSA B149.1:20 PACKAGE (PDF + PRINT)"
+          case input
+          when /\sPACKAGE\s+[A-Z]/i
+            # Format: {base} PACKAGE {materials}
+            # Extract materials after PACKAGE keyword
+            base_input, package_materials = input.split(/\s+PACKAGE\s+/i, 2)
+            base_input = base_input.strip
+            package_materials = package_materials ? package_materials.strip : ""
+            materials_after = true
+          when /:(\d{2,4})(\s+[^P]+)\s+PACKAGE/i
+            # Format: {base} PACKAGE or {base} {materials} PACKAGE
+            # Examples: "C22.1-15 PACKAGE" (no materials), "CSA B149.1:25 Code, Handbook & Training Package"
+
+            # Check if there's a year followed by materials before PACKAGE
+            # Must check this BEFORE the generic "{base} PACKAGE" pattern
+            $1
+            $2
+
+            # Check if this is a combined identifier (has comma with CSA after it)
+            # Pattern: ", CSA" or ", CAN" which indicates combined identifier
+            if input.match?(/,\s+CSA/)
+              # For combined identifiers, we need to extract everything before "& Training Package"
+              # The base is the combined identifier, materials is just "& Training Package"
+              combined_match = input.match(/^(.+?)(\s+&[^P]+)\s+PACKAGE$/i)
+              if combined_match
+                base_input = combined_match[1].strip
+                package_materials = "#{combined_match[2].strip} Package" # Keep "& Training Package"
+              else
+                # Fallback to year-based extraction
+                year_match = input.match(/:\d{2,4}/)
+                if year_match
+                  base_input = input[0..(year_match.end(0) - 1)]
+                  materials_input = input[year_match.end(0)..].strip
+                  package_materials = materials_input
+                end
+              end
+            else
+              # Standard single identifier with materials before PACKAGE
+              year_match = input.match(/:\d{2,4}/)
+              if year_match
+                base_input = input[0..(year_match.end(0) - 1)]
+                # Materials is everything between base and PACKAGE - keep the "Package" suffix for correct capitalization
+                materials_input = input[year_match.end(0)..].strip
+                package_materials = materials_input # Keep full materials including "Package" suffix
+                base_input = base_input.strip
+              end
+            end
+            materials_after = false
+          # Format: {base} {materials} PACKAGE - "CSA B149.1:25 Code, Handbook & Training Package"
+          # OR: Combined identifier with package: "CSA B149.1:25, CSA B149.2:25 & Training Package"
+          when /^(.+?)\s+PACKAGE\s*$/i
+            # Format: {base} PACKAGE (no materials) - "C22.1-15 PACKAGE"
+            # Treat PACKAGE as the package description
+            base_input = input.sub(/\s+PACKAGE\s*$/i, "").strip
+            package_materials = "" # No additional materials
+            materials_after = true
+          else
+            # Fallback: try parsing incrementally
+            tokens = input.split(/\s+/)
+            base_input = ""
+            tokens.each do |token|
+              break if token.match?(/^PACKAGE$/i)
+
+              test_input = base_input.empty? ? token : "#{base_input} #{token}"
+              parsed = parse(test_input)
+              if parsed
+                base_input = test_input
+              else
+                break
+              end
+            end
+
+            # Extract materials as everything between base and PACKAGE
+            if base_input && base_input.length < input.length
+              materials_input = input[base_input.length..].strip
+              package_materials = materials_input.sub(/\s+PACKAGE\s*$/i,
+                                                      "").strip
+              materials_after = !package_materials.empty?
+            end
+          end
+
+          # Parse base identifier recursively
+          base_identifier = base_input ? parse(base_input) : nil
+          return nil unless base_identifier
+
+          # Create PackageIdentifier
+          result = Identifiers::Package.new
+          result.base_identifier = base_identifier
+          # Set materials if present
+          if package_materials && !package_materials.empty?
+            result.package_materials = package_materials
+          end
+          result.package_keyword = "PACKAGE"
+          # Set materials_after_keyword flag based on which format we detected
+          result.materials_after_keyword = materials_after
+
+          return result
+        end
+
+        # Legacy handling for CAN/CSA- and CAN3- (will be migrated to proper classes later)
+        # Detect original publisher prefix before normalization
+        publisher_prefix = if input.start_with?("CAN/CSA-")
+                             "CAN/CSA-"
+                           elsif input.start_with?("CAN3-")
+                             "CAN3-"
+                           elsif input.start_with?("CSA ")
+                             "CSA"
+                           end
+
+        # Detect year format before normalization
+        # CAN/CSA- standards use dash format: CAN/CSA-C22.2-05
+        # Modern CSA standards use colon format: CSA B149:20
+        has_dash_year = input.match?(/-\d{2}\b/)
+
+        # Normalize CAN/CSA- and CAN3- to CSA (global replacement for combined identifiers)
+        normalized = input.gsub("CAN/CSA-", "CSA ")
+        # Normalize CAN3- to CSA (historical prefix)
+        normalized = normalized.gsub("CAN3-", "CSA ")
+
+        tree = Parser.new.parse(normalized)
+        result = Builder.new.build(tree)
+
+        # Set publisher prefix if detected
+        if result && publisher_prefix
+          set_publisher_prefix(result, publisher_prefix)
+        end
+
+        # Set year format if detected as dash and not already set
+        if result && has_dash_year && result.year_format.nil?
+          result.year_format = "dash"
+        end
+
+        result
+      rescue Parslet::ParseFailed => e
+        raise e
+      end
+
+      def self.set_publisher_prefix(obj, prefix)
+        # Set on main object if it has the attribute
+        if obj.class.attributes.key?(:publisher_prefix)
+          obj.publisher_prefix = prefix
+        end
+
+        # Set on combined identifier parts
+        if obj.is_a?(Identifiers::Combined)
+          if obj.first&.class&.attributes&.key?(:publisher_prefix)
+            obj.first.publisher_prefix = prefix
+          end
+          if obj.second && obj.second.class.attributes.key?(:has_publisher) && obj.second.has_publisher && obj.second.class.attributes.key?(:publisher_prefix)
+            obj.second.publisher_prefix = prefix
+          end
+          if obj.third && obj.third.class.attributes.key?(:has_publisher) && obj.third.has_publisher && obj.third.class.attributes.key?(:publisher_prefix)
+            obj.third.publisher_prefix = prefix
+          end
+        end
+
+        # Set on bundled identifier base
+        if obj.is_a?(Identifiers::Bundled) && obj.base
+          set_publisher_prefix(obj.base, prefix)
+        end
+      end
+
+      def self.parse_external_standard(input)
+        # Ensure full Pubid is loaded (handles Scheme and all flavors)
+        require_relative "../../pubid" unless defined?(Pubid::Iso) && defined?(Pubid::Iec)
+
+        # Try ISO/IEC first (most common)
+        if input.match?(/^(ISO\/IEC|ISO|IEC|CEI|CEI\/IEC)\s/)
+          begin
+            # Normalize CEI/IEC to IEC for parsing (CEI is French for IEC)
+            normalized_input = input.sub(/^CEI\/IEC/, "IEC")
+            return Pubid::Iso.parse(normalized_input)
+          rescue StandardError
+            return nil
+          end
+        end
+
+        # Try CISPR (uses IEC parser)
+        if input.match?(/^CISPR\s/)
+          begin
+            return Pubid::Iec.parse(input)
+          rescue StandardError
+            return nil
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    module Identifiers
+      class Base < SingleIdentifier
+        def to_s
+          prefix = publisher_prefix || "CSA"
+
+          # Handle code_only identifiers (empty string means no prefix)
+          if prefix == ""
+            # No prefix for code_only identifiers
+            parts = []
+          else
+            # Determine if we need space after prefix
+            # CAN/CSA- and CAN3- end with dash, so no space needed
+            needs_space = !prefix.end_with?("-")
+
+            parts = []
+            parts << prefix
+          end
+
+          # Code and year together
+          code_part = code.to_s if code
+
+          # NO. keyword
+          if no_number
+            code_part += " NO. #{no_number}"
+          end
+
+          # Series prefix and keyword (before year)
+          if series_prefix
+            code_part += " #{series_prefix} SERIES"
+          elsif series
+            # SERIES without prefix
+            code_part += " SERIES"
+          end
+
+          parts << code_part if code_part
+
+          # Year with proper format (colon or dash)
+          if year
+            # Use dash if year_format is dash, otherwise colon
+            separator = year_format == "dash" ? "-" : ":"
+            year_part = separator
+            year_part += year_prefix if year_prefix # Add M or F prefix
+            year_part += "F" if french && year_format != "dash" && !year_prefix # Only add F if no prefix
+            # Convert 4-digit year back to 2-digit for M/F prefix preservation
+            # M1983 → M83, F1983 → F83, 1983 → 83, 20xx → xx
+            # However, preserve original 4-digit format if the input was 4-digit (original_year_4digit)
+            year_str = year.to_s
+            year_part += if original_year_4digit
+                           # Preserve 4-digit format (e.g., "M1981" stays "M1981")
+                           year_str
+                         elsif year_prefix&.match?(/^[MF]$/) && year_str.length == 4 && year_str.start_with?("19")
+                           # M/F + 4-digit year (1900s) → convert to 2-digit with prefix
+                           year_str[2..3]
+                         elsif year_str.length == 4 && year_str.start_with?("20")
+                           # 2000s → just last 2 digits
+                           year_str[2..3]
+                         elsif year_str.length == 4 && year_str.start_with?("19") && !original_year_4digit
+                           # 1900s with no M/F prefix, but original was 2-digit (e.g., CAN3-Z299.0-86)
+                           # Convert back to 2-digit
+                           year_str[2..3]
+                         else
+                           # Other formats - keep as-is
+                           year_str
+                         end
+            parts[-1] += year_part
+          end
+
+          result = if prefix == ""
+                     # No prefix, just join parts
+                     parts.join(" ")
+                   elsif needs_space
+                     parts.join(" ")
+                   elsif parts.length == 2
+                     # No space after dash-ending prefix - join first two parts directly
+                     # If there are more parts after code, they should still have spaces
+                     parts.join
+                   else
+                     # More than 2 parts shouldn't happen in current design
+                     parts.join
+                   end
+
+          # Reaffirmation - preserve original format and determine spacing
+          if reaffirmation
+            # Check if year was originally 2-digit (original_year_4digit flag)
+            year_was_2digit = !original_year_4digit
+
+            # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
+            reaffirmation_was_4digit = original_reaffirmation_4digit
+
+            # Preserve original reaffirmation format
+            # If original was 4-digit, keep as 4-digit
+            # If original was 2-digit, convert from 4-digit storage back to 2-digit
+            reaffirmation_str = if reaffirmation_was_4digit
+                                  # Original was 4-digit, keep as-is
+                                  reaffirmation.to_s
+                                elsif reaffirmation.to_s.length == 4 && reaffirmation.to_s.start_with?(
+                                  "19", "20"
+                                )
+                                  # Original was 2-digit, convert 4-digit storage back to 2-digit
+                                  # (R2004) → (R04), (R1994) → (R94)
+                                  reaffirmation.to_s[2..3]
+                                else
+                                  # Already 2-digit or other format
+                                  reaffirmation.to_s
+                                end
+
+            # Determine spacing based on original formats
+            # Space needed if year is 2-digit and reaffirmation is 4-digit (original format)
+            # No space if both year and reaffirmation are 2-digit, or both are 4-digit
+            if year_was_2digit && reaffirmation_was_4digit
+              # Year was 2-digit, reaffirmation was 4-digit → add space
+              result += " (R#{reaffirmation_str})"
+            else
+              # Both 2-digit, both 4-digit, or other cases → no space
+              result += "(R#{reaffirmation_str})"
+            end
+          end
+
+          # Package (already has leading space from parser)
+          if package
+            result += package
+          end
+
+          result
+        end
+      end
+    end
+  end
+end