trailblazer-finder 0.1.0

data/spec/trailblazer/finder/filter_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'ostruct'
+
+module Trailblazer
+  class Finder
+    describe Filter do
+      class TestFind
+        include Trailblazer::Finder::Base
+        include Trailblazer::Finder::Filter
+
+        entity_type { [1, 2, 3, 4, 5] }
+
+        filter_by :filter, defined_by: %w[odd even]
+
+        private
+
+        def apply_filter_with_odd(entity_type)
+          entity_type.select(&:odd?)
+        end
+
+        def apply_filter_with_even(entity_type)
+          entity_type.select(&:even?)
+        end
+
+        def handle_invalid_filter(_entity_type, value)
+          "invalid filter - #{value}"
+        end
+      end
+
+      it 'can filter by defined values' do
+        expect(TestFind.results(filter: { filter: 'odd' })).to eq [1, 3, 5]
+        expect(TestFind.results(filter: { filter: 'even' })).to eq [2, 4]
+      end
+
+      it 'ignores blank values' do
+        expect(TestFind.results(filter: { filter: nil })).to eq [1, 2, 3, 4, 5]
+        expect(TestFind.results(filter: { filter: '' })).to eq [1, 2, 3, 4, 5]
+      end
+
+      it 'handles wrongly defined values' do
+        expect(TestFind.results(filter: { filter: 'foo' })).to eq 'invalid filter - foo'
+      end
+
+      it 'raises when block is passed with defined filter' do
+        expect do
+          Class.new do
+            include Trailblazer::Finder::Base
+            include Trailblazer::Finder::Filter
+
+            filter_by(:filter, defined_by: %w[a b]) { |_entity_type, _value| nil }
+          end
+        end.to raise_error Trailblazer::Finder::Error::BlockIgnored
+      end
+
+      it 'raises when :with is passed with defined filter_by' do
+        expect do
+          Class.new do
+            include Trailblazer::Finder::Base
+            include Trailblazer::Finder::Filter
+
+            filter_by :filter, defined_by: %w[a b], with: :method_name
+          end
+        end.to raise_error Trailblazer::Finder::Error::WithIgnored
+      end
+    end
+
+    describe Filter::Handler do
+      describe 'apply_filter' do
+        def new_object(&block)
+          klass = Class.new(&block)
+          klass.new
+        end
+
+        def call(object: nil, filter_by: nil, defined_bys: nil, entity_type: nil, value:)
+          described_class.apply_filter(
+            object: object || new_object,
+            filter_by: filter_by || 'filter_by',
+            defined_bys: defined_bys || [value],
+            entity_type: entity_type || [],
+            value: value
+          )
+        end
+
+        it 'filters by methods based on the defined value' do
+          object = new_object do
+            private
+
+            def apply_select_with_name(entity_type)
+              entity_type.select { |value| value == 'name' }
+            end
+
+            def apply_select_with_age(entity_type)
+              entity_type.select { |value| value == 'age' }
+            end
+          end
+
+          entity_type = %w[name age location]
+
+          expect(call(object: object, filter_by: 'select', entity_type: entity_type, value: 'name')).to eq %w[name]
+          expect(call(object: object, filter_by: 'select', entity_type: entity_type, value: 'age')).to eq %w[age]
+        end
+
+        it 'raises NoMethodError when object can not handle defined method' do
+          expect { call(defined_bys: ['a'], value: 'a') }.to raise_error NoMethodError
+        end
+
+        it 'raises error when value is not defined' do
+          expect { call(defined_bys: [], value: 'invalid') }.to raise_error Trailblazer::Finder::Error::InvalidDefinedByValue
+        end
+
+        it 'can delegate missing defined value to object' do
+          object = new_object do
+            def handle_invalid_filter_by(_entity_type, value)
+              "handles #{value} value"
+            end
+          end
+
+          expect(call(object: object, defined_bys: [], value: 'invalid')).to eq 'handles invalid value'
+        end
+
+        it 'can delegate missing defined value to object (cath all)' do
+          object = new_object do
+            def handle_invalid_defined_by(filter_by, _entity_type, value)
+              "handles #{value} value for #{filter_by}"
+            end
+          end
+
+          expect(call(object: object, defined_bys: [], value: 'invalid')).to eq 'handles invalid value for filter_by'
+        end
+      end
+    end
+  end
+end

data/spec/trailblazer/finder/find_spec.rb

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

