cachely 0.0.5 → 0.0.6

data/README.md

@@ -43,8 +43,8 @@ In order to make this work, you must connect to a redis store using the method:
 
 		Cachely::Mechanics.connect(opts = {})
 
-Opts accepts keys :host, :port, :password, :driver. See redis-rb documentation for which drivers you want,
-including whether or not you wish it to be evented.
+Opts accepts keys :host, :port, :password, :driver, and :logging. See redis-rb documentation for which drivers you want,
+including whether or not you wish it to be evented. The :logging key is cachely only, it turns on performance logging.
 
 I'd recommend doing this in a Rails initializer, or if you're using sinatra or other rack app, in config.ru.
 
@@ -85,6 +85,22 @@ Want to wipe all keys?
 
 And done.
 
+## to_json, the all important method
+
+Cachely relies on the to_json method of objects extensively to work. ActiveRecord to_json methods are supported, as well as to_jsons
+on primitives and what not. If you deign to write your own to_json for your objects, including ARs, good for you, you should. But you should know
+that cachely works partially by instantiating a new instance of your class and calling to_json on it without setting any associations. So, if your to_json method is
+
+    def to_json
+      {
+        "stuff": self.stuff.id
+      }.to_json
+    end
+
+Where stuff is some kind of association, it will destroy cachely, because when cachely instantiates this new object with no fields just to get a look at it's field structure,
+it's going to call id on a nil class(stuff is unset.) So think about this when you write to_json methods. I can't protect you from your own stupidity, you really should
+be checking for nilness before you call id. I recommend the gem andand.
+
 ## Caveats
 
 CAVEAT 1: Do NOT use Cachely for functions that depend on time of day or random numbers, as these are inherently uncachable. 
@@ -105,7 +121,10 @@ has circular references to itself, don't use cachely then, either.
 One exception is ActiveRecord objects, which have already been fixed in this regard. There are three tests in conversion_tests.rb that fail still that deal with this
 caveat. I'll be fixing them in the future and we'll be one caveat shorter.
 
-  
+CAVEAT 3: Do not use Cachely if you are altering arguments that you pass into the method. Cachely isn't running the method if it has a response already stored, so obviously your argument will remain unchanged. I guess I could add support for this in the future, but this is a bit of a complex, nuanced addition and I'd rather not worry about it now. 
+
+CAVEAT 4: Do not use on functions that return ActiveRecord::Relation objects, or use them as arguments. They can't be instantiated normally and I haven't added support for them yet. I have added two tests for them, and they still fail. So if you can write a fix, and it passes these tests, go for it!
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/db/migrate/002_create_dummy_model_2.rb

@@ -0,0 +1,8 @@
+class CreateDummyModel2 < ActiveRecord::Migration
+	def change
+		create_table :dummy_model_twos do |t|
+      t.string :attr_1
+			t.timestamps
+		end
+	end
+end

data/lib/cachely.rb

@@ -13,9 +13,9 @@ module Cachely
     # @name [Symbol] fcn name
     # @return nil
     def singleton_method_added(name)
-      if(@cachely_fcns and @cachely_fcns.include?(name) and !self.respond_to?("#{name.to_s}_old".to_sym))
+      if(@cachely_fcns and @cachely_fcns.include?(name) and !self.respond_to?("#{name.to_s.gsub("?",'')}_old".to_sym))
         unless(@cachely_opts[name][:type] and @cachely_opts[name][:type] == "instance")
