yap 1.4.0 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 90a7fb8f804bd7b631c632deeb7241bfcdac00ee
-  data.tar.gz: 4d2de49002fcdc9d79dd60786a3c191fac6275cb
+  metadata.gz: 04100f8b32c43f3281e414e58d2ac06bc736351f
+  data.tar.gz: 8242bbd5e3b635a25feb3d69264a057d491bffda
 SHA512:
-  metadata.gz: 1669e8d881f42da049c61c49c1b1c483340ece46642f281831dd104f999198320eca72b82c097d8d1df534830b8c97223a559c080fdae695671c8f9a9a36a89e
-  data.tar.gz: fac27392172ca4fbbf5fb96332f79bcf157893a87076335e094d50908589b9e85e6f1ee5cbaa55d900538bf688cbc7451751d985ec57af61a7e32af9db2d564e
+  metadata.gz: 276f3729be6894e0ce980a4625d3f48f7b4f03730c1a89cc2468441b08c85aba33abb5aa213f2a7e2d92c08a01cb5fb8d6275af2dc65570943e67b806d3d15d8
+  data.tar.gz: a3424e43274c8bc5c27c6b3ebe11a5a09576a00b07685fadd6c54b64fa9234f9a0f45a9b51ea03121dbeb5180557b6c76bad8b2c54a0f613cf19ee9056467d46

data/README.md

