search_object 0.1

data/lib/search_object/version.rb

@@ -0,0 +1,3 @@
+module SearchObject
+  VERSION = '0.1'
+end

data/search_object.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'search_object/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "search_object"
+  spec.version       = SearchObject::VERSION
+  spec.authors       = ["Radoslav Stankov"]
+  spec.email         = ["rstankov@gmail.com"]
+  spec.description   = %q{Search object DSL}
+  spec.summary       = %q{Provides DSL for creating search objects}
+  spec.homepage      = "https://github.com/RStankov/SearchObject"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec', '~> 2.14'
+  spec.add_development_dependency 'rspec-mocks', '>= 2.12.3'
+  spec.add_development_dependency 'activerecord', '>= 3.0.0'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'active_model_lint-rspec'
+  spec.add_development_dependency 'will_paginate'
+  spec.add_development_dependency 'kaminari'
+end

data/spec/search_object/base_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+
+module SearchObject
+  describe Base do
+    def new_search(default_scope = [], filters = {}, &block)
+      search_class = Class.new do
+        include SearchObject.module
+
+        scope { default_scope }
+
+        if block.nil?
+          option :value do |scope, value|
+            scope.find_all { |v| v == value }
+          end
+        else
+          class_eval &block
+        end
+      end
+
+      search_class.new filters
+    end
+
+    it "can had its #initialize method overwritten" do
+      search = new_search do
+        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
+      search1 = new_search [1, 2, 3], filter: 1 do
+        option :filter do |scope, value|
+          scope.select { |v| v == value }
+        end
+      end
+
+      search2 = new_search [1, 2, 3], filter: 1 do
+        option :filter, 2 do |scope, value|
+          scope.reject { |v| v == value }
+        end
+      end
+
+      expect(search1.results).not_to eq search2.results
+    end
+
+    context "no scope" do
+      def search_class
+        Class.new do
+          include SearchObject.module
+
+          option :name do
+          end
+        end
+      end
+
+      it "treats first argument as scope" do
+        expect(search_class.new('scope').results).to eq 'scope'
+      end
+
+      it "treats second argument as filters" do
+        expect(search_class.new('scope', name: 'name').params).to eq 'name' => 'name'
+      end
+    end
+
+    describe "option" do
+      it "has default filter" do
+        scope = [1, 2, 3]
+        expect(scope).to receive(:where).with('value' => 1) { 'results' }
+
+        search = new_search scope, value: 1 do
+          option :value
+        end
+
+        expect(search.results).to eq 'results'
+      end
+
+      it "returns the scope if nil returned" do
+        scope = [1, 2, 3]
+        search = new_search scope, value: 'some' do
+          option :value do
+            nil
+          end
+        end
+
+        expect(search.results).to eq scope
+      end
+
+      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)
+          end
+
+          private
+
+          def some_instance_method(scope, value)
+            scope.select { |v| v == value }
+          end
+        end
+
+        expect(search1.results).to eq [1]
+      end
+    end
+
+    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
+        search = new_search do
+          option :value, 1
+        end
+        expect(search.value).to eq 1
+      end
+
+      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 "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
+          option :bigger_than do |scope, value|
+            scope.find_all { |v| v > value }
+          end
+
+          option :odd do |scope, value|
+            scope.find_all(&:odd?) if value
+          end
+        end
+
+        expect(search.results).to eq [5, 7]
+      end
+
+      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
+        search = new_search [1, 2, 3], value: 1 do
+          option :value do |scope, value|
+            scope.find_all { |v| v == value }
+          end
+
+          def fetch_results
+            super.map { |v| "~#{v}~" }
+          end
+        end
+
+        expect(search.results).to eq ['~1~']
+      end
+
+      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
+        end
+        expect(search.results).to eq [1]
+      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
+      end
+
+      it "returns false if there aren't any results" do
+        expect(new_search([1,2,3], value: 4).results?).to be_false
+      end
+    end
+
+    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
+          def fetch_results
+            []
+          end
+        end
+
+        expect(search.count).to eq 3
+      end
+    end
+
+    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
+        search = new_search [], value: 1
+        expect(search.params(value: 2)).to eq 'value' => 2
+      end
+
+      it "ignores missing options" do
+        search = new_search
+        expect(search.params).to eq({})
+      end
+
+      it "ignores invalid options" do
+        search = new_search [], invalid: 'option'
+        expect(search.params).to eq({})
+      end
+
+      it "includes default options" do
+        search = new_search do
+          option :value, 1
+        end
+        expect(search.params).to eq 'value' => 1
+      end
+    end
+  end
+end

data/spec/search_object/helper_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module SearchObject
+  describe Helper 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])
+        expect(hash).to eq a: 1, b: 2
+      end
+
+      it "ignores not existing keys" do
+        hash = Helper.select_keys({}, [:a, :b])
+        expect(hash).to eq({})
+      end
+    end
+
+    describe "camelize" do
+      it "transforms :paging to 'Paging'" do
+        expect(Helper.camelize(:paging)).to eq 'Paging'
+      end
+    end
+  end
+end

data/spec/search_object/plugin/kaminari_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper_active_record'
+
+require_relative '../../support/kaminari_setup'
+
+module SearchObject
+  module Plugin
+    describe Paging do
+      def search_class
+        Class.new do
+          include SearchObject.module(:kaminari)
+
+          scope { Product }
+
+          per_page 2
+        end
+      end
+
+      after do
+        Product.delete_all
+      end
+
+      it "paginates" do
+        10.times { |i| Product.create name: "product_#{i}" }
+        search = search_class.new({}, 3)
+        expect(search.results.map(&:name)).to eq %w(product_4 product_5)
+      end
+
+      it "uses will paginate" do
+        search = search_class.new
+        expect(search.results.respond_to? :total_pages).to be_true
+      end
+
+      it "treats nil page as 0" do
+        search = search_class.new({}, nil)
+        expect(search.page).to eq 0
+      end
+
+      it "treats negative page numbers as positive" do
+        search = search_class.new({}, -1)
+        expect(search.page).to eq 1
+      end
+
+      it "gives the real count" do
+        10.times { |i| Product.create name: "product_#{i}" }
+        search = search_class.new({}, 1)
+        expect(search.count).to eq 10
+      end
+    end
+  end
+end

