ransack 0.3.0 → 0.4.0

data/lib/ransack/adapters/active_record.rb

@@ -1,18 +1,17 @@
+require 'ransack/adapters/active_record/base'
+ActiveRecord::Base.extend Ransack::Adapters::ActiveRecord::Base
+
 case ActiveRecord::VERSION::STRING
 when /^3\.0\./
-  require 'ransack/adapters/active_record/3.0/base'
   require 'ransack/adapters/active_record/3.0/join_dependency'
   require 'ransack/adapters/active_record/3.0/join_association'
   require 'ransack/adapters/active_record/3.0/context'
 
-  ActiveRecord::Base.extend Ransack::Adapters::ActiveRecord::Base
   ActiveRecord::Associations::ClassMethods::JoinDependency.send :include, Ransack::Adapters::ActiveRecord::JoinDependency
 else
-  require 'ransack/adapters/active_record/base'
   require 'ransack/adapters/active_record/join_dependency'
   require 'ransack/adapters/active_record/join_association'
   require 'ransack/adapters/active_record/context'
 
-  ActiveRecord::Base.extend Ransack::Adapters::ActiveRecord::Base
   ActiveRecord::Associations::JoinDependency.send :include, Ransack::Adapters::ActiveRecord::JoinDependency
 end

data/lib/ransack/adapters/active_record/3.0/compat.rb

@@ -20,4 +20,147 @@ class ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase
                                 :engine  => active_record.arel_engine,
                                 :columns => active_record.columns)
   end
+end
+
+module Arel
+
+  class Table
+    alias :table_name :name
+
+    def [] name
+      ::Arel::Attribute.new self, name.to_sym
+    end
+  end
+
+  module Nodes
+    class Node
+      def not
+        Nodes::Not.new self
+      end
+    end
+
+    remove_const :And
+    class And < Arel::Nodes::Node
+      attr_reader :children
+
+      def initialize children, right = nil
+        unless Array === children
+          children = [children, right]
+        end
+        @children = children
+      end
+
+      def left
+        children.first
+      end
+
+      def right
+        children[1]
+      end
+    end
+
+    class NamedFunction < Arel::Nodes::Function
+      attr_accessor :name, :distinct
+
+      include Arel::Predications
+
+      def initialize name, expr, aliaz = nil
+        super(expr, aliaz)
+        @name = name
+        @distinct = false
+      end
+    end
+
+    class InfixOperation < Binary
+      include Arel::Expressions
+      include Arel::Predications
+
+      attr_reader :operator
+
+      def initialize operator, left, right
+        super(left, right)
+        @operator = operator
+      end
+    end
+
+    class Multiplication < InfixOperation
+      def initialize left, right
+        super(:*, left, right)
+      end
+    end
+
+    class Division < InfixOperation
+      def initialize left, right
+        super(:/, left, right)
+      end
+    end
+
+    class Addition < InfixOperation
+      def initialize left, right
+        super(:+, left, right)
+      end
+    end
+
+    class Subtraction < InfixOperation
+      def initialize left, right
+        super(:-, left, right)
+      end
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def column_for attr
+        name    = attr.name.to_s
+        table   = attr.relation.table_name
+
+        column_cache[table][name]
+      end
+
+      def column_cache
+        @column_cache ||= Hash.new do |hash, key|
+          hash[key] = Hash[
+            @engine.connection.columns(key, "#{key} Columns").map do |c|
+              [c.name, c]
+            end
+          ]
+        end
+      end
+
+      def visit_Arel_Nodes_InfixOperation o
+        "#{visit o.left} #{o.operator} #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_NamedFunction o
+        "#{o.name}(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
+          visit x
+        }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+      end
+
+      def visit_Arel_Nodes_And o
+        o.children.map { |x| visit x }.join ' AND '
+      end
+
+      def visit_Arel_Nodes_Not o
+        "NOT (#{visit o.expr})"
+      end
+
+      def visit_Arel_Nodes_Values o
+        "VALUES (#{o.expressions.zip(o.columns).map { |value, attr|
+          if Nodes::SqlLiteral === value
+            visit_Arel_Nodes_SqlLiteral value
+          else
+            quote(value, attr && column_for(attr))
+          end
+        }.join ', '})"
+      end
+    end
+  end
+
+  module Predications
+    def as other
+      Nodes::As.new self, Nodes::SqlLiteral.new(other)
+    end
+  end
+
 end

