aub-record_filter 0.1.1 → 0.1.2

data/VERSION.yml

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

data/lib/record_filter.rb

@@ -2,9 +2,11 @@ require 'rubygems'
 gem 'activerecord', '~> 2.2'
 require 'active_record'
 
-%w(active_record query table conjunctions restrictions filter join order dsl).each do |file|
+%w(active_record query table conjunctions restrictions filter join order group_by dsl).each do |file|
   require File.join(File.dirname(__FILE__), 'record_filter', file)
 end
 
 module RecordFilter
+  class AssociationNotFoundException < Exception; end
+  class ColumnNotFoundException < Exception; end
 end

data/lib/record_filter/conjunctions.rb

@@ -5,8 +5,8 @@ module RecordFilter
 
       def self.create_from(dsl_conjunction, table)
         result = case dsl_conjunction.type
-          when :any_of: AnyOf.new(table)
-          when :all_of: AllOf.new(table)
+          when :any_of then AnyOf.new(table)
+          when :all_of then AllOf.new(table)
         end
 
         dsl_conjunction.steps.each do |step|
@@ -22,6 +22,8 @@ module RecordFilter
             result.add_limit_and_offset(step.limit, step.offset)
           when DSL::Order
             result.add_order(step.column, step.direction)
+          when DSL::GroupBy
+            result.add_group_by(step.column)
           end
         end
         result
@@ -35,6 +37,7 @@ module RecordFilter
       end
 
       def add_restriction(column_name, operator, value, options={})
+        check_column_exists!(column_name)
         restriction_class = "RecordFilter::Restrictions::#{operator.to_s.camelize}".constantize
         restriction = restriction_class.new("#{@table_name}.#{column_name}", value, options)
         self << restriction
@@ -50,8 +53,12 @@ module RecordFilter
         @table.join_association(association_name)
       end
       
-      def add_order(column, direction)
-        @table.order_column(column, direction)
+      def add_order(column_name, direction)
+        @table.order_column(column_name, direction)
+      end
+
+      def add_group_by(column_name)
+        @table.group_by_column(column_name)
       end
 
       def add_limit_and_offset(limit, offset)
@@ -79,6 +86,14 @@ module RecordFilter
           end
         end
       end
+
+      protected
+
+      def check_column_exists!(column_name)
+        if (!@table.has_column(column_name))
+          raise ColumnNotFoundException.new("The column #{column_name} was not found in #{@table.table_name}.")
+        end
+      end
     end
 
     class AnyOf < Base

data/lib/record_filter/dsl.rb

@@ -1,4 +1,4 @@
-%w(conjunction conjunction_dsl dsl join limit order restriction).each { |file| require File.join(File.dirname(__FILE__), 'dsl', file) }
+%w(conjunction conjunction_dsl dsl group_by join limit order restriction).each { |file| require File.join(File.dirname(__FILE__), 'dsl', file) }
 
 module RecordFilter
   module DSL

data/lib/record_filter/dsl/conjunction.rb

@@ -42,6 +42,10 @@ module RecordFilter
       def add_order(column, direction)
         @steps << Order.new(column, direction)
       end
+
+      def add_group_by(column)
+        @steps << GroupBy.new(column)
+      end
     end
   end
 end

data/lib/record_filter/dsl/dsl.rb

@@ -37,6 +37,11 @@ module RecordFilter
         @conjunction.add_order(column, direction)
         nil
       end
+
+      def group_by(column)
+        @conjunction.add_group_by(column)
+        nil
+      end
     end
   end
 end

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

@@ -20,6 +20,8 @@ module RecordFilter
       alias_method :gte, :greater_than_or_equal_to
       alias_method :lt, :less_than
       alias_method :lte, :less_than_or_equal_to
+      alias_method :null, :is_null
+      alias_method :nil, :is_null
     end
   end
 end

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/order.rb

@@ -18,6 +18,10 @@ module RecordFilter
         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} #{dir}"
     end
   end

data/lib/record_filter/query.rb

@@ -10,8 +10,10 @@ module RecordFilter
       params = { :conditions => @conjunction.to_conditions }
       joins = @table.all_joins
       params[:joins] = joins.map { |join| join.to_sql } * ' ' unless joins.empty?
-      orders = @table.all_orders
+      orders = @table.orders
       params[:order] = orders.map { |order| order.to_sql } * ', ' unless orders.empty?
+      group_bys = @table.group_bys
+      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

data/lib/record_filter/table.rb

@@ -1,6 +1,6 @@
 module RecordFilter
   class Table
-    attr_reader :table_alias
+    attr_reader :table_alias, :orders, :group_bys
 
     def initialize(model_class, table_alias = nil)
       @model_class = model_class
@@ -9,6 +9,7 @@ module RecordFilter
       @joins_cache = {}
       @joins = []
       @orders = []
+      @group_bys = []
     end
 
     def table_name
@@ -19,6 +20,9 @@ module RecordFilter
       @joins_cache[association_name] ||=
         begin
           association = @model_class.reflect_on_association(association_name)
