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

data/lib/pubid/csa/builder.rb

@@ -53,7 +53,7 @@ module Pubid
         # Build base identifier (without package_portion)
         base_data = parsed_hash.dup
         base_data.delete(:package_portion)
-        package.base = build_single(base_data)
+        package.base_identifier = build_single(base_data)
 
         # Set package materials
         if parsed_hash[:package_portion]
@@ -101,7 +101,7 @@ module Pubid
           else
             begin
               Pubid::Iso.parse(base_str)
-            rescue Parslet::ParseFailed
+            rescue Pubid::Errors::ParseError
               Pubid::Iec.parse(base_str)
             end
           end
@@ -128,17 +128,17 @@ module Pubid
           end
           amendment_str = "#{base_str}/Amd #{parsed_hash[:adoption_amendment]}:#{wrapped_amendment_year}"
 
-          base = if adoption_org.start_with?("ISO", "CEI")
-                   Pubid::Iso.parse(amendment_str)
-                 elsif adoption_org.start_with?("IEC")
-                   Pubid::Iec.parse(amendment_str)
-                 else
-                   begin
-                     Pubid::Iso.parse(amendment_str)
-                   rescue Parslet::ParseFailed
-                     Pubid::Iec.parse(amendment_str)
-                   end
-                 end
+          wrapped_identifier = if adoption_org.start_with?("ISO", "CEI")
+                                 Pubid::Iso.parse(amendment_str)
+                               elsif adoption_org.start_with?("IEC")
+                                 Pubid::Iec.parse(amendment_str)
+                               else
+                                 begin
+                                   Pubid::Iso.parse(amendment_str)
+                                 rescue Pubid::Errors::ParseError
+                                   Pubid::Iec.parse(amendment_str)
+                                 end
+                               end
         else
           # No amendment, simple base identifier
           wrapped_id_str = "#{adoption_org} #{adoption_number}#{year_sep}#{wrapped_year}"
@@ -148,20 +148,20 @@ module Pubid
             wrapped_id_str = wrapped_id_str.sub("CEI/IEC", "IEC")
           end
 
-          base = if adoption_org.start_with?("ISO", "CEI")
-                   Pubid::Iso.parse(wrapped_id_str)
-                 elsif adoption_org.start_with?("IEC")
-                   Pubid::Iec.parse(wrapped_id_str)
-                 else
-                   begin
-                     Pubid::Iso.parse(wrapped_id_str)
-                   rescue Parslet::ParseFailed
-                     Pubid::Iec.parse(wrapped_id_str)
-                   end
-                 end
+          wrapped_identifier = if adoption_org.start_with?("ISO", "CEI")
+                                 Pubid::Iso.parse(wrapped_id_str)
+                               elsif adoption_org.start_with?("IEC")
+                                 Pubid::Iec.parse(wrapped_id_str)
+                               else
+                                 begin
+                                   Pubid::Iso.parse(wrapped_id_str)
+                                 rescue Pubid::Errors::ParseError
+                                   Pubid::Iec.parse(wrapped_id_str)
+                                 end
+                               end
         end
 
-        adoption.base = base
+        adoption.wrapped_identifier = wrapped_identifier
 
         # Handle reaffirmation
         if parsed_hash[:reaffirmation]
@@ -195,25 +195,23 @@ module Pubid
           # SERIES matched - build Series identifier with CAN/CSA- prefix
           # The Series.to_s will handle rendering as "CAN/CSA-A220 SERIES-06"
           # (keeping the full prefix instead of "CAN/CSA-A220...")
-          base = build_series(wrapped_data)
+          wrapped_identifier = build_series(wrapped_data)
           # Set the full publisher_prefix on the wrapped Series for proper rendering
-          # The test expects base.publisher_prefix to be "CAN/CSA-"
+          # The test expects wrapped_identifier.publisher_prefix to be "CAN/CSA-"
         elsif parsed_hash.key?(:cec_part)
           # CEC matched - build Cec identifier
-          base = build_cec(wrapped_data)
+          wrapped_identifier = build_cec(wrapped_data)
         else
           # Standard CSA identifier
