outoftime-record_filter 0.1.1 → 0.1.3

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 1
-:patch: 1
+:patch: 3

data/lib/record_filter/active_record.rb

@@ -7,6 +7,8 @@ module RecordFilter
       end
 
       def named_filter(name, &block)
+        return if named_filters.include?(name.to_sym)
+        named_filters << name.to_sym 
         DSL::DSL::subclass(self).module_eval do
           define_method(name, &block)
         end
@@ -17,6 +19,10 @@ module RecordFilter
           end
         end
       end
+
+      def named_filters
+        read_inheritable_attribute(:named_filters) || write_inheritable_attribute(:named_filters, [])
+      end
     end
   end
 end

data/lib/record_filter/conjunctions.rb

@@ -7,6 +7,8 @@ module RecordFilter
         result = case dsl_conjunction.type
           when :any_of then AnyOf.new(table)
           when :all_of then AllOf.new(table)
+          when :none_of then NoneOf.new(table)
+          when :not_all_of then NotAllOf.new(table)
         end
 
         dsl_conjunction.steps.each do |step|
@@ -50,7 +52,13 @@ module RecordFilter
       end
 
       def add_join_on_association(association_name)
-        @table.join_association(association_name)
+        table = @table
+        while association_name.is_a?(Hash)
+          result = table.join_association(association_name.keys[0])
+          table = result.right_table
+          association_name = association_name.values[0]
+        end
+        table.join_association(association_name)
       end
       
       def add_order(column_name, direction)
@@ -70,21 +78,25 @@ module RecordFilter
       end
 
       def to_conditions
-        if @restrictions.empty?
-          nil
-        elsif @restrictions.length == 1
-          @restrictions.first.to_conditions
-        else
-          @restrictions.map do |restriction|
-            conditions = restriction.to_conditions
-            conditions[0] = "(#{conditions[0]})"
-            conditions
-          end.inject do |conditions, new_conditions|
-            conditions.first << " #{conjunctor} #{new_conditions.shift}"
-            conditions.concat(new_conditions)
-            conditions
+        result = begin
+          if @restrictions.empty?
+            nil
+          elsif @restrictions.length == 1
+            @restrictions.first.to_conditions
+          else
+            @restrictions.map do |restriction|
+              conditions = restriction.to_conditions
+              conditions[0] = "(#{conditions[0]})"
+              conditions
+            end.inject do |conditions, new_conditions|
+              conditions.first << " #{conjunctor} #{new_conditions.shift}"
+              conditions.concat(new_conditions)
+              conditions
+            end
           end
         end
+        result[0] = "!(#{result[0]})" if (negated && !result.nil? && !result[0].nil?)
+        result
       end
 
       protected
@@ -97,15 +109,23 @@ module RecordFilter
     end
 
     class AnyOf < Base
-      def conjunctor
-        'OR'
-      end
+      def conjunctor; 'OR'; end
+      def negated; false; end
     end
 
     class AllOf < Base
-      def conjunctor
-        'AND'
-      end
+      def conjunctor; 'AND'; end
+      def negated; false; end
+    end
+
+    class NoneOf < Base
+      def conjunctor; 'OR'; end
+      def negated; true; end
+    end
+
+    class NotAllOf < Base
+      def conjunctor; 'AND'; end
+      def negated; true; end
     end
   end
 end

data/lib/record_filter/dsl/conjunction_dsl.rb

@@ -30,6 +30,16 @@ module RecordFilter
         nil
       end
 
+      def none_of(&block)
+        @conjunction.add_conjunction(:none_of, &block)
+        nil
+      end
+
+      def not_all_of(&block)
+        @conjunction.add_conjunction(:not_all_of, &block)
+        nil
+      end
+
       # join
       def having(association, &block)
         join = @conjunction.add_join(association, &block)

data/lib/record_filter/dsl/group_by.rb

@@ -0,0 +1,11 @@
+module RecordFilter
+  module DSL
+    class GroupBy
+      attr_reader :column
+
+      def initialize(column)
+        @column = column
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/restriction.rb

@@ -8,7 +8,7 @@ module RecordFilter
         @column, @negated, @operator = column, negated, nil
       end
 
-      [:equal_to, :is_null, :less_than, :less_than_or_equal_to, :greater_than, :greater_than_or_equal_to, :in, :between].each do |operator|
+      [:equal_to, :is_null, :less_than, :less_than_or_equal_to, :greater_than, :greater_than_or_equal_to, :in, :like].each do |operator|
         define_method(operator) do |*args|
           @value = args[0] 
           @operator = operator
@@ -16,6 +16,16 @@ module RecordFilter
         end
       end
 
