trailblazer-finder 0.1.4 → 0.2.5

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Adapters
+      # ActiveRecord Adapter
+      module Basic
+        # Basic Predicates Adapter
+        module Predicates
+          module_function
+
+          def set_eq_handler
+            lambda do |entity, attribute, value|
+              return if Utils::String.blank?(value.to_s) || Utils::String.blank?(attribute.to_s)
+
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && v.to_s == value.to_s && !v.nil? }, entity
+            end
+          end
+
+          def set_not_eq_handler
+            lambda do |entity, attribute, value|
+              return if Utils::String.blank?(value.to_s)
+
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && v.to_s != value.to_s && !v.nil? }, entity
+            end
+          end
+
+          def set_blank_handler
+            lambda do |entity, attribute, _value|
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && Utils::String.blank?(v.to_s) }, entity
+            end
+          end
+
+          def set_not_blank_handler
+            lambda do |entity, attribute, _value|
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && !Utils::String.blank?(v.to_s) }, entity
+            end
+          end
+
+          def set_gt_handler
+            lambda do |entity, attribute, value|
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && v.to_f > value.to_f }, entity
+            end
+          end
+
+          def set_gte_handler
+            lambda do |entity, attribute, value|
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && v.to_f >= value.to_f }, entity
+            end
+          end
+
+          def set_lt_handler
+            lambda do |entity, attribute, value|
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && v.to_f < value.to_f }, entity
+            end
+          end
+
+          def set_lte_handler
+            lambda do |entity, attribute, value|
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && v.to_i <= value.to_f }, entity
+            end
+          end
+
+          def set_cont_handler
+            lambda do |entity, attribute, value|
+              return if Utils::String.blank?(value.to_s) || Utils::String.blank?(attribute.to_s)
+
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && v.to_s.include?(value.to_s) && !v.nil? }, entity
+            end
+          end
+
+          def set_not_cont_handler
+            lambda do |entity, attribute, value|
+              return if Utils::String.blank?(value.to_s) || Utils::String.blank?(attribute.to_s)
+
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && !v.to_s.include?(value.to_s) && !v.nil? }, entity
+            end
+          end
+
+          def set_sw_handler
+            lambda do |entity, attribute, value|
+              return if Utils::String.blank?(value.to_s) || Utils::String.blank?(attribute.to_s)
+
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && v.to_s.start_with?(value.to_s) && !v.nil? }, entity
+            end
+          end
+
+          def set_not_sw_handler
+            lambda do |entity, attribute, value|
+              return if Utils::String.blank?(value.to_s) || Utils::String.blank?(attribute.to_s)
+
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && !v.to_s.start_with?(value.to_s) && !v.nil? }, entity
+            end
+          end
+
+          def set_ew_handler
+            lambda do |entity, attribute, value|
+              return if Utils::String.blank?(value.to_s) || Utils::String.blank?(attribute.to_s)
+
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && v.to_s.end_with?(value.to_s) && !v.nil? }, entity
+            end
+          end
+
+          def set_not_ew_handler
+            lambda do |entity, attribute, value|
+              return if Utils::String.blank?(value.to_s) || Utils::String.blank?(attribute.to_s)
+
+              Utils::Hash.deep_locate ->(k, v, _) { k == attribute.to_sym && !v.to_s.end_with?(value.to_s) && !v.nil? }, entity
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/basic/sorting.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Adapters
+      # ActiveRecord Adapter
+      module Basic
+        # Basic Paging Adapter
+        module Sorting
+          module_function
+
+          def set_sorting_handler
+            lambda do |sort_attributes, entity|
+              sort_attributes.delete(:handler)
+              attributes = []
+              sort_attributes.each do |attr|
+                attributes << [attr[0].to_sym, (attr[1] == :asc ? 1 : -1)]
+              end
+              entity.sort do |this, that|
+                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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/adapters/kaminari/paging.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Adapters
+      # ActiveRecord Adapter
+      module Kaminari
+        # Kaminari Paging Adapter
+        module Paging
+          module_function
+
+          def set_paging_handler
+            lambda do |current_page, per_page, entity|
+              entity.page(current_page).per(per_page)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,17 +1,18 @@
+# frozen_string_literal: true
+
 module Trailblazer
   class Finder
     module Adapters
+      # ActiveRecord Adapter
       module Sequel
-        # Sequel - Paging Adapter
+        # ActiveRecord Paging Adapter
         module Paging
-          def self.included(base)
-            base.extend Features::Paging::ClassMethods
-          end
-
-          private
+          module_function
 
