might 0.3.0

data/lib/might/filter_parameters_extractor.rb

@@ -0,0 +1,78 @@
+require_relative 'filter_predicates'
+require_relative 'filter_undefined_parameter'
+require_relative 'filter_parameter'
+
+module Might
+  # User provided filters syntax:
+  #   * `{ 'name_eq' => 'Martin' }` - name is equal to Martin
+  #   * `{ 'name_in' => 'Martin,Bob' }` - name is either Martin or Bob
+  #
+  # This middleware parses filters hash and builds Parameter array
+  # @see Might::FilterParameter
+  #
+  # If user passes not defined filter, it yields to `UndefinedParameter`, so you may
+  # validate it.
+  #
+  class FilterParametersExtractor
+    # @param app [#call]
+    # @param parameters_definition [Set<Might::FilterParameterDefinition>]
+    def initialize(app, parameters_definition)
+      @app = app
+      @parameters_definition = parameters_definition
+    end
+
+    # @param env [<{:filter => Hash}, []>]
+    #   * first element is a scope to be filtered
+    #   * second is a hash with user provided filters
+    # @return [<{:filter => <Might::FilterParameter>, []}]
+    #
+    def call(env)
+      params, errors = env
+
+      provided_parameters = Hash(params[:filter]).each_with_object([]) do |(name, value), parameters|
+        type_casted_value = type_cast_value(name, value)
+        parameters << extract_parameter(name, type_casted_value)
+      end
+
+      not_provided_parameters = parameters_definition - provided_parameters.map(&:definition)
+
+      undefined_parameters = not_provided_parameters.map do |definition|
+        FilterParameter.new(nil, nil, definition)
+      end
+
+      # Keep even undefined parameters to validate required ones
+      filters = provided_parameters + undefined_parameters
+
+      app.call([params.merge(filter: filters), errors])
+    end
+
+    private
+
+    attr_reader :parameters_definition, :app
+
+    def name_and_predicate(name_with_predicate)
+      predicate = FilterPredicates::ALL.detect { |p| name_with_predicate.end_with?("_#{p}") }
+      [
+        name_with_predicate.chomp("_#{predicate}"),
+        predicate
+      ]
+    end
+
+    # @param [String] name
+    # @param [String, Array<String>] value
+    #
+    def extract_parameter(name, value)
+      name, predicate = name_and_predicate(name)
+      definition = parameters_definition.detect { |d| d.as == name } || FilterUndefinedParameter.new(name)
+      FilterParameter.new(value, predicate, definition)
+    end
+
+    def type_cast_value(name, value)
+      if name.end_with?(*FilterPredicates::ON_ARRAY)
+        value.split(',')
+      else
+        value
+      end
+    end
+  end
+end

data/lib/might/filter_parameters_validator.rb

@@ -0,0 +1,26 @@
+module Might
+  # Validates filters and raises error if one of them is invalid
+  #
+  class FilterParametersValidator
+    # @param app [#call]
+    def initialize(app)
+      @app = app
+    end
+
+    # @param env [<{:filter => <Might::FilterParameter>, Array>}]
+    # @return [<{:filter => <Might::FilterParameter>, Array>}]
+    #
+    def call(env)
+      params, errors = env
+
+      invalid_filters = Array(params[:filter]).select(&:invalid?)
+      messages = invalid_filters.flat_map(&:errors)
+
+      app.call([params, errors.concat(messages)])
+    end
+
+    private
+
+    attr_reader :app
+  end
+end

data/lib/might/filter_predicates.rb

@@ -0,0 +1,26 @@
+module Might
+  # Contains contains with all supported predicates
+  #
+  module FilterPredicates
+    ON_VALUE = %w(
+      not_eq eq
+      does_not_match matches
+      gt lt
+      gteq lteq
+      not_cont cont
+      not_start start
+      not_end end
+      not_true true
+      not_false false
+      blank present
+      not_null null
+    )
+
+    ON_ARRAY = %w(
+      not_in in
+      not_cont_any cont_any
+    )
+
+    ALL = ON_VALUE + ON_ARRAY
+  end
+end

data/lib/might/filter_undefined_parameter.rb

@@ -0,0 +1,15 @@
+require_relative 'filter_parameter_definition'
+
+module Might
+  # Null object for ParameterDefinition
+  #
+  class FilterUndefinedParameter < FilterParameterDefinition
+    def required?
+      false
+    end
+
+    def defined?
+      false
+    end
+  end
+end

data/lib/might/filter_value_validator.rb