data/spec/trailblazer/finder/utils/extra_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Trailblazer
+  class Finder
+    module Utils
+      describe Extra do
+        describe '.deep_copy' do
+          it 'returns a deep copy on the given object' do
+            original = {
+              array: [1, 2, 3],
+              hash: { key: 'value' },
+              boolean: true,
+              number: 1,
+              null: nil
+            }
+
+            deep_copy = Finder::Utils::Extra.deep_copy(original)
+
+            original[:array][0] = 42
+            original[:hash][:key] = 'other value'
+
+            expect(deep_copy).to eq(
+              array: [1, 2, 3],
+              hash: { key: 'value' },
+              boolean: true,
+              number: 1,
+              null: nil
+            )
+          end
+        end
+
+        describe '.ensure_included' do
+          it 'works' do
+            str = Utils::Extra.ensure_included '1 2'.to_s.split(' ', 2).last, %w[1]
+            expect(str).to eq('1')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/trailblazer/finder/utils/params_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Trailblazer
+  class Finder
+    module Utils
+      describe Params do
+        describe '.slice_keys' do
+          it 'selects only given keys' do
+            hash = Finder::Utils::Params.slice_keys({ a: 1, b: 2, c: 3 }, %i[a b])
+            expect(hash).to eq a: 1, b: 2
+          end
+
+          it 'ignores not existing keys' do
+            hash = Finder::Utils::Params.slice_keys({}, %i[a b])
+            expect(hash).to eq({})
+          end
+        end
+
+        describe '.normalize_params' do
+          it 'combines defaults and filters' do
+            expect(Finder::Utils::Params.normalize_params({ 'a' => 1, 'b' => 2 }, { a: 2 }, %w[a b])).to eq 'a' => 2, 'b' => 2
+          end
+
+          it 'excludes non specified keys' do
+            expect(Finder::Utils::Params.normalize_params({ 'a' => 1 }, { b: 2 }, %w[a])).to eq 'a' => 1
+          end
+
+          it 'handles missing defaults' do
+            expect(Finder::Utils::Params.normalize_params(nil, { a: 1 }, %w[a])).to eq 'a' => 1
+          end
+
+          it 'handles missing filters' do
+            expect(Finder::Utils::Params.normalize_params(nil, nil, ['a'])).to eq({})
+          end
+        end
+      end
+    end
+  end
+end

data/spec/trailblazer/finder/utils/parse_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Trailblazer
+  class Finder
+    module Utils
+      describe Parse do
+        describe '.parse_date' do
+          it 'returns when value is a date' do
+            expect(Finder::Utils::Parse.date('2018-01-01')).to eq '2018-01-01'
+          end
+
+          it 'returns when value is a screwed up date like 02-2018-01 10:10:10' do
+            expect(Finder::Utils::Parse.date('02-2018-01 10:10')).to eq '2018-01-02'
+          end
+
+          it 'returns nil value is not date worthy' do
+            expect(Finder::Utils::Parse.date('Unknown')).to eq nil
+          end
+        end
+
+        describe '.escape_term' do
+          it 'returns escaped value' do
+            expect(Finder::Utils::Parse.term('term')).to eq '%term%'
+          end
+
+          it 'returns mutliple escaped values' do
+            expect(Finder::Utils::Parse.term('term term')).to eq '%term%term%'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/trailblazer/finder/utils/string_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Trailblazer
+  class Finder
+    module Utils
+      describe String do
+        describe '.camelize' do
+          it "transforms :paging to 'Paging'" do
+            expect(Finder::Utils::String.camelize(:paging)).to eq 'Paging'
+          end
+        end
+
+        describe '.underscore' do
+          it "transforms 'veryPopular' to 'very_popular'" do
+            expect(Finder::Utils::String.underscore(:veryPopular)).to eq 'very_popular'
+          end
+
+          it "transforms 'Very Popular' to 'very_popular'" do
+            expect(Finder::Utils::String.underscore('Very Popular')).to eq 'very_popular'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/trailblazer/operation/finder_spec.rb