-          def apply_paging(entity_type)
-            entity_type.limit(per_page).offset(([page, 1].max - 1) * per_page)
+          def set_paging_handler
+            lambda do |current_page, per_page, entity|
+              entity.limit(per_page).offset(([current_page, 1].max - 1) * per_page)
+            end
           end
         end
       end

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

@@ -1,40 +1,101 @@
+# frozen_string_literal: true
+
 module Trailblazer
   class Finder
     module Adapters
+      # ActiveRecord Adapter
       module Sequel
-        # Sequel - Predicates Adapter
+        # ActiveRecord Predicates Adapter
         module Predicates
+          module_function
+
+          def set_eq_handler
+            lambda do |entity, attribute, value|
+              return if Utils::String.blank?(value.to_s)
+
+              entity.where { ::Sequel[attribute.to_sym] =~ value }
+            end
+          end
+
+          def set_not_eq_handler
+            lambda do |entity, attribute, value|
+              return if Utils::String.blank?(value.to_s)
+
+              entity.where { ::Sequel[attribute.to_sym] !~ value }
+            end
+          end
+
+          def set_blank_handler
+            lambda do |entity, attribute, _value|
+              entity.where { ::Sequel.|({::Sequel[attribute.to_sym] => nil}, {::Sequel[attribute.to_sym] => ""}) }
+            end
+          end
+
+          def set_not_blank_handler
+            lambda do |entity, attribute, _value|
+              entity.exclude(::Sequel[attribute.to_sym] => nil, ::Sequel[attribute.to_sym] => "")
+              # entity.exclude(attribute.to_sym => nil).exclude(attribute.to_sym => "")
+            end
+          end
+
+          def set_gt_handler
+            lambda do |entity, attribute, value|
+              entity.where { ::Sequel[attribute.to_sym] > value.to_f }
+            end
+          end
+
+          def set_gte_handler
+            lambda do |entity, attribute, value|
+              entity.where { ::Sequel[attribute.to_sym] >= value.to_f }
+            end
+          end
 
-          def not_eq(attribute, value, entity_type)
-            entity_type.exclude(attribute.to_sym => value.to_s)
+          def set_lt_handler
+            lambda do |entity, attribute, value|
+              entity.where { ::Sequel[attribute.to_sym] < value.to_f }
+            end
           end
 
-          def eq(attribute, value, entity_type)
-            entity_type.where(attribute.to_sym => value.to_s)
+          def set_lte_handler
+            lambda do |entity, attribute, value|
+              entity.where { ::Sequel[attribute.to_sym] <= value.to_f }
+            end
           end
 
-          def blank(attribute, value, entity_type)
-            entity_type.where(attribute.to_sym => nil).or(attribute.to_sym => "")
+          def set_cont_handler
+            lambda do |entity, attribute, value|
+              entity.where(::Sequel.like(attribute.to_sym, "%#{value}%"))
+            end
           end
 
-          def not_blank(attribute, value, entity_type)
-            entity_type.exclude(attribute.to_sym => nil).exclude(attribute.to_sym => "")
+          def set_not_cont_handler
+            lambda do |entity, attribute, value|
+              entity.where(~::Sequel.like(attribute.to_sym, "%#{value}%"))
+            end
           end
 
-          def gt(attribute, value, entity_type)
-            entity_type.where{::Sequel[attribute.to_sym] > value.to_f}
+          def set_sw_handler
+            lambda do |entity, attribute, value|
+              entity.where(::Sequel.like(attribute.to_sym, "#{value}%"))
+            end
           end
 
-          def gte(attribute, value, entity_type)
-            entity_type.where{::Sequel[attribute.to_sym] >= value.to_f}
+          def set_not_sw_handler
+            lambda do |entity, attribute, value|
+              entity.where(~::Sequel.like(attribute.to_sym, "#{value}%"))
+            end
           end
 
-          def lt(attribute, value, entity_type)
-            entity_type.where{::Sequel[attribute.to_sym] < value.to_f}
+          def set_ew_handler
+            lambda do |entity, attribute, value|
+              entity.where(::Sequel.like(attribute.to_sym, "%#{value}"))
+            end
           end
 
-          def lte(attribute, value, entity_type)
-            entity_type.where{::Sequel[attribute.to_sym] <= value.to_f}
+          def set_not_ew_handler
+            lambda do |entity, attribute, value|
+              entity.where(~::Sequel.like(attribute.to_sym, "%#{value}"))
+            end
           end
         end
       end

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

@@ -1,24 +1,26 @@
+# frozen_string_literal: true
+
 module Trailblazer
   class Finder
     module Adapters
+      # ActiveRecord Adapter
       module Sequel
-        # Sequel - Sorting Adapter
+        # ActiveRecord Paging Adapter
         module Sorting
