right 0.7.2

data/lib/right/pagination_parameters_validator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module Right
+  #
+  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/right/paginator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module Right
+  # 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)
+      collection.offset(offset).limit(limit)
+    end
+  end
+end

data/lib/right/railtie.rb

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

data/lib/right/ransackable_filter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Right
+  #
+  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/right/ransackable_filter_parameters_adapter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+module Right
+  # 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

data/lib/right/ransackable_sort.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Right
+  # Sort scope
+  class RansackableSort
+    # @param app [#call]
+    def initialize(app)
+      @app = app
+    end
+
+    # @param env [<ActiveRecord::Relation, <String>]
+    #   * first element is a scope to be sorted
+    #   * second is a array with user provided sortings
+    # @return [<ActiveRecord::Relation, <String>]
+    #
+    def call(env)
+      scope, params = env
+
+      ransackable_query = scope.ransack
+      ransackable_query.sorts = params[:sort]
+
+      app.call([ransackable_query.result, params])
+    end
+
+    private
+
+    attr_reader :app
+  end
+end

data/lib/right/ransackable_sort_parameters_adapter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Right
+  # Converts array of parameters to hash familiar to ransack gem
+  #
+  class RansackableSortParametersAdapter
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      scope, params = env
+
+      ransackable_parameters = Array(params[:sort]).map do |parameter|
+        "#{parameter.name} #{parameter.direction}"
+      end
+
+      app.call([scope, params.merge(sort: ransackable_parameters)])
+    end
+
+    private
+
+    attr_reader :app
+  end
+end

data/lib/right/result.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module Right
+  # Marker module
+  module Result
+  end
+
+  # Represents fetching failure
+  class Failure
+    include Result
+
+    # @param errors [<String>]
+    def initialize(errors)
+      @errors = errors
+    end
+
+    # @param errors [<String>]
+    attr_reader :errors
+
+    # @return [true]
+    def failure?
+      !success?
+    end
+
+    # @return [false]
+    def success?
+      false
+    end
+
+    # @raise [NotImplementedError]
+    def get
+      fail NotImplementedError, <<-MESSAGE.strip_heredoc
+        #{self.class} does not respond to #get. You should explicitly check for
+        #success? before calling #get.
+      MESSAGE
+    end
+
+    # @yield given block
+    def get_or_else
+      yield
+    end
+  end
+
+  # Represents fetching success
+  class Success
+    include Result
+
+    # @param value [ActiveRecord::Relation]
+    def initialize(value)
+      @value = value
+    end
+
+    # @return [false]
+    def failure?
+      !success?
+    end
+
+    # @return [true]
+    def success?
+      true
+    end
+
+    # @return [ActiveRecord::Relation]
+    def get
+      @value
+    end
+
+    # @return [ActiveRecord::Relation]
+    def get_or_else
+      @value
+    end
+  end
+end

data/lib/right/sort_middleware.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Right
+  # Sort scope using ransack gem
+  #
+  class SortMiddleware
+    # @param app [#call]
+    #
+    def initialize(app)
+      @app = app
+    end
+
+    attr_reader :app
+
+    # @param [Array(ActiveRecord::Relation, Hash)] env
+    # First argument is a ActiveRecord relation which must be sorted
+    # Second argument is a request parameters provided by user
+    #
+    def call(env)
+      scope, = ::Middleware::Builder.new do |b|
+        b.use RansackableSortParametersAdapter
+        b.use RansackableSort
+      end.call(env)
+
+      app.call([scope, env[1]])
+    end
+  end
+end

data/lib/right/sort_parameter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module Right
+  # User provided filtering on particular parameter
+  #
+  class SortParameter
+    DIRECTIONS = %w(asc desc).freeze
+    REVERSED_DIRECTIONS = {
+      'asc' => 'desc',
+      'desc' => 'asc',
+    }.freeze
+
+    attr_reader :direction
+
+    # @return [ParameterDefinition]
+    #
+    attr_reader :definition
+
+    # @param ['asc', desc'] direction
+    # @param [SortParameterDefinition]
+    #
+    def initialize(direction, definition)
+      @direction = direction.to_s
+      fail ArgumentError unless DIRECTIONS.include?(@direction)
+      @definition = definition
+      @validator = definition.validator
+    end
+
+    attr_reader :validator
+    delegate :name, to: :definition
+    delegate :valid?, to: :validator
+    delegate :invalid?, to: :validator
+
+    def errors
+      validator.errors.full_messages
+    end
+
+    def ==(other)
+      is_a?(other.class) &&
+        direction == other.direction &&
+        definition == other.definition
+    end
+
+    # @return ['asc', desc']
+    #
+    def direction
+      if definition.reverse_direction?
+        REVERSED_DIRECTIONS[@direction]
+      else
+        @direction
+      end
+    end
+  end
+end

data/lib/right/sort_parameter_definition.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module Right
+  # Sorting parameter definition
+  #
+  class SortParameterDefinition
+    # @return [String]
+    attr_reader :name
+
+    # If the property name doesn't match the name in the query string, use the :as option
+    # @return [String]
+    attr_reader :as
+
+    # @return [Boolean]
+    attr_reader :reverse_direction
+
+    # @param [String] name of the field
+    # @param [String] as (#name) alias for the property
+    # @param [Boolean] reverse_direction (false) default sorting direction
+    #
+    def initialize(name, as: name, reverse_direction: false)
+      @name = name.to_s
+      @as = as.to_s
+      @reverse_direction = reverse_direction
+    end
+
+    # If two parameters have the same name, they are equal.
+    delegate :hash, to: :name
+
+    def eql?(other)
+      other.is_a?(self.class) && other.name == name
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        other.name == name &&
+        other.as == as
+    end
+
+    alias reverse_direction? reverse_direction
+
+    def validator
+      SortValueValidator.build(self).new
+    end
+
+    def defined?
+      true
+    end
+
+    def undefined?
+      !self.defined?
+    end
+  end
+end