@@ -1,3 +1,5 @@
+[![Build Status](https://travis-ci.org/1and1/yap.svg?branch=master)](https://travis-ci.org/1and1/yap) [![Test Coverage](https://codeclimate.com/github/1and1/yap/badges/coverage.svg)](https://codeclimate.com/github/1and1/yap/coverage) [![Code Climate](https://codeclimate.com/github/1and1/yap/badges/gpa.svg)](https://codeclimate.com/github/1and1/yap)
+
 Yet another paginator for Ruby on Rails, which adds a `paginate` scope to your ActiveRecords.
 
 ## Setup

data/lib/string_infinity.rb

@@ -3,8 +3,8 @@ class StringInfinity < String
     String::INFINITY_NEGATIVE
   end
 
-  def ==(value)
-    self.class == value.class
+  def ==(other)
+    self.class == other.class
   end
 end
 

data/lib/yap.rb

@@ -1,6 +1,6 @@
 require 'active_support/concern'
 require 'yap/active_record/relation'
-require 'yap/column_mapper'
+require 'yap/params_extractor'
 require 'yap/filterable'
 require 'yap/exceptions'
 require 'string_infinity'
@@ -28,7 +28,7 @@ module Yap
   include Filterable
 
   DEFAULTS = Struct.new(:page, :per_page, :hard_limit, :sort, :direction, :disable_warnings)
-                 .new(1, 10, nil, :id, :asc, false)
+    .new(1, 10, nil, :id, :asc, false)
 
   def self.configure
     raise ArgumentError, 'No block given.' unless block_given?
@@ -40,85 +40,16 @@ module Yap
   end
 
   included do
-    extend ColumnMapper
+    extend ParamsExtractor
 
     ##
     # The paginate scope takes a hash as parameter. All options are optional and can be combined arbitrarily.
     #
-    # @param [Hash] params The parameters used for pagination (:page, :per_page, :sort, :direction)
+    # @param [Hash] params The parameters used for pagination (:page, :per_page, :sort, :direction, :filter)
     #
-    scope :paginate, -> (params = {}) {
+    scope :paginate, lambda { |params = {}|
       page, per_page, order_by = extract_pagination_params(params)
-      filter(params[:filter]).limit(per_page).offset((page-1)*per_page).order(order_by)
+      filter(params[:filter]).limit(per_page).offset((page - 1) * per_page).order(order_by)
     }
-
-    private
-
-    def self.extract_pagination_params(params)
-      page = extract_number(params[:page], DEFAULTS.page)
-      per_page = extract_number(params[:per_page], DEFAULTS.per_page)
-      if DEFAULTS.hard_limit && per_page > DEFAULTS.hard_limit
-        raise PaginationError.new("Not more than #{DEFAULTS.hard_limit} items per page accepted.")
-      end
-      sort = extract_order(params[:sort], params[:direction])
-
-      return page, per_page, sort
-    end
-
-    def self.extract_number(number, default)
-      number ||= default
-      begin
-        number = Integer(number)
-      rescue
-        raise PaginationError.new("'#{number}' is not a valid number.")
-      end
-
-      raise PaginationError.new('Only positive numbers are accepted.') unless number > 0
-      number
-    end
-
-    def self.extract_order(sort, direction)
-      sort = sort.split(',') if sort.is_a?(String) && sort =~ /,/
-      direction = direction.split(',') if direction.is_a?(String) && direction =~ /,/
-
-      case sort
-      when Array
-        order = []
-        direction = Array.wrap direction
-        sort.each_with_index do |s, i|
-          order << build_order_by(s, direction[i] || DEFAULTS.direction)
-        end
-
-        order
-      when Hash
-        sort.map do |s, d|
-          build_order_by(s, d)
-        end
-      else
-        build_order_by sort, direction
-      end
-    end
-
-    def self.build_order_by(sort, direction)
-      sort = extract_column(sort)
-      direction = extract_direction(direction)
-
-      (sort =~ /\./ ? "#{sort} #{direction}" : { sort => direction })
-    end
-    private_class_method :build_order_by
-
-    def self.extract_column(sort)
-      sort ||= DEFAULTS.sort
-      column = map_column(sort.to_s.downcase)
-      raise PaginationError.new("Cannot sort by '#{sort}'.") unless column
-      column
-    end
-
-    def self.extract_direction(direction)
-      direction ||= DEFAULTS.direction
-      dir = (direction).to_sym.downcase
-      raise PaginationError.new("'#{direction}' is not a valid direction. Use 'asc' or 'desc'.") unless [:asc, :desc].include? dir
-      dir
-    end
   end
 end

data/lib/yap/active_record/relation.rb

@@ -20,7 +20,7 @@ module ActiveRecord
     # @return [Integer] Total number of results
     #
     def total
-      @total ||= without_pagination { |rel| rel.count }
+      @total ||= without_pagination(&:count)
     end
 
     ##
@@ -42,8 +42,8 @@ module ActiveRecord
     # @return [Hash] Values defining the range of the current page.
     #
     def range(include_total = false)
-      from = offset_value+1
-      to = offset_value+limit_value
+      from = offset_value + 1
+      to = offset_value + limit_value
       to = total if total < to && include_total
 
       range = { from: from, to: to }
@@ -52,4 +52,4 @@ module ActiveRecord
       range.merge(total: total)
     end
   end
-end
+end

data/lib/yap/column_mapper.rb

@@ -1,12 +1,14 @@
 module ColumnMapper
-  private
-
   def map_column(name)
-    column_names.include?(name) ? name : if respond_to? :map_name_to_column
+    actual_column = name if column_names.include?(name)
+
+    column_alias = if respond_to? :map_name_to_column
       map_name_to_column(name)
-    else
-      warn "#{self.name} does not implement map_name_to_column. If you do not need column mapping set disable_warnings=true" unless Yap::DEFAULTS.disable_warnings
-      nil
+    elsif actual_column.nil? && !Yap::DEFAULTS.disable_warnings
+      warn "#{self.name} does not implement map_name_to_column. If you do not need column mapping set " \
+          'disable_warnings=true'
     end
+
+    column_alias || actual_column
   end
-end
+end

data/lib/yap/exceptions.rb

@@ -2,4 +2,4 @@ module Yap
   class YapError < StandardError; end
   class PaginationError < YapError; end
   class FilterError < YapError; end
-end
+end

data/lib/yap/extended_range.rb

@@ -1,24 +1,23 @@
 module Yap
+  ##
+  # Extends Range by StringInfinity.
+  #
   class ExtendedRange < Range
     def begin
-      infinity_or_do_not_change super
+      handle_infinity super
     end
 
     def end
-      infinity_or_do_not_change super
+      handle_infinity super
     end
 
-    def infinity_or_do_not_change(value)
-      if value.is_a? StringInfinity
-        if value == String::INFINITY
-          Float::INFINITY
-        elsif value == -String::INFINITY
-          -Float::INFINITY
-        else
-          raise ArgumentError, "Invalid value for StringInfinity."
-        end
+    def handle_infinity(value)
+      return value unless value.is_a? StringInfinity
+
+      if value.is_a?(StringInfinityNegative)
+        -Float::INFINITY
       else
-        value
+        Float::INFINITY
       end
     end
   end

data/lib/yap/filter.rb

@@ -1,58 +1,52 @@
-require 'yap/extended_range'
+require 'yap/filter_column'
 
 module Yap
-  class Filter < Hash
+  class Filter
     def initialize
-      self[:where] = {}
-      self[:not] = {}
+      @failed = []
+      @columns = []
     end
 
-    def parse!(column, values)
-      values.to_s.split(',').each do |value|
-        # Perform negative match if value starts with '!'.
-        if value =~/^!(.+)$/
-          match = :not
-          value = $1
-        else
-          match = :where
-        end
+    def parse!(model, params)
+      params.each do |attribute, values|
+        parse_arrtibute(model, attribute, values)
+      end
 
-        case value
-        when /([<>]=?)(.+)/
-          match, value = handle_comparison_operators(match, column, $1.to_sym, $2)
-        when /(.+)\.{3}(.+)/
-          value = $1...$2
-        when /(.+)\.{2}(.+)/
-          value = $1..$2
-        else
-          # Convert null to ruby nil to use 'IS NULL' in SQL.
-          value = value.downcase == 'null' ? nil : value
-        end
+      raise FilterError, "Cannot filter by: #{@failed.join(', ')}" unless @failed.empty?
+    end
 
-        # Ensure filter contains an array to append to.
-        self[match][column] ||= []
+    def where
+      extract_filters(:where)
+    end
 
-        self[match][column] << value
-      end
+    def not
+      extract_filters(:not)
     end
 
     private
 
-    def handle_comparison_operators(match, column, operator, value)
-      case operator
-      when :<
-        handle_comparison_operators(toggle_match(match), column, :>=, value)
-      when :>
-        handle_comparison_operators(toggle_match(match), column, :<=, value)
-      when :<=
-        return match, ExtendedRange.new(-String::INFINITY, value)
-      when :>=
-        return match, ExtendedRange.new(value, String::INFINITY)
+    def extract_filters(condition)
+      @columns.inject({}) do |filter, column|
+        values = column.send(condition)
+
+        if values.empty?
+          filter
+        else
+          filter.merge(column.name => values.size == 1 ? values.first : values)
+        end
       end
     end
 
-    def toggle_match(match)
-      match == :where ? :not : :where
+    def parse_arrtibute(model, attribute, values)
+      column = model.map_column(attribute.to_s.downcase)
+      if column.nil?
+        @failed << attribute
+        return
+      end
+
+      filter_column = FilterColumn.new(column)
+      filter_column.parse_values(values)
+      @columns << filter_column
     end
   end
 end

data/lib/yap/filter_column.rb

@@ -0,0 +1,35 @@
+require 'yap/filter_value'
+
+module Yap
+  ##
+  # Multiple filter for a column can be separated by comma (,).
+  #
+  class FilterColumn
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      @values = []
+    end
+
+    def parse_values(values)
+      values.to_s.split(',').each do |value|
+        filter_value = FilterValue.new
+        filter_value.parse_value(value)
+        @values << filter_value
+      end
+    end
+
+    def where
+      @values.select do |v|
+        v.condition == :where
+      end.map(&:value)
+    end
+
+    def not
+      @values.select do |v|
+        v.condition == :not
+      end.map(&:value)
+    end
+  end
+end

data/lib/yap/filter_value.rb

@@ -0,0 +1,67 @@
+require 'yap/extended_range'
+
+module Yap
+  ##
+  # Filter values can have the following formats:
+  #
+  #  * Integer - e.g. 100
+  #  * String - e.g. text
+  #  * Comparisons - e.g. >10, <=B
+  #  * Dates - e.g. 1970-01-01 (depends on the database backend)
+  #  * Ranges - e.g. 1...2, Jones..Smith
+  #  * NULL -  e.g. NULL, null, Null
+  #  * Negation - e.g. !value, !1..10
+  #
+  class FilterValue
+    OPERATOR_INVERSION_MAP = { :< => :>=, :> => :<= }.freeze
+
+    attr_reader :condition, :value
+
+    def parse_value(value)
+      value = handle_negation(value)
+
+      @value = case value
+      when /([<>]=?)(.+)/
+        handle_comparison_operators($1.to_sym, $2)
+      when /(.+)(\.{2,3})(.+)/
+        Range.new $1, $3, $2 == '...'
+      else
+        handle_null(value)
+      end
+    end
+
+    private
+
+    def handle_negation(value)
+      if value =~ /^!(.+)$/
+        @condition = :not
+        value = $1
+      else
+        @condition = :where
+      end
+
+      value
+    end
+
+    def handle_comparison_operators(operator, value)
+      case operator
+      when :<, :> then invert_comparison_operator(operator, value)
+      when :<= then ExtendedRange.new(-String::INFINITY, value)
+      when :>= then ExtendedRange.new(value, String::INFINITY)
+      end
+    end
+
+    def invert_comparison_operator(operator, value)
+      toggle_condition!
+      handle_comparison_operators(OPERATOR_INVERSION_MAP[operator], value)
+    end
+
+    def toggle_condition!
+      @condition = @condition == :where ? :not : :where
+    end
+
+    def handle_null(value)
+      value.casecmp('null').zero? ? nil : value
+    end
+  end
+end

data/lib/yap/filterable.rb

@@ -32,31 +32,18 @@ module Yap
       #
       # @param [Hash] Attribute/value pairs to filter ( { 'gender' => 'f' } )
       #
-      scope :filter, -> (params = nil) {
+      scope :filter, lambda { |params = nil|
         if params.blank?
           all
         else
           filter = extract_filter_params(params)
-          where(filter[:where]).where.not(filter[:not])
+          where(filter.where).where.not(filter.not)
         end
       }
 
-      private
-
       def self.extract_filter_params(params)
         filter = Filter.new
-
-        failed = []
-        params.each do |key, values|
-          column = map_column(key.to_s.downcase)
-          if column
-            filter.parse!(column, values)
-          else
-            failed << key
-          end
-        end
-
-        raise FilterError.new('Cannot filter by: ' + failed.join(', ')) unless failed.empty?
+        filter.parse!(self, params)
 
         filter
       end

data/lib/yap/params_extractor.rb

@@ -0,0 +1,102 @@
+require 'yap/column_mapper'
+
+module Yap
+  ##
+  # Methods for extracting valid pagination parameters from rails params.
+  #
+  module ParamsExtractor
+    def extract_pagination_params(params)
+      page = extract_page(params)
+      per_page = extract_per_page(params)
+      sort = extract_order(params)
+
+      [page, per_page, sort]
+    end
+
+    def extract_page(params)
+      extract_number(params[:page], DEFAULTS.page)
+    end
+
+    def extract_per_page(params)
+      per_page = extract_number(params[:per_page], DEFAULTS.per_page)
+
+      if DEFAULTS.hard_limit && per_page > DEFAULTS.hard_limit
+        raise PaginationError, "Not more than #{DEFAULTS.hard_limit} items per page accepted."
+      end
+
+      per_page
+    end
+
+    def extract_number(number, default)
+      number ||= default
+      begin
+        number = Integer(number)
+      rescue ArgumentError
+        raise PaginationError, "'#{number}' is not a valid number."
+      end
+
+      raise PaginationError, 'Only positive numbers are accepted.' unless number > 0
+      number
+    end
+
+    def extract_order(params)
+      sort, direction = params.values_at(:sort, :direction)
+
+      case sort
+      when Array, String
+        build_order_from_array(sort, direction)
+      when Hash
+        build_order_from_hash(sort)
+      else # nil or symbol
+        build_order sort, direction
+      end
+    end
+
+    def build_order_from_array(sort, direction = [])
+      sort = convert_to_array(sort)
+      direction = convert_to_array(direction)
+      order = []
+      sort.each_with_index do |s, i|
+        order << build_order(s, direction[i] || DEFAULTS.direction)
+      end
+
+      order
+    end
+
+    def convert_to_array(object)
+      object = object.split(',') if object.is_a?(String)
+
+      Array.wrap(object)
+    end
+
+    def build_order_from_hash(sort)
+      sort.map do |s, d|
+        build_order(s, d)
+      end
+    end
+
+    def build_order(sort, direction)
+      sort = extract_column(sort || DEFAULTS.sort)
+      direction = extract_direction(direction)
+
+      (sort =~ /\./ ? "#{sort} #{direction}" : { sort => direction })
+    end
+
+    def extract_column(sort)
+      column = map_column(sort.to_s.downcase)
+      raise PaginationError, "Cannot sort by '#{sort}'." unless column
+
+      column
+    end
+
+    def extract_direction(direction)
+      direction ||= DEFAULTS.direction
+      dir = direction.to_sym.downcase
+      unless [:asc, :desc].include? dir
+        raise PaginationError, "'#{direction}' is not a valid direction. Use 'asc' or 'desc'."
+      end
+
+      dir
+    end
+  end
+end

data/lib/yap/version.rb

@@ -1,3 +1,3 @@
 module Yap
-  VERSION = '1.4.0'
+  VERSION = '1.4.2'.freeze
 end

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: yap
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.2
 platform: ruby
 authors:
 - Finn Glöe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-25 00:00:00.000000000 Z
+date: 2017-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +44,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
-description: Yet another paginator for Ruby on Rails adding a pagination and filtering
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+description: Yet another paginator for Ruby on Rails adding pagination and filtering
   interface to ActiveRecords.
 email: finn.gloee@1und1.de
 executables: []
@@ -54,7 +74,10 @@ files:
 - lib/yap/exceptions.rb
 - lib/yap/extended_range.rb
 - lib/yap/filter.rb
+- lib/yap/filter_column.rb
+- lib/yap/filter_value.rb
 - lib/yap/filterable.rb
+- lib/yap/params_extractor.rb
 - lib/yap/version.rb
 homepage: https://github.com/1and1/yap
 licenses:
@@ -66,9 +89,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -76,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Yet another paginator for Ruby on Rails