-          base = build_single(wrapped_data)
+          wrapped_identifier = build_single(wrapped_data)
         end
-        base.publisher_prefix = original_prefix if original_prefix && base.class.attributes.key?(:publisher_prefix)
+        wrapped_identifier.publisher_prefix = original_prefix if original_prefix && wrapped_identifier.class.attributes.key?(:publisher_prefix)
 
-        canadian_adopted.base = base
+        canadian_adopted.wrapped_identifier = wrapped_identifier
 
-        # Handle reaffirmation - supports both 2-digit and 4-digit years.
-        # The wrapper's own original_reaffirmation_4digit is left at its
-        # default: CanadianAdopted#to_s only consults it when the wrapped id
-        # carries no reaffirmation of its own, and Series/Cec track the printed
-        # width themselves.
+        # Handle reaffirmation - supports both 2-digit and 4-digit years
+        # Note: CanadianAdopted (WrapperIdentifier) doesn't track original_reaffirmation_4digit
+        # That's only for Series/Cec identifiers
         if parsed_hash[:reaffirmation_4digit]
           # Original was 4-digit (e.g., "R2019")
           canadian_adopted.reaffirmation = parsed_hash[:reaffirmation_4digit].to_s
@@ -253,7 +251,7 @@ module Pubid
 
         # Code
         if parsed_hash[:code]
-          series.number = Components::Code.new(value: parsed_hash[:code].to_s)
+          series.code = Components::Code.new(value: parsed_hash[:code].to_s)
         end
 
         # Year format and year
@@ -453,10 +451,10 @@ module Pubid
       def build_combined(parsed_hash)
         combined = Identifiers::Combined.new
 
-        # Build each designation, in printed order, into one collection.
-        combined.identifiers = %i[first second third]
-          .filter_map { |key| parsed_hash[key] }
-          .map { |part| build_single(part) }
+        # Build each part
+        combined.first = build_single(parsed_hash[:first])
+        combined.second = build_single(parsed_hash[:second])
+        combined.third = build_single(parsed_hash[:third]) if parsed_hash[:third]
 
         # Detect separator from parser marker
         combined.separator = if parsed_hash[:comma_separator]
@@ -497,13 +495,15 @@ module Pubid
         identifier_class = select_identifier_class(data)
         identifier = identifier_class.new
 
-        # Publisher prefix (CAN/CSA-, CAN3-, or CSA).
-        # A code with no prefix in the original is a code_only identifier; the
-        # flag stops rendering from supplying the default "CSA".
+        # Publisher prefix (CAN/CSA-, CAN3-, or CSA)
+        # For code_only identifiers (no prefix in original), set to empty string
+        # to prevent default "CSA" from being added in rendering
         if data[:publisher_prefix]
           identifier.publisher_prefix = data[:publisher_prefix].to_s
-        elsif data[:code]
-          identifier.code_only = true
+        elsif data[:code] && !data[:publisher_prefix]
+          # Code exists but no publisher_prefix = code_only identifier
+          # Use empty string to indicate "no prefix wanted"
+          identifier.publisher_prefix = ""
         end
 
         # Publisher presence flag
@@ -520,13 +520,13 @@ module Pubid
           # Pattern: "C22.1-15" should become code="C22.1", year="2015"
           if !data[:year] && code_value =~ /^(.+)-(\d{2})$/
             # Split code and year
-            identifier.number = Components::Code.new(value: $1)
+            identifier.code = Components::Code.new(value: $1)
             # Convert 2-digit year to 4-digit
             year_2digit = $2
             identifier.year = "20#{year_2digit}"
             identifier.year_format = "dash"
           else
-            identifier.number = Components::Code.new(value: code_value)
+            identifier.code = Components::Code.new(value: code_value)
           end
         end
 

data/lib/pubid/csa/composite_identifier.rb

@@ -8,31 +8,20 @@ module Pubid
     # collections of other identifiers or package materials.
     #
     # Examples:
