kasket 0.5.5 → 0.6.0

data/Rakefile

@@ -6,10 +6,10 @@ begin
   Jeweler::Tasks.new do |gem|
     gem.name = "kasket"
     gem.summary = %Q{A write back caching layer on active record}
-    gem.description = %Q{A rewrite of cache money}
+    gem.description = %Q{put's a cap on your queries}
     gem.email = "mick@staugaard.com"
     gem.homepage = "http://github.com/staugaard/kasket"
-    gem.authors = ["Mick Staugaard"]
+    gem.authors = ["Mick Staugaard", "Eric Chapweske"]
     gem.add_dependency('activerecord', '>= 2.3.4')
     gem.add_dependency('activesupport', '>= 2.3.4')
     gem.add_development_dependency "thoughtbot-shoulda", ">= 0"

data/VERSION

@@ -1 +1 @@
-0.5.5
+0.6.0

data/lib/kasket.rb

@@ -9,6 +9,7 @@ module Kasket
   autoload :ConfigurationMixin, 'kasket/configuration_mixin'
   autoload :ReloadAssociationMixin, 'kasket/reload_association_mixin'
   autoload :RackMiddleware, 'kasket/rack_middleware'
+  autoload :Query, 'kasket/query'
 
   CONFIGURATION = {:max_collection_size => 100}
 
@@ -26,13 +27,6 @@ module Kasket
     ActiveRecord::Associations::BelongsToPolymorphicAssociation.send(:include, Kasket::ReloadAssociationMixin)
     ActiveRecord::Associations::HasOneThroughAssociation.send(:include, Kasket::ReloadAssociationMixin)
 
-    #sets up local cache clearing on rack
-    begin
-      ActionController::Dispatcher.middleware.use(Kasket::RackMiddleware)
-    rescue NameError => e
-      puts('WARNING: The kasket rack middleware is not in your rack stack')
-    end
-
     #sets up local cache clearing before each request.
     #this is done to make it work for non rack rails and for functional tests
     begin
@@ -42,6 +36,13 @@ module Kasket
     rescue NameError => e
     end
 
+    #sets up local cache clearing on rack
+    begin
+      ActionController::Dispatcher.middleware.use(Kasket::RackMiddleware)
+    rescue NameError => e
+      puts('WARNING: The kasket rack middleware is not in your rack stack')
+    end
+
     #sets up local cache clearing after each test case
     begin
       ActiveSupport::TestCase.class_eval do

data/lib/kasket/active_record_patches.rb

@@ -53,4 +53,4 @@ module Kasket
   end
 end
 
-ActiveRecord::Base.extend Kasket::FixForAssociationAccessorMethods
+ActiveRecord::Base.extend Kasket::FixForAssociationAccessorMethods

data/lib/kasket/cache.rb

@@ -6,11 +6,9 @@ module Kasket
 
     def read(*args)
       result = @local_cache[args[0]] || Rails.cache.read(*args)
-      if result.is_a?(CachedModel)
-        result = result.instanciate_model
-      elsif result.is_a?(Array)
+      if result.is_a?(Array) && result.first.is_a?(String)
         models = get_multi(result)
-        result = result.map { |key| models[key]}
+        result = result.map { |key| models[key] }
       end
 
       @local_cache[args[0]] = result if result
@@ -25,7 +23,6 @@ module Kasket
         if Rails.cache.respond_to?(:read_multi)
           missing_map = Rails.cache.read_multi(missing_keys)
           missing_map.each do |key, value|
-            value = value.instanciate_model if value.is_a?(CachedModel)
             missing_map[key] = @local_cache[key] = value
           end
           map.merge!(missing_map)
@@ -39,14 +36,12 @@ module Kasket
       map
     end
 
-    def write(*args)
-      @local_cache[args[0]] = args[1]
-
-      if args[1].is_a?(ActiveRecord::Base)
-        args[1] = CachedModel.new(args[1])
+    def write(key, value)
+      if storable?(value)
+        @local_cache[key] = value.duplicable? ? value.dup : value
+        Rails.cache.write(key, value.duplicable? ? value.dup : value) # Fix due to Rails.cache freezing values in 2.3.4
       end
-
-      Rails.cache.write(*args)
+      value
     end
 
     def delete(*args)
@@ -68,15 +63,15 @@ module Kasket
       @local_cache = {}
     end
 
-    class CachedModel
-      def initialize(model)
-        @name = model.class.name
-        @attributes = model.instance_variable_get(:@attributes)
-      end
+    def local
+      @local_cache
+    end
 
-      def instanciate_model
-        @name.constantize.send(:instantiate, @attributes)
+    protected
+
+      def storable?(value)
+        !value.is_a?(Array) || value.size <= Kasket::CONFIGURATION[:max_collection_size]
       end
-    end
+
   end
 end

data/lib/kasket/configuration_mixin.rb

@@ -4,14 +4,50 @@ module Kasket
   autoload :ReadMixin, 'kasket/read_mixin'
   autoload :WriteMixin, 'kasket/write_mixin'
   autoload :DirtyMixin, 'kasket/dirty_mixin'
+  autoload :QueryParser, 'kasket/query_parser'
 
   module ConfigurationMixin
+
+    def without_kasket(&block)
+      old_value = @use_kasket || true
+      @use_kasket = false
+      yield
+    ensure
+      @use_kasket = old_value
+    end
+
+    def use_kasket?
+      @use_kasket != false
+    end
+
+    def kasket_parser
+      @kasket_parser ||= QueryParser.new(self)
+    end
+
     def kasket_key_prefix
       @kasket_key_prefix ||= "kasket/#{table_name}/version=#{column_names.join.sum}/"
     end
 
     def kasket_key_for(attribute_value_pairs)
-      kasket_key_prefix + attribute_value_pairs.map {|attribute, value| attribute.to_s + '=' + value.to_s}.join('/')
+      kasket_key_prefix + attribute_value_pairs.map do |attribute, value|
+        if (column = columns_hash[attribute.to_s]) && column.number?
+          attribute.to_s + '=' + convert_number_column_value(value.to_s)
+        else
+          attribute.to_s + '=' + connection.quote(value.to_s)
+        end
+      end.join('/')
+    end
+
+    def convert_number_column_value(value)
+      if value == false
+        0
+      elsif value == true
+        1
+      elsif value.is_a?(String) && value.blank?
+        nil
+      else
+        value
+      end
     end
 
     def kasket_key_for_id(id)
@@ -42,8 +78,8 @@ module Kasket
       @kasket_indices << attributes unless @kasket_indices.include?(attributes)
 
       include WriteMixin unless instance_methods.include?('store_in_kasket')
-      extend ReadMixin unless methods.include?('without_kasket')
       extend DirtyMixin unless methods.include?('kasket_dirty_methods')
+      extend ReadMixin unless methods.include?('find_by_sql_with_kasket')
     end
   end
-end
+end

data/lib/kasket/dirty_mixin.rb

@@ -15,4 +15,4 @@ module Kasket
 
     alias_method :kasket_dirty_method, :kasket_dirty_methods
   end
-end
+end

data/lib/kasket/query_parser.rb

@@ -0,0 +1,53 @@
+module Kasket
+  class QueryParser
+    # Examples:
+    # SELECT * FROM `users` WHERE (`users`.`id` = 2)
+    # SELECT * FROM `users` WHERE (`users`.`id` = 2) LIMIT 1
+    # 'SELECT * FROM \'posts\' WHERE (\'posts\'.\'id\' = 574019247) '
+
+    AND = /\s+AND\s+/i
+    VALUE = /'?(\d+|\?|(?:(?:[^']|''|\\')*))'?/ # Matches: 123, ?, '123', '12''3'
+
+    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}(?:`|")?\.)?(?:`|")?(\w+)(?:`|")?/ # Matches: `users`.id, `users`.`id`, users.id, id
+      @key_eq_value_pattern = /^[\(\s]*#{@table_and_column_pattern}\s+=\s+#{VALUE}[\)\s]*$/ # Matches: KEY = VALUE, (KEY = VALUE), ()(KEY = VALUE))
+    end
+
+    def parse(sql)
+      if match = @supported_query_pattern.match(sql)
+        query = Hash.new
+        query[:attributes] = sorted_attribute_value_pairs(match[1])
+        return nil if query[:attributes].nil?
+        query[:index] = query[:attributes].map(&:first)
+        query[:limit] = match[2].blank? ? nil : 1
+        query[:key] = @model_class.kasket_key_for(query[:attributes])
+        query[:key] << '/first' if query[:limit] == 1 && !query[:index].include?(:id)
+        query
+      end
+    end
+
+    private
+
+      def sorted_attribute_value_pairs(conditions)
+        if attributes = parse_condition(conditions)
+          attributes.sort { |pair1, pair2| pair1[0].to_s <=> pair2[0].to_s }
+        end
+      end
+
+      def parse_condition(conditions = '', *values)
+        values = values.dup
+        conditions.split(AND).inject([]) do |pairs, condition|
+          matched, column_name, sql_value = *(@key_eq_value_pattern.match(condition))
+          if matched
+            value = sql_value == '?' ? values.shift : sql_value
+            pairs << [column_name.to_sym, value.gsub(/''|\\'/, "'")]
+          else
+            return nil
+          end
+        end
+      end
+
+  end
+end

data/lib/kasket/rack_middleware.rb

@@ -10,4 +10,4 @@ module Kasket
       Kasket.cache.clear_local
     end
   end
-end
+end

data/lib/kasket/read_mixin.rb

@@ -1,92 +1,40 @@
-require 'kasket/conditions_parser'
-
 module Kasket
   module ReadMixin
 
-    def self.extended(model_class)
-      class << model_class
-        alias_method_chain :find_some, :kasket unless methods.include?('find_some_without_kasket')
-        alias_method_chain :find_every, :kasket unless methods.include?('find_every_without_kasket')
+    def self.extended(base)
+      class << base
+        alias_method_chain :find_by_sql, :kasket
       end
     end
 
-    def without_kasket(&block)
-      old_value = @use_kasket || true
-      @use_kasket = false
-      yield
-    ensure
-      @use_kasket = old_value
-    end
-
-    def find_every_with_kasket(options)
-      attribute_value_pairs = kasket_conditions_parser.attribute_value_pairs(options) if cache_safe?(options)
-
-      limit = (options[:limit] || (scope(:find) || {})[:limit])
-
-      if (limit.nil? || limit == 1) && attribute_value_pairs && has_kasket_index_on?(attribute_value_pairs.map(&:first))
-        collection_key = kasket_key_for(attribute_value_pairs)
-        collection_key << '/first' if limit == 1
-        unless records = Kasket.cache.read(collection_key)
-          records = without_kasket do
-            find_every_without_kasket(options)
-          end
-
-          if records.size == 1
-            Kasket.cache.write(collection_key, records[0])
-          elsif records.size <= Kasket::CONFIGURATION[:max_collection_size]
-            records.each { |record| record.store_in_kasket if record }
-            Kasket.cache.write(collection_key, records.map(&:kasket_key))
-          end
+    def find_by_sql_with_kasket(sql)
+      query = kasket_parser.parse(sql) if use_kasket?
+      if query && has_kasket_index_on?(query[:index])
+        if value = Kasket.cache.read(query[:key])
+          Array.wrap(value).collect! { |record| instantiate(record.clone) }
+        else
+          store_in_kasket(query[:key], find_by_sql_without_kasket(sql))
         end
-
-        Array(records)
       else
-        without_kasket do
-          find_every_without_kasket(options)
-        end
+        find_by_sql_without_kasket(sql)
       end
     end
 
-    def find_some_with_kasket(ids, options)
-      attribute_value_pairs = kasket_conditions_parser.attribute_value_pairs(options) if cache_safe?(options)
-      attribute_value_pairs << [:id, ids] if attribute_value_pairs
-
-      limit = (options[:limit] || (scope(:find) || {})[:limit])
-
-      if limit.nil? && attribute_value_pairs && has_kasket_index_on?(attribute_value_pairs.map(&:first))
-        id_to_key_map = Hash[*ids.uniq.map { |id| [id, kasket_key_for_id(id)] }.flatten]
-        cached_record_map = Kasket.cache.get_multi(id_to_key_map.values)
-
-        missing_keys = cached_record_map.select { |key, record| record.nil? }.map(&:first)
+    protected
 
-        return cached_record_map.values if missing_keys.empty?
-
-        missing_ids = id_to_key_map.invert.select { |key, id| missing_keys.include?(key) }.map(&:last)
-
-        db_records = without_kasket do
-          find_some_without_kasket(missing_ids, options)
-        end
-        db_records.each { |record| record.store_in_kasket if record }
-
-        (cached_record_map.values + db_records).compact.uniq.sort { |x, y| x.id <=> y.id}
-      else
-        without_kasket do
-          find_some_without_kasket(ids, options)
-        end
-      end
-    end
-
-    private
-
-      def cache_safe?(options)
-        @use_kasket != false && [options, scope(:find) || {}].all? do |hash|
-          result = hash[:select].nil? && hash[:joins].nil? && hash[:order].nil? && hash[:offset].nil?
-          result && (options[:limit].nil? || options[:limit] == 1)
+      def store_in_kasket(key, records)
+        if records.size == 1
+          Kasket.cache.write(key, records.first.instance_variable_get(:@attributes))
+        else
+          keys = records.map do |record|
+            key = kasket_key_for_id(record.id)
+            Kasket.cache.write(key, record.instance_variable_get(:@attributes))
+            key
+          end
+          Kasket.cache.write(key, keys)
         end
+        records
       end
 
-      def kasket_conditions_parser
-        @kasket_conditions_parser ||= Kasket::ConditionsParser.new(self)
-      end
   end
 end

data/lib/kasket/reload_association_mixin.rb

@@ -15,4 +15,4 @@ module Kasket
       base.alias_method_chain :reload, :kasket_clearing
     end
   end
-end
+end

data/lib/kasket/write_mixin.rb

@@ -1,5 +1,6 @@
 module Kasket
   module WriteMixin
+
     module ClassMethods
       def remove_from_kasket(ids)
         Array(ids).each do |id|
@@ -20,7 +21,7 @@ module Kasket
 
       def store_in_kasket
         if !readonly? && kasket_key
-          Kasket.cache.write(kasket_key, self)
+          Kasket.cache.write(kasket_key, @attributes)
         end
       end
 
@@ -35,13 +36,14 @@ module Kasket
         keys = []
         self.class.kasket_indices.each do |index|
           keys += attribute_sets.map do |attribute_set|
-            self.class.kasket_key_for(index.map { |attribute| [attribute, attribute_set[attribute]]})
+            key = self.class.kasket_key_for(index.map { |attribute| [attribute, attribute_set[attribute]]})
+            index.include?(:id) ? key : [key, key + '/first']
           end
         end
 
-        keys.uniq!
-        keys.map! {|key| [key, "#{key}/first"]}
         keys.flatten!
+        keys.uniq!
+        keys
       end
 
       def clear_kasket_indices

data/test/cache_expiry_test.rb

@@ -3,14 +3,11 @@ require File.dirname(__FILE__) + '/helper'
 class CacheExpiryTest < ActiveSupport::TestCase
   fixtures :blogs, :posts
 
-  Post.has_kasket
-  Post.has_kasket_on :title
-  Post.has_kasket_on :blog_id
-
   context "a cached object" do
     setup do
       post = Post.first
       @post = Post.find(post.id)
+
       assert(Rails.cache.read(@post.kasket_key))
     end
 
@@ -21,11 +18,9 @@ class CacheExpiryTest < ActiveSupport::TestCase
 
     should "clear all indices for instance when deleted" do
       Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "id=#{@post.id}")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "id=#{@post.id}/first")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title=#{@post.title}")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title=#{@post.title}/first")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}/first")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'/first")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}/id=#{@post.id}")
       Kasket.cache.expects(:delete).never
 
       @post.destroy
@@ -39,17 +34,16 @@ class CacheExpiryTest < ActiveSupport::TestCase
 
     should "clear all indices for instance when updated" do
       Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "id=#{@post.id}")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "id=#{@post.id}/first")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title=#{@post.title}")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title=#{@post.title}/first")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title=new title")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title=new title/first")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}")
