dalli 3.1.5 → 3.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a9612ab509bc2a6b7bd2560a7a10564183b3b9fbb2aa0655f339b30067407fa
-  data.tar.gz: 510c3ed03a4e2b4ae4e7f8540eac19e7d28508341b768edc938f9886d5504fbe
+  metadata.gz: d9a374b5939ef874ce8067059c88b088c9129e7ab09ff891b1ad1ca3cf13c3ce
+  data.tar.gz: d5937c697bcd86a6d3d4207d328ce7e73c854b93a1d19e402630c3f80caec2ec
 SHA512:
-  metadata.gz: 81e31363e781e948f66c3a143cd506162e4b51b4c67bb76a8cbdbfb2efdcdbd279216b24cdc077c3c2e4ad88b356ffec1a74f4428c556b05d17591b171b874d2
-  data.tar.gz: ef45c25f8552e203751a51cb32172b5670b6b509ac45cbcc41b19a4f70688f0f50eb01b09af32c3faa05d643dd93acce2e748d8cedbba5dded585070b6ed7ec6
+  metadata.gz: 36010355440b325c1f8d5b922e882a8a8e199b8bd48dda92b1dcc4866f29e81b536ce41ff4896441c6c2c4f4e8e8faaf891ca6355e47de91733baf10bdfa9eee
+  data.tar.gz: 0c2b42e88960838ceef44c6c0f696b938925ade65da7c8791a07539ca36e18d6e874693dfde840a08e78ac9076f6810735a05d137c98d8c64387414f89d6f016

data/{History.md → CHANGELOG.md}

@@ -4,16 +4,66 @@ Dalli Changelog
 Unreleased
 ==========
 
+3.2.6
+==========
+
+- Rescue IO::TimeoutError raised by Ruby since 3.2.0 on blocking reads/writes (skaes)
+- Fix rubydoc link (JuanitoFatas)
+
+3.2.5
+==========
+
+- Better handle memcached requests being interrupted by Thread#raise or Thread#kill (byroot)
+- Unexpected errors are no longer treated as `Dalli::NetworkError`, including errors raised by `Timeout.timeout` (byroot)
+
+3.2.4
+==========
+
+- Cache PID calls for performance since glibc no longer caches in recent versions (byroot)
+- Preallocate the read buffer in Socket#readfull (byroot)
+
+3.2.3
+==========
+
+- Sanitize CAS inputs to ensure additional commands are not passed to memcached (xhzeem / petergoldstein)
+- Sanitize input to flush command to ensure additional commands are not passed to memcached (xhzeem / petergoldstein)
+- Namespaces passed as procs are now evaluated every time, as opposed to just on initialization (nrw505)
+- Fix missing require of uri in ServerConfigParser (adam12)
+- Fix link to the CHANGELOG.md file in README.md (rud)
+
+3.2.2
+==========
+
+- Ensure apps are resilient against old session ids (kbrock)
+
+3.2.1
+==========
+
+- Fix null replacement bug on some SASL-authenticated services (veritas1)
+
+3.2.0
+==========
+
+- BREAKING CHANGE: Remove protocol_implementation client option (petergoldstein)
+- Add protocol option with meta implementation (petergoldstein)
+
+3.1.6
+==========
+
+- Fix bug with cas/cas! with "Not found" value (petergoldstein)
+- Add Ruby 3.1 to CI (petergoldstein)
+- Replace reject(&:nil?) with compact (petergoldstein)
+
 3.1.5
 ==========
 
-- Fix bug with get_cas key with "Not found" value [petergoldstein]
+- Fix bug with get_cas key with "Not found" value (petergoldstein)
 - Replace should return nil, not raise error, on miss (petergoldstein)
 
 3.1.4
 ==========
 
-- Improve response parsing performance (casperisfine)
+- Improve response parsing performance (byroot)
 - Reorganize binary protocol parsing a bit (petergoldstein)
 - Fix handling of non-ASCII keys in get_multi (petergoldstein)
 
@@ -100,6 +150,9 @@ Unreleased
   * The Rack session adapter has been refactored to remove support for thread-unsafe
     configurations. You will need to include the `connection_pool` gem in
     your Gemfile to ensure session operations are thread-safe.
