covercache 0.1.0 → 0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YzU2NzM4MzljZGIzOTkyMzU2ZGYwMDBkN2Q2YzNjODQ4YmQxNDE4NQ==
+    YjlhOGViNGViNzYwZDEyNjg3ZjQ1N2ZhNjFiYWY3OGJmMTY5ODVmNw==
   data.tar.gz: !binary |-
-    NDNhOTk2NmVhMjExZjcxNDhhNDJhOGY1MDA1YWE1Nzg0YmQ5N2YwNA==
+    MmE3MDFlNmU0ZDQ4NDVjNjEwN2EwOWQxMjI5NDVmY2FiODA3ZjVmYQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    YThkMDcwYzE1Y2YzZWY2MWM4MTU4M2ZmMWY5NTFmNmZjMWEwYzVlNjJjNGEy
-    ZjYzZjU0ZmM1Zjk5ZTlmMWUzOGEwMWNlOThlNWFkZjAyMzVhMGFiYzQ2NTlk
-    M2EwNWViMDRjNTNhZjQ2OWJiODA5YWM5YmIyNDJiM2QwNzZmYzQ=
+    NjM3YmJmN2NjMzI2NzBlYjU5MDQ5ZmI5YjBhY2E4MDllY2I1MTM4YzdhMWE0
+    YjQ4M2EzYTk3ZjJjODZkMGYwYTYwMDIxY2Y0Yzk3OGI0ZTczOWI5NWE3N2Vj
+    ZTJjZDEyZThjMDNmOTY1MGMyYzE2YTY3ZGJkMjllMDlmZmEwZWY=
   data.tar.gz: !binary |-
-    ODE1MTRlYzMzZjc4MTdkZjE1MzhmZDc4MGJmYmRkODdiZTZkYTBlMTUzZmVk
-    ZjFhZjkyNmUyNjFjNjgyMGFlY2JlZWI0MzU0MDVlNGE1ODZiZWRmODQ1ZGMz
-    ZGIwNzIxMWU0YzgwOWE3MmYzZDQ2MGZjNGMzMTFjOGE5MDE1Yzk=
+    MmQ5OTllYzMwZmUyMmZlYzk2MmUyNzMyOGEyMmI1ZWY2OTg3ZDkxNjBiYzBk
+    NmNjMTE4ZDA1ZGMxMjU1MGFhZGE0ZDIwZjZiZDY1ZGQ3Zjc4OTEzM2EzMzlk
+    N2YxOTRkYjY2ZjE3ZTFkMjhiMjEyYjE3MjcyYjRhMmM2OWNiOTY=

data/README.md

@@ -1,5 +1,7 @@
 # Covercache
 
+[![Code Climate](https://codeclimate.com/github/estum/covercache.png)](https://codeclimate.com/github/estum/covercache)
+
 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.
 
@@ -59,7 +61,7 @@ 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:
+To wrap instance methods you should use a name of already defined method or set block with the first argument as record:
   
     class Post < ActiveRecord::Base
 	  def all_comments
@@ -72,7 +74,10 @@ To wrap instance methods you should use a name of already defined method:
 	  # You can add arguments like for covercache: 
 	  # [keys], debug: true, expires_in: 10.minutes
 	  define_cached :all_comments, expires_in: 1.minute
-	
+	  
+	  define_cached :all_comments_authors, debug: true, do |record|
+	    record.author
+	  end
 	  # ...
 	end
 	  

data/covercache.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["anton.estum@gmail.com"]
   spec.description   = %q{Helper method to simplify Rails caching, based on PackRat}
   spec.summary       = %q{Rails cache helper based on PackRat gem}
-  spec.homepage      = "http://github.com/tonissimo/covercache"
+  spec.homepage      = "http://github.com/estum/covercache"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)

data/lib/covercache/version.rb

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

data/lib/covercache.rb

@@ -4,8 +4,6 @@ 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.
@@ -22,7 +20,7 @@ require "where"
 # 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:
+# To wrap instance methods you should use a name of already defined method or set block with the first argument as record:
 #   
 #   class Post < ActiveRecord::Base
 #     def all_comments
@@ -35,13 +33,16 @@ require "where"
 #     # You can add arguments like for covercache: [keys], debug: true, expires_in: 10.minutes
 #     define_cached :all_comments, expires_in: 1.minute
 # 
+#     define_cached :all_comments_authors, expires_in: 1.minute do |record|
+#       record.author
+#     end
 #     # ...
 #   end
 #   
 #   post = Post.find(1)
 #   post.cached_all_comments
 # 
-# To wrap class methods you can also use use a block:
+# To wrap class methods:
 #   
 #   class_define_cached :for_post_ids, debug: true, expires_in: 10.minutes do |post_ids|
 #     where(post_id: post_ids).all
@@ -52,85 +53,119 @@ require "where"
 # 
 module Covercache
   # 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)     
+  module Base    
+    # Arguments:
+    #     
+    #      [1..]              any count of custom *keys
+    #      :debug             #=>
+    #      :without_auto_key  #=> don't generate cache_key
+    #       any option for Rails.cache.fetch
+    # 
+    # Example:
+    #     
+    #     scope :published, -> { where published: true }
+    #     has_many :comments
+    #           
+    #     def cached_comments
+    #       covercache do
+    #         comments.all
+    #       end
+    #     end
+    #           
+    #     def self.cached_published
+    #       covercache debug:true do
+    #         published.all
+    #       end
+    #     end
+    # 
+    private
+    def covercache(*keys, &block)
+      klass      = class_or_instance_class
+      options    = keys.extract_options!
+      cover_opts = options.extract! :debug, :without_auto_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)
+      # if :no_auto_cache_keys was set, we skip creating our own key
+      keys.prepend get_auto_cache_key(klass.name, caller) unless cover_opts[:without_auto_key]
+      keys.flatten!
+      puts keys.inspect if !!cover_opts[:debug]
+      # puts caller.inspect if !!cover_opts[:debug],
+            
+      Rails.cache.fetch keys, options do
+        klass.covercache_keys |= [ keys ]
         block.call
       end
     end