+      # Between can take either a tuple of [start, finish], a range, or two values.
+      def between(start, finish=nil)
+        @operator = :between
+        if !finish.nil?
+          @value = [start, finish]
+        else
+          @value = start
+        end
+      end
+
       alias_method :gt, :greater_than
       alias_method :gte, :greater_than_or_equal_to
       alias_method :lt, :less_than

data/lib/record_filter/filter.rb

@@ -17,7 +17,7 @@ module RecordFilter
     end
 
     def method_missing(method, *args, &block)
-      if @clazz.respond_to?(method) # UGLY, we need to only pass through things that are named filters.
+      if @clazz.named_filters.include?(method)
         Filter.new(@clazz, method, @dsl.conjunction, *args)
       else
         loaded_data.send(method, *args, &block)

data/lib/record_filter/group_by.rb

@@ -0,0 +1,23 @@
+module RecordFilter
+  class GroupBy
+    attr_reader :column, :table
+
+    def initialize(column, table)
+      @column, @table = column, table
+    end
+
+    def to_sql
+      table, column = @table, @column
+      while column.is_a?(Hash)
+        table = table.join_association(column.keys[0]).right_table
+        column = column.values[0]
+      end
+
+      if (!table.has_column(column))
+        raise ColumnNotFoundException.new("The column #{column} was not found in #{table.table_name}.")
+      end
+
+      "#{table.table_name}.#{column}"
+    end
+  end
+end

data/lib/record_filter/restrictions.rb

@@ -3,6 +3,7 @@ module RecordFilter
     class Base
       def initialize(column_name, value, options={})
         @column_name, @value, @negated = column_name, value, !!options.delete(:negated)
+        @value = @value.id if @value.kind_of?(ActiveRecord::Base)
       end
 
       def to_conditions
@@ -77,5 +78,15 @@ module RecordFilter
         ["#{@column_name} #{'NOT ' if @negated}BETWEEN ? AND ?", @value.first, @value.last]
       end
     end
+
+    class Like < Base
+      def to_positive_sql
+        "#{@column_name} LIKE ?"
+      end
+
+      def to_negative_sql
+        "#{@column_name} NOT LIKE ?"
+      end
+    end
   end
 end

data/spec/exception_spec.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'raising exceptions' do
+  
+  describe 'on missing associations' do
+    it 'should get AssociationNotFoundException' do
+      lambda {
+        Post.filter do
+          having(:something_that_does_not_exist) do
+            with(:something_bad)
+          end
+        end.inspect
+      }.should raise_error(RecordFilter::AssociationNotFoundException)
+    end
+  end
+
+  describe 'on missing columns' do
+    it 'should get ColumnNotFoundException for with' do
+      lambda {
+        Post.filter do
+          with(:this_is_not_there, 2)
+        end.inspect
+      }.should raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should get ColumnNotFoundException for without' do
+      lambda {
+        Post.filter do
+          without(:this_is_not_there, 2)
+        end.inspect
+      }.should raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should get ColumnNotFoundException for order' do
+      lambda {
+        Post.filter do
+          order(:this_is_not_there, :asc)
+        end.inspect
+      }.should raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should get AssociationNotFoundException for orders on bad associations' do
+      lambda {
+        Post.filter do
+          order({ :this_is_not_there => :eh }, :asc)
+        end.inspect
+      }.should raise_error(RecordFilter::AssociationNotFoundException)
+    end
+  end
+end

data/spec/implicit_join_spec.rb

@@ -93,6 +93,25 @@ describe 'implicit joins' do
     end
   end
 
+  describe 'with one having statement expressing multiple joins' do
+    before do
+      Blog.filter do
+        having(:posts => :comments) do
+          with :offensive, true
+        end
+      end.inspect
+    end
+
+    it 'should add both joins' do
+      Blog.last_find[:joins].should == %q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id ) +
+                                       %q(INNER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id)
+    end
+
+    it 'should query against both conditions' do
+      Blog.last_find[:conditions].should == [%q(blogs__posts__comments.offensive = ?), true] 
+    end
+  end
+
   describe 'on has_one' do
     before do
       Post.filter do

data/spec/named_filter_spec.rb

@@ -54,8 +54,22 @@ describe 'named filters' do
     end
   end
 
+  describe 'taking active_record objects as arguments' do
+    it 'should use the id of the object as the actual parameter' do
+      Post.named_filter(:with_ar_arg) do |blog|
+        with(:blog_id, blog)
+      end
+      blog = Blog.create
+      Post.with_ar_arg(blog).inspect
+      Post.last_find[:conditions].should == [%q("posts".blog_id = ?), blog.id]
+    end
+  end
+
   describe 'using filters in subclasses' do
     before do
+      Comment.named_filter(:with_contents) do |*args|
+        with :contents, args[0]
+      end
       class NiceComment < Comment
         extend TestModel
 