@@ -0,0 +1,103 @@
+require 'delegate'
+require 'trailblazer'
+require 'spec_helper_active_record'
+
+class Product::FinderNoEntity < Trailblazer::Finder
+  adapters ActiveRecord
+
+  filter_by :id
+  filter_by :name
+  filter_by :escaped_name, with: :apply_escaped_name
+
+  def apply_escaped_name(entity_type, value)
+    return unless value.present?
+    entity_type.where 'lower(name) LIKE ?', Utils::Parse.term(value.downcase)
+  end
+end
+
+class Product::FinderWithEntity < Trailblazer::Finder
+  adapters ActiveRecord
+
+  entity_type { Product }
+
+  filter_by :id
+  filter_by :name
+  filter_by :escaped_name, with: :apply_escaped_name
+
+  def apply_escaped_name(entity_type, value)
+    return unless value.present?
+    entity_type.where 'lower(name) LIKE ?', Utils::Parse.term(value.downcase)
+  end
+end
+
+class Product::Index < Trailblazer::Operation
+  step Finder(Product::FinderNoEntity, :all, Product)
+end
+
+class Product::Show < Trailblazer::Operation
+  step Finder(Product::FinderNoEntity, :single, Product)
+end
+
+class Product::IndexNoEntity < Trailblazer::Operation
+  step Finder(Product::FinderWithEntity, :all)
+end
+
+class Product::ShowNoEntity < Trailblazer::Operation
+  step Finder(Product::FinderWithEntity, :single)
+end
+
+
+describe 'Trailblazer::Operation - Finder Macro' do
+  before do
+    Product.destroy_all
+    Product.reset_pk_sequence
+    20.times { |i| Product.create name: "product_#{i}" }
+  end
+
+  after do
+    Product.destroy_all
+    Product.reset_pk_sequence
+  end
+
+  it 'Can find a single row by id' do
+    params = { id: 5 }
+    result = Product::Show.call(params: params)
+
+    expect(result[:finder].name).to eq 'product_4'
+  end
+
+  it 'Can find a single row by name' do
+    params = { f: { name: 'product_2' } }
+    result = Product::Show.call(params: params)
+
+    expect(result[:finder].name).to eq 'product_2'
+  end
+
+  it 'Can find multiple rows by escaped name' do
+    params = { f: { escaped_name: 'product_1' } }
+    result = Product::Index.call(params: params)
+
+    expect(result[:finder].results.last.name).to eq 'product_19'
+  end
+
+  it 'Can find a single row by id when no entity type is given in macro' do
+    params = { id: 8 }
+    result = Product::ShowNoEntity.call(params: params)
+
+    expect(result[:finder].name).to eq 'product_7'
+  end
+
+  it 'Can find a single row by name when no entity type is given in macro' do
+    params = { f: { name: 'product_2' } }
+    result = Product::ShowNoEntity.call(params: params)
+
+    expect(result[:finder].name).to eq 'product_2'
+  end
+
+  it 'Can find multiple rows by escaped name when no entity type is given in macro' do
+    params = { f: { escaped_name: 'product_1' } }
+    result = Product::IndexNoEntity.call(params: params)
+
+    expect(result[:finder].results.last.name).to eq 'product_19'
+  end
+end

data/spec/trailblazer/operation/paging_spec.rb

@@ -0,0 +1,68 @@
+require 'delegate'
+require 'trailblazer'
+require 'spec_helper_active_record'
+
+class Product::PagingFinderNoEntity < Trailblazer::Finder
+  features Paging
+
+  adapters ActiveRecord
+
+  per_page 2
+  min_per_page 2
+  max_per_page 10
+
+  filter_by :id
+  filter_by :name
+end
+
+class Product::PagingFinderWithEntity < Trailblazer::Finder
+  features Paging
+
+  adapters ActiveRecord
+
+  entity_type { Product }
+
+  per_page 2
+  min_per_page 2
+  max_per_page 10
+
+  filter_by :id
+  filter_by :name
+end
+
+class Product::PagingIndex < Trailblazer::Operation
+  step Finder(Product::PagingFinderNoEntity, :all, Product)
+end
+
+class Product::PagingIndexNoEntity < Trailblazer::Operation
+  step Finder(Product::PagingFinderWithEntity, :all)
+end
+
+describe 'Trailblazer::Operation - Finder Macro - Paging' do
+  before do
+    Product.destroy_all
+    Product.reset_pk_sequence
+    20.times { |i| Product.create name: "product_#{i}" }
+  end
+
+  after do
+    Product.destroy_all
+    Product.reset_pk_sequence
+  end
+
+  it 'Can paginate results' do
+    params = { page: 2 }
+    result = Product::PagingIndex.call(params: params)
+
+    expect(result[:finder].count).to eq 20
+    expect(result[:finder].results).to eq Product.limit(2).offset(2)
+  end
+
+  it 'Can paginate results when no entity type is given in macro' do
+    params = { page: 2 }
+    result = Product::PagingIndexNoEntity.call(params: params)
+
+    expect(result[:finder].count).to eq 20
+    expect(result[:finder].results).to eq Product.limit(2).offset(2)
+  end
+end