-          def self.included(base)
-            base.extend Features::Sorting::ClassMethods
-          end
-
-          private
-
-          def sort_orders(sort_attr, sort_dir)
-            ::Sequel.send sort_dir, sort_attr.to_sym
-          end
+          module_function
 
-          def sort_it(entity_type, sort_attributes)
-            result = []
-            result << [:order, sort_attributes.first] if sort_attributes.is_a? Array
-            sort_attributes.drop(1).each { |x| result << [:order_append, x] }
-            result.inject(entity_type) { |obj, method_and_args| obj.send(*method_and_args) }
+          def set_sorting_handler
+            lambda do |sort_attributes, entity|
+              sort_attributes.delete(:handler)
+              attributes = []
+              sort_attributes.each do |attr|
+                attributes << (::Sequel.send attr[1], attr[0].to_sym)
+              end
+              result = []
+              result << [:order, attributes.first] if attributes.is_a? Array
+              attributes.drop(1).each { |x| result << [:order_append, x] }
+              result.reduce(entity) { |obj, method_and_args| obj.send(*method_and_args) }
+            end
           end
         end
       end

data/lib/trailblazer/finder/adapters/will_paginate/paging.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Adapters
+      # ActiveRecord Adapter
+      module WillPaginate
+        # Kaminari Paging Adapter
+        module Paging
+          module_function
+
+          def set_paging_handler
+            lambda do |current_page, per_page, entity|
+              entity.paginate per_page: per_page, page: current_page.zero? ? nil : current_page
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/base.rb

@@ -1,95 +1,32 @@
+# frozen_string_literal: true
+
 module Trailblazer
   class Finder
-    # Base module
+    ORM_ADAPTERS = %w[ActiveRecord Sequel].freeze
+    PAGING_ADAPTERS = %w[Kaminari WillPaginate].freeze
+
     module Base
       def self.included(base)
-        base.extend ClassMethods
-        base.instance_eval do
-          @config = {
-            defaults:  {},
-            actions:   {},
-            entity_type:     nil
-          }
-        end
-      end
-
-      def initialize(options = {})
-        config      = self.class.config
-        entity_type = options[:entity_type] || (config[:entity_type] && instance_eval(&config[:entity_type]))
-        actions     = config[:actions] || {}
-        params      = Utils::Params.normalize_params(config[:defaults], options[:filter], actions.keys)
-
-        raise Error::MissingEntityType unless entity_type
-
-        @find = Find.new(entity_type, params, actions)
-      end
-
-      def results
-        @results ||= fetch_results
-      end
-
-      def results?
-        results.any?
-      end
-
-      def count
-        @count ||= @find.count self
-      end
-
-      def params(additions = {})
-        if additions.empty?
-          @find.params
-        else
-          @find.params.merge Utils::Params.stringify_keys(additions)
-        end
+        base.include Helpers::Basic
+        base.include Helpers::Sorting
+        base.extend Finder::Dsl
       end
 
-      private
+      attr_reader :signal, :errors
 
-      def fetch_results
-        @find.query self
+      def initialize(options = {}) # rubocop:disable Style/OptionHash
+        config = self.class.config
+        ctx = {config: config, options: options}
+        @signal, (ctx, *) = Activity::Find.call([ctx, {}])
+        @options = options
+        @errors = ctx[:errors] || {}
+        @find = ctx[:finder]
       end
 
-      # ClassMethods
-      module ClassMethods
-        attr_reader :config
-
-        def inherited(base)
-          base.instance_variable_set '@config', Utils::Extra.deep_copy(config)
-        end
-
-        def entity_type(&block)
-          config[:entity_type] = block
-        end
-
-        def filter_by(name, options = nil, &block)
-          options = { default: options } unless options.is_a?(Hash)
-
-          name    = name.to_s
-          default = options[:default]
-          handler = options[:with] || block
-
-          config[:defaults][name] = default unless default.nil?
-          config[:actions][name]  = normalize_find_handler(handler, name)
-
-          define_method(name) { @find.param name }
-        end
-
-        def results(*args)
-          new(*args).results
-        end
-
-        def normalize_find_handler(handler, key)
-          case handler
-          when Symbol then ->(entity_type, value) { method(handler).call entity_type, value }
-          when Proc then handler
-          else
-            lambda do |entity_type, value|
-              return if Utils::String.blank?(value)
-              Utils::DeepLocate.deep_locate ->(k, v, _object) { k == key.to_sym && v == value }, entity_type
-            end
-          end
-        end
+      def fetch_result
+        result = @find.query self
+        result = Utils::Array.convert_hashes_in_array_to_struct(result) if result.first.is_a?(Hash)
+        result
       end
     end
   end