@@ -0,0 +1,43 @@
+require 'active_support'
+require 'active_support/core_ext/module/delegation'
+require 'active_model/validator'
+require 'active_model/validations'
+require 'active_model/naming'
+require 'active_model/callbacks'
+require 'active_model/translation'
+require 'active_model/errors'
+
+module Might
+  # Build singleton validation class for specified attribute name
+  # @example you need a nice validator for a first_name
+  #   validator_klass = ValueValidator.build('first_name', presence: true, length: { minimum: 3 })
+  #   validator = validator_klass.new('Bo')
+  #   validator.valid? #=> false
+  #   validator.errors.full_messages #=> ['First name is too short (minimum is 3 characters)']
+  #
+  module FilterValueValidator
+    module_function
+
+    # Validates if Parameter is undefined or not
+    class DefinedValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, _value)
+        record.errors.add(attribute, :undefined_filter) if record.undefined?
+      end
+    end
+
+    def build(definition)
+      Struct.new(definition.as.to_sym) do
+        include ActiveModel::Validations
+
+        validates(definition.as, definition.validations) if definition.validations.present?
+        validates(definition.as, 'might/filter_value_validator/defined': true)
+
+        define_method(:undefined?) { definition.undefined? }
+
+        def self.model_name
+          ActiveModel::Name.new(Might, nil, 'Might')
+        end
+      end
+    end
+  end
+end

data/lib/might/pagination_middleware.rb

@@ -0,0 +1,60 @@
+# require_relative 'validator'
+require 'might/paginator'
+
+module Might
+  # Pagination middleware
+  #
+  class PaginationMiddleware
+    # @param app [#call, Proc]
+    # @param max_per_page [Integer]
+    # @param per_page [Integer]
+    #
+    def initialize(app, max_per_page: false, per_page: 50)
+      @app = app
+      @max_per_page = max_per_page
+      @per_page = per_page
+    end
+
+    # @param [Array(ActiveRecord::Relation, Hash)] env
+    # First argument is a ActiveRecord relation which must be paginated
+    # Second argument is a request parameters provided by user
+    #
+    def call(env)
+      scope, params = env
+      # validate_parameters!(params)
+      paginated_scope = Paginator.new(pagination_options(params)).paginate(scope)
+      app.call([paginated_scope, params])
+    end
+
+    private
+
+    attr_reader :app
+
+    # def validate_parameters!(params)
+    #   validator = Validator.new(params[:page])
+    #   fail(PaginationValidationFailed, validator.errors) unless validator.valid?
+    # end
+
+    # @param [Hash] params
+    # @option params [Hash] (nil) :limit
+    # @option params [Hash] (nil) :offset
+    #
+    def pagination_options(params)
+      options = default_pagination_options.merge(Hash(params[:page]))
+      max_per_page = @max_per_page
+
+      if max_per_page && options[:limit] > max_per_page
+        options.merge(limit: max_per_page)
+      else
+        options
+      end
+    end
+
+    def default_pagination_options
+      {
+        limit: @per_page,
+        offset: 0
+      }.with_indifferent_access
+    end
+  end
+end

data/lib/might/pagination_parameters_validator.rb

@@ -0,0 +1,55 @@
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/callbacks'
+require 'active_model/naming'
+require 'active_model/validator'
+require 'active_model/callbacks'
+require 'active_model/translation'
+require 'active_model/errors'
+require 'active_model/validations'
+
+module Might
+  #
+  class PaginationParametersValidator
+    # Validates pagination parameters
+    # @param [Hash, nil] page
+    # @option page [Number, nil] :limit
+    # @option page [Number, nil] :offset
+    #
+    Validator = Struct.new(:page) do
+      include ActiveModel::Validations
+
+      validate :page_is_a_hash
+      validates :limit, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
+      validates :offset, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
+
+      def page_is_a_hash
+        return if page.is_a?(Hash) || page.nil?
+        errors.add(:page, :invalid_page_type)
+      end
+
+      def limit
+        page[:limit] if page.is_a?(Hash)
+      end
+
+      def offset
+        page[:offset] if page.is_a?(Hash)
+      end
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      params, errors = env
+
+      validator = Validator.new(params[:page]).tap(&:validate)
+      messages = validator.errors.full_messages
+
+      app.call([params, errors.concat(messages)])
+    end
+
+    attr_reader :app
+  end
+end

data/lib/might/paginator.rb