-
-    def covercaching_get_model_digest
-      self.covercache_model_digest.presence
+    
+    def get_auto_cache_key(class_name, _caller)
+      caller_method = _caller.map {|c| c[/`([^']*)'/, 1] }.detect {|m| !m.start_with?('block') }
+      puts caller_method.inspect
+      [ class_name, covercache_model_digest, caller_method, (cache_key if self.respond_to?(:cache_key?)) ].compact
+    end
+    
+    def class_or_instance_class
+      self.is_a?(Class) ? self : self.class
     end
     
-    def covercaching_class_method?
-      self.is_a? Class
+    def extract_cache_key_from(*args)
+      Array.wrap((args.last.delete(:cache_key) if args.last.is_a?(Hash)))
     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!
-      # 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
+    def define_cached(method, *args, &block)
+      options = args.extract_options!
+      is_class_method = !!options.delete(:is_class_method)
+
+      file, line = caller[is_class_method ? 1 : 0].split ':', 2
+      line = line.to_i
+      
+      covercache_method_arguments method, args, options, &block
+      covercache_define_wrapper method, file, line, block_given?, is_class_method
+    end
+  
+    def class_define_cached(method, *args, &block)
+      options = args.extract_options!
+      options[:is_class_method] = true
+      self.send :define_cached, method, *args, options, &block
     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)
+    private
+    def covercache_define_wrapper(method, file, line, with_block=false, is_class_method=false)
+      cached_method = "cached_#{method}"
+      
+      class_eval(<<-EOS, file, line - 2)
+        def #{'self.' if is_class_method}#{cached_method}(*args, &block)
+          settings = Array.wrap(#{cached_method}_settings[:args]) + extract_cache_key_from(*args)
+          covercache(*settings, #{cached_method}_settings[:opts]) do
+            if #{with_block}
+              #{cached_method}_settings[:block].call(#{'self,' unless is_class_method}*args)
+            else
+              self.__send__ :#{method}, *args, &block
+            end
           end
         end
-      end
+      EOS
+    end
+    
+    def covercache_method_arguments(method, *args, &block)
+      settings = collect_method_args_to_hash(*args, &block)
+      puts settings.inspect
+      class_attribute :"cached_#{method}_settings"
+      self.send(:"cached_#{method}_settings=", settings)
+    end
+    
+    def collect_method_args_to_hash(*args, &block)
+      puts args.inspect
+      Hash[ %w{args opts block}.map do |x| 
+        [ x, (args.shift || block) ] 
+      end].to_options
     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
@@ -143,7 +178,7 @@ module Covercache
       end
               
       self.covercache_keys ||= []
-      self.covercache_model_source = Where.is_class self, of: 'app/models'
+      self.covercache_model_source ||= @covercache_caller_source #Where.is_class self, of: 'app/models'
 
       generate_model_digest!
       
@@ -165,14 +200,12 @@ module Covercache
     
       # Generates and sets file_digest attribute
       def generate_model_digest!
-        self.covercache_model_digest = self.generate_model_digest
+        self.covercache_model_digest = 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?
+        self.covercache_keys.each { |key| Rails.cache.delete(key) }.clear # if Rails.cache.exist?(key)
+        covercache_keys.empty?
       end
     end
     
@@ -185,7 +218,10 @@ module Covercache
   # module CoversWithCache
   # add Covercache supporting to model
   def covers_with_cache
+    caller_source = caller.first[/[^:]+/]
+    
     class_eval do
+      @covercache_caller_source = caller_source
       include Covercache::ModelConcern
       extend  Covercache::DefiningHelper
     end

data/spec/libs/covercache_spec.rb

@@ -5,10 +5,6 @@ describe "covercache" do
   it 'should respond to covers_with_cache' do
     Post.should respond_to(:covers_with_cache)
   end
-  it 'should hove class keys storage' do
-    pp Post.covercache_keys
-    Post.covercache_keys.should be_an(Array)
-  end
   it 'should have covercache_model_source attribute' do
     pp Post.covercache_model_source
     Post.covercache_model_source.should be_an(String)
@@ -36,4 +32,12 @@ describe "covercache" do
     pp test.cached_comments.inspect
     test.cached_comments.count.should == test.comments.count
   end
+  it 'post should have class keys storage' do
+    pp Post.covercache_keys
+    Post.covercache_keys.should be_an(Array)
+  end
+  it 'comments should have class keys storage' do
+    pp Comment.covercache_keys
+    Comment.covercache_keys.should be_an(Array)
+  end
 end

data/spec/spec_helper.rb

@@ -62,17 +62,20 @@ end
 class Post < ActiveRecord::Base
   has_many :comments
   covers_with_cache
-  def cached_comments
-    covercache debug: true do
-      comments.all
-    end
-  end
+  define_cached :comments, debug: true
+  # def cached_comments
+  #   covercache debug: true do
+  #     comments.all
+  #   end
+  # end
 end
 
 class Comment < ActiveRecord::Base
   belongs_to :post
   covers_with_cache
-  define_cached :post, debug: true
+  define_cached :post, debug: true do |record|
+    record.post 
+  end
   class_define_cached :for_post, debug: true do |post_id|
     where(post_id: post_id).all
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: covercache
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: '0.2'
 platform: ruby
 authors:
 - Tõnis Simo
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-20 00:00:00.000000000 Z
+date: 2013-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -139,11 +139,10 @@ files:
 - covercache.gemspec
 - lib/covercache.rb
 - lib/covercache/version.rb
-- lib/where.rb
 - spec/covercache.sqlite3
 - spec/libs/covercache_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/tonissimo/covercache
+homepage: http://github.com/estum/covercache
 licenses:
 - MIT
 metadata: {}

data/lib/where.rb

@@ -1,69 +0,0 @@
-# A little Ruby module for finding the source location where class and methods are defined.
-# https://gist.github.com/wtaysom/1236979
-
-module Where
-  #== Example
-  # 
-  #   Where.is_class Post, of: 'app/models'
-  # 
-  class <<self
-    def is_class(klass, opts={})
-      methods = defined_methods(klass)
-      file_groups = methods.group_by{|sl| sl[0]}
-      file_counts = file_groups.map do |file, sls|
-        lines = sls.map{|sl| sl[1]}
-        count = lines.size
-        line = lines.min
-        {file: file, count: count, line: line}
-      end
-      file_counts.sort_by!{|fc| fc[:count]}
-    
-      if opts[:of].present?
-        path_expand = joins_path(opts[:of])
-        return File.expand_path("../../spec/spec_helper.rb", __FILE__) unless !!path_expand
-        pattern = Regexp.new "^#{path_expand}/.*"
-        matches = file_counts.select do |fc| 
-          !!fc[:file][pattern] 
-        end
-        return matches.first[:file] if matches.first.present?
-      end
-    
-      source_locations = file_counts.map{|fc| [fc[:file], fc[:line]]}
-      source_locations
-    end
-  
-  private
-    def joins_path(of)
-      Rails.root.join(of).to_s
-    rescue NameError
-      return false
-    end    
-    
-    def source_location(method)
-      method.source_location || (
-        method.to_s =~ /: (.*)>/
-        $1
-      )
-    end
-  
-    def defined_methods(klass)
-      methods = klass.methods(false).map{|m| klass.method(m)} +
-        klass.instance_methods(false).map{|m| klass.instance_method(m)}
-      methods.map!(&:source_location)
-      methods.compact!
-      methods
-    end
-  end
-end
-
-def where_is(klass, method = nil)
-  Where.edit(if method
-    begin
-      Where.is_instance_method(klass, method)
-    rescue NameError
-      Where.is_method(klass, method)
-    end
-  else
-    Where.is_class_primarily(klass)
-  end)
-end