-      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}/first")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'/first")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='new title'")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='new title'/first")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}/id=#{@post.id}")
       Kasket.cache.expects(:delete).never
 
       @post.title = "new title"
       @post.save
     end
+
   end
 end

data/test/cache_test.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/helper'
+
+class CacheTest < ActiveSupport::TestCase
+
+  context "Cache" do
+    setup do
+      @cache = Kasket::Cache.new
+    end
+
+    context "reading" do
+
+      should "work with non collection values" do
+        @cache.write('key', 'value')
+        assert_equal 'value', @cache.read('key')
+      end
+
+      should "fetch original results of stored collections" do
+        @cache.write('key1', 'value1')
+        @cache.write('key2', 'value2')
+        @cache.write('key3', 'value3')
+        @cache.write('collection_key', [ 'key1', 'key2', 'key3'])
+
+        assert_equal [ 'value1', 'value2', 'value3'], @cache.read('collection_key')
+      end
+
+      should "not impact original object" do
+        record = { 'id' => 1, 'color' => 'red' }
+        @cache.write('key', record)
+        record['id'] = 2
+
+        assert_not_equal record, @cache.read('key')
+      end
+
+    end
+
+    context "writing" do
+      setup do
+        @cache.write('key', 'value')
+      end
+
+      should "store the object locally" do
+        assert_equal 'value', @cache.local['key']
+      end
+
+      should "persist the object" do
+        @cache.clear_local
+        assert_equal 'value', @cache.read('key')
+      end
+
+      should "respect max collection size" do
+        original_max = Kasket::CONFIGURATION[:max_collection_size]
+        Kasket::CONFIGURATION[:max_collection_size] = 2
+
+        @cache.write('key', [ 'a', 'b'])
+        assert_equal 2, @cache.read('key').size
+
+        @cache.write('key2', ['a', 'b', 'c'])
+        assert_equal nil, @cache.read('key2')
+
+        Kasket::CONFIGURATION[:max_collection_size] = original_max
+      end
+
+    end
+
+    should "delete" do
+      @cache.write('key', 'value')
+      @cache.delete('key')
+
+      assert_equal nil, @cache.local['key']
+      assert_equal nil, @cache.read('key')
+    end
+
+    should "delete matched local" do
+      @cache.write('key1', 'value1')
+      @cache.write('key2', 'value2')
+      @cache.delete_matched_local(/2/)
+
+      assert_equal nil, @cache.local['key2']
+      assert_equal 'value1', @cache.local['key1']
+      assert_equal 'value2', @cache.read('key2')
+    end
+
+    should "delete local" do
+      @cache.write('key1', 'value1')
+      @cache.write('key2', 'value2')
+      @cache.delete_local('key1', 'key2')
+
+      assert_equal nil, @cache.local['key1']
+      assert_equal nil, @cache.local['key2']
+      assert_equal 'value1', @cache.read('key1')
+      assert_equal 'value2', @cache.read('key2')
+    end
+
+    should "clear local" do
+      @cache.write('key1', 'value1')
+      @cache.clear_local
+
+      assert @cache.local.blank?
+    end
+
+  end
+end

