search_object 1.0 → 1.1.0

data/spec/search_object/base_spec.rb

@@ -3,18 +3,24 @@ require 'active_support/core_ext/object/blank'
 
 module SearchObject
   describe Base do
-    def search_class(default_scope = [], &block)
+    def define_search_class(&block)
       Class.new do
         include SearchObject.module
 
+        class_eval(&block)
+      end
+    end
+
+    def search_class(default_scope = [], &block)
+      define_search_class do
         scope { default_scope }
 
         if block.nil?
           option :value do |scope, value|
-            scope.find_all { |v| v == value }
+            scope.select { |v| v == value }
           end
         else
-          class_eval &block
+          class_eval(&block)
         end
       end
     end
@@ -23,22 +29,22 @@ module SearchObject
       search_class(default_scope, &block).new filters: filters
     end
 
-    it "can had its #initialize method overwritten" do
+    it 'can had its #initialize method overwritten' do
       search = new_search do
+        attr_reader :initialized
+
+        alias_method :initialized?, :initialized
+
         def initialize(filters = {})
           @initialized = true
           super filters
         end
-
-        def initialized?
-          @initialized
-        end
       end
 
       expect(search).to be_initialized
     end
 
-    it "can have multiple subclasses" do
+    it 'can have multiple subclasses' do
       search1 = new_search [1, 2, 3], filter: 1 do
         option :filter do |scope, value|
           scope.select { |v| v == value }
@@ -54,27 +60,43 @@ module SearchObject
       expect(search1.results).not_to eq search2.results
     end
 
-    context "no scope" do
-      def search_class
-        Class.new do
-          include SearchObject.module
+    it 'can be inherited' do
+      child_class = Class.new(search_class([1, 2, 3])) do
+        option :value do |scope, value|
+          scope.select { |v| v == value }
+        end
+      end
+
+      expect(child_class.new(filters: { value: 1 }).results).to eq [1]
+    end
 
+    context 'scope' do
+      def search_class
+        define_search_class do
           option :name do
           end
         end
       end
 
-      it "accepts scope as argument" do
+      it 'accepts scope as argument' do
         expect(search_class.new(scope: 'scope').results).to eq 'scope'
       end
 
-      it "raises an error if scope is not provided" do
-        expect { search_class.new }.to raise_error SearchObject::MissingScopeError
+      it 'raises an error if scope is not provided' do
+        expect { search_class.new }.to raise_error MissingScopeError
+      end
+
+      it 'can overwrite the search scope' do
+        search_class = define_search_class do
+          scope { 'scope' }
+        end
+
+        expect(search_class.new(scope: 'other scope').results).to eq 'other scope'
       end
     end
 
-    describe "option" do
-      it "has default filter" do
+    describe 'option' do
+      it 'has default filter' do
         scope = [1, 2, 3]
         expect(scope).to receive(:where).with('value' => 1) { 'results' }
 
@@ -85,7 +107,7 @@ module SearchObject
         expect(search.results).to eq 'results'
       end
 
-      it "returns the scope if nil returned" do
+      it 'returns the scope if nil returned' do
         scope = [1, 2, 3]
         search = new_search scope, value: 'some' do
           option :value do
@@ -96,7 +118,7 @@ module SearchObject
         expect(search.results).to eq scope
       end
 
-      it "can use methods from the object" do
+      it 'can use methods from the object' do
         search1 = new_search [1, 2, 3], filter: 1 do
           option :filter do |scope, value|
             some_instance_method(scope, value)
@@ -111,64 +133,78 @@ module SearchObject
 
         expect(search1.results).to eq [1]
       end
+
+      it 'can dispatch with instance methods' do
+        search = new_search [1, 2, 3], filter: 1 do
+          option :filter, with: :some_instance_method
+
+          private
+
+          def some_instance_method(scope, value)
+            scope.select { |v| v == value }
+          end
+        end
+
+        expect(search.results).to eq [1]
+      end
     end
 
-    describe "option attributes" do
-      it "access option values" do
+    describe 'option attributes' do
+      it 'access option values' do
         search = new_search [], value: 1
         expect(search.value).to eq 1
       end
 
-      it "returns default option value if option is not specified" do
+      it 'returns default option value if option is not specified' do
         search = new_search do
           option :value, 1
         end
         expect(search.value).to eq 1
       end
 
