cachely 0.0.1 → 0.0.2

data/Gemfile

@@ -5,7 +5,7 @@ gemspec
 
 group :test do
   gem 'pg'
-  gem 'activerecord', :require => "active_record"
+  gem 'activerecord', "~> 3.2.12", :require => "active_record"
   gem 'activesupport'
   gem 'test-unit'
 	gem 'cucumber'

data/README.md

@@ -1,7 +1,81 @@
 # Cachely
 
-TODO: Write a gem description
+Transparent method level caching using redis. Event machine optional.
 
+## Usage
+
+		class A 
+			include Cachely
+			
+			cachely :foo
+			
+			def foo
+				sleep(10)
+				return rand(500) #Holy moly, what a HUGE, LONG CALL! Returns a different value every time.
+			end
+		
+		end
+		
+		a = A.new
+		
+		start = Time.now
+		result_1 = a.foo
+		after = Time.now
+		time_1 = after-start
+		
+		start = Time.now
+		result_2 = a.foo #Now it uses the redis cache.
+		after = Time.now
+		time_2 = after-start
+		
+		p "First call took #{time_1}"
+		
+		p "Second call took #{time_2}"
+		
+		p "Results equal? #{result_2 == result_1}. Of course! It cached the output."
+		
+		=> "First call took 10.031092"
+		=> "Second call took 0.032047"
+		=> "Results equal? true. Of course! It cached the output."
+		
+
+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.
+
+I'd recommend doing this in a Rails initializer, or if you're using sinatra or other rack app, in config.ru.
+
+If you want cached results to expire, instead of
+
+		cachely :foo
+		
+use
+
+		cachely :foo, time_to_expiry: 3.minutes
+		
+If you have a class method of the same name as an instance variable,
+
+		cachely :foo
+		
+will still work, it will cache both the instance method foo and the class method foo, but in different
+keyed locations, of course. To specify instance or class method, do
+
+		cachely :foo, :type => "instance"
+		cachely :foo, :type => "class"
+		
+Cachely is able to figure out whether or not to use the cache by looking at the arguments you pass in.
+Generally, if your arguments are the same, and the object you're calling the method on is the same(Cachely uses 
+the to_json method on the object you call the method on to determine this), then it assumes the result
+will be the same and uses the cached result. 
+
+CAVEAT: Do NOT use Cachely for functions that depend on time of day or random numbers, as these are inherently uncachable. 
+If you check the tests out, you'll see random number functions are used exhaustively to test the caching ability of cachely,
+because we know the function wasn't called if the second call yields the same number.
+
+If you do not understand the implications of the caveat, do not use cachely. You're not ready yet. 
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -16,10 +90,6 @@ Or install it yourself as:
 
     $ gem install cachely
 
-## Usage
-
-TODO: Write usage instructions here
-
 ## Contributing
 
 1. Fork it

data/cachely.gemspec