data/test/database.yml

@@ -5,3 +5,5 @@ test:
   username: root
   password:
   socket: /tmp/mysql.sock
+
+

data/test/dirty_test.rb

@@ -3,13 +3,10 @@ require File.dirname(__FILE__) + '/helper'
 class DirtyTest < ActiveSupport::TestCase
   fixtures :blogs, :posts
 
-  Post.has_kasket
-  Post.kasket_dirty_methods :make_dirty!
-
   should "clear the indices when a dirty method is called" do
     post = Post.first
 
-    pots = Post.find(post.id)
+    Post.cache { pots = Post.find(post.id) }
     assert(Rails.cache.read(post.kasket_key))
 
     post.make_dirty!

data/test/find_one_test.rb

@@ -3,17 +3,24 @@ require File.dirname(__FILE__) + '/helper'
 class FindOneTest < ActiveSupport::TestCase
   fixtures :blogs, :posts
 
-  Post.has_kasket
-
   should "cache find(id) calls" do
     post = Post.first
-    assert_nil(Rails.cache.read(post.kasket_key))
+    Rails.cache.write(post.kasket_key, nil)
     assert_equal(post, Post.find(post.id))
     assert(Rails.cache.read(post.kasket_key))
     Post.connection.expects(:select_all).never
     assert_equal(post, Post.find(post.id))
   end
 
