pubid 1.15.21 → 2.0.0.alpha.10

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Csa
+    module Identifiers
+      class Bundled < Identifier
+        # The consolidated base document and the amendments bundled with it.
+        # Both are typed cross-flavor and polymorphic — see
+        # WrapperIdentifier#base — because a bundle's base is routinely a Cec,
+        # which is not a Standard subclass. #root is inherited: it walks
+        # `base` to the origin document.
+        attribute :base, ::Pubid::Identifier, polymorphic: true
+        attribute :bundled_with, ::Pubid::Identifier, polymorphic: true,
+                                                      collection: true
+        attribute :reaffirmation, :string
+        attribute :original_reaffirmation_4digit, :boolean, default: -> {
+          false
+        }
+        attribute :year_format, :string # Add for compatibility with identifier.rb
+
+        # A bundle is a base document consolidated with its amendments, so
+        # both matching primitives peel to that base.
+        def base_document
+          base ? base.base_document : self
+        end
+
+        def drop_supplements
+          base || self
+        end
+
+        def to_s(**opts)
+          # For Cec identifiers, use normalized form (number 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.number.value.to_s + # 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.number.value.to_s # 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.number.to_s if bundled.number
+
+                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
+
+          annotate_plain_render(result, **opts)
+        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 base 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(**opts)
+          # 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 base.class.attributes.key?(:publisher_prefix) && base.publisher_prefix
+            prefix = base.publisher_prefix
+            # CAN3- is standalone, just render wrapped identifier
+            # CAN/CSA- is already complete for Series identifiers
+            if prefix == "CAN3-" || (prefix == "CAN/CSA-" && base.is_a?(Identifiers::Series))
+              result = base.to_s
+            else
+              # For other cases, prepend CAN/ prefix
+              result = "CAN/#{base}"
+            end
+          else
+            # No publisher_prefix, prepend CAN/
+            result = "CAN/#{base}"
+          end
+          # Only add reaffirmation from wrapper if base doesn't have one
+          # (to avoid duplicates - Identifier.parse sets it on both)
+          if reaffirmation && !(base.class.attributes.key?(:reaffirmation) && base.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 = base.class.attributes.key?(:original_year_4digit) &&
+              !base.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
+          annotate_plain_render(result, **opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# 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.
+
+        # `CSA C22.2 NO. 286:23` stores the joined "C22.2-286" in `number`, which
+        # appears nowhere in the printed form; the two halves it does print live
+        # in `cec_part` and `no_number`. Naming them gives the identifier its
+        # docnumber spans back.
+        def annotation_tokens
+          super + [
+            [:publisher_prefix, "publisher"],
+            [:cec_part, "docnumber"],
+            [:no_number, "docnumber"],
+          ]
+        end
+
+        # Merged with SingleIdentifier's block (lutaml combines an inherited
+        # key_value block with a subclass one), so this adds only the half of
+        # the code that Cec keeps separately.
+        key_value do
+          map "cec_part",
+              with: { to: :cec_part_to_kv, from: :cec_part_from_kv }
+        end
+
+        def cec_part_to_kv(model, doc)
+          emit_kv(doc, "cec_part", model.cec_part)
+        end
+
+        def cec_part_from_kv(model, value)
+          model.cec_part = Components::Code.new(value: value.to_s)
+        end
+
+        # The document code, synthesised from its two halves:
+        # cec_part + "-" + no_number (e.g. "C22.2-1"). This is the index key.
+        #
+        # It shadows the reader lutaml generates for the inherited `number`
+        # attribute, which is safe because Cec declares no `number` of its own
+        # — the ITU precedent (itu/identifiers/base.rb). `cec_part` and
+        # `no_number` are themselves serialized, so from_hash reproduces the
+        # synthesised value.
+        #
+        # Deliberately NOT memoised: `@number` is the very ivar lutaml uses to
+        # store the inherited attribute, so caching there would both discard a
+        # value assigned through the generated writer and go stale if
+        # `cec_part`/`no_number` were reassigned — and `number` is the relaton
+        # index key. The concatenation is trivial, so there is nothing to save.
+        def number
+          return nil unless cec_part && no_number
+
+          Components::Code.new(value: "#{cec_part.value}-#{no_number.value}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Csa
+    module Identifiers
+      # Combined represents CSA identifiers joined with "/" or ", "
+      # 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 < Identifier
+        # The co-equal designations, in printed order.
+        #
+        # One polymorphic collection, the IEC ConsolidatedIdentifier shape —
+        # not the historical first/second/third triple, which hard-capped the
+        # form at three and froze a non-standard hash shape. The first member
+        # is the primary designation, which is what #root walks so the index
+        # key is non-empty. Typed cross-flavor for the same reason as
+        # WrapperIdentifier#base.
+        attribute :identifiers, ::Pubid::Identifier, polymorphic: true,
+                                                     collection: true
+        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 ", "
+
+        # A combined id stores its members in `identifiers`, not `base`, so
+        # walk the primary designation to the origin document
+        # (Iec::Identifiers::ConsolidatedIdentifier does the same).
+        def root
+          identifiers&.first&.root || self
+        end
+
+        # Co-equal designations, so both matching primitives reduce to the
+        # primary one — the Iec::Identifiers::ConsolidatedIdentifier shape.
+        def base_document
+          identifiers&.first&.base_document || self
+        end
+
+        def drop_supplements
+          identifiers&.first || self
+        end
+
+        def to_s(**opts)
+          parts = render_parts
+          result = parts.join(separator || "/")
+          result += render_reaffirmation if reaffirmation
+          result += package if package
+          annotate_plain_render(result, **opts)
+        end
+
+        private
+
+        # With a comma separator every designation carries its full prefix;
+        # with a slash the trailing ones are continuations printed bare.
+        def render_parts
+          return identifiers.map(&:to_s) if separator == ", "
+
+          identifiers.each_with_index.map do |identifier, index|
+            index.zero? ? identifier.to_s : render_continuation(identifier)
+          end
+        end
+
+        # Reaffirmation - preserve original format and determine spacing.
+        # A space is needed when the year was printed 2-digit and the
+        # reaffirmation 4-digit; the year format comes from the primary
+        # designation.
+        def render_reaffirmation
+          primary = identifiers&.first
+          year_was_2digit =
+            primary &&
+            primary.class.attributes.key?(:original_year_4digit) &&
+            !primary.original_year_4digit
+
+          reaffirmation_was_4digit = reaffirmation.to_s.length == 4 &&
+            reaffirmation.to_s.start_with?("19", "20")
+
+          if year_was_2digit && reaffirmation_was_4digit
+            " (R#{reaffirmation})"
+          else
+            "(R#{reaffirmation})"
+          end
+        end
+
+        # 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
+            parts << (identifier.publisher_prefix || "CSA")
+          end
+
+          code_part = identifier.number.to_s if identifier.number
+
+          # 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
+
+          code_part += render_continuation_year(identifier) if identifier.year
+
+          parts << code_part if code_part
+
+          join_continuation(identifier, parts)
+        end
+
+        # Year with proper format (colon or dash)
+        def render_continuation_year(identifier)
+          separator = identifier.year_format == "dash" ? "-" : ":"
+          year_part = separator
+          # Add M or F prefix
+          year_part += identifier.year_prefix if identifier.year_prefix
+          # Only add F if no prefix
+          if identifier.french && identifier.year_format != "dash" &&
+              !identifier.year_prefix
+            year_part += "F"
+          end
+          # 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
+        end
+
+        # Join with proper spacing based on prefix
+        def join_continuation(identifier, parts)
+          return parts.join(" ") unless identifier.has_publisher &&
+            parts.length > 1
+
+          prefix = parts[0]
+          if prefix.end_with?("-")
+            # No space after dash-ending prefix
+            prefix + parts[1..].join(" ")
+          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 base 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(**opts)
+          # Get string representation from wrapped identifier
+          base_str = base.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
+
+          annotate_plain_render(result, **opts)
+        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 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(**opts)
+          result = base.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
+
+          annotate_plain_render(result, **opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    module Identifiers
+      # SeriesIdentifier represents CSA identifiers where SERIES
+      # is the primary document type, not just a keyword modifier
+      #
+      # Examples:
+      #   CSA MH SERIES 3.14:20
+      #   CSA RV SERIES 1:19
+      #   CSA SERIES Z1000:22
+      #
+      # Difference from Standard with series_keyword:
+      #   - Series: SERIES is the document type (primary)
+      #   - Standard: SERIES is a modifier keyword (secondary)
+      class Series < Base
+        # Series prefix (MH, RV, etc.) - optional
+        attribute :series_prefix, :string
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    module Identifiers
+      class Standard < Base
+      end
+    end
+  end
+end

data/lib/pubid/csa/identifiers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    module Identifiers
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Bundled, "#{__dir__}/identifiers/bundled"
+      autoload :CanadianAdopted, "#{__dir__}/identifiers/canadian_adopted"
+      autoload :Cec, "#{__dir__}/identifiers/cec"
+      autoload :Combined, "#{__dir__}/identifiers/combined"
+      autoload :CsaAdopted, "#{__dir__}/identifiers/csa_adopted"
+      autoload :Package, "#{__dir__}/identifiers/package"
+      autoload :Series, "#{__dir__}/identifiers/series"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end