ca_ching 0.1.0

data/lib/ca_ching/read_through.rb

@@ -0,0 +1,64 @@
+require 'ca_ching/query/abstract'
+require 'ca_ching/query/calculation'
+require 'ca_ching/query/select'
+
+module CaChing
+  module ReadThrough
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      # All queries, be they find(id), dynamic finders (find_by_foo, find_all_by_foo, etc.),
+      # where(:foo => :bar), order('foo DESC'), etc. go through to_a before being returned.
+      # Hook into that point to check the cache. 
+      def to_a_with_cache
+        @_query = CaChing::Query::Select.new(self)
+        
+        return to_a_without_cache if CaChing.cache.nil? || CaChing.disabled? || !cacheable?
+        
+        result = CaChing.cache.find(@_query)
+        @from_cache = true
+        
+        if result.nil?
+          result = to_a_without_cache
+          CaChing.cache.insert(result, :for => @_query)
+          @from_cache = false
+        end
+        
+        result.from_cache = self.from_cache?
+        result.each { |item| item.from_cache = self.from_cache? }
+        
+        return result
+      end 
+      
+      def from_cache?
+        @from_cache ||= false
+      end
+      
+      def cacheable?
+        unsupported_methods = [:from_value,
+                               :group_values,
+                               :having_values,
+                               :includes_values,
+                               :joined_includes_values,
+                               :joins_values,
+                               :lock_value,
+                               :select_values]
+        !where_values.empty? && find_on_indexed_fields? && unsupported_methods.inject(true) { |flag, method| self.send(method).send(method.to_s =~ /values/ ? :empty? : :nil?) && flag }
+      end
+      
+      private
+      def find_on_indexed_fields?
+        (@_query.where.keys - indexed_fields.keys).empty?
+      end
+    end
+    
+    included do |base|
+      base.class_eval do
+        alias_method_chain :to_a, :cache
+      end
+    end
+  end
+end

data/lib/ca_ching/version.rb