@@ -0,0 +1,58 @@
+# require 'active_support/core_ext/hash/keys'
+
+module Might
+  # Paginates ActiveRecord scopes
+  # @example
+  #
+  #   Paginator.new(limit: 10, offset: 100).paginate(Movie.all)
+  #
+  # As a side effect of pagination it defines the following methods on collection:
+  #   collection#limit
+  #   collection#offset
+  #   collection#count
+  #   collection#total_count
+  #
+  class Paginator
+    InvalidLimitOrOffset = Class.new(StandardError)
+
+    attr_reader :limit, :offset
+
+    # @param [{Symbol => Integer}] params
+    # @option params [Integer] :limit
+    # @option params [Integer] :offset
+    #
+    def initialize(options = {})
+      @limit = Integer(options.fetch(:limit))
+      @offset = Integer(options.fetch(:offset))
+
+      fail InvalidLimitOrOffset if @limit < 0 || @offset < 0
+    end
+
+    # Paginate given collection
+    # @param [ActiveRecord::CollectionProxy, ActiveRecord::Base] collection
+    # @return [ActiveRecord::CollectionProxy]
+    #
+    def paginate(collection)
+      paginated_collection = collection.offset(offset).limit(limit)
+
+      pagination_hash = pagination(collection, paginated_collection)
+
+      paginated_collection.define_singleton_method(:pagination) do
+        pagination_hash
+      end
+
+      paginated_collection
+    end
+
+    private
+
+    def pagination(collection, paginated_collection)
+      {
+        limit: limit,
+        offset: offset,
+        count: paginated_collection.count(:all),
+        total: collection.count(:all)
+      }
+    end
+  end
+end

data/lib/might/railtie.rb

@@ -0,0 +1,8 @@
+require 'rails/railtie'
+
+#
+module Might
+  # Load railtie to get translations
+  class Railtie < Rails::Railtie
+  end
+end

data/lib/might/ransackable_filter.rb

@@ -0,0 +1,24 @@
+module Might
+  #
+  class RansackableFilter
+    # @param app [#call]
+    def initialize(app)
+      @app = app
+    end
+
+    # @param env [<ActiveRecord::Relation, Hash]
+    #   * first element is a scope to be filtered
+    #   * second is a hash with user provided filters
+    # @return [<ActiveRecord::Relation, Hash]
+    #
+    def call(env)
+      scope, params = env
+      filtered_scope = scope.ransack(params[:filter]).result
+      app.call([filtered_scope, params])
+    end
+
+    private
+
+    attr_reader :app
+  end
+end

data/lib/might/ransackable_filter_parameters_adapter.rb

@@ -0,0 +1,61 @@
+module Might
+  # Converts array of parameters to hash familiar to ransack gem
+  #
+  class RansackableFilterParametersAdapter
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      scope, params = env
+
+      ransackable_parameters = Array(params[:filter]).reject { |f| f.predicate.nil? }
+                               .each_with_object({}) do |filter, ransackable_filters|
+        ransackable_filters[canonical_name_for(filter)] = filter.value
+      end
+
+      app.call([scope, params.merge(filter: ransackable_parameters)])
+    end
+
+    private
+
+    attr_reader :app
+
+    # @return [String, nil] filter with predicate. E.g. `first_name_eq`
+    #   nil value means that
+    #
+    def canonical_name_for(filter)
+      if filter.on.is_a?(Hash)
+        name_for_polymorphic(filter)
+      else
+        [filter.on, filter.name, filter.predicate].compact.join('_')
+      end
+    end
+
+    # Build query method for polymorphic association
+    # @see https://github.com/activerecord-hackery/ransack/wiki/Polymorphic-searches
+    # @see https://github.com/activerecord-hackery/ransack/commit/c156fa4a7ac6e1a8d730791c49bf4403aa0f3af7#diff-a26803e1ff6e56eb67b80c91d79a063eR34
+    # @param [SortParameter] filter
+    # @return [String]
+    #
+    # @example
+    #
+    #   definition = ParameterDefinition.new('genre_name', on: { resource: ['Movie', 'Channel'] })
+    #   parameter = Parameter.new('Horror', 'eq', definition)
+    #   name_for_polymorphic(parameter)
+    #     #=> 'resource_of_Movie_type_genre_name_or_resource_of_Channel_type_genre_name_eq'
+    #
+    def name_for_polymorphic(filter)
+      unless filter.on.size == 1
+        fail ArgumentError, 'Polymorphic association must be defined as Hash with single value'
+      end
+      polymorphic_name = filter.on.keys.first
+
+      name = Array(filter.on.values.first)
+             .map { |polymorphic_type| "#{polymorphic_name}_of_#{polymorphic_type}_type_#{filter.name}" }
+             .join('_or_')
+
+      "#{name}_#{filter.predicate}"
+    end
+  end
+end