data/spec/trailblazer/operation/sorting_spec.rb

@@ -0,0 +1,80 @@
+require 'delegate'
+require 'trailblazer'
+require 'spec_helper_active_record'
+
+class Product::SortFinderNoEntity < Trailblazer::Finder
+  features Sorting
+
+  adapters ActiveRecord
+
+  sortable_by :id, :name
+
+  filter_by :id
+  filter_by :name
+end
+
+class Product::SortFinderWithEntity < Trailblazer::Finder
+  features Sorting
+
+  adapters ActiveRecord
+
+  entity_type { Product }
+
+  sortable_by :id, :name
+
+  filter_by :id
+  filter_by :name
+end
+
+class Product::SortIndex < Trailblazer::Operation
+  step Finder(Product::SortFinderNoEntity, :all, Product)
+end
+
+class Product::SortIndexNoEntity < Trailblazer::Operation
+  step Finder(Product::SortFinderWithEntity, :all)
+end
+
+describe 'Trailblazer::Operation - Finder Macro - Sorting' do
+  before do
+    Product.destroy_all
+    Product.reset_pk_sequence
+    20.times { |i| Product.create name: "product_#{i}" }
+  end
+
+  after do
+    Product.destroy_all
+    Product.reset_pk_sequence
+  end
+
+  it 'Can sort results by name descending' do
+    params = { f: { sort: 'name desc' } }
+    result = Product::SortIndex.call(params: params)
+
+    expect(result[:finder].count).to eq 20
+    expect(result[:finder].results.last.name).to eq 'product_0'
+  end
+
+  it 'Can sort results by name descending when no entity type is given in macro' do
+    params = { f: { sort: 'name desc' } }
+    result = Product::SortIndexNoEntity.call(params: params)
+
+    expect(result[:finder].count).to eq 20
+    expect(result[:finder].results.last.name).to eq 'product_0'
+  end
+
+  it 'Can sort results by id ascending' do
+    params = { f: { sort: 'id asc' } }
+    result = Product::SortIndex.call(params: params)
+
+    expect(result[:finder].count).to eq 20
+    expect(result[:finder].results.last.name).to eq 'product_19'
+  end
+
+  it 'Can sort results by id ascending when no entity type is given in macro' do
+    params = { f: { sort: 'id asc' } }
+    result = Product::SortIndexNoEntity.call(params: params)
+
+    expect(result[:finder].count).to eq 20
+    expect(result[:finder].results.last.name).to eq 'product_19'
+  end
+end

data/trailblazer-finder.gemspec

@@ -0,0 +1,41 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'trailblazer/finder/version'
+
+Gem::Specification.new do |spec|
+  spec.name           = 'trailblazer-finder'
+  spec.version        = Trailblazer::Finder::VERSION
+  spec.date           = '2018-03-11'
+  spec.description    = %q{Trailblazer Finder object DSL}
+  spec.summary        = %q{Provides DSL for creating trailblazer based finder objects}
+  spec.authors        = ["Nick Sutterer", "Marc Tich"]
+  spec.email          = ["apotonick@gmail.com", "marc@mudsu.com"]
+  spec.homepage       = 'http://trailblazer.to'
+  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_dependency 'hashie', '~> 3.5'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'sequel'
+  spec.add_development_dependency 'activerecord'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'will_paginate'
+  spec.add_development_dependency 'kaminari'
+  spec.add_development_dependency 'kaminari-activerecord'
+  spec.add_development_dependency 'rspec', '~> 3.5'
+  spec.add_development_dependency 'rspec-mocks', '~> 3.5'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-rspec'
+  spec.add_development_dependency 'data_mapper'
+  spec.add_development_dependency 'dm-sqlite-adapter'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'trailblazer', '>= 2.1.0.beta4'
+  spec.add_development_dependency 'rspec_junit_formatter'
+
+  spec.required_ruby_version = '>= 2.1.0'
+end