active_remote-cached 1.0.0 → 1.2.0

data/lib/active_remote/cached.rb

@@ -1,33 +1,38 @@
-require "active_support"
-require "active_support/cache"
-require "active_support/concern"
-require "active_support/core_ext/array/extract_options"
+# frozen_string_literal: true
 
-require "active_remote/cached/argument_keys"
-require "active_remote/cached/cache"
-require "active_remote/cached/version"
-require "active_remote/errors"
+require 'active_support'
+require 'active_support/cache'
+require 'active_support/concern'
+require 'active_support/core_ext/array/extract_options'
+
+require 'active_remote/cached/argument_keys'
+require 'active_remote/cached/cache'
+require 'active_remote/cached/version'
+require 'active_remote/errors'
 
 module ActiveRemote
   module Cached
     extend ::ActiveSupport::Concern
 
-    # When upgrading Rails versions, don't reuse the same cache key, because you can't rely upon the serialized objects to be consistent across versions.
-    # To fix, this adds a cache key that caches the ruby engine version and the activesupport version to prevent cache re-use across different versions.
+    # When upgrading Rails versions, don't reuse the same cache key,
+    # because you can't rely upon the serialized objects to be consistent across versions.
+    # To fix, this adds a cache key that caches the ruby engine version
+    # and the activesupport version to prevent cache re-use across different versions.
     RUBY_AND_ACTIVE_SUPPORT_VERSION = "#{RUBY_ENGINE_VERSION}:#{ActiveSupport::VERSION::STRING}".freeze
 
     def self.cache(cache_provider = nil)
       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
 
     def self.default_options(options = nil)
-      if options
-        @default_options = options
-      end
+      @default_options = options if options
 
       @default_options || {}
     end
@@ -38,6 +43,29 @@ module ActiveRemote
         @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!
 
@@ -50,27 +78,23 @@ module ActiveRemote
         cached_finders_for(*keys)
       end
 
-      def cached_find(argument_hash, options = {})
+      def cached_find(argument_hash, options = {}, &block)
         method_name = _cached_find_method_name(argument_hash.keys)
         arguments = argument_hash.keys.sort.map { |k| argument_hash[k] }
 
         if block_given?
-          __send__(method_name, *arguments, options) do
-            yield
-          end
+          __send__(method_name, *arguments, options, &block)
         else
           __send__(method_name, *arguments, options)
         end
       end
 
-      def cached_search(argument_hash, options = {})
+      def cached_search(argument_hash, options = {}, &block)
         method_name = _cached_search_method_name(argument_hash.keys)
         arguments = argument_hash.keys.sort.map { |k| argument_hash[k] }
 
         if block_given?
-          __send__(method_name, *arguments, options) do
-            yield
-          end
+          __send__(method_name, *arguments, options, &block)
         else
           __send__(method_name, *arguments, options)
         end
@@ -101,48 +125,50 @@ module ActiveRemote
       # Underscored Methods
       #
       def _method_missing_name(m)
-        regex = /(cached_(?:delete|exist_search|search|exist_find|find)_by_)([a-zA-Z_]*)(!|\?)?/
+        regex = /(cached_(?:delete|exist_search|search|exist_find|find)_by_)([0-9a-zA-Z_]*)(!|\?)?/
 
-        if m.to_s =~ regex
-          params = $2.split("_and_")
-          "#{$1}#{params.sort.join("_and_")}#{$3}".to_sym
-        else
-          nil
-        end
+        return unless m.to_s =~ regex
+
+        params = ::Regexp.last_match(2).split('_and_')
+        "#{::Regexp.last_match(1)}#{params.sort.join('_and_')}#{::Regexp.last_match(3)}".to_sym
       end
 
       def _args_in_sorted_order(m, args)
-        regex = /cached_(?:delete|exist_search|search|exist_find|find)_by_([a-zA-Z_]*)(!|\?)?/
+        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:disable Metrics/AbcSize
       def _create_cached_finder_for(cached_finder_key, options = {})
-        cached_finder_key_set = [ cached_finder_key ].flatten.sort
+        cached_finder_key_set = [cached_finder_key].flatten.sort
 
         delete_method_name = _cached_delete_method_name(cached_finder_key_set)
         exist_find_method_name = _cached_exist_find_method_name(cached_finder_key_set)
@@ -154,7 +180,7 @@ module ActiveRemote
         unless cached_methods.include?(delete_method_name)
           _define_cached_delete_method(delete_method_name, cached_finder_key_set, options)
         end
-        
+
         unless cached_methods.include?(exist_find_method_name)
           _define_cached_exist_find_method(exist_find_method_name, cached_finder_key_set, options)
         end
@@ -171,10 +197,11 @@ module ActiveRemote
           _define_cached_search_bang_method(search_bang_method_name, cached_finder_key_set, options)
         end
 
-        unless cached_methods.include?(search_method_name)
-          _define_cached_search_method(search_method_name, cached_finder_key_set, options)
-        end
+        return if cached_methods.include?(search_method_name)
+
+        _define_cached_search_method(search_method_name, cached_finder_key_set, options)
       end
+      # rubocop:enable Metrics/AbcSize
 
       def _cached_delete_method_name(arguments)
         "cached_delete_by_#{arguments.sort.join('_and_')}"
@@ -196,25 +223,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_method_args = method_arguments.join(',')
+        expanded_cache_key_args = _expanded_cache_key_args(method_arguments)
 
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        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 = [
@@ -222,35 +265,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_method_args = method_arguments.join(',')
+        expanded_cache_key_args = _expanded_cache_key_args(method_arguments)
 
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        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)
@@ -258,28 +302,30 @@ module ActiveRemote
         RUBY
 
         singleton_class.send(:alias_method, "#{method_name}?", method_name)
-      end
 
-      def _define_cached_exist_search_method(method_name, *method_arguments, cached_finder_options)
-        method_arguments.flatten!
-        expanded_method_args = method_arguments.join(",")
-        sorted_method_args = method_arguments.sort.join(",")
+        cached_finder_options[method_name] = cached_finder_options_hash
         cached_methods << method_name
         cached_methods << "#{method_name}?"
+      end
 
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def _define_cached_exist_search_method(method_name, *method_arguments, cached_finder_options_hash)
+        method_arguments.flatten!
+        expanded_method_args = method_arguments.join(',')
+        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)
@@ -287,20 +333,20 @@ 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_method_args = method_arguments.join(',')
+        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)
 
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           # def self.cached_find_by_user_guid(user_guid, options = {})
           #   options = ::ActiveRemote::Cached.default_options.merge({}).merge(options)
           #
@@ -313,14 +359,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
@@ -332,20 +378,19 @@ 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_method_args = method_arguments.join(',')
+        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)
 
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           # def self.cached_search_by_user_guid(user_guid, options = {})
           #   options = ::ActiveRemote::Cached.default_options.merge({}).merge(options)
           #
@@ -362,14 +407,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
@@ -381,20 +426,19 @@ 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_method_args = method_arguments.join(',')
+        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)
 
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           # def self.cached_search_by_user_guid!(user_guid, options = {})
           #   options = ::ActiveRemote::Cached.default_options.merge({}).merge(options)
           #
@@ -407,7 +451,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
@@ -416,14 +460,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
@@ -435,11 +479,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
 
@@ -448,4 +495,4 @@ module ActiveRemote
   end
 end
 
-require "active_remote/cached/railtie" if defined?(Rails)
+require 'active_remote/cached/railtie' if defined?(Rails)

data/lib/active_remote-cached.rb

@@ -1 +1,3 @@
-require "active_remote/cached"
+# frozen_string_literal: true
+
+require 'active_remote/cached'