active_remote-cached 1.1.1 → 1.3.0

data/lib/active_remote/cached.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support'
 require 'active_support/cache'
 require 'active_support/concern'
@@ -19,23 +21,60 @@ module ActiveRemote
     RUBY_AND_ACTIVE_SUPPORT_VERSION = "#{RUBY_ENGINE_VERSION}:#{ActiveSupport::VERSION::STRING}".freeze
 
     def self.cache(cache_provider = nil)
-      @cache_provider = ::ActiveRemote::Cached::Cache.new(cache_provider) if cache_provider
+      if cache_provider
+        nested_caching = @cache_provider&.nested_caching?
+        @cache_provider = ::ActiveRemote::Cached::Cache.new(cache_provider)
+        # A new Cache starts with nested caching off, so carry the setting over.
+        @cache_provider.enable_nested_caching! if nested_caching
+      end
 
       @cache_provider
     end
 
+    # Merges the given options into the current options, and returns the
+    # result. A later call adds to the options, so an app initializer keeps the
+    # :expires_in and :race_condition_ttl that the Rails railtie set before it.
     def self.default_options(options = nil)
-      @default_options = options if options
+      @default_options = default_options.merge(options) if options
 
       @default_options || {}
     end
 
+    # Replaces the current options with the given options, and returns them.
+    # Pass an empty hash to clear the options.
+    def self.default_options_overwrite(options)
+      @default_options = options.dup
+    end
+
     module ClassMethods
       def cached_methods
         @cached_methods ||= []
         @cached_methods
       end
 
+      # The options each cached finder was declared with, keyed by method name.
+      # The generated methods read this at call time. Interpolating the options
+      # into the generated source instead would require every value to have a
+      # literal form, and a value such as 5.minutes does not.
+      def cached_finder_options
+        @cached_finder_options ||= {}
+      end
+
+      # A subclass inherits the finder methods its parent defined, but not the
+      # parent registry, so the lookup walks up the superclass chain.
+      def _cached_finder_options_for(method_name)
+        klass = self
+
+        while klass.respond_to?(:cached_finder_options)
+          options = klass.cached_finder_options[method_name]
+          return options if options
+
+          klass = klass.superclass
+        end
+
+        {}
+      end
+
       def cached_finders_for(*cached_finder_keys)
         options = cached_finder_keys.extract_options!
 
@@ -103,37 +142,38 @@ module ActiveRemote
         "#{::Regexp.last_match(1)}#{params.sort.join('_and_')}#{::Regexp.last_match(3)}".to_sym
       end
 
-      # rubocop:disable Metrics/AbcSize
       def _args_in_sorted_order(m, args)
         regex = /cached_(?:delete|exist_search|search|exist_find|find)_by_([0-9a-zA-Z_]*)(!|\?)?/
 
-        method_name = _method_missing_name(m)
+        called_match = m.match(regex)
+        sorted_match = _method_missing_name(m).match(regex)
 
-        match_1 = m.match(regex)
-        match_2 = method_name.match(regex)
+        return args unless called_match[1] && sorted_match[1]
 
-        args_in_order = []
+        called_field_names = called_match[1].split('_and_')
+        sorted_field_names = sorted_match[1].split('_and_')
 
-        if match_1[1] && match_2[1]
-          orignal_args_name = match_1[1].split('_and_')
-          args_names_in_order = match_2[1].split('_and_')
+        _reorder_args(m, args, called_field_names, sorted_field_names)
+      end
 
-          args_names_in_order.each do |arg_name|
-            index = orignal_args_name.index(arg_name)
-            args_in_order << args[index]
-          end
+      def _reorder_args(m, args, called_field_names, sorted_field_names)
+        if args.size < called_field_names.size
+          raise ::ArgumentError,
+                "wrong number of arguments to #{m} (given #{args.size}, expected #{called_field_names.size})"
+        end
 
-          if args.size > args_in_order.size
-            # Add options if passed
-            args_in_order << args.last
-          end
+        args_in_order = sorted_field_names.map do |field_name|
+          index = called_field_names.index(field_name)
+          raise ::ArgumentError, "#{m} has no argument named #{field_name}" if index.nil?
 
-          args_in_order
-        else
-          args
+          args[index]
         end
+
+        # Add the options hash if the caller passed one.
+        args_in_order << args.last if args.size > called_field_names.size
+
+        args_in_order
       end
