active_remote-cached 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5d24644649d050e9d4e4bf6164b050a30551a146
+  data.tar.gz: ff66a84b00c10d48fcf6bca41b50193f961b2b7f
+SHA512:
+  metadata.gz: 222352b851868aedc14f66832239056f81a7f467f902f682f0ca2500d70296162bace6cc7144a2758bff153d5582f3fb0aed53886d0f48d30b7c8045bb060c38
+  data.tar.gz: f39cb8f7a1101dc3c92afc49c9d9c21b4cc460a850ef4b589dd53a387b732bfa48577bfccc8b9f238e5a5114c8d61e6d20cfb0975990b677493c457b3a377d08

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.ruby-*
+.rvmrc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_remote-cached.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Brandon Dewitt
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# ActiveRemote::Cached
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_remote-cached'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_remote-cached
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.libs.push "spec"
+  t.pattern = "spec/**/*_spec.rb"
+  t.verbose = true
+end
+
+task :spec => :test
+task :default => :spec

data/active_remote-cached.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_remote-cached/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "active_remote-cached"
+  gem.version       = ActiveRemote::Cached::VERSION
+  gem.authors       = ["Brandon Dewitt"]
+  gem.email         = ["brandonsdewitt@gmail.com"]
+  gem.description   = %q{ Provides "cached" finders and a DSL to enumerate which finders should have cached versions }
+  gem.summary       = %q{ Provides a configuration for caching mechanisms and finders on ActiveRemote models that are cached/cacheable }
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "active_remote"
+  gem.add_dependency "activesupport"
+
+  gem.add_development_dependency "bundler"
+  gem.add_development_dependency "mocha"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "rake"
+end

data/lib/active_remote-cached.rb

