covercache 0.0.1 → 0.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzNkNTE2ZGNhMWY5NGZmYWMyZDY1NTE5NzhmYWQwZjlmZjEyMWVkOA==
+    YzU2NzM4MzljZGIzOTkyMzU2ZGYwMDBkN2Q2YzNjODQ4YmQxNDE4NQ==
   data.tar.gz: !binary |-
-    ZWFlOWM5M2ZiZGFmZjE0NzAxNDVlYjVkMzU2YWM0ZGE2ODQ5ZDY4Mw==
+    NDNhOTk2NmVhMjExZjcxNDhhNDJhOGY1MDA1YWE1Nzg0YmQ5N2YwNA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NDJhMjcxZGQzZWYwMTAxNWMxNTQxMDdhNTM3ZGMxNmU4MDgzYmYwYzJjN2Vm
-    YWJkNjE5N2JjNGRkMmYxODczYmI0MDZmODlhNzJiZTQ4ZDg4YjU1M2NhMjUz
-    ZDk5ODdmODk5MjVkNTUyODE5YTc1ZDhlYmI3OWZlMDhiZjI0MjY=
+    YThkMDcwYzE1Y2YzZWY2MWM4MTU4M2ZmMWY5NTFmNmZjMWEwYzVlNjJjNGEy
+    ZjYzZjU0ZmM1Zjk5ZTlmMWUzOGEwMWNlOThlNWFkZjAyMzVhMGFiYzQ2NTlk
+    M2EwNWViMDRjNTNhZjQ2OWJiODA5YWM5YmIyNDJiM2QwNzZmYzQ=
   data.tar.gz: !binary |-
-    NmQ4MmJiNjIyNzM5ZjgwMGUwNWJiNzkyOTljMDEzYWVhMmE3MzMxNzI3ZmIz
-    NzdkYjFlNzNlYWRjNGI1MGJhZTY1YzJjN2Q1OWE4MmZjZWMwMjk2ZDkyM2Iw
-    ZjI1NGM4NmQ1NDcxNGMyNjQ3ODhlMzYwNTBlNWYyYjg3MzcwYmM=
+    ODE1MTRlYzMzZjc4MTdkZjE1MzhmZDc4MGJmYmRkODdiZTZkYTBlMTUzZmVk
+    ZjFhZjkyNmUyNjFjNjgyMGFlY2JlZWI0MzU0MDVlNGE1ODZiZWRmODQ1ZGMz
+    ZGIwNzIxMWU0YzgwOWE3MmYzZDQ2MGZjNGMzMTFjOGE5MDE1Yzk=

data/README.md

@@ -1,16 +1,41 @@
 # Covercache
 