+  should "only cache on indexed attributes" do
+    Kasket.cache.expects(:read).twice
+    Post.find_by_id(1)
+    Post.find_by_id(1, :conditions => {:blog_id => 2})
+
+    Kasket.cache.expects(:read).never
+    Post.first :conditions => {:blog_id => 2}
+  end
+
   should "not use cache when using the :select option" do
     post = Post.first
     assert_nil(Rails.cache.read(post.kasket_key))

data/test/find_some_test.rb

@@ -3,10 +3,7 @@ require File.dirname(__FILE__) + '/helper'
 class FindSomeTest < ActiveSupport::TestCase
   fixtures :blogs, :posts
 
-  Post.has_kasket
-  Post.has_kasket_on :blog_id
-
-  should "cache find(id, id) calls" do
+  should_eventually "cache find(id, id) calls" do
     post1 = Post.first
     post2 = Post.last
 
@@ -17,32 +14,31 @@ class FindSomeTest < ActiveSupport::TestCase
 
     assert(Rails.cache.read(post1.kasket_key))
     assert(Rails.cache.read(post2.kasket_key))
-
     Post.connection.expects(:select_all).never
     Post.find(post1.id, post2.id)
   end
 
-  should "only lookup the records that are not in the cache" do
+  should_eventually "only lookup the records that are not in the cache" do
     post1 = Post.first
     post2 = Post.last
     assert_equal(post1, Post.find(post1.id))
     assert(Rails.cache.read(post1.kasket_key))
     assert_nil(Rails.cache.read(post2.kasket_key))
 