data/lib/ransack/adapters/active_record/base.rb

@@ -19,12 +19,11 @@ module Ransack
           Ransacker.new(self, name, opts, &block)
         end
 
-        # TODO: Let's actually do some authorization. Whitelist-only.
-        def ransackable_attributes(auth_object)
+        def ransackable_attributes(auth_object = nil)
           column_names + _ransackers.keys
         end
 
-        def ransackable_associations(auth_object)
+        def ransackable_associations(auth_object = nil)
           reflect_on_all_associations.map {|a| a.name.to_s}
         end
 

data/lib/ransack/configuration.rb

@@ -7,7 +7,7 @@ module Ransack
     mattr_accessor :predicates
     self.predicates = {}
 
-    def self.predicate_keys
+    def predicate_keys
       predicates.keys.sort {|a,b| b.length <=> a.length}
     end
 

data/lib/ransack/helpers/form_builder.rb

@@ -77,12 +77,8 @@ module Ransack
         search_fields(:c, args, block)
       end
 
-      def and_fields(*args, &block)
-        search_fields(:n, args, block)
-      end
-
-      def or_fields(*args, &block)
-        search_fields(:o, args, block)
+      def grouping_fields(*args, &block)
+        search_fields(:g, args, block)
       end
 
       def attribute_fields(*args, &block)
@@ -114,15 +110,27 @@ module Ransack
       end
 
       def predicate_select(options = {}, html_options = {})
+        options[:compounds] = true if options[:compounds].nil?
+        keys = options[:compounds] ? Ransack.predicate_keys : Ransack.predicate_keys.reject {|k| k.match(/_(any|all)$/)}
+        if only = options[:only]
+          if only.respond_to? :call
+            keys = keys.select {|k| only.call(k)}
+          else
+            only = Array.wrap(only).map(&:to_s)
+            keys = keys.select {|k| only.include? k.sub(/_(any|all)$/, '')}
+          end
+        end
+
         @template.collection_select(
-          @object_name, :p, Predicate.collection, :first, :last,
+          @object_name, :p, keys.map {|k| [k, Translate.predicate(k)]}, :first, :last,
           objectify_options(options), @default_options.merge(html_options)
         )
       end
 
       def combinator_select(options = {}, html_options = {})
+        choices = Nodes::Condition === object ? [:or, :and] : [:and, :or]
         @template.collection_select(
-          @object_name, :m, [['or', Translate.word(:or)], ['and', Translate.word(:and)]], :first, :last,
+          @object_name, :m, choices.map {|o| [o.to_s, Translate.word(o)]}, :first, :last,
           objectify_options(options), @default_options.merge(html_options)
         )
       end

data/lib/ransack/nodes.rb

@@ -4,5 +4,4 @@ require 'ransack/nodes/attribute'
 require 'ransack/nodes/value'
 require 'ransack/nodes/condition'
 require 'ransack/nodes/sort'
-require 'ransack/nodes/and'
-require 'ransack/nodes/or'
+require 'ransack/nodes/grouping'

data/lib/ransack/nodes/condition.rb

@@ -28,7 +28,7 @@ module Ransack
 
         def extract_attributes_and_predicate(key)
           str = key.dup
