active_remote-cached 0.2.0 → 1.1.1

data/lib/active_remote/cached.rb

@@ -1,38 +1,41 @@
-require "active_support"
-require "active_support/cache"
-require "active_support/concern"
-require "active_support/core_ext/array/extract_options"
+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"
+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
-        @cache_provider = ::ActiveRemote::Cached::Cache.new(cache_provider)
-      end
+      @cache_provider = ::ActiveRemote::Cached::Cache.new(cache_provider) if cache_provider
 
       @cache_provider
     end
 
     def self.default_options(options = nil)
-      if options
-        @default_options = options
-      end
+      @default_options = options if options
 
       @default_options || {}
     end
 
     module ClassMethods
+      def cached_methods
+        @cached_methods ||= []
+        @cached_methods
+      end
+
       def cached_finders_for(*cached_finder_keys)
         options = cached_finder_keys.extract_options!
 
@@ -45,102 +48,157 @@ 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.values
+        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.values
+        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 method_missing(m, *args, &block)
+        method_name = _method_missing_name(m)
+
+        if method_name.nil? || !cached_methods.include?(method_name.to_s)
+          super(m, *args, &block)
+        else
+          new_args = _args_in_sorted_order(m, args)
+          __send__(method_name, *new_args, &block)
+        end
+      end
+
+      def respond_to_missing?(m, include_private = false)
+        method_name = _method_missing_name(m)
+
+        if !method_name.nil? && cached_methods.include?(method_name.to_s)
+          true
+        else
+          super
+        end
+      end
+
       ##
       # Underscored Methods
       #
-      def _create_cached_finder_for(cached_finder_key, options = {})
-        cached_finder_key_set = [ cached_finder_key ].flatten.sort
-
-        ##
-        # Run each permutation of the arguments passed in
-        # and define each finder/searcher
-        #
-        cached_finder_key_set.permutation do |arguments|
-          delete_method_name = _cached_delete_method_name(arguments)
-          exist_find_method_name = _cached_exist_find_method_name(arguments)
-          exist_search_method_name = _cached_exist_search_method_name(arguments)
-          find_method_name = _cached_find_method_name(arguments)
-          search_method_name = _cached_search_method_name(arguments)
-          search_bang_method_name = "#{search_method_name}!"
-
-          unless self.respond_to?(delete_method_name)
-            _define_cached_delete_method(delete_method_name, arguments, options)
-          end
+      def _method_missing_name(m)
+        regex = /(cached_(?:delete|exist_search|search|exist_find|find)_by_)([0-9a-zA-Z_]*)(!|\?)?/
 
-          unless self.respond_to?(exist_find_method_name)
-            _define_cached_exist_find_method(exist_find_method_name, arguments, options)
-          end
+        return unless m.to_s =~ regex
 
-          unless self.respond_to?(exist_search_method_name)
-            _define_cached_exist_search_method(exist_search_method_name, arguments, options)
-          end
+        params = ::Regexp.last_match(2).split('_and_')
+        "#{::Regexp.last_match(1)}#{params.sort.join('_and_')}#{::Regexp.last_match(3)}".to_sym
+      end
 
-          unless self.respond_to?(find_method_name)
-            _define_cached_find_method(find_method_name, arguments, options)
-          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_]*)(!|\?)?/
 
-          unless self.respond_to?(search_bang_method_name)
-            _define_cached_search_bang_method(search_bang_method_name, arguments, options)
+        method_name = _method_missing_name(m)
+
+        match_1 = m.match(regex)
+        match_2 = method_name.match(regex)
+
+        args_in_order = []
+
+        if match_1[1] && match_2[1]
+          orignal_args_name = match_1[1].split('_and_')
+          args_names_in_order = match_2[1].split('_and_')
+
+          args_names_in_order.each do |arg_name|
+            index = orignal_args_name.index(arg_name)
+            args_in_order << args[index]
           end
 
-          unless self.respond_to?(search_method_name)
-            _define_cached_search_method(search_method_name, arguments, options)
+          if args.size > args_in_order.size
+            # Add options if passed
+            args_in_order << args.last
           end
+
+          args_in_order
+        else
+          args
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize
+      def _create_cached_finder_for(cached_finder_key, options = {})
+        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)
+        exist_search_method_name = _cached_exist_search_method_name(cached_finder_key_set)
+        find_method_name = _cached_find_method_name(cached_finder_key_set)
+        search_method_name = _cached_search_method_name(cached_finder_key_set)
+        search_bang_method_name = "#{search_method_name}!"
+
+        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
+
+        unless cached_methods.include?(exist_search_method_name)
+          _define_cached_exist_search_method(exist_search_method_name, cached_finder_key_set, options)
+        end
+
+        unless cached_methods.include?(find_method_name)
+          _define_cached_find_method(find_method_name, cached_finder_key_set, options)
+        end
+
+        unless cached_methods.include?(search_bang_method_name)
+          _define_cached_search_bang_method(search_bang_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.join('_and_')}"
+        "cached_delete_by_#{arguments.sort.join('_and_')}"
       end
 
       def _cached_exist_find_method_name(arguments)
