trailblazer-finder 0.50.0 → 0.80.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfcac8d017065a8faea558faebaa1bd9e742b7ceb9444a50eafd79d2c759bbfc
-  data.tar.gz: fdfafe463cba185afb34934f981b3428bb357a4031f941e22cb44e1c45608e11
+  metadata.gz: d9ed5fd3c089acb644a3c240478b2aae6b028f63108a94fba82e3afb9164e226
+  data.tar.gz: 155a516ced78ae4621595ec091e5cf5c651d187949961ddc793b3d57bc10aaf9
 SHA512:
-  metadata.gz: 89c313cc891e5ef6b1d6e07145e23541d74698b543e47f4213d621e21925ec18c60d01d66cdbc2c6fe9d2ddbbfc4d5ef201f1bb80a1264ffe70c01f3e37772e0
-  data.tar.gz: 2a00366ecc9c10ae045ce1d1c69f455cc7a8b101be8bb360228cf8cb148833502ea6039ce30740781bd93f97c8cabf878a6129beeb072c9e4e6e0b13b5c3128f
+  metadata.gz: dec5f359b98b15578b1bc38f521a43200bfe5f68b92daa3e70e2274bfc0a6e43503564dc012f0478af51f3fd2afdb22dc0b8293239c2919508d0ab2158117dfa
+  data.tar.gz: 363bc66d7057c76290622ed083aaa270896ef956ca16019d63d8c653fd95630764fd116f6df052e9061e8c5442eaec0dec6e130c159a92e829c79e37251f01fa

data/lib/trailblazer/finder/activities/find.rb

@@ -6,8 +6,7 @@ module Trailblazer
       class Find < Trailblazer::Activity::Railway
         PREDICATES = %w[eq not_eq blank not_blank lt lte gt gte sw not_sw ew not_ew cont not_cont].freeze
 
-
-        def process_params(ctx, params:,  **)
+        def process_params(ctx, params:, **)
           params.each do |attribute, value|
             result = {}
             filter_attribute = attribute.to_sym
@@ -31,23 +30,24 @@ module Trailblazer
         step :set_finder
 
         private
-          def fetch_filters(ctx, result, attribute)
-            filter_attribute = ctx[:filters][attribute]
-            result[:filter] = {}
-            result[:name] = attribute
-            result[:filter][:handler] = filter_attribute[:with] || filter_attribute[:block]
-          end
 
-          def fetch_properties(result, attribute, value, properties)
-            splitter = Utils::Splitter.new attribute, value
-            PREDICATES.each do |predicate|
-              next unless splitter.split_key predicate
-              next unless properties.include?(splitter.field.to_sym)
+        def fetch_filters(ctx, result, attribute)
+          filter_attribute = ctx[:filters][attribute]
+          result[:filter] = {}
+          result[:name] = attribute
+          result[:filter][:handler] = filter_attribute[:with] || filter_attribute[:block]
+        end
 
-              result[:name] = splitter.field
-              result[:predicate] = predicate
-            end
+        def fetch_properties(result, attribute, value, properties)
+          splitter = Utils::Splitter.new attribute, value
+          PREDICATES.each do |predicate|
+            next unless splitter.split_key predicate
+            next unless properties.include?(splitter.field.to_sym)
+
+            result[:name] = splitter.field
+            result[:predicate] = predicate
           end
+        end
       end
     end
   end

data/lib/trailblazer/finder/activities/prepare_adapter.rb

@@ -4,7 +4,6 @@ module Trailblazer
   class Finder
     module Activities
       class PrepareAdapter < Trailblazer::Activity::Railway
-
         def set_adapter(ctx, **)
           ctx[:adapter] = ctx.dig(:config, :adapter) || "Basic"
         end
@@ -13,13 +12,13 @@ module Trailblazer
           (ORM_ADAPTERS + ["Basic"]).include? adapter.to_s
         end
 
-        def is_invalid?((ctx, _flow_options), **_circuit_options)
+        def invalid?((ctx, _flow_options), **_circuit_options)
           (ctx[:errors] ||= []) << {adapter: "The specified adapter are invalid"}
         end
 
         step :set_adapter
         step :validate_adapter
-        fail :is_invalid?
+        fail :invalid?
       end
     end
   end

data/lib/trailblazer/finder/activities/prepare_entity.rb

@@ -5,7 +5,7 @@ module Trailblazer
     module Activities
       class PrepareEntity < Trailblazer::Activity::Railway
         def validate_entity(ctx, **)