-          self.instance_eval("alias :#{"#{name.to_s}_old".to_sym} :#{name}")
+          self.instance_eval("alias :#{"#{name.to_s.gsub("?",'')}_old".to_sym} :#{name}")
           Cachely::Mechanics.setup_method(self,name, @cachely_opts[name][:time_to_expiry], true)
         end
       end
@@ -28,10 +28,10 @@ module Cachely
     # @name [Symbol] fcn name
     # @return nil
     def method_added(name)
-      if(@cachely_fcns and @cachely_fcns.include?(name) and !self.new.respond_to?("#{name.to_s}_old".to_sym))
+      if(@cachely_fcns and @cachely_fcns.include?(name) and !self.new.respond_to?("#{name.to_s.gsub("?",'')}_old".to_sym))
         # only do this if we either haven't explicitly labeled fcn type, or it's not class.
         unless(@cachely_opts[name][:type] and @cachely_opts[name][:type] == "class")
-          self.class_eval("alias :#{"#{name.to_s}_old".to_sym} :#{name}") #alias old function out
+          self.class_eval("alias :#{"#{name.to_s.gsub("?",'')}_old".to_sym} :#{name}") #alias old function out
           Cachely::Mechanics.setup_method(self,name, @cachely_opts[name][:time_to_expiry])
         end
       end

data/lib/cachely/mechanics.rb

@@ -7,11 +7,24 @@ module Cachely
     # @opt [Hash<Symbol>] 
     # @return [Boolean] success or not
     def self.connect(opts = {})
+      @opts ||= opts.symbolize_keys
       @redis ||= Redis.new(
-        :host => opts[:host], 
-        :port => opts[:port],
-        :password => opts[:password],
-        :driver => opts[:driver])
+        :host => @opts[:host], 
+        :port => @opts[:port],
+        :password => @opts[:password],
+        :driver => @opts[:driver])
+      @logging = @opts[:logging]
+      @logged_cached_calls_avg = 0
+      @logged_cached_calls_amt = 0
+      @logged_uncached_calls_avg = 0
+      @logged_uncached_calls_amt = 0
+    end
+
+    # Returns whether logging is present.
+    #
+    # @return [Boolean] Logging on or not
+    def self.logging
+      @logging    
     end
     
     # Flush the Redis store of all keys.
@@ -46,17 +59,32 @@ module Cachely
     # @return nil
     def self.setup_method(klazz, name, time_to_expire_in_s, is_class_method = false) 
       context = (is_class_method ? klazz : klazz.new)
-      args_str = context.method("#{name.to_s}_old".to_sym).parameters.map { |k| k.last}.join(',')
+      args_str = context.method("#{name.to_s.gsub("?",'')}_old".to_sym).parameters.map { |k| k.last}.join(',')
       args_to_use_in_def = args_str.empty? ? "" : "," + args_str
       time_exp_str = time_to_expire_in_s.nil? ? ",nil" : ",time_to_expire_in_s"
-      eval("klazz.define_#{is_class_method ? "singleton_" : ""}method(:#{name}) do #{args_str.empty? ? "" : "|#{args_str}|"}; " +
-        "result = Cachely::Mechanics.get(context,:#{name}#{time_exp_str}#{args_to_use_in_def});" +
+
+      to_def_header=nil
+
+      if is_class_method
+        to_def_header = "klazz.define_singleton_method(:#{name}) do"
+      else
+        to_def_header = "klazz.send(:define_method, :#{name}) do"
+      end
+
+      to_def = ("#{to_def_header} #{args_str.empty? ? "" : "|#{args_str}|"}; " +
+        "time_1 = Time.now;" + 
+        "result = Cachely::Mechanics.get(self,:#{name}#{time_exp_str}#{args_to_use_in_def});" +
+        "time_2 = Time.now;" +
+        "total_time = time_2-time_1; p 'Whole call took ' + total_time.to_s if Cachely::Mechanics.logging and result.is_a?(Array);" + 
         "return result.first if result.is_a?(Array);" + 
-        "result = context.send(:#{"#{name.to_s}_old"}#{args_to_use_in_def});" + 
-        "Cachely::Mechanics.store(context,:#{"#{name.to_s}"}, result#{time_exp_str}#{args_to_use_in_def});" +
+        "result = self.send(:#{"#{name.to_s.gsub("?",'')}_old"}#{args_to_use_in_def});" + 
+        "Cachely::Mechanics.store(self,:#{"#{name.to_s}"}, result#{time_exp_str}#{args_to_use_in_def});" +
+        "time_2 = Time.now;" + 
+        "total_time = time_2-time_1; p 'Whole call took ' + total_time.to_s if Cachely::Mechanics.logging;" + 
         "return result;" + 
         "end"
       )
+      eval(to_def)
     end
  
     # Force-expires a result to a method with this signature given by obj, method, args.
@@ -64,14 +92,23 @@ module Cachely
     # @obj [Object] the object you're calling method on
     # @method [String,Symbol] the method name
     # @args The arguments of the method
-    # @return The original response of the method back, whatever it may be.
+    # @return The original response of the method back, whatever it may be, or nil.
     def self.expire(obj, method, *args)
       key = redis_key(obj, method, *args)
       result = get(obj,method,1,*args)
       redis.del(key)
-      return result
+      result.nil? ? nil : result.first
     end   
 
+    # returns avg cached and uncached response times for methods.
+    #
+    #
+    # @return [String] Info on methods
+    def self.monitoring
+      return "Avg cached call is currently #{@logged_cached_calls_avg.to_f/@logged_cached_calls_amt.to_f}" +
+      "Avg uncached call is currently #{@logged_uncached_calls_avg.to_f/@logged_uncached_calls_amt.to_f}"
+    end
+
     # Gets a cached response to a method.
     #
     # @obj [Object] the object you're calling method on
@@ -81,9 +118,16 @@ module Cachely
     # @return The original response of the method back, whatever it may be.
     def self.get(obj, method, time_to_exp_in_s, *args)
       key = redis_key(obj, method, *args)
+      time_1 = Time.now
       result = redis.get(key)
+      time_2 = Time.now
+      p "GET for #{method} took #{time_2-time_1}" if @logging
       if result
         redis.expire(key, time_to_exp_in_s) if time_to_exp_in_s #reset the expiry
+
+        @logged_cached_calls_amt +=1
+        @logged_cached_calls_avg+=(time_2-time_1)
+
         #return an array, bc if the result stored was nil, it looks the same as if
         #we got no result back(which we would return nil) so we differentiate by putting
         #our return value always in an array. Easy to check.
@@ -100,9 +144,17 @@ module Cachely
     # @time_to_exp_in_s time in seconds before it expires
     # @args Arguments of the method
     # @return [String] Should be "Ok" or something similar.
-    def self.store(obj, method, result, time_to_exp_in_sec, *args) 
+    def self.store(obj, method, result, time_to_exp_in_sec, *args)
+      time_1 = Time.now 
       redis.set(redis_key(obj, method, *args), map_param_to_s(result))
-      redis.expire(redis_key(obj, method, *args), time_to_exp_in_sec) if time_to_exp_in_sec
+      to_ret = redis.expire(redis_key(obj, method, *args), time_to_exp_in_sec) if time_to_exp_in_sec
+      time_2 = Time.now
+      p "STORE for #{method} took #{time_2-time_1}" if @logging
+
+      @logged_uncached_calls_amt+=1
+      @logged_uncached_calls_avg+=(time_2-time_1)
+
+      return to_ret
     end
     
     # Converts method name and arguments into a coherent key. Creates a hash and to_jsons it
@@ -172,9 +224,14 @@ module Cachely
         return data
       when "NilClass"
         return nil
+      when "Time"
+        return DateTime.parse(data).to_time
+      when "DateTime"
+        return DateTime.parse(data)
+      when "Date"
+        return DateTime.parse(data).to_date
       else
         class_or_instance == "instance" ? obj = Object.const_get(type).new : obj = Object.const_get(type)
-
         JSON.parse(data).each do |key, value|
           obj.send(key+"=",value) if obj.respond_to?(key+"=")
         end
@@ -211,9 +268,17 @@ module Cachely
           translated = "instance|Fixnum|" + p.to_s
         elsif p.is_a?(Float)
           translated = "instance|Float|" + p.to_s
-        elsif p.is_a?(ActiveRecord::Base)
+        elsif p.is_a?(Time)
+          translated = "instance|Time|" + p.to_s
+        elsif p.is_a?(DateTime)
+          translated = "instance|DateTime|" + p.to_s
+        elsif p.is_a?(Date)
+          translated = "instance|Date|" + p.to_s
+        elsif p.is_a?(ActiveRecord::Base) and JSON.parse(p.to_json)[p.class.to_s.underscore]
           #don't want { "dummy_model" = > {:attributes => 1}}
           #want {:attributes => 1}
+          #this is default AR to_json
+          #we use normal else below if own to_json method defined.
           translated = "instance|#{p.class.to_s}|#{JSON.parse(p.to_json)[p.class.to_s.underscore].to_json}"
         else
           my_json = nil
@@ -222,7 +287,6 @@ module Cachely
           rescue ActiveSupport::JSON::Encoding::CircularReferenceError => e
             my_json = "{}"
           end
-
           translated = (p.to_s.match(/^#</) ? "instance|#{p.class}" : "class|#{p.to_s}") + "|"+ my_json
         end
 

data/lib/cachely/version.rb

@@ -1,3 +1,3 @@
 module Cachely
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/test/models/dummy_class.rb

@@ -6,7 +6,9 @@ class DummyClass
   cachely :cache_expiry_3, time_to_expiry: 3.seconds
   
   cachely :class_diff, time_to_expiry: 3.minutes
-  
+
+  cachely :question_mark?
+ 
   cachely :instance_only_cache, time_to_expiry: 3.minutes, type: "instance"
   cachely :class_only_cache, time_to_expiry: 3.minutes, type: "class"
   
@@ -97,12 +99,27 @@ class DummyClass
   cachely :class_to_json, time_to_expiry: 3.minutes
   cachely :class_to_json_one, time_to_expiry: 3.minutes
   cachely :class_to_json_two, time_to_expiry: 3.minutes
-  
+ 
+  cachely :get_ar_relations
+ 
   def to_json
     {
       "random_no" => self.random_no
     }.to_json
   end
+
+  def question_mark?
+    rand(500)
+  end
+
+  def self.get_ar_relations
+    DummyModel.create!(:attr_1 => 1)
+    DummyModel.where(:attr_1=>1)
+  end
+ 
+  def self.question_mark?
+    rand(500)
+  end
   
   def instance_only_cache
     rand(500)

data/test/models/dummy_class_2.rb

@@ -0,0 +1,8 @@
+class DummyClass2
+  
+  def to_json
+    {
+      :me => self.to_json
+    }.to_json
+  end
+end

data/test/models/dummy_model.rb

@@ -1,4 +1,7 @@
 class DummyModel < ActiveRecord::Base
+  include Cachely
+  cachely :use_attributes
+
   attr_accessible :attr_1, :attr_2, :dummy_model_id
   
   belongs_to :dummy_model, :foreign_key => :dummy_model_id
@@ -6,4 +9,8 @@ class DummyModel < ActiveRecord::Base
   def instance_fixnum
     rand(500)
   end
+  
+  def use_attributes
+    rand(500)/self.attr_1.to_i # if attr_1 is nil, this thing will throw a ZeroDivisionError. ;)
+  end
 end

data/test/models/dummy_model_two.rb

@@ -0,0 +1,20 @@
+class DummyModelTwo < ActiveRecord::Base
+  include Cachely
+  cachely :random
+  attr_accessible :attr_1
+
+  def random(arg)
+    rand(500)
+  end
+
+  def self.random(arg)
+    rand(500)
+  end
+
+  def to_json
+    {
+      :id => self.id,
+      :attr_1 => self.attr_1
+    }.to_json
+  end
+end

data/test/unit/base_test.rb

@@ -4,6 +4,13 @@ Bundler.require(:default, :test)
 require 'yaml'
 base_dir = File.expand_path(File.join(File.dirname(__FILE__), "../.."))
 require base_dir + "/lib/cachely.rb"
+
+database_config ||= YAML.load(File.open(File.dirname(__FILE__)+'/../../config/database.yml', 'r'))
+ActiveRecord::Base.configurations = database_config
+ActiveRecord::Base.establish_connection("test")
+conf =  YAML.load(File.read('./config/redis.yml'))
+Cachely::Mechanics.connect(conf["test"])
+
 require_relative '../models/dummy_model.rb'
 require_relative '../models/dummy_model_two.rb'
 require_relative '../models/dummy_class.rb'
@@ -11,11 +18,6 @@ require_relative '../models/dummy_class_2.rb'
 
 class BaseTest < ActiveSupport::TestCase
   def setup
-    database_config ||= YAML.load(File.open(File.dirname(__FILE__)+'/../../config/database.yml', 'r'))
-    ActiveRecord::Base.configurations = database_config
-    ActiveRecord::Base.establish_connection("test")
-    conf =  YAML.load(File.read('./config/redis.yml'))
-    Cachely::Mechanics.connect(conf["test"])
     Cachely::Mechanics.flush_all_keys
     DummyModel.destroy_all
   end

data/test/unit/cachely_test.rb

@@ -2,7 +2,26 @@ require_relative 'base_test.rb'
 #This test level is for functionality that occurs at the cachely.rb level. Things that interact
 #With the model.
 class CachelyTest < BaseTest
-  #later test: having defaults in parameters.
+
+  test "caches output of methods in orm object" do
+    d = DummyModelTwo.create!(:attr_1 => rand(500)) 
+    assert_equal(d.random(5), d.random(5))
+    assert_equal(DummyModelTwo.random(5), DummyModelTwo.random(5))
+  end
+
+  test "caches output when its an ar relations object" do
+    assert_nothing_raised(NameError) do
+      DummyClass.get_ar_relations
+      DummyClass.get_ar_relations
+    end
+  end
+
+  test "caches output of question mark methods" do
+    d = DummyClass.new
+    assert_equal(d.question_mark?, d.question_mark?)
+    assert_equal(DummyClass.question_mark?, DummyClass.question_mark?)
+  end
+
   test "caches output of instance and class methods primitive" do
     ["instance","class"].each do |preset|
       [

data/test/unit/conversions_test.rb

@@ -92,7 +92,18 @@ class ConversionsTest < BaseTest
     reformed = Cachely::Mechanics.map_s_to_param(str)
     assert_equal(reformed, DummyClass)
   end
-  
+ 
+  test "orm where conversion" do
+    d = DummyModel.create!(:attr_1 => 1, :attr_2 => 2)
+    str = Cachely::Mechanics.map_param_to_s(DummyModel.where(:attr_1 => 1))
+    assert_nothing_raised(NameError) do
+      respawned = Cachely::Mechanics.map_s_to_param(str)
+      first = respawned.first
+      assert_equal(d.id, first.id)
+      assert_equal(d.attr_1, first.attr_1)
+    end
+  end
+ 
   test "orm conversion" do
     d = DummyModel.create!(:attr_1 => rand(500), :attr_2 => rand(500))
     str = Cachely::Mechanics.map_param_to_s(d)
@@ -110,6 +121,9 @@ class ConversionsTest < BaseTest
     assert_equal("instance|String|1", Cachely::Mechanics.map_param_to_s("1"))   
     assert_equal("instance|NilClass|nil", Cachely::Mechanics.map_param_to_s(nil))    
     assert_equal("instance|Symbol|shit", Cachely::Mechanics.map_param_to_s(:shit))    
+    assert_equal("instance|Time|2013-03-04 16:16:14 -0600", Cachely::Mechanics.map_param_to_s(Time.new(2013,03,04,16,16,14)))    
+    assert_equal("instance|DateTime|2013-03-04T16:16:14-06:00", Cachely::Mechanics.map_param_to_s(DateTime.parse("2013-03-04T16:16:14-0600")))    
+    assert_equal("instance|Date|2013-03-04", Cachely::Mechanics.map_param_to_s(Date.new(2013,03,04)))    
     assert_equal(true, Cachely::Mechanics.map_s_to_param("instance|TrueClass|true"))
     assert_equal(false, Cachely::Mechanics.map_s_to_param("instance|FalseClass|false"))
     assert_equal(1, Cachely::Mechanics.map_s_to_param("instance|Fixnum|1"))
@@ -118,6 +132,9 @@ class ConversionsTest < BaseTest
     assert_equal("1|2", Cachely::Mechanics.map_s_to_param("instance|String|1|2"))
     assert_equal(:shit, Cachely::Mechanics.map_s_to_param("instance|Symbol|shit"))
     assert_equal(nil, Cachely::Mechanics.map_s_to_param("instance|NilClass|nil"))
-    
+    assert_equal(Time.new(2013,03,04,16,16,14), Cachely::Mechanics.map_s_to_param("instance|Time|2013-03-04 16:16:14 -0600"))    
+    assert_equal(DateTime.parse("2013-03-04T16:16:14-0600"), Cachely::Mechanics.map_s_to_param("instance|DateTime|2013-03-04T16:16:14-06:00"))    
+    assert_equal(Date.new(2013,03,04), Cachely::Mechanics.map_s_to_param("instance|Date|2013-03-04"))    
+   
   end
 end

data/test/unit/mechanics_test.rb

@@ -14,7 +14,22 @@ class MechanicsTest < BaseTest
     assert_equal(1, respawned.keys.size)
     assert_equal("baz", respawned[:bar])
   end
-  
+ 
+  test "get/store orm with predefined to_json" do
+    d = DummyModelTwo.create!(:attr_1 => 1)
+    Cachely::Mechanics.store(DummyClass,:foo, d,nil,[3,4])
+    respawned = Cachely::Mechanics.get(DummyClass,:foo, nil, [3,4]).first
+    assert_equal(d.id, respawned.id)
+    assert_equal(d.attr_1, respawned.attr_1)
+  end 
+
+  test "orm with method that depends on its attributes has its attributes set when called" do
+    d = DummyModel.create!(:attr_1 => 1, :attr_2 => 3)
+    assert_nothing_raised(ZeroDivisionError) do 
+      assert_equal(d.use_attributes, d.use_attributes)
+    end
+  end
+
   test "get/store orm" do
     d = DummyModel.create!(:attr_1 => 1, :attr_2 => 3)
     Cachely::Mechanics.store(DummyClass,:foo, d,nil,[3,4])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cachely
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-04 00:00:00.000000000 Z
+date: 2013-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &21983920 !ruby/object:Gem::Requirement
+  requirement: &19218640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 3.0.1
   type: :runtime
   prerelease: false
-  version_requirements: *21983920
+  version_requirements: *19218640
 - !ruby/object:Gem::Dependency
   name: hiredis
-  requirement: &21982820 !ruby/object:Gem::Requirement
+  requirement: &19233140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 0.4.5
   type: :runtime
   prerelease: false
-  version_requirements: *21982820
+  version_requirements: *19233140
 - !ruby/object:Gem::Dependency
   name: em-synchrony
-  requirement: &21997700 !ruby/object:Gem::Requirement
+  requirement: &19232120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *21997700
+  version_requirements: *19232120
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &21996800 !ruby/object:Gem::Requirement
+  requirement: &19231420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *21996800
+  version_requirements: *19231420
 description: Transparently cache the results of methods using redis.
 email:
 - jordanmprince@gmail.com
@@ -71,11 +71,14 @@ files:
 - config/database.yml
 - config/redis.yml
 - db/migrate/001_create_dummy_model.rb
+- db/migrate/002_create_dummy_model_2.rb
 - lib/cachely.rb
 - lib/cachely/mechanics.rb
 - lib/cachely/version.rb
 - test/models/dummy_class.rb
+- test/models/dummy_class_2.rb
 - test/models/dummy_model.rb
+- test/models/dummy_model_two.rb
 - test/unit/base_test.rb
 - test/unit/cachely_test.rb
 - test/unit/conversions_test.rb
@@ -106,7 +109,9 @@ specification_version: 3
 summary: Transparently cache the results of methods using redis.
 test_files:
 - test/models/dummy_class.rb
+- test/models/dummy_class_2.rb
 - test/models/dummy_model.rb
+- test/models/dummy_model_two.rb
 - test/unit/base_test.rb
 - test/unit/cachely_test.rb
 - test/unit/conversions_test.rb