-      # rubocop:enable Metrics/AbcSize
 
       # rubocop:disable Metrics/AbcSize
       def _create_cached_finder_for(cached_finder_key, options = {})
@@ -192,25 +232,41 @@ module ActiveRemote
         "cached_search_by_#{arguments.sort.join('_and_')}"
       end
 
-      def _define_cached_delete_method(method_name, *method_arguments, cached_finder_options)
+      def _expanded_search_args(method_arguments)
+        method_arguments.map { |method_argument| ":#{method_argument} => #{method_argument}," }.join
+      end
+
+      # Returns the source text that builds the cache key for a generated
+      # method. The key names each field, so that two finders that take the
+      # same values do not share one cache entry.
+      def _expanded_cache_key_args(method_arguments)
+        sorted_arguments = method_arguments.sort
+        field_names = sorted_arguments.map { |argument| ":#{argument}" }.join(',')
+
+        '::ActiveRemote::Cached::ArgumentKeys.for_fields(' \
+          "[#{field_names}], [#{sorted_arguments.join(',')}], __active_remote_cached_options" \
+          ').cache_key'
+      end
+
+      def _define_cached_delete_method(method_name, *method_arguments, cached_finder_options_hash)
         method_arguments.flatten!
         expanded_method_args = method_arguments.join(',')
-        sorted_method_args = method_arguments.sort.join(',')
-        cached_methods << method_name
+        expanded_cache_key_args = _expanded_cache_key_args(method_arguments)
 
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           # def self.cached_delete_by_user_guid(user_guid, options = {})
           #   ::ActiveRemote::Cached.cache.delete([name, user_guid])
           # end
           def self.#{method_name}(#{expanded_method_args}, __active_remote_cached_options = {})