-          ctx.dig(:options,:entity) || ctx.dig(:config,:entity)
+          ctx.dig(:options, :entity) || ctx.dig(:config, :entity)
         end
 
         def invalid_entity_error(ctx, **)
@@ -13,7 +13,7 @@ module Trailblazer
         end
 
         def set_entity(ctx, **)
-          ctx[:entity] = ctx.dig(:options,:entity) || instance_eval(&ctx[:config][:entity])
+          ctx[:entity] = ctx.dig(:options, :entity) || instance_eval(&ctx[:config][:entity])
         end
 
         step :validate_entity

data/lib/trailblazer/finder/activities/prepare_paging.rb

@@ -12,8 +12,8 @@ module Trailblazer
         end
 
         def set_paging(ctx, **)
-          ctx[:paging] = ctx.dig(:config,:paging) || {}
-          ctx[:paging][:current_page] = ctx.dig(:params,:page) || 1
+          ctx[:paging] = ctx.dig(:config, :paging) || {}
+          ctx[:paging][:current_page] = ctx.dig(:params, :page) || 1
           return true unless ctx[:params][:per_page]
 
           ctx[:paging][:per_page] = ctx[:params][:per_page].to_i || ctx[:paging][:per_page]

data/lib/trailblazer/finder/activities/prepare_properties.rb

@@ -18,11 +18,7 @@ module Trailblazer
           return true if properties.empty?
 
           properties.each do |key, _value|
-            if LEGACY_DRY_TYPES
-              return properties[key][:type].class.ancestors.include?(::Dry::Types::Definition)
-            else
-              return properties[key][:type].class.ancestors.include?(::Dry::Types::Nominal)
-            end
+            return properties[key][:type].class.ancestors.include?(::Dry::Types::Nominal)
           end
         end
 

data/lib/trailblazer/finder/activities/process_adapters.rb

@@ -4,7 +4,7 @@ module Trailblazer
   class Finder
     module Activities
       class ProcessAdapters < Trailblazer::Activity::Railway
-        def set_adapter((ctx, flow_options), **)
+        def set_adapter((ctx, _flow_options), **)
           adapter = ctx[:adapter]
           ctx[:orm] = {}
           ctx[:orm][:adapter] = adapter
@@ -19,12 +19,18 @@ module Trailblazer
           return true unless paginator
           return false unless ORM_ADAPTERS.include?(ctx[:orm][:adapter])
           return false unless PAGING_ADAPTERS.include?(paginator)
+
           ctx[:orm][:paging] = "Trailblazer::Finder::Adapters::#{paginator}::Paging"
           true
         end
 
         def invalid_paginator_error(ctx, **)
-          (ctx[:errors] ||= []) << {paginator: "Can't use paginator #{ctx.dig(:config, :paginator)} without using an ORM like ActiveRecord or Sequel"}
+          (ctx[:errors] ||= []) << {
+            paginator: "Can't use paginator #{ctx.dig(
+              :config,
+              :paginator
+            )} without using an ORM like ActiveRecord or Sequel"
+          }
         end
 
         step :set_adapter, fast_track: true

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

@@ -10,7 +10,7 @@ module Trailblazer
           module_function
 
           def set_paging_handler
-            lambda do |current_page, per_page, entity|
+            ->(current_page, per_page, entity) do
               entity.limit(per_page).offset(([current_page, 1].max - 1) * per_page)
             end
           end

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

@@ -10,7 +10,7 @@ module Trailblazer
           module_function
 
           def set_eq_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               return if Utils::String.blank?(value.to_s)
 
               entity.where(attribute => value)
@@ -18,7 +18,7 @@ module Trailblazer
           end
 
           def set_not_eq_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               return if Utils::String.blank?(value.to_s)
 
               entity.where.not(attribute => value)
@@ -26,73 +26,73 @@ module Trailblazer
           end
 
           def set_blank_handler
-            lambda do |entity, attribute, _value|
+            ->(entity, attribute, _value) do
               entity.where(attribute.to_sym => [nil, ""])
             end
           end
 
           def set_not_blank_handler
