trailblazer-finder 0.1.4 → 0.2.5

data/lib/trailblazer/finder/activity/prepare/sorting.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Prepare
+        # Paging Activity
+        module Sorting
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def check_sorting(ctx, **)
+            sorting = ctx[:config][:sorting] || nil
+            return true unless ctx[:config][:sorting].empty? || sorting.nil?
+          end
+
+          def set_sorting(ctx, **)
+            return true if ctx[:params][:sort].nil?
+
+            sorting = ctx[:params][:sort]
+            config = ctx[:config][:sorting]
+            ctx[:sorting] = ctx[:sorting] || {}
+            sorting.split(",").each do |sorter|
+              spt = sorter.split
+              ctx[:sorting][spt[0]] = fetch_sort_direction(config[spt[0].to_sym], spt[1]) if config.include?(spt[0].to_sym)
+            end
+          end
+
+          def fetch_sort_direction(config_direction, params_direction = nil)
+            return config_direction == :asc ? :asc : :desc if params_direction.nil?
+
+            case params_direction
+              when ":asc", :asc, "asc" then :asc
+              else :desc
+            end
+          end
+
+          def clear_sorting(ctx, **)
+            ctx[:params].delete(:sort) unless ctx[:params][:sort].nil?
+            true
+          end
+
+          step method(:check_sorting), id: :check_sorting,
+            Output(:success) => Track(:paging),
+            Output(:failure) => Track(:end_sorting)
+          step method(:set_sorting), id: :set_sorting, magnetic_to: [:paging],
+            Output(:success) => Track(:end_sorting),
+            Output(:failure) => Track(:failure)
+          step method(:clear_sorting), id: :clear_sorting, magnetic_to: [:end_sorting],
+            Output(:success) => Track(:success),
+            Output(:failure) => Track(:failure)
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/process.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      # Process Activity
+      module Process
+        extend Trailblazer::Activity::Railway()
+
+        step Subprocess(Process::Adapters), id: :process_adapters
+        step Subprocess(Process::Predicates), id: :process_predicates
+        step Subprocess(Process::Filters), id: :process_filters
+        step Subprocess(Process::Paging), id: :process_paging
+        step Subprocess(Process::Sorting), id: :process_sorting
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/process/adapters.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Process
+        # Process Adapters Activity
+        module Adapters
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def set_orm_adapters(ctx, **)
+            ctx[:adapters].each do |adapter|
+              next unless (ORM_ADAPTERS + ["Basic"]).include?(adapter)
+
+              ctx[:orm] = {}
+              ctx[:orm][:adapter] = adapter
+              ctx[:orm][:predicates] = "Trailblazer::Finder::Adapters::#{adapter}::Predicates"
+              ctx[:orm][:paging] = "Trailblazer::Finder::Adapters::#{adapter}::Paging"
+              ctx[:orm][:sorting] = "Trailblazer::Finder::Adapters::#{adapter}::Sorting"
+              return true
+            end
+          end
+
+          def set_paging_adapters(ctx, **)
+            ctx[:adapters].each do |adapter|
+              next unless PAGING_ADAPTERS.include?(adapter)
+              return false if ctx[:adapters].include?("Basic")
+
+              ctx[:orm][:paging] = "Trailblazer::Finder::Adapters::#{adapter}::Paging"
+              return true
+            end
+            true
+          end
+
+          def invalid_paging_adapter_error(ctx, **)
+            (ctx[:errors] ||= []) << {adapters: "Can't use paging adapters like Kaminari without using an ORM like ActiveRecord or Sequel"}
+          end
+
+          step method(:set_orm_adapters)
+          step method(:set_paging_adapters)
+          fail method(:invalid_paging_adapter_error)
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/process/filters.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Process
+        # Process Filters Activity
+        module Filters
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def set_filter_handlers(ctx, **)
+            return true unless ctx[:process]
+
+            ctx[:process].each do |key, value|
+              next if ctx[:process][key][:filter].nil?
+
+              ctx[:process][key][:handler] = Utils::Extra.apply_handler(value[:filter] ? value[:filter][:handler] : "none")
+            end
+          end
+
+          step method(:set_filter_handlers), id: :set_filter_handlers
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/process/paging.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Process
+        # Process Paging Activity
+        module Paging
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def set_paging_handler(ctx, **)
+            return true if ctx[:paging].nil?
+
+            ctx[:paging][:handler] = Utils::Extra.apply_handler(
+              (Object.const_get(ctx[:orm][:paging]).__send__ :set_paging_handler)
+            )
+          end
+
+          step method(:set_paging_handler), id: :set_paging_handler
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/process/predicates.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Process
+        # Process Predicates Activity
+        module Predicates
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def set_properties_handler(ctx, **)
+            return true if ctx[:process].nil?
+
+            ctx[:process].each do |key, _value|
+              next if ctx[:process][key][:predicate].nil?
+
+              ctx[:process][key][:handler] = Utils::Extra.apply_handler(
+                (Object.const_get(ctx[:orm][:predicates]).__send__ "set_#{ctx[:process][key][:predicate]}_handler".to_sym)
+              )
+            end
+          end
+
+          step method(:set_properties_handler), id: :set_properties_handler
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/process/sorting.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Process
+        # Process sorting Activity
+        module Sorting
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def set_sorting_handler(ctx, **)
+            return true if ctx[:sorting].nil?
+
+            ctx[:sorting][:handler] = Utils::Extra.apply_handler(
+              (Object.const_get(ctx[:orm][:sorting]).__send__ :set_sorting_handler)
+            )
+          end
+
+          step method(:set_sorting_handler), id: :set_sorting_handler
+        end
+      end
+    end
+  end
+end

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

@@ -1,17 +1,18 @@
+# frozen_string_literal: true
+
 module Trailblazer
   class Finder
     module Adapters
+      # ActiveRecord Adapter
       module ActiveRecord
-        # ActiveRecord - 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/active_record/predicates.rb

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

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

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 module Trailblazer
   class Finder
     module Adapters
+      # ActiveRecord Adapter
       module ActiveRecord
-        # ActiveRecord - Sorting Adapter
+        # ActiveRecord Paging Adapter
         module Sorting
-          def self.included(base)
-            base.extend Features::Sorting::ClassMethods
-          end
-
-          private
-
-          def sort_it(entity_type, sort_attributes)
-            entity_type.order(sort_attributes)
-          end
+          module_function
 
-          def sort_orders(sort_attr, sort_dir)
-            { sort_attr.to_s => sort_dir }
+          def set_sorting_handler
+            lambda do |sort_attributes, entity|
+              sort_attributes.delete(:handler)
+              attributes = []
+              sort_attributes.each do |attr|
+                attributes << {attr[0].to_s => attr[1]}
+              end
+              entity.order(attributes)
+            end
           end
         end
       end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Adapters
+      # ActiveRecord Adapter
+      module Basic
+        # Basic Paging Adapter
+        module Paging
+          module_function
+
+          def set_paging_handler
+            lambda do |current_page, per_page, entity|
+              entity.drop(([current_page, 1].max - 1) * per_page).first(per_page)
+            end
+          end
+        end
+      end
+    end
+  end
+end