-          name = Ransack::Configuration.predicate_keys.detect {|p| str.sub!(/_#{p}$/, '')}
+          name = Ransack.predicate_keys.detect {|p| str.sub!(/_#{p}$/, '')}
           predicate = Predicate.named(name)
           raise ArgumentError, "No valid predicate for #{key}" unless predicate
           attributes = str.split(/_and_|_or_/)

data/lib/ransack/nodes/grouping.rb

@@ -2,11 +2,20 @@ module Ransack
   module Nodes
     class Grouping < Node
       attr_reader :conditions
+      attr_accessor :combinator
+      alias :m :combinator
+      alias :m= :combinator=
+
       i18n_word :condition, :and, :or
       i18n_alias :c => :condition, :n => :and, :o => :or
 
       delegate :each, :to => :values
 
+      def initialize(context, combinator = nil)
+        super(context)
+        self.combinator = combinator.to_s if combinator
+      end
+
       def persisted?
         false
       end
@@ -52,7 +61,7 @@ module Ransack
       end
 
       def values
-        conditions + ors + ands
+        conditions + groupings
       end
 
       def respond_to?(method_id)
@@ -79,51 +88,28 @@ module Ransack
         condition
       end
 
-      def ands
-        @ands ||= []
+      def groupings
+        @groupings ||= []
       end
-      alias :n :ands
+      alias :g :groupings
 
-      def ands=(ands)
-        case ands
+      def groupings=(groupings)
+        case groupings
         when Array
-          ands.each do |attrs|
-            and_object = And.new(@context).build(attrs)
-            self.ands << and_object if and_object.values.any?
+          groupings.each do |attrs|
+            grouping_object = new_grouping(attrs)
+            self.groupings << grouping_object if grouping_object.values.any?
           end
         when Hash
-          ands.each do |index, attrs|
-            and_object = And.new(@context).build(attrs)
-            self.ands << and_object if and_object.values.any?
+          groupings.each do |index, attrs|
+            grouping_object = new_grouping(attrs)
+            self.groupings << grouping_object if grouping_object.values.any?
           end
         else
-          raise ArgumentError, "Invalid argument (#{ands.class}) supplied to ands="
+          raise ArgumentError, "Invalid argument (#{groupings.class}) supplied to groupings="
         end
       end
-      alias :n= :ands=
-
-      def ors
-        @ors ||= []
-      end
-      alias :o :ors
-
-      def ors=(ors)
-        case ors
-        when Array
-          ors.each do |attrs|
-            or_object = Or.new(@context).build(attrs)
-            self.ors << or_object if or_object.values.any?
-          end
-        when Hash
-          ors.each do |index, attrs|
-            or_object = Or.new(@context).build(attrs)
-            self.ors << or_object if or_object.values.any?
-          end
-        else
-          raise ArgumentError, "Invalid argument (#{ors.class}) supplied to ors="
-        end
-      end
-      alias :o= :ors=
+      alias :g= :groupings=
 
       def method_missing(method_id, *args)
         method_name = method_id.to_s
@@ -138,39 +124,28 @@ module Ransack
       def attribute_method?(name)
         name = strip_predicate_and_index(name)
         case name
-        when /^(n|o|c|ands|ors|conditions)=?$/
+        when /^(g|c|m|groupings|conditions|combinator)=?$/
           true
         else
           name.split(/_and_|_or_/).select {|n| !@context.attribute_method?(n)}.empty?
         end
       end
 
-      def build_and(params = {})
-        params ||= {}
-        new_and(params).tap do |new_and|
-          self.ands << new_and
-        end
-      end
-
-      def new_and(params = {})
-        And.new(@context).build(params)
-      end
-
-      def build_or(params = {})
+      def build_grouping(params = {})
         params ||= {}
-        new_or(params).tap do |new_or|
-          self.ors << new_or
+        new_grouping(params).tap do |new_grouping|
+          self.groupings << new_grouping
         end
       end
 
-      def new_or(params = {})
-        Or.new(@context).build(params)
+      def new_grouping(params = {})
+        Grouping.new(@context).build(params)
       end
 
       def build(params)
         params.with_indifferent_access.each do |key, value|
           case key
-          when /^(n|o|c)$/
+          when /^(g|c|m)$/
             self.send("#{key}=", value)
           else
             write_attribute(key.to_s, value)
@@ -198,7 +173,7 @@ module Ransack
 
       def strip_predicate_and_index(str)
         string = str.split(/\(/).first
-        Ransack::Configuration.predicate_keys.detect {|p| string.sub!(/_#{p}$/, '')}
+        Ransack.predicate_keys.detect {|p| string.sub!(/_#{p}$/, '')}
         string
       end
 

data/lib/ransack/predicate.rb

@@ -4,15 +4,11 @@ module Ransack
 
     class << self
       def named(name)
-        Configuration.predicates[name.to_s]
+        Ransack.predicates[name.to_s]
       end
 
       def for_attribute_name(attribute_name)
-        self.named(Configuration.predicate_keys.detect {|p| attribute_name.to_s.match(/_#{p}$/)})
-      end
-
-      def collection
-        Configuration.predicates.map {|k, v| [k, Translate.predicate(k)]}
+        self.named(Ransack.predicate_keys.detect {|p| attribute_name.to_s.match(/_#{p}$/)})
       end
     end
 

data/lib/ransack/search.rb

@@ -9,15 +9,15 @@ module Ransack
     attr_reader :base, :context
 
     delegate :object, :klass, :to => :context
-    delegate :new_and, :new_or, :new_condition,
-             :build_and, :build_or, :build_condition,
+    delegate :new_grouping, :new_condition,
+             :build_grouping, :build_condition,
              :translate, :to => :base
 
     def initialize(object, params = {}, options = {})
       params ||= {}
       @context = Context.for(object)
       @context.auth_object = options[:auth_object]
-      @base = Nodes::And.new(@context)
+      @base = Nodes::Grouping.new(@context, 'and')
       build(params.with_indifferent_access)
     end
 

data/lib/ransack/translate.rb

@@ -18,7 +18,7 @@ module Ransack
       original_name = key.to_s
       base_class = context.klass
       base_ancestors = base_class.ancestors.select { |x| x.respond_to?(:model_name) }
-      predicate = Ransack::Configuration.predicate_keys.detect {|p| original_name.match(/_#{p}$/)}
+      predicate = Ransack.predicate_keys.detect {|p| original_name.match(/_#{p}$/)}
       attributes_str = original_name.sub(/_#{predicate}$/, '')
       attribute_names = attributes_str.split(/_and_|_or_/)
       combinator = attributes_str.match(/_and_/) ? :and : :or

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/ransack/visitor.rb

@@ -17,7 +17,11 @@ module Ransack
       object.arel_predicate if object.valid?
     end
 
-    def visit_Ransack_Nodes_And(object)
+    def visit_Ransack_Nodes_Grouping(object)
+      object.combinator == 'or' ? visit_or(object) : visit_and(object)
+    end
+
+    def visit_and(object)
       nodes = object.values.map {|o| accept(o)}.compact
       return nil unless nodes.size > 0
 
@@ -28,11 +32,7 @@ module Ransack
       end
     end
 
-    def visit_Ransack_Nodes_Sort(object)
-      object.attr.send(object.dir) if object.valid?
-    end
-
-    def visit_Ransack_Nodes_Or(object)
+    def visit_or(object)
       nodes = object.values.map {|o| accept(o)}.compact
       return nil unless nodes.size > 0
 
@@ -43,6 +43,10 @@ module Ransack
       end
     end
 
+    def visit_Ransack_Nodes_Sort(object)
+      object.attr.send(object.dir) if object.valid?
+    end
+
     def quoted?(object)
       case object
       when Arel::Nodes::SqlLiteral, Bignum, Fixnum

data/spec/ransack/configuration_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 module Ransack
   describe Configuration do
-    it 'yields self on configure' do
-      Ransack.configure do
-        self.should eq Ransack::Configuration
+    it 'yields Ransack on configure' do
+      Ransack.configure do |config|
+        config.should eq Ransack
       end
     end
   end

data/spec/ransack/helpers/form_builder_spec.rb

@@ -32,12 +32,88 @@ module Ransack
 
       it 'selects previously-entered time values with datetime_select' do
         @s.created_at_eq = [2011, 1, 2, 3, 4, 5]
-        html = @f.datetime_select :created_at_eq
-        [2011, 1, 2, 3, 4, 5].each do |val|
-          html.should match /<option selected="selected" value="#{val}">#{val}<\/option>/o
+        html = @f.datetime_select :created_at_eq, :use_month_numbers => true, :include_seconds => true
+        %w(2011 1 2 03 04 05).each do |val|
+          html.should match /<option selected="selected" value="#{val}">#{val}<\/option>/
         end
       end
 
+      describe '#label' do
+
+        it 'localizes attribute names' do
+          html = @f.label :name_cont
+          html.should match /Full Name contains/
+        end
+
+      end
+
+      describe '#submit' do
+
+        it 'localizes :search when no default value given' do
+          html = @f.submit
+          html.should match /"Search"/
+        end
+
+      end
+
+      describe '#attribute_select' do
+
+        it 'returns ransackable attributes' do
+          html = @f.attribute_select
+          html.split(/\n/).should have(Person.ransackable_attributes.size + 1).lines
+          Person.ransackable_attributes.each do |attribute|
+            html.should match /<option value="#{attribute}">/
+          end
+        end
+
+        it 'returns ransackable attributes for associations with :associations' do
+          attributes = Person.ransackable_attributes + Article.ransackable_attributes.map {|a| "articles_#{a}"}
+          html = @f.attribute_select :associations => ['articles']
+          html.split(/\n/).should have(attributes.size).lines
+          attributes.each do |attribute|
+            html.should match /<option value="#{attribute}">/
+          end
+        end
+
+        it 'returns option groups for base and associations with :associations' do
+          html = @f.attribute_select :associations => ['articles']
+          [Person, Article].each do |model|
+            html.should match /<optgroup label="#{model}">/
+          end
+        end
+
+      end
+
+      describe '#predicate_select' do
+
+        it 'returns predicates with predicate_select' do
+          html = @f.predicate_select
+          Ransack.predicate_keys.each do |key|
+            html.should match /<option value="#{key}">/
+          end
+        end
+
+        it 'filters predicates with single-value :only' do
+          html = @f.predicate_select :only => 'eq'
+          Ransack.predicate_keys.reject {|k| k =~ /^eq/}.each do |key|
+            html.should_not match /<option value="#{key}">/
+          end
+        end
+
+        it 'filters predicates with multi-value :only' do
+          html = @f.predicate_select :only => [:eq, :lt]
+          Ransack.predicate_keys.reject {|k| k =~ /^(eq|lt)/}.each do |key|
+            html.should_not match /<option value="#{key}">/
+          end
+        end
+
+        it 'excludes compounds when :compounds => false' do
+          html = @f.predicate_select :compounds => false
+          Ransack.predicate_keys.select {|k| k =~ /_(any|all)$/}.each do |key|
+            html.should_not match /<option value="#{key}">/
+          end
+        end
+      end
     end
   end
 end

data/spec/ransack/search_spec.rb

@@ -39,30 +39,34 @@ module Ransack
 
       it 'accepts arrays of groupings' do
         search = Search.new(Person,
-          :o => [
-            {:name_eq => 'Ernie', :children_name_eq => 'Ernie'},
-            {:name_eq => 'Bert', :children_name_eq => 'Bert'},
+          :g => [
+            {:m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie'},
+            {:m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert'},
           ]
         )
-        ors = search.ors
+        ors = search.groupings
         ors.should have(2).items
         or1, or2 = ors
-        or1.should be_a Nodes::Or
-        or2.should be_a Nodes::Or
+        or1.should be_a Nodes::Grouping
+        or1.combinator.should eq 'or'
+        or2.should be_a Nodes::Grouping
+        or2.combinator.should eq 'or'
       end
 
       it 'accepts "attributes" hashes for groupings' do
         search = Search.new(Person,
-          :o => {
-            '0' => {:name_eq => 'Ernie', :children_name_eq => 'Ernie'},
-            '1' => {:name_eq => 'Bert', :children_name_eq => 'Bert'},
+          :g => {
+            '0' => {:m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie'},
+            '1' => {:m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert'},
           }
         )
-        ors = search.ors
+        ors = search.groupings
         ors.should have(2).items
         or1, or2 = ors
-        or1.should be_a Nodes::Or
-        or2.should be_a Nodes::Or
+        or1.should be_a Nodes::Grouping
+        or1.combinator.should eq 'or'
+        or2.should be_a Nodes::Grouping
+        or2.combinator.should eq 'or'
       end
 
       it 'accepts "attributes" hashes for conditions' do
@@ -102,7 +106,8 @@ module Ransack
 
       it 'evaluates nested conditions' do
         search = Search.new(Person, :children_name_eq => 'Ernie',
-          :o => [{
+          :g => [{
+            :m => 'or',
             :name_eq => 'Ernie',
             :children_children_name_eq => 'Ernie'
           }]
@@ -114,9 +119,9 @@ module Ransack
 
       it 'evaluates arrays of groupings' do
         search = Search.new(Person,
-          :o => [
-            {:name_eq => 'Ernie', :children_name_eq => 'Ernie'},
-            {:name_eq => 'Bert', :children_name_eq => 'Bert'},
+          :g => [
+            {:m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie'},
+            {:m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert'},
           ]
         )
         search.result.should be_an ActiveRecord::Relation
@@ -125,7 +130,7 @@ module Ransack
       end
 
       it 'returns distinct records when passed :distinct => true' do
-        search = Search.new(Person, :o => [{:comments_body_cont => 'e', :articles_comments_body_cont => 'e'}])
+        search = Search.new(Person, :g => [{:m => 'or', :comments_body_cont => 'e', :articles_comments_body_cont => 'e'}])
         search.result.should have(920).items
         search.result(:distinct => true).should have(330).items
         search.result.all.uniq.should eq search.result(:distinct => true).all
@@ -195,9 +200,9 @@ module Ransack
       end
 
       it 'allows chaining to access nested conditions' do
-        @s.ors = [{:name_eq => 'Ernie', :children_name_eq => 'Ernie'}]
-        @s.ors.first.name_eq.should eq 'Ernie'
-        @s.ors.first.children_name_eq.should eq 'Ernie'
+        @s.groupings = [{:m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie'}]
+        @s.groupings.first.name_eq.should eq 'Ernie'
+        @s.groupings.first.children_name_eq.should eq 'Ernie'
       end
     end
 

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ require 'faker'
 require 'ransack'
 
 Time.zone = 'Eastern Time (US & Canada)'
+I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'support', '*.yml')]
 
 Dir[File.expand_path('../{helpers,support,blueprints}/*.rb', __FILE__)].each do |f|
   require f

data/spec/support/en.yml

@@ -0,0 +1,5 @@
+en:
+  ransack:
+    attributes:
+      person:
+        name: Full Name

metadata

@@ -2,7 +2,7 @@
 name: ransack
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Ernie Miller
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-30 00:00:00 Z
+date: 2011-06-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -106,7 +106,6 @@ files:
 - Rakefile
 - lib/ransack.rb
 - lib/ransack/adapters/active_record.rb
-- lib/ransack/adapters/active_record/3.0/base.rb
 - lib/ransack/adapters/active_record/3.0/compat.rb
 - lib/ransack/adapters/active_record/3.0/context.rb
 - lib/ransack/adapters/active_record/3.0/join_association.rb
@@ -124,13 +123,11 @@ files:
 - lib/ransack/locale/en.yml
 - lib/ransack/naming.rb
 - lib/ransack/nodes.rb
-- lib/ransack/nodes/and.rb
 - lib/ransack/nodes/attribute.rb
 - lib/ransack/nodes/bindable.rb
 - lib/ransack/nodes/condition.rb
 - lib/ransack/nodes/grouping.rb
 - lib/ransack/nodes/node.rb
-- lib/ransack/nodes/or.rb
 - lib/ransack/nodes/sort.rb
 - lib/ransack/nodes/value.rb
 - lib/ransack/predicate.rb
@@ -157,6 +154,7 @@ files:
 - spec/ransack/predicate_spec.rb
 - spec/ransack/search_spec.rb
 - spec/spec_helper.rb
+- spec/support/en.yml
 - spec/support/schema.rb
 homepage: http://metautonomo.us/projects/ransack
 licenses: []
@@ -203,4 +201,5 @@ test_files:
 - spec/ransack/predicate_spec.rb
 - spec/ransack/search_spec.rb
 - spec/spec_helper.rb
+- spec/support/en.yml
 - spec/support/schema.rb

data/lib/ransack/adapters/active_record/3.0/base.rb

@@ -1,33 +0,0 @@
-module Ransack
-  module Adapters
-    module ActiveRecord
-      module Base
-
-        def self.extended(base)
-          alias :search :ransack unless base.method_defined? :search
-          base.instance_eval do
-            class_attribute :_ransackers
-            self._ransackers ||= {}
-          end
-        end
-
-        def ransack(params = {}, options = {})
-          Search.new(self, params, options)
-        end
-
-        def ransacker(name, opts = {}, &block)
-          Ransacker.new(self, name, opts, &block)
-        end
-
-        def ransackable_attributes(auth_object)
-          column_names + _ransackers.keys
-        end
-
-        def ransackable_associations(auth_object)
-          reflect_on_all_associations.map {|a| a.name.to_s}
-        end
-
-      end
-    end
-  end
-end

data/lib/ransack/nodes/and.rb

@@ -1,8 +0,0 @@
-require 'ransack/nodes/grouping'
-
-module Ransack
-  module Nodes
-    class And < Grouping
-    end
-  end
-end

data/lib/ransack/nodes/or.rb

@@ -1,8 +0,0 @@
-require 'ransack/nodes/grouping'
-
-module Ransack
-  module Nodes
-    class Or < Grouping
-    end
-  end
-end