-      it "does not include invalid options" do
+      it 'does not include invalid options' do
         search = new_search [], invalid: 'option'
         expect { search.invalid }.to raise_error NoMethodError
       end
     end
 
-    describe ".results" do
-      it "shortcut for creating new search and immediately returning results" do
-        klass = search_class [1 ,2 ,3]
-        expect(klass.results(filters: {value: 1})).to eq [1]
+    describe '.results' do
+      it 'shortcut for creating new search and immediately returning results' do
+        klass = search_class [1, 2, 3]
+        expect(klass.results(filters: { value: 1 })).to eq [1]
       end
     end
 
-    describe "#results" do
-      it "returns only the filtered search results" do
-        search = new_search [1 ,2 ,3], value: 1
+    describe '#results' do
+      it 'returns only the filtered search results' do
+        search = new_search [1, 2, 3], value: 1
         expect(search.results).to eq [1]
       end
 
-      it "can apply several options" do
-        scope  = [1, 2, 3, 4, 5, 6, 7]
-        search = new_search scope, bigger_than: 3, odd: true do
+      it 'can apply several options' do
+        values  = [1, 2, 3, 4, 5, 6, 7]
+        search = new_search values, bigger_than: 3, odd: true do
           option :bigger_than do |scope, value|
-            scope.find_all { |v| v > value }
+            scope.select { |v| v > value }
           end
 
           option :odd do |scope, value|
-            scope.find_all(&:odd?) if value
+            scope.select(&:odd?) if value
           end
         end
 
         expect(search.results).to eq [5, 7]
       end
 
-      it "ignores invalid filters" do
+      it 'ignores invalid filters' do
         search = new_search [1, 2, 3], invalid: 'option'
         expect(search.results).to eq [1, 2, 3]
       end
 
-      it "can be overwritten by overwriting #fetch_results" do
+      it 'can be overwritten by overwriting #fetch_results' do
         search = new_search [1, 2, 3], value: 1 do
           option :value do |scope, value|
-            scope.find_all { |v| v == value }
+            scope.select { |v| v == value }
           end
 
           def fetch_results
@@ -179,8 +215,8 @@ module SearchObject
         expect(search.results).to eq ['~1~']
       end
 
-      it "applies to default options" do
-        search = new_search [1,2,3] do
+      it 'applies to default options' do
+        search = new_search [1, 2, 3] do
           option :value, 1 do |scope, value|
             scope.select { |v| v == value }
           end
@@ -189,23 +225,23 @@ module SearchObject
       end
     end
 
-    describe "#results?" do
-      it "returns true if there are results" do
-        expect(new_search([1,2,3], value: 1).results?).to be_true
+    describe '#results?' do
+      it 'returns true if there are results' do
+        expect(new_search([1, 2, 3], value: 1).results?).to be_truthy
       end
 
-      it "returns false if there aren't any results" do
-        expect(new_search([1,2,3], value: 4).results?).to be_false
+      it 'returns false if there are no results' do
+        expect(new_search([1, 2, 3], value: 4).results?).to be_falsey
       end
     end
 
-    describe "#count" do
-      it "counts the number of results" do
-        expect(new_search([1,2,3], value: 1).count).to eq 1
+    describe '#count' do
+      it 'counts the number of results' do
+        expect(new_search([1, 2, 3], value: 1).count).to eq 1
       end
 
-      it "can't be bypassed by plug ins" do
-        search = new_search [1,2,3] do
+      it 'can not be bypassed by plugins' do
+        search = new_search [1, 2, 3] do
           def fetch_results
             []
           end
@@ -215,28 +251,28 @@ module SearchObject
       end
     end
 
-    describe "#params" do
-      it "exports options as params" do
+    describe '#params' do
+      it 'exports options as params' do
         search = new_search [], value: 1
         expect(search.params).to eq 'value' => 1
       end
 
-      it "can overwrite options (mainly used for url handers)" do
+      it 'can overwrite options (mainly used for url handers)' do
         search = new_search [], value: 1
         expect(search.params(value: 2)).to eq 'value' => 2
       end
 
-      it "ignores missing options" do
+      it 'ignores missing options' do
         search = new_search
         expect(search.params).to eq({})
       end
 
-      it "ignores invalid options" do
+      it 'ignores invalid options' do
         search = new_search [], invalid: 'option'
         expect(search.params).to eq({})
       end
 
