aub-record_filter 0.9.5 → 0.9.6

data/README.rdoc

@@ -141,6 +141,7 @@ object that has methods to specify a number of different conditions and to negat
   with(:permalink, nil)                    # ['permalink IS NULL']
   with(:permalink).is_null                 # ['permalink IS NULL']
   with(:permalink, nil).not                # ['permalink IS NOT NULL']
+  with(:permalink).is_not_null             # ['permalink IS NOT NULL']
 
 The following condition types are supported through the Restriction API:
 
@@ -164,10 +165,22 @@ for more details on how to use them.
 
   with(:id).in([1, 2, 3])                    # ['id in (?)', [1, 2, 3]]
 
+  with(:id).not_in([4, 5, 6])                # ['id NOT IN (?)', [4, 5, 6]]
+
   with(:content).like('%easy%')              # ['content LIKE ?', '%easy%']
 
   with(:content).not.like('%hard%')          # ['content NOT LIKE ?', '%hard%']
 
+The comparison operators (greater_than, less_than, greater_than_or_equal_to and less_than_or_equal_to)
+are aliased to their short forms (gt, lt, gte and lte).
+
+It is also possible to specify multiple conditions on a single line using the 'and' and 'or' methods,
+eliminating the need to use a conjunction block in many common cases.
+
+  with(:expired_at).gt(Time.now).or.is_null  # ['expired_at > ? OR expired_at IS NULL', Time.now]
+
+  with(:id).gt(100).and.lt(1000)             # ['id > ? AND id < ?', 100, 1000]
+
 === Boolean Operations
 
 Conditions can be combined with boolean operators using the methods all_of, any_of, none_of

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 9
-:patch: 5
+:patch: 6

data/lib/record_filter/column_parser.rb

@@ -5,7 +5,7 @@ module RecordFilter
 
     def parse_column_in_table(column, table)
       while column.is_a?(Hash)
-        table = table.join_association(column.keys[0]).right_table
+        table = table.find_join!(column.keys[0]).right_table
         column = column.values[0]
       end
       [column, table]

data/lib/record_filter/query.rb

@@ -27,6 +27,7 @@ module RecordFilter
         params[:group] = group_bys.map { |group_by| group_by.to_sql } * ', ' unless group_bys.empty?
         params[:limit] = @conjunction.limit if @conjunction.limit
         params[:offset] = @conjunction.offset if @conjunction.offset
+        params[:readonly] = false
         params
       end
     end

data/lib/record_filter/restrictions.rb

@@ -41,25 +41,25 @@ module RecordFilter
 
     class LessThan < Base
       def to_positive_sql
-        "#{@column_name} < ?"
+        "#{@column_name} < #{@value.nil? ? 'NULL' : '?'}"
       end
     end
 
     class LessThanOrEqualTo < Base
       def to_positive_sql
-        "#{@column_name} <= ?"
+        "#{@column_name} <= #{@value.nil? ? 'NULL' : '?'}"
       end
     end
 
     class GreaterThan < Base
       def to_positive_sql
-        "#{@column_name} > ?"
+        "#{@column_name} > #{@value.nil? ? 'NULL' : '?'}"
       end
     end
 
     class GreaterThanOrEqualTo < Base
       def to_positive_sql
-        "#{@column_name} >= ?"
+        "#{@column_name} >= #{@value.nil? ? 'NULL' : '?'}"
       end
     end
 

data/lib/record_filter/table.rb

@@ -56,6 +56,16 @@ module RecordFilter
         end
     end
 
+    def find_join(join_key)
+      @joins_cache[join_key]
+    end
+
+    def find_join!(join_key)
+      join = find_join(join_key)
+      raise InvalidJoinException.new("The join #{join_key} was not found.") unless join
+      join
+    end
+
     def all_joins
       @joins + @joins.inject([]) do |child_joins, join|
         child_joins.concat(join.right_table.all_joins)
@@ -124,7 +134,7 @@ module RecordFilter
     def alias_for_association(association)
       @alias_cache ||= {} 
       @alias_cache[association.name] ||= 
-        "#{@aliased ? @table_alias.to_s : @model_class.table_name}__#{association.name.to_s.downcase}"
+        "#{@aliased ? @table_alias.to_s : @model_class.table_name}__#{association.name.to_s.underscore}"
     end
 
     alias_method :alias_for_class, :alias_for_association

data/lib/record_filter.rb

