trailblazer-finder 0.1.4 → 0.2.5

data/lib/trailblazer/finder/dsl.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Dsl
+      attr_reader :config
+
+      def inherited(base)
+        base.instance_variable_set "@config", apply_config({})
+      end
+
+      def entity(&block)
+        config[:entity] = block
+      end
+
+      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
+      end
+
+      def property(name, options = {})
+        config[:properties][name] = options
+        config[:properties][name][:type] = options[:type] || Types::String
+        config[:sorting][name] = options[:sort_direction] || :desc if options[:sortable]
+      end
+
+      def filter_by(name, options = {}, &block)
+        config[:filters][name] = {}
+        config[:filters][name][:name] = name
+        config[:filters][name][:with] = options[:with] if options.include?(:with)
+        config[:filters][name][:block] = block || nil
+      end
+
+      def adapters(*adapters)
+        adapters.each do |adapter|
+          config[:adapters].push adapter.to_s.split("::").last.gsub("}>", "") if config[:adapters]
+        end
+      end
+
+      def apply_config(options, **)
+        return @config = options unless options.empty?
+
+        @config = {
+          actions:    {},
+          entity:     nil,
+          properties: {},
+          filters:    {},
+          paging:     {},
+          sorting:    {},
+          adapters:   []
+        }
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/find.rb

@@ -1,28 +1,41 @@
+# frozen_string_literal: true
+
 module Trailblazer
   class Finder
     class Find
-      attr_reader :params
+      attr_reader :params, :paging, :sorting, :filters, :config
 
-      def initialize(entity_type, params, actions)
-        @entity_type  = entity_type
-        @actions      = actions
-        @params       = params
+      def initialize(entity, params, filters, paging = nil, sorting = nil, config = nil)
+        @entity   = entity
+        @filters  = filters
+        @params   = params
+        @paging   = paging || {}
+        @sorting = sorting || {}
+        @config = config || {}
       end
 
-      def param(name)
-        @params[name]
+      def process_filters(ctx)
+        @params.reduce(@entity) do |entity, (name, value)|
+          value = Utils::String.to_date(value) if Utils::String.date?(value)
+          new_entity = ctx.instance_exec entity, @filters[name.to_sym][:name], value, &@filters[name.to_sym][:handler]
+          new_entity || entity
+        end
       end
 
-      def query(context)
-        @params.inject(@entity_type) do |entity_type, (name, value)|
-          value = Utils::Parse.date(value) if Utils::Parse.date(value)
-          new_entity_type = context.instance_exec entity_type, value, &@actions[name]
-          new_entity_type || entity_type
-        end
+      def process_paging(ctx)
+        # ctx.instance_exec @paging[:current_page], @paging[:per_page], (process_filters ctx), &@paging[:handler]
+        ctx.instance_exec @paging[:current_page], @paging[:per_page], (@sorting.empty? ? (process_filters ctx) : (process_sorting ctx)), &@paging[:handler]
       end
 
-      def count(context)
-        query(context).count
+      def process_sorting(ctx)
+        ctx.instance_exec @sorting, (process_filters ctx), &@sorting[:handler]
+      end
+
+      def query(ctx)
+        return process_paging ctx unless @paging.empty? || @paging.nil?
+        return process_sorting ctx unless @sorting.empty? || @sorting.nil?
+
+        process_filters ctx
       end
     end
   end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Helpers
