kasket 1.0.4 → 2.1.0

data/README.rdoc

@@ -1,6 +1,6 @@
 = Kasket {<img src="https://secure.travis-ci.org/staugaard/kasket.png" />}[http://travis-ci.org/staugaard/kasket]
 === Puts a cap on your queries
-A caching layer for ActiveRecord
+A caching layer for ActiveRecord (2.3.x and 3.1.x)
 
 Developed and used on http://zendesk.com.
 

data/lib/kasket.rb

@@ -2,26 +2,42 @@
 require 'active_record'
 require 'active_support'
 
-require 'kasket/active_record_patches'
 require 'kasket/version'
 
 module Kasket
-  autoload :ConfigurationMixin, 'kasket/configuration_mixin'
+  autoload :ReadMixin,              'kasket/read_mixin'
+  autoload :WriteMixin,             'kasket/write_mixin'
+  autoload :DirtyMixin,             'kasket/dirty_mixin'
+  autoload :QueryParser,            'kasket/query_parser'
+  autoload :ConfigurationMixin,     'kasket/configuration_mixin'
   autoload :ReloadAssociationMixin, 'kasket/reload_association_mixin'
-  autoload :Query, 'kasket/query'
+  autoload :Query,                  'kasket/query'
+  autoload :Visitor,                'kasket/visitor'
+  autoload :SelectManagerMixin,     'kasket/select_manager_mixin'
+  autoload :RelationMixin,          'kasket/relation_mixin'
+
+  AR30 = (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0)
 
   CONFIGURATION = {:max_collection_size => 100}
 
   module_function
 
   def setup(options = {})
-    return if ActiveRecord::Base.extended_by.member?(Kasket::ConfigurationMixin)
+    return if ActiveRecord::Base.respond_to?(:has_kasket)
 
     CONFIGURATION[:max_collection_size] = options[:max_collection_size] if options[:max_collection_size]
 
     ActiveRecord::Base.extend(Kasket::ConfigurationMixin)
+
+    if defined?(ActiveRecord::Relation)
+      ActiveRecord::Relation.send(:include, Kasket::RelationMixin)
+      Arel::SelectManager.send(:include, Kasket::SelectManagerMixin)
+    end
+
     ActiveRecord::Associations::BelongsToAssociation.send(:include, Kasket::ReloadAssociationMixin)
-    ActiveRecord::Associations::BelongsToPolymorphicAssociation.send(:include, Kasket::ReloadAssociationMixin)
+    if ActiveRecord::VERSION::MAJOR == 2 || AR30
+      ActiveRecord::Associations::BelongsToPolymorphicAssociation.send(:include, Kasket::ReloadAssociationMixin)
+    end
     ActiveRecord::Associations::HasOneThroughAssociation.send(:include, Kasket::ReloadAssociationMixin)
   end
 
@@ -39,4 +55,3 @@ module Kasket
     end
   end
 end
-

data/lib/kasket/configuration_mixin.rb

@@ -3,10 +3,6 @@ require 'active_support'
 require "digest/md5"
 
 module Kasket
-  autoload :ReadMixin, 'kasket/read_mixin'
-  autoload :WriteMixin, 'kasket/write_mixin'
-  autoload :DirtyMixin, 'kasket/dirty_mixin'
-  autoload :QueryParser, 'kasket/query_parser'
 
   module ConfigurationMixin
 
@@ -27,7 +23,7 @@ module Kasket
     end
 
     def kasket_key_prefix
-      @kasket_key_prefix ||= "kasket-#{Kasket::Version::STRING}/#{table_name}/version=#{column_names.join.sum}/"
+      @kasket_key_prefix ||= "kasket-#{Kasket::Version::PROTOCOL}/#{table_name}/version=#{column_names.join.sum}/"
     end
 
     def kasket_key_for(attribute_value_pairs)

data/lib/kasket/query_parser.rb

@@ -11,15 +11,26 @@ module Kasket
 
     def initialize(model_class)
       @model_class = model_class
-      @supported_query_pattern = /^select \* from (?:`|")#{@model_class.table_name}(?:`|") where \((.*)\)(|\s+limit 1)\s*$/i
-      @table_and_column_pattern = /(?:(?:`|")?#{@model_class.table_name}(?:`|")?\.)?(?:`|")?(\D\w*)(?:`|")?/ # Matches: `users`.id, `users`.`id`, users.id, id
+      @supported_query_pattern = if AR30
+        /^select\s+(?:`#{@model_class.table_name}`.)?\* from (?:`|")#{@model_class.table_name}(?:`|") where (.*?)\s*$/i
+      else
+        /^select \* from (?:`|")#{@model_class.table_name}(?:`|") where \((.*)\)(|\s+limit 1)\s*$/i
+      end
+      @table_and_column_pattern = /(?:(?:`|")?#{@model_class.table_name}(?:`|")?\.)?(?:`|")?([a-zA-Z]\w*)(?:`|")?/ # Matches: `users`.id, `users`.`id`, users.id, id
       @key_eq_value_pattern = /^[\(\s]*#{@table_and_column_pattern}\s+(=|IN)\s+#{VALUE}[\)\s]*$/ # Matches: KEY = VALUE, (KEY = VALUE), ()(KEY = VALUE))
     end
 
     def parse(sql)
       if match = @supported_query_pattern.match(sql)
+        where, limit = match[1], match[2]
+        if AR30 && where =~ /limit \d+\s*$/i
+          # limit is harder to find in rails 3.0 since where does not use surrounding braces
+          return unless where =~ /(.*?)(\s+limit 1)\s*$/i
+          where, limit = $1, $2
+        end
+
         query = Hash.new
-        query[:attributes] = sorted_attribute_value_pairs(match[1])
+        query[:attributes] = sorted_attribute_value_pairs(where)
         return nil if query[:attributes].nil?
 
         if query[:attributes].size > 1 && query[:attributes].map(&:last).any? {|a| a.is_a?(Array)}
@@ -28,7 +39,7 @@ module Kasket
         end
 
         query[:index] = query[:attributes].map(&:first)
-        query[:limit] = match[2].blank? ? nil : 1
+        query[:limit] = limit.blank? ? nil : 1
         query[:key] = @model_class.kasket_key_for(query[:attributes])
         query[:key] << '/first' if query[:limit] == 1 && !query[:index].include?(:id)
         query

data/lib/kasket/read_mixin.rb

@@ -8,8 +8,17 @@ module Kasket
       end
     end
 
-    def find_by_sql_with_kasket(sql)
-      query = kasket_parser.parse(sanitize_sql(sql)) if use_kasket?
+    def find_by_sql_with_kasket(*args)
+      sql = args[0]
+
+      if use_kasket?
+        if sql.respond_to?(:to_kasket_query)
+          query = sql.to_kasket_query(self, args[1])
+        else
+          query = kasket_parser.parse(sanitize_sql(sql))
+        end
+      end
+
       if query && has_kasket_index_on?(query[:index])
         if query[:key].is_a?(Array)
           find_by_sql_with_kasket_on_id_array(query[:key])
@@ -21,40 +30,36 @@ module Kasket
               Array.wrap(value).collect { |record| instantiate(record.dup) }
             end
           else
-            store_in_kasket(query[:key], find_by_sql_without_kasket(sql))
+            store_in_kasket(query[:key], find_by_sql_without_kasket(*args))
           end
         end
       else
-        find_by_sql_without_kasket(sql)
+        find_by_sql_without_kasket(*args)
       end
     end
 
     def find_by_sql_with_kasket_on_id_array(keys)
-      key_value_map = Kasket.cache.read_multi(*keys)
-      missing_ids = []
-
-      keys.each do |key|
-        if value = key_value_map[key]
-          key_value_map[key] = instantiate(value.dup)
-        else
-          missing_ids << key.split('=').last.to_i
-        end
-      end
+      key_attributes_map = Kasket.cache.read_multi(*keys)
 
-      if missing_ids.any?
-        without_kasket do
-          find_all_by_id(missing_ids).each do |instance|
-            instance.store_in_kasket
-            key_value_map[instance.kasket_key] = instance
-          end
-        end
-      end
+      found_keys, missing_keys = keys.partition{|k| key_attributes_map[k] }
+      found_keys.each{|k| key_attributes_map[k] = instantiate(key_attributes_map[k].dup) }
+      key_attributes_map.merge!(missing_records_from_db(missing_keys))
 
-      key_value_map.values.compact
+      key_attributes_map.values.compact
     end
 
     protected
 
+      def missing_records_from_db(missing_keys)
+        return {} if missing_keys.empty?
+
+        id_key_map = Hash[missing_keys.map{|key| [key.split('=').last.to_i, key] }]
+
+        found = without_kasket { find_all_by_id(id_key_map.keys) }
+        found.each(&:store_in_kasket)
+        Hash[found.map{|record| [id_key_map[record.id], record] }]
+      end
+
       def store_in_kasket(key, records)
         if records.size == 1
           if records.first.kasket_cacheable?

data/lib/kasket/relation_mixin.rb

@@ -0,0 +1,9 @@
+module Kasket
+  module RelationMixin
+    def to_kasket_query(binds = [])
+      if arel.is_a?(Arel::SelectManager)
+        arel.to_kasket_query(klass, binds)
+      end
+    end
+  end
+end

data/lib/kasket/reload_association_mixin.rb

@@ -1,13 +1,13 @@
 # -*- encoding: utf-8 -*-
 module Kasket
   module ReloadAssociationMixin
-    # TODO write tests for this
     def reload_with_kasket_clearing(*args)
       if loaded?
         Kasket.clear_local if target.class.include?(WriteMixin)
       else
-        target_class = proxy_reflection.options[:polymorphic] ? association_class : proxy_reflection.klass
-        Kasket.clear_local if target_class.include?(WriteMixin)
+        refl = respond_to?(:reflection) ? reflection : proxy_reflection
+        target_class = (refl.options[:polymorphic] ? (respond_to?(:klass) ? klass : association_class) : refl.klass)
+        Kasket.clear_local if target_class && target_class.include?(WriteMixin)
       end
 
       reload_without_kasket_clearing(*args)

data/lib/kasket/select_manager_mixin.rb

@@ -0,0 +1,26 @@
+module Kasket
+  module SelectManagerMixin
+    def to_kasket_query(klass, binds = [])
+      query = Kasket::Visitor.new(klass, binds).accept(ast)
+
+      return nil if query.nil? || query == :unsupported
+      return nil if query[:attributes].blank?
+
+      query[:index] = query[:attributes].map(&:first)
+
+      if query[:limit]
+        return nil if query[:limit] > 1
+        # return nil if !query[:index].include?(:id)
+      end
+
+      if query[:index].size > 1 && query[:attributes].any? { |attribute, value| value.is_a?(Array) }
+        return nil
+      end
+
+      query[:key] = klass.kasket_key_for(query[:attributes])
+      query[:key] << '/first' if query[:limit] == 1 && query[:index] != [:id]
+
+      query
+    end
+  end
+end

data/lib/kasket/version.rb

@@ -1,8 +1,10 @@
+# -*- encoding: utf-8 -*-
 module Kasket
   class Version
-    MAJOR = 1
-    MINOR = 0
-    PATCH = 4
+    MAJOR = 2
+    MINOR = 1
+    PATCH = 0
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+    PROTOCOL = 3
   end
 end

data/lib/kasket/visitor.rb

@@ -0,0 +1,140 @@
+require 'arel'
+
+module Kasket
+  class Visitor < Arel::Visitors::Visitor
+    def initialize(model_class, binds)
+      @model_class = model_class
+      @binds       = binds.dup
+    end
+
+    def accept(node)
+      self.last_column = nil
+      super
+    end
+
+    def last_column=(col)
+      Thread.current[:arel_visitors_to_sql_last_column] = col
+    end
+
+    def last_column
+      Thread.current[:arel_visitors_to_sql_last_column]
+    end
+
+    def column_for(name)
+      @model_class.columns_hash[name.to_s]
+    end
+
+    def visit_Arel_Nodes_SelectStatement(node)
+      return :unsupported if !AR30 && node.with
+      return :unsupported if node.offset
+      return :unsupported if node.lock
+      return :unsupported if node.orders.any?
+      return :unsupported if node.cores.size != 1
+
+      query = visit_Arel_Nodes_SelectCore(node.cores[0])
+      return query if query == :unsupported
+
+      query = query.inject({}) do |memo, item|
+        memo.merge(item)
+      end
+
+      query.merge!(visit(node.limit)) if node.limit
+      query
+    end
+
+    def visit_Arel_Nodes_SelectCore(node)
+      return :unsupported if node.groups.any?
+      return :unsupported if node.having
+      return :unsupported if !AR30 && node.set_quantifier
+      return :unsupported if !AR30 && (!node.source || node.source.empty?)
+      return :unsupported if node.projections.size != 1
+
+      select = node.projections[0]
+      select = select.name if select.respond_to?(:name)
+      return :unsupported if select != '*'
+
+      parts = [visit(node.source)]
+
+      parts += node.wheres.map {|where| visit(where) }
+
+      parts.include?(:unsupported) ? :unsupported : parts
+    end
+
+    def visit_Arel_Nodes_Limit(node)
+      {:limit => node.value.to_i}
+    end
+
+    def visit_Arel_Nodes_JoinSource(node)
+      return :unsupported if !node.left || node.right.any?
+      return :unsupported if !node.left.is_a?(Arel::Table)
+      visit(node.left)
+    end
+
+    def visit_Arel_Table(node)
+      {:from => node.name}
+    end
+
+    def visit_Arel_Nodes_And(node)
+      attributes = node.children.map { |child| visit(child) }
+      return :unsupported if attributes.include?(:unsupported)
+      attributes.sort! { |pair1, pair2| pair1[0].to_s <=> pair2[0].to_s }
+      { :attributes => attributes }
+    end
+
+    def visit_Arel_Nodes_In(node)
+      left = visit(node.left)
+      return :unsupported if left != :id
+
+      [left, visit(node.right)]
+    end
+
+    def visit_Arel_Nodes_Equality(node)
+      right = node.right
+      [visit(node.left), right ? visit(right) : nil]
+    end
+
+    def visit_Arel_Attributes_Attribute(node)
+      self.last_column = column_for(node.name)
+      node.name.to_sym
+    end
+
+    def literal(node)
+      if node == '?'
+        column, value = @binds.shift
+        value.to_s
+      else
+        node.to_s
+      end
+    end
+
+    # only gets used on 1.8.7
+    def visit_Arel_Nodes_BindParam(x)
+      @binds.shift[1]
+    end
+
+    def visit_Array(node)
+      node.map {|value| quoted(value) }
+    end
+
+    #TODO: We are actually not using this?
+    def quoted(node)
+      @model_class.connection.quote(node, self.last_column)
+    end
+
+    alias :visit_String                :literal
+    alias :visit_Fixnum                :literal
+    alias :visit_TrueClass             :literal
+    alias :visit_FalseClass            :literal
+    alias :visit_Arel_Nodes_SqlLiteral :literal
+
+    def method_missing(name, *args, &block)
+      return :unsupported if name.to_s.start_with?('visit_')
+      super
+    end
+
+    def respond_to?(name, include_private = false)
+      return super || name.to_s.start_with?('visit_')
+    end
+
+  end
+end

data/test/configuration_mixin_test.rb

@@ -6,7 +6,7 @@ class ConfigurationMixinTest < ActiveSupport::TestCase
   context "Generating cache keys" do
 
     should "not choke on empty numeric attributes" do
-      expected_cache_key = "kasket-#{Kasket::Version::STRING}/posts/version=3558/blog_id=null"
+      expected_cache_key = "kasket-#{Kasket::Version::PROTOCOL}/posts/version=#{POST_VERSION}/blog_id=null"
       query_attributes   = [ [:blog_id, ''] ]
 
       assert_equal expected_cache_key, Post.kasket_key_for(query_attributes)
@@ -27,7 +27,7 @@ class ConfigurationMixinTest < ActiveSupport::TestCase
 
     should "downcase string attributes" do
       query_attributes = [ [:title, 'ThIs'] ]
-      expected_cache_key = "kasket-#{Kasket::Version::STRING}/posts/version=3558/title='this'"
+      expected_cache_key = "kasket-#{Kasket::Version::PROTOCOL}/posts/version=#{POST_VERSION}/title='this'"
 
       assert_equal expected_cache_key, Post.kasket_key_for(query_attributes)
     end

data/test/database.yml

@@ -4,6 +4,4 @@ test:
   database: kasket_test
   username: root
   password:
-  socket: /tmp/mysql.sock
-
-
+  host: 127.0.0.1

data/test/fixtures/authors.yml

@@ -0,0 +1,5 @@
+mick:
+  name: Mick Staugaard
+
+eric:
+  name: Eric Chapweske

data/test/fixtures/comments.yml

@@ -1,12 +1,14 @@
 few_comments_1:
-  post: has_two_comments
+  id: 1
+  post_id: 2
   body: what ever body 1
 
 few_comments_2:
-  post: has_two_comments
+  id: 2
+  post_id: 2
   body: what ever body 2
 
-<% (1..10000).each do |i| %>
+<% (1..10).each do |i| %>
 many_comments_<%= i %>:
   post: has_many_comments
   body: what ever body <%= i %>

data/test/fixtures/posts.yml

@@ -1,15 +1,23 @@
 no_comments:
+  id: 1
   blog: a_blog
   title: no_comments
+  author: mick
 
 has_two_comments:
+  id: 2
   blog: a_blog
   title: few_comments
+  author: mick
 
 on_other_blog:
+  id: 3
   blog: other_blog
   title: no_comments
+  author: eric
 
 has_many_comments:
+  id: 4
   blog: a_blog
-  title: many_comments
+  title: many_comments
+  author: eric

data/test/helper.rb

@@ -10,6 +10,7 @@ if defined?(Debugger)
 end
 
 require 'test/unit'
+require 'active_record'
 require 'active_record/fixtures'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -18,13 +19,9 @@ require 'kasket'
 
 Kasket.setup
 
-require 'shoulda'
-
 class ActiveSupport::TestCase
   include ActiveRecord::TestFixtures
 
-  fixtures :all
-
   def create_fixtures(*table_names)
     if block_given?
       Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
@@ -41,11 +38,23 @@ class ActiveSupport::TestCase
   def clear_cache
     Kasket.cache.clear
   end
+
+  def arel?
+    self.class.arel?
+  end
+
+  def self.arel?
+    ActiveRecord::VERSION::MAJOR >= 3 && ActiveRecord::VERSION::MINOR >= 1
+  end
 end
 
 ActiveSupport::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
 $LOAD_PATH.unshift(ActiveSupport::TestCase.fixture_path)
 
+class ActiveSupport::TestCase
+  fixtures :all
+end
+
 module Rails
   module_function
   CACHE = ActiveSupport::Cache::MemoryStore.new
@@ -61,3 +70,5 @@ module Rails
 end
 
 require 'test_models'
+POST_VERSION = Post.column_names.join.sum
+COMMENT_VERSION = Comment.column_names.join.sum

data/test/parser_test.rb

@@ -2,6 +2,24 @@ require File.expand_path("helper", File.dirname(__FILE__))
 require 'kasket/query_parser'
 
 class ParserTest < ActiveSupport::TestCase
+  def parse(options)
+    scope = Post
+    if arel?
+      options.each do |k,v|
+        scope = case k
+        when :conditions then scope.where(v)
+        else
+          scope.send(k, v)
+        end
+      end
+      scope.to_kasket_query
+    elsif ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
+      @parser.parse(scope.scoped(options).to_sql)
+    else
+      sql = scope.send(:construct_finder_sql, options)
+      @parser.parse(sql)
+    end
+  end
 
   context "Parsing" do
     setup do
@@ -9,40 +27,50 @@ class ParserTest < ActiveSupport::TestCase
     end
 
     should "not support conditions with number as column (e.g. 0 = 1)" do
-      kasket_query = @parser.parse('SELECT * FROM `posts` WHERE (0 = 1)')
-      assert(!kasket_query)
+      assert !parse(:conditions => "0 = 1")
+    end
+
+    should "not support conditions with number as column and parans (e.g. 0 = 1)" do
+      assert !parse(:conditions => "(0 = 1)")
     end
 
     should 'not support IN queries in combination with other conditions' do
-      parsed_query = @parser.parse('SELECT * FROM `posts` WHERE (`posts`.`id` IN (1,2,3) AND `posts`.`is_active` = 1)')
-      assert(!parsed_query)
+      assert !parse(:conditions => {:id => [1,2,3], :is_active => true})
     end
 
     should "extract conditions" do
-      assert_equal [[:blog_id, "big"], [:title, "red"]], @parser.parse('SELECT * FROM `posts` WHERE (`posts`.`title` = red AND `posts`.`blog_id` = big)')[:attributes]
+      kasket_query = parse(:conditions => {:title => 'red', :blog_id => 1})
+      assert_equal [[:blog_id, "1"], [:title, "red"]], kasket_query[:attributes]
+    end
+
+    should "extract conditions with parans that do not surround" do
+      kasket_query = parse(:conditions => "(title = 'red') AND (blog_id = 1)")
+      if ActiveRecord::VERSION::STRING > "3.1.0"
+        assert !kasket_query
+      else
+        assert_equal [[:blog_id, "1"], [:title, "red"]], kasket_query[:attributes]
+      end
     end
 
     should "extract required index" do
-      assert_equal [:blog_id, :title], @parser.parse('SELECT * FROM `posts` WHERE (`posts`.`title` = red AND `posts`.`blog_id` = big)')[:index]
+      assert_equal [:blog_id, :title], parse(:conditions => {:title => 'red', :blog_id => 1})[:index]
     end
 
     should "only support queries against its model's table" do
-      assert !@parser.parse('SELECT * FROM `apples` WHERE (`users`.`id` = 2) ')
+      assert !parse(:conditions => {'users.id' => 2}, :from => 'apples')
     end
 
     should "support cachable queries" do
-      assert @parser.parse('SELECT * FROM `posts` WHERE (`posts`.`id` = 2) ')
-      assert @parser.parse('SELECT * FROM `posts` WHERE (`posts`.`id` = 2) LIMIT 1')
+      assert parse(:conditions => {:id => 1})
+      assert parse(:conditions => {:id => 1}, :limit => 1)
     end
 
     should "support IN queries on id" do
-      parsed_query = @parser.parse('SELECT * FROM `posts` WHERE (`posts`.`id` IN (1,2,3))')
-      assert(parsed_query)
-      assert_equal([[:id, ['1', '2', '3']]], parsed_query[:attributes])
+      assert_equal [[:id, ['1', '2', '3']]], parse(:conditions => {:id => [1,2,3]})[:attributes]
     end
 
     should "not support IN queries on other attributes" do
-      assert(!@parser.parse('SELECT * FROM `posts` WHERE (`posts`.`hest` IN (1,2,3))'))
+      assert !parse(:conditions => {:hest => [1,2,3]})
     end
 
     should "support vaguely formatted queries" do
@@ -50,57 +78,58 @@ class ParserTest < ActiveSupport::TestCase
     end
 
     context "extract options" do
-
       should "provide the limit" do
-        sql = 'SELECT * FROM `posts` WHERE (`posts`.`id` = 2)'
-        assert_equal nil, @parser.parse(sql)[:limit]
-
-        sql << ' LIMIT 1'
-        assert_equal 1, @parser.parse(sql)[:limit]
+        assert_equal nil, parse(:conditions => {:id => 2})[:limit]
+        assert_equal 1, parse(:conditions => {:id => 2}, :limit => 1)[:limit]
       end
-
     end
 
     context "unsupported queries" do
-
       should "include advanced limits" do
-        assert !@parser.parse('SELECT * FROM `posts` WHERE (title = red AND blog_id = big) LIMIT 2')
+        assert !parse(:conditions => {:title => 'red', :blog_id => 1}, :limit => 2)
       end
 
       should "include joins" do
-        assert !@parser.parse('SELECT * FROM `posts`, `trees` JOIN ON apple.tree_id = tree.id WHERE (title = red)')
+        assert !parse(:conditions => {:title => 'test', 'apple.tree_id' => 'posts.id'}, :from => ['posts', 'apple'])
+        assert !parse(:conditions => {:title => 'test'}, :joins => :comments)
       end
 
       should "include specific selects" do
-        assert !@parser.parse('SELECT id FROM `posts` WHERE (title = red)')
+        assert !parse(:conditions => {:title => 'red'}, :select => :id)
       end
 
       should "include offset" do
-        assert !@parser.parse('SELECT * FROM `posts` WHERE (title = red) LIMIT 1 OFFSET 2')
+        assert !parse(:conditions => {:title => 'red'}, :limit => 1, :offset => 2)
       end
 
       should "include order" do
-        assert !@parser.parse('SELECT * FROM `posts` WHERE (title = red) ORDER DESC')
+        assert !parse(:conditions => {:title => 'red'}, :order => :title)
       end
 
       should "include the OR operator" do
-        assert !@parser.parse('SELECT * FROM `posts` WHERE (title = red OR blog_id = big) LIMIT 2')
+        assert !parse(:conditions => "title = 'red' OR blog_id = 1")
       end
     end
 
     context "key generation" do
       should "include the table name and version" do
-        assert_match(/^kasket-#{Kasket::Version::STRING}\/posts\/version=3558\//, @parser.parse('SELECT * FROM `posts` WHERE (id = 1)')[:key])
+        kasket_query = parse(:conditions => {:id => 1})
+        assert_match(/^kasket-#{Kasket::Version::PROTOCOL}\/posts\/version=#{POST_VERSION}\//, kasket_query[:key])
       end
 
       should "include all indexed attributes" do
-        assert_match(/id=1$/, @parser.parse('SELECT * FROM `posts` WHERE (id = 1)')[:key])
-        assert_match(/blog_id=2\/id=1$/, @parser.parse('SELECT * FROM `posts` WHERE (id = 1 AND blog_id = 2)')[:key])
-        assert_match(/id=1\/title='title'$/, @parser.parse("SELECT * FROM `posts` WHERE (id = 1 AND title = 'title')")[:key])
+        kasket_query = parse(:conditions => {:id => 1})
+        assert_match(/id=1$/, kasket_query[:key])
+
+        kasket_query = parse(:conditions => {:id => 1, :blog_id => 2})
+        assert_match(/blog_id=2\/id=1$/, kasket_query[:key])
+
+        kasket_query = parse(:conditions => {:id => 1, :title => 'title'})
+        assert_match(/id=1\/title='title'$/, kasket_query[:key])
       end
 
       should "generate multiple keys on IN queries" do
-        keys = @parser.parse('SELECT * FROM `posts` WHERE (id IN (1,2))')[:key]
+        keys = parse(:conditions => {:id => [1,2]})[:key]
         assert_instance_of(Array, keys)
         assert_match(/id=1$/, keys[0])
         assert_match(/id=2$/, keys[1])
@@ -108,13 +137,13 @@ class ParserTest < ActiveSupport::TestCase
 
       context "when limit 1" do
         should "add /first to the key if the index does not include id" do
-          assert_match(/title='a'\/first$/, @parser.parse("SELECT * FROM `posts` WHERE (title = 'a') LIMIT 1")[:key])
+          assert_match(/title='a'\/first$/, parse(:conditions => {:title => 'a'}, :limit => 1)[:key])
         end
+
         should "not add /first to the key when the index includes id" do
-          assert_match(/id=1$/, @parser.parse("SELECT * FROM `posts` WHERE (id = 1) LIMIT 1")[:key])
+          assert_match(/id=1$/, parse(:conditions => {:id => 1}, :limit => 1)[:key])
         end
       end
     end
   end
-
 end

data/test/read_mixin_test.rb

@@ -20,20 +20,25 @@ class ReadMixinTest < ActiveSupport::TestCase
     end
 
     should "read results" do
-      Kasket.cache.write("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1", @post_database_result)
+      Kasket.cache.write("kasket-#{Kasket::Version::PROTOCOL}/posts/version=#{POST_VERSION}/id=1", @post_database_result)
       assert_equal @post_records, Post.find_by_sql('SELECT * FROM `posts` WHERE (id = 1)')
     end
 
+    should "support sql with ?" do
+      Kasket.cache.write("kasket-#{Kasket::Version::PROTOCOL}/posts/version=#{POST_VERSION}/id=1", @post_database_result)
+      assert_equal @post_records, Post.find_by_sql(['SELECT * FROM `posts` WHERE (id = ?)', 1])
+    end
+
     should "store results in kasket" do
       Post.find_by_sql('SELECT * FROM `posts` WHERE (id = 1)')
 
-      assert_equal @post_database_result, Kasket.cache.read("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1")
+      assert_equal @post_database_result, Kasket.cache.read("kasket-#{Kasket::Version::PROTOCOL}/posts/version=#{POST_VERSION}/id=1")
     end
 
     should "store multiple records in cache" do
       Comment.find_by_sql('SELECT * FROM `comments` WHERE (post_id = 1)')
-      stored_value = Kasket.cache.read("kasket-#{Kasket::Version::STRING}/comments/version=3476/post_id=1")
-      assert_equal(["kasket-#{Kasket::Version::STRING}/comments/version=3476/id=1", "kasket-#{Kasket::Version::STRING}/comments/version=3476/id=2"], stored_value)
+      stored_value = Kasket.cache.read("kasket-#{Kasket::Version::PROTOCOL}/comments/version=#{COMMENT_VERSION}/post_id=1")
+      assert_equal(["kasket-#{Kasket::Version::PROTOCOL}/comments/version=#{COMMENT_VERSION}/id=1", "kasket-#{Kasket::Version::PROTOCOL}/comments/version=#{COMMENT_VERSION}/id=2"], stored_value)
       assert_equal(@comment_database_result, stored_value.map {|key| Kasket.cache.read(key)})
 
       Comment.expects(:find_by_sql_without_kasket).never
@@ -43,13 +48,15 @@ class ReadMixinTest < ActiveSupport::TestCase
 
     context "modifying results" do
       setup do
-        Kasket.cache.write("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1", @post_database_result)
-        @record = Post.find_by_sql('SELECT * FROM `posts` WHERE (id = 1)').first
+        Kasket.cache.write("kasket-#{Kasket::Version::PROTOCOL}/posts/version=#{POST_VERSION}/id=1", {'id' => 1, 'title' => "asd"})
+        @sql = 'SELECT * FROM `posts` WHERE (id = 1)'
+        @record = Post.find_by_sql(@sql).first
+        assert_equal "asd", @record.title # read from cache ?
         @record.instance_variable_get(:@attributes)['id'] = 3
       end
 
       should "not impact other queries" do
-        same_record = Post.find_by_sql('SELECT * FROM `posts` WHERE (id = 1)').first
+        same_record = Post.find_by_sql(@sql).first
 
         assert_not_equal @record, same_record
       end

data/test/reload_test.rb

@@ -0,0 +1,85 @@
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class ReloadTest < ActiveSupport::TestCase
+  context "Loading a polymorphic belongs_to" do
+    should "not clear cache when loading nil" do
+      @post = Post.first
+      @post.poly = nil
+      @post.save!
+      Kasket.expects(:clear_local).never
+      assert_nil @post.poly
+    end
+
+    context "that is uncached" do
+      setup do
+        @post = Post.first
+        @post.poly = Blog.first
+        @post.save!
+        assert @post.poly
+      end
+
+      should "not clear local when it is unloaded" do
+        Kasket.expects(:clear_local).never
+        assert Post.first.poly
+      end
+
+      should "not clear local when it is loaded" do
+        Kasket.expects(:clear_local).never
+        assert @post.poly.reload
+      end
+    end
+
+    context "that is cached" do
+      setup do
+        @post = Post.first
+        @post.poly = Comment.first
+        @post.save!
+        assert @post.poly
+      end
+
+      should "clear local when it is loaded" do
+        Kasket.expects(:clear_local)
+        @post.poly.reload
+      end
+    end
+  end
+
+  context "Reloading a model" do
+    setup do
+      @post = Post.first
+      assert @post
+      assert @post.title
+    end
+
+    should "clear local cache" do
+      Kasket.expects(:clear_local)
+      @post.reload
+    end
+  end
+
+  context "Reloading a belongs_to association" do
+    setup do
+      @post = Comment.first.post
+      assert @post
+      assert @post.title
+    end
+
+    should "clear local cache" do
+      Kasket.expects(:clear_local)
+      @post.reload
+    end
+  end
+
+  context "Reloading a has_one_through association" do
+    setup do
+      @author = Comment.first.author
+      assert @author
+      assert @author.name
+    end
+
+    should "clear local cache" do
+      Kasket.expects(:clear_local)
+      @author.reload
+    end
+  end
+end

data/test/schema.rb

@@ -0,0 +1,30 @@
+ActiveRecord::Schema.define(:version => 1) do
+  suppress_messages do
+    create_table 'comments', :force => true do |t|
+      t.text     'body'
+      t.integer  'post_id'
+      t.datetime 'created_at'
+      t.datetime 'updated_at'
+    end
+
+    create_table 'authors', :force => true do |t|
+      t.string 'name'
+    end
+
+    create_table 'posts', :force => true do |t|
+      t.string   'title'
+      t.integer  'author_id'
+      t.integer  'blog_id'
+      t.integer  'poly_id'
+      t.string   'poly_type'
+      t.datetime 'created_at'
+      t.datetime 'updated_at'
+    end
+
+    create_table 'blogs', :force => true do |t|
+      t.string   'name'
+      t.datetime 'created_at'
+      t.datetime 'updated_at'
+    end
+  end
+end

data/test/test_models.rb

@@ -1,29 +1,29 @@
-require 'temping'
-include Temping
-
-create_model :comment do
-  with_columns do |t|
-    t.text     "body"
-    t.integer  "post_id"
-    t.datetime "created_at"
-    t.datetime "updated_at"
-  end
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.expand_path("database.yml", File.dirname(__FILE__))))
+
+conf = ActiveRecord::Base.configurations['test']
+`echo "drop DATABASE if exists #{conf['database']}" | mysql --user=#{conf['username']}`
+`echo "create DATABASE #{conf['database']}" | mysql --user=#{conf['username']}`
+ActiveRecord::Base.establish_connection('test')
+load(File.dirname(__FILE__) + "/schema.rb")
 
+class Comment < ActiveRecord::Base
   belongs_to :post
+  has_one :author, :through => :post
 
   has_kasket_on :post_id
 end
 
-create_model :post do
-  with_columns do |t|
-    t.string   "title"
-    t.integer  "blog_id"
-    t.datetime "created_at"
-    t.datetime "updated_at"
-  end
+class Author < ActiveRecord::Base
+  has_many :posts
+
+  has_kasket
+end
 
+class Post < ActiveRecord::Base
   belongs_to :blog
+  belongs_to :author
   has_many :comments
+  belongs_to :poly, :polymorphic => true
 
   has_kasket
   has_kasket_on :title
@@ -33,15 +33,11 @@ create_model :post do
     self.updated_at = Time.now
     self.connection.execute("UPDATE posts SET updated_at = '#{updated_at.utc.to_s(:db)}' WHERE id = #{id}")
   end
+
   kasket_dirty_methods :make_dirty!
 end
 
-create_model :blog do
-  with_columns do |t|
-    t.string   "name"
-    t.datetime "created_at"
-    t.datetime "updated_at"
-  end
-
+class Blog < ActiveRecord::Base
   has_many :posts
+  has_many :comments, :through => :posts
 end

data/test/visitor_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class VisitorTest < ActiveSupport::TestCase
+  if arel?
+    context Kasket::Visitor do
+      should "build select id" do
+        expected = {
+          :attributes=>[[:id, "1"]],
+          :from=>"posts",
+          :index=>[:id],
+          :key=>"kasket-#{Kasket::Version::PROTOCOL}/posts/version=#{POST_VERSION}/id=1"
+        }
+        assert_equal expected, Post.where(:id => 1).to_kasket_query
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kasket
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 2.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,24 +10,30 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-19 00:00:00.000000000 Z
+date: 2012-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.6
+    - - <
       - !ruby/object:Gem::Version
-        version: 2.3.4
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.6
+    - - <
       - !ruby/object:Gem::Version
-        version: 2.3.4
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -61,23 +67,23 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: shoulda
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: shoulda
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -93,13 +99,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: temping
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 0.10.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -107,23 +113,23 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 0.10.5
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.5.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.5.1
 description: puts a cap on your queries
 email:
 - mick@zendesk.com
@@ -132,13 +138,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/kasket/active_record_patches.rb
 - lib/kasket/configuration_mixin.rb
 - lib/kasket/dirty_mixin.rb
 - lib/kasket/query_parser.rb
 - lib/kasket/read_mixin.rb
+- lib/kasket/relation_mixin.rb
 - lib/kasket/reload_association_mixin.rb
+- lib/kasket/select_manager_mixin.rb
 - lib/kasket/version.rb
+- lib/kasket/visitor.rb
 - lib/kasket/write_mixin.rb
 - lib/kasket.rb
 - README.rdoc
@@ -149,14 +157,18 @@ files:
 - test/dirty_test.rb
 - test/find_one_test.rb
 - test/find_some_test.rb
+- test/fixtures/authors.yml
 - test/fixtures/blogs.yml
 - test/fixtures/comments.yml
 - test/fixtures/posts.yml
 - test/helper.rb
 - test/parser_test.rb
 - test/read_mixin_test.rb
+- test/reload_test.rb
+- test/schema.rb
 - test/test_models.rb
 - test/transaction_test.rb
+- test/visitor_test.rb
 homepage: http://github.com/staugaard/kasket
 licenses: []
 post_install_message: 
@@ -171,13 +183,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4530626145164262218
+      hash: 2863500110980526189
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2863500110980526189
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -192,11 +207,15 @@ test_files:
 - test/dirty_test.rb
 - test/find_one_test.rb
 - test/find_some_test.rb
+- test/fixtures/authors.yml
 - test/fixtures/blogs.yml
 - test/fixtures/comments.yml
 - test/fixtures/posts.yml
 - test/helper.rb
 - test/parser_test.rb
 - test/read_mixin_test.rb
+- test/reload_test.rb
+- test/schema.rb
 - test/test_models.rb
 - test/transaction_test.rb
+- test/visitor_test.rb

data/lib/kasket/active_record_patches.rb

@@ -1,57 +0,0 @@
-# -*- encoding: utf-8 -*-
-module Kasket
-  module FixForAssociationAccessorMethods
-    def association_accessor_methods(reflection, association_proxy_class)
-      define_method(reflection.name) do |*params|
-        force_reload = params.first unless params.empty?
-        association = association_instance_get(reflection.name)
-
-        if association.nil? || force_reload
-          association = association_proxy_class.new(self, reflection)
-          retval = force_reload ? association.reload : association.__send__(:load_target)
-          if retval.nil? and association_proxy_class == ActiveRecord::Associations::BelongsToAssociation
-            association_instance_set(reflection.name, nil)
-            return nil
-          end
-          association_instance_set(reflection.name, association)
-        end
-
-        association.target.nil? ? nil : association
-      end
-
-      define_method("loaded_#{reflection.name}?") do
-        association = association_instance_get(reflection.name)
-        association && association.loaded?
-      end
-
-      define_method("#{reflection.name}=") do |new_value|
-        association = association_instance_get(reflection.name)
-
-        if association.nil? || association.target != new_value
-          association = association_proxy_class.new(self, reflection)
-        end
-
-        if association_proxy_class == ActiveRecord::Associations::HasOneThroughAssociation
-          association.create_through_record(new_value)
-          if new_record?
-            association_instance_set(reflection.name, new_value.nil? ? nil : association)
-          else
-            self.send(reflection.name, new_value)
-          end
-        else
-          association.replace(new_value)
-          association_instance_set(reflection.name, new_value.nil? ? nil : association)
-        end
-      end
-
-      define_method("set_#{reflection.name}_target") do |target|
-        return if target.nil? and association_proxy_class == ActiveRecord::Associations::BelongsToAssociation
-        association = association_proxy_class.new(self, reflection)
-        association.target = target
-        association_instance_set(reflection.name, association)
-      end
-    end
-  end
-end
-
-ActiveRecord::Base.extend Kasket::FixForAssociationAccessorMethods