-      it "includes default options" do
+      it 'includes default options' do
         search = new_search do
           option :value, 1
         end

data/spec/search_object/helper_spec.rb

@@ -2,26 +2,26 @@ require 'spec_helper'
 
 module SearchObject
   describe Helper do
-    describe ".stringify_keys" do
-      it "converts hash keys to strings" do
+    describe '.stringify_keys' do
+      it 'converts hash keys to strings' do
         hash = Helper.stringify_keys a: 1, b: nil, c: false
         expect(hash).to eq 'a' => 1, 'b' => nil, 'c' => false
       end
     end
 
-    describe ".select_keys" do
-      it "selects only given keys" do
-        hash = Helper.select_keys({a: 1, b: 2, c:3}, [:a, :b])
+    describe '.select_keys' do
+      it 'selects only given keys' do
+        hash = Helper.select_keys({ a: 1, b: 2, c: 3 }, [:a, :b])
         expect(hash).to eq a: 1, b: 2
       end
 
-      it "ignores not existing keys" do
+      it 'ignores not existing keys' do
         hash = Helper.select_keys({}, [:a, :b])
         expect(hash).to eq({})
       end
     end
 
-    describe "camelize" do
+    describe 'camelize' do
       it "transforms :paging to 'Paging'" do
         expect(Helper.camelize(:paging)).to eq 'Paging'
       end

data/spec/search_object/plugin/kaminari_spec.rb

@@ -5,10 +5,10 @@ require_relative '../../support/kaminari_setup'
 module SearchObject
   module Plugin
     describe Kaminari do
-      it_behaves_like "a paging plugin" do
-        it "uses kaminari gem" do
+      it_behaves_like 'a paging plugin' do
+        it 'uses kaminari gem' do
           search = search_with_page
-          expect(search.results.respond_to? :total_pages).to be_true
+          expect(search.results.respond_to? :total_pages).to be_truthy
         end
       end
     end

data/spec/search_object/plugin/model_spec.rb

@@ -30,14 +30,18 @@ module SearchObject
       end
 
       def assert(condition, message = nil)
-        expect(condition).to be_true, message
+        expect(condition).to be_truthy, message
       end
 
       def assert_kind_of(expected_kind, object, message = nil)
         expect(object).to be_kind_of(expected_kind), message
       end
 
-      ActiveModel::Lint::Tests.public_instance_methods.map { |method| method.to_s }.grep(/^test/).each do |method|
+      def assert_equal(expected_value, value, message = nil)
+        expect(value).to eq(expected_value), message
+      end
+
+      ActiveModel::Lint::Tests.public_instance_methods.map(&:to_s).grep(/^test/).each do |method|
         example(method.gsub('_', ' ')) { send method }
       end
     end

data/spec/search_object/plugin/paging_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper_active_record'
 module SearchObject
   module Plugin
     describe Paging do
-      it_behaves_like "a paging plugin"
+      it_behaves_like 'a paging plugin'
     end
   end
 end

data/spec/search_object/plugin/sorting_spec.rb

@@ -17,123 +17,128 @@ module SearchObject
       end
 
       def search_with_sort(sort = nil, filters = {})
-        search_class.new filters: {sort: sort}.merge(filters)
+        search_class.new filters: { sort: sort }.merge(filters)
       end
 
-      describe "sorting" do
+      it 'can be inherited' do
+        child_class = Class.new(search_class)
+        expect(child_class.new.sort_attribute).to eq 'name'
+      end
+
+      describe 'sorting' do
         after do
           Product.delete_all
         end
 
-        it "sorts results based on the sort option" do
+        it 'sorts results based on the sort option' do
           5.times { |i| Product.create! price: i }
 
           search = search_with_sort 'price desc'
           expect(search.results.map(&:price)).to eq [4, 3, 2, 1, 0]
         end
 
-        it "defaults to first sort by option" do
+        it 'defaults to first sort by option' do
           5.times { |i| Product.create! name: "Name#{i}" }
 
           search = search_with_sort
           expect(search.results.map(&:name)).to eq %w(Name4 Name3 Name2 Name1 Name0)
         end
 
-        it "ignores invalid sort values" do
+        it 'ignores invalid sort values' do
           search = search_with_sort 'invalid attribute'
           expect { search.results.to_a }.not_to raise_error
         end
       end
 