-    Post.expects(:find_some_without_kasket).with([post2.id], {}).returns([post2])
+    Post.expects(:find_by_sql_without_kasket).with("SELECT * FROM \'posts\' WHERE (\'posts\'.\'id\' IN (#{post1.id},#{post2.id})) ").returns([post2])
     found_posts = Post.find(post1.id, post2.id)
     assert_equal([post1, post2].map(&:id).sort, found_posts.map(&:id).sort)
 
-    Post.expects(:find_some_without_kasket).never
+    Post.expects(:find_by_sql_without_kasket).never
     found_posts = Post.find(post1.id, post2.id)
     assert_equal([post1, post2].map(&:id).sort, found_posts.map(&:id).sort)
   end
 
-  should "cache on index other than primary key" do
+  should_eventually "cache on index other than primary key" do
     blog = blogs(:a_blog)
     posts = Post.find_all_by_blog_id(blog.id)
 
-    Post.expects(:find_every_without_kasket).never
+    Post.expects(:find_by_sql_without_kasket).never
 
     assert_equal(posts, Post.find_all_by_blog_id(blog.id))
   end

data/test/helper.rb

@@ -56,10 +56,15 @@ class Post < ActiveRecord::Base
   belongs_to :blog
   has_many :comments
 
+  has_kasket
+  has_kasket_on :title
+  has_kasket_on :blog_id, :id
+
   def make_dirty!
     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
 
 class Blog < ActiveRecord::Base