-        "cached_exist_find_by_#{arguments.join('_and_')}"
+        "cached_exist_find_by_#{arguments.sort.join('_and_')}"
       end
 
       def _cached_exist_search_method_name(arguments)
-        "cached_exist_search_by_#{arguments.join('_and_')}"
+        "cached_exist_search_by_#{arguments.sort.join('_and_')}"
       end
 
       def _cached_find_method_name(arguments)
-        "cached_find_by_#{arguments.join('_and_')}"
+        "cached_find_by_#{arguments.sort.join('_and_')}"
       end
 
       def _cached_search_method_name(arguments)
-        "cached_search_by_#{arguments.join('_and_')}"
+        "cached_search_by_#{arguments.sort.join('_and_')}"
       end
 
       def _define_cached_delete_method(method_name, *method_arguments, cached_finder_options)
         method_arguments.flatten!
-        expanded_method_args = method_arguments.join(",")
-        sorted_method_args = method_arguments.sort.join(",")
+        expanded_method_args = method_arguments.join(',')
+        sorted_method_args = method_arguments.sort.join(',')
+        cached_methods << method_name
 
-        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
@@ -171,10 +229,12 @@ module ActiveRemote
 
       def _define_cached_exist_find_method(method_name, *method_arguments, cached_finder_options)
         method_arguments.flatten!
-        expanded_method_args = method_arguments.join(",")
-        sorted_method_args = method_arguments.sort.join(",")
+        expanded_method_args = method_arguments.join(',')
+        sorted_method_args = method_arguments.sort.join(',')
+        cached_methods << method_name
+        cached_methods << "#{method_name}?"
 
-        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
@@ -198,10 +258,12 @@ module ActiveRemote
 
       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(",")
+        expanded_method_args = method_arguments.join(',')
+        sorted_method_args = method_arguments.sort.join(',')
+        cached_methods << method_name
+        cached_methods << "#{method_name}?"
 
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        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
@@ -225,15 +287,16 @@ module ActiveRemote
 
       def _define_cached_find_method(method_name, *method_arguments, cached_finder_options)
         method_arguments.flatten!
-        expanded_method_args = method_arguments.join(",")
-        sorted_method_args = method_arguments.sort.join(",")
+        expanded_method_args = method_arguments.join(',')
+        sorted_method_args = method_arguments.sort.join(',')
+        cached_methods << method_name
 
-        expanded_search_args = ""
+        expanded_search_args = ''
         method_arguments.each do |method_argument|
           expanded_search_args << ":#{method_argument} => #{method_argument},"
         end
 
-        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)
           #
@@ -269,15 +332,16 @@ module ActiveRemote
 
       def _define_cached_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(",")
+        expanded_method_args = method_arguments.join(',')
+        sorted_method_args = method_arguments.sort.join(',')
+        cached_methods << method_name
 
-        expanded_search_args = ""
+        expanded_search_args = ''
         method_arguments.each do |method_argument|
           expanded_search_args << ":#{method_argument} => #{method_argument},"
         end
 
-        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)
           #
@@ -317,15 +381,16 @@ module ActiveRemote
 
       def _define_cached_search_bang_method(method_name, *method_arguments, cached_finder_options)
         method_arguments.flatten!
-        expanded_method_args = method_arguments.join(",")
-        sorted_method_args = method_arguments.sort.join(",")
+        expanded_method_args = method_arguments.join(',')
+        sorted_method_args = method_arguments.sort.join(',')
+        cached_methods << method_name
 
-        expanded_search_args = ""
+        expanded_search_args = ''
         method_arguments.each do |method_argument|
           expanded_search_args << ":#{method_argument} => #{method_argument},"
         end
 
-        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)
           #
@@ -379,4 +444,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'

data/spec/active_remote/cached/argument_keys_spec.rb

@@ -1,25 +1,27 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ::ActiveRemote::Cached::ArgumentKeys do
-  it "does not mutate a string by default" do
-    ::ActiveRemote::Cached::ArgumentKeys.new("hello", {}).cache_key.must_equal("hello")
+  it 'does not mutate a string by default' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello', {}).cache_key).to eq('hello')
   end
 
-  it "returns a string of a symbol by default" do
-    ::ActiveRemote::Cached::ArgumentKeys.new(:hello, {}).cache_key.must_equal("hello")
+  it 'returns a string of a symbol by default' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new(:hello, {}).cache_key).to eq('hello')
   end
 
-  it "does not mutate a string with special characters by default" do
-    ::ActiveRemote::Cached::ArgumentKeys.new("hello {}", {}).cache_key.must_equal("hello {}")
+  it 'does not mutate a string with special characters by default' do
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello {}', {}).cache_key).to eq('hello {}')
   end
 
-  it "removes special characters from string with special characters when :active_remote_cached_remove_characters" do
+  it 'removes special characters from string with special characters when :active_remote_cached_remove_characters' do
     options = { :active_remote_cached_remove_characters => true }