@@ -0,0 +1,186 @@
+require "active_support/concern"
+require "active_support/core_ext/array/extract_options"
+require "active_remote-cached/version"
+require "active_remote-cached/cache"
+
+module ActiveRemote
+  module Cached
+    extend ::ActiveSupport::Concern
+
+    def self.cache(cache_provider = nil)
+      if cache_provider
+        @cache_provider = ::ActiveRemote::Cached::Cache.new(cache_provider)
+      end
+
+      @cache_provider
+    end
+
+    def self.default_options(options = nil)
+      if options
+        @default_options = options
+      end
+
+      @default_options || {}
+    end
+
+    module ClassMethods
+
+      def cached_finders_for(*cached_finder_keys)
+        options = cached_finder_keys.extract_options!
+
+        cached_finder_keys.each do |cached_finder_key|
+          _create_cached_finder_for(cached_finder_key, options)
+        end
+      end
+
+      def cached_finders(*keys)
+        cached_finders_for(*keys)
+      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_method_name = _cached_exist_method_name(arguments)
+          find_method_name = _cached_find_method_name(arguments)
+          search_method_name = _cached_search_method_name(arguments)
+
+          unless self.respond_to?(delete_method_name)
+            _define_cached_delete_method(delete_method_name, arguments)
+          end
+
+          unless self.respond_to?(exist_method_name)
+            _define_cached_exist_method(exist_method_name, arguments)
+          end
+
+          unless self.respond_to?(find_method_name)
+            _define_cached_find_method(find_method_name, arguments)
+          end
+
+          unless self.respond_to?(search_method_name)
+            _define_cached_search_method(search_method_name, arguments)
+          end
+        end
+      end
+
+      def _cached_delete_method_name(arguments)
+        "cached_delete_by_#{arguments.join('_and_')}"
+      end
+
+      def _cached_exist_method_name(arguments)
+        "cached_exist_by_#{arguments.join('_and_')}"
+      end
+
+      def _cached_find_method_name(arguments)
+        "cached_find_by_#{arguments.join('_and_')}"
+      end
+
+      def _cached_search_method_name(arguments)
+        "cached_search_by_#{arguments.join('_and_')}"
+      end
+
+      def _define_cached_delete_method(method_name, *method_arguments)
+        method_arguments.flatten!
+        expanded_method_args = method_arguments.join(",")
+        sorted_method_args = method_arguments.sort.join(",")
+
+        self.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}, options = {})
+            ::ActiveRemote::Cached.cache.delete([name, #{sorted_method_args}])
+          end
+        RUBY
+      end
+
+      def _define_cached_exist_method(method_name, *method_arguments)
+        method_arguments.flatten!
+        expanded_method_args = method_arguments.join(",")
+        sorted_method_args = method_arguments.sort.join(",")
+
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          # def self.cached_exist_by_user_guid(user_guid, options = {})
+          #   ::ActiveRemote::Cached.cache.exist?([name, user_guid])
+          # end
+          def self.#{method_name}(#{expanded_method_args}, options = {})
+            ::ActiveRemote::Cached.cache.exist?([name, #{sorted_method_args}])
+          end
+        RUBY
+
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          # def self.cached_exist_by_user_guid?(user_guid, options = {})
+          #   ::ActiveRemote::Cached.cache.exist?([name, user_guid])
+          # end
+          def self.#{method_name}?(#{expanded_method_args}, options = {})
+            ::ActiveRemote::Cached.cache.exist?([name, #{sorted_method_args}])
+          end
+        RUBY
+      end
+
+      def _define_cached_find_method(method_name, *method_arguments)
+        method_arguments.flatten!
+        expanded_method_args = method_arguments.join(",")
+        sorted_method_args = method_arguments.sort.join(",")
+
+        expanded_search_args = ""
+        method_arguments.each do |method_argument|
+          expanded_search_args << ":#{method_argument} => #{method_argument},"
+        end
+
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          # def self.cached_find_by_user_guid(user_guid, options = {})
+          #   options = ::ActiveRemote::Cached.default_options.merge(options)
+          #
+          #   ::ActiveRemote::Cached.cache.fetch([name, user_guid], options) do
+          #     self.find(:user_guid => user_guid)
+          #   end
+          # end
+          def self.#{method_name}(#{expanded_method_args}, options = {})
+            options = ::ActiveRemote::Cached.default_options.merge(options)
+
+            ::ActiveRemote::Cached.cache.fetch([name, #{sorted_method_args}], options) do
+              self.find(#{expanded_search_args})
+            end
+          end
+        RUBY
+      end
+
+      def _define_cached_search_method(method_name, *method_arguments)
+        method_arguments.flatten!
+        expanded_method_args = method_arguments.join(",")
+        sorted_method_args = method_arguments.sort.join(",")
+
+        expanded_search_args = ""
+        method_arguments.each do |method_argument|
+          expanded_search_args << ":#{method_argument} => #{method_argument},"
+        end
+
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          # def self.cached_search_by_user_guid(user_guid, options = {})
+          #   options = ::ActiveRemote::Cached.default_options.merge(options)
+          #
+          #   ::ActiveRemote::Cached.cache.fetch([name, user_guid], options) do
+          #     self.search(:user_guid => user_guid)
+          #   end
+          # end
+          def self.#{method_name}(#{expanded_method_args}, options = {})
+            options = ::ActiveRemote::Cached.default_options.merge(options)
+
+            ::ActiveRemote::Cached.cache.fetch([name, #{sorted_method_args}], options) do
+              self.search(#{expanded_search_args})
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/active_remote-cached/cache.rb

@@ -0,0 +1,30 @@
+require 'delegate'
+
+module ActiveRemote::Cached
+  class Cache < ::SimpleDelegator
+    attr_reader :cache_provider
+
+    def initialize(new_cache_provider)
+      @cache_provider = new_cache_provider
+      validate_provider_method_present(:delete)
+      validate_provider_method_present(:exist?)
+      validate_provider_method_present(:fetch)
+      validate_provider_method_present(:read)
+      validate_provider_method_present(:write)
+      
+      super(@cache_provider)
+    end
+
+    private
+
+    def validate_provider_method_present(method_name)
+      unless self.cache_provider.respond_to?(method_name)
+        raise <<-CACHE_METHOD
+          ActiveRemote::Cached::Cache must respond_to? #{method_name}
+          in order to be used as a caching interface for ActiveRemote
+        CACHE_METHOD
+      end
+    end
+      
+  end
+end

data/lib/active_remote-cached/version.rb

@@ -0,0 +1,5 @@
+module ActiveRemote
+  module Cached
+    VERSION = "0.0.1"
+  end
+end

data/spec/cache_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe ::ActiveRemote::Cached::Cache do
+  describe "API" 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)
+    end
+
+    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)
+    end
+
+    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)
+    end
+
+    it "validates #exist? present" do
+      cache = OpenStruct.new(:write => nil, :fetch => nil, :read => nil, :delete => nil)
+      error = lambda { ::ActiveRemote::Cached.cache(cache) }.must_raise(RuntimeError)
+      error.message.must_match(/respond_to.*exist/i)
+    end
+
+    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)
+    end
+  end
+end

data/spec/cached_delete_methods_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+class DeleteMethodClass
+  include ::ActiveRemote::Cached
+
+  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]
+end
+
+describe DeleteMethodClass do
+  describe "API" do
+    it "creates 'cached_delete_by_guid'" do
+      DeleteMethodClass.must_respond_to("cached_delete_by_guid")
+    end
+
+    it "creates 'cached_delete_by_user_guid'" do
+      DeleteMethodClass.must_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")
+    end
+
+    it "creates 'cached_delete_by_client_guid_and_user_guid'" do
+      DeleteMethodClass.must_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")
+    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")
+    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")
+    end
+  end
+end

data/spec/cached_exist_methods_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+class ExistMethodClass
+  include ::ActiveRemote::Cached
+
+  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]
+end
+
+describe ExistMethodClass do
+  describe "API" do
+    it "creates 'cached_exist_by_guid'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_guid")
+    end
+
+    it "creates 'cached_exist_by_user_guid'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_user_guid")
+    end
+
+    it "creates 'cached_exist_by_user_guid_and_client_guid'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_user_guid_and_client_guid")
+    end
+
+    it "creates 'cached_exist_by_client_guid_and_user_guid'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_client_guid_and_user_guid")
+    end
+
+    it "creates 'cached_exist_by_derp_and_user_guid_and_client_guid'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_derp_and_user_guid_and_client_guid")
+    end
+
+    it "creates 'cached_exist_by_client_guid_and_derp_and_user_guid'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_client_guid_and_derp_and_user_guid")
+    end
+
+    it "creates 'cached_exist_by_client_guid_and_user_guid_and_derp'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_client_guid_and_user_guid_and_derp")
+    end
+
+    it "creates 'cached_exist_by_guid?'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_guid?")
+    end
+
+    it "creates 'cached_exist_by_user_guid?'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_user_guid?")
+    end
+
+    it "creates 'cached_exist_by_user_guid_and_client_guid?'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_user_guid_and_client_guid?")
+    end
+
+    it "creates 'cached_exist_by_client_guid_and_user_guid?'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_client_guid_and_user_guid?")
+    end
+
+    it "creates 'cached_exist_by_derp_and_user_guid_and_client_guid?'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_derp_and_user_guid_and_client_guid?")
+    end
+
+    it "creates 'cached_exist_by_client_guid_and_derp_and_user_guid?'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_client_guid_and_derp_and_user_guid?")
+    end
+
+    it "creates 'cached_exist_by_client_guid_and_user_guid_and_derp?'" do
+      ExistMethodClass.must_respond_to("cached_exist_by_client_guid_and_user_guid_and_derp?")
+    end
+  end
+end