@@ -26,7 +26,8 @@ module RecordFilter
   # already exists in the class it is created on or one of its superclasses.
   class InvalidFilterNameException < StandardError; end
 
-  # An exception that is raised when no columns are privided to specify an explicit join. 
+  # An exception that is raised when no columns are privided to specify an explicit join
+  # or when the join names are incorrect.
   class InvalidJoinException < StandardError; end
 
   # An exception raised in the case where a named filter is called from within a filter

data/spec/exception_spec.rb

@@ -55,7 +55,7 @@ describe 'raising exceptions' do
         Post.filter do
           order({ :this_is_not_there => :eh }, :asc)
         end.inspect
-      }.should raise_error(RecordFilter::AssociationNotFoundException)
+      }.should raise_error(RecordFilter::InvalidJoinException)
     end
 
     it 'should raise ColumnNotFoundException for explicit joins on bad column names for the right table' do

data/spec/limits_and_ordering_spec.rb

@@ -164,6 +164,22 @@ describe 'filter qualifiers' do
       end
     end
 
+    describe 'with explicit joins' do
+      before do
+        Post.filter do
+          with(:published, false)
+          join(Comment, :inner) do
+            on(:id => :post_id)
+          end
+          order(Comment => :id)
+        end.inspect
+      end
+
+      it 'should create the correct order params' do
+        Post.last_find[:order].should == %q(posts__comment.id ASC)
+      end
+    end
+
     describe 'with the order supplied as a string' do
       before do
         Post.filter do

data/spec/named_filter_spec.rb

@@ -258,7 +258,7 @@ describe 'named filters' do
     it 'should have an empty conditions hash' do
       blog = Class.new(Blog)
       blog.named_filter(:ordered_by_id) { order(:id, :desc) }
-      blog.ordered_by_id.proxy_options.should == { :order => %q("blogs".id DESC) }
+      blog.ordered_by_id.proxy_options.should == { :readonly => false, :order => %q("blogs".id DESC) }
     end
   end
 end

data/spec/restrictions_spec.rb

@@ -9,7 +9,7 @@ describe 'RecordFilter restrictions' do
     Post.filter do
       with :permalink, 'blog-post'
     end.inspect
-    Post.last_find.should == { :conditions => [%q{"posts".permalink = ?}, 'blog-post'] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q{"posts".permalink = ?}, 'blog-post'] }
   end
 
   it 'should filter for equality with multiple conditions' do
@@ -17,7 +17,7 @@ describe 'RecordFilter restrictions' do
       with :permalink, 'blog-post'
       with :blog_id, 3
     end.inspect
-    Post.last_find.should == { :conditions => [%q{("posts".permalink = ?) AND ("posts".blog_id = ?)}, 'blog-post', 3] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q{("posts".permalink = ?) AND ("posts".blog_id = ?)}, 'blog-post', 3] }
   end
 
   it 'should filter by comparison operators' do
@@ -26,17 +26,22 @@ describe 'RecordFilter restrictions' do
        Post.filter do
          with(:created_at).send(set[0], Time.parse('2009-01-03 23:02:00'))
        end.inspect
-       Post.last_find.should == { :conditions => ["\"posts\".created_at #{set[2]} ?", Time.parse('2009-01-03 23:02:00')] }
+       Post.last_find.should == { :readonly => false, :conditions => ["\"posts\".created_at #{set[2]} ?", Time.parse('2009-01-03 23:02:00')] }
+
+       Post.filter do
+         with(:id).send(set[0], nil)
+       end.inspect
+       Post.last_find.should == { :readonly => false, :conditions => ["\"posts\".id #{set[2]} NULL"] }
 
        Post.filter do
          with(:created_at).send(set[1], Time.parse('2009-01-03 23:02:00'))
        end.inspect
-       Post.last_find.should == { :conditions => ["\"posts\".created_at #{set[2]} ?", Time.parse('2009-01-03 23:02:00')] }
+       Post.last_find.should == { :readonly => false, :conditions => ["\"posts\".created_at #{set[2]} ?", Time.parse('2009-01-03 23:02:00')] }
 
        Post.filter do
          with(:created_at).not.send(set[0], Time.parse('2009-02-02 02:22:22'))
        end.inspect
