active_remote-cached 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0f5c9001aeadeb02257a3a6cbc8206e0209e3e7
-  data.tar.gz: b50ea3df9a27c2cd8f38c47f49687880a67aa8af
+  metadata.gz: 8ab07ab8e11e7520b6bfb6d309943f8824076362
+  data.tar.gz: ad6a3abff29c918cd16e9dc94a283f222cfdb606
 SHA512:
-  metadata.gz: 60eaeea21dfc61be402f4ca821e2a2d3f3ce6e5f8f7359e57c5591c62f609d20b1ba2f24389694d9e75f83e9e6011dd7651b358380a19e5446f1da128464967c
-  data.tar.gz: b1056bf3a13952433b28b7ebb13904d8511bc2e88bd90783dd728468c8d6157406677be137129123e42a61ae43b8578509a49de378d868c6331961ea80aff3f4
+  metadata.gz: fcecd3db779daa85deb56636edd9511c670cca9c079a02f861a09e1547e3758af0f5423471bce501d7156d51267dd845dff5b76e6884966ef2679a8cfc7f442a
+  data.tar.gz: 1811c6219eb8123a54dc4e6a95bd75952fd71a28ef70038b57f5a5b6f50d9073a4f67d7f0bb4b3873b45da28d4e69f3fadf471216347551bcb0774bf1759f075

data/README.md

@@ -18,38 +18,76 @@ Or install it yourself as:
 
 ## Usage
 
-include `::ActiveRemote::Cached` into your ActiveRemote models that can support cached finders
+### Defining cache finders
+
+Include `::ActiveRemote::Cached` into your ActiveRemote models that can support cached finders*
+
+```ruby
+class Customer < ::ActiveRemote::Base
+  include ::ActiveRemote::Cached
+end
+```
+
+_*This is already done for you in Rails_
+
+Then declare some cache finder methods. Cached finders can be defined for individual fields or defined as composites for mulitple fields
 
 ```ruby
-  class Customer < ::ActiveRemote::Base
-    include ::ActiveRemote::Cached
+class Customer < ::ActiveRemote::Base
+  # Create a cached finder for id
+  cached_finders_for :id
 
-    # Declare the cached finder methods that will be supported
-    cached_finders_for :id
-    cached_finders_for [:name, :email]
-  end
+  # Create a composite cached finder for name and email
+  cached_finders_for [:name, :email]
+end
 ```
 
 Now that you have a model that has cached finders on it you can use the `cached_search`, `cached_find`, or dynamic cached finder methods on the model to use the cache before you issue the AR search/find method.
 
 ```ruby
-  customer = ::Customer.cached_find_by_id(1) # => <Customer id=1>
-  customer = ::Customer.cached_find(:id => 1) # => <Customer id=1>
-  customer = ::Customer.cached_search_by_id(1) # => [ <Customer id=1> ]
-  customer = ::Customer.cached_search(:id => 1) # => [ <Customer id=1> ]
+customer = ::Customer.cached_find_by_id(1) # => <Customer id=1>
+customer = ::Customer.cached_find(:id => 1) # => <Customer id=1>
+customer = ::Customer.cached_search_by_id(1) # => [ <Customer id=1> ]
+customer = ::Customer.cached_search(:id => 1) # => [ <Customer id=1> ]
 ```
 
 ```ruby
-  # All permutations of "complex" dynamic finders are defined
-  customer = ::Customer.cached_find_by_name_and_email("name", "email") # => <Customer id=1>
-  customer = ::Customer.cached_find_by_email_and_name("email", "name") # => <Customer id=1>
+# All permutations of "complex" dynamic finders are defined
+customer = ::Customer.cached_find_by_name_and_email("name", "email") # => <Customer id=1>
+customer = ::Customer.cached_find_by_email_and_name("email", "name") # => <Customer id=1>
+
+# Only declared finders are defined
+customer = ::Customer.cached_find_by_name("name") # => NoMethodError
+```
+
+### Configuring the cache provider
+
+ActiveRemote::Cached relies on an ActiveSupport::Cache-compatible cache provider. The cache is initialized with a simple memory store (defaults to 32MB), but can be overridden via `ActiveRemote::Cached.cache`:
+
+```ruby
+ActiveRemote::Cached.cache(Your::ActiveSupport::Cache::Compatible::Provider.new)
+```
+
+In Rails apps, the memory store is replaced the whatever Rails is using as it's cache store.
 
-  # Only declared finders are defined
-  customer = ::Customer.cached_find_by_name("name") # => NoMethodError
+#### Default options
+
+The default cache options used when interacting with the cache can be specified via `ActiveRemote::Cached.default_options`:
+
+```ruby
+ActiveRemote::Cached.default_options(:expires_in => 1.hour)
 ```
 