-            lambda do |entity, attribute, _value|
+            ->(entity, attribute, _value) do
               entity.where.not(attribute.to_sym => [nil, ""])
             end
           end
 
           def set_gt_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where("#{attribute} > ?", value.to_f)
             end
           end
 
           def set_gte_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where("#{attribute} >= ?", value.to_f)
             end
           end
 
           def set_lt_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where("#{attribute} < ?", value.to_f)
             end
           end
 
           def set_lte_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where("#{attribute} <= ?", value.to_f)
             end
           end
 
           def set_cont_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where("#{attribute} LIKE ?", "%#{value}%")
             end
           end
 
           def set_not_cont_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where("#{attribute} NOT LIKE ?", "%#{value}%")
             end
           end
 
           def set_sw_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where("#{attribute} LIKE ?", "#{value}%")
             end
           end
 
           def set_not_sw_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where("#{attribute} NOT LIKE ?", "#{value}%")
             end
           end
 
           def set_ew_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where("#{attribute} LIKE ?", "%#{value}")
             end
           end
 
           def set_not_ew_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where("#{attribute} NOT LIKE ?", "%#{value}")
             end
           end

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

@@ -10,7 +10,7 @@ module Trailblazer
           module_function
 
           def set_sorting_handler
-            lambda do |sort_attributes, entity|
+            ->(sort_attributes, entity) do
               sort_attributes.delete(:handler)
               attributes = []
               sort_attributes.each do |attr|

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

@@ -10,7 +10,7 @@ module Trailblazer
           module_function
 
           def set_paging_handler
-            lambda do |current_page, per_page, entity|
+            ->(current_page, per_page, entity) do
               entity.drop(([current_page, 1].max - 1) * per_page).first(per_page)
             end
           end

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

@@ -10,7 +10,7 @@ module Trailblazer
           module_function
 
           def set_eq_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               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
@@ -18,7 +18,7 @@ module Trailblazer
           end
 
           def set_not_eq_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               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
@@ -26,43 +26,43 @@ module Trailblazer
           end
 
           def set_blank_handler
-            lambda do |entity, attribute, _value|
+            ->(entity, attribute, _value) do
               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|
+            ->(entity, attribute, _value) do
               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|
+            ->(entity, attribute, value) do
               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|
+            ->(entity, attribute, value) do
               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|
+            ->(entity, attribute, value) do
               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|
+            ->(entity, attribute, value) do
               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|
+            ->(entity, attribute, value) do
               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
@@ -70,7 +70,7 @@ module Trailblazer
           end
 
           def set_not_cont_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               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
@@ -78,7 +78,7 @@ module Trailblazer
           end
 
           def set_sw_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               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
@@ -86,7 +86,7 @@ module Trailblazer
           end
 
           def set_not_sw_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               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
@@ -94,7 +94,7 @@ module Trailblazer
           end
 
           def set_ew_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               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
@@ -102,7 +102,7 @@ module Trailblazer
           end
 
           def set_not_ew_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               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

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

@@ -10,7 +10,7 @@ module Trailblazer
           module_function
 
           def set_sorting_handler
-            lambda do |sort_attributes, entity|
+            ->(sort_attributes, entity) do
               sort_attributes.delete(:handler)
               attributes = []
               sort_attributes.each do |attr|

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

@@ -9,7 +9,7 @@ module Trailblazer
           module_function
 
           def set_paging_handler
-            lambda do |current_page, per_page, entity|
+            ->(current_page, per_page, entity) do
               entity.page(current_page).per(per_page)
             end
           end

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

@@ -10,7 +10,7 @@ module Trailblazer
           module_function
 
           def set_paging_handler
-            lambda do |current_page, per_page, entity|
+            ->(current_page, per_page, entity) do
               entity.limit(per_page).offset(([current_page, 1].max - 1) * per_page)
             end
           end

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

@@ -10,7 +10,7 @@ module Trailblazer
           module_function
 
           def set_eq_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               return if Utils::String.blank?(value.to_s)
 
               entity.where { ::Sequel[attribute.to_sym] =~ value }
@@ -18,7 +18,7 @@ module Trailblazer
           end
 
           def set_not_eq_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               return if Utils::String.blank?(value.to_s)
 
               entity.where { ::Sequel[attribute.to_sym] !~ value }
@@ -26,74 +26,74 @@ module Trailblazer
           end
 
           def set_blank_handler
-            lambda do |entity, attribute, _value|
+            ->(entity, attribute, _value) do
               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, attribute, _value) do
               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, attribute, value) do
               entity.where { ::Sequel[attribute.to_sym] > value.to_f }
             end
           end
 
           def set_gte_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where { ::Sequel[attribute.to_sym] >= value.to_f }
             end
           end
 
           def set_lt_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where { ::Sequel[attribute.to_sym] < value.to_f }
             end
           end
 
           def set_lte_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where { ::Sequel[attribute.to_sym] <= value.to_f }
             end
           end
 
           def set_cont_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where(::Sequel.like(attribute.to_sym, "%#{value}%"))
             end
           end
 
           def set_not_cont_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where(~::Sequel.like(attribute.to_sym, "%#{value}%"))
             end
           end
 
           def set_sw_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where(::Sequel.like(attribute.to_sym, "#{value}%"))
             end
           end
 
           def set_not_sw_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where(~::Sequel.like(attribute.to_sym, "#{value}%"))
             end
           end
 
           def set_ew_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where(::Sequel.like(attribute.to_sym, "%#{value}"))
             end
           end
 
           def set_not_ew_handler
