trailblazer-finder 0.1.1 → 0.1.2

data/lib/trailblazer/finder/adapters/friendly_id.rb

@@ -1,31 +1,29 @@
-if Gem.loaded_specs.key?('activerecord')
-  module Trailblazer
-    class Finder
-      module Adapters
-        # FriendlyId Adapter
-        module FriendlyId
-          def self.included(base)
-            base.extend ClassMethods
-            base.class_eval do
-              filter_by :id, with: :apply_slug_filter
-            end
+module Trailblazer
+  class Finder
+    module Adapters
+      # FriendlyId Adapter
+      module FriendlyId
+        def self.included(base)
+          base.extend ClassMethods
+          base.class_eval do
+            filter_by :id, with: :apply_slug_filter
           end
+        end
 
-          def apply_slug_filter(entity_type, value)
-            return if value.nil?
-            return if value == ''
-            if num?(value)
-              entity_type.where(id: value)
-            else
-              entity_type.where(slug: Utils::String.underscore(value.downcase))
-            end
+        def apply_slug_filter(entity_type, value)
+          return if value.nil?
+          return if value == ''
+          if num?(value)
+            entity_type.where(id: value)
+          else
+            entity_type.where(slug: Utils::String.underscore(value.downcase))
           end
+        end
 
-          def num?(str)
-            Integer(str)
-          rescue ArgumentError, TypeError
-            false
-          end
+        def num?(str)
+          Integer(str)
+        rescue ArgumentError, TypeError
+          false
         end
       end
     end

data/lib/trailblazer/finder/adapters/sequel.rb

@@ -1,5 +1,6 @@
 require 'trailblazer/finder/adapters/sequel/paging'
 require 'trailblazer/finder/adapters/sequel/sorting'
+require 'trailblazer/finder/adapters/sequel/predicates'
 
 module Trailblazer
   class Finder
@@ -8,6 +9,10 @@ module Trailblazer
       module Sequel
         def self.included(base)
           base.extend ClassMethods
+          base.instance_eval do
+            include Sequel::Predicates if defined?(Features::Predicate::ClassMethods)
+          end
+          # require 'trailblazer/finder/adapters/sequel/predicates' if defined?(Features::Predicates::ClassMethods)
         end
 
         module ClassMethods

data/lib/trailblazer/finder/adapters/sequel/predicates.rb

@@ -0,0 +1,43 @@
+module Trailblazer
+  class Finder
+    module Adapters
+      module Sequel
+        # Sequel - Predicates Adapter
+        module Predicates
+
+          def not_eq(attribute, value, entity_type)
+            entity_type.exclude(attribute.to_sym => value.to_s)
+          end
+
+          def eq(attribute, value, entity_type)
+            entity_type.where(attribute.to_sym => value.to_s)
+          end
+
+          def blank(attribute, value, entity_type)
+            entity_type.where(attribute.to_sym => nil).or(attribute.to_sym => "")
+          end
+
+          def not_blank(attribute, value, entity_type)
+            entity_type.exclude(attribute.to_sym => nil).exclude(attribute.to_sym => "")
+          end
+
+          def gt(attribute, value, entity_type)
+            entity_type.where{::Sequel[attribute.to_sym] > value.to_f}
+          end
+
+          def gte(attribute, value, entity_type)
+            entity_type.where{::Sequel[attribute.to_sym] >= value.to_f}
+          end
+
+          def lt(attribute, value, entity_type)
+            entity_type.where{::Sequel[attribute.to_sym] < value.to_f}
+          end
+
+          def lte(attribute, value, entity_type)
+            entity_type.where{::Sequel[attribute.to_sym] <= value.to_f}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/base.rb

@@ -1,9 +1,9 @@
-require 'hashie/extensions/deep_locate'
-
 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
@@ -88,7 +88,7 @@ module Trailblazer
           else
             lambda do |entity_type, value|
               return if Utils::String.blank?(value)
-              Hashie::Extensions::DeepLocate.deep_locate ->(k, v, _object) { k == key.to_sym && v == value }, entity_type
+              Utils::DeepLocate.deep_locate ->(k, v, _object) { k == key.to_sym && v == value }, entity_type
             end
           end
         end

data/lib/trailblazer/finder/features.rb

@@ -1,5 +1,6 @@
 require 'trailblazer/finder/features/paging'
 require 'trailblazer/finder/features/sorting'