data/test/parser_test.rb

@@ -0,0 +1,98 @@
+require File.dirname(__FILE__) + '/helper'
+require 'kasket/query_parser'
+
+class ParserTest < ActiveSupport::TestCase
+
+  context "Parsing" do
+    setup do
+      @parser = Kasket::QueryParser.new(Post)
+    end
+
+    should "extract conditions" do
+      assert_equal [[:color, "red"], [:size, "big"]], @parser.parse('SELECT * FROM `posts` WHERE (`posts`.`color` = red AND `posts`.`size` = big)')[:attributes]
+    end
+
+    should "extract required index" do
+      assert_equal [:color, :size], @parser.parse('SELECT * FROM `posts` WHERE (`posts`.`color` = red AND `posts`.`size` = big)')[:index]
+    end
+
+    should "only support queries against its model's table" do
+      assert !@parser.parse('SELECT * FROM `apples` WHERE (`users`.`id` = 2) ')
+    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')
+    end
+
+    should "support vaguely formatted queries" do
+      assert @parser.parse('SELECT * FROM "posts" WHERE (color = red AND size = big)')
+    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]
+      end
+
+    end
+
+    context "unsupported queries" do
+
+      should "include advanced limits" do
+        assert !@parser.parse('SELECT * FROM `posts` WHERE (color = red AND size = big) LIMIT 2')
+      end
+
+      should "include joins" do
+        assert !@parser.parse('SELECT * FROM `posts`, `trees` JOIN ON apple.tree_id = tree.id WHERE (color = red)')
+      end
+
+      should "include specific selects" do
+        assert !@parser.parse('SELECT id FROM `posts` WHERE (color = red)')
+      end
+
+      should "include offset" do
+        assert !@parser.parse('SELECT * FROM `posts` WHERE (color = red) LIMIT 1 OFFSET 2')
+      end
+
+      should "include order" do
+        assert !@parser.parse('SELECT * FROM `posts` WHERE (color = red) ORDER DESC')
+      end
+
+      should "include the OR operator" do
+        assert !@parser.parse('SELECT * FROM `posts` WHERE (color = red OR size = big) LIMIT 2')
+      end
+
+      should "include the IN operator" do
+        assert !@parser.parse('SELECT * FROM `posts` WHERE (id IN (1,2,3))')
+      end
+
+    end
+
+    context "key generation" do
+      should "include the table name and version" do
+        assert_match(/^kasket\/posts\/version=3558\//, @parser.parse('SELECT * FROM `posts` WHERE (id = 1)')[: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='world\\'s best title'$/, @parser.parse("SELECT * FROM `posts` WHERE (id = 1 AND title = 'world\\'s best title')")[:key])
+      end
+
+      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])
+        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])
+        end
+      end
+    end
+  end
+
+end