-    #   - Package: base + package materials
+    #   - 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 < Identifier
-      # The primary/base identifier. A real lutaml attribute under the uniform
-      # `base` name, so `#root` walks it and it survives serialization — see
-      # WrapperIdentifier#base for why the type is the cross-flavor
-      # ::Pubid::Identifier.
-      attribute :base, ::Pubid::Identifier, polymorphic: true
+    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(**_opts)
+      def to_s
         raise NotImplementedError, "Subclasses must implement to_s method"
       end
-
-      # A package peels to the standard it packages — see
-      # WrapperIdentifier#base_document.
-      def base_document
-        base ? base.base_document : self
-      end
-
-      def drop_supplements
-        base || self
-      end
     end
   end
 end

data/lib/pubid/csa/identifier.rb

@@ -2,38 +2,13 @@
 
 module Pubid
   module Csa
-    # Common base class for EVERY CSA identifier — the single-document types
-    # through SingleIdentifier, and the container types (WrapperIdentifier,
-    # CompositeIdentifier, Bundled, Combined) directly. So every CSA identifier
-    # is `is_a?(Pubid::Csa::Identifier)` natively and gets the shared
-    # polymorphic `from_hash`, `#root`, `#exclude` and MR rendering. The
-    # containers used to be separate Lutaml::Model types, which is what made
-    # `root.number` raise rather than return the relaton index key.
-    class Identifier < ::Pubid::Identifier
+    class Identifier
       def self.parse(input)
-        unless input.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if input.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
         # Filter out comments
-        if input.start_with?("#")
-          raise Pubid::Errors::ParseError.new(
-            "Not a CSA identifier (comment): #{input}",
-            input: input, flavor: "csa",
-          )
-        end
+        return nil if input.start_with?("#")
 
-        # Filter out non-standards (memberships, courses, newsletters)
-        if input.match?(/^CSA (Communities|Group|Learning|OnDemand|Update)/)
-          raise Pubid::Errors::ParseError.new(
-            "Not a CSA standard: #{input}", input: input, flavor: "csa"
-          )
-        end
+        # 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")
@@ -62,14 +37,16 @@ module Pubid
 
             # Parse normally (will create Bundled or Combined identifier)
             tree = Parser.new.parse(normalized)
-            result = build!(tree, input)
+            result = Builder.new.build(tree)
 
             # Apply CAN/CSA- prefix to the appropriate parts
-            set_publisher_prefix(result, "CAN/CSA-")
+            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
+              # Handle reaffirmation if present
+              if (wrapped_input =~ /\(R(\d{4})\)/) && result.class.attributes.key?(:reaffirmation)
+                result.reaffirmation = $1
+              end
             end
 
             return result
@@ -105,7 +82,8 @@ module Pubid
           wrapped_input = wrapped_input.sub(/^CSA-/, "CSA ")
 
           # Parse the wrapped identifier recursively
-          base = parse(wrapped_input)
+          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.
@@ -114,35 +92,32 @@ module Pubid
           # 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 base.class.attributes.key?(:publisher_prefix)
-            if is_can_csa && base.is_a?(Identifiers::Series)
+          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
-              base.publisher_prefix = "CAN/CSA-"
+              wrapped_identifier.publisher_prefix = "CAN/CSA-"
             elsif original_prefix
-              # For Combined identifiers, set on the primary designation
-              if base.is_a?(Identifiers::Combined) && base.identifiers&.first
-                primary = base.identifiers.first
-                if primary.class.attributes.key?(:publisher_prefix)
-                  primary.publisher_prefix = original_prefix
-                end
+              # 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
-                base.publisher_prefix = original_prefix
+                wrapped_identifier.publisher_prefix = original_prefix
               end
             end
           end
 
-          # Set reaffirmation on base if it has the attribute
-          if base.class.attributes.key?(:reaffirmation) && reaffirm_year
-            base.reaffirmation = reaffirm_year
-            if base.class.attributes.key?(:original_reaffirmation_4digit)
-              base.original_reaffirmation_4digit = reaffirmation_was_4digit
+          # 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.base = base
+          result.wrapped_identifier = wrapped_identifier
           result.reaffirmation = reaffirm_year if reaffirm_year
 
           return result
@@ -173,43 +148,44 @@ module Pubid
           end
 
           # Parse the wrapped identifier recursively
