trailblazer-finder 0.1.2 → 0.1.3

data/lib/trailblazer/finder/base.rb

@@ -2,8 +2,6 @@ module Trailblazer
   class Finder
     # Base module
     module Base
-      PREDICATES = %w[eq not_eq].freeze
-
       def self.included(base)
         base.extend ClassMethods
         base.instance_eval do

data/lib/trailblazer/finder/features/predicate.rb

@@ -2,6 +2,8 @@ module Trailblazer
   class Finder
     module Features
       module Predicate
+        PREDICATES = %w[eq not_eq blank not_blank lt lte gt gte].freeze
+
         def self.included(base)
           base.extend ClassMethods
           base.instance_eval do
@@ -10,7 +12,7 @@ module Trailblazer
         end
 
         module ClassMethods
-          def do_filters(attribute, predicate)
+          def predicate_filter(attribute, predicate)
             filter_by "#{attribute}_#{predicate}" do |entity_type, value|
               splitter = Utils::Splitter.new "#{attribute}_#{predicate}", value
               splitter.split_key predicate.to_sym
@@ -20,14 +22,7 @@ module Trailblazer
 
           def predicates_for(*attributes)
             attributes.each do |attribute|
-              do_filters(attribute, "eq")
-              do_filters(attribute, "not_eq")
-              do_filters(attribute, "blank")
-              do_filters(attribute, "not_blank")
-              do_filters(attribute, "gt")
-              do_filters(attribute, "gte")
-              do_filters(attribute, "lt")
-              do_filters(attribute, "lte")
+              PREDICATES.each { |predicate| predicate_filter(attribute, predicate) }
             end
           end
         end

data/lib/trailblazer/finder/features/sorting.rb

@@ -5,55 +5,97 @@ module Trailblazer
         def self.included(base)
           base.extend ClassMethods
           base.instance_eval do
-            filter_by :sort do |entity_type, _|
-              sort_it(entity_type, sort_attribute, sort_direction)
+            filter_by :sort do |entity_type, value|
+              next sort_it(entity_type, [sort_orders(sort_attribute(value), sort_direction(value))]) if value.nil?
+              sort_attributes = value.split(',')
+              sorters = []
+              sort_attributes.each do |sort_attr|
+                sorters << sort_orders(sort_attribute(sort_attr), sort_direction(sort_attr))
+              end
+              sort_it(entity_type, sorters)
             end
           end
         end
 
-        # Adapters will overwite this method
-        def sort_it(entity_type, sort_attribute, sort_direction)
-          case sort_direction
-          when 'asc', 'ascending'
-            entity_type.sort_by { |a| a[sort_attribute.to_sym] }
-          when 'desc', 'descending'
-            entity_type.sort_by { |a| a[sort_attribute.to_sym] }.reverse
-          end
-        end
-
         def sort?(attribute)
-          attribute == sort || sort.to_s.start_with?("#{attribute} ")
+          sort.include?(attribute.to_s)
         end
 
-        def sort_attribute
-          @sort_attribute ||= Utils::Extra.ensure_included sort.to_s.split(' ', 2).first, self.class.sort_attributes
+        def sort_direction_for(attribute)
+          return 'asc' if !sort.nil? && sort.include?("#{attribute} asc")
+          'desc'
         end
 
-        def sort_direction
-          @sort_direction ||= Utils::Extra.ensure_included sort.to_s.split(' ', 2).last, %w[desc asc]
+        def reverse_sort_direction_for(attribute)
+          return 'desc' if sort_direction_for(attribute) == 'asc'
+          'asc'
         end
 
-        def sort_direction_for(attribute)
-          if sort_attribute == attribute.to_s
-            reverted_sort_direction
-          else
-            'desc'
-          end
+        def sort_params_for(attribute, options = {})
+          options['sort'] = if sort.nil?
+                              "#{attribute} #{sort_direction_for(attribute)}"
+                            elsif sort.include?(attribute.to_s)
+                              sort
+                            else
+                              "#{attribute} #{sort_direction_for(attribute)}"
+                            end
+          params options
         end
 
-        def sort_params_for(attribute, options = {})
+        def new_sort_params_for(attribute, options = {})
           options['sort'] = "#{attribute} #{sort_direction_for(attribute)}"
           params options
         end
 