@@ -4,8 +4,8 @@ require File.expand_path('../lib/cachely/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Jordan Prince"]
   gem.email         = ["jordanmprince@gmail.com"]
-  gem.description   = %q{Coming soon.}
-  gem.summary       = %q{Use em-redis to transparently cache results from your class methods. Eventmachine compatible out of the box!}
+  gem.description   = %q{Transparently cache the results of methods using redis.}
+  gem.summary       = %q{Transparently cache the results of methods using redis.}
   gem.homepage      = ""
 
   gem.files         = `git ls-files`.split($\)
@@ -14,5 +14,8 @@ Gem::Specification.new do |gem|
   gem.name          = "cachely"
   gem.require_paths = ["lib"]
   gem.version       = Cachely::VERSION
-  gem.add_dependency "em-hiredis"
+  gem.add_dependency "redis", '~> 3.0.1'
+  gem.add_dependency "hiredis", '~> 0.4.5'
+  gem.add_dependency "em-synchrony"
+  gem.add_dependency "json"
 end

data/config/database.yml

@@ -2,5 +2,6 @@ test:
   adapter: postgresql
   database: cachely_test
   host: localhost
+  password: pi
   pool: 60
 

data/config/redis.yml

@@ -0,0 +1,4 @@
+test:
+  host: 127.0.0.1
+  port: 6379
+  

data/lib/cachely.rb

@@ -1,25 +1,55 @@
 require_relative "cachely/version"
-
+require_relative 'cachely/mechanics'
+require 'redis'
+require 'hiredis'
+require 'em-synchrony'
+require 'json'
 module Cachely
   module ClassMethods
-
+    
+    # Called after class methods loaded, this aliases out the old method, puts in place the listener version
+    # That only calls it if the cache can't fill in.
+    #
+    # @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))
+        unless(@cachely_opts[name][:type] and @cachely_opts[name][:type] == "instance")
+          self.instance_eval("alias :#{"#{name.to_s}_old".to_sym} :#{name}")
+          Cachely::Mechanics.setup_method(self,name, @cachely_opts[name][:time_to_expiry], true)
+        end
+      end
+      super
+    end
+    
+    # Called after methods loaded, this aliases out the old method, puts in place the listener version
+    # That only calls it if the cache can't fill in.
+    #
+    # @name [Symbol] fcn name
+    # @return nil
     def method_added(name)
-      if(@cachely_fcns.include?(name) and !@cachely_fcns_added.include?(name))
-        @cachely_fcns_added << name #this method'll get called when we do define method below
-        #this halts that.
-
-        self.class_eval("alias #{"#{name.to_s}_old".to_sym} #{name}") #alias old function out
-
-        self.define_method name do |*args| #define new one
-          send "#{name.to_s}_old".to_sym, *args
+      if(@cachely_fcns and @cachely_fcns.include?(name) and !self.new.respond_to?("#{name.to_s}_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
+          Cachely::Mechanics.setup_method(self,name, @cachely_opts[name][:time_to_expiry])
         end
       end
+      super
     end
 
+    # Catches the method name, stores for after because methods aren't loaded when this is called.
+    #
+    # @fcn [Symbol] fcn name
+    # @opts [Hash] options
+    # @extension No idea
+    # @return [Array] Array of current fcns to be added.
     def cachely(fcn, opts = {}, &extension)
-      @cachely_fcns_added ||= []
-      @cachely_fcns = []
+      @cachely_fcns ||= []
+      @cachely_opts ||= {}
+      
       @cachely_fcns << fcn
+      @cachely_opts[fcn] = opts
     end
   end
 

data/lib/cachely/mechanics.rb

@@ -0,0 +1,218 @@
+#place all mechanics methods here bc we do not want to introduce random method namespaces to objects
+module Cachely
+  module Mechanics
+    
+    # Connects to the Redis store you want to use for a cache.
+    #
+    # @opt [Hash<Symbol>] 
+    # @return [Boolean] success or not
+    def self.connect(opts = {})
+      @redis ||= Redis.new(
+        :host => opts[:host], 
+        :port => opts[:port],
+        :password => opts[:password],
+        :driver => opts[:driver])
+    end
+    
+    # Flush the Redis store of all keys.
+    #
+    # @return [String] success or not, normally "OK"
+    def self.flush_all_keys
+      redis.flushdb
+    end
+
+    # Grab current redis instance. Has ability to reconnect for you if it fails.
+    #
+    # @return [Redis], instance of Redis client.
+    def self.redis
+      @tries = 0 unless @tries
+      begin
+        @redis.get("test") #tests to see if we're still authed.
+        @tries = 0 #means we can reset our trymeter.
+      rescue Exception => e
+        @tries+=1 if @tries
+        if @tries<5
+          connect
+        end
+      end
+      return @redis  
+    end
+    
+    # Defines the method using my hacky eval script. So far, this is the only way I've found that
+    # allows me to define variable argument length definitions. If you have a better idea, please
+    # refactor it!
+    #
+    # @name [Symbol] fcn name
+    # @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_to_use_in_def = args_str.empty? ? "" : "," + args_str
+      eval("klazz.define_#{is_class_method ? "singleton_" : ""}method(:#{name}) do #{args_str.empty? ? "" : "|#{args_str}|"}; " +
+        "result = Cachely::Mechanics.get(context,:#{name}#{args_to_use_in_def});" +
+        "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_to_expire_in_s.nil? ? ",nil": ",#{time_to_expire_in_s}"}#{args_to_use_in_def});" +
+        "return result;" + 
+        "end"
+      )
+    end
+    
+    # Gets a cached response to a method.
+    #
+    # @method [String,Symbol] the method name
+    # @args The arguments of the method
+    # @return The original response of the method back, whatever it may be.
+    def self.get(obj, method, *args)
+      result = redis.get(redis_key(obj, method, *args))
+      #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.
+      result.nil? ? nil : [map_s_to_param(result)]
+    end
+    
+    # Stores the result in it's proper cached location on redis by getting the redis key and parsing
+    # The result into a storable string, mostly made up of recursive json.
+    #
+    # @method [Symbol] Method name
+    # @result Anything, really.
+    # @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) 
+      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
+    end
+    
+    # Converts method name and arguments into a coherent key. Creates a hash and to_jsons it
+    # And that becomes the redis key. Spiffy, I know.
+    #
+    # @method [String,Symbol] The method name
+    # @return [String] The proper redis key to be used in storage.
+    def self.redis_key(obj, method, *args)
+      map_param_to_s({
+        :obj => obj.to_s.match(/^#</) ? "instance:#{obj.class}" : obj.to_s,
+        :attributes => obj.to_json, #Best way to identify objects is to just to_json them.
+        :method => method,
+        :args => args
+      })
+    end
+    
+    # Turns any string into a parameter. Current supported types are primitives, orm models
+    # That respond to id and have an updated_at field, and objects that have a to_json method.
+    #
+    # @s The string to convert
+    # @return [Object] The respawned object
+    def self.map_s_to_param(s)
+      begin
+        respawned_hash = JSON.parse(s)
+        
+        if respawned_hash.is_a?(Array)
+          respawned_hash.map! do |piece|
+            map_s_to_param(piece)
+          end
+        elsif respawned_hash.is_a?(Hash)
+          respawned_hash = respawned_hash.inject(Hash.new) do |new_hash, entry|
+            new_hash[map_s_to_param(entry[0])] = map_s_to_param(entry[1])
+            new_hash
+          end
+        end
+        
+        return respawned_hash
+      rescue JSON::ParserError => e
+        #The only times the string isn't json is if it is a primitive, or an ORM object
+        #This exception happens then, we catch it, and check orm signature.
+        
+        return map_s_to_obj(s)
+      end
+      
+    end
+    
+    # Turns String into an actual object
+    #
+    # @s The string to convert
+    # @return The respawned object
+    def self.map_s_to_obj(s)
+      type = s.split(":").first
+      data = s.gsub(/^#{type}:/,'')
+      
+      case type
+      when "TrueClass"
+        return true
+      when "FalseClass"
+        return false
+      when "Symbol"
+        return data.to_sym
+      when "Fixnum"
+        return data.to_i
+      when "Float"
+        return data.to_f
+      when "String"
+        return data
+      when "NilClass"
+        return nil
+      else
+        obj = Object.const_get(type).new
+        JSON.parse(data).each do |key, value|
+          obj.send(key+"=",value)
+        end
+        return obj
+      end
+    end 
+
+    # Turns any parameter into a string. Current supported types are primitives, orm models
+    # That respond to id and have an updated_at field, and objects that have a to_json method.
+    #
+    # @p The object to convert
+    # @return [String] The redis coded string.
+    def self.map_param_to_s(p)
+      if(p.is_a?(Hash)) 
+        return map_hash_to_s(p)
+      elsif(p.is_a?(Array))
+        return map_array_to_s(p)
+      elsif(p.respond_to?("to_json"))
+        #below do extra search if string bc string puts annoying quotes in json like "\"1\""
+        #breaks the parser on the return translation.
+        translated = nil
+        if p.is_a?(String)
+          translated = p
+        elsif p.is_a?(Symbol)
+          translated = p.to_s
+        elsif p.nil?
+          translated = "nil"
+        elsif p.is_a?(ActiveRecord::Base)
+          #don't want { "dummy_model" = > {:attributes => 1}}
+          #want {:attributes => 1}
+          translated = JSON.parse(p.to_json)[p.class.to_s.underscore].to_json
+        else
+          translated = p.to_json
+        end
+        
+        return p.class.to_s + ":" + translated
+      end
+    end
+    
+    # Maps hash to s, basically does recursive call to map_param_to_s to get everythign inside
+    # and then to_jsons.
+    #
+    # @p [Hash] Incoming hash
+    # @return [String] Outgoing redis string
+    def self.map_hash_to_s(p)
+      p.inject(Hash.new) do |hash, entry|
+        hash[map_param_to_s(entry[0])] = map_param_to_s(entry[1])
+        hash
+      end.to_json
+    end
+    
+    # Map array to s, calls recursively on elements then to json
+    #
+    # @p [Array] Incoming array
+    # @return [String] Outgoing redis string
+    def self.map_array_to_s(p)  
+      p.map do |part|
+        map_param_to_s(part)
+      end.to_json
+    end
+    
+
+  end
+end

data/lib/cachely/version.rb

@@ -1,3 +1,3 @@
 module Cachely
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/models/dummy_class.rb

@@ -1,92 +1,455 @@
 class DummyClass
   include Cachely
-  cachely :test_function_num, time: 3.minutes
-  #cachely :test_function_array, time: 2.minutes
-  #cachely :test_function_hash, time: 2.minutes
-  #cachely :test_function_string, time: 3.minutes
-  #cachely :test_function_obj, time: 4.minutes
-  #cachely :test_function_array_obj, time: 5.minutes
-  #cachely :test_function_hash_obj, time: 6.minutes
-
-  def test_function_num
+  attr_accessor :random_no
+  
+  cachely :cache_expiry, time_to_expiry: 1.seconds
+  
+  cachely :class_diff, time_to_expiry: 3.minutes
+  
+  cachely :instance_only_cache, time_to_expiry: 3.minutes, type: "instance"
+  cachely :class_only_cache, time_to_expiry: 3.minutes, type: "class"
+  
+  cachely :instance_fixnum, time_to_expiry: 3.minutes
+  cachely :instance_fixnum_one, time_to_expiry: 3.minutes
+  cachely :instance_fixnum_two, time_to_expiry: 3.minutes
+  
+  cachely :instance_float, time_to_expiry: 3.minutes
+  cachely :instance_float_one, time_to_expiry: 3.minutes
+  cachely :instance_float_two, time_to_expiry: 3.minutes
+  
+  cachely :instance_string, time_to_expiry: 3.minutes
+  cachely :instance_string_one, time_to_expiry: 3.minutes
+  cachely :instance_string_two, time_to_expiry: 3.minutes
+  
+  cachely :instance_symbol, time_to_expiry: 3.minutes
+  cachely :instance_symbol_one, time_to_expiry: 3.minutes
+  cachely :instance_symbol_two, time_to_expiry: 3.minutes
+  
+  cachely :instance_nilclass, time_to_expiry: 3.minutes
+  cachely :instance_nilclass_one, time_to_expiry: 3.minutes
+  cachely :instance_nilclass_two, time_to_expiry: 3.minutes
+  
+  cachely :instance_falseclass, time_to_expiry: 3.minutes
+  cachely :instance_falseclass_one, time_to_expiry: 3.minutes
+  cachely :instance_falseclass_two, time_to_expiry: 3.minutes
+  
+  cachely :instance_trueclass, time_to_expiry: 3.minutes
+  cachely :instance_trueclass_one, time_to_expiry: 3.minutes
+  cachely :instance_trueclass_two, time_to_expiry: 3.minutes
+  
+  cachely :instance_orm, time_to_expiry: 3.minutes
+  cachely :instance_orm_one, time_to_expiry: 3.minutes
+  cachely :instance_orm_two, time_to_expiry: 3.minutes
+  
+  cachely :instance_array, time_to_expiry: 3.minutes
+  cachely :instance_array_one, time_to_expiry: 3.minutes
+  cachely :instance_array_two, time_to_expiry: 3.minutes
+  
+  cachely :instance_hash, time_to_expiry: 3.minutes
+  cachely :instance_hash_one, time_to_expiry: 3.minutes
+  cachely :instance_hash_two, time_to_expiry: 3.minutes
+  
+  cachely :instance_to_json, time_to_expiry: 3.minutes
+  cachely :instance_to_json_one, time_to_expiry: 3.minutes
+  cachely :instance_to_json_two, time_to_expiry: 3.minutes
+  
+  cachely :class_fixnum, time_to_expiry: 3.minutes
+  cachely :class_fixnum_one, time_to_expiry: 3.minutes
+  cachely :class_fixnum_two, time_to_expiry: 3.minutes
+  
+  cachely :class_float, time_to_expiry: 3.minutes
+  cachely :class_float_one, time_to_expiry: 3.minutes
+  cachely :class_float_two, time_to_expiry: 3.minutes
+  
+  cachely :class_string, time_to_expiry: 3.minutes
+  cachely :class_string_one, time_to_expiry: 3.minutes
+  cachely :class_string_two, time_to_expiry: 3.minutes
+  
+  cachely :class_symbol, time_to_expiry: 3.minutes
+  cachely :class_symbol_one, time_to_expiry: 3.minutes
+  cachely :class_symbol_two, time_to_expiry: 3.minutes
+  
+  cachely :class_nilclass, time_to_expiry: 3.minutes
+  cachely :class_nilclass_one, time_to_expiry: 3.minutes
+  cachely :class_nilclass_two, time_to_expiry: 3.minutes
+  
+  cachely :class_falseclass, time_to_expiry: 3.minutes
+  cachely :class_falseclass_one, time_to_expiry: 3.minutes
+  cachely :class_falseclass_two, time_to_expiry: 3.minutes
+  
+  cachely :class_trueclass, time_to_expiry: 3.minutes
+  cachely :class_trueclass_one, time_to_expiry: 3.minutes
+  cachely :class_trueclass_two, time_to_expiry: 3.minutes
+  
+  cachely :class_orm, time_to_expiry: 3.minutes
+  cachely :class_orm_one, time_to_expiry: 3.minutes
+  cachely :class_orm_two, time_to_expiry: 3.minutes
+  
+  cachely :class_array, time_to_expiry: 3.minutes
+  cachely :class_array_one, time_to_expiry: 3.minutes
+  cachely :class_array_two, time_to_expiry: 3.minutes
+  
+  cachely :class_hash, time_to_expiry: 3.minutes
+  cachely :class_hash_one, time_to_expiry: 3.minutes
+  cachely :class_hash_two, time_to_expiry: 3.minutes
+  
+  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
+  
+  def to_json
+    {
+      "random_no" => self.random_no
+    }.to_json
+  end
+  
+  def instance_only_cache
     rand(500)
   end
-
-  def self.class_test_function_num
+  
+  def self.instance_only_cache
     rand(500)
   end
-
-  def self.class_test_function_not_cached
+  
+  def class_only_cache
     rand(500)
   end
-
-  def test_function_not_cached
+  
+  def self.class_only_cache
     rand(500)
   end
-
-  def test_function_array
-    [1,2,3,4,5,6, rand(500)]
+  
+  def self.class_diff
+    rand(500)
   end
-
-  def self.class_test_function_array
-    [1,2,3,4,5,6, rand(500)]
+  
+  def class_diff
+    rand(500)
   end
-
-  def test_function_hash
-    {
-      :foo => "bar#{rand(500)}",
-      :baz => "boof"
-    }
+  
+  def cache_expiry
+    rand(500)
   end
- 
-  def self.class_test_function_hash
-    {
-      :foo => "bar#{rand(500)}",
-      :baz => "boof"
-    }
-  end 
-
-  def test_function_string
-    rand(500).to_s
-  end
- 
-  def self.class_test_function_string
-    rand(500).to_s
-  end
-  
-  def test_function_obj
-    DummyModel.create(
-      :attr1 => rand(500),
-      :attr2 => rand(500)
-    )    
-  end
-
-  def self.class_test_function_obj
-    DummyModel.create(
-      :attr1 => rand(500),
-      :attr2 => rand(500)
-    )    
-  end
-
-  def test_function_array_obj
-    [test_function_obj, test_function_obj]
-  end
-
-  def self.class_test_function_array_obj
-    [test_function_obj, test_function_obj]
-  end
-
-  def test_function_hash_obj
-    {
-      :foo => test_function_obj,
-      :bar => test_function_obj
-    }
+  
+  def instance_fixnum
+    rand(500)
   end
-
-  def self.class_test_function_hash_obj
-    {
-      :foo => test_function_obj,
-      :bar => test_function_obj
-    }
+  
+  def instance_fixnum_one(a)
+    rand(500)
+  end
+  
+  def instance_fixnum_two(a,b)
+    rand(500)
+  end
+  
+  def instance_float
+    rand(500).to_f + 0.5
+  end
+  
+  def instance_float_one(a)
+    rand(500).to_f + 0.5
+  end
+  
+  def instance_float_two(a,b)
+    rand(500).to_f + 0.5
+  end
+  
+  def instance_string
+    rand(500).to_s + "cheese"
+  end
+  
+  def instance_string_one(a)
+    rand(500).to_s + "cheese"
+  end
+  
+  def instance_string_two(a,b)
+    rand(500).to_s + "cheese"
+  end
+  
+  def instance_symbol
+    "cheese#{rand(500)}".to_sym
+  end
+  
+  def instance_symbol_one(a)
+    "cheese#{rand(500)}".to_sym
+  end
+  
+  def instance_symbol_two(a,b)
+    "cheese#{rand(500)}".to_sym
+  end
+  
+  def instance_nilclass #force it to be nil ONLY once to check caching ability.
+    @@set_nilclass_0 ||= false
+    p "i am false now " if @@set_nilclass_0
+    return "1" if @@set_nilclass_0
+    @@set_nilclass_0 = true
+    nil
+  end
+  
+  def instance_nilclass_one(a)
+    @@set_nilclass_1 ||= false
+    p "i am false now " if @@set_nilclass_1
+    return "1" if @@set_nilclass_1
+    @@set_nilclass_1 = true
+    nil  end
+  
+  def instance_nilclass_two(a,b)
+    @@set_nilclass_2 ||= false
+    p "i am false now " if @@set_nilclass_2
+    return "1" if @@set_nilclass_2
+    @@set_nilclass_2 = true
+    nil  
+  end
+  
+  def instance_falseclass
+    @@set_falseclass_0 ||= false
+    return true if @@set_falseclass_0
+    @@set_falseclass_0 = true
+    false
+  end
+  
+  def instance_falseclass_one(a)
+    @@set_falseclass_1 ||= false
+    return true if @@set_falseclass_1
+    @@set_falseclass_1 = true
+    false  
+  end
+  
+  def instance_falseclass_two(a,b)
+    @@set_falseclass_2 ||= false
+    return true if @@set_falseclass_2
+    @@set_falseclass_2 = true
+    false  
+  end
+  
+  def instance_trueclass
+    @@set_trueclass_0 ||= false
+    return false if @@set_trueclass_0
+    @@set_trueclass_0 = true
+    true
+  end
+  
+  def instance_trueclass_one(a)
+    @@set_trueclass_1 ||= false
+    return false if @@set_trueclass_1
+    @@set_trueclass_1 = true
+    true  
+  end
+  
+  def instance_trueclass_two(a,b)
+    @@set_trueclass_2 ||= false
+    return false if @@set_trueclass_2
+    @@set_trueclass_2 = true
+    true  
+  end
+  
+  def instance_orm
+    DummyModel.create!(:attr_1 => rand(500), :attr_2 => rand(500))
+  end
+  
+  def instance_orm_one(a)
+    DummyModel.create!(:attr_1 => rand(500), :attr_2 => rand(500))
+  end
+  
+  def instance_orm_two(a,b)
+    DummyModel.create!(:attr_1 => rand(500), :attr_2 => rand(500))
+  end
+  
+  def instance_to_json
+    DummyClass.new
+  end
+  
+  def instance_to_json_one(a)
+    DummyClass.new
+  end
+  
+  def instance_to_json_two(a,b)
+    DummyClass.new
+  end
+  
+  def instance_hash
+    {:foo => rand(500)}
+  end
+  
+  def instance_hash_one(a)
+    {:foo => rand(500)}
+  end
+  
+  def instance_hash_two(a,b)
+    {:foo => rand(500)}
+  end
+  
+  def instance_array
+    [rand(500)]
+  end
+  
+  def instance_array_one(a)
+    [rand(500)]
+  end
+  
+  def instance_array_two(a,b)
+    [rand(500)]
+  end
+  
+  def self.class_fixnum
+    rand(500)
+  end
+  
+  def self.class_fixnum_one(a)
+    rand(500)
+  end
+  
+  def self.class_fixnum_two(a,b)
+    rand(500)
+  end
+  
+  def self.class_float
+    rand(500).to_f + 0.5
+  end
+  
+  def self.class_float_one(a)
+    rand(500).to_f + 0.5
+  end
+  
+  def self.class_float_two(a,b)
+    rand(500).to_f + 0.5
+  end
+  
+  def self.class_string
+    rand(500).to_s + "cheese"
+  end
+  
+  def self.class_string_one(a)
+    rand(500).to_s + "cheese"
+  end
+  
+  def self.class_string_two(a,b)
+    rand(500).to_s + "cheese"
+  end
+  
+  def self.class_symbol
+    "cheese#{rand(500)}".to_sym
+  end
+  
+  def self.class_symbol_one(a)
+    "cheese#{rand(500)}".to_sym
+  end
+  
+  def self.class_symbol_two(a,b)
+    "cheese#{rand(500)}".to_sym
+  end
+  
+  def self.class_nilclass #force it to be nil ONLY once to check caching ability.
+    @@set_nilclass_0 ||= false
+    p "i am false now " if @@set_nilclass_0
+    return "1" if @@set_nilclass_0
+    @@set_nilclass_0 = true
+    nil
+  end
+  
+  def self.class_nilclass_one(a)
+    @@set_nilclass_1 ||= false
+    p "i am false now " if @@set_nilclass_1
+    return "1" if @@set_nilclass_1
+    @@set_nilclass_1 = true
+    nil  end
+  
+  def self.class_nilclass_two(a,b)  
+    @@set_nilclass_2 ||= false
+    p "i am false now " if @@set_nilclass_2
+    return "1" if @@set_nilclass_2
+    @@set_nilclass_2 = true
+    nil  
+  end
+  
+  def self.class_falseclass
+    @@set_falseclass_0 ||= false
+    return true if @@set_falseclass_0
+    @@set_falseclass_0 = true
+    false
+  end
+  
+  def self.class_falseclass_one(a)
+    @@set_falseclass_1 ||= false
+    return true if @@set_falseclass_1
+    @@set_falseclass_1 = true
+    false  
+  end
+  
+  def self.class_falseclass_two(a,b)
+    @@set_falseclass_2 ||= false
+    return true if @@set_falseclass_2
+    @@set_falseclass_2 = true
+    false  
+  end
+  
+  def self.class_trueclass
+    @@set_trueclass_0 ||= false
+    return false if @@set_trueclass_0
+    @@set_trueclass_0 = true
+    true
+  end
+  
+  def self.class_trueclass_one(a)
+    @@set_trueclass_1 ||= false
+    return false if @@set_trueclass_1
+    @@set_trueclass_1 = true
+    true  
+  end
+  
+  def self.class_trueclass_two(a,b)
+    @@set_trueclass_2 ||= false
+    return false if @@set_trueclass_2
+    @@set_trueclass_2 = true
+    true  
+  end
+  
+  def self.class_orm
+    DummyModel.create!(:attr_1 => rand(500), :attr_2 => rand(500))
+  end
+  
+  def self.class_orm_one(a)
+    DummyModel.create!(:attr_1 => rand(500), :attr_2 => rand(500))
+  end
+  
+  def self.class_orm_two(a,b)
+    DummyModel.create!(:attr_1 => rand(500), :attr_2 => rand(500))
+  end
+  
+  def self.class_to_json
+    DummyClass.new
+  end
+  
+  def self.class_to_json_one(a)
+    DummyClass.new
+  end
+  
+  def self.class_to_json_two(a,b)
+    DummyClass.new
+  end
+  
+  def self.class_hash
+    {:foo => rand(500)}
+  end
+  
+  def self.class_hash_one(a)
+    {:foo => rand(500)}
+  end
+  
+  def self.class_hash_two(a,b)
+    {:foo => rand(500)}
+  end
+  
+  def self.class_array
+    [rand(500)]
+  end
+  
+  def self.class_array_one(a)
+    [rand(500)]
+  end
+  
+  def self.class_array_two(a,b)
+    [rand(500)]
   end
 end