-Covercache based on PackRat
+Covercache is a helper for Rails.cache, based on [PackRat](https://github.com/cpuguy83/pack_rat) gem, and, as it says: <br />
+> When included in your class it makes caching trivial.
 
-Covercache is a simple helper for Rails.cache<br />
-When included in your class it makes caching trivial.
+## Motivation
 
-Add following line to your model which you want to cache
+* Quickly use <tt>Rails.cache</tt> for some tasks without rubbish code in models.
+* Don't worrying about generation and storing cache keys, but sometimes will be able to adjust it.
+* Cache any queries and scopes, not only `find_by` and simple associations, as many caching gems provide.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'covercache'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install covercache
+
+## Usage
+
+Add following line to your model which you want to cache:
 
     class Post < ActiveRecord::Base
       covers_with_cache
-    
-Now you can wrap methods with Covercash (like PackRat). For example:
+
+Now you can use `define_cached`, `class_define_cached` or `covercache` helpers.
+
+### Method covering with `covercache`
+
+Use the `covercache` helper inside instance and class methods. Syntax is similar to PackRat `cache` helper with a few additions (see source).
 
       has_many :comments
       scope :published, where(published: true)
@@ -22,29 +47,48 @@ Now you can wrap methods with Covercash (like PackRat). For example:
       end
       
       def self.cached_published
-        covercache do
+        covercache debug:true do
           published.all
         end
       end
 
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'covercache'
-
-And then execute:
-
-    $ bundle
+### Wrapping with <tt>define_cached</tt> and `class_define_cached`
 
-Or install it yourself as:
+You can easily wrap methods with the <tt>define_cached</tt> helper.<br />
+Note, that Relation objects couldn't be cached, so wrapped method or block 
+should return an array or single instance of your model. 
 
-    $ gem install covercache
-
-## Usage
-
-TODO: Write usage instructions here
+To wrap instance methods you should use a name of already defined method:
+  
+    class Post < ActiveRecord::Base
+	  def all_comments
+	    comments.all
+	  end
+	    
+	  # Wrap instance method Post#all_comments to Post#cached_all_comments:
+	  define_cached :all_comments
+	
+	  # You can add arguments like for covercache: 
+	  # [keys], debug: true, expires_in: 10.minutes
+	  define_cached :all_comments, expires_in: 1.minute
+	
+	  # ...
+	end
+	  
+	post = Post.find(1)
+	post.cached_all_comments
+
+To wrap class methods you can also use blocks:
+  
+    class_define_cached :for_post_ids, 
+    					debug:      true, 
+    					expires_in: 10.minutes do |post_ids|
+      where(post_id: post_ids).all
+    end
+  
+    post_ids = (1..10).to_a
+    Comments.cached_for_post_ids post_ids, cache_key: post_ids.hash
 
 ## Contributing
 

data/lib/covercache/version.rb

@@ -1,3 +1,3 @@
 module Covercache
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/covercache.rb

@@ -1,44 +1,195 @@
-require "where"
-require 'active_record'
-require 'active_support/core_ext'
 require "covercache/version"
-require "covercache/model"
 
+require 'active_support/core_ext'
+require 'active_support/concern' 
+require 'active_record'
+
+require "where"
+
+# == Motivation
+# 
+# * Quickly use <tt>Rails.cache</tt> for some tasks without rubbish code in models.
+# * Don't worrying about generation and storing cache keys, but sometimes will be able to adjust it.
+# * Don't be limited with indexes, queries or scopes.
+# 
+# == Usage
+# 
+# Add <tt>covers_with_cache</tt> in your model class and use <tt>define_cached</tt> or <tt>covercache</tt> helpers.
+# 
+# == Wrapping with <tt>define_cached</tt>
+# 
+# You can easily wrap methods with the <tt>define_cached</tt> helper.<br />
+# Note, that Relation objects couldn't be cached, so wrapped method or block 
+# should return an array or single instance of your model. 
+# 
+# To wrap instance methods you should use a name of already defined method:
+#   
+#   class Post < ActiveRecord::Base
+#     def all_comments
+#       comments.all
+#     end
+#     
+#     # Wrap instance method Post#all_comments to Post#cached_all_comments:
+#     define_cached :all_comments
+# 
+#     # You can add arguments like for covercache: [keys], debug: true, expires_in: 10.minutes
+#     define_cached :all_comments, expires_in: 1.minute
+# 
+#     # ...
+#   end
+#   
+#   post = Post.find(1)
+#   post.cached_all_comments
+# 
+# To wrap class methods you can also use use a block:
+#   
+#   class_define_cached :for_post_ids, debug: true, expires_in: 10.minutes do |post_ids|
+#     where(post_id: post_ids).all
+#   end
+#   
+#   post_ids = (1..10).to_a
+#   Comments.cached_for_post_ids post_ids, cache_key: post_ids.hash
+# 
 module Covercache
-  module CoversWithCache
-    def covers_with_cache
-      class_eval do
-        %w(keys model_source model_digest).each do |key, value|
-          class_attribute :"covercache_#{key}"
-          self.send(:"covercache_#{key}=", value) if value.present?
-        end
-                
-        self.covercache_keys ||= []
-        self.covercache_model_source = Where.is_class self, of: 'app/models'
-        
-        include Covercache::Model
-        
-        generate_model_digest!
-        
-        after_commit :covercache_flush_cache
+  # General helper method (ex <tt>cache</tt> helper  in PackRat)
+  module Base
+    private # ?    
+    def covercache(*args, &block) 
+      options = args.extract_options!
+      key     = []
+      should_debug = options[:debug].present? and options[:debug]
+
+      klass = covercaching_class_method? ? self : self.class
+
+      # Remove helper related options so we can pass to Rails.cache
+      filtered_options = options.except(:debug, :overwrite_key)     
+      
+      # if overwrite_key was set, we skip creating our own key
+      unless options[:overwrite_key] 
+        model_digest   = covercaching_get_model_digest
+        # Hack to get the method that called cache
+        calling_method = caller[0][/`([^']*)'/, 1] 
+
+        key << klass.name
+        key << [model_digest, calling_method].compact.join('/')
+        key << cache_key if self.respond_to?(:cache_key)
+        key += args
+      end
+      # Output the generated cache key to the console if debug is set
+      puts key.inspect if should_debug                              
+      # Make the actual Rails.cache call
+      Rails.cache.fetch key, filtered_options do
+        klass.covercache_keys << key unless key.in?(klass.covercache_keys)
+        block.call
       end
     end
+
+    def covercaching_get_model_digest
+      self.covercache_model_digest.presence
+    end
     
-    # TODO: coming soon...
+    def covercaching_class_method?
+      self.is_a? Class
+    end
+  end
+  
+  # == Defining Helper
+  # 
+  # TODO: share logic
+  # 
+  module DefiningHelper
+    # Define and wrap methods or blocks
     def define_cached(*args)
       method_name = args.shift              
       opts = args.extract_options!
-      define_method :"cached_#{method_name}" do |*method_args|
-        puts self.inspect
+      # method definition
+      define_method :"cached_#{method_name}" do |*method_args|      
         if method_args.last.is_a?(Hash) and method_args.last.has_key?(:cache_key)
           add_to_args = method_args.last.delete(:cache_key)
           args += [add_to_args].flatten if add_to_args.present?
         end
-        covercache(*args, opts) { self.send(method_name, *method_args) }
-      end      
+        covercache(*args,opts){ self.send method_name, *method_args }
+      end
     end
     
+    # TODO: not good
+    def class_define_cached(*args)
+      (class << self; self; end).instance_eval do
+        method_name = args.shift              
+        opts = args.extract_options!
+        # method definition
+        define_method :"cached_#{method_name}" do |*method_args|        
+          if method_args.last.is_a?(Hash) and method_args.last.has_key?(:cache_key)
+            add_to_args = method_args.last.delete :cache_key
+            args += [add_to_args].flatten if add_to_args.present?
+          end
+          covercache(*args, opts) do 
+            block_given? ? yield(*method_args) : self.send(method_name, *method_args)
+          end
+        end
+      end
+    end
+  end
+  
+  # Extend and Include to model Base helper so cache method is available in all contexts. 
+  # <em>(yes, it is form PackRat too)</em>
+  module ModelConcern
+    extend ActiveSupport::Concern
+
+    included do
+      %w(keys model_source model_digest).each do |key, value|
+        class_attribute :"covercache_#{key}"
+        self.send(:"covercache_#{key}=", value) if value.present?
+      end
+              
+      self.covercache_keys ||= []
+      self.covercache_model_source = Where.is_class self, of: 'app/models'
+
+      generate_model_digest!
+      
+      after_commit :covercache_flush_cache
+
+      extend  Base
+      include Base
+    end
+    
+    # Support class methods
+    module ClassMethods
+      def generate_model_digest
+        return unless covercache_model_source?
+        file = File.read self.covercache_model_source
+        Digest::MD5.hexdigest(file)
+      rescue
+        nil
+      end
+    
+      # Generates and sets file_digest attribute
+      def generate_model_digest!
+        self.covercache_model_digest = self.generate_model_digest
+      end
+      
+      def covercache_flush!
+        self.covercache_keys.each do |key|
+          Rails.cache.delete(key) # if Rails.cache.exist?(key)
+        end.clear
+        self.covercache_keys.empty?
+      end
+    end
+    
+    # flush cache on after_commit callback
+    def covercache_flush_cache!
+      self.class.send :covercache_flush!
+    end
+  end
+  
+  # module CoversWithCache
+  # add Covercache supporting to model
+  def covers_with_cache
+    class_eval do
+      include Covercache::ModelConcern
+      extend  Covercache::DefiningHelper
+    end
   end
 end
 
-ActiveRecord::Base.extend Covercache::CoversWithCache
+ActiveRecord::Base.extend Covercache #::CoversWithCache

data/spec/libs/covercache_spec.rb

@@ -17,6 +17,14 @@ describe "covercache" do
     pp Post.covercache_model_digest
     Post.covercache_model_digest.should be_an(String)
   end
+  it "should respounds to instance method defined by define_cached" do
+    comment = Comment.last
+    comment.cached_post.should == comment.post
+  end
+  it "should respounds to class method defined by define_cached" do
+    comments = Comment.cached_for_post(1)
+    Post.find(1).comments.should == comments
+  end
   it 'should return the same digest for class and instance' do
     post1 = Post.find(1)
     pp post1.covercache_model_digest

data/spec/spec_helper.rb

@@ -72,6 +72,10 @@ end
 class Comment < ActiveRecord::Base
   belongs_to :post
   covers_with_cache
+  define_cached :post, debug: true
+  class_define_cached :for_post, debug: true do |post_id|
+    where(post_id: post_id).all
+  end
 end
 
 post1 = Post.create(:text => "First post!")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: covercache
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Tõnis Simo
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-19 00:00:00.000000000 Z
+date: 2013-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -138,8 +138,6 @@ files:
 - Rakefile
 - covercache.gemspec
 - lib/covercache.rb
-- lib/covercache/model.rb
-- lib/covercache/model/cacher.rb
 - lib/covercache/version.rb
 - lib/where.rb
 - spec/covercache.sqlite3

data/lib/covercache/model/cacher.rb

@@ -1,43 +0,0 @@
-module Covercache
-  module Model
-    module Cacher
-      private
-      def covercache(*args, &block)        
-        options = args.extract_options!
-        key     = []
-        should_debug = options[:debug].present? and options[:debug]
-
-        klass = covercaching_class_method? ? self : self.class
-
-        filtered_options = options.except(:debug, :overwrite_key)     # Remove PackRat related options so we can pass to Rails.cache
-        
-        unless options[:overwrite_key] # if overwrite_key was set, we skip creating our own key
-          model_digest   = covercaching_get_model_digest
-          calling_method = caller[0][/`([^']*)'/, 1] # Hack to get the method that called cache
-
-          key << klass.name
-          key << [model_digest, calling_method].compact.join('/')
-          key << cache_key if self.respond_to?(:cache_key)
-          key += args
-        end
-        
-        puts key.inspect if should_debug                              # Output the generated cache key to the console if debug is set
-        
-        # Make the actual Rails.cache call
-        Rails.cache.fetch key, filtered_options do
-          klass.covercache_keys << key unless key.in?(klass.covercache_keys)
-          block.call
-        end
-      end
-      
-      private
-      def covercaching_get_model_digest
-        self.covercache_model_digest.presence
-      end
-      
-      def covercaching_class_method?
-        self.is_a? Class
-      end
-    end
-  end
-end

data/lib/covercache/model.rb

@@ -1,40 +0,0 @@
-require 'active_support/concern' 
-require 'covercache/model/cacher'
-
-module Covercache
-  module Model
-    extend ActiveSupport::Concern
-
-    included do
-      extend  Cacher          # Include and Extend so cache method is available in all contexts
-      include Cacher
-    end
-
-    module ClassMethods
-      def generate_model_digest
-        return unless covercache_model_source?
-        file = File.read self.covercache_model_source
-        Digest::MD5.hexdigest(file)
-      rescue
-        nil
-      end
-    
-      # Generates and sets file_digest attribute
-      def generate_model_digest!
-        self.covercache_model_digest = self.generate_model_digest
-      end
-      
-      def covercache_flush!
-        self.covercache_keys.each do |key|
-          Rails.cache.delete(key) # if Rails.cache.exist?(key)
-        end.clear
-        self.covercache_keys.empty?
-      end
-    end
-    
-    # flush cache on after_commit callback
-    def covercache_flush_cache!
-      self.class.send :covercache_flush!
-    end
-  end
-end