+          if association.nil?
+            raise AssociationNotFoundException.new("The association #{association_name} was not found on #{@model_class.name}.")
+          end
           case association.macro
           when :belongs_to, :has_many, :has_one
             simple_join(association)
@@ -39,11 +43,12 @@ module RecordFilter
       @orders << Order.new(column, direction, self)
     end
 
-    def all_orders
-      @orders + @joins.inject([]) do |child_orders, join|
-        child_orders.concat(join.right_table.all_orders)
-        child_orders
-      end
+    def group_by_column(column)
+      @group_bys << GroupBy.new(column, self)
+    end
+
+    def has_column(column_name)
+      @model_class.column_names.include?(column_name.to_s)
     end
 
     private
@@ -88,6 +93,7 @@ module RecordFilter
       @joins_cache = {}
       @joins = []
       @orders = []
+      @group_bys = []
     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

@@ -9,7 +9,7 @@ describe 'implicit joins' do
     describe 'with single condition inline' do
       before do
         Post.filter do
-          having(:blog).with :title, 'Test Title'
+          having(:blog).with :name, 'Test Name'
         end.inspect
       end
 
@@ -18,7 +18,7 @@ describe 'implicit joins' do
       end
 
       it 'should query against condition on join table' do
-        Post.last_find[:conditions].should == ['posts__blog.title = ?', 'Test Title']
+        Post.last_find[:conditions].should == ['posts__blog.name = ?', 'Test Name']
       end
     end
 
@@ -28,14 +28,14 @@ describe 'implicit joins' do
       end
 
       it 'should query against conditions on join table' do
-        Post.last_find[:conditions].should == [%q((posts__blog.title = ?) AND (posts__blog.published = ?)), 'Test Title', true]
+        Post.last_find[:conditions].should == [%q((posts__blog.name = ?) AND (posts__blog.published = ?)), 'Test Name', true]
       end
     end
 
     describe 'with multiple conditions on single join inline' do
       before do
         Post.filter do
-          having(:blog).with :title, 'Test Title'
+          having(:blog).with :name, 'Test Name'
           having(:blog).with :published, true
         end.inspect
       end
@@ -47,7 +47,7 @@ describe 'implicit joins' do
       before do
         Post.filter do
           having :blog do
-            with :title, 'Test Title'
+            with :name, 'Test Name'
             with :published, true
           end
         end.inspect
@@ -154,13 +154,13 @@ describe 'implicit joins' do
   describe 'with nil conditions' do
     before do
       Comment.filter do
-        with :content, nil
+        with :contents, nil
         with :offensive, true
       end.inspect
     end
 
     it 'should create the correct IS NULL condition' do
-      Comment.last_find[:conditions].should == [%q(("comments".content IS NULL) AND ("comments".offensive = ?)), true]
+      Comment.last_find[:conditions].should == [%q(("comments".contents IS NULL) AND ("comments".offensive = ?)), true]
     end
   end
 
@@ -179,13 +179,13 @@ describe 'implicit joins' do
   describe 'with negated nil conditions' do
     before do
       Comment.filter do
-        without :content, nil
+        without :contents, nil
         with :offensive, true
       end.inspect
     end
 
     it 'should create the correct IS NOT NULL condition' do
-      Comment.last_find[:conditions].should == [%q(("comments".content IS NOT NULL) AND ("comments".offensive = ?)), true]
+      Comment.last_find[:conditions].should == [%q(("comments".contents IS NOT NULL) AND ("comments".offensive = ?)), true]
     end
   end
 end

data/spec/limits_and_ordering_spec.rb

@@ -161,4 +161,30 @@ describe 'filter qualifiers' do
       end
     end
   end
+
+  describe 'group_by' do
+    it 'should add the group for a simple column' do
+      Post.filter do
+        group_by(:created_at)
+      end.inspect
+      Post.last_find[:group].should == %q("posts".created_at)
+    end
+
+    it 'should add the group for multiple column' do
+      Post.filter do
+        group_by(:created_at)
+        group_by(:published)
+      end.inspect
+      Post.last_find[:group].should == %q("posts".created_at, "posts".published)
+    end
+
+    it 'should add the group for joined columns' do
+      Post.filter do
+        having(:photo)
+        group_by(:created_at)
+        group_by(:photo => :format)
+      end.inspect
+      Post.last_find[:group].should == %q("posts".created_at, "photos".format)
+    end
+  end
 end

data/spec/restrictions_spec.rb

@@ -75,4 +75,13 @@ describe 'RecordFilter restrictions' do
     Post.last_find.should == { :conditions => [%q{(("posts".blog_id = ?) AND ("posts".permalink = ?)) OR ("posts".permalink = ?)},
                                                1, 'my-post', 'another-post'] }
   end
+
+  it 'should filter for nil' do
+    [:is_null, :null, :nil].each do |method|
+      Post.filter do
+        with(:permalink).send(method)
+      end.inspect
+      Post.last_find.should == { :conditions => [%q("posts".permalink IS NULL)] }
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aub-record_filter
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Mat Brown
@@ -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