data/spec/cached_find_methods_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+class FindMethodClass
+  include ::ActiveRemote::Cached
+
+  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]
+end
+
+describe FindMethodClass do
+  describe "API" do
+    it "creates 'cached_find_by_guid'" do
+      FindMethodClass.must_respond_to("cached_find_by_guid")
+    end
+
+    it "creates 'cached_find_by_user_guid'" do
+      FindMethodClass.must_respond_to("cached_find_by_user_guid")
+    end
+
+    it "creates 'cached_find_by_user_guid_and_client_guid'" do
+      FindMethodClass.must_respond_to("cached_find_by_user_guid_and_client_guid")
+    end
+
+    it "creates 'cached_find_by_client_guid_and_user_guid'" do
+      FindMethodClass.must_respond_to("cached_find_by_client_guid_and_user_guid")
+    end
+
+    it "creates 'cached_find_by_derp_and_user_guid_and_client_guid'" do
+      FindMethodClass.must_respond_to("cached_find_by_derp_and_user_guid_and_client_guid")
+    end
+
+    it "creates 'cached_find_by_client_guid_and_derp_and_user_guid'" do
+      FindMethodClass.must_respond_to("cached_find_by_client_guid_and_derp_and_user_guid")
+    end
+
+    it "creates 'cached_find_by_client_guid_and_user_guid_and_derp'" do
+      FindMethodClass.must_respond_to("cached_find_by_client_guid_and_user_guid_and_derp")
+    end
+  end
+
+  describe "#cached_find_by_guid" do
+    before do
+      ::ActiveRemote::Cached.cache(HashCache.new)
+      ::ActiveRemote::Cached.default_options(:expires_in => 100)
+    end
+
+    after do
+      ::ActiveRemote::Cached.default_options({})
+    end
+
+    it "executes the fetch block if not present in cache" do
+      FindMethodClass.stub(:find, :hello) do
+        FindMethodClass.cached_find_by_guid(:guid).must_equal(:hello)
+      end
+    end
+
+    it "merges the default options in for the fetch call" do
+      ::ActiveRemote::Cached.cache.expects(:fetch).with([FindMethodClass.name, :guid], :expires_in => 100).returns(:hello)
+
+      FindMethodClass.stub(:find, :hello) do
+        FindMethodClass.cached_find_by_guid(:guid).must_equal(:hello)
+      end
+    end
+
+    it "overrides the default options with local options for the fetch call" do
+      ::ActiveRemote::Cached.cache.expects(:fetch).with([FindMethodClass.name, :guid], :expires_in => 200).returns(:hello)
+
+      FindMethodClass.stub(:find, :hello) do
+        FindMethodClass.cached_find_by_guid(:guid, :expires_in => 200).must_equal(:hello)
+      end
+    end
+  end
+end