+require 'trailblazer/finder/features/predicate'
 
 module Trailblazer
   class Finder

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

@@ -0,0 +1,37 @@
+module Trailblazer
+  class Finder
+    module Features
+      module Predicate
+        def self.included(base)
+          base.extend ClassMethods
+          base.instance_eval do
+            include Predicates
+          end
+        end
+
+        module ClassMethods
+          def do_filters(attribute, predicate)
+            filter_by "#{attribute}_#{predicate}" do |entity_type, value|
+              splitter = Utils::Splitter.new "#{attribute}_#{predicate}", value
+              splitter.split_key predicate.to_sym
+              send splitter.op, splitter.field, splitter.value, entity_type
+            end
+          end
+
+          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")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/filter.rb

@@ -21,7 +21,7 @@ module Trailblazer
       module Handler
         module_function
 
-        def build(name, defined_bys) # rubocop:disable Metrics/MethodLength
+        def build(name, defined_bys) 
           defined_bys = defined_bys.map(&:to_s)
           handler = self
           lambda do |entity_type, value|
@@ -35,7 +35,7 @@ module Trailblazer
           end
         end
 
-        def apply_filter(object:, filter_by:, defined_bys:, entity_type:, value:) # rubocop:disable Metrics/MethodLength
+        def apply_filter(object:, filter_by:, defined_bys:, entity_type:, value:) 
           return if value.nil? || value == ''
 
           unless defined_bys.include? value

data/lib/trailblazer/finder/predicates.rb

@@ -0,0 +1,39 @@
+module Trailblazer
+  class Finder
+    module Predicates
+      def not_eq(attribute, value, entity_type)
+        return if Utils::String.blank?(value.to_s)
+        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_s != value.to_s && v != nil }, entity_type
+      end
+
+      def eq(attribute, value, entity_type)
+        return if Utils::String.blank?(value.to_s)
+        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_s == value.to_s && v != nil }, entity_type
+      end
+
+      def blank(attribute, _value, entity_type)
+        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && Utils::String.blank?(v.to_s) }, entity_type
+      end
+
+      def not_blank(attribute, _value, entity_type)
+        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && !Utils::String.blank?(v.to_s) }, entity_type
+      end
+
+      def gt(attribute, value, entity_type)
+        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_i > value.to_f }, entity_type
+      end
+
+      def gte(attribute, value, entity_type)
+        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_i >= value.to_f }, entity_type
+      end
+
+      def lt(attribute, value, entity_type)
+        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_i < value.to_f }, entity_type
+      end
+
+      def lte(attribute, value, entity_type)
+        Utils::DeepLocate.deep_locate ->(k, v, _object) { k == attribute.to_sym && v.to_i <= value.to_f }, entity_type
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+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 = [])
+          if object.is_a?(::Enumerable)
+            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)
+            end
+          end
+
+          result
+        end
+
+        def self._match_comparator?(value, comparator, object)
+          if object.is_a?(::Hash)
+            key, value = value
+          else
+            key = nil
+          end
+
+          comparator.call(key, value, object)
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module Trailblazer
           end
         end
 
-        def self.deep_copy(object) # rubocop:disable Metrics/MethodLength
+        def self.deep_copy(object)
           case object
           when Array
             object.map { |element| deep_copy(element) }

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