-            lambda do |entity, attribute, value|
+            ->(entity, attribute, value) do
               entity.where(~::Sequel.like(attribute.to_sym, "%#{value}"))
             end
           end

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

@@ -10,7 +10,7 @@ module Trailblazer
           module_function
 
           def set_sorting_handler
-            lambda do |sort_attributes, entity|
+            ->(sort_attributes, entity) do
               sort_attributes.delete(:handler)
               attributes = []
               sort_attributes.each do |attr|

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

@@ -9,7 +9,7 @@ module Trailblazer
           module_function
 
           def set_paging_handler
-            lambda do |current_page, per_page, entity|
+            ->(current_page, per_page, entity) do
               entity.paginate per_page: per_page, page: current_page.zero? ? nil : current_page
             end
           end

data/lib/trailblazer/finder/dsl.rb

@@ -13,7 +13,7 @@ module Trailblazer
         config[:entity] = block
       end
 
-      def paging(options, **)
+      def paging(**options)
         config[:paging][:per_page] = options[:per_page] || 25
         config[:paging][:min_per_page] = options[:min_per_page] || 10
         config[:paging][:max_per_page] = options[:max_per_page] || 100

data/lib/trailblazer/finder/find.rb

@@ -24,7 +24,8 @@ module Trailblazer
       end
 
       def process_paging(ctx)
-        ctx.instance_exec @paging[:current_page], @paging[:per_page], (@sorting.empty? ? (process_filters ctx) : (process_sorting ctx)), &@paging[:handler]
+        ctx.instance_exec @paging[:current_page], @paging[:per_page],
+                          (@sorting.empty? ? (process_filters ctx) : (process_sorting ctx)), &@paging[:handler]
       end
 
       def process_sorting(ctx)

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

@@ -31,7 +31,10 @@ module Trailblazer
           if sorting.nil?
             params.merge! sort: "#{attribute} #{sort_direction_for(attribute)}"
           elsif sorting.include?(attribute.to_s)
-            params.merge! sort: sorting.gsub(/#{attribute} #{sort_direction_for(attribute)}/, "#{attribute} #{reverse_sort_direction_for(attribute)}")
+            params.merge! sort: sorting.gsub(
+              /#{attribute} #{sort_direction_for(attribute)}/,
+              "#{attribute} #{reverse_sort_direction_for(attribute)}"
+            )
           else
             params.merge! sort: "#{sorting}, #{attribute} #{sort_direction_for(attribute)}"
           end

data/lib/trailblazer/finder/version.rb

@@ -2,6 +2,6 @@
 
 module Trailblazer
   class Finder
-    VERSION = "0.50.0".freeze
+    VERSION = "0.80.1"
   end
 end

data/lib/trailblazer/finder.rb

@@ -33,14 +33,8 @@ require "trailblazer/operation/finder"
 
 module Trailblazer
   class Finder
-    DRY_TYPES_VERSION = Gem::Version.new(Dry::Types::VERSION)
-    LEGACY_DRY_TYPES = DRY_TYPES_VERSION <= Gem::Version.new('1')
     module Types
-      if LEGACY_DRY_TYPES
-        include Dry::Types.module
-      else
-        include Dry.Types(default: :nominal)
-      end
+      include Dry.Types(default: :nominal)
     end
 
     include Base

data/lib/trailblazer/operation/finder.rb

@@ -12,13 +12,12 @@ Trailblazer::Operation.instance_eval do
   end
 
   class Finder
-    def call(ctx, options, **)
+    def call(ctx, **options)
       builder                = Finder::Builder.new
       ctx[:finder]           = finder = builder.call(options, options[:params])
       ctx[:model]            = finder # Don't like it, but somehow it's needed if contracts are loaded
       ctx[:"result.finder"]  = Trailblazer::Operation::Result.new(!finder.nil?, {})
 
-
       ctx[:"result.finder"].success?
     end
 
@@ -49,6 +48,7 @@ Trailblazer::Operation.instance_eval do
 
       def apply_id(params)
         return if params[:id].nil?
+
         params[:id_eq] = params[:id]
       end
     end