pubid 1.15.19 → 2.0.0.pre.alpha.2

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Csa
+    module Identifiers
+      class Bundled < Lutaml::Model::Serializable
+        attribute :base, Standard
+        attribute :bundled_with, Standard, collection: true
+        attribute :reaffirmation, :string
+        attribute :original_reaffirmation_4digit, :boolean, default: -> {
+          false
+        }
+        attribute :year_format, :string # Add for compatibility with identifier.rb
+
+        def to_s
+          # For Cec identifiers, use normalized form (code instead of cec_part + NO.)
+          # This is used for "normalized form" rendering in bundled identifiers
+          if base.is_a?(Cec)
+            # Render base with normalized code format
+            prefix = base.publisher_prefix || "CSA"
+            needs_space = !prefix.end_with?("-")
+            # Convert 4-digit year back to 2-digit for display
+            year_display = if base.year
+                             year_str = base.year.to_s
+                             if year_str.length == 4 && year_str.start_with?("20")
+                               year_str[2..3]
+                             else
+                               year_str
+                             end
+                           end
+            base_str = (needs_space ? "#{prefix} " : prefix) +
+              base.code.value.to_s + # Use normalized code (e.g., "C22.2-1")
+              ":#{year_display}"
+            parts = [base_str]
+          else
+            # Standard rendering for other identifier types
+            parts = [base.to_s]
+          end
+
+          # Add bundled amendments/supplements (without CSA prefix)
+          if bundled_with && !bundled_with.empty?
+            bundled_with.each do |bundled|
+              # For Cec identifiers, use normalized code format
+              if bundled.is_a?(Cec)
+                bundled_part = bundled.code.value.to_s # Normalized code (e.g., "C22.2-2")
+                if bundled.year
+                  # Use dash if year_format is dash, otherwise colon
+                  separator = bundled.year_format == "dash" ? "-" : ":"
+                  bundled_part += separator
+                  bundled_part += bundled.year_prefix if bundled.year_prefix # Add M or F prefix
+                  bundled_part += "F" if bundled.french && bundled.year_format != "dash" && !bundled.year_prefix
+                  # Convert 4-digit year back to 2-digit
+                  year_str = bundled.year.to_s
+                  bundled_part += if year_str.length == 4 && year_str.start_with?("20")
+                                    year_str[2..3]
+                                  else
+                                    year_str
+                                  end
+                end
+              else
+                # Standard rendering for other identifier types
+                bundled_part = ""
+                bundled_part += bundled.code.to_s if bundled.code
+
+                if bundled.year
+                  # Use dash if year_format is dash, otherwise colon
+                  separator = bundled.year_format == "dash" ? "-" : ":"
+                  bundled_part += separator
+                  bundled_part += bundled.year_prefix if bundled.year_prefix # Add M or F prefix
+                  bundled_part += "F" if bundled.french && bundled.year_format != "dash" && !bundled.year_prefix # Only add F if no prefix
+                  # Convert 4-digit year back to 2-digit
+                  # Use original_year_4digit flag to determine original format
+                  year_str = bundled.year.to_s
+                  bundled_part += if bundled.class.attributes.key?(:original_year_4digit) && bundled.original_year_4digit
+                                    # Preserve 4-digit format
+                                    year_str
+                                  elsif year_str.length == 4 && year_str.start_with?("20")
+                                    # 2000s → convert to 2-digit
+                                    year_str[2..3]
+                                  elsif year_str.length == 4 && year_str.start_with?("19") && bundled.class.attributes.key?(:original_year_4digit) && !bundled.original_year_4digit
+                                    # 1900s with no M/F prefix, but original was 2-digit (e.g., bundled identifier)
+                                    # Convert back to 2-digit
+                                    year_str[2..3]
+                                  else
+                                    # Other formats - keep as-is
+                                    year_str
+                                  end
+                end
+              end
+
+              parts << bundled_part
+            end
+          end
+
+          result = parts.join(" + ")
+
+          # Reaffirmation - preserve original format and determine spacing
+          if reaffirmation
+            # For bundled identifiers, check year format from base identifier
+            # to determine spacing
+            year_was_2digit = base.class.attributes.key?(:original_year_4digit) && !base.original_year_4digit
+
+            # Check if reaffirmation was originally 4-digit
+            # Note: We need to track this at the Bundled level, but for now
+            # assume 4-digit if the value is 4 digits and starts with 19/20
+            reaffirmation_was_4digit = reaffirmation.to_s.length == 4 &&
+              reaffirmation.to_s.start_with?("19", "20")
+
+            # Determine spacing based on original formats
+            # Space needed if year is 2-digit and reaffirmation is 4-digit
+            result += if year_was_2digit && reaffirmation_was_4digit
+                        " (R#{reaffirmation})"
+                      else
+                        "(R#{reaffirmation})"
+                      end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    module Identifiers
+      # CanadianAdoptedIdentifier represents Canadian adoption of standards
+      # indicated by the CAN/ prefix wrapper.
+      #
+      # Examples:
+      #   CAN/CSA-C22.2 NO. 60601-1-9:15
+      #   CAN/CSA-Z662:23 (R2024)
+      #
+      # This is a wrapper pattern where:
+      #   - CAN/ indicates Canadian adoption
+      #   - The wrapped_identifier is the actual CSA standard being adopted
+      #
+      # This is semantically different from a string prefix because:
+      #   - CAN/ wraps an entire identifier (which may itself be complex)
+      #   - The wrapped identifier is recursively parsed as a full CSA identifier
+      #   - Proper object composition, not string manipulation
+      class CanadianAdopted < WrapperIdentifier
+        def to_s
+          # For CAN3- identifiers, don't add CAN/ prefix (CAN3- is already complete)
+          # For Series with CAN/CSA- prefix, don't add CAN/ (it's already complete)
+          # For CAN/CSA- identifiers, CAN/ wraps CSA- part
+          if wrapped_identifier.class.attributes.key?(:publisher_prefix) && wrapped_identifier.publisher_prefix
+            prefix = wrapped_identifier.publisher_prefix
+            # CAN3- is standalone, just render wrapped identifier
+            # CAN/CSA- is already complete for Series identifiers
+            if prefix == "CAN3-" || (prefix == "CAN/CSA-" && wrapped_identifier.is_a?(Identifiers::Series))
+              result = wrapped_identifier.to_s
+            else
+              # For other cases, prepend CAN/ prefix
+              result = "CAN/#{wrapped_identifier}"
+            end
+          else
+            # No publisher_prefix, prepend CAN/
+            result = "CAN/#{wrapped_identifier}"
+          end
+          # Only add reaffirmation from wrapper if wrapped_identifier doesn't have one
+          # (to avoid duplicates - Identifier.parse sets it on both)
+          if reaffirmation && !(wrapped_identifier.class.attributes.key?(:reaffirmation) && wrapped_identifier.reaffirmation)
+            # Determine if space is needed before reaffirmation
+            # Space needed if year is 2-digit and reaffirmation is 4-digit (original format)
+            # No space if both year and reaffirmation are 2-digit
+            # Check original_year_4digit flag - if false, year was originally 2-digit
+            year_was_2digit = wrapped_identifier.class.attributes.key?(:original_year_4digit) &&
+              !wrapped_identifier.original_year_4digit
+            # Check 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
+
+            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 or other cases → no space
+              result += "(R#{reaffirmation_str})"
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    module Identifiers
+      # Canadian Electrical Code (CEC) identifier
+      # Pattern: CSA C22.{2,3,4,6} NO. {number}:{year}
+      # Examples: CSA C22.2 NO. 286:23, CSA C22.3 NO. 7:20
+      #
+      # The "NO." indicates a numbered standard within the C22.x series
+      # and must be preserved (not normalized) as a semantic component.
+      class Cec < SingleIdentifier
+        attribute :cec_part, Components::Code      # C22.2, C22.3, C22.4, C22.6
+        attribute :no_number, Components::Code     # Number after NO.
+
+        # Combined code attribute for compatibility
+        # Returns cec_part + "-" + no_number (e.g., "C22.2-1")
+        def code
+          return nil unless cec_part && no_number
+
+          @code ||= Components::Code.new(value: "#{cec_part.value}-#{no_number.value}")
+        end
+
+        def to_s
+          parts = []
+
+          # Publisher prefix (CSA, CAN/CSA-, CAN3-)
+          prefix = publisher_prefix || "CSA"
+
+          # Determine if we need space after prefix
+          # CAN/CSA- and CAN3- end with dash, so no space needed
+          needs_space = !prefix.end_with?("-")
+
+          parts << prefix unless prefix == ""
+
+          # CEC Part (C22.2, C22.3, etc.)
+          parts << cec_part.value if cec_part
+
+          # NO. notation - this is the key semantic component
+          parts << "NO."
+
+          # Number after NO.
+          parts << no_number.value if no_number
+
+          # Determine separator based on prefix ending
+          result = if prefix == ""
+                     parts.join(" ")
+                   elsif needs_space
+                     parts.join(" ")
+                   elsif parts.length <= 2
+                     # No space after dash-ending prefix (CAN/CSA-, CAN3-)
+                     # Join first two parts directly, rest with spaces
+                     parts.join
+                   else
+                     parts[0] + parts[1..].join(" ")
+                   end
+
+          # 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
+
+            # Convert 4-digit year back to 2-digit for display
+            year_str = year.to_s
+            display_year = if year_str.length == 4 && year_str.start_with?("20")
+                             year_str[2..3]
+                           elsif year_str.length == 4 && year_str.start_with?("19")
+                             year_str[2..3]
+                           else
+                             year_str
+                           end
+
+            # Add prefix if present
+            year_part += if year_prefix
+                           year_prefix + display_year
+                         elsif french && year_format != "dash"
+                           # Only add F if no prefix already set
+                           "F#{display_year}"
+                         else
+                           display_year
+                         end
+
+            result += year_part
+          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
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Csa
+    module Identifiers
+      # CombinedIdentifier represents CSA identifiers combined with "/" separator
+      # Examples:
+      #   CSA A23.1:24/CSA A23.2:24
+      #   CSA N285.0:23/CSA N285.6 SERIES:23
+      #   CSA A123.1-05/A123.5-05 (R2015)
+      #   CSA B44:19/B44.1:19/B44.2:19 (triple combined)
+      class Combined < Lutaml::Model::Serializable
+        attribute :first, Standard
+        attribute :second, Standard
+        attribute :third, Standard
+        attribute :reaffirmation, :string
+        attribute :original_reaffirmation_4digit, :boolean, default: -> {
+          false
+        }
+        attribute :package, :string
+        attribute :year_format, :string # Dummy for compatibility
+        attribute :separator, :string, default: -> { "/" } # "/" or ", "
+
+        def to_s
+          # For comma separator, render both parts with full prefix
+          # For slash separator, second/third parts without prefix
+          if separator == ", "
+            # Comma: Both with full CSA prefix
+            parts = [first.to_s, second.to_s]
+            parts << third.to_s if third
+          else
+            # Slash: Second and third without CSA prefix (continuation)
+            parts = [first.to_s]
+            parts << render_continuation(second)
+            parts << render_continuation(third) if third
+          end
+
+          result = parts.join(separator || "/")
+
+          # Reaffirmation - preserve original format and determine spacing
+          if reaffirmation
+            # For combined identifiers, check year format from first identifier
+            # to determine spacing
+            year_was_2digit = first.class.attributes.key?(:original_year_4digit) && !first.original_year_4digit
+
+            # Check if reaffirmation was originally 4-digit
+            # Note: We need to track this at the Combined level, but for now
+            # assume 4-digit if the value is 4 digits and starts with 19/20
+            reaffirmation_was_4digit = reaffirmation.to_s.length == 4 &&
+              reaffirmation.to_s.start_with?("19", "20")
+
+            # Determine spacing based on original formats
+            # Space needed if year is 2-digit and reaffirmation is 4-digit
+            result += if year_was_2digit && reaffirmation_was_4digit
+                        " (R#{reaffirmation})"
+                      else
+                        "(R#{reaffirmation})"
+                      end
+          end
+
+          result += package if package
+          result
+        end
+
+        private
+
+        # Render identifier without CSA prefix (unless has_publisher is true)
+        def render_continuation(identifier)
+          parts = []
+
+          # Add CSA prefix if present in original
+          if identifier.has_publisher
+            prefix = identifier.publisher_prefix || "CSA"
+            !prefix.end_with?("-")
+            parts << prefix
+          end
+
+          code_part = identifier.code.to_s if identifier.code
+
+          # NO. keyword
+          if identifier.no_number
+            code_part += " NO. #{identifier.no_number}"
+          end
+
+          # Series prefix and keyword (before year)
+          if identifier.series_prefix
+            code_part += " #{identifier.series_prefix} SERIES"
+          elsif identifier.series
+            # SERIES without prefix
+            code_part += " SERIES"
+          end
+
+          # Year with proper format (colon or dash)
+          if identifier.year
+            separator = identifier.year_format == "dash" ? "-" : ":"
+            year_part = separator
+            year_part += identifier.year_prefix if identifier.year_prefix # Add M or F prefix
+            year_part += "F" if identifier.french && identifier.year_format != "dash" && !identifier.year_prefix # Only add F if no prefix
+            # Convert 4-digit year back to 2-digit
+            year_str = identifier.year.to_s
+            year_part += if year_str.length == 4 && year_str.start_with?("20")
+                           year_str[2..3]
+                         else
+                           year_str
+                         end
+            code_part += year_part
+          end
+
+          parts << code_part if code_part
+
+          # Join with proper spacing based on prefix
+          if identifier.has_publisher && parts.length > 1
+            prefix = parts[0]
+            needs_space = !prefix.end_with?("-")
+            if needs_space
+              parts.join(" ")
+            else
+              # No space after dash-ending prefix
+              parts[0] + parts[1..].join(" ")
+            end
+          else
+            parts.join(" ")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    module Identifiers
+      # CsaAdoptedIdentifier represents CSA adoption of international standards
+      # (ISO, IEC, ISO/IEC, CISPR, etc.)
+      #
+      # Examples:
+      #   CSA ISO/IEC TR 12785-3:15
+      #   CSA ISO/IEC TR 19758:04 (R2024)
+      #   CSA CISPR 16-1-1:18
+      #   CSA-ISO 10012:03 (when wrapped by CanadianAdopted)
+      #
+      # Key difference from CanadianAdopted:
+      #   - CsaAdopted wraps ISO/IEC/CISPR standards (external)
+      #   - CanadianAdopted wraps CSA standards (internal)
+      #
+      # This is a wrapper pattern where:
+      #   - CSA prefix indicates adoption
+      #   - The wrapped_identifier is the external standard (ISO/IEC/CISPR)
+      #   - Wrapped identifier is recursively parsed using external flavor parsers
+      class CsaAdopted < WrapperIdentifier
+        # Publisher prefix (e.g., "CSA-", "CAN3-") for rendering
+        # When set, uses dash format without space (e.g., "CSA-ISO" not "CSA ISO")
+        attribute :publisher_prefix, :string
+
+        def to_s
+          # Get string representation from wrapped identifier
+          base_str = wrapped_identifier.to_s
+
+          # Convert 4-digit years to 2-digit for CSA adoption format
+          # ISO/IEC TR 12785-3:2015 → ISO/IEC TR 12785-3:15
+          # Also handle amendment years: /Amd 1:2022 → /A1:22
+          if base_str =~ /:(\d{4})\b/
+            year = $1
+            if year.start_with?("20")
+              short_year = year[2..3]
+              base_str = base_str.sub(":#{year}", ":#{short_year}")
+            elsif year.start_with?("19")
+              # Handle 1900s years: 1998 → 98
+              short_year = year[2..3]
+              base_str = base_str.sub(":#{year}", ":#{short_year}")
+            end
+          end
+
+          # Convert ISO/IEC amendment format to CSA format
+          # /Amd 1:22 → /A1:22, /Amd 1-22 → /A1-22
+          # Handle both 2-digit and 4-digit years
+          base_str = base_str.gsub(%r{/Amd\s+(\d+)([:/-])(\d{2,4})\b}) do |_match|
+            amendment_num = $1
+            separator = $2
+            amend_year = $3
+            # Convert 4-digit year to 2-digit if needed
+            if amend_year.length == 4 && amend_year.start_with?("20", "19")
+              amend_year = amend_year[2..3]
+            end
+            "/A#{amendment_num}#{separator}#{amend_year}"
+          end
+
+          # Apply publisher prefix format
+          # If publisher_prefix is "CSA-", render as "CSA-ISO..." (no space)
+          # Otherwise render as "CSA ISO..." (with space)
+          result = if publisher_prefix&.end_with?("-")
+                     "#{publisher_prefix}#{base_str}"
+                   else
+                     "CSA #{base_str}"
+                   end
+
+          # Append reaffirmation if present
+          result += " (R#{reaffirmation})" if reaffirmation
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    module Identifiers
+      # PackageIdentifier represents CSA standards sold as packages
+      # with additional materials (PDF, print, addenda, etc.)
+      #
+      # Examples:
+      #   CSA Z662:23 PACKAGE INCLUDES: +1 (PDF & ESA)
+      #   CSA B149.1:20 PACKAGE (PDF + PRINT)
+      #   CSA C22.2 NO. 60601-1:15 PACKAGE WITH ADDENDUM
+      #
+      # This is a composite pattern where:
+      #   - base_identifier is the core CSA standard (recursively parsed)
+      #   - package_materials describes what's included in the package
+      #   - Package portion is metadata, not a parseable identifier
+      #
+      # Difference from BundledIdentifier:
+      #   - Package: Single base + materials metadata
+      #   - Bundled: Multiple identifiers consolidated together
+      class Package < CompositeIdentifier
+        # Package materials/contents description
+        # Examples: "INCLUDES: +1 (PDF & ESA)", "(PDF + PRINT)", "WITH ADDENDUM"
+        attribute :package_materials, :string
+
+        # Package keyword variant (for future extensibility)
+        # Usually "PACKAGE" but could be variations
+        attribute :package_keyword, :string
+
+        # Track whether materials come before or after PACKAGE keyword
+        # true = materials AFTER: "CSA Z662:23 PACKAGE INCLUDES: +1"
+        # false = materials BEFORE: "CSA B149.1:25 Code, Handbook & Training Package"
+        attribute :materials_after_keyword, :boolean, default: -> { true }
+
+        def to_s
+          result = base_identifier.to_s
+
+          # Add package materials if present
+          if package_materials && !package_materials.empty?
+            if materials_after_keyword
+              # Format: {base} PACKAGE {materials}
+              result += " PACKAGE"
+              result += " #{package_materials}"
+            elsif package_materials.match?(/\sPACKAGE\s*$/i)
+              # Format: {base} {materials} PACKAGE
+              # Check if materials already end with "Package" (to preserve exact capitalization)
+              # Materials already include the Package suffix
+              result += " #{package_materials}"
+            else
+              # Add Package suffix (use the package_keyword value)
+              result += " #{package_materials}"
+              result += " #{package_keyword}"
+            end
+          else
+            # No materials, just add PACKAGE keyword
+            result += " PACKAGE"
+          end
+
+          result
+        end
+      end
+    end
+  end
+end