ransack 1.8.4 → 3.2.1

data/spec/mongoid/search_spec.rb

@@ -1,445 +0,0 @@
-require 'mongoid_spec_helper'
-
-module Ransack
-  describe Search do
-    describe '#initialize' do
-      it "removes empty conditions before building" do
-        expect_any_instance_of(Search).to receive(:build).with({})
-        Search.new(Person, :name_eq => '')
-      end
-
-      it "keeps conditions with a false value before building" do
-        expect_any_instance_of(Search).to receive(:build).with({"name_eq" => false})
-        Search.new(Person, :name_eq => false)
-      end
-
-      it "keeps conditions with a value before building" do
-        expect_any_instance_of(Search).to receive(:build).with({"name_eq" => 'foobar'})
-        Search.new(Person, :name_eq => 'foobar')
-      end
-
-      it "removes empty suffixed conditions before building" do
-        expect_any_instance_of(Search).to receive(:build).with({})
-        Search.new(Person, :name_eq_any => [''])
-      end
-
-      it "keeps suffixed conditions with a false value before building" do
-        expect_any_instance_of(Search).to receive(:build).with({"name_eq_any" => [false]})
-        Search.new(Person, :name_eq_any => [false])
-      end
-
-      it "keeps suffixed conditions with a value before building" do
-        expect_any_instance_of(Search).to receive(:build).with({"name_eq_any" => ['foobar']})
-        Search.new(Person, :name_eq_any => ['foobar'])
-      end
-
-      it 'does not raise exception for string :params argument' do
-        expect { Search.new(Person, '') }.not_to raise_error
-      end
-    end
-
-    describe '#build' do
-      it 'creates conditions for top-level attributes' do
-        search = Search.new(Person, :name_eq => 'Ernie')
-        condition = search.base[:name_eq]
-        expect(condition).to be_a Nodes::Condition
-        expect(condition.predicate.name).to eq 'eq'
-        expect(condition.attributes.first.name).to eq 'name'
-        expect(condition.value).to eq 'Ernie'
-      end
-
-      context 'joins' do
-        before { pending 'not implemented for mongoid' }
-
-        it 'creates conditions for association attributes' do
-          search = Search.new(Person, :children_name_eq => 'Ernie')
-          condition = search.base[:children_name_eq]
-          expect(condition).to be_a Nodes::Condition
-          expect(condition.predicate.name).to eq 'eq'
-          expect(condition.attributes.first.name).to eq 'children_name'
-          expect(condition.value).to eq 'Ernie'
-        end
-
-        it 'creates conditions for polymorphic belongs_to association attributes' do
-          search = Search.new(Note, :notable_of_Person_type_name_eq => 'Ernie')
-          condition = search.base[:notable_of_Person_type_name_eq]
-          expect(condition).to be_a Nodes::Condition
-          expect(condition.predicate.name).to eq 'eq'
-          expect(condition.attributes.first.name).to eq 'notable_of_Person_type_name'
-          expect(condition.value).to eq 'Ernie'
-        end
-
-        it 'creates conditions for multiple polymorphic belongs_to association attributes' do
-          search = Search.new(Note,
-            :notable_of_Person_type_name_or_notable_of_Article_type_title_eq => 'Ernie')
-          condition = search.
-            base[:notable_of_Person_type_name_or_notable_of_Article_type_title_eq]
-          expect(condition).to be_a Nodes::Condition
-          expect(condition.predicate.name).to eq 'eq'
-          expect(condition.attributes.first.name).to eq 'notable_of_Person_type_name'
-          expect(condition.attributes.last.name).to eq 'notable_of_Article_type_title'
-          expect(condition.value).to eq 'Ernie'
-        end
-        before { skip }
-        it 'accepts arrays of groupings with joins' do
-          search = Search.new(Person,
-            g: [
-              { :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' },
-              { :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert' },
-            ]
-          )
-          ors = search.groupings
-          expect(ors.size).to eq(2)
-          or1, or2 = ors
-          expect(or1).to be_a Nodes::Grouping
-          expect(or1.combinator).to eq 'or'
-          expect(or2).to be_a Nodes::Grouping
-          expect(or2.combinator).to eq 'or'
-        end
-
-        it 'accepts "attributes" hashes for groupings' do
-          search = Search.new(Person,
-            g: {
-              '0' => { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' },
-              '1' => { m: 'or', name_eq: 'Bert',  children_name_eq: 'Bert' },
-            }
-          )
-          ors = search.groupings
-          expect(ors.size).to eq(2)
-          or1, or2 = ors
-          expect(or1).to be_a Nodes::Grouping
-          expect(or1.combinator).to eq 'or'
-          expect(or2).to be_a Nodes::Grouping
-          expect(or2.combinator).to eq 'or'
-        end
-
-        it 'accepts "attributes" hashes for conditions' do
-          search = Search.new(Person,
-            :c => {
-              '0' => { :a => ['name'], :p => 'eq', :v => ['Ernie'] },
-              '1' => { :a => ['children_name', 'parent_name'],
-                       :p => 'eq', :v => ['Ernie'], :m => 'or' }
-              }
-          )
-          conditions = search.base.conditions
-          expect(conditions.size).to eq(2)
-          expect(conditions.map { |c| c.class })
-          .to eq [Nodes::Condition, Nodes::Condition]
-        end
-
-        before { skip }
-        it 'does not evaluate the query on #inspect' do
-          search = Search.new(Person, :children_id_in => [1, 2, 3])
-          expect(search.inspect).not_to match /ActiveRecord/
-        end
-      end
-
-      it 'discards empty conditions' do
-        search = Search.new(Person, :children_name_eq => '')
-        condition = search.base[:children_name_eq]
-        expect(condition).to be_nil
-      end
-
-      it 'accepts arrays of groupings' do
-        search = Search.new(Person,
-          g: [
-            { :m => 'or', :name_eq => 'Ernie', :email_eq => 'ernie@example.org' },
-            { :m => 'or', :name_eq => 'Bert', :email_eq => 'bert@example.org' },
-          ]
-        )
-        ors = search.groupings
-        expect(ors.size).to eq(2)
-        or1, or2 = ors
-        expect(or1).to be_a Nodes::Grouping
-        expect(or1.combinator).to eq 'or'
-        expect(or2).to be_a Nodes::Grouping
-        expect(or2.combinator).to eq 'or'
-      end
-
-      it 'creates conditions for custom predicates that take arrays' do
-        Ransack.configure do |config|
-          config.add_predicate 'ary_pred', :wants_array => true
-        end
-
-        search = Search.new(Person, :name_ary_pred => ['Ernie', 'Bert'])
-        condition = search.base[:name_ary_pred]
-        expect(condition).to be_a Nodes::Condition
-        expect(condition.predicate.name).to eq 'ary_pred'
-        expect(condition.attributes.first.name).to eq 'name'
-        expect(condition.value).to eq ['Ernie', 'Bert']
-      end
-
-      context 'with an invalid condition' do
-        subject { Search.new(Person, :unknown_attr_eq => 'Ernie') }
-
-        context "when ignore_unknown_conditions is false" do
-          before do
-            Ransack.configure { |c| c.ignore_unknown_conditions = false }
-          end
-
-          specify { expect { subject }.to raise_error ArgumentError }
-        end
-
-        context "when ignore_unknown_conditions is true" do
-          before do
-            Ransack.configure { |c| c.ignore_unknown_conditions = true }
-          end
-
-          specify { expect { subject }.not_to raise_error }
-        end
-      end
-    end
-
-    describe '#result' do
-      let(:people_name_field) {
-        "#{quote_table_name("people")}.#{quote_column_name("name")}"
-      }
-      # let(:children_people_name_field) {
-      #   "#{quote_table_name("children_people")}.#{quote_column_name("name")}"
-      # }
-
-      it 'evaluates arrays of groupings' do
-        search = Search.new(Person,
-          :g => [
-            { :m => 'or', :name_eq => 'Ernie', :email_eq => 'ernie@example.org' },
-            { :m => 'or', :name_eq => 'Bert', :email_eq => 'bert@example.org' }
-          ]
-        )
-        expect(search.result).to be_an Mongoid::Criteria
-        selector = search.result.selector
-        expect(selector.keys).to eq ['$and']
-        first, second = selector.values.first
-        expect(first).to eq({ '$or' => [ { 'name' => 'Ernie' }, { 'email' => 'ernie@example.org' } ] })
-        expect(second).to eq({ '$or' => [ { 'name' => 'Bert' }, { 'email' => 'bert@example.org' } ] })
-      end
-
-      context 'with joins' do
-        before { pending 'not implemented for mongoid' }
-
-        it 'evaluates conditions contextually' do
-          search = Search.new(Person, :children_name_eq => 'Ernie')
-          expect(search.result).to be_an ActiveRecord::Relation
-          where = search.result.where_values.first
-          expect(where.to_sql).to match /#{children_people_name_field} = 'Ernie'/
-        end
-
-        it 'evaluates compound conditions contextually' do
-          search = Search.new(Person, :children_name_or_name_eq => 'Ernie')
-          expect(search.result).to be_an ActiveRecord::Relation
-          where = search.result.where_values.first
-          expect(where.to_sql).to match /#{children_people_name_field
-            } = 'Ernie' OR #{people_name_field} = 'Ernie'/
-        end
-
-        it 'evaluates polymorphic belongs_to association conditions contextually' do
-          search = Search.new(Note, :notable_of_Person_type_name_eq => 'Ernie')
-          expect(search.result).to be_an ActiveRecord::Relation
-          where = search.result.where_values.first
-          expect(where.to_sql).to match /#{people_name_field} = 'Ernie'/
-        end
-
-        it 'evaluates nested conditions' do
-          search = Search.new(Person, :children_name_eq => 'Ernie',
-            :g => [
-              { :m => 'or',
-                :name_eq => 'Ernie',
-                :children_children_name_eq => 'Ernie'
-              }
-            ]
-          )
-          expect(search.result).to be_an ActiveRecord::Relation
-          where = search.result.where_values.first
-          expect(where.to_sql).to match /#{children_people_name_field} = 'Ernie'/
-          expect(where.to_sql).to match /#{people_name_field} = 'Ernie'/
-          expect(where.to_sql).to match /#{quote_table_name("children_people_2")
-            }.#{quote_column_name("name")} = 'Ernie'/
-        end
-
-        it 'evaluates arrays of groupings' do
-          search = Search.new(Person,
-            :g => [
-              { :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' },
-              { :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert' }
-            ]
-          )
-          expect(search.result).to be_an ActiveRecord::Relation
-          where = search.result.where_values.first
-          sql = where.to_sql
-          first, second = sql.split(/ AND /)
-          expect(first).to match /#{people_name_field} = 'Ernie'/
-          expect(first).to match /#{children_people_name_field} = 'Ernie'/
-          expect(second).to match /#{people_name_field} = 'Bert'/
-          expect(second).to match /#{children_people_name_field} = 'Bert'/
-        end
-
-        it 'returns distinct records when passed :distinct => true' do
-          search = Search.new(
-            Person, :g => [
-              { :m => 'or',
-                :comments_body_cont => 'e',
-                :articles_comments_body_cont => 'e'
-              }
-            ]
-          )
-          if ActiveRecord::VERSION::MAJOR == 3
-            all_or_load, uniq_or_distinct = :all, :uniq
-          else
-            all_or_load, uniq_or_distinct = :load, :distinct
-          end
-          expect(search.result.send(all_or_load).size).
-            to eq(9000)
-          expect(search.result(:distinct => true).size).
-            to eq(10)
-          expect(search.result.send(all_or_load).send(uniq_or_distinct)).
-            to eq search.result(:distinct => true).send(all_or_load)
-        end
-      end
-    end
-
-    describe '#sorts=' do
-      before do
-        @s = Search.new(Person)
-      end
-
-      it 'creates sorts based on a single attribute/direction' do
-        @s.sorts = 'id desc'
-        expect(@s.sorts.size).to eq(1)
-        sort = @s.sorts.first
-        expect(sort).to be_a Nodes::Sort
-        expect(sort.name).to eq 'id'
-        expect(sort.dir).to eq 'desc'
-        expect(@s.result.options).to eq({ :sort => { '_id' => -1 } })
-      end
-
-      it 'creates sorts based on a single attribute and uppercase direction' do
-        @s.sorts = 'id DESC'
-        expect(@s.sorts.size).to eq(1)
-        sort = @s.sorts.first
-        expect(sort).to be_a Nodes::Sort
-        expect(sort.name).to eq 'id'
-        expect(sort.dir).to eq 'desc'
-        expect(@s.result.options).to eq({ :sort => { '_id' => -1 } })
-      end
-
-      it 'creates sorts based on a single attribute and without direction' do
-        @s.sorts = 'id'
-        expect(@s.sorts.size).to eq(1)
-        sort = @s.sorts.first
-        expect(sort).to be_a Nodes::Sort
-        expect(sort.name).to eq 'id'
-        expect(sort.dir).to eq 'asc'
-        expect(@s.result.options).to eq({ :sort => { '_id' => 1 } })
-      end
-
-      it 'creates sorts based on multiple attributes/directions in array format' do
-        @s.sorts = ['id desc', { :name => 'name', :dir => 'asc' }]
-        expect(@s.sorts.size).to eq(2)
-        sort1, sort2 = @s.sorts
-        expect(sort1).to be_a Nodes::Sort
-        expect(sort1.name).to eq 'id'
-        expect(sort1.dir).to eq 'desc'
-        expect(sort2).to be_a Nodes::Sort
-        expect(sort2.name).to eq 'name'
-        expect(sort2.dir).to eq 'asc'
-        expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
-      end
-
-      it 'creates sorts based on multiple attributes and uppercase directions in array format' do
-        @s.sorts = ['id DESC', { :name => 'name', :dir => 'ASC' }]
-        expect(@s.sorts.size).to eq(2)
-        sort1, sort2 = @s.sorts
-        expect(sort1).to be_a Nodes::Sort
-        expect(sort1.name).to eq 'id'
-        expect(sort1.dir).to eq 'desc'
-        expect(sort2).to be_a Nodes::Sort
-        expect(sort2.name).to eq 'name'
-        expect(sort2.dir).to eq 'asc'
-        expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
-      end
-
-      it 'creates sorts based on multiple attributes and different directions in array format' do
-        @s.sorts = ['id DESC', { name: 'name', dir: nil }]
-        expect(@s.sorts.size).to eq(2)
-        sort1, sort2 = @s.sorts
-        expect(sort1).to be_a Nodes::Sort
-        expect(sort1.name).to eq 'id'
-        expect(sort1.dir).to eq 'desc'
-        expect(sort2).to be_a Nodes::Sort
-        expect(sort2.name).to eq 'name'
-        expect(sort2.dir).to eq 'asc'
-        expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
-      end
-
-      it 'creates sorts based on multiple attributes/directions in hash format' do
-        @s.sorts = {
-          '0' => { :name => 'id', :dir => 'desc' },
-          '1' => { :name => 'name', :dir => 'asc' }
-        }
-        expect(@s.sorts.size).to eq(2)
-        expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
-        id_sort = @s.sorts.detect { |s| s.name == 'id' }
-        name_sort = @s.sorts.detect { |s| s.name == 'name' }
-        expect(id_sort.dir).to eq 'desc'
-        expect(name_sort.dir).to eq 'asc'
-        expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
-      end
-
-      it 'creates sorts based on multiple attributes and uppercase directions in hash format' do
-        @s.sorts = {
-            '0' => { :name => 'id', :dir => 'DESC' },
-            '1' => { :name => 'name', :dir => 'ASC' }
-        }
-        expect(@s.sorts.size).to eq(2)
-        expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
-        id_sort = @s.sorts.detect { |s| s.name == 'id' }
-        name_sort = @s.sorts.detect { |s| s.name == 'name' }
-        expect(id_sort.dir).to eq 'desc'
-        expect(name_sort.dir).to eq 'asc'
-        expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
-      end
-
-      it 'creates sorts based on multiple attributes and different directions in hash format' do
-        @s.sorts = {
-            '0' => { :name => 'id', :dir => 'DESC' },
-            '1' => { :name => 'name', :dir => nil }
-        }
-        expect(@s.sorts.size).to eq(2)
-        expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
-        id_sort = @s.sorts.detect { |s| s.name == 'id' }
-        name_sort = @s.sorts.detect { |s| s.name == 'name' }
-        expect(id_sort.dir).to eq 'desc'
-        expect(name_sort.dir).to eq 'asc'
-        expect(@s.result.options).to eq({ :sort=>{"_id"=>-1, "name"=>1} })
-      end
-
-      it 'overrides existing sort' do
-        @s.sorts = 'id asc'
-        expect(@s.result.first.id.to_s).to eq Person.min(:id).to_s
-      end
-    end
-
-    describe '#method_missing' do
-      before do
-        @s = Search.new(Person)
-      end
-
-      it 'raises NoMethodError when sent an invalid attribute' do
-        expect { @s.blah }.to raise_error NoMethodError
-      end
-
-      it 'sets condition attributes when sent valid attributes' do
-        @s.name_eq = 'Ernie'
-        expect(@s.name_eq).to eq 'Ernie'
-      end
-
-      context 'with joins' do
-        it 'allows chaining to access nested conditions' do
-          @s.groupings = [
-            { :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' }
-          ]
-          expect(@s.groupings.first.children_name_eq).to eq 'Ernie'
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/support/mongoid.yml

@@ -1,11 +0,0 @@
-test:
-  clients:
-    default:
-      database: ransack_mongoid_test
-      hosts:
-        - localhost:27017
-  sessions:
-    default:
-      database: ransack_mongoid_test
-      hosts:
-        - localhost:27017

data/spec/mongoid/support/schema.rb

@@ -1,135 +0,0 @@
-require 'mongoid'
-
-Mongoid.load!(File.expand_path("../mongoid.yml", __FILE__), :test)
-Mongo::Logger.logger.level = Logger::WARN if defined?(Mongo)
-Mongoid.purge!
-
-class Person
-  include Mongoid::Document
-  include Mongoid::Timestamps
-
-  field :name, type: String
-  field :email, type: String
-  field :only_search, type: String
-  field :only_sort, type: String
-  field :only_admin, type: String
-  field :salary, type: Integer
-  field :awesome, type: Boolean, default: false
-
-  belongs_to :parent, :class_name => 'Person', inverse_of: :children
-  has_many   :children, :class_name => 'Person', inverse_of: :parent
-
-  has_many   :articles
-  has_many   :comments
-
-  ransack_alias :term, :name_or_email
-
-  # has_many   :authored_article_comments, :through => :articles,
-             # :source => :comments, :foreign_key => :person_id
-
-  has_many   :notes, :as => :notable
-
-  default_scope -> { order(id: :desc) }
-
-  scope :restricted,  lambda { where(restricted: 1) }
-  scope :active,      lambda { where(active: 1) }
-  scope :over_age,    lambda { |y| where(:age.gt => y) }
-
-  ransacker :reversed_name, :formatter => proc { |v| v.reverse } do |parent|
-    parent.table[:name]
-  end
-
-  ransacker :doubled_name do |parent|
-    # Arel::Nodes::InfixOperation.new(
-    #   '||', parent.table[:name], parent.table[:name]
-    #   )
-    parent.table[:name]
-  end
-
-  def self.ransackable_attributes(auth_object = nil)
-    if auth_object == :admin
-      all_ransackable_attributes - ['only_sort']
-    else
-      all_ransackable_attributes - ['only_sort', 'only_admin']
-    end
-  end
-
-  def self.ransortable_attributes(auth_object = nil)
-    if auth_object == :admin
-      all_ransackable_attributes - ['only_search']
-    else
-      all_ransackable_attributes - ['only_search', 'only_admin']
-    end
-  end
-end
-
-class Musician < Person
-end
-
-class Article
-  include Mongoid::Document
-
-  field :title, type: String
-  field :body, type: String
-
-  belongs_to :person
-  has_many :comments
-  # has_and_belongs_to_many :tags
-  has_many :notes, :as => :notable
-end
-
-module Namespace
-  class Article < ::Article
-
-  end
-end
-
-class Comment
-  include Mongoid::Document
-
-  field :body, type: String
-
-
-  belongs_to :article
-  belongs_to :person
-end
-
-class Tag
-  include Mongoid::Document
-
-  field :name, type: String
-
-  # has_and_belongs_to_many :articles
-end
-
-class Note
-  include Mongoid::Document
-
-  field :note, type: String
-
-  belongs_to :notable, :polymorphic => true
-end
-
-module Schema
-  def self.create
-    10.times do
-      person = Person.make.save!
-      Note.make.save!(:notable => person)
-      3.times do
-        article = Article.create!(:person => person)
-        3.times do
-          # article.tags = [Tag.make.save!, Tag.make.save!, Tag.make.save!]
-        end
-        Note.create.save!(:notable => article)
-        10.times do
-          Comment.create.save!(:article => article, :person => person)
-        end
-      end
-    end
-
-    Comment.create!(
-      :body => 'First post!',
-      :article => Article.create!(:title => 'Hello, world!')
-      )
-  end
-end

data/spec/mongoid/translate_spec.rb

@@ -1,14 +0,0 @@
-require 'mongoid_spec_helper'
-
-module Ransack
-  describe Translate do
-
-    describe '.attribute' do
-      it 'translate namespaced attribute like AR does' do
-        ar_translation = ::Namespace::Article.human_attribute_name(:title)
-        ransack_translation = Ransack::Translate.attribute(:title, :context => ::Namespace::Article.search.context)
-        expect(ransack_translation).to eq ar_translation
-      end
-    end
-  end
-end

data/spec/mongoid_spec_helper.rb

@@ -1,63 +0,0 @@
-require 'machinist/object'
-require 'sham'
-require 'faker'
-require 'pry'
-require 'mongoid'
-require 'ransack'
-
-I18n.enforce_available_locales = false
-Time.zone = 'Eastern Time (US & Canada)'
-I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'support', '*.yml')]
-
-Dir[File.expand_path('../{mongoid/helpers,mongoid/support,blueprints}/*.rb',
-  __FILE__)]
-.each { |f| require f }
-
-Sham.define do
-  name        { Faker::Name.name }
-  title       { Faker::Lorem.sentence }
-  body        { Faker::Lorem.paragraph }
-  salary      { |index| 30000 + (index * 1000) }
-  tag_name    { Faker::Lorem.words(3).join(' ') }
-  note        { Faker::Lorem.words(7).join(' ') }
-  only_admin  { Faker::Lorem.words(3).join(' ') }
-  only_search { Faker::Lorem.words(3).join(' ') }
-  only_sort   { Faker::Lorem.words(3).join(' ') }
-  notable_id  { |id| id }
-end
-
-RSpec.configure do |config|
-  config.alias_it_should_behave_like_to :it_has_behavior, 'has behavior'
-
-  config.before(:suite) do
-    if ENV['DB'] == 'mongoid4'
-      message = "Running Ransack specs with #{Mongoid.default_session.inspect
-        }, Mongoid #{Mongoid::VERSION}, Moped #{Moped::VERSION
-        }, Origin #{Origin::VERSION} and Ruby #{RUBY_VERSION}"
-    else
-      message = "Running Ransack specs with #{Mongoid.default_client.inspect
-        }, Mongoid #{Mongoid::VERSION}, Mongo driver #{Mongo::VERSION}"
-    end
-    line = '=' * message.length
-    puts line, message, line
-    Schema.create
-  end
-
-  config.before(:all)   { Sham.reset(:before_all) }
-  config.before(:each)  { Sham.reset(:before_each) }
-
-  config.include RansackHelper
-end
-
-RSpec::Matchers.define :be_like do |expected|
-  match do |actual|
-    actual.gsub(/^\s+|\s+$/, '').gsub(/\s+/, ' ').strip ==
-      expected.gsub(/^\s+|\s+$/, '').gsub(/\s+/, ' ').strip
-  end
-end
-
-RSpec::Matchers.define :have_attribute_method do |expected|
-  match do |actual|
-    actual.attribute_method?(expected)
-  end
-end

data/spec/ransack/dependencies_spec.rb

@@ -1,12 +0,0 @@
-=begin
-rails = ::ActiveRecord::VERSION::STRING.first(3)
-
-if %w(3.2 4.0 4.1).include?(rails) || rails == '3.1' && RUBY_VERSION < '2.2'
-  describe 'Ransack' do
-    it 'can be required without errors' do
-      output = `bundle exec ruby -e "require 'ransack'" 2>&1`
-      expect(output).to be_empty
-    end
-  end
-end
-=end