data/test/read_mixin_test.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ReadMixinTest < ActiveSupport::TestCase
+
+  context "find by sql with kasket" do
+    setup do
+      @database_results = [ { 'id' => 1, 'title' => 'Hello' }, { 'id' => 2, 'title' => 'World' } ]
+      @records = @database_results.map { |r| Post.send(:instantiate, r) }
+      Post.stubs(:find_by_sql_without_kasket).returns(@records)
+    end
+
+    should "handle unsupported sql" do
+      assert_equal @records, Post.find_by_sql_with_kasket('select unsupported sql statement')
+      assert Kasket.cache.local.empty?
+    end
+
+    should "read results" do
+      Kasket.cache.write('kasket/posts/version=3558/id=1', @database_results.first)
+      assert_equal [ @records.first ], Post.find_by_sql('SELECT * FROM `posts` WHERE (id = 1)'), Kasket.cache.inspect
+    end
+
+    should "store results in kasket" do
+      Post.find_by_sql('SELECT * FROM `posts` WHERE (id = 1)')
+
+      assert_equal @database_results.first, Kasket.cache.read('kasket/posts/version=3558/id=1'), Kasket.cache.inspect
+    end
+
+    context "modifying results" do
+      setup do
+        Kasket.cache.write('kasket/posts/version=3558/id=1', @database_results.first)
+        @record = Post.find_by_sql('SELECT * FROM `posts` WHERE (id = 1)').first
+        @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
+
+        assert_not_equal @record, same_record
+      end
+
+    end
+
+  end
+
+end

data/test/schema.rb

@@ -1,4 +1,4 @@
-# This file is auto-generated from the current state of the database. Instead of editing this file, 
+# This file is auto-generated from the current state of the database. Instead of editing this file,
 # please use the migrations feature of Active Record to incrementally modify your database, and
 # then regenerate this schema definition.
 #

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification 
 name: kasket
 version: !ruby/object:Gem::Version 
-  version: 0.5.5
+  version: 0.6.0
 platform: ruby
 authors: 
 - Mick Staugaard
+- Eric Chapweske
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-12-02 00:00:00 -08:00
+date: 2009-12-05 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-description: A rewrite of cache money
+description: put's a cap on your queries
 email: mick@staugaard.com
 executables: []
 
@@ -71,14 +72,15 @@ files:
 - lib/kasket.rb
 - lib/kasket/active_record_patches.rb
 - lib/kasket/cache.rb
-- lib/kasket/conditions_parser.rb
 - lib/kasket/configuration_mixin.rb
 - lib/kasket/dirty_mixin.rb
+- lib/kasket/query_parser.rb
 - lib/kasket/rack_middleware.rb
 - lib/kasket/read_mixin.rb
 - lib/kasket/reload_association_mixin.rb
 - lib/kasket/write_mixin.rb
 - test/cache_expiry_test.rb
+- test/cache_test.rb
 - test/database.yml
 - test/dirty_test.rb
 - test/find_one_test.rb
@@ -87,8 +89,9 @@ files:
 - test/fixtures/comments.yml
 - test/fixtures/posts.yml
 - test/helper.rb