-          base = parse(wrapped_input)
+          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 && base.class.attributes.key?(:year_format)
-            base.year_format = "dash"
+          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 base.class.attributes.key?(:original_year_4digit)
-              base.original_year_4digit = false
+            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 base.is_a?(Identifiers::Series)
-            base.publisher_prefix = "CAN3-"
-            base.reaffirmation = reaffirm_year if reaffirm_year
-            base.original_reaffirmation_4digit = reaffirmation_was_4digit
-            return base
+          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 base.class.attributes.key?(:publisher_prefix)
-            base.publisher_prefix = "CAN3-"
+          if wrapped_identifier.class.attributes.key?(:publisher_prefix)
+            wrapped_identifier.publisher_prefix = "CAN3-"
           end
 
-          # Set reaffirmation on base if it has the attribute
-          if base.class.attributes.key?(:reaffirmation) && reaffirm_year
-            base.reaffirmation = reaffirm_year
-            if base.class.attributes.key?(:original_reaffirmation_4digit)
-              base.original_reaffirmation_4digit = reaffirmation_was_4digit
+          # 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.base = base
+          result.wrapped_identifier = wrapped_identifier
           result.reaffirmation = reaffirm_year if reaffirm_year
 
           return result
@@ -265,20 +241,13 @@ module Pubid
             "/Amd #{amendment_num}#{separator}#{amend_full_year}"
           end
 
-          # Parse with appropriate flavor parser. The helper probes several
-          # flavors and reports failure with nil; the public contract is a
-          # raise, so translate here.
-          base = parse_external_standard(wrapped_input)
-          unless base
-            raise Pubid::Errors::ParseError.new(
-              "Unparseable adopted standard: #{input}",
-              input: input, flavor: "csa",
-            )
-          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.base = base
+          result.wrapped_identifier = wrapped_identifier
           result.reaffirmation = reaffirm_year if reaffirm_year
 
           return result
@@ -359,9 +328,12 @@ module Pubid
               break if token.match?(/^PACKAGE$/i)
 
               test_input = base_input.empty? ? token : "#{base_input} #{token}"
-              break unless try_parse(test_input)
-
-              base_input = test_input
+              parsed = parse(test_input)
+              if parsed
+                base_input = test_input
+              else
+                break
+              end
             end
 
             # Extract materials as everything between base and PACKAGE
@@ -373,20 +345,13 @@ module Pubid
             end
           end
 
-          # Parse the base identifier recursively. An unparseable base is a
-          # failed package, not a nil.
-          if base_input.nil? || base_input.empty?
-            raise Pubid::Errors::ParseError.new(
-              "Unparseable package base: #{input}",
-              input: input, flavor: "csa",
-            )
-          end
-
-          base = parse(base_input)
+          # 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 = base
+          result.base_identifier = base_identifier
           # Set materials if present
           if package_materials && !package_materials.empty?
             result.package_materials = package_materials
@@ -419,61 +384,39 @@ module Pubid
         normalized = normalized.gsub("CAN3-", "CSA ")
 
         tree = Parser.new.parse(normalized)
-        result = build!(tree, input)
+        result = Builder.new.build(tree)
 
         # Set publisher prefix if detected
-        set_publisher_prefix(result, publisher_prefix) if publisher_prefix
+        if result && publisher_prefix
+          set_publisher_prefix(result, publisher_prefix)
+        end
 
         # Set year format if detected as dash and not already set
-        result.year_format = "dash" if has_dash_year && result.year_format.nil?
+        if result && has_dash_year && result.year_format.nil?
+          result.year_format = "dash"
+        end
 
         result
       rescue Parslet::ParseFailed => e
         raise e
       end
 