-            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(#{cached_finder_options}).merge(__active_remote_cached_options)
+            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(_cached_finder_options_for('#{method_name}')).merge(__active_remote_cached_options)
             namespace = __active_remote_cached_options.delete(:namespace)
+            argument_cache_key = #{expanded_cache_key_args}
             find_cache_key = [
               RUBY_AND_ACTIVE_SUPPORT_VERSION,
               namespace,
               name,
               "#find",
-              ::ActiveRemote::Cached::ArgumentKeys.new(#{sorted_method_args}, __active_remote_cached_options).cache_key
+              argument_cache_key
             ].compact
 
             search_cache_key = [
@@ -218,35 +274,36 @@ module ActiveRemote
               namespace,
               name,
               "#search",
-              ::ActiveRemote::Cached::ArgumentKeys.new(#{sorted_method_args}, __active_remote_cached_options).cache_key
+              argument_cache_key
             ].compact
 
             ::ActiveRemote::Cached.cache.delete(find_cache_key)
             ::ActiveRemote::Cached.cache.delete(search_cache_key)
           end
         RUBY
+
+        cached_finder_options[method_name] = cached_finder_options_hash
+        cached_methods << method_name
       end
 
-      def _define_cached_exist_find_method(method_name, *method_arguments, cached_finder_options)
+      def _define_cached_exist_find_method(method_name, *method_arguments, cached_finder_options_hash)
         method_arguments.flatten!
         expanded_method_args = method_arguments.join(',')
-        sorted_method_args = method_arguments.sort.join(',')
-        cached_methods << method_name
-        cached_methods << "#{method_name}?"
+        expanded_cache_key_args = _expanded_cache_key_args(method_arguments)
 
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           # def self.cached_exist_find_by_user_guid(user_guid, options = {})
           #   ::ActiveRemote::Cached.cache.exist?([name, user_guid])
           # end
           def self.#{method_name}(#{expanded_method_args}, __active_remote_cached_options = {})
-            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(#{cached_finder_options}).merge(__active_remote_cached_options)
+            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(_cached_finder_options_for('#{method_name}')).merge(__active_remote_cached_options)
             namespace = __active_remote_cached_options.delete(:namespace)
             cache_key = [
               RUBY_AND_ACTIVE_SUPPORT_VERSION,
               namespace,
               name,
               "#find",
-              ::ActiveRemote::Cached::ArgumentKeys.new(#{sorted_method_args}, __active_remote_cached_options).cache_key
+              #{expanded_cache_key_args}
             ].compact
 
             ::ActiveRemote::Cached.cache.exist?(cache_key)
@@ -254,28 +311,30 @@ module ActiveRemote
         RUBY
 
         singleton_class.send(:alias_method, "#{method_name}?", method_name)
+
+        cached_finder_options[method_name] = cached_finder_options_hash
+        cached_methods << method_name
+        cached_methods << "#{method_name}?"
       end
 
-      def _define_cached_exist_search_method(method_name, *method_arguments, cached_finder_options)
+      def _define_cached_exist_search_method(method_name, *method_arguments, cached_finder_options_hash)
         method_arguments.flatten!
         expanded_method_args = method_arguments.join(',')
-        sorted_method_args = method_arguments.sort.join(',')
-        cached_methods << method_name
-        cached_methods << "#{method_name}?"
+        expanded_cache_key_args = _expanded_cache_key_args(method_arguments)
 
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           # def self.cached_exist_search_by_user_guid(user_guid, options = {})
           #   ::ActiveRemote::Cached.cache.exist?([namespace, name, "#search", user_guid])
           # end
           def self.#{method_name}(#{expanded_method_args}, __active_remote_cached_options = {})
-            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(#{cached_finder_options}).merge(__active_remote_cached_options)
+            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(_cached_finder_options_for('#{method_name}')).merge(__active_remote_cached_options)
             namespace = __active_remote_cached_options.delete(:namespace)
             cache_key = [
               RUBY_AND_ACTIVE_SUPPORT_VERSION,
               namespace,
               name,
               "#search",
-              ::ActiveRemote::Cached::ArgumentKeys.new(#{sorted_method_args}, __active_remote_cached_options).cache_key
+              #{expanded_cache_key_args}
             ].compact
 
             ::ActiveRemote::Cached.cache.exist?(cache_key)
@@ -283,18 +342,18 @@ module ActiveRemote
         RUBY
 
         singleton_class.send(:alias_method, "#{method_name}?", method_name)
+
+        cached_finder_options[method_name] = cached_finder_options_hash
+        cached_methods << method_name
+        cached_methods << "#{method_name}?"
       end
 
-      def _define_cached_find_method(method_name, *method_arguments, cached_finder_options)
+      def _define_cached_find_method(method_name, *method_arguments, cached_finder_options_hash)
         method_arguments.flatten!
         expanded_method_args = method_arguments.join(',')
-        sorted_method_args = method_arguments.sort.join(',')
-        cached_methods << method_name
+        expanded_cache_key_args = _expanded_cache_key_args(method_arguments)
 
-        expanded_search_args = ''
-        method_arguments.each do |method_argument|
-          expanded_search_args << ":#{method_argument} => #{method_argument},"
-        end
+        expanded_search_args = _expanded_search_args(method_arguments)
 
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           # def self.cached_find_by_user_guid(user_guid, options = {})
@@ -309,14 +368,14 @@ module ActiveRemote
           # of the result object is maintained for requests/responses
           #
           def self.#{method_name}(#{expanded_method_args}, __active_remote_cached_options = {})
-            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(#{cached_finder_options}).merge(__active_remote_cached_options)
+            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(_cached_finder_options_for('#{method_name}')).merge(__active_remote_cached_options)
             namespace = __active_remote_cached_options.delete(:namespace)
             cache_key = [
               RUBY_AND_ACTIVE_SUPPORT_VERSION,
               namespace,
               name,
               "#find",
-              ::ActiveRemote::Cached::ArgumentKeys.new(#{sorted_method_args}, __active_remote_cached_options).cache_key
+              #{expanded_cache_key_args}
             ].compact
 
             ::ActiveRemote::Cached.cache.fetch(cache_key, __active_remote_cached_options) do
@@ -328,18 +387,17 @@ module ActiveRemote
             end
           end
         RUBY
+
+        cached_finder_options[method_name] = cached_finder_options_hash
+        cached_methods << method_name
       end
 
-      def _define_cached_search_method(method_name, *method_arguments, cached_finder_options)
+      def _define_cached_search_method(method_name, *method_arguments, cached_finder_options_hash)
         method_arguments.flatten!
         expanded_method_args = method_arguments.join(',')
-        sorted_method_args = method_arguments.sort.join(',')
-        cached_methods << method_name
+        expanded_cache_key_args = _expanded_cache_key_args(method_arguments)
 
-        expanded_search_args = ''
-        method_arguments.each do |method_argument|
-          expanded_search_args << ":#{method_argument} => #{method_argument},"
-        end
+        expanded_search_args = _expanded_search_args(method_arguments)
 
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           # def self.cached_search_by_user_guid(user_guid, options = {})
@@ -358,14 +416,14 @@ module ActiveRemote
           # of the result object is maintained for requests/responses
           #
           def self.#{method_name}(#{expanded_method_args}, __active_remote_cached_options = {})
-            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(#{cached_finder_options}).merge(__active_remote_cached_options)
+            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(_cached_finder_options_for('#{method_name}')).merge(__active_remote_cached_options)
             namespace = __active_remote_cached_options.delete(:namespace)
             cache_key = [
               RUBY_AND_ACTIVE_SUPPORT_VERSION,
               namespace,
               name,
               "#search",
-              ::ActiveRemote::Cached::ArgumentKeys.new(#{sorted_method_args}, __active_remote_cached_options).cache_key
+              #{expanded_cache_key_args}
             ].compact
 
             ::ActiveRemote::Cached.cache.fetch(cache_key, __active_remote_cached_options) do
@@ -377,18 +435,17 @@ module ActiveRemote
             end
           end
         RUBY
+
+        cached_finder_options[method_name] = cached_finder_options_hash
+        cached_methods << method_name
       end
 
-      def _define_cached_search_bang_method(method_name, *method_arguments, cached_finder_options)
+      def _define_cached_search_bang_method(method_name, *method_arguments, cached_finder_options_hash)
         method_arguments.flatten!
         expanded_method_args = method_arguments.join(',')
-        sorted_method_args = method_arguments.sort.join(',')
-        cached_methods << method_name
+        expanded_cache_key_args = _expanded_cache_key_args(method_arguments)
 
-        expanded_search_args = ''
-        method_arguments.each do |method_argument|
-          expanded_search_args << ":#{method_argument} => #{method_argument},"
-        end
+        expanded_search_args = _expanded_search_args(method_arguments)
 
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           # def self.cached_search_by_user_guid!(user_guid, options = {})
@@ -403,7 +460,7 @@ module ActiveRemote
           #       results = self.search(:user_guid => user_guid)
           #     end
           #
-          #     raise ::ActiveRemote::RemoteRecordNotFound.new(self.class) if results.size <= 0
+          #     raise ::ActiveRemote::RemoteRecordNotFound, self if results.nil? || results.first.nil?
           #     results
           #   end
           # end
@@ -412,14 +469,14 @@ module ActiveRemote
           # of the result object is maintained for requests/responses
           #
           def self.#{method_name}(#{expanded_method_args}, __active_remote_cached_options = {})
-            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(#{cached_finder_options}).merge(__active_remote_cached_options)
+            __active_remote_cached_options = ::ActiveRemote::Cached.default_options.merge(_cached_finder_options_for('#{method_name}')).merge(__active_remote_cached_options)
             namespace = __active_remote_cached_options.delete(:namespace)
             cache_key = [
               RUBY_AND_ACTIVE_SUPPORT_VERSION,
               namespace,
               name,
               "#search",
-              ::ActiveRemote::Cached::ArgumentKeys.new(#{sorted_method_args}, __active_remote_cached_options).cache_key
+              #{expanded_cache_key_args}
             ].compact
 
             ::ActiveRemote::Cached.cache.fetch(cache_key, __active_remote_cached_options) do
@@ -431,11 +488,14 @@ module ActiveRemote
                 results = self.search(#{expanded_search_args})
               end
 
-              raise ::ActiveRemote::RemoteRecordNotFound.new(self.class) if results.first.nil?
+              raise ::ActiveRemote::RemoteRecordNotFound, self if results.nil? || results.first.nil?
               results
             end
           end
         RUBY
+
+        cached_finder_options[method_name] = cached_finder_options_hash
+        cached_methods << method_name
       end
     end
 

data/spec/active_remote/cached/argument_keys_spec.rb

@@ -24,4 +24,128 @@ describe ::ActiveRemote::Cached::ArgumentKeys do
     options = { :active_remote_cached_replace_characters => true }
     expect(::ActiveRemote::Cached::ArgumentKeys.new('hello {}', options).cache_key).to eq('helloSPLBRB')
   end
+
+  it 'replaces a tab when :active_remote_cached_replace_characters' do
+    options = { :active_remote_cached_replace_characters => true }
+    expect(::ActiveRemote::Cached::ArgumentKeys.new("a\tb", options).cache_key).to eq('aTBb')
+  end
+
+  it 'replaces a newline when :active_remote_cached_replace_characters' do
+    options = { :active_remote_cached_replace_characters => true }
+    expect(::ActiveRemote::Cached::ArgumentKeys.new("a\nb", options).cache_key).to eq('aNLb')
+  end
+
+  # REMOVE_CHARACTERS uses [[:space:]], so both options must cover the same
+  # whitespace. A raw tab or newline in a key breaks the Memcached protocol.
+  it 'leaves no whitespace in the key under either option' do
+    argument = "a b\tc\nd\re\ff\vg"
+
+    removed = ::ActiveRemote::Cached::ArgumentKeys.new(
+      argument, :active_remote_cached_remove_characters => true
+    ).cache_key
+    replaced = ::ActiveRemote::Cached::ArgumentKeys.new(
+      argument, :active_remote_cached_replace_characters => true
+    ).cache_key
+
+    expect(removed).not_to match(/[[:space:]]/)
+    expect(replaced).not_to match(/[[:space:]]/)
+  end
+
+  it 'joins multiple arguments into one key' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello', 'world', {}).cache_key).to eq('helloworld')
+  end
+
+  it 'removes nil arguments from the key' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello', nil, 'world', {}).cache_key).to eq('helloworld')
+  end
+
+  it 'flattens nested array arguments into the key' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new(['hello', ['world']], {}).cache_key).to eq('helloworld')
+  end
+
+  it 'returns an empty key when no arguments are given' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new({}).cache_key).to eq('')
+  end
+
+  it 'returns the cache key from #to_s' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello', {}).to_s).to eq('hello')
+  end
+
+  it 'removes characters when both the remove and the replace option are given' do
+    options = {
+      :active_remote_cached_remove_characters => true,
+      :active_remote_cached_replace_characters => true
+    }
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello {}', options).cache_key).to eq('hello')
+  end
+
+  describe '.for_fields' do
+    it 'names each field in the key' do
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], %w[x y], {})
+
+      expect(argument_keys.cache_key).to eq('alpha.x/beta.y')
+    end
+
+    it 'gives two finders with the same values two different keys' do
+      alpha_beta = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], %w[x y], {})
+      gamma_delta = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[gamma delta], %w[x y], {})
+
+      expect(alpha_beta.cache_key).not_to eq(gamma_delta.cache_key)
+    end
+
+    it 'gives a single field a different key than two fields with the same characters' do
+      one_field = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[guid], %w[xy], {})
+      two_fields = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], %w[x y], {})
+
+      expect(one_field.cache_key).not_to eq(two_fields.cache_key)
+    end
+
+    it 'joins an array value with a comma' do
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[guid], [%w[a b]], {})
+
+      expect(argument_keys.cache_key).to eq('guid.a.b')
+    end
+
+    it 'removes a nil inside an array value' do
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[guid], [['a', nil, 'b']], {})
+
+      expect(argument_keys.cache_key).to eq('guid.a.b')
+    end
+
+    it 'gives an empty value for a nil argument' do
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], ['x', nil], {})
+
+      expect(argument_keys.cache_key).to eq('alpha.x/beta.')
+    end
+
+    it 'escapes a separator inside a value' do
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[guid], ['a/b.c%d'], {})
+
+      expect(argument_keys.cache_key).to eq('guid.a%2Fb%2Ec%25d')
+    end
+
+    it 'keeps the separators when the remove option is given' do
+      options = { :active_remote_cached_remove_characters => true }
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], ['hello {}', 'y'], options)
+
+      expect(argument_keys.cache_key).to eq('alpha.hello/beta.y')
+    end
+
+    it 'keeps the separators when the replace option is given' do
+      options = { :active_remote_cached_replace_characters => true }
+      argument_keys = ::ActiveRemote::Cached::ArgumentKeys.for_fields(%i[alpha beta], ['hello {}', 'y'], options)
+
+      expect(argument_keys.cache_key).to eq('alpha.helloSPLBRB/beta.y')
+    end
+  end
+
+  # #cache_key calls gsub! on an instance variable, so a second call must not
+  # replace the characters of the first result again.
+  it 'returns the same key when :active_remote_cached_replace_characters is called twice' do
+    options = { :active_remote_cached_replace_characters => true }
+    argument_keys = ::ActiveRemote::Cached::ArgumentKeys.new('hello {}', options)
+
+    expect(argument_keys.cache_key).to eq('helloSPLBRB')
+    expect(argument_keys.cache_key).to eq('helloSPLBRB')
+  end
 end