-        def reverted_sort_direction
-          sort_direction == 'desc' ? 'asc' : 'desc'
+        def add_sort_params_for(attribute, options = {})
+          options['sort'] = if sort.nil?
+                              "#{attribute} #{sort_direction_for(attribute)}"
+                            elsif sort.include?(attribute.to_s)
+                              sort.gsub(/#{attribute} #{sort_direction_for(attribute)}/, "#{attribute} #{reverse_sort_direction_for(attribute)}")
+                            else
+                              "#{sort}, #{attribute} #{sort_direction_for(attribute)}"
+                            end
+          params options
+        end
+
+        private
+
+        # ORM Adapters will overwite this method
+        def sort_it(entity_type, sort_attributes)
+          entity_type.sort do |this, that|
+            sort_attributes.reduce(0) do |diff, order|
+              next diff if diff != 0 # this and that have differed at an earlier order entry
+              key, direction = order
+              # deal with nil cases
+              next  0 if this[key].nil? && that[key].nil?
+              next  1 if this[key].nil?
+              next -1 if that[key].nil?
+              # do the actual comparison
+              comparison = this[key] <=> that[key]
+              comparison * direction
+            end
+          end
+        end
+
+        # ORM Adapters will overwite this method
+        def sort_orders(sort_attr, sort_dir)
+          [sort_attr.to_sym, (sort_dir.to_sym == :asc ? 1 : -1)]
+        end
+
+        def sort_attribute(attribute)
+          result = Utils::Extra.ensure_included attribute.to_s.split(' ', 2).first, self.class.sort_attributes
+          result
+        end
+
+        def sort_direction(attribute)
+          return Utils::Extra.ensure_included attribute.to_s.split(' ', 2).last, %w[desc asc] unless attribute.nil?
+          'desc'
         end
 
         module ClassMethods
+          attr_accessor :sorted_attributes
           def sortable_by(*attributes)
-            config[:sort_attributes]  = attributes.map(&:to_s)
-            config[:defaults]['sort'] = "#{config[:sort_attributes].first} desc"
+            config[:sort_attributes] = attributes.map(&:to_s)
           end
 
           def sort_attributes

data/lib/trailblazer/finder/utils/deep_locate.rb

@@ -2,35 +2,20 @@ module Trailblazer
   class Finder
     module Utils
       module DeepLocate
-        def self.deep_locate(comparator, object)
-          comparator = _construct_key_comparator(comparator, object) unless comparator.respond_to?(:call)
-
-          _deep_locate(comparator, object)
-        end
-
-        def self._construct_key_comparator(search_key, object)
-          search_key = search_key.to_s if defined?(::ActiveSupport::HashWithIndifferentAccess) && object.is_a?(::ActiveSupport::HashWithIndifferentAccess)
-          search_key = search_key.to_s if object.respond_to?(:indifferent_access?) && object.indifferent_access?
-
-          lambda do |non_callable_object|
-            ->(key, _, _) { key == non_callable_object }
-          end.call(search_key)
-        end
-
-        def self._deep_locate(comparator, object, result = [])
+        def self.deep_locate(comparator, object, result = [])
           if object.is_a?(::Enumerable)
-            if object.any? { |value| _match_comparator?(value, comparator, object) }
+            if object.any? { |value| match_comparator?(value, comparator, object) }
               result.push object
             end
             (object.respond_to?(:values) ? object.values : object.entries).each do |value|
-              _deep_locate(comparator, value, result)
+              deep_locate(comparator, value, result)
             end
           end
 
           result
         end
 
-        def self._match_comparator?(value, comparator, object)
+        def self.match_comparator?(value, comparator, object)
           if object.is_a?(::Hash)
             key, value = value
           else

data/lib/trailblazer/finder/utils/parse.rb

@@ -7,13 +7,13 @@ module Trailblazer
       class Parse
         # Need a replacement for this
         def self.date(value)
-          return if value.nil?
-          return if [true, false].include? value
-          return if value.is_a? Integer
-          return if value =~ /[[:alpha:]]/
+          return unless valid_date(value)
           Date.parse(value).strftime('%Y-%m-%d')
-        rescue ArgumentError
-          nil
+        end
+
+        def self.valid_date(date)
+          date_hash = Date._parse(date.to_s)
+          Date.valid_date?(date_hash[:year].to_i, date_hash[:mon].to_i, date_hash[:mday].to_i)
         end
 
         def self.term(value)

data/lib/trailblazer/finder/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Finder
-    VERSION = '0.1.2'.freeze
+    VERSION = '0.1.3'.freeze
   end
 end

data/spec/spec_helper.rb

@@ -12,4 +12,5 @@ end
 require 'coveralls'
 Coveralls.wear!
 
+require_relative 'support/sorting_shared_example'
 require 'trailblazer/finder'

data/spec/spec_helper_active_record.rb

@@ -1,6 +1,5 @@
 require_relative 'spec_helper'
 require_relative 'support/paging_shared_example'
-require_relative 'support/sorting_shared_example'
 require 'active_record'
 
 ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'

data/spec/support/sorting_shared_example.rb

@@ -1,71 +1,90 @@
 shared_examples_for 'a sorting feature' do
   describe '#sort?' do
-    it 'matches the sort option' do
+    it 'says if the requested item is sorted on, for single sort' do
       finder = finder_with_sort 'price desc'
 
       expect(finder).to be_sort :price
       expect(finder).not_to be_sort :name
     end
 
-    it 'matches string also' do
+    it 'says if the requested item is sorted on for multiple sorts' do
+      finder = finder_with_sort 'price desc, name asc, id desc'
+
+      expect(finder).to be_sort :price
+      expect(finder).to be_sort :name
+      expect(finder).to be_sort :id
+      expect(finder).not_to be_sort :created_at
+    end
+
+    it 'matches string also, for single sort' do
       finder = finder_with_sort 'price desc'
 
       expect(finder).to be_sort 'price'
       expect(finder).not_to be_sort 'name'
     end
 
-    it 'matches exact strings' do
-      finder = finder_with_sort 'price desc'
+    it 'matches string also, for multiple sorts' do
+      finder = finder_with_sort 'price desc, name asc, id desc'
 
-      expect(finder).to be_sort 'price desc'
-      expect(finder).not_to be_sort 'price asc'
+      expect(finder).to be_sort 'price'
+      expect(finder).to be_sort 'name'
+      expect(finder).to be_sort 'id'
+      expect(finder).not_to be_sort 'created_at'
     end
-  end
 
-  describe '#sort_attribute' do
-    it 'returns sort option attribute' do
+    it 'matches exact strings, for single sort' do
       finder = finder_with_sort 'price desc'
-      expect(finder.sort_attribute).to eq 'price'
-    end
 
-    it 'defaults to the first sort by option' do
-      finder = finder_with_sort
-      expect(finder.sort_attribute).to eq 'name'
+      expect(finder).to be_sort 'price desc'
+      expect(finder).not_to be_sort 'price asc'
     end
 
-    it 'rejects invalid sort options, uses defaults' do
-      finder = finder_with_sort 'invalid'
-      expect(finder.sort_attribute).to eq 'name'
+    it 'matches exact strings, for multiple sort' do
+      finder = finder_with_sort 'price desc, name asc'
+
+      expect(finder).to be_sort 'price desc'
+      expect(finder).to be_sort 'name asc'
+      expect(finder).not_to be_sort 'name desc'
     end
   end
 
-  describe '#sort_direction' do
-    it 'returns asc or desc' do
-      expect(finder_with_sort('price desc').sort_direction).to eq 'desc'
-      expect(finder_with_sort('price asc').sort_direction).to eq 'asc'
+  describe '#sort_direction_for' do
+    it 'returns desc if current sort attribute is not the given attribute' do
+      expect(finder_with_sort('price desc').sort_direction_for('name')).to eq 'desc'
     end
 
-    it 'defaults to desc' do
-      expect(finder_with_sort.sort_direction).to eq 'desc'
-      expect(finder_with_sort('price').sort_direction).to eq 'desc'
+    it 'returns asc if current sort attribute is the given attribute' do
+      expect(finder_with_sort('name desc').sort_direction_for('name')).to eq 'desc'
     end
 
-    it 'rejects invalid sort options, uses desc' do
-      expect(finder_with_sort('price foo').sort_direction).to eq 'desc'
+    it 'returns desc if current sort attribute is the given attribute, but asc with direction' do
+      expect(finder_with_sort('name asc').sort_direction_for('name')).to eq 'asc'
     end
   end
 
-  describe '#sort_direction_for' do
+  describe '#reverse_sort_direction_for' do
     it 'returns desc if current sort attribute is not the given attribute' do
-      expect(finder_with_sort('price desc').sort_direction_for('name')).to eq 'desc'
+      expect(finder_with_sort('price desc').reverse_sort_direction_for('name')).to eq 'asc'
     end
 
     it 'returns asc if current sort attribute is the given attribute' do
-      expect(finder_with_sort('name desc').sort_direction_for('name')).to eq 'asc'
+      expect(finder_with_sort('name desc').reverse_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(finder_with_sort('name asc').sort_direction_for('name')).to eq 'desc'
+      expect(finder_with_sort('name asc').reverse_sort_direction_for('name')).to eq 'desc'
+    end
+  end
+
+  describe '#new_sort_params_for' do
+    it 'adds new sort parmas when none are present' do
+      finder = finder_with_sort
+      expect(finder.new_sort_params_for(:price)).to eq 'sort' => 'price desc'
+    end
+
+    it 'adds new sort params when multiple ones exists (replaces them all)' do
+      finder = finder_with_sort 'name desc, price desc, id asc', name: 'test'
+      expect(finder.new_sort_params_for(:name)).to eq 'sort' => 'name desc', 'name' => 'test'
     end
   end
 
@@ -75,9 +94,10 @@ shared_examples_for 'a sorting feature' do
       expect(finder.sort_params_for(:price)).to eq 'sort' => 'price desc', 'name' => 'test'
     end
 
-    it 'reverses sort direction if this is the current sort attribute' do
-      finder = finder_with_sort 'name desc', name: 'test'
-      expect(finder.sort_params_for(:name)).to eq 'sort' => 'name asc', 'name' => 'test'
+    it 'finds params for multiple sorts' do
+      finder = finder_with_sort 'name desc, price desc, id asc', name: 'test'
+      expect(finder.sort_params_for(:name)).to eq 'sort' => 'name desc, price desc, id asc', 'name' => 'test'
+      expect(finder.sort_params_for(:price)).to eq 'sort' => 'name desc, price desc, id asc', 'name' => 'test'
     end
 
     it 'accepts additional options' do
@@ -86,10 +106,20 @@ shared_examples_for 'a sorting feature' do
     end
   end
 
-  describe '#reverted_sort_direction' do
-    it 'reverts sorting direction' do
-      expect(finder_with_sort('price desc').reverted_sort_direction).to eq 'asc'
-      expect(finder_with_sort('price asc').reverted_sort_direction).to eq 'desc'
+  describe '#add_sort_params_for' do
+    it 'adds sort params when none exists' do
+      finder = finder_with_sort
+      expect(finder.add_sort_params_for(:price)).to eq 'sort' => 'price desc'
+    end
+
+    it 'adds sort params when one already exists' do
+      finder = finder_with_sort 'name', name: 'test'
+      expect(finder.add_sort_params_for(:price)).to eq 'sort' => 'name, price desc', 'name' => 'test'
+    end
+
+    it 'adds sort params when current attribute already exists, but change it' do
+      finder = finder_with_sort 'name asc, price asc', name: 'test'
+      expect(finder.add_sort_params_for(:price)).to eq 'sort' => 'name asc, price desc', 'name' => 'test'
     end
   end
 end

data/spec/trailblazer/finder/adapters/active_record/predicates_spec.rb

@@ -6,6 +6,11 @@ module Trailblazer
     module Adapters
       module ActiveRecord
         describe Predicates do
+          after do
+            Product.delete_all
+            Product.reset_pk_sequence
+          end
+
           class TestFinder < Trailblazer::Finder
             features Predicate
             adapters ActiveRecord
@@ -23,8 +28,6 @@ module Trailblazer
 
           describe 'equals' do
             before do
-              Product.delete_all
-              Product.reset_pk_sequence
               10.times do |i|
                 next Product.create name: "", price: "1#{i}" if i == 7
                 next Product.create name: nil, price: "1#{i}" if i == 8

data/spec/trailblazer/finder/adapters/active_record/sorting_spec.rb

@@ -1,86 +1,99 @@
 require 'spec_helper_active_record'
 
-module Trailblazer
-  class Finder
-    module Adapters
-      module ActiveRecord
-        describe Sorting do
-          def finder_class
-            Class.new do
-              include Trailblazer::Finder::Base
-              include Trailblazer::Finder::Features::Sorting
-              include Trailblazer::Finder::Adapters::ActiveRecord
-
-              entity_type { Product.all }
-
-              sortable_by :name, :price, :created_at
-
-              filter_by :name
-              filter_by :price
-              filter_by(:category) { |entity_type, _| entity_type.joins(:category) }
-            end
-          end
-
-          def finder_with_sort(sort = nil, filters = {})
-            finder_class.new filter: { sort: sort }.merge(filters)
-          end
-
-          it 'can be inherited' do
-            child_class = Class.new(finder_class)
-            expect(child_class.new.sort_attribute).to eq 'name'
-          end
-
-          describe 'sorting' do
-            before do
-              Product.delete_all
-            end
-
-            after do
-              Product.delete_all
-            end
-
-            it 'sorts results based on the sort option desc' do
-              5.times { |i| Product.create! price: i }
-
-              finder = finder_with_sort 'price desc'
-              expect(finder.results.map(&:price)).to eq [4, 3, 2, 1, 0]
-            end
-
-            it 'sorts results based on the sort option asc' do
-              5.times { |i| Product.create! price: i }
-
-              finder = finder_with_sort 'price asc'
-              expect(finder.results.map(&:price)).to eq [0, 1, 2, 3, 4]
-            end
-
-            it 'defaults to first sort by option' do
-              5.times { |i| Product.create! name: "Name#{i}" }
-
-              finder = finder_with_sort
-              expect(finder.results.map(&:name)).to eq %w[Name4 Name3 Name2 Name1 Name0]
-            end
-
-            it 'ignores invalid sort values' do
-              finder = finder_with_sort 'invalid attribute'
-              expect { finder.results.to_a }.not_to raise_error
-            end
-
-            it 'can handle renames of sorting in joins' do
-              older_category = Category.create! title: 'older'
-              newer_category = Category.create! title: 'newer'
-
-              product_of_newer_category = Product.create! name: 'older product', category: newer_category
-              product_of_older_category = Product.create! name: 'newer product', category: older_category
-
-              finder = finder_with_sort 'created_at desc', category: ''
-
-              expect(finder.results.map(&:name)).to eq [product_of_older_category.name, product_of_newer_category.name]
-            end
-          end
-
-          it_behaves_like 'a sorting feature'
-        end
+describe "Trailblazer::Finder::Adapters::ActiveRecord::Sorting", :sorting do
+  after do
+    Product.delete_all
+    Product.reset_pk_sequence
+  end
+
+  before do
+    Product.delete_all
+    Product.reset_pk_sequence
+  end
+
+  class TestARFinder < Trailblazer::Finder
+    features Sorting
+    adapters ActiveRecord
+
+    entity_type { Product.all }
+
+    sortable_by :name, :price, :created_at
+
+    filter_by :name
+    filter_by :price
+  end
+
+  def finder_with_sort(sort = nil, filters = {})
+    TestARFinder.new filter: (sort.nil? ? {} : { sort: sort }).merge(filters)
+  end
+
+  describe 'sorting' do
+
+    it 'sorts results based on the sort option desc' do
+      5.times { |i| Product.create! price: i }
+
+      finder = finder_with_sort 'price desc'
+      expect(finder.results.map(&:price)).to eq [4, 3, 2, 1, 0]
+    end
+
+    it 'sorts results based on the sort option asc' do
+      5.times { |i| Product.create! price: i }
+
+      finder = finder_with_sort 'price asc'
+      expect(finder.results.map(&:price)).to eq [0, 1, 2, 3, 4]
+    end
+
+    it 'defaults to defaulted database sort if none is set' do
+      5.times { |i| Product.create! name: "Name#{i}" }
+
+      finder = finder_with_sort
+      expect(finder.results.map(&:name)).to eq %w[Name0 Name1 Name2 Name3 Name4]
+    end
+
+    it 'ignores invalid sort values' do
+      finder = finder_with_sort 'invalid attribute'
+      expect { finder.results.to_a }.not_to raise_error
+    end
+
+    it 'can handle renames of sorting in joins' do
+      older_category = Category.create! title: 'older'
+      newer_category = Category.create! title: 'newer'
+
+      product_of_newer_category = Product.create! name: 'older product', category: newer_category
+      product_of_older_category = Product.create! name: 'newer product', category: older_category
+
+      finder = finder_with_sort 'created_at desc', category: ''
+
+      expect(finder.results.map(&:name)).to eq [product_of_older_category.name, product_of_newer_category.name]
+    end
+  end
+
+  describe 'sorting by multiple' do
+    before do
+      5.times do |i|
+        Product.create name: "Name#{i}", price: "1#{i}"
       end
+      Product.create name: 'Name3', price: '8'
+    end
+
+    it 'sorts by multiple columns name asc and price asc' do
+      finder = finder_with_sort 'name asc, price asc'
+      expect(finder.results.map(&:name)).to eq %w[Name0 Name1 Name2 Name3 Name3 Name4]
+      expect(finder.results.map(&:price)).to eq [10, 11, 12, 8, 13, 14]
+    end
+
+    it 'sorts by multiple columns name asc and price desc' do
+      finder = finder_with_sort 'name asc, price desc'
+      expect(finder.results.map(&:name)).to eq %w[Name0 Name1 Name2 Name3 Name3 Name4]
+      expect(finder.results.map(&:price)).to eq [10, 11, 12, 13, 8, 14]
+    end
+
+    it 'sorts by multiple columns name desc and price desc' do
+      finder = finder_with_sort 'name desc, price desc'
+      expect(finder.results.map(&:name)).to eq %w[Name4 Name3 Name3 Name2 Name1 Name0]
+      expect(finder.results.map(&:price)).to eq [14, 13, 8, 12, 11, 10]
     end
   end
+
+  it_behaves_like 'a sorting feature'
 end