@@ -63,9 +77,6 @@ describe 'named filters' do
           with :offensive, true
         end
       end
-      Comment.named_filter(:with_contents) do |*args|
-        with :contents, args[0]
-      end
     end
 
     it 'should execute the parent class filters correctly' do
@@ -81,17 +92,19 @@ describe 'named filters' do
       NiceComment.offensive.with_contents('something').inspect
       NiceComment.last_find[:conditions].should == [%q(("comments".offensive = ?) AND ("comments".contents = ?)), true, 'something']
     end
+
+    it 'should provide access to the named filters' do
+      Comment.named_filters.should == [:with_contents]
+      NiceComment.named_filters.sort_by { |i| i.to_s }.should == [:offensive, :with_contents]
+    end
   end
 
   describe 'using compound filters' do
-    before do
+    it 'should concatenate the filters correctly' do
+      pending 'nested chaining'
       Post.named_filter(:with_offensive_comments) do
         having(:comments).offensive(true)
       end
-    end
-
-    it 'should concatenate the filters correctly' do
-      pending 'nested chaining'
       Post.with_offensive_comments.inspect
       Post.last_find[:conditions].should == [%q(posts__comments.offensive = ?), true] 
       Post.last_find[:joins].should == %q(INNER JOIN "comments" AS posts__comments ON "comments".post_id = posts__blog.id)

data/spec/restrictions_spec.rb

@@ -51,6 +51,40 @@ describe 'RecordFilter restrictions' do
     Post.last_find.should == { :conditions => [%q{"posts".created_at BETWEEN ? AND ?}, time1, time2] }
   end
 
+  it 'should filter for between with two arguments passed' do
+    Post.filter do
+      with(:id).between(1, 5)
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".id BETWEEN ? AND ?), 1, 5] }
+  end
+
+  it 'should filter for between with an array passed' do
+    Post.filter do
+      with(:id).between([2, 6])
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".id BETWEEN ? AND ?), 2, 6] }
+  end
+
+  it 'should filter by none_of' do
+    Post.filter do
+      none_of do
+        with(:blog_id, 1)
+        with(:permalink, 'eek')
+      end
+    end.inspect
+    Post.last_find.should == { :conditions => [%q{!(("posts".blog_id = ?) OR ("posts".permalink = ?))}, 1, 'eek'] }
+  end
+
+  it 'should filter by not_all_of' do
+    Post.filter do
+      not_all_of do
+        with(:blog_id, 1)
+        with(:permalink, 'eek')
+      end
+    end.inspect
+    Post.last_find.should == { :conditions => [%q{!(("posts".blog_id = ?) AND ("posts".permalink = ?))}, 1, 'eek'] }
+  end
+
   it 'should filter by disjunction' do
     Post.filter do
       any_of do
@@ -84,4 +118,18 @@ describe 'RecordFilter restrictions' do
       Post.last_find.should == { :conditions => [%q("posts".permalink IS NULL)] }
     end
   end
+
+  it 'should support like' do
+    Post.filter do
+      with(:permalink).like('%piglets%')
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".permalink LIKE ?), '%piglets%'] }
+  end
+
+  it 'should support NOT LIKE' do
+    Post.filter do
+      without(:permalink).like('%ostriches%')
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".permalink NOT LIKE ?), '%ostriches%'] }
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: outoftime-record_filter
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors: 
 - Mat Brown
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-17 00:00:00 -07:00
+date: 2009-04-20 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -32,17 +32,20 @@ files:
 - lib/record_filter/dsl/conjunction.rb
 - lib/record_filter/dsl/conjunction_dsl.rb
 - lib/record_filter/dsl/dsl.rb
+- lib/record_filter/dsl/group_by.rb
 - lib/record_filter/dsl/join.rb
 - lib/record_filter/dsl/limit.rb
 - lib/record_filter/dsl/order.rb
 - lib/record_filter/dsl/restriction.rb
 - lib/record_filter/filter.rb
+- lib/record_filter/group_by.rb
 - lib/record_filter/join.rb
 - lib/record_filter/join_table.rb
 - lib/record_filter/order.rb
 - lib/record_filter/query.rb
 - lib/record_filter/restrictions.rb
 - lib/record_filter/table.rb
+- spec/exception_spec.rb
 - spec/implicit_join_spec.rb
 - spec/limits_and_ordering_spec.rb
 - spec/models/blog.rb
@@ -81,6 +84,7 @@ signing_key:
 specification_version: 3
 summary: Pure-ruby criteria API for building complex queries in ActiveRecord
 test_files: 
+- spec/exception_spec.rb
 - spec/implicit_join_spec.rb
 - spec/limits_and_ordering_spec.rb
 - spec/models/blog.rb