@@ -0,0 +1,42 @@
+module Trailblazer
+  class Finder
+    # Helper module
+    module Utils
+      class Splitter
+        def initialize( key, value )
+          @key, @value = key, value
+        end
+
+        attr_reader :key, :value
+
+        # split suffix from the key and store the two values as name and op
+        # return truthy if successful
+        def split_key( suffix )
+          rv = @key =~ /\A(?:(.*?)_)?(#{suffix})\z/
+          @field, @op = $1, $2
+          rv
+        end
+
+        alias_method :===, :split_key
+        alias_method :=~, :split_key
+
+        # return name if the split was successful, or fall back to key
+        # which is handy when none of the predicates match and so key
+        # is probably just a field name.
+        def field
+          (@field || @key)
+        end
+
+        # the operator, or predicate
+        def op
+          @op.to_sym
+        end
+
+        # the value
+        def value
+          @value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/version.rb

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

data/spec/spec_helper_sequel.rb

@@ -3,6 +3,7 @@ require_relative 'support/paging_shared_example'
 require_relative 'support/sorting_shared_example'
 require 'sequel'
 Sequel::Model.plugin :timestamps
+
 DB = Sequel.sqlite
 
 DB.create_table :s_products do

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

@@ -16,7 +16,7 @@ module Trailblazer
           end
         end
 
-        def finder_class(&block) # rubocop:disable Metrics/MethodLength
+        def finder_class(&block) 
           define_finder_class do
             adapters ActiveRecord
 

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

@@ -0,0 +1,98 @@
+require 'spec_helper_active_record'
+# require 'spec_helper'
+
+module Trailblazer
+  class Finder
+    module Adapters
+      module ActiveRecord
+        describe Predicates do
+          class TestFinder < Trailblazer::Finder
+            features Predicate
+            adapters ActiveRecord
+
+            entity_type { Product }
+
+            predicates_for :name, :price, :created_at
+
+            filter_by(:category) { |entity_type, _| entity_type.joins(:category) }
+          end
+
+          def finder_with_predicate(filter = nil, value = nil, filters = {})
+            TestFinder.new filter: { filter => value }.merge(filters)
+          end
+
+          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
+                next Product.create name: "product_4", price: "1#{i}" if i == 9
+                Product.create name: "product_#{i}", price: "1#{i}"
+              end
+            end
+
+            it 'it finds single row with name equal to product_5' do
+              finder = finder_with_predicate 'name_eq', 'product_5'
+              expect(finder.results.map(&:price)).to eq [15]
+            end
+
+            it 'it finds multiple rows with name equal to product_4' do
+              finder = finder_with_predicate 'name_eq', 'product_4'
+              expect(finder.results.map(&:price)).to eq [14, 19]
+            end
+
+            it 'it finds rows with name not equal to product_4' do
+              finder = finder_with_predicate 'name_not_eq', 'product_4'
+              expect(finder.results.map(&:name)).to eq ["product_0", "product_1", "product_2", "product_3", "product_5", "product_6", ""]
+              expect(finder.results.map(&:price)).to eq [10, 11, 12, 13, 15, 16, 17]
+            end
+
+            it 'it finds multiple rows with name blank (empty/nil)' do
+              finder = finder_with_predicate 'name_blank', ''
+              expect(finder.results.map(&:price)).to eq [17, 18]
+            end
+
+            it 'it finds multiple rows with name not blank (empty/nil)' do
+              finder = finder_with_predicate 'name_not_blank', ''
+              expect(finder.results.map(&:name)).to eq ["product_0", "product_1", "product_2", "product_3", "product_4", "product_5", "product_6", "product_4"]
+            end
+
+            it 'it finds multiple rows with price less than 15' do
+              finder = finder_with_predicate 'price_lt', 15
+              expect(finder.results.map(&:name)).to eq ["product_0", "product_1", "product_2", "product_3", "product_4"]
+              expect(finder.results.map(&:price)).to eq [10, 11, 12, 13, 14]
+            end
+
+            it 'it finds multiple rows with price equal to and less than 15' do
+              finder = finder_with_predicate 'price_lte', 15
+              expect(finder.results.map(&:name)).to eq ["product_0", "product_1", "product_2", "product_3", "product_4", "product_5"]
+              expect(finder.results.map(&:price)).to eq [10, 11, 12, 13, 14, 15]
+            end
+
+            it 'it finds multiple rows with price greater than 15' do
+              finder = finder_with_predicate 'price_gt', 15
+              expect(finder.results.map(&:name)).to eq ["product_6", "", nil, "product_4"]
+              expect(finder.results.map(&:price)).to eq [16, 17, 18, 19]
+            end
+
+            it 'it finds multiple rows with price equal to and greater than 15' do
+              finder = finder_with_predicate 'price_gte', 15
+              expect(finder.results.map(&:name)).to eq ["product_5", "product_6", "", nil, "product_4"]
+              expect(finder.results.map(&:price)).to eq [15, 16, 17, 18, 19]
+            end
+
+            it 'it finds rows with name not equal to product_4 and name not blank and price greater than 14' do
+              params = { name_not_blank: true, price_gt: 14 }
+              finder = finder_with_predicate 'name_not_eq', 'product_4', params
+
+              expect(finder.results.map(&:name)).to eq ["product_5", "product_6"]
+              expect(finder.results.map(&:price)).to eq [15, 16]
+            end
+          end
+        end
+      end
+    end
+  end
+end