@@ -0,0 +1,13 @@
+module CaChing
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    PRE   = nil
+
+
+    def self.to_s
+      [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+    end
+  end
+end

data/lib/ca_ching/write_through.rb

@@ -0,0 +1,23 @@
+module CaChing
+  module WriteThrough
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      def save_with_cache(*)
+        return save_without_cache if CaChing.cache.nil? || CaChing.disabled?
+        
+        CaChing.cache.update(self)
+        save_without_cache
+      end
+    end
+    
+    included do |base|
+      base.class_eval do
+        alias_method_chain :save, :cache
+      end
+    end
+  end
+end

data/lib/ca_ching.rb

@@ -0,0 +1,21 @@
+require "ca_ching/version"
+
+require 'redis'
+require 'redis/connection/hiredis'
+
+require 'ca_ching/configuration'
+
+require 'ca_ching/read_through'
+require 'ca_ching/write_through'
+require 'ca_ching/index'
+
+require 'ca_ching/errors'
+
+require 'ca_ching/adapters/redis'
+require 'ca_ching/adapters/active_record'
+
+require 'ca_ching/core_ext/array'
+
+module CaChing
+  extend Configuration
+end

data/spec/blueprints/articles.rb

@@ -0,0 +1,5 @@
+Article.blueprint do
+  person
+  title
+  body
+end

data/spec/blueprints/comments.rb

@@ -0,0 +1,5 @@
+Comment.blueprint do
+  article
+  person
+  body
+end

data/spec/blueprints/people.rb

@@ -0,0 +1,5 @@
+Person.blueprint do
+  name
+  salary
+  age { (rand(70) + 10).to_i }
+end

data/spec/blueprints/tags.rb

@@ -0,0 +1,3 @@
+Tag.blueprint do
+  name    { Sham.tag_name }
+end

data/spec/ca_ching/adapters/active_record_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe ActiveRecord::Base do
+  
+end

data/spec/ca_ching/adapters/redis_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+module CaChing
+  module Adapters
+    describe Redis do
+      before :all do
+        @cache = CaChing::Adapters::Redis.new
+      end
+      
+      before :each do
+        @cache.clear!
+      end
+      
+      describe '#find' do
+        it 'finds the object(s) for the given query' do
+          object = [Article.where('1=1').limit(1).to_a_without_cache.first]
+          ar = Article.where(:title => object.first.title)
+          query = CaChing::Query::Abstract.new(ar)
+          
+          @cache.insert(ar, :for => query)
+          @cache.find(query).should == object
+        end
+        
+        it 'returns nil if the objects are not found' do
+          ar = Article.where(:title => 'Foo bar')
+          query = CaChing::Query::Abstract.new(ar)
+          
+          @cache.find(query).should == nil
+        end
+        
+        it 'does not return a dirty object' do
+          object = [Article.where('1=1').limit(1).to_a_without_cache.first]
+          ar = Article.where(:title => object.first.title)
+          query = CaChing::Query::Abstract.new(ar)
+          
+          @cache.insert(ar, :for => query)
+          @cache.find(query).inject(true) { |flag, object| flag && object.changed? }.should == false
+        end
+      end
+      
+      describe '#insert' do
+        it 'inserts the objects for a query with one where clause' do
+          object = [Article.where('1=1').limit(1).to_a_without_cache.first]
+          ar = Article.where(:title => object.first.title)
+          query = CaChing::Query::Abstract.new(ar)
+          
+          @cache.insert(ar, :for => query)
+          @cache.find(query).should == object
+        end
+        
+        it 'does not insert the objects for a query with multiple where clauses' do
+          ar = Article.where(:person_id => 1, :title => 'Foo bar')
+          query = CaChing::Query::Abstract.new(ar)
+          
+          @cache.insert(ar, :for => query)
+          @cache.find(query).should == nil
+        end
+        
+        it 'returns nil if the operation was unsuccessful' do
+          ar = Article.where(:person_id => 1, :title => 'Foo bar')
+          query = CaChing::Query::Abstract.new(ar)
+          
+          @cache.insert(ar, :for => query).should == nil
+        end
+        
+        it 'returns the objects inserted if the operation was successful' do
+          object = [Article.where('1=1').to_a_without_cache.first]
+          ar = Article.where(:title => object.first.title)
+          query = CaChing::Query::Abstract.new(ar)
+          
+          @cache.insert(ar, :for => query).should == object
+        end
+      end
+      
+      describe '#update' do        
+        it 'updates the object at the given key' do
+          object = [Article.where('1=1').to_a_without_cache.first]
+          ar = Article.where(:person_id => object.first.person_id)
+          query = CaChing::Query::Abstract.new(ar)
+          
+          @cache.insert(ar, :for => query)
+          
+          record = ar.to_a_without_cache.first
+          record.title = record.title.reverse
+          
+          @cache.update(record)
+          @cache.find(query).first.title.should == record.title
+        end
+        
+        describe 'key change' do
+          it 'removes the object at the old key and inserts it at the new key if the key already exists' do
+            articles = Article.where('1=1').to_a_without_cache
+            ar = Article.where(:person_id => articles.first.person_id)
+            query = CaChing::Query::Abstract.new(ar)
+          
+            @cache.insert(ar, :for => query)
+            
+            ar = Article.where(:person_id => articles.last.person_id)
+            query2 = CaChing::Query::Abstract.new(ar)
+
+            @cache.insert(ar, :for => query)
+          
+            record = ar.to_a_without_cache.first
+            record.person_id = articles.first.person_id
+            
+            @cache.update(record)
+          
+            ar = Article.where(:person_id => 1)
+            query = CaChing::Query::Abstract.new(ar)
+          
+            @cache.find(query).last.title.should == record.title
+            @cache.find(query2).should == nil
+          end
+          
+          it 'removes the object at the old key but does not insert it at the new if the key doesn\'t exist' do
+            articles = Article.where('1=1').to_a_without_cache
+            ar = Article.where(:title => articles.first.title)
+            query = CaChing::Query::Abstract.new(ar)
+            
+            @cache.insert(ar, :for => query)
+            
+            record = ar.to_a_without_cache.first
+            record.title = record.title.reverse
+
+            @cache.update(record)
+            @cache.find(query).should == nil
+            @cache.find(CaChing::Query::Abstract.new(Article.where(:title => record.title))).should == nil
+          end
+        end
+      end
+      
+      describe '#destroy' do
+        it 'removes the object at the key' do
+          articles = Article.where('1=1').to_a_without_cache
+          ar = Article.where(:title => articles.last.title)
+          query = CaChing::Query::Abstract.new(ar)
+          
+          @cache.insert(ar, :for => query)
+          @cache.destroy(ar.first, :at => "articles:title=#{articles.last.title}")
+          @cache.find(query).should == nil
+        end
+      end
+      
+      describe '#clear!' do
+        it 'clears redis' do
+          
+        end
+      end
+      
+      describe '#inflate' do
+        it 'turns the stored objects back into AR objects' do
+          
+        end
+      end
+      
+      describe '#deflate' do
+        
+      end
+      
+      describe '#deflate_with_score' do
+        it 'turns the objects into JSON strings' do
+          
+        end
+        
+        it 'uses the score method if provided' do
+          
+        end
+        
+        it 'defaults to using id if no score method is provided' do
+          
+        end
+      end
+    end
+  end
+
+end

data/spec/ca_ching/configuration_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module CaChing
+  describe Configuration do
+    
+  end
+end

data/spec/ca_ching/index_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module CaChing
+  describe Index do
+    it 'allows indexes to be defined' do
+      Person.index :name
+      Person.indexes?(:name).should == true
+    end
+    
+    describe Index, 'index options' do
+      it 'allows indexes to be defined with options' do
+        Person.index :name, :order => { :age => :asc }, :ttl => 12.seconds
+        Person.indexes?(:name).should == true
+        Person.send(:indexed_fields)[:name].should == { :order => { :age => :asc }, :ttl => 12.seconds }
+      end
+      
+      it 'rejects unsupported options' do
+        lambda { Person.index :name, :not => :valid }.should raise_error(InvalidOptionError)
+      end
+    end
+  end
+end

data/spec/ca_ching/query/abstract_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+module CaChing
+  module Query
+    describe Abstract do
+      describe 'SQL parsing' do
+        # The queries we are concerned with take the form:
+        #    SELECT [*|field1,field2,...] FROM table_name WHERE field [=|<|>|<=...] value [AND|OR] ... LIMIT x OFFSET y... ORDER BY ...
+        # The tests are split up into parsing the various parts, namely:
+        #  - table_name
+        #  - conditions (the WHERE bit)
+        #  - limit
+        #  - offset
+        #  - order
+        # 
+        # The tests conclude with parsing various complete queries to test the combination of the various parsing logics.
+        describe '#order' do
+          it 'returns {} if no order is set' do
+            ar = Person.where(:name => 'Andrew')
+            query = Abstract.new(ar)
+            query.order.should == {}
+          end
+
+          it 'returns the key and desc for a singular order clause DESC' do 
+            ar = Person.order('created_at DESC')
+            query = Abstract.new(ar)
+            query.order.should == { :created_at => :desc }
+          end
+
+          it 'returns the key and desc for a singular order clause ASC' do 
+            ar = Person.order('created_at ASC')
+            query = Abstract.new(ar)
+            query.order.should == { :created_at => :asc }
+          end
+
+          it 'returns the keys and direction for multiple order clauses from different order calls' do 
+            ar = Person.order('created_at DESC').order('name ASC')
+            query = Abstract.new(ar)
+            query.order.should == { :created_at => :desc, :name => :asc }
+          end
+
+          it 'returns the keys and direction for multiple order clauses from the same order call' do 
+            ar = Person.order('created_at DESC, name ASC')
+            query = Abstract.new(ar)
+            query.order.should == { :created_at => :desc, :name => :asc }
+          end
+
+          it 'returns the keys and direction for multiple order clauses from different order calls and from the same order call' do 
+            ar = Person.order('created_at DESC, name ASC').order('salary DESC')
+            query = Abstract.new(ar)
+            query.order.should == { :created_at => :desc, :name => :asc, :salary => :desc }
+          end
+        end
+        
+        describe '#where' do
+          it 'returns {} if no where clause has been specified' do
+            ar = Person.order('created_at DESC')
+            query = Abstract.new(ar)
+            query.where.should == {}
+          end
+          
+          it 'interpolates bind_values' do
+            pending 'needs a hook to get collection for Model.find(id), since that seems the only place that uses bind_values'
+          end
+          
+          describe 'string queries' do
+            it 'handles a single condition' do
+              ar = Person.where('name = ?', 'Andrew')
+              query = Abstract.new(ar)
+              query.where.should == { :name => ['=', 'Andrew'] }
+            end
+            
+            it 'splits on AND' do
+              ar = Person.where('name = ? AND age = ?', 'Andrew', 22)
+              query = Abstract.new(ar)
+              query.where.should == { :name => ['=', 'Andrew'], :age => ['=', '22'] }
+            end
+            
+            it 'handles arbitrary comparators' do
+              ar = Person.where('age > ?', 18)
+              query = Abstract.new(ar)
+              query.where.should == { :age => ['>', '18'] }
+            end
+            
+            it 'rejects OR conditions' do
+              ar = Person.where('name = ? OR age > ?', 'Andrew', 18)
+              query = Abstract.new(ar)
+              lambda { query.where }.should raise_error(UncacheableConditionError)
+            end
+          end
+          
+          describe 'hash queries' do
+            it 'handles a single condition' do
+              ar = Person.where(:name => 'Andrew')
+              query = Abstract.new(ar)
+              query.where.should == { :name => ['=', 'Andrew'] }
+            end
+            
+            it 'handles multiple clauses' do
+              ar = Person.where(:name => 'Andrew', :age => 22)
+              query = Abstract.new(ar)
+              query.where.should == { :name => ['=', 'Andrew'], :age => ['=', 22] }
+            end
+          end
+        end
+        
+        describe '#limit' do
+          it 'returns the limit if one is set' do
+            ar = Person.limit(10)
+            query = Abstract.new(ar)
+            query.limit.should == 10
+          end
+          
+          it 'returns nil if the limit is not set' do
+            ar = Person.where(:name => 'Andrew')
+            query = Abstract.new(ar)
+            query.limit.should == nil
+          end
+        end
+        
+        describe '#offset' do
+          it 'returns the offset if one is set' do
+            ar = Person.offset(10)
+            query = Abstract.new(ar)
+            query.offset.should == 10
+          end
+          
+          it 'returns nil if the offset is not set' do
+            ar = Person.where(:name => 'Andrew')
+            query = Abstract.new(ar)
+            query.offset.should == nil
+          end
+        end
+        
+        describe '#table_name' do
+          it 'returns the table name' do
+            ar = Person.where(:name => 'Andrew')
+            query = Abstract.new(ar)
+            query.table_name.should == "people"
+          end
+        end
+        
+        it 'handles complex queries' do
+          ar = Person.where(:name => 'Andrew').where('age >= ? AND salary < ?', 21, 10000).order('created_at DESC').order('name DESC, age ASC').limit(20).offset(20)
+          query = Abstract.new(ar)
+          
+          query.where.should == { :name => ['=', 'Andrew'], :age => ['>=', '21'], :salary => ['<', '10000'] }
+          query.order.should == { :created_at => :desc, :name => :desc, :age => :asc }
+          query.limit.should == 20
+          query.offset.should == 20
+        end
+      end
+      
+      describe '#to_key' do
+        it 'formats the key as table_name:field1="value1"&field2="value2"...' do
+          ar = Person.where(:name => 'Andrew', :age => 22)
+          query = Abstract.new(ar)
+          query.to_key.should == 'people:name="Andrew"&age="22"'
+        end
+        
+        it 'escapes quotes in a string' do
+          ar = Person.where(:name => '"Howard"')
+          query = Abstract.new(ar)
+          query.to_key.should == 'people:name="\"Howard\""'
+        end
+        
+        it 'separates multiple conditions by &' do
+          ar = Person.where(:name => 'Andrew', :age => 22)
+          query = Abstract.new(ar)
+          query.to_key.should == 'people:name="Andrew"&age="22"'
+        end
+      end
+      
+      describe '#primary_key?' do
+        it 'returns true if the query is only on the primary key' do
+          ar = Person.where(:id => 1)
+          query = Abstract.new(ar)
+          query.primary_key?.should == true
+        end
+        
+        it 'returns false if the query is not on the primary key' do
+          ar = Person.where(:name => 'Andrew')
+          query = Abstract.new(ar)
+          query.primary_key?.should == false
+        end
+        
+        it 'returns false if the query is on the primary key and another field' do
+          ar = Person.where(:id => 1, :name => 'Andrew')
+          query = Abstract.new(ar)
+          query.primary_key?.should == false
+        end
+      end
+    end
+  end
+end

data/spec/ca_ching/query/calculation_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module CaChing
+  module Query
+    describe Calculation do
+
+    end
+  end
+end

data/spec/ca_ching/query/select_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module CaChing
+  module Query
+    describe Select do
+
+    end
+  end
+end