-      describe "#sort?" do
-        it "matches the sort option" do
+      describe '#sort?' do
+        it 'matches the sort option' do
           search = search_with_sort 'price desc'
 
-          expect(search.sort?(:price)).to be_true
-          expect(search.sort?(:name)).to be_false
+          expect(search.sort?(:price)).to be_truthy
+          expect(search.sort?(:name)).to be_falsey
         end
 
-        it "matches string also" do
+        it 'matches string also' do
           search = search_with_sort 'price desc'
 
-          expect(search.sort?('price')).to be_true
-          expect(search.sort?('name')).to be_false
+          expect(search.sort?('price')).to be_truthy
+          expect(search.sort?('name')).to be_falsey
         end
 
-        it "matches exact strings" do
+        it 'matches exact strings' do
           search = search_with_sort 'price desc'
 
-          expect(search.sort?('price desc')).to be_true
-          expect(search.sort?('price asc')).to be_false
+          expect(search.sort?('price desc')).to be_truthy
+          expect(search.sort?('price asc')).to be_falsey
         end
       end
 
-      describe "#sort_attribute" do
-        it "returns sort option attribute" do
+      describe '#sort_attribute' do
+        it 'returns sort option attribute' do
           search = search_with_sort 'price desc'
           expect(search.sort_attribute).to eq 'price'
         end
 
-        it "defaults to the first sort by option" do
+        it 'defaults to the first sort by option' do
           search = search_with_sort
           expect(search.sort_attribute).to eq 'name'
         end
 
-        it "rejects invalid sort options, uses defaults" do
+        it 'rejects invalid sort options, uses defaults' do
           search = search_with_sort 'invalid'
           expect(search.sort_attribute).to eq 'name'
         end
       end
 
-      describe "#sort_direction" do
-        it "returns asc or desc" do
+      describe '#sort_direction' do
+        it 'returns asc or desc' do
           expect(search_with_sort('price desc').sort_direction).to eq 'desc'
           expect(search_with_sort('price asc').sort_direction).to eq 'asc'
         end
 
-        it "defaults to desc" do
+        it 'defaults to desc' do
           expect(search_with_sort.sort_direction).to eq 'desc'
           expect(search_with_sort('price').sort_direction).to eq 'desc'
         end
 
-        it "rejects invalid sort options, uses desc" do
+        it 'rejects invalid sort options, uses desc' do
           expect(search_with_sort('price foo').sort_direction).to eq 'desc'
         end
       end
 
-      describe "#sort_direction_for" do
-        it "returns desc if current sort attribute is not the given attribute" do
+      describe '#sort_direction_for' do
+        it 'returns desc if current sort attribute is not the given attribute' do
           expect(search_with_sort('price desc').sort_direction_for('name')).to eq 'desc'
         end
 
-        it "returns asc if current sort attribute is the given attribute" do
+        it 'returns asc if current sort attribute is the given attribute' do
           expect(search_with_sort('name desc').sort_direction_for('name')).to eq 'asc'
         end
 
-        it "returns desc if current sort attribute is the given attribute, but asc with direction" do
+        it 'returns desc if current sort attribute is the given attribute, but asc with direction' do
           expect(search_with_sort('name asc').sort_direction_for('name')).to eq 'desc'
         end
       end
 
-      describe "#sort_params_for" do
-        it "adds sort direction" do
+      describe '#sort_params_for' do
+        it 'adds sort direction' do
           search = search_with_sort 'name', name: 'test'
           expect(search.sort_params_for(:price)).to eq 'sort' => 'price desc', 'name' => 'test'
         end
 
-        it "reverses sort direction if this is the current sort attribute" do
+        it 'reverses sort direction if this is the current sort attribute' do
           search = search_with_sort 'name desc', name: 'test'
           expect(search.sort_params_for(:name)).to eq 'sort' => 'name asc', 'name' => 'test'
         end
 
-        it "accepts additional options" do
+        it 'accepts additional options' do
           search = search_with_sort
           expect(search.sort_params_for(:price, name: 'value')).to eq 'sort' => 'price desc', 'name' => 'value'
         end
       end
 
-      describe "#reverted_sort_direction" do
-        it "reverts sorting direction" do
+      describe '#reverted_sort_direction' do
+        it 'reverts sorting direction' do
           expect(search_with_sort('price desc').reverted_sort_direction).to eq 'asc'
           expect(search_with_sort('price asc').reverted_sort_direction).to eq 'desc'
         end

