trailblazer-finder 0.10.1 → 0.70.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 691fee589f1865e7704d021751dfedfa6be1c51950f5812b09de57493ac2d6e4
-  data.tar.gz: 1919763290c8173d600c4722fa6c1c43a4be4bd70715cc1d05efb963ba5af78b
+  metadata.gz: 39f554fa2720ae7fe8f7bdc61eb44e636167a7ec85cb4c0b47da5027f80d4c3e
+  data.tar.gz: 83e4e41732b0c4fef9d4d5793e3f6de7ad6b66086c906854127e6018f7a7eaa5
 SHA512:
-  metadata.gz: 3215baeb3874a0aafe6eb0f4c65f28848ebb08806f26a76e195eb8b9fc9bf8e087a6f64e126ca5d7f0981c42f1cedde892e27e8d882ed799d7ee9e84771d05d8
-  data.tar.gz: ec4f69e4f75bac9d921bf503381afab35073d0806c65dfd1b1af4382e82ae51f9199098366898429f0dd3f6c22da2dd7977b17bcd8f5b03d08f1a0748cbf19d4
+  metadata.gz: d8e69bb8c68980e657d2399fb1e6b50d63b1538e38346eb1a40465e60737940f431c052689a29c3b4ca9fdfc69b6e7d26f49f59db015e30beb5ba736522e81e5
+  data.tar.gz: 9fe89ed1a67614bff0a9d5a69242972ce4bd219b0d20e72bb0d356637f7dbc9c2f3ea6e27fd32eb42c32e5502e67716545f4be5e9498a3d94c3863c92e4db1e0

data/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.5, 2.6, 2.7, '3.0']
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - run: bundle exec rake

data/.rubocop.yml

@@ -2,4 +2,10 @@ require: rubocop-rspec
 
 inherit_from:
   - https://raw.githubusercontent.com/trailblazer/meta/master/rubocop.yml
-  - .rubocop_todo.yml
+
+RSpec/ExampleLength:
+  Enabled: false
+RSpec/MultipleExpectations:
+  Enabled: false
+Layout/LineLength:
+  Enabled: false

data/CHANGES.md

@@ -1,3 +1,18 @@
+# 0.70.0
+* Drop Support Legacy Dry-types
+
+# 0.60.0
+* Support Ruby 3.0
+
+# 0.50.0
+* Breaking change: Use adapter and paginator configs instead of mixing them in adapters config.
+
+# 0.10.3
+* Add support for strings in filters keys.
+
+# 0.10.2
+* Add support for ActiveSupport::Hash as params
+
 # 0.10.1
 * Move activities to Activities folder to avoid conflict with Activity Class.
 

data/Gemfile

@@ -4,7 +4,9 @@ source "https://rubygems.org"
 
 gemspec
 
-gem "pry-byebug"
+gem "debug", platform: :mri
+gem "jdbc-sqlite3", :platform => :jruby
+gem "sqlite3", platform: :mri
 
 # Had to add this for a bit, since none of the latest changes have been pushed to gems yet
 # gem "trailblazer", github: "trailblazer/trailblazer"

data/README.md

@@ -78,7 +78,7 @@ Basically for most use cases, Entity is the entity/model/array of hashes you wis
 ```ruby
 class Post::Finder < Trailblazer::Finder
   # Without defining an ORM everything defaults to dealing with hash objects
-  adapters :ActiveRecord
+  adapter :ActiveRecord
 
   # Optional if you use it as option in the caller, Model/Entity or Array with Hashes
   entity { Post }
@@ -364,7 +364,7 @@ You can specify the adapters you wish to use inside your enherited Finder class.
 ### Adapters Example
 ```ruby
 class Post::Finder < Trailblazer::Finder
-  adapters :ActiveRecord
+  adapter "ActiveRecord"
 end
 ```
 
@@ -374,7 +374,7 @@ The only thing the [ActiveRecord](https://github.com/rails/rails/tree/master/act
 #### Active Record Example
 ```ruby
 class Post::Finder < Trailblazer::Finder
-  adapters :ActiveRecord
+  adapter "ActiveRecord"
 end
 ```
 
@@ -384,7 +384,7 @@ The only thing the [Sequel](https://github.com/jeremyevans/sequel) adapter does,
 #### Sequel Example
 ```ruby
 class Post::Finder < Trailblazer::Finder