-       Post.last_find.should == { :conditions => ["NOT (\"posts\".created_at #{set[2]} ?)", Time.parse('2009-02-02 02:22:22')] }
+       Post.last_find.should == { :readonly => false, :conditions => ["NOT (\"posts\".created_at #{set[2]} ?)", Time.parse('2009-02-02 02:22:22')] }
      end
   end
 
@@ -44,70 +49,70 @@ describe 'RecordFilter restrictions' do
     Post.filter do
       with(:blog_id).equal_to(nil)
     end.inspect
-    Post.last_find.should == { :conditions => [%q("posts".blog_id IS NULL)] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".blog_id IS NULL)] }
   end
 
   it 'should filter for in' do
     Post.filter do
       with(:blog_id).in [1, 3, 5]
     end.inspect
-    Post.last_find.should == { :conditions => [%q{"posts".blog_id IN (?)}, [1, 3, 5]] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q{"posts".blog_id IN (?)}, [1, 3, 5]] }
   end
 
   it 'should negate IN filters correctly' do
     Post.filter do
       with(:blog_id).not.in [1, 3, 5]
     end.inspect
-    Post.last_find.should == { :conditions => [%q{"posts".blog_id NOT IN (?)}, [1, 3, 5]] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q{"posts".blog_id NOT IN (?)}, [1, 3, 5]] }
   end
 
   it 'should work correctly for NOT IN' do
     Post.filter do
       with(:blog_id).not_in [1, 3, 5]
     end.inspect
-    Post.last_find.should == { :conditions => [%q{"posts".blog_id NOT IN (?)}, [1, 3, 5]] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q{"posts".blog_id NOT IN (?)}, [1, 3, 5]] }
   end
 
   it 'should do the right thing for IN filters with empty arrays' do
     Post.filter do
       with(:blog_id).in([])
     end.inspect