-    ::ActiveRemote::Cached::ArgumentKeys.new("hello {}", options).cache_key.must_equal("hello")
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello {}', options).cache_key).to eq('hello')
   end
 
-  it "replaces special characters from string with special characters when :active_remote_cached_replace_characters" do
+  it 'replaces special characters from string with special characters when :active_remote_cached_replace_characters' do
     options = { :active_remote_cached_replace_characters => true }
-    ::ActiveRemote::Cached::ArgumentKeys.new("hello {}", options).cache_key.must_equal("helloSPLBRB")
+    expect(::ActiveRemote::Cached::ArgumentKeys.new('hello {}', options).cache_key).to eq('helloSPLBRB')
   end
 end

data/spec/active_remote/cached/cache_spec.rb

@@ -1,35 +1,32 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ::ActiveRemote::Cached::Cache do
-  describe "API" do
-    it "validates #delete present" do
+  describe 'API' do
+    it 'validates #delete present' do
       cache = OpenStruct.new(:write => nil, :fetch => nil, :read => nil, :exist? => nil)
-      error = lambda { ::ActiveRemote::Cached.cache(cache) }.must_raise(RuntimeError)
-      error.message.must_match(/respond_to.*delete/i)
+      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(RuntimeError, /respond_to.*delete/i)
     end
 
-    it "validates #exist? present" do
+    it 'validates #exist? present' do
       cache = OpenStruct.new(:write => nil, :delete => nil, :read => nil, :fetch => nil)
-      error = lambda { ::ActiveRemote::Cached.cache(cache) }.must_raise(RuntimeError)
-      error.message.must_match(/respond_to.*exist/i)
+      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(RuntimeError, /respond_to.*exist/i)
     end
 
-    it "validates #fetch present" do
+    it 'validates #fetch present' do
       cache = OpenStruct.new(:write => nil, :delete => nil, :read => nil, :exist? => nil)
-      error = lambda { ::ActiveRemote::Cached.cache(cache) }.must_raise(RuntimeError)
-      error.message.must_match(/respond_to.*fetch/i)
+      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(RuntimeError, /respond_to.*fetch/i)
     end
 
-    it "validates #read present" do
+    it 'validates #read present' do
       cache = OpenStruct.new(:write => nil, :delete => nil, :fetch => nil, :exist? => nil)
-      error = lambda { ::ActiveRemote::Cached.cache(cache) }.must_raise(RuntimeError)
-      error.message.must_match(/respond_to.*read/i)
+      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(RuntimeError, /respond_to.*read/i)
     end
 
-    it "validates #write present" do
+    it 'validates #write present' do
       cache = OpenStruct.new(:read => nil, :delete => nil, :fetch => nil, :exist? => nil)
-      error = lambda { ::ActiveRemote::Cached.cache(cache)}.must_raise(RuntimeError)
-      error.message.must_match(/respond_to.*write/i)
+      expect { ::ActiveRemote::Cached.cache(cache) }.to raise_error(RuntimeError, /respond_to.*write/i)
     end
   end
 end

data/spec/active_remote/cached_delete_methods_spec.rb

@@ -1,45 +1,52 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class DeleteMethodClass
   include ::ActiveRemote::Cached
 
-  def self.find; nil; end
-  def self.search; nil; end
+  def self.find
+    nil
+  end
+
+  def self.search
+    nil
+  end
 
   cached_finders_for :guid
   cached_finders_for :guid, :user_guid
-  cached_finders_for [:user_guid, :client_guid]
-  cached_finders_for [:derp, :user_guid, :client_guid]
+  cached_finders_for %i[user_guid client_guid]
+  cached_finders_for %i[derp user_guid client_guid]
 end
 
 describe DeleteMethodClass do
-  describe "API" do
+  describe 'API' do
     it "creates 'cached_delete_by_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_guid)
     end
 
     it "creates 'cached_delete_by_user_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_user_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_user_guid)
     end
 
     it "creates 'cached_delete_by_user_guid_and_client_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_user_guid_and_client_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_user_guid_and_client_guid)
     end
 
     it "creates 'cached_delete_by_client_guid_and_user_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_client_guid_and_user_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_client_guid_and_user_guid)
     end
 
     it "creates 'cached_delete_by_derp_and_user_guid_and_client_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_derp_and_user_guid_and_client_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_derp_and_user_guid_and_client_guid)
     end
 
     it "creates 'cached_delete_by_client_guid_and_derp_and_user_guid'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_client_guid_and_derp_and_user_guid")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_client_guid_and_derp_and_user_guid)
     end
 
     it "creates 'cached_delete_by_client_guid_and_user_guid_and_derp'" do
-      DeleteMethodClass.must_respond_to("cached_delete_by_client_guid_and_user_guid_and_derp")
+      expect(DeleteMethodClass).to respond_to(:cached_delete_by_client_guid_and_user_guid_and_derp)
     end
   end
 end