-      # Build a parse tree into an identifier, or fail loudly.
-      #
-      # Builder#build can return nil for a tree it recognises but cannot map
-      # to a class. `parse` must return an identifier or raise — every flavor
-      # but `api` already honours that — because a nil surfaces in the caller
-      # as a NoMethodError far from the input that caused it, rather than as a
-      # catchable parse failure.
-      def self.build!(tree, input)
-        built = Builder.new.build(tree)
-        return built if built
-
-        raise Pubid::Errors::ParseError.new(
-          "Unparseable CSA identifier: #{input}",
-          input: input, flavor: "csa",
-        )
-      end
-
-      # Probe whether a string parses. The package base scan walks
-      # progressively longer prefixes and keeps the longest that succeeds, so
-      # it is the one caller that genuinely wants a nil rather than a raise.
-      def self.try_parse(input)
-        parse(input)
-      rescue Parslet::ParseFailed, ArgumentError
-        nil
-      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. The primary designation always
-        # takes the prefix; a trailing one only when it printed a publisher of
-        # its own (a bare continuation must stay bare).
+        # Set on combined identifier parts
         if obj.is_a?(Identifiers::Combined)
-          Array(obj.identifiers).each_with_index do |part, index|
-            next unless part.class.attributes.key?(:publisher_prefix)
-            next if index.positive? &&
-              !(part.class.attributes.key?(:has_publisher) && part.has_publisher)
-
-            part.publisher_prefix = prefix
+          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
 
@@ -484,6 +427,9 @@ module Pubid
       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
@@ -506,65 +452,6 @@ module Pubid
 
         nil
       end
-
-      # CSA stores the publication year in its own plain `year` string
-      # attribute (not a `Components::Date`), so the base `#exclude`'s
-      # `:year`->`:date` remap nils the unused inherited `date` and leaves
-      # `year` intact. Override to nil `year` (and its formatting metadata)
-      # when `:year`/`:date` is excluded, so a partial (year-less) CSA
-      # reference is a year wildcard under `matches?(row, ignore: [:year])`.
-      # The metadata attrs (`year_format`, `year_prefix`,
-      # `original_year_4digit`, `french`) are year-derived — a year-less
-      # parse leaves them nil/false, so they must be reset here too or `==`
-      # would still differ. `french` in particular is only ever set from a
-      # `:F` year prefix (the French-edition form `CSA B149.1:F20`), so a
-      # bare `CSA B149.1` reference must wildcard it to match both the
-      # English and French editions of a document number. `super` preserves
-      # the base recursion into nested identifiers (adoption wrappers
-      # delegate their year to an inner id and lack a `year` accessor, hence
-      # the `respond_to?` guard). Mirrors BIPM.
-      def exclude(*args)
-        result = super
-        year_keys = args & %i[year date]
-        if !year_keys.empty? && result.respond_to?(:year=)
-          result.year = nil
-          result.year_format = nil
-          result.year_prefix = nil
-          result.original_year_4digit = false
-          result.french = nil
-        end
-        result
-      end
-
-      # CSA encodes its identity across many shape-specific attributes
-      # (`publisher_prefix`, `number`, `no_number`, `series`, `series_prefix`,
-      # `package`, `reaffirmation`, `year` with prefix/format/French markers,
-      # etc.) that the generic MrString renderer doesn't know about. The
-      # CSA `to_s` already round-trips losslessly through the CSA parser, so
-      # MR mirrors it: ` ` → `.`, `:` → `.` (so the year never looks like
-      # another code segment), `/` → `-` (CAN/CSA- prefix), then lowercased
-      # to match the all-lowercase MR convention (issue #142).
-      #
-      # Those three are the SEMANTIC mappings — they carry CSA's segment
-      # structure. Everything else is then neutralised by CHARSET, not by an
-      # enumerated escape list, so a character that appears in a future
-      # reference cannot leak into what `to_slug` hands a filesystem. CSA
-      # references really do carry `(`, `)`, `,`, `&` and `+` today
-      # (`CSA C22.2 NO. 100:14 (R2024)`, `… Code, Handbook & Training
-      # Package`, `… + A1:15`), and the old `tr` chain let all of them
-      # through — 601 of 816 slugs were not filename-safe. The BIPM `mr_slug`
-      # precedent.
-      def to_mr_string
-        to_s
-          .downcase
-          .tr(" ", ".").tr(":", ".").tr("/", "-")
-          .gsub(/[^a-z0-9._-]+/, "-")
-          .gsub(/\A[-.]+|[-.]+\z/, "")
-      end
-
-      def to_slug
-        to_mr_string
-      end
     end
   end
 end