data/spec/search_object/plugin/will_paginate_spec.rb

@@ -6,10 +6,10 @@ require 'will_paginate/active_record'
 module SearchObject
   module Plugin
     describe WillPaginate do
-      it_behaves_like "a paging plugin" do
-        it "uses will_paginate gem" do
+      it_behaves_like 'a paging plugin' do
+        it 'uses will_paginate gem' do
           search = search_with_page
-          expect(search.results.respond_to? :total_entries).to be_true
+          expect(search.results.respond_to? :total_entries).to be_truthy
         end
       end
     end

data/spec/search_object/search_spec.rb

@@ -2,69 +2,68 @@ require 'spec_helper'
 
 module SearchObject
   describe Search do
-
-    describe ".params" do
-      it "returns the passed params" do
+    describe '.params' do
+      it 'returns the passed params' do
         search = Search.new('scope', 'params', {})
         expect(search.params).to eq 'params'
       end
     end
 
-    describe ".param" do
-      it "returns the param value" do
-        search = Search.new('scope', {name: 'value'}, {})
+    describe '.param' do
+      it 'returns the param value' do
+        search = Search.new('scope', { name: 'value' }, {})
         expect(search.param(:name)).to eq 'value'
       end
     end
 
-    describe ".query" do
-      it "returns filtered result" do
+    describe '.query' do
+      it 'returns filtered result' do
         actions = {
-          :min => ->(scope, min) { scope.select { |v| v > min } },
+          min: ->(scope, min) { scope.select { |v| v > min } }
         }
 
-        search = Search.new [1,2,3], {min: 2}, actions
+        search = Search.new [1, 2, 3], { min: 2 }, actions
         expect(search.query(Object.new)).to eq [3]
       end
 
-      it "applies actions to params" do
+      it 'applies actions to params' do
         actions = {
-          :min => ->(scope, min) { scope.select { |v| v > min } },
-          :max => ->(scope, max) { scope.select { |v| v < max } },
+          min: ->(scope, min) { scope.select { |v| v > min } },
+          max: ->(scope, max) { scope.select { |v| v < max } }
         }
 
-        search = Search.new [1,2,3,4,5], {min: 2, max: 5},  actions
-        expect(search.query(Object.new)).to eq [3,4]
+        search = Search.new [1, 2, 3, 4, 5], { min: 2, max: 5 },  actions
+        expect(search.query(Object.new)).to eq [3, 4]
       end
 
-      it "handles nil returned from action" do
+      it 'handles nil returned from action' do
         actions = {
-          :odd => ->(scope, odd) { scope.select(&:odd?) if odd }
+          odd: ->(scope, odd) { scope.select(&:odd?) if odd }
         }
 
-        search = Search.new [1,2,3,4,5], {odd: false}, actions
-        expect(search.query(Object.new)).to eq [1,2,3,4,5]
+        search = Search.new [1, 2, 3, 4, 5], { odd: false }, actions
+        expect(search.query(Object.new)).to eq [1, 2, 3, 4, 5]
       end
 
-      it "executes action in the passed context" do
+      it 'executes action in the passed context' do
         actions = {
-          :search => ->(scope, _) { scope.select { |v| v == target_value } }
+          search: ->(scope, _) { scope.select { |v| v == target_value } }
         }
 
         context = double target_value: 2
 
-        search = Search.new [1,2,3,4,5], {search: true}, actions
+        search = Search.new [1, 2, 3, 4, 5], { search: true }, actions
         expect(search.query(context)).to eq [2]
       end
     end
 
-    describe ".count" do
-      it "counts the results of the query" do
+    describe '.count' do
+      it 'counts the results of the query' do
         actions = {
-          :value => ->(scope, value) { scope.select { |v| v == value} }
+          value: ->(scope, value) { scope.select { |v| v == value } }
         }
 
-        search = Search.new [1,2,3], {value: 2}, actions
+        search = Search.new [1, 2, 3], { value: 2 }, actions
         expect(search.count(Object.new)).to eq 1
       end
     end

data/spec/spec_helper.rb

@@ -10,4 +10,3 @@ require 'search_object'
 RSpec.configure do |config|
   config.expect_with(:rspec) { |c| c.syntax = :expect }
 end
-