might 0.3.0

data/lib/might/ransackable_sort.rb

@@ -0,0 +1,27 @@
+module Might
+  # 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/might/ransackable_sort_parameters_adapter.rb

@@ -0,0 +1,23 @@
+module Might
+  # 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/might/result.rb

@@ -0,0 +1,68 @@
+module Might
+  # 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
+    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/might/sort_middleware.rb

@@ -0,0 +1,31 @@
+require 'might/ransackable_sort_parameters_adapter'
+require 'might/ransackable_sort'
+require 'might/sort_parameters_extractor'
+require 'middleware'
+
+module Might
+  # 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/might/sort_parameter.rb

@@ -0,0 +1,54 @@
+require 'active_support/core_ext/module/delegation'
+
+module Might
+  # 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/might/sort_parameter_definition.rb

@@ -0,0 +1,54 @@
+require_relative 'sort_value_validator'
+
+module Might
+  # 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_method :reverse_direction?, :reverse_direction
+
+    def validator
+      SortValueValidator.build(self).new
+    end
+
+    def defined?
+      true
+    end
+
+    def undefined?
+      !self.defined?
+    end
+  end
+end

data/lib/might/sort_parameters_extractor.rb

@@ -0,0 +1,62 @@
+require 'might/sort_undefined_parameter'
+require 'might/sort_parameter'
+
+module Might
+  # User provided sorting syntax:
+  #   * `name` - sort by name
+  #   * `-name` - sort by name in reversed order
+  #   * `-name,created_at` - sort by name in reversed order, and then sort by created_at
+  #
+  # This middleware parses sorting string and builds Parameter array
+  # @see Might::Sort::Parameter
+  #
+  # If user passes not defined sort order, it yields to `UndefinedParameter`, so you may
+  # validate it.
+  #
+  class SortParametersExtractor
+    # @param app [#call]
+    # @param parameters_definition [Set<Might::SortParameterDefinition>]
+    def initialize(app, parameters_definition)
+      @app = app
+      @parameters_definition = parameters_definition
+    end
+
+    # @param env [<String, []>]
+    #   * first element is a scope to be sorted
+    #   * second is a String with user provided sortings
+    # @return [<<Might::RansackableSort::SortParameter, []>]
+    #
+    def call(env)
+      params, errors = env
+
+      sort_params = sort_order(params[:sort]).map do |(attribute, direction)|
+        extract_parameter(attribute, direction)
+      end
+
+      app.call([params.merge(sort: sort_params), errors])
+    end
+
+    private
+
+    attr_reader :parameters_definition, :app
+
+    def extract_parameter(name, direction)
+      definition = parameters_definition.detect { |d| d.as == name } || SortUndefinedParameter.new(name)
+      SortParameter.new(direction, definition)
+    end
+
+    def sort_order(params)
+      String(params).split(',').map do |attribute|
+        sorting_for(attribute)
+      end
+    end
+
+    def sorting_for(field)
+      if field.start_with?('-')
+        [field.delete('-'), 'desc']
+      else
+        [field, 'asc']
+      end
+    end
+  end
+end

data/lib/might/sort_parameters_validator.rb

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

data/lib/might/sort_undefined_parameter.rb

@@ -0,0 +1,15 @@
+require 'might/sort_parameter_definition'
+
+module Might
+  # Null object for ParameterDefinition
+  #
+  class SortUndefinedParameter < SortParameterDefinition
+    def required?
+      false
+    end
+
+    def defined?
+      false
+    end
+  end
+end

data/lib/might/sort_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/callbacks'
+require 'active_model/naming'
+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 SortValueValidator
+    module_function
+
+    # Validates if Parameter is undefined or not
+    class DefinedValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, _value)
+        record.errors.add(attribute, :undefined_sort_order) if record.undefined?
+      end
+    end
+
+    def build(definition)
+      Class.new do
+        include ActiveModel::Validations
+
+        validates(definition.name, 'might/sort_value_validator/defined': true)
+
+        define_method(:undefined?) { definition.undefined? }
+        define_method(definition.name) {}
+
+        def self.model_name
+          ActiveModel::Name.new(Might, nil, 'Might')
+        end
+      end
+    end
+  end
+end

data/lib/might/version.rb

@@ -0,0 +1,4 @@
+#
+module Might
+  VERSION = '0.3.0'
+end

data/might.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'might/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'might'
+  spec.version       = Might::VERSION
+  spec.authors       = ['Tema Bolshakov']
+  spec.email         = ['abolshakov@spbtv.com']
+
+  spec.summary       = 'Mighty resource fetchers'
+  spec.description   = 'Mighty resource fetchers build on top of Ransack gem'
+  spec.homepage      = 'https://github.com/SPBTV/might'
+  spec.license       = 'Apache 2.0'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'activesupport', '>= 3.2'
+  spec.add_runtime_dependency 'activemodel', '>= 3.2'
+  spec.add_runtime_dependency 'uber', '~> 0.0.15'
+  spec.add_runtime_dependency 'ibsciss-middleware', '~> 0.3'
+  spec.add_runtime_dependency 'ransack', '~> 1.6.6'
+  spec.add_development_dependency 'activerecord', '>= 3.2'
+  spec.add_development_dependency 'sqlite3', '~> 1.3'
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.3'
+  spec.add_development_dependency 'rubocop', '~> 0.34.2'
+end