-  adapters :Sequel
+  adapter "Sequel"
 end
 ```
 

data/Rakefile

@@ -16,12 +16,6 @@ end
 
 RuboCop::RakeTask.new(:rubocop)
 
-desc "Remove temporary files"
-task :clean do
-  `rm -rf *.gem doc pkg coverage test-reports`
-  %x(rm -f `find . -name '*.rbc'`)
-end
-
 desc "Build the gem"
 task :gem do
   `gem build trailblazer-finder.gemspec`

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

@@ -3,21 +3,19 @@
 module Trailblazer
   class Finder
     module Activities
-      # Find Activity
       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 = {}
-
-            fetch_filters(ctx, result, attribute) || result if ctx[:filters].include?(attribute)
-            fetch_properties(result, attribute, value, ctx[:properties]) || result
+            filter_attribute = attribute.to_sym
+            fetch_filters(ctx, result, filter_attribute) || result if ctx[:filters].include?(filter_attribute)
+            fetch_properties(result, filter_attribute, value, ctx[:properties]) || result
             next ctx[:params].delete(attribute) if result.empty?
 
             ctx[:process] ||= {}
-            ctx[:process][attribute] = result.merge!(value: value)
+            ctx[:process][filter_attribute] = result.merge!(value: value)
           end
           true
         end
@@ -32,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
+
+        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
+            result[:name] = splitter.field
+            result[:predicate] = predicate
           end
+        end
       end
     end
   end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "prepare_adapters"
+require_relative "prepare_adapter"
 require_relative "prepare_entity"
 require_relative "prepare_properties"
 require_relative "prepare_filters"
@@ -11,14 +11,13 @@ require_relative "prepare_sorting"
 module Trailblazer
   class Finder
     module Activities
-      # Prepare Activity
       class Prepare < Trailblazer::Activity::Railway
         def clean_ctx((ctx, flow_options), **)
           ctx.delete(:options)
           [Activity::Right, [ctx, flow_options]]
         end
 
-        step Subprocess(PrepareAdapters)
+        step Subprocess(PrepareAdapter)
         step Subprocess(PrepareEntity)
         step Subprocess(PrepareProperties)
         step Subprocess(PrepareFilters)

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activities
+      class PrepareAdapter < Trailblazer::Activity::Railway
+        def set_adapter(ctx, **)
+          ctx[:adapter] = ctx.dig(:config, :adapter) || "Basic"
+        end
+
+        def validate_adapter(_ctx, adapter:, **)
+          (ORM_ADAPTERS + ["Basic"]).include? adapter.to_s
+        end
+
+        def invalid?((ctx, _flow_options), **_circuit_options)
+          (ctx[:errors] ||= []) << {adapter: "The specified adapter are invalid"}
+        end
+
+        step :set_adapter
+        step :validate_adapter
+        fail :invalid?
+      end
+    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,12 +13,12 @@ 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)
-        fail (:invalid_entity_error)
-        step (:set_entity)
+        step :validate_entity
+        fail :invalid_entity_error
+        step :set_entity
       end
     end
   end

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]
@@ -27,15 +27,9 @@ module Trailblazer
           true
         end
 
-        step (:check_paging),
-             Output(:failure) => Track(:end_paging)
-        step (:set_paging),
-             Output(:success) => Track(:end_paging),
-             Output(:failure) => Track(:failure)
-        step (:clear_paging),
-             magnetic_to: :end_paging,
-             Output(:success) => Track(:success),
-             Output(:failure) => Track(:failure)
+        step :check_paging, Output(:failure) => Track(:end_paging)
+        step :set_paging
+        step :clear_paging, magnetic_to: :end_paging
       end
     end
   end

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

@@ -18,9 +18,9 @@ module Trailblazer
           ctx[:params] = ctx[:options][:params] || {}
         end
 
-        step (:validate_params)
-        fail (:invalid_params_error)
-        step (:set_params)
+        step :validate_params
+        fail :invalid_params_error
+        step :set_params
       end
     end
   end

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/prepare_sorting.rb

@@ -37,15 +37,10 @@ module Trailblazer
           true
         end
 
-        step (:check_sorting),
-             Output(:success) => Track(:paging),
+        step :check_sorting,
              Output(:failure) => Track(:end_sorting)
-        step (:set_sorting),
-             magnetic_to: :paging,
-             Output(:success) => Track(:end_sorting),
-             Output(:failure) => Track(:failure)
-        step (:clear_sorting),
-             magnetic_to: :end_sorting
+        step :set_sorting
+        step :clear_sorting, magnetic_to: :end_sorting
       end
     end
   end

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

@@ -9,7 +9,6 @@ require_relative "process_filters"
 module Trailblazer
   class Finder
     module Activities
-      # Process Activity
       class Process < Trailblazer::Activity::Railway
         step Subprocess(ProcessAdapters)
         step Subprocess(ProcessPredicates)

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

@@ -4,36 +4,38 @@ module Trailblazer
   class Finder
     module Activities
       class ProcessAdapters < Trailblazer::Activity::Railway
-        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
+        def set_adapter((ctx, _flow_options), **)
+          adapter = ctx[: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"
+          true
         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
+        def set_paginator(ctx, **)
+          paginator = ctx.dig(:config, :paginator)
+          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_paging_adapter_error(ctx, **)
-          (ctx[:errors] ||= []) << {adapters: "Can't use paging adapters like Kaminari without using an ORM like ActiveRecord or Sequel"}
+        def invalid_paginator_error(ctx, **)
+          (ctx[:errors] ||= []) << {
+            paginator: "Can't use paginator #{ctx.dig(
+              :config,
+              :paginator
+            )} without using an ORM like ActiveRecord or Sequel"
+          }
         end
 
-        step :set_orm_adapters
-        step :set_paging_adapters
-        fail :invalid_paging_adapter_error
+        step :set_adapter, fast_track: true
+        step :set_paginator
+        fail :invalid_paginator_error
       end
     end
   end

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