+In Rails apps, the :race_condition_ttl option defaults to 5 seconds.
+
+#### Local overrides
+
 Each finder as takes an optional options hash that will override the options passed to the caching provider (override from the global defaults setup for ActiveRemote::Cached)
 
+```ruby
+customer = ::Customer.cached_find_by_id(1, :expires_in => 15.minutes)
+```
+
 ## Contributing
 
 1. Fork it

data/active_remote-cached.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'active_remote-cached/version'
+require 'active_remote/cached/version'
 
 Gem::Specification.new do |gem|
   gem.name          = "active_remote-cached"

data/lib/active_remote-cached.rb

@@ -1,262 +1 @@
-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
-
-      def cached_find(argument_hash, options = {})
-        method_name = _cached_find_method_name(argument_hash.keys)
-        arguments = argument_hash.values
-
-        if block_given?
-          __send__(method_name, *arguments, options) do
-            yield
-          end
-        else
-          __send__(method_name, *arguments, options)
-        end
-      end
-
-      def cached_search(argument_hash, options = {})
-        method_name = _cached_search_method_name(argument_hash.keys)
-        arguments = argument_hash.values
-
-        if block_given?
-          __send__(method_name, *arguments, options) do
-            yield
-          end
-        else
-          __send__(method_name, *arguments, options)
-        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)
-
-          unless self.respond_to?(delete_method_name)
-            _define_cached_delete_method(delete_method_name, arguments)
-          end
-
-          unless self.respond_to?(exist_find_method_name)
-            _define_cached_exist_find_method(exist_find_method_name, arguments)
-          end
-
-          unless self.respond_to?(exist_search_method_name)
-            _define_cached_exist_search_method(exist_search_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_find_method_name(arguments)
-        "cached_exist_find_by_#{arguments.join('_and_')}"
-      end
-
-      def _cached_exist_search_method_name(arguments)
-        "cached_exist_search_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, "#search", #{sorted_method_args}])
-            ::ActiveRemote::Cached.cache.delete([name, "#find", #{sorted_method_args}])
-          end
-        RUBY
-      end
-
-      def _define_cached_exist_find_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_find_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, "#find", #{sorted_method_args}])
-          end
-        RUBY
-
-        self.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}, options = {})
-            ::ActiveRemote::Cached.cache.exist?([name, "#find", #{sorted_method_args}])
-          end
-        RUBY
-      end
-
-      def _define_cached_exist_search_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_search_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, "#search", #{sorted_method_args}])
-          end
-        RUBY
-
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          # def self.cached_exist_search_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, "#search", #{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, "#find", user_guid], options) do
-          #     self.find(:user_guid => user_guid)
-          #   end
-          # end
-          # 
-          # If a block is given, it is incumbent on the caller to make sure the expectation
-          # of the result object is maintained for requests/responses
-          #
-          def self.#{method_name}(#{expanded_method_args}, options = {})
-            options = ::ActiveRemote::Cached.default_options.merge(options)
-
-            ::ActiveRemote::Cached.cache.fetch([name, "#find", #{sorted_method_args}], options) do
-              if block_given?
-                yield
-              else
-                self.find(#{expanded_search_args})
-              end
-            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, "#search", user_guid], options) do
-          #     self.search(:user_guid => user_guid)
-          #   end
-          # end
-          #
-          # If a block is given, it is incumbent on the caller to make sure the expectation
-          # of the result object is maintained for requests/responses
-          #
-          def self.#{method_name}(#{expanded_method_args}, options = {})
-            options = ::ActiveRemote::Cached.default_options.merge(options)
-
-            ::ActiveRemote::Cached.cache.fetch([name, "#search", #{sorted_method_args}], options) do
-              if block_given?
-                yield
-              else
-                self.search(#{expanded_search_args})
-              end
-            end
-          end
-        RUBY
-      end
-    end
-  end
-end
+require "active_remote/cached"

data/lib/active_remote/cached.rb

@@ -0,0 +1,269 @@
+require "active_support"
+require "active_support/cache"
+require "active_support/concern"
+require "active_support/core_ext/array/extract_options"
+
+require "active_remote/cached/cache"
+require "active_remote/cached/version"
+
+require "active_remote/cached/railtie" if defined?(Rails)
+
+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
+
+      def cached_find(argument_hash, options = {})
+        method_name = _cached_find_method_name(argument_hash.keys)
+        arguments = argument_hash.values
+
+        if block_given?
+          __send__(method_name, *arguments, options) do
+            yield
+          end
+        else
+          __send__(method_name, *arguments, options)
+        end
+      end
+
+      def cached_search(argument_hash, options = {})
+        method_name = _cached_search_method_name(argument_hash.keys)
+        arguments = argument_hash.values
+
+        if block_given?
+          __send__(method_name, *arguments, options) do
+            yield
+          end
+        else
+          __send__(method_name, *arguments, options)
+        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)
+
+          unless self.respond_to?(delete_method_name)
+            _define_cached_delete_method(delete_method_name, arguments)
+          end
+
+          unless self.respond_to?(exist_find_method_name)
+            _define_cached_exist_find_method(exist_find_method_name, arguments)
+          end
+
+          unless self.respond_to?(exist_search_method_name)
+            _define_cached_exist_search_method(exist_search_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_find_method_name(arguments)
+        "cached_exist_find_by_#{arguments.join('_and_')}"
+      end
+
+      def _cached_exist_search_method_name(arguments)
+        "cached_exist_search_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, "#search", #{sorted_method_args}])
+            ::ActiveRemote::Cached.cache.delete([name, "#find", #{sorted_method_args}])
+          end
+        RUBY
+      end
+
+      def _define_cached_exist_find_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_find_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, "#find", #{sorted_method_args}])
+          end
+        RUBY
+
+        self.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}, options = {})
+            ::ActiveRemote::Cached.cache.exist?([name, "#find", #{sorted_method_args}])
+          end
+        RUBY
+      end
+
+      def _define_cached_exist_search_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_search_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, "#search", #{sorted_method_args}])
+          end
+        RUBY
+
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          # def self.cached_exist_search_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, "#search", #{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, "#find", user_guid], options) do
+          #     self.find(:user_guid => user_guid)
+          #   end
+          # end
+          #
+          # If a block is given, it is incumbent on the caller to make sure the expectation
+          # of the result object is maintained for requests/responses
+          #
+          def self.#{method_name}(#{expanded_method_args}, options = {})
+            options = ::ActiveRemote::Cached.default_options.merge(options)
+
+            ::ActiveRemote::Cached.cache.fetch([name, "#find", #{sorted_method_args}], options) do
+              if block_given?
+                yield
+              else
+                self.find(#{expanded_search_args})
+              end
+            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, "#search", user_guid], options) do
+          #     self.search(:user_guid => user_guid)
+          #   end
+          # end
+          #
+          # If a block is given, it is incumbent on the caller to make sure the expectation
+          # of the result object is maintained for requests/responses
+          #
+          def self.#{method_name}(#{expanded_method_args}, options = {})
+            options = ::ActiveRemote::Cached.default_options.merge(options)
+
+            ::ActiveRemote::Cached.cache.fetch([name, "#search", #{sorted_method_args}], options) do
+              if block_given?
+                yield
+              else
+                self.search(#{expanded_search_args})
+              end
+            end
+          end
+        RUBY
+      end
+    end
+
+    # Initialize the cache provider with a MemoryStore cache
+    cache(ActiveSupport::Cache::MemoryStore.new)
+  end
+end

data/lib/active_remote/cached/railtie.rb

@@ -0,0 +1,14 @@
+module ActiveRemote
+  module Cached
+    class Railtie < Rails::Railtie
+      initializer "active_remote-cached.initialize_cache" do |app|
+        ActiveRemote::Cached.cache(app.cache)
+        ActiveRemote::Cached.default_options(:race_condition_ttl => 5.seconds)
+      end
+
+      ActiveSupport.on_load(:active_remote) do
+        include ActiveRemote::Cached
+      end
+    end
+  end
+end

data/lib/{active_remote-cached → active_remote/cached}/version.rb

@@ -1,5 +1,5 @@
 module ActiveRemote
   module Cached
-    VERSION = "0.0.5"
+    VERSION = "0.0.6"
   end
 end

metadata

@@ -1,97 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: active_remote-cached
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Brandon Dewitt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-08 00:00:00.000000000 Z
+date: 2014-07-31 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
@@ -102,20 +102,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".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
+- lib/active_remote/cached.rb
+- lib/active_remote/cached/cache.rb
+- lib/active_remote/cached/railtie.rb
+- lib/active_remote/cached/version.rb
+- spec/active_remote/cached/cache_spec.rb
+- spec/active_remote/cached_delete_methods_spec.rb
+- spec/active_remote/cached_exist_methods_spec.rb
+- spec/active_remote/cached_find_methods_spec.rb
+- spec/active_remote/cached_search_methods_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses: []
@@ -126,12 +128,12 @@ 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: []
@@ -142,9 +144,9 @@ 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/active_remote/cached/cache_spec.rb
+- spec/active_remote/cached_delete_methods_spec.rb
+- spec/active_remote/cached_exist_methods_spec.rb
+- spec/active_remote/cached_find_methods_spec.rb
+- spec/active_remote/cached_search_methods_spec.rb
 - spec/spec_helper.rb