data/spec/cached_search_methods_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+class SearchMethodClass
+  include ::ActiveRemote::Cached
+
+  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]
+end
+
+describe SearchMethodClass do
+  describe "API" do
+    it "creates 'cached_search_by_guid'" do
+      SearchMethodClass.must_respond_to("cached_search_by_guid")
+    end
+
+    it "creates 'cached_search_by_user_guid'" do
+      SearchMethodClass.must_respond_to("cached_search_by_user_guid")
+    end
+
+    it "creates 'cached_search_by_user_guid_and_client_guid'" do
+      SearchMethodClass.must_respond_to("cached_search_by_user_guid_and_client_guid")
+    end
+
+    it "creates 'cached_search_by_client_guid_and_user_guid'" do
+      SearchMethodClass.must_respond_to("cached_search_by_client_guid_and_user_guid")
+    end
+
+    it "creates 'cached_search_by_derp_and_user_guid_and_client_guid'" do
+      SearchMethodClass.must_respond_to("cached_search_by_derp_and_user_guid_and_client_guid")
+    end
+
+    it "creates 'cached_search_by_client_guid_and_derp_and_user_guid'" do
+      SearchMethodClass.must_respond_to("cached_search_by_client_guid_and_derp_and_user_guid")
+    end
+
+    it "creates 'cached_search_by_client_guid_and_user_guid_and_derp'" do
+      SearchMethodClass.must_respond_to("cached_search_by_client_guid_and_user_guid_and_derp")
+    end
+  end
+
+  describe "#cached_search_by_guid" do
+    before do
+      ::ActiveRemote::Cached.cache(HashCache.new)
+      ::ActiveRemote::Cached.default_options(:expires_in => 100)
+    end
+
+    after do
+      ::ActiveRemote::Cached.default_options({})
+    end
+
+    it "executes the fetch block if not present in cache" do
+      SearchMethodClass.stub(:search, :hello) do
+        SearchMethodClass.cached_search_by_guid(:guid).must_equal(:hello)
+      end
+    end
+
+    it "merges the default options in for the fetch call" do
+      ::ActiveRemote::Cached.cache.expects(:fetch).with([SearchMethodClass.name, :guid], :expires_in => 100).returns(:hello)
+
+      SearchMethodClass.stub(:search, :hello) do
+        SearchMethodClass.cached_search_by_guid(:guid).must_equal(:hello)
+      end
+    end
+
+    it "overrides the default options with local options for the fetch call" do
+      ::ActiveRemote::Cached.cache.expects(:fetch).with([SearchMethodClass.name, :guid], :expires_in => 200).returns(:hello)
+
+      SearchMethodClass.stub(:search, :hello) do
+        SearchMethodClass.cached_search_by_guid(:guid, :expires_in => 200).must_equal(:hello)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'bundler'
+Bundler.require(:default, :development, :test)
+
+require 'minitest/mock'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/pride'
+
+class HashCache < Hash
+  def exist?(key)
+    self.has_key?(key)
+  end
+
+  def fetch(key, options = {}, &blk)
+    if self.has_key?(key)
+      return self[key]
+    end
+
+    self[key] = yield
+  end
+
+  def read(key)
+    self[key]
+  end
+
+  def write(key, value)
+    self[key] = value
+  end
+end
+
+require 'mocha/api'

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: active_remote-cached
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Brandon Dewitt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_remote
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ' Provides "cached" finders and a DSL to enumerate which finders should
+  have cached versions '
+email:
+- brandonsdewitt@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_remote-cached.gemspec
+- lib/active_remote-cached.rb
+- lib/active_remote-cached/cache.rb
+- lib/active_remote-cached/version.rb
+- spec/cache_spec.rb
+- spec/cached_delete_methods_spec.rb
+- spec/cached_exist_methods_spec.rb
+- spec/cached_find_methods_spec.rb
+- spec/cached_search_methods_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Provides a configuration for caching mechanisms and finders on ActiveRemote
+  models that are cached/cacheable
+test_files:
+- spec/cache_spec.rb
+- spec/cached_delete_methods_spec.rb
+- spec/cached_exist_methods_spec.rb
+- spec/cached_find_methods_spec.rb
+- spec/cached_search_methods_spec.rb
+- spec/spec_helper.rb