+  * When using namespaces, the algorithm for calculating truncated keys was
+    changed.  Non-truncated keys and truncated keys for the non-namespace
+    case were left unchanged.
 
 - Raise NetworkError when multi response gets into corrupt state (mervync, #783)
 - Validate servers argument (semaperepelitsa, petergoldstein, #776)

data/Gemfile

@@ -4,13 +4,18 @@ source 'https://rubygems.org'
 
 gemspec
 
-group :test do
-  gem 'minitest'
-  gem 'rake'
+group :development, :test do
+  gem 'connection_pool'
+  gem 'minitest', '~> 5'
+  gem 'rack', '~> 2.0', '>= 2.2.0'
+  gem 'rake', '~> 13.0'
   gem 'rubocop'
   gem 'rubocop-minitest'
   gem 'rubocop-performance'
   gem 'rubocop-rake'
-  gem 'ruby-prof', platform: :mri
   gem 'simplecov'
 end
+
+group :test do
+  gem 'ruby-prof', platform: :mri
+end

data/README.md

@@ -23,11 +23,17 @@ The name is a variant of Salvador Dali for his famous painting [The Persistence
 * [Announcements](https://github.com/petergoldstein/dalli/discussions/categories/announcements) - Announcements of interest to the Dalli community will be posted here.
 * [Bug Reports](https://github.com/petergoldstein/dalli/issues) - If you discover a problem with Dalli, please submit a bug report in the tracker.
 * [Forum](https://github.com/petergoldstein/dalli/discussions/categories/q-a) - If you have questions about Dalli, please post them here.
-* [Client API](https://www.rubydoc.info/github/petergoldstein/dalli/master/Dalli/Client) - Ruby documentation for the `Dalli::Client` API
+* [Client API](https://www.rubydoc.info/gems/dalli) - Ruby documentation for the `Dalli::Client` API
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## Contributing
 
-If you have a fix you wish to provide, please fork the code, fix in your local project and then send a pull request on github.  Please ensure that you include a test which verifies your fix and update `History.md` with a one sentence description of your fix so you get credit as a contributor.
+If you have a fix you wish to provide, please fork the code, fix in your local project and then send a pull request on github.  Please ensure that you include a test which verifies your fix and update the [changelog](CHANGELOG.md) with a one sentence description of your fix so you get credit as a contributor.
 
 ## Appreciation
 

data/lib/dalli/client.rb

@@ -43,11 +43,11 @@ module Dalli
     #                 #fetch operations.
     # - :digest_class - defaults to Digest::MD5, allows you to pass in an object that responds to the hexdigest method,
     #                   useful for injecting a FIPS compliant hash object.
-    # - :protocol_implementation - defaults to Dalli::Protocol::Binary which uses the binary protocol. Allows you to
-    #                              pass an alternative implementation using another protocol.
+    # - :protocol - one of either :binary or :meta, defaulting to :binary.  This sets the protocol that Dalli uses
+    #               to communicate with memcached.
     #
     def initialize(servers = nil, options = {})
-      @servers = ::Dalli::ServersArgNormalizer.normalize_servers(servers)
+      @normalized_servers = ::Dalli::ServersArgNormalizer.normalize_servers(servers)
       @options = normalize_options(options)
       @key_manager = ::Dalli::KeyManager.new(@options)
       @ring = nil
@@ -375,7 +375,6 @@ module Dalli
 
     def cas_core(key, always_set, ttl = nil, req_options = nil)
       (value, cas) = perform(:cas, key)
-      value = nil if !value || value == 'Not found'
       return if value.nil? && !always_set
 
       newvalue = yield(value)
@@ -393,17 +392,16 @@ module Dalli
     end
 
     def ring
-      # TODO: This server initialization should probably be pushed down
-      # to the Ring
-      @ring ||= Dalli::Ring.new(
-        @servers.map do |s|
-          protocol_implementation.new(s, @options)
-        end, @options
-      )
+      @ring ||= Dalli::Ring.new(@normalized_servers, protocol_implementation, @options)
     end
 
     def protocol_implementation
-      @protocol_implementation ||= @options.fetch(:protocol_implementation, Dalli::Protocol::Binary)
+      @protocol_implementation ||= case @options[:protocol]&.to_s
+                                   when 'meta'
+                                     Dalli::Protocol::Meta
+                                   else
+                                     Dalli::Protocol::Binary
+                                   end
     end
 
     ##

data/lib/dalli/key_manager.rb

@@ -61,7 +61,7 @@ module Dalli
     def key_with_namespace(key)
       return key if namespace.nil?
 
-      "#{namespace}#{NAMESPACE_SEPARATOR}#{key}"
+      "#{evaluate_namespace}#{NAMESPACE_SEPARATOR}#{key}"
     end
 
     def key_without_namespace(key)
@@ -75,6 +75,8 @@ module Dalli
     end
 
     def namespace_regexp
+      return /\A#{Regexp.escape(evaluate_namespace)}:/ if namespace.is_a?(Proc)
+
       @namespace_regexp ||= /\A#{Regexp.escape(namespace)}:/.freeze unless namespace.nil?
     end
 
@@ -87,9 +89,15 @@ module Dalli
     def namespace_from_options
       raw_namespace = @key_options[:namespace]
       return nil unless raw_namespace
-      return raw_namespace.call.to_s if raw_namespace.is_a?(Proc)
+      return raw_namespace.to_s unless raw_namespace.is_a?(Proc)
+
+      raw_namespace
+    end
+
+    def evaluate_namespace
+      return namespace.call.to_s if namespace.is_a?(Proc)
 
-      raw_namespace.to_s
+      namespace
     end
 
     ##

data/lib/dalli/pid_cache.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # Dalli::PIDCache is a wrapper class for PID checking to avoid system calls when checking the PID.
+  ##
+  module PIDCache
+    if !Process.respond_to?(:fork) # JRuby or TruffleRuby
+      @pid = Process.pid
+      singleton_class.attr_reader(:pid)
+    elsif Process.respond_to?(:_fork) # Ruby 3.1+
+      class << self
+        attr_reader :pid
+
+        def update!
+          @pid = Process.pid
+        end
+      end
+      update!
+
+      ##
+      # Dalli::PIDCache::CoreExt hooks into Process to be able to reset the PID cache after fork
+      ##
+      module CoreExt
+        def _fork
+          child_pid = super
+          PIDCache.update! if child_pid.zero?
+          child_pid
+        end
+      end
+      Process.singleton_class.prepend(CoreExt)
+    else # Ruby 3.0 or older
+      class << self
+        def pid
+          Process.pid
+        end
+      end
+    end
+  end
+end

data/lib/dalli/pipelined_getter.rb

@@ -167,7 +167,7 @@ module Dalli
       groups = @ring.keys_grouped_by_server(keys)
       if (unfound_keys = groups.delete(nil))
         Dalli.logger.debug do
-          "unable to get keys for #{unfound_keys.length} keys "\
+          "unable to get keys for #{unfound_keys.length} keys " \
             'because no matching server was found'
         end
       end

data/lib/dalli/protocol/base.rb

@@ -32,7 +32,13 @@ module Dalli
         verify_state(opkey)
 
         begin
-          send(opkey, *args)
+          @connection_manager.start_request!
+          response = send(opkey, *args)
+
+          # pipelined_get emit query but doesn't read the response(s)
+          @connection_manager.finish_request! unless opkey == :pipelined_get
+
+          response
         rescue Dalli::MarshalError => e
           log_marshal_err(args.first, e)
           raise
@@ -40,7 +46,8 @@ module Dalli
           raise
         rescue StandardError => e
           log_unexpected_err(e)
-          down!
+          close
+          raise
         end
       end
 
@@ -65,10 +72,9 @@ module Dalli
       #
       # Returns nothing.
       def pipeline_response_setup
-        verify_state(:getkq)
+        verify_pipelined_state(:getkq)
         write_noop
         response_buffer.reset
-        @connection_manager.start_request!
       end
 
       # Attempt to receive and parse as many key/value pairs as possible
@@ -100,7 +106,7 @@ module Dalli
         end
 
         values
-      rescue SystemCallError, Timeout::Error, EOFError => e
+      rescue SystemCallError, *TIMEOUT_ERRORS, EOFError => e
         @connection_manager.error_on_request!(e)
       end
 
@@ -127,11 +133,11 @@ module Dalli
       end
 
       def username
-        @options[:username] || ENV['MEMCACHE_USERNAME']
+        @options[:username] || ENV.fetch('MEMCACHE_USERNAME', nil)
       end
 
       def password
-        @options[:password] || ENV['MEMCACHE_PASSWORD']
+        @options[:password] || ENV.fetch('MEMCACHE_PASSWORD', nil)
       end
 
       def require_auth?
@@ -147,6 +153,13 @@ module Dalli
 
       private
 
+      ALLOWED_QUIET_OPS = %i[add replace set delete incr decr append prepend flush noop].freeze
+      def verify_allowed_quiet!(opkey)
+        return if ALLOWED_QUIET_OPS.include?(opkey)
+
+        raise Dalli::NotPermittedMultiOpError, "The operation #{opkey} is not allowed in a quiet block."
+      end
+
       ##
       # Checks to see if we can execute the specified operation.  Checks
       # whether the connection is in use, and whether the command is allowed
@@ -162,6 +175,11 @@ module Dalli
         raise_down_error unless ensure_connected!
       end
 
+      def verify_pipelined_state(_opkey)
+        @connection_manager.confirm_in_progress!
+        raise_down_error unless connected?
+      end
+
       # The socket connection to the underlying server is initialized as a side
       # effect of this call.  In fact, this is the ONLY place where that
       # socket connection is initialized.
@@ -190,8 +208,6 @@ module Dalli
         authenticate_connection if require_auth?
         @version = version # Connect socket if not authed
         up!
-      rescue Dalli::DalliError
-        raise
       end
 
       def pipelined_get(keys)

data/lib/dalli/protocol/binary/request_formatter.rb

@@ -86,7 +86,7 @@ module Dalli
           touch: TTL_AND_KEY,
           gat: TTL_AND_KEY
         }.freeze
-        FORMAT = BODY_FORMATS.transform_values { |v| REQ_HEADER_FORMAT + v; }
+        FORMAT = BODY_FORMATS.transform_values { |v| REQ_HEADER_FORMAT + v }
 
         # rubocop:disable Metrics/ParameterLists
         def self.standard_request(opkey:, key: nil, value: nil, opaque: 0, cas: 0, bitflags: nil, ttl: nil)
@@ -94,7 +94,7 @@ module Dalli
           key_len = key.nil? ? 0 : key.bytesize
           value_len = value.nil? ? 0 : value.bytesize
           header = [REQUEST, OPCODES[opkey], key_len, extra_len, 0, 0, extra_len + key_len + value_len, opaque, cas]
-          body = [bitflags, ttl, key, value].reject(&:nil?)
+          body = [bitflags, ttl, key, value].compact
           (header + body).pack(FORMAT[opkey])
         end
         # rubocop:enable Metrics/ParameterLists
@@ -109,7 +109,7 @@ module Dalli
         end
 
         def self.as_8byte_uint(val)
-          [val >> 32, 0xFFFFFFFF & val]
+          [val >> 32, val & 0xFFFFFFFF]
         end
       end
     end

data/lib/dalli/protocol/binary/response_processor.rb

@@ -50,9 +50,9 @@ module Dalli
           extra_len = resp_header.extra_len
           key_len = resp_header.key_len
           bitflags = extra_len.positive? ? body.unpack1('N') : 0x0
-          key = body.byteslice(extra_len, key_len).force_encoding('UTF-8') if key_len.positive?
+          key = body.byteslice(extra_len, key_len).force_encoding(Encoding::UTF_8) if key_len.positive?
           value = body.byteslice((extra_len + key_len)..-1)
-          value = parse_as_stored_value ? @value_marshaller.retrieve(value, bitflags) : value
+          value = @value_marshaller.retrieve(value, bitflags) if parse_as_stored_value
           [key, value]
         end
 

data/lib/dalli/protocol/binary/sasl_authentication.rb

@@ -15,7 +15,7 @@ module Dalli
 
           # Substitute spaces for the \x00 returned by
           # memcached as a separator for easier
-          content&.tr("\u0000", ' ')
+          content&.tr!("\u0000", ' ')
           mechanisms = content&.split
           [status, mechanisms]
         end

data/lib/dalli/protocol/binary.rb

@@ -18,13 +18,6 @@ module Dalli
 
       private
 
-      ALLOWED_QUIET_OPS = %i[add replace set delete incr decr append prepend flush noop].freeze
-      def verify_allowed_quiet!(opkey)
-        return if ALLOWED_QUIET_OPS.include?(opkey)
-
-        raise Dalli::NotPermittedMultiOpError, "The operation #{opkey} is not allowed in a quiet block."
-      end
-
       # Retrieval Commands
       def get(key, options = nil)
         req = RequestFormatter.standard_request(opkey: :get, key: key)

data/lib/dalli/protocol/connection_manager.rb

@@ -4,6 +4,8 @@ require 'English'
 require 'socket'
 require 'timeout'
 
+require 'dalli/pid_cache'
+
 module Dalli
   module Protocol
     ##
@@ -51,7 +53,8 @@ module Dalli
         Dalli.logger.debug { "Dalli::Server#connect #{name}" }
 
         @sock = memcached_socket
-        @pid = Process.pid
+        @pid = PIDCache.pid
+        @request_in_progress = false
       rescue SystemCallError, Timeout::Error, EOFError, SocketError => e
         # SocketError = DNS resolution failure
         error_on_request!(e)
@@ -96,7 +99,13 @@ module Dalli
       end
 
       def confirm_ready!
-        error_on_request!(RuntimeError.new('Already writing to socket')) if request_in_progress?
+        close if request_in_progress?
+        close_on_fork if fork_detected?
+      end
+
+      def confirm_in_progress!
+        raise '[Dalli] No request in progress. This may be a bug in Dalli.' unless request_in_progress?
+
         close_on_fork if fork_detected?
       end
 
@@ -122,10 +131,14 @@ module Dalli
       end
 
       def start_request!
+        raise '[Dalli] Request already in progress. This may be a bug in Dalli.' if @request_in_progress
+
         @request_in_progress = true
       end
 
       def finish_request!
+        raise '[Dalli] No request in progress. This may be a bug in Dalli.' unless @request_in_progress
+
         @request_in_progress = false
       end
 
@@ -133,27 +146,27 @@ module Dalli
         @request_in_progress = false
       end
 
-      def read(count)
-        start_request!
-        data = @sock.readfull(count)
-        finish_request!
+      def read_line
+        data = @sock.gets("\r\n")
+        error_on_request!('EOF in read_line') if data.nil?
         data
-      rescue SystemCallError, Timeout::Error, EOFError => e
+      rescue SystemCallError, *TIMEOUT_ERRORS, EOFError => e
+        error_on_request!(e)
+      end
+
+      def read(count)
+        @sock.readfull(count)
+      rescue SystemCallError, *TIMEOUT_ERRORS, EOFError => e
         error_on_request!(e)
       end
 
       def write(bytes)
-        start_request!
-        result = @sock.write(bytes)
-        finish_request!
-        result
-      rescue SystemCallError, Timeout::Error => e
+        @sock.write(bytes)
+      rescue SystemCallError, *TIMEOUT_ERRORS => e
         error_on_request!(e)
       end
 
-      # Non-blocking read.  Should only be used in the context
-      # of a caller who has called start_request!, but not yet
-      # called finish_request!.  Here to support the operation
+      # Non-blocking read.  Here to support the operation
       # of the get_multi operation
       def read_nonblock
         @sock.read_available
@@ -216,7 +229,7 @@ module Dalli
       end
 
       def fork_detected?
-        @pid && @pid != Process.pid
+        @pid && @pid != PIDCache.pid
       end
 
       def log_down_detected

data/lib/dalli/protocol/meta/key_regularizer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Dalli
+  module Protocol
+    class Meta
+      ##
+      # The meta protocol requires that keys be ASCII only, so Unicode keys are
+      # not supported.  In addition, the use of whitespace in the key is not
+      # allowed.
+      # memcached supports the use of base64 hashes for keys containing
+      # whitespace or non-ASCII characters, provided the 'b' flag is included in the request.
+      class KeyRegularizer
+        WHITESPACE = /\s/.freeze
+
+        def self.encode(key)
+          return [key, false] if key.ascii_only? && !WHITESPACE.match(key)
+
+          [Base64.strict_encode64(key), true]
+        end
+
+        def self.decode(encoded_key, base64_encoded)
+          return encoded_key unless base64_encoded
+
+          Base64.strict_decode64(encoded_key).force_encoding(Encoding::UTF_8)
+        end
+      end
+    end
+  end
+end

data/lib/dalli/protocol/meta/request_formatter.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: false
+
+module Dalli
+  module Protocol
+    class Meta
+      ##
+      # Class that encapsulates logic for formatting meta protocol requests
+      # to memcached.
+      ##
+      class RequestFormatter
+        # Since these are string construction methods, we're going to disable these
+        # Rubocop directives.  We really can't make this construction much simpler,
+        # and introducing an intermediate object seems like overkill.
+        #
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable Metrics/PerceivedComplexity
+        def self.meta_get(key:, value: true, return_cas: false, ttl: nil, base64: false, quiet: false)
+          cmd = "mg #{key}"
+          cmd << ' v f' if value
+          cmd << ' c' if return_cas
+          cmd << ' b' if base64
+          cmd << " T#{ttl}" if ttl
+          cmd << ' k q s' if quiet # Return the key in the response if quiet
+          cmd + TERMINATOR
+        end
+
+        def self.meta_set(key:, value:, bitflags: nil, cas: nil, ttl: nil, mode: :set, base64: false, quiet: false)
+          cmd = "ms #{key} #{value.bytesize}"
+          cmd << ' c' unless %i[append prepend].include?(mode)
+          cmd << ' b' if base64
+          cmd << " F#{bitflags}" if bitflags
+          cmd << cas_string(cas)
+          cmd << " T#{ttl}" if ttl
+          cmd << " M#{mode_to_token(mode)}"
+          cmd << ' q' if quiet
+          cmd << TERMINATOR
+          cmd << value
+          cmd + TERMINATOR
+        end
+
+        def self.meta_delete(key:, cas: nil, ttl: nil, base64: false, quiet: false)
+          cmd = "md #{key}"
+          cmd << ' b' if base64
+          cmd << cas_string(cas)
+          cmd << " T#{ttl}" if ttl
+          cmd << ' q' if quiet
+          cmd + TERMINATOR
+        end
+
+        def self.meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, base64: false, quiet: false)
+          cmd = "ma #{key} v"
+          cmd << ' b' if base64
+          cmd << " D#{delta}" if delta
+          cmd << " J#{initial}" if initial
+          # Always set a TTL if an initial value is specified
+          cmd << " N#{ttl || 0}" if ttl || initial
+          cmd << cas_string(cas)
+          cmd << ' q' if quiet
+          cmd << " M#{incr ? 'I' : 'D'}"
+          cmd + TERMINATOR
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/ParameterLists
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        def self.meta_noop
+          "mn#{TERMINATOR}"
+        end
+
+        def self.version
+          "version#{TERMINATOR}"
+        end
+
+        def self.flush(delay: nil, quiet: false)
+          cmd = +'flush_all'
+          cmd << " #{parse_to_64_bit_int(delay, 0)}" if delay
+          cmd << ' noreply' if quiet
+          cmd + TERMINATOR
+        end
+
+        def self.stats(arg = nil)
+          cmd = +'stats'
+          cmd << " #{arg}" if arg
+          cmd + TERMINATOR
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def self.mode_to_token(mode)
+          case mode
+          when :add
+            'E'
+          when :replace
+            'R'
+          when :append
+            'A'
+          when :prepend
+            'P'
+          else
+            'S'
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def self.cas_string(cas)
+          cas = parse_to_64_bit_int(cas, nil)
+          cas.nil? || cas.zero? ? '' : " C#{cas}"
+        end
+
+        def self.parse_to_64_bit_int(val, default)
+          val.nil? ? nil : Integer(val)
+        rescue ArgumentError
+          # Sanitize to default if it isn't parsable as an integer
+          default
+        end
+      end
+    end
+  end
+end