rhino_project_core 0.20.0.alpha.0

data/lib/rhino/sieve/filter.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Filter # rubocop:disable Metrics/ClassLength
+      def initialize(app)
+        @app = app
+      end
+
+      # filter[blog_id]=1
+      def resolve(scope, params)
+        return @app.resolve(scope, params) unless params.key?(:filter)
+
+        filter = params[:filter].permit!.to_h
+        scope = scope.joins(get_joins(scope.klass, filter))
+        query = apply_filters(scope, scope.klass, filter).distinct(:id)
+        @app.resolve(query, params)
+      end
+
+      private
+      def get_joins_hash(base, filter)
+        res = []
+        filter.each do |key, val|
+          value_is_hash = val.is_a? Hash
+          # only consider a key for the join clause if it is a relationship a.k.a reflection
+          key_is_reflection = base.reflections.key? key
+
+          next unless value_is_hash && key_is_reflection
+
+          # in the next recursion, the associations will have to be checked against this current key, not the initial model
+          reflection_model = base.reflections[key.to_s].klass
+          res << { key => get_joins_hash(reflection_model, val) }
+        end
+        res
+      end
+
+      def get_joins(base, filter)
+        joins_hash = get_joins_hash(base, filter)
+        result = []
+        joins_hash.each do |entry|
+          entry.each do |key, value|
+            result << ArelHelpers.join_association(base, { key => value }, Arel::Nodes::OuterJoin, {})
+          end
+        end
+        result
+      end
+
+      def apply_filters(scope, base, filter)
+        filter.each do |key, val|
+          key = Sieve::Helpers.real_column_name(scope, key)
+          key_is_reflection = base.reflections.key? key
+          key_is_attribute = base.attribute_names.include? key
+          key_is_association_operator = ASSOCIATION_OPS.include? key
+          if key_is_association_operator
+            scope = apply_association_operator(base, scope, key, val)
+          elsif key_is_reflection || key_is_attribute
+            scope = apply_filter(scope, base, key, val)
+          end
+        end
+        scope
+      end
+
+      def apply_filter(scope, base, key, val)
+        reflection = base.reflections[key.to_s]
+        value_is_hash = val.is_a? Hash
+        if value_is_hash && reflection
+          # joined table filter, continue recursion, e.g. ?filter[blog][...]
+          association_base = reflection.klass
+          apply_filters(scope, association_base, val)
+        elsif reflection
+          # direct association id filter, e.g. ?filter[blog]=1
+          apply_association_filter(base, scope, key, val)
+        else
+          # column filter, e.g. ?filter[name]=...
+          apply_column_filter(base, scope, key, val)
+        end
+      end
+
+      def apply_association_filter(base, scope, key, value)
+        scope.where(base.arel_table[base.reflections[key].foreign_key].eq(value))
+      end
+
+      ASSOCIATION_OPS = %w[_is_empty].freeze
+      def apply_association_operator(base, scope, key, value)
+        if key == '_is_empty' && truthy?(value)
+          arel_node = base.arel_table['id']
+
+          where_clause = arel_node.eq(nil)
+          scope.where(where_clause)
+        else
+          scope
+        end
+      end
+
+      def apply_column_filter(base, scope, column_name, column_value)
+        if column_value.is_a?(Hash)
+          # it is a more complex query, possibly using operators like gt, lt, etc.
+          # more than one operator per-field is allowed
+          column_value.each do |operation, value|
+            scope = merge_where_clause(base, scope, column_name, value, operation)
+          end
+        else
+          scope = merge_where_clause(base, scope, column_name, column_value)
+        end
+        scope
+      end
+
+      BASIC_AREL_OPS = %w[eq gt lt gteq lteq].freeze
+      BASIC_AREL_COALESCE_OPS = BASIC_AREL_OPS.map { |op| "#{op}_coalesce" }.freeze
+      def merge_where_clause(base, scope, column_name, value, operation = nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        arel_node = base.arel_table[column_name]
+        where_clause = case operation
+                       when *BASIC_AREL_OPS then arel_node.send(operation, value)
+                       when *BASIC_AREL_COALESCE_OPS
+                         coalesce = Arel::Nodes::NamedFunction.new('COALESCE', [arel_node, Arel::Nodes.build_quoted(value)])
+                         coalesce.send(operation.split('_').first, value)
+                       when 'diff' then arel_node.not_eq(value)
+                       when 'is_null' then apply_is_null(arel_node, value)
+                       when /^tree_(.*)/ then apply_tree(Regexp.last_match(1), base, column_name, arel_node, value)
+                       else
+                         if value.is_a? Array
+                           arel_node.in(value)
+                         else
+                           arel_node.eq(value)
+                         end
+        end
+        scope.where(where_clause)
+      end
+
+      def apply_is_null(arel_node, value)
+        if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
+          arel_node.not_eq(nil)
+        else
+          arel_node.eq(nil)
+        end
+      end
+
+      def apply_tree(operation, base, column_name, arel_node, value)
+        subquery = base.where(column_name => value).map(&operation.to_sym).flatten.map(&column_name.to_sym)
+
+        arel_node.in(subquery)
+      end
+
+      def truthy?(value)
+        value.present? && ActiveModel::Type::Boolean::FALSE_VALUES.exclude?(value)
+      end
+    end
+  end
+end

data/lib/rhino/sieve/geospatial.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Geospatial
+      def initialize(app)
+        @app = app
+      end
+
+      # geospatial={near: {location: { latitude: 41.2565, longitude: -95.9345 }, max_distance: 10, units: 'km'}}
+      # geospatial={near: {location: 'Omaha, NE, US', max_distance: 10, units: 'km'}}
+      def resolve(scope, params)
+        return @app.resolve(scope, params) unless valid?(params)
+
+        @app.resolve(
+          scope.near(
+            @location_params,
+            @near_params[:max_distance],
+            units: @near_params[:units]
+          ), params
+        )
+      end
+
+      private
+        def valid?(params) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          @geospatial_params = params[:geospatial]
+          return false unless @geospatial_params.is_a?(ActionController::Parameters)
+
+          @near_params = @geospatial_params[:near]
+          return false unless @near_params.is_a?(ActionController::Parameters)
+
+          @location_params = @near_params[:location]
+          if @location_params.is_a?(String)
+            @location_params = @near_params[:location]
+          elsif @location_params.is_a?(ActionController::Parameters) && @location_params[:latitude].present? && @location_params[:longitude].present?
+            @location_params = [@location_params[:latitude], @location_params[:longitude]]
+          else
+            return false
+          end
+
+          @near_params[:max_distance].present?
+        end
+    end
+  end
+end

data/lib/rhino/sieve/helpers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Helpers
+      def self.real_column_name(scope, column_name)
+        scope.attribute_aliases[column_name] || column_name
+      end
+    end
+  end
+end

data/lib/rhino/sieve/limit.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Limit
+      attr_accessor :default_limit
+
+      def initialize(app, default_limit: 20)
+        @app = app
+
+        @default_limit = default_limit
+      end
+
+      # limit=20
+      def resolve(scope, params)
+        @app.resolve(scope.limit(params[:limit] || default_limit), params)
+      end
+    end
+  end
+end

data/lib/rhino/sieve/offset.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Offset
+      def initialize(app)
+        @app = app
+      end
+
+      # offset=20
+      def resolve(scope, params)
+        @app.resolve(scope.offset(params[:offset]), params)
+      end
+    end
+  end
+end

data/lib/rhino/sieve/order.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Order
+      def initialize(app)
+        @app = app
+      end
+
+      # order=name
+      def resolve(scope, params)
+        @scope = scope
+        @param = params[:order]
+
+        # Always append id to the end of the order clause to ensure a stable sort for pagination
+        result = apply_order.order(:id)
+        @app.resolve(result, params)
+      end
+
+      private
+      def parse(param)
+        direction = parse_direction(param)
+        column_name = parse_column_name(param, direction)
+        [direction, column_name]
+      end
+
+      def parse_direction(param)
+        if param[0] == '-'
+          :desc
+        else
+          :asc
+        end
+      end
+
+      def parse_column_name(param, direction)
+        param = if direction == :asc
+                  param
+        else
+                  param[1..]
+        end
+        Sieve::Helpers.real_column_name(@scope, param)
+      end
+
+      def string?(param)
+        param.is_a? String
+      end
+
+      def get_joins(base, path, _last_base)
+        return {} if path.empty?
+
+        # Convert to nested hash
+        join_tables = path.reverse.inject({}) { |assigned_value, key| { key => assigned_value } }
+
+        # If InnerJoin was used instead of OuterJoin, a simple ORDER clause targeting an association's column
+        # would incur in a join being made, which in turn would exclude records with no association. This would
+        # be conceptually wrong, as an ORDER clause would be excluding records from the final result. In order to
+        # restore the previous behavior and exclude these records without parent, one could simply add a WHERE
+        # clause with something like `WHERE association.id IS NOT NULL`.
+        ArelHelpers.join_association(base, join_tables, Arel::Nodes::OuterJoin, {})
+      rescue StandardError
+        nil
+      end
+
+      def build_select_clause(model, path, field)
+        return model.arel_table[Arel.star] if path.empty?
+
+        model.arel_table[field]
+      end
+
+      def split_field_path(column_name)
+        chunks = column_name.split('.')
+        field = chunks.last
+        path = chunks.slice(0, chunks.length - 1)
+        [path, field]
+      end
+
+      def analyze(column_name)
+        path, field = split_field_path(column_name)
+
+        last_base = if path.last.blank?
+            @scope
+        else
+            path.last.classify.safe_constantize
+        end
+        return nil unless last_base&.attribute_names&.include? field
+
+        join_clauses = get_joins(@scope.klass, path, last_base)
+        select_clause = build_select_clause(last_base, path, field)
+
+        [join_clauses, last_base.arel_table[field], select_clause]
+      end
+
+      NULL_ORDERING = {
+        asc: :nulls_last,
+        desc: :nulls_first
+      }.freeze
+      def order(direction, column_name)
+        # nulls_last should generally be the desired user experience
+        join_clauses, order_clause, select_clause = analyze(column_name)
+        return nil unless join_clauses && order_clause
+
+        final_clause = order_clause
+                       .send(direction)
+                       .send(NULL_ORDERING[direction])
+        [join_clauses, final_clause, select_clause]
+      end
+
+      def build_clause(param)
+        return nil unless string?(param)
+
+        direction, column_name = parse(param)
+        order(direction, column_name)
+      end
+
+      def group_clauses(clauses)
+        join_clauses = clauses.map { |joins, _node, _select| joins }
+        order_clauses = clauses.map { |_joins, node, _select| node }
+        select_clauses = clauses.map { |_joins, _node, select| select }
+        [order_clauses, join_clauses, select_clauses]
+      end
+
+      def build_clauses
+        clauses = @param.split(',')
+                        .map { |el| build_clause(el) }
+                        .filter { |joins, node, select| joins && node && select }
+        group_clauses(clauses)
+      end
+
+      def apply_order
+        return @scope unless string?(@param)
+
+        order_clauses, join_clauses, select_clauses = build_clauses
+        if order_clauses.empty?
+          @scope
+        else
+          select_clauses << "#{@scope.klass.table_name}.*"
+          @scope = @scope.reorder(nil).select(select_clauses.uniq).joins(join_clauses)
+          order_clauses.inject(@scope) { |acc, el| acc.order(el) }
+        end
+      end
+    end
+  end
+end

data/lib/rhino/sieve/search.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Search
+      def initialize(app)
+        @app = app
+      end
+
+      # search='test'
+      def resolve(scope, params)
+        return @app.resolve(scope, params) unless scope.respond_to?(:search_text_fields) && params[:search].present?
+
+        # Re-order so that rank isn't the default
+        # FIXME: Should look at the order param for 'rank'
+        @app.resolve(scope.search_text_fields(params[:search]).reorder(''), params)
+      end
+    end
+  end
+end

data/lib/rhino/sieve.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    extend ActiveSupport::Autoload
+
+    autoload :Filter
+    autoload :Geospatial
+    autoload :Limit
+    autoload :Offset
+    autoload :Order
+    autoload :Search
+    autoload :Helpers
+  end
+
+  class SieveStack
+    class Sieve
+      attr_reader :args, :block, :klass
+
+      def initialize(klass, args, block)
+        @klass = klass
+        @args  = args
+        @block = block
+      end
+
+      delegate :name, to: :klass
+
+      def ==(other)
+        case other
+        when Sieve
+          klass == other.klass
+        when Class
+          klass == other
+        end
+      end
+
+      def inspect
+        if klass.is_a?(Class)
+          klass.to_s
+        else
+          klass.class.to_s
+        end
+      end
+
+      def build(app)
+        klass.new(app, *args, &block)
+      end
+
+      def build_instrumented(app)
+        InstrumentationProxy.new(build(app), inspect)
+      end
+    end
+
+    # This class is used to instrument the execution of a single sieve.
+    # It proxies the `s` method transparently and instruments the method
+    # call.
+    class InstrumentationProxy
+      EVENT_NAME = 'rhino.apply_sieve'
+
+      def initialize(sieve, class_name)
+        @sieve = sieve
+
+        @payload = {
+          sieve: class_name
+        }
+      end
+
+      def resolve(scope, params)
+        ActiveSupport::Notifications.instrument(EVENT_NAME, @payload) do
+          @sieve.resolve(scope, params)
+        end
+      end
+    end
+
+    # Pretty much stolen from ActionDispatch::MiddlewareStack
+    include Enumerable
+
+    attr_accessor :sieves
+
+    def initialize(*_args)
+      @sieves = []
+      yield(self) if block_given?
+    end
+
+    # rubocop:todo Style/ExplicitBlockArgument
+    def each
+      @sieves.each { |x| yield x }
+    end
+    # rubocop:enable Style/ExplicitBlockArgument
+
+    delegate :[], :size, :last, to: :sieves
+
+    def unshift(klass, *args, &block)
+      sieves.unshift(build_sieve(klass, args, block))
+    end
+    ruby2_keywords(:unshift) if respond_to?(:ruby2_keywords, true)
+
+    def initialize_copy(other)
+      self.sieves = other.sieves.dup
+    end
+
+    def insert(index, klass, *args, &block)
+      index = assert_index(index, :before)
+      sieves.insert(index, build_sieve(klass, args, block))
+    end
+    ruby2_keywords(:insert) if respond_to?(:ruby2_keywords, true)
+
+    alias insert_before insert
+
+    def insert_after(index, *args, &block)
+      index = assert_index(index, :after)
+      insert(index + 1, *args, &block)
+    end
+    ruby2_keywords(:insert_after) if respond_to?(:ruby2_keywords, true)
+
+    def swap(target, *args, &block)
+      index = assert_index(target, :before)
+      insert(index, *args, &block)
+      sieves.delete_at(index + 1)
+    end
+    ruby2_keywords(:swap) if respond_to?(:ruby2_keywords, true)
+
+    def delete(target)
+      sieves.delete_if { |m| m.klass == target }
+    end
+
+    def use(klass, *args, &block)
+      sieves.push(build_sieve(klass, args, block))
+    end
+    ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
+
+    def build(app = nil, &block)
+      instrumenting = ActiveSupport::Notifications.notifier.listening?(InstrumentationProxy::EVENT_NAME)
+
+      # Freeze only production so that reloading works
+      sieves.freeze unless Rails.env.development?
+
+      sieves.reverse.inject(app || block) do |a, e|
+        if instrumenting
+          e.build_instrumented(a)
+        else
+          e.build(a)
+        end
+      end
+    end
+
+    private
+    def assert_index(index, where)
+      i = index.is_a?(Integer) ? index : sieves.index { |m| m.klass == index }
+      raise "No such sieve to insert #{where}: #{index.inspect}" unless i
+
+      i
+    end
+
+    def build_sieve(klass, args, block)
+      Sieve.new(klass, args, block)
+    end
+  end
+end