data/spec/search_object/plugin/model_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+require 'active_model_lint-rspec'
+
+module SearchObject
+  module Plugin
+    class ExtendedModel
+      include SearchObject.module(:model)
+
+      # Fake errors
+      # Since SearchObject is focused to plain search forms,
+      # which don't have validation most of the time
+      def errors
+        Hash.new([])
+      end
+    end
+
+    describe ExtendedModel do
+      it_behaves_like 'an ActiveModel'
+    end
+  end
+end

data/spec/search_object/plugin/paging_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper_active_record'
+
+module SearchObject
+  module Plugin
+    describe Paging do
+      def search_class
+        Class.new do
+          include SearchObject.module(:paging)
+
+          scope { Product }
+
+          per_page 2
+        end
+      end
+
+      after do
+        Product.delete_all
+      end
+
+      it "paginates results (by offset and limit)" do
+        10.times { |i| Product.create name: "product_#{i}" }
+        search = search_class.new({}, 1)
+        expect(search.results.map(&:name)).to eq %w(product_2 product_3)
+      end
+
+      it "treats nil page as 0" do
+        search = search_class.new({}, nil)
+        expect(search.page).to eq 0
+      end
+
+      it "treats negative page numbers as positive" do
+        search = search_class.new({}, -1)
+        expect(search.page).to eq 1
+      end
+
+      it "gives the real count" do
+        10.times { |i| Product.create name: "product_#{i}" }
+        search = search_class.new({}, 1)
+        expect(search.count).to eq 10
+      end
+    end
+  end
+end

data/spec/search_object/plugin/sorting_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper_active_record'
+
+module SearchObject
+  module Plugin
+    describe Sorting do
+      def search_class
+        Class.new do
+          include SearchObject.module(:sorting)
+
+          scope { Product.all }
+
+          sort_by :name, :price
+
+          option :name
+          option :price
+        end
+      end
+
+      describe "sorting" do
+        after do
+          Product.delete_all
+        end
+
+        it "sorts results based on the sort option" do
+          5.times { |i| Product.create! price: i }
+
+          search = search_class.new sort: 'price desc'
+          expect(search.results.map(&:price)).to eq [4, 3, 2, 1, 0]
+        end
+
+        it "defaults to first sort by option" do
+          5.times { |i| Product.create! name: "Name#{i}" }
+
+          search = search_class.new
+          expect(search.results.map(&:name)).to eq %w(Name4 Name3 Name2 Name1 Name0)
+        end
+
+        it "ignores invalid sort values" do
+          search = search_class.new sort: 'invalid attribute'
+          expect { search.results.to_a }.not_to raise_error
+        end
+      end
+
+      describe "#sort?" do
+        it "matches the sort option" do
+          search = search_class.new sort: 'price desc'
+
+          expect(search.sort?(:price)).to be_true
+          expect(search.sort?(:name)).to be_false
+        end
+
+        it "matches string also" do
+          search = search_class.new sort: 'price desc'
+
+          expect(search.sort?('price')).to be_true
+          expect(search.sort?('name')).to be_false
+        end
+
+        it "matches exact strings" do
+          search = search_class.new sort: 'price desc'
+
+          expect(search.sort?('price desc')).to be_true
+          expect(search.sort?('price asc')).to be_false
+        end
+      end
+
+      describe "#sort_attribute" do
+        it "returns sort option attribute" do
+          search = search_class.new sort: 'price desc'
+          expect(search.sort_attribute).to eq 'price'
+        end
+
+        it "defaults to the first sort by option" do
+          search = search_class.new
+          expect(search.sort_attribute).to eq 'name'
+        end
+
+        it "rejects invalid sort options, uses defaults" do
+          search = search_class.new sort: 'invalid'
+          expect(search.sort_attribute).to eq 'name'
+        end
+      end
+
+      describe "#sort_direction" do
+        it "returns asc or desc" do
+          expect(search_class.new(sort: 'price desc').sort_direction).to eq 'desc'
+          expect(search_class.new(sort: 'price asc').sort_direction).to eq 'asc'
+        end
+
+        it "defaults to desc" do
+          expect(search_class.new.sort_direction).to eq 'desc'
+          expect(search_class.new(sort: 'price').sort_direction).to eq 'desc'
+        end
+
+        it "rejects invalid sort options, uses desc" do
+          expect(search_class.new(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
+          expect(search_class.new(sort: 'price desc').sort_direction_for('name')).to eq 'desc'
+        end
+
+        it "returns asc if current sort attribute is the given attribute" do
+          expect(search_class.new(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
+          expect(search_class.new(sort: 'name asc').sort_direction_for('name')).to eq 'desc'
+        end
+      end
+
+      describe "#sort_params_for" do
+        it "adds sort direction" do
+          search = search_class.new 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
+          search = search_class.new sort: 'name desc', name: 'test'
+          expect(search.sort_params_for(:name)).to eq 'sort' => 'name asc', 'name' => 'test'
+        end
+
+        it "accepts additional options" do
+          search = search_class.new
+          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
+          expect(search_class.new(sort: 'price desc').reverted_sort_direction).to eq 'asc'
+          expect(search_class.new(sort: 'price asc').reverted_sort_direction).to eq 'desc'
+        end
+      end
+    end
+  end
+end