-    Post.last_find.should == { :conditions => [%q("posts".blog_id IN (?)), []] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".blog_id IN (?)), []] }
   end
 
   it 'should do the right thing for IN filters with single values' do
     Post.filter do
       with(:blog_id).in(1)
     end.inspect
-    Post.last_find.should == { :conditions => [%q("posts".blog_id IN (?)), 1] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".blog_id IN (?)), 1] }
   end
 
   it 'should do the right thing for IN filters with nil' do
     Post.filter do
       with(:blog_id).in(nil)
     end.inspect
-    Post.last_find.should == { :conditions => [%q("posts".blog_id IN (?)), nil] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".blog_id IN (?)), nil] }
   end
 
   it 'should do the right thing for IN filters with a range' do
     Post.filter do
       with(:blog_id).in(1..5)
     end.inspect
-    Post.last_find.should == { :conditions => [%q("posts".blog_id IN (?)), 1..5] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".blog_id IN (?)), 1..5] }
   end
 
   it 'should negate is_not_null conditions correctly' do
     Post.filter do
       with(:blog_id).is_not_null.not
     end.inspect
-    Post.last_find.should == { :conditions => [%q("posts".blog_id IS NULL)] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".blog_id IS NULL)] }
   end 
   
   it 'should double-negate correctly' do
     Post.filter do
       with(:blog_id, 3).not.not
     end.inspect
-    Post.last_find.should == { :conditions => [%q("posts".blog_id = ?), 3] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".blog_id = ?), 3] }
   end
 
   it 'should filter for between' do
@@ -116,21 +121,21 @@ describe 'RecordFilter restrictions' do
     Post.filter do
       with(:created_at).between time1..time2
     end.inspect
-    Post.last_find.should == { :conditions => [%q{"posts".created_at BETWEEN ? AND ?}, time1, time2] }
+    Post.last_find.should == { :readonly => false, :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] }
+    Post.last_find.should == { :readonly => false, :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] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".id BETWEEN ? AND ?), 2, 6] }
   end
 
   it 'should filter by none_of' do
@@ -140,7 +145,7 @@ describe 'RecordFilter restrictions' do
         with(:permalink, 'eek')
       end
     end.inspect
-    Post.last_find.should == { :conditions => [%q{NOT (("posts".blog_id = ?) OR ("posts".permalink = ?))}, 1, 'eek'] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q{NOT (("posts".blog_id = ?) OR ("posts".permalink = ?))}, 1, 'eek'] }
   end
 
   it 'should filter by not_all_of' do
@@ -150,7 +155,7 @@ describe 'RecordFilter restrictions' do
         with(:permalink, 'eek')
       end
     end.inspect
-    Post.last_find.should == { :conditions => [%q{NOT (("posts".blog_id = ?) AND ("posts".permalink = ?))}, 1, 'eek'] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q{NOT (("posts".blog_id = ?) AND ("posts".permalink = ?))}, 1, 'eek'] }
   end
 
   it 'should filter by disjunction' do
@@ -160,7 +165,7 @@ describe 'RecordFilter restrictions' do
         with(:permalink).equal_to 'my-post'
       end
     end.inspect
-    Post.last_find.should == { :conditions => [%q{("posts".blog_id = ?) OR ("posts".permalink = ?)}, 1, 'my-post'] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q{("posts".blog_id = ?) OR ("posts".permalink = ?)}, 1, 'my-post'] }
   end
 
   it 'should filter by disjunction composed of conjunction' do
@@ -174,8 +179,8 @@ describe 'RecordFilter restrictions' do
       end
     end.inspect
 
-    Post.last_find.should == { :conditions => [%q{(("posts".blog_id = ?) AND ("posts".permalink = ?)) OR ("posts".permalink = ?)},
-                                               1, 'my-post', 'another-post'] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q{(("posts".blog_id = ?) AND ("posts".permalink = ?)) OR ("posts".permalink = ?)},
+                                                                  1, 'my-post', 'another-post'] }
   end
 
   it 'should filter for nil' do
@@ -183,7 +188,7 @@ describe 'RecordFilter restrictions' do
       Post.filter do
         with(:permalink).send(method)
       end.inspect
-      Post.last_find.should == { :conditions => [%q("posts".permalink IS NULL)] }
+      Post.last_find.should == { :readonly => false, :conditions => [%q("posts".permalink IS NULL)] }
     end
   end
 
@@ -191,48 +196,48 @@ describe 'RecordFilter restrictions' do
     Post.filter do
       with(:permalink).is_not_null
     end.inspect
-    Post.last_find.should == { :conditions => [%q("posts".permalink IS NOT NULL)] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".permalink IS NOT NULL)] }
   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%'] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".permalink LIKE ?), '%piglets%'] }
   end
 
   it 'should support NOT LIKE' do
     Post.filter do
       with(:permalink).not.like('%ostriches%')
     end.inspect
-    Post.last_find.should == { :conditions => [%q("posts".permalink NOT LIKE ?), '%ostriches%'] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".permalink NOT LIKE ?), '%ostriches%'] }
   end
 
   it 'should provide access to the filter class in the filter' do
     Post.filter do
       with(:permalink).not.equal_to(filter_class.name)
     end.inspect
-    Post.last_find.should == { :conditions => [%q("posts".permalink <> ?), 'Post'] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q("posts".permalink <> ?), 'Post'] }
   end
 
   it 'should work correctly for one-line ORs with is_null' do
     Post.filter do
       with(:permalink, 'abc').or.is_null
     end.inspect
-    Post.last_find.should == { :conditions => [%q(("posts".permalink = ?) OR ("posts".permalink IS NULL)), 'abc'] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q(("posts".permalink = ?) OR ("posts".permalink IS NULL)), 'abc'] }
   end
 
   it 'should work correctly for one-line ANDs with is_null' do
     Post.filter do
       with(:id).gt(56).and.lt(200)
     end.inspect
-    Post.last_find.should == { :conditions => [%q(("posts".id > ?) AND ("posts".id < ?)), 56, 200] }
+    Post.last_find.should == { :readonly => false, :conditions => [%q(("posts".id > ?) AND ("posts".id < ?)), 56, 200] }
   end
 
   it 'should work properly with multiple one-line conjunctions' do
     Post.filter do
       with(:id).gt(56).and.lt(200).or.gt(500).or.lt(15)
     end.inspect
-    Post.last_find.should == { :conditions => [%q(("posts".id > ?) AND (("posts".id < ?) OR (("posts".id > ?) OR ("posts".id < ?)))), 56, 200, 500, 15] } 
+    Post.last_find.should == { :readonly => false, :conditions => [%q(("posts".id > ?) AND (("posts".id < ?) OR (("posts".id > ?) OR ("posts".id < ?)))), 56, 200, 500, 15] } 
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aub-record_filter
 version: !ruby/object:Gem::Version 
-  version: 0.9.5
+  version: 0.9.6
 platform: ruby
 authors: 
 - Aubrey Holland
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-11 00:00:00 -07:00
+date: 2009-05-13 00:00:00 -07:00
 default_executable: 
 dependencies: []