+      module Basic
+        def paging
+          return if @errors.any?
+          return if @find.paging.empty?
+
+          result = Utils::Hash.remove_keys_from_hash(@find.paging, %i[handler max_per_page min_per_page])
+          result[:page] = result[:page] || result.delete(:current_page) || result[:current_page]
+          result
+        end
+
+        def params
+          return @options[:params] if @errors.any?
+
+          @params ||= (paging.merge @find.params).merge sort: sorting
+        end
+
+        def filters
+          @filters ||= @find.filters if @errors.empty?
+        end
+
+        def result
+          @result ||= @errors.empty? ? fetch_result : {errors: @errors} if respond_to?(:fetch_result)
+        end
+
+        def result?
+          return false if @errors.any?
+
+          result.any?
+        end
+
+        def count
+          return if @errors.any?
+
+          @count ||= result.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Helpers
+      module Sorting
+        def sorting
+          return if @errors.any?
+          return if @find.sorting.empty?
+
+          @sorting ||= Utils::Hash.remove_keys_from_hash(@find.sorting, [:handler]).map { |r| r.join(" ") }.join(", ")
+        end
+
+        def sort?(attribute)
+          sorting.include?(attribute.to_s)
+        end
+
+        def sort_direction_for(attribute)
+          return "asc" if (!sorting.nil? && sorting.include?("#{attribute} asc")) || @find.config[:sorting][attribute.to_sym] == :asc
+
+          "desc"
+        end
+
+        def reverse_sort_direction_for(attribute)
+          return "desc" if (!sorting.nil? && sorting.include?("#{attribute} asc")) || @find.config[:sorting][attribute.to_sym] == :asc
+
+          "asc"
+        end
+
+        def sort_params_for(attribute)
+          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)}")
+          else
+            params.merge! sort: "#{sorting}, #{attribute} #{sort_direction_for(attribute)}"
+          end
+        end
+
+        def remove_sort_params_for(attribute)
+          return unless sorting.include?(attribute.to_s)
+
+          sort = sorting.gsub(/#{attribute} #{sort_direction_for(attribute)}/, "").split(",")
+          sort.delete_if(&:blank?)
+          params.merge! sort: sort.join(",")
+        end
+
+        def new_sort_params_for(attribute)
+          params.merge! sort: "#{attribute} #{sort_direction_for(attribute)}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    # Helper module
+    module Utils
+      module Array
+        module_function
+
+        def convert_hashes_in_array_to_struct(hash)
+          result = []
+          hash.each do |h|
+            result << (OpenStruct.new h)
+          end
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -1,28 +1,18 @@
+# frozen_string_literal: true
+
 module Trailblazer
   class Finder
     # Helper module
     module Utils
-      class Extra
-        def self.ensure_included(item, collection)
-          if collection.include? item
-            item
-          else
-            collection.first
-          end
-        end
+      module Extra
+        module_function
 
-        def self.deep_copy(object)
-          case object
-          when Array
-            object.map { |element| deep_copy(element) }
-          when Hash
-            object.each_with_object({}) do |(key, value), result|
-              result[key] = deep_copy(value)
-            end
-          when NilClass, FalseClass, TrueClass, Symbol, Method, Numeric
-            object
-          else
-            object.dup
+        def apply_handler(handler, predicate_handler = "Trailblazer::Finder::Adapters::Basic::Predicates")
+          case handler
+            when Symbol then ->(entity, attribute, value) { method(handler).call entity, attribute, value }
+            when Proc then handler
+            else
+              Object.const_get(predicate_handler).__send__ :set_eq_handler
           end
         end
       end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    # Helper module
+    module Utils
+      module Hash
+        module_function
+
+        def deep_locate(comparator, object, result = [])
+          if object.is_a?(::Enumerable) && comparator.is_a?(::Proc)
+            result.push object if object.any? { |value| match_comparator?(value, comparator, object) }
+            (object.respond_to?(:values) ? object.values : object.entries).each do |value|
+              deep_locate(comparator, value, result)
+            end
+          end
+
+          result
+        end
+
+        def match_comparator?(value, comparator, object)
+          key = nil
+          key, value = value if object.is_a?(::Hash)
+          comparator.call(key, value, object)
+        end
+
+        def remove_keys_from_hash(hash, keys)
+          hash.each do |key, _value|
+            hash.delete(key) if keys.include?(key)
+          end
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -1,24 +1,28 @@
+# frozen_string_literal: true
+
 module Trailblazer
   class Finder
     # Helper module
     module Utils
       class Splitter
-        def initialize( key, value )
-          @key, @value = key, value
-        end
-
         attr_reader :key, :value
 
+        def initialize(key, value)
+          @key = key
+          @value = value.to_s
+        end
+
         # split suffix from the key and store the two values as name and op
         # return truthy if successful
-        def split_key( suffix )
+        def split_key(suffix)
           rv = @key =~ /\A(?:(.*?)_)?(#{suffix})\z/
-          @field, @op = $1, $2
-          rv
+          @field = Regexp.last_match(1)
+          @predicate = Regexp.last_match(2)
+          !rv.nil?
         end
 
-        alias_method :===, :split_key
-        alias_method :=~, :split_key
+        alias === split_key
+        alias =~ 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
@@ -27,14 +31,9 @@ module Trailblazer
           (@field || @key)
         end
 
-        # the operator, or predicate
-        def op
-          @op.to_sym
-        end
-
-        # the value
-        def value
-          @value.to_s
+        # the predicate
+        def predicate
+          @predicate.to_sym
         end
       end
     end

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

@@ -1,18 +1,19 @@
-require 'date'
+# frozen_string_literal: true
 
 module Trailblazer
   class Finder
     # Helper module
     module Utils
       class String
-        def self.blank?(value)
-          return false if num?(value)
-          value.nil? || value.strip.empty?
+        def self.blank?(string)
+          return false if numeric?(string)
+
+          string.nil? || string.strip.empty?
         end
 
-        def self.num?(str)
-          Integer(str)
-        rescue ArgumentError, TypeError
+        def self.numeric?(string)
+          !Float(string).nil?
+        rescue StandardError
           false
         end
 
@@ -22,13 +23,22 @@ module Trailblazer
 
         def self.underscore(text)
           text
-            .to_s.gsub(/::/, '/')
+            .to_s.gsub(/::/, "/")
             .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
             .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-            .tr('-', '_')
-            .tr(' ', '_')
+            .tr("-", "_")
+            .tr(" ", "_")
             .downcase
         end
+
+        def self.to_date(value)
+          Date.parse(value).strftime("%Y-%m-%d") if date?(value)
+        end
+
+        def self.date?(date)
+          date_hash = Date._parse(date.to_s)
+          Date.valid_date?(date_hash[:year].to_i, date_hash[:mon].to_i, date_hash[:mday].to_i)
+        end
       end
     end
   end

data/lib/trailblazer/finder/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Trailblazer
   class Finder
-    VERSION = '0.1.4'.freeze
+    VERSION = "0.2.5"
   end
 end

data/lib/trailblazer/operation/finder.rb

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
 
 # Really gotta clean this up, but can't be bothered right now
 module Trailblazer
   class Operation
-    def self.Finder(finder_class, action = nil, entity_type = nil)
-      task = Trailblazer::Activity::TaskBuilder::Binary.call(Finder.new)
+    def self.Finder(finder_class, action = nil, entity = nil)
+      task = Trailblazer::Activity::TaskBuilder::Binary(Finder.new)
 
       extension = Trailblazer::Activity::TaskWrap::Merge.new(
         Wrap::Inject::Defaults(
-          'finder.class'        => finder_class,
-          'finder.entity_type'  => entity_type,
-          'finder.action'       => action
+          "finder.class"        => finder_class,
+          "finder.entity"       => entity,
+          "finder.action"       => action
         )
       )
 
-      { task: task, id: 'finder.build', extension: [extension] }
+      {task: task, id: "finder.build", Trailblazer::Activity::DSL::Extension.new(extension) => true}
     end
 
     class Finder
@@ -21,40 +22,40 @@ module Trailblazer
         builder                   = Finder::Builder.new
         options[:finder]          = finder = builder.call(options, params)
         options[:model]           = finder # Don't like it, but somehow it's needed if contracts are loaded
-        options['result.finder']  = result = Result.new(!finder.nil?, {})
+        options["result.finder"]  = result = Result.new(!finder.nil?, {})
 
         result.success?
       end
 
       class Builder
         def call(options, params)
-          finder_class  = options['finder.class']
-          entity_type   = options['finder.entity_type'] || nil
-          action        = options['finder.action'] || :all
+          finder_class  = options["finder.class"]
+          entity        = options["finder.entity"] || nil
+          action        = options["finder.action"] || :all
           action        = :all unless %i[all single].include?(action)
 
-          send("#{action}!", finder_class, entity_type, params, options['finder.action'])
+          send("#{action}!", finder_class, entity, params, options["finder.action"])
         end
 
         private
 
-        def all!(finder_class, entity_type, params, *)
-          finder_class.new(entity_type: entity_type, filter: params[:f], page: params[:page], per_page: params[:per_page])
+        def all!(finder_class, entity, params, *)
+          finder_class.new(entity: entity, params: params)
         end
 
-        def single!(finder_class, entity_type, params, *)
+        def single!(finder_class, entity, params, *)
           apply_id(params)
-          if entity_type.nil?
-            finder_class.new(filter: params[:f], page: params[:page], per_page: params[:per_page]).results.first
+          if entity.nil?
+            finder_class.new(params: params).result.first
           else
-            finder_class.new(entity_type: entity_type, filter: params[:f]).results.first
+            finder_class.new(entity: entity, params: params).result.first
           end
         end
 
         def apply_id(params)
           return if params[:id].nil?
-          params[:f] = {} unless params.key?('f')
-          params[:f][:id] = params[:id] unless params[:f].key?('id')
+
+          params[:id_eq] = params[:id] unless params.key?("id")
         end
       end
     end