+- test/parser_test.rb
+- test/read_mixin_test.rb
 - test/schema.rb
-- test/serialization_test.rb
 has_rdoc: true
 homepage: http://github.com/staugaard/kasket
 licenses: []
@@ -119,9 +122,11 @@ specification_version: 3
 summary: A write back caching layer on active record
 test_files: 
 - test/cache_expiry_test.rb
+- test/cache_test.rb
 - test/dirty_test.rb
 - test/find_one_test.rb
 - test/find_some_test.rb
 - test/helper.rb
+- test/parser_test.rb
+- test/read_mixin_test.rb
 - test/schema.rb
-- test/serialization_test.rb

data/lib/kasket/conditions_parser.rb

@@ -1,79 +0,0 @@
-module Kasket
-  class ConditionsParser
-    def initialize(model_class)
-      @model_class = model_class
-    end
-
-    def attribute_value_pairs(options)
-      #pulls out the conditions from each hash
-      condition_fragments = [options[:conditions]]
-
-      #add the scope to the mix
-      if scope = @model_class.send(:scope, :find)
-        condition_fragments << scope[:conditions]
-      end
-
-      #add the type if we are on STI
-      condition_fragments << {:type => @model_class.name} if @model_class.finder_needs_type_condition?
-
-      condition_fragments.compact!
-
-      #parses each conditions fragment but bails if one of the did not parse
-      attributes_fragments = condition_fragments.map do |condition_fragment|
-        attributes_fragment = attributes_for_conditions(condition_fragment)
-        return nil unless attributes_fragment
-        attributes_fragment
-      end
-
-      #merges the hashes but bails if there is an overlap
-      attributes = attributes_fragments.inject({}) do |memo, attributes_fragment|
-        attributes_fragment.each do |attribute, value|
-          return nil if memo.has_key?(attribute)
-          memo[attribute] = value
-        end
-        memo
-      end
-
-      attributes.keys.sort.map { |attribute| [attribute.to_sym, attributes[attribute]] }
-    end
-
-    def attributes_for_conditions(conditions)
-      pairs = case conditions
-        when Hash
-          return conditions.stringify_keys
-        when String
-          parse_indices_from_condition(conditions)
-        when Array
-          parse_indices_from_condition(*conditions)
-        when NilClass
-          []
-      end
-
-      return nil unless pairs
-
-      pairs.inject({}) do |memo, pair|
-        return nil if memo.has_key?(pair[0])
-        memo[pair[0]] = pair[1]
-        memo
-      end
-    end
-
-    AND = /\s+AND\s+/i
-    TABLE_AND_COLUMN = /(?:(?:`|")?(\w+)(?:`|")?\.)?(?:`|")?(\w+)(?:`|")?/ # Matches: `users`.id, `users`.`id`, users.id, id
-    VALUE = /'?(\d+|\?|(?:(?:[^']|'')*))'?/                     # Matches: 123, ?, '123', '12''3'
-    KEY_EQ_VALUE = /^[\(\s]*#{TABLE_AND_COLUMN}\s+=\s+#{VALUE}[\)\s]*$/ # Matches: KEY = VALUE, (KEY = VALUE), ()(KEY = VALUE))
-
-    def parse_indices_from_condition(conditions = '', *values)
-      values = values.dup
-      conditions.split(AND).inject([]) do |indices, condition|
-        matched, table_name, column_name, sql_value = *(KEY_EQ_VALUE.match(condition))
-        if matched
-          value = sql_value == '?' ? values.shift : @model_class.columns_hash[column_name].type_cast(sql_value)
-          indices << [column_name, value]
-        else
-          return nil
-        end
-      end
-    end
-  end
-end

data/test/serialization_test.rb

@@ -1,21 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class SerializationTest < ActiveSupport::TestCase
-  fixtures :blogs, :posts
-
-  Post.has_kasket
-
-  should "store a CachedModel" do
-    post = Post.first
-    post.store_in_kasket
-    assert_instance_of(Kasket::Cache::CachedModel, Rails.cache.read(post.kasket_key))
-  end
-
-  should "bring convert CachedModel to model instances" do
-    post = Post.first
-    post.store_in_kasket
-
-    post = Kasket.cache.read(post.kasket_key)
-    assert_instance_of(Post, post)
-  end
-end