rice_cooker 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: febeec59cbb060cf35bb66891a2c3017876f6263
-  data.tar.gz: 80ec86ea16fc1496809c648789e937e7592332a0
+  metadata.gz: 929e7389b2a4a7d2d42b2c69cd6216886e6ddf3c
+  data.tar.gz: 4c58c53af490da81965005546c814966117b94ee
 SHA512:
-  metadata.gz: 0b54debc8ddc3c88ae32a8b2eff042e4c1fa14bd73b6ccbc9ac32b0e2bb8c95b26db833186eadee1ac80639dad42037b69940cc4a7e4121f0c58272941525897
-  data.tar.gz: 3d46fbf0f23c24ef4afa1c01e72612a843f8b28cdc10db72ac5d8d4d39558cb9f2b7c2090d0d1ca952e02b97adb37a28edfedf159fdc90b5247a9eb620b72e2a
+  metadata.gz: 3ecd88c5dd48b17eb2a34a4307e3380843c5c74e7781076c0e6f3120c3f192839e9c928b187ac1d4fc2e04bfd623ba37ad3b328efbf605bd97baa0ab73dc75cf
+  data.tar.gz: 21ee114e133548192359a057d939cacdc3189eed43e059e1803796785508a67f7743abdab0213a3f8ededf4acf4ab631c9d494d57e03d1d7df111c8453587d80

data/.rubocop.yml

@@ -19,4 +19,7 @@ Metrics/PerceivedComplexity:
 
 Metrics/MethodLength:
   CountComments: false  # count full line comments?
-  Max: 20
+  Max: 40
+
+Style/AsciiComments:
+  Enabled: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rice_cooker (0.1.3)
+    rice_cooker (0.1.4)
       actionpack (>= 4.2.0, < 5.1)
       has_scope (~> 0.7.0, >= 0.6.0)
       rails (>= 4.2.0, < 5.1)
@@ -47,7 +47,7 @@ GEM
       i18n (~> 0.7)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    arel (7.0.0)
+    arel (7.1.1)
     ast (2.3.0)
     builder (3.2.2)
     coderay (1.1.1)
@@ -63,7 +63,7 @@ GEM
       railties (>= 3.0.0)
     faker (1.6.1)
       i18n (~> 0.5)
-    globalid (0.3.6)
+    globalid (0.3.7)
       activesupport (>= 4.1.0)
     has_scope (0.7.0)
       actionpack (>= 4.1, < 5.1)
@@ -163,7 +163,7 @@ GEM
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.0)
     slop (3.6.0)
-    sprockets (3.6.3)
+    sprockets (3.7.0)
       concurrent-ruby (~> 1.0)
       rack (> 1, < 3)
     sprockets-rails (3.1.1)

data/README.md

@@ -1,6 +1,6 @@
 # Rice Cooker
 
-[![Build Status](https://travis-ci.com/lambda2/rice_cooker.svg?token=zsj9q6JjpQd8brNcmt9S&branch=master)](https://travis-ci.com/lambda2/rice_cooker)
+[![Build Status](https://travis-ci.org/lambda2/rice_cooker.svg?branch=master)](https://travis-ci.org/lambda2/rice_cooker)
 
 Handle sort, filters, searches, and ranges on Rails collections.
 
@@ -11,6 +11,7 @@ Handle sort, filters, searches, and ranges on Rails collections.
 In your `Gemfile`:
 
 ```ruby
+gem 'has_scope'
 gem 'rice_cooker'
 ```
 
@@ -35,4 +36,28 @@ class UsersController < ActionController::Base
   end
 end
 
-```
+```
+
+### Sorting
+
+The `sort` parameter allow sorting on one or several, comma-separated, fields. The sort is applied in the order specified.
+The sort order for each sort field is ascending unless it is prefixed with a minus (-), in which case it is descending.
+
+For example, the `api.example.org/unicorns?sort=color,-name` url will return all the unicorns order by **color** in the ascending order, and if they have the same color, by **name**, on the descending order.
+
+### Filtering
+
+The `filter` parameter is a hash allowing filtering for a field, as a key, on one or several, comma-separated, values. Only the fields matching the given filter(s) will be returned.
+
+For example, the `api.example.org/unicorns?filter[color]=yellow&filter[age]=21,22` url will return all the **yellow** unicorns which are **21** OR **22** years old.
+
+### Ranging
+
+The `range` parameter is a hash allowing filtering for a field, as a key, on two comma-separated bounds. Only the fields between the given bounds will be returned. The bounds are inclusives.
+
+For example, the `api.example.org/unicorns?range[age]=21,42` url will return all the unicorns which are between **21** and **42** years old.
+
+
+## Specification
+
+The gem try to follow the [RAPIS](https://github.com/lambda2/rapis) api convention.

data/lib/rice_cooker/base/base.rb

@@ -0,0 +1,19 @@
+
+module RiceCooker
+  class Base
+    include Helpers
+    attr_accessor :params
+    attr_accessor :model
+    attr_accessor :allowed_keys
+
+    def initialize(unformated_params, model)
+      @params = format_additional_param((unformated_params || {}), self.class.action)
+      @model = model
+      @allowed_keys = []
+    end
+
+    def self.action
+      raise "You must override action"
+    end
+  end
+end

data/lib/rice_cooker/{helpers.rb → base/helpers.rb}

@@ -11,6 +11,12 @@ module RiceCooker
   class InvalidFilterValueException < Exception
   end
 
+  class InvalidSearchException < Exception
+  end
+
+  class InvalidSearchValueException < Exception
+  end
+
   class InvalidRangeException < Exception
   end
 
@@ -42,6 +48,15 @@ module RiceCooker
       end
     end
 
+    # Overridable method for available rangeable fields
+    def searchable_fields_for(model)
+      if model.respond_to?(:searchable_fields)
+        model.rangeable_fields.map(&:to_sym)
+      else
+        filterable_fields_for(model)
+      end
+    end
+
     # Overridable method for available rangeable fields
     def rangeable_fields_for(model)
       if model.respond_to?(:rangeable_fields)
@@ -180,6 +195,102 @@ module RiceCooker
       collection
     end
 
+
+    # ------------------------ Search helpers --------------------
+
+    # Va transformer le param url en hash exploitable
+    def parse_searching_param(searching_param, allowed_params)
+      return {} unless searching_param.present?
+
+      fields = {}
+
+      # Extract the fields for each type from the fields parameters
+      if searching_param.is_a?(Hash)
+        searching_param.each do |field, value|
+          resource_fields = value.split(',') unless value.nil? || value.empty?
+          fields[field.to_sym] = resource_fields
+        end
+      else
+        raise InvalidSearchException, "Invalid search format for #{searching_param}"
+      end
+      check_searching_param(fields, allowed_params)
+      fields
+    end
+
+    # Our little barrier <3
+    def check_searching_param(searching_param, allowed)
+      🔞 = searching_param.keys.map(&:to_sym) - allowed.map(&:to_sym)
+      raise InvalidSearchException, "Attributes #{🔞.map(&:to_s).to_sentence} doesn't exists or aren't searchables. Available searchs are: #{allowed.to_sentence}" if 🔞.any?
+    end
+
+    # On va essayer de garder un format commun, qui est:
+    #
+    # ```
+    # search: {
+    #   proc: -> (values) { * je fais des trucs avec les values * },
+    #   all: ['les', 'valeurs', 'aceptées'],
+    #   description: "La description dans la doc"
+    # }
+    # ```
+    #
+    # On va donc transformer `additional` dans le format ci-dessus
+    #
+    def format_additional_param(additional, context_format = 'searching')
+      if additional.is_a? Hash
+        additional = additional.map do |field, value|
+          if value.is_a?(Hash)
+            value = {
+              proc: nil,
+              all: [],
+              description: ''
+            }.merge(value)
+          elsif value.is_a? Array
+            value = {
+              proc: value.try(:at, 0),
+              all: value.try(:at, 1) || [],
+              description: value.try(:at, 2) || ''
+            }
+          elsif value.is_a? Proc
+            value = {
+              proc: value,
+              all: [],
+              description: ''
+            }
+          else
+            raise "Unable to format addional #{context_format} params (got #{additional})"
+          end
+          [field, value]
+        end.to_h
+      end
+      additional
+    end
+
+    def reduce_where(col, field, value)
+      reducer = nil
+      value.each do |v|
+        query = col.model.arel_table[field.to_sym].matches("%#{v.to_s}%")
+        reducer = (reducer ? reducer.or(query) : query)
+      end
+      col.where(reducer)
+    end
+
+    def apply_search_to_collection(col, searching_params, additional = {})
+      return col if col.nil?
+
+      searching_params.each do |field, value|
+        if additional.key?(field) && additional[field].key?(:proc)
+          col = col.instance_exec(value, &(additional[field][:proc]))
+        elsif value.is_a?(String)
+          col = col.where(col.model.arel_table[field.to_sym].matches("%#{value.join(' ')}%"))
+        elsif value.is_a?(Array)
+          col = reduce_where(col, field, value)
+        elsif value.is_a?(Hash) && value.key?(:proc)
+          col
+        end
+      end
+      col
+    end
+
     # ------------------------ Range helpers --------------------
 
     # Va transformer le param url en hash exploitable

data/lib/rice_cooker/filter.rb

@@ -6,52 +6,84 @@ module RiceCooker
 
     FILTER_PARAM = :filter
 
-    module ClassMethods
-      include Helpers
+    class Filter < RiceCooker::Base
+
+      def self.action
+        :filtering
+      end
+
+      def initialize(unformated_params, model)
+        super
+        @allowed_keys = (filterable_fields_for(@model) + @params.keys)
+      end
+
+      def register_bools
+        additional = (filterable_fields_for(@model) - [:created_at, :updated_at])
+                     .select { |e| e =~ /_at$/ }
+                     .select { |e| @params[e.to_s.gsub(/_at$/, '')].nil? }
+        additional.each { |fi| parse_bool(fi) }
+      end
+
+      def parse_bool(fi)
+        if fi.to_sym == :begin_at
+          parse_future_bool fi
+        else
+          parse_named_bool fi
+        end
+      end
+
+      def parse_future_bool(fi)
+        @params[:future] = {
+          proc: Filer.get_future_lambda("#{@model.quoted_table_name}.\"#{fi}\""),
+          all: %w(true false),
+          description: "Return only #{@model.to_s.underscore.humanize.downcase.pluralize} which begins in the future"
+        }
+        @allowed_keys << :future
+      end
+
+      def parse_named_bool(fi)
+        name = fi.to_s.gsub(/_at$/, '')
+        @params[name.to_sym] = {
+          proc: Filer.get_named_lambda(fi),
+          all: %w(true false),
+          description: "Return only #{name} #{@model.to_s.underscore.humanize.downcase.pluralize}"
+        }
+        @allowed_keys << name
+      end
+
+      def self.get_future_lambda(db_field)
+        lambda do |value|
+          value.first == 'true' ? where("#{db_field} >= ?", Time.zone.now) : where("#{db_field} < ?", Time.zone.now)
+        end
+      end
 
+      def self.get_named_lambda(fi)
+        lambda do |value|
+          value.first == 'true' ? where.not(fi => nil) : where(fi => nil)
+        end
+      end
+
+      def process(value, scope, custom, filter)
+        params = parse_filtering_param(value, filter)
+        apply_filter_to_collection(scope, params, custom)
+      end
+    end
+
+    module ClassMethods
       def filtered(additional_filtering_params = {})
         cattr_accessor :filtering_keys
         cattr_accessor :custom_filters
 
-        # On normalize tout ca
-        additional_filtering_params = format_additional_param(additional_filtering_params, 'filtering')
-
-        # On recupere tous les filtres autorisés
-        allowed_keys = (filterable_fields_for(resource_model) + additional_filtering_params.keys)
+        filter = Filter.new(additional_filtering_params, resource_model)
 
-        # On fait une sorte de *register_bool_filter* sur tous les champs *_at
-        additional = (filterable_fields_for(resource_model) - [:created_at, :updated_at])
-                     .select { |e| e =~ /_at$/ }
-                     .select { |e| additional_filtering_params[e.to_s.gsub(/_at$/, '')].nil? }
-
-        additional.each do |fi|
-          name = fi.to_s.gsub(/_at$/, '')
-
-          if fi.to_sym == :begin_at
-            db_field = "#{resource_model.quoted_table_name}.\"#{fi}\""
-            additional_filtering_params[:future] = {
-              proc: -> (value) { value.first == 'true' ? where("#{db_field} >= ?", Time.zone.now) : where("#{db_field} < ?", Time.zone.now) },
-              all: %w(true false),
-              description: "Return only #{resource_model.to_s.underscore.humanize.downcase.pluralize} which begins in the future"
-            }
-            allowed_keys << :future
-          else
-            additional_filtering_params[name.to_sym] = {
-              proc: -> (value) { value.first == 'true' ? where.not(fi => nil) : where(fi => nil) },
-              all: %w(true false),
-              description: "Return only #{name} #{resource_model.to_s.underscore.humanize.downcase.pluralize}"
-            }
-            allowed_keys << name
-          end
-        end
+        filter.register_bools
 
         # On recupere le default
-        self.filtering_keys = allowed_keys
-        self.custom_filters = additional_filtering_params
+        self.filtering_keys = filter.allowed_keys
+        self.custom_filters = filter.params
 
-        has_scope :filter, type: :hash, only: [:index] do |_controller, scope, value|
-          params = parse_filtering_param(value, filtering_keys)
-          scope = apply_filter_to_collection(scope, params, custom_filters)
+        has_scope FILTER_PARAM, type: :hash, only: [:index] do |_controller, scope, value|
+          scope = filter.process(value, scope, custom_filters, filtering_keys)
           scope
         end
       end
@@ -61,11 +93,11 @@ module RiceCooker
       #
       # name: le nom du filtre custom (ex: with_mark)
       # proc: le filtre, prend un arg `val` qui est un tableau des args du filtre
-      # all: l'ensemble des valeurs acceptées pour le filtre. Laisser nil ou [] pour tout accepter
+      # all: l'ensemble des valeurs acceptées pour le filtre. Laisser nil ou pour tout accepter
       # description: La description dans la doc
       #
       def register_filter(name, proc, all = nil, description = nil)
-        raise "A '#{name}' filter already exists for class #{self.class}" unless custom_filters[name].nil?
+        raise "A '#{name}' filter already exists for class #{self.class}" unless filter_exists?(name)
         custom_filters[name] = {
           proc: proc,
           all: all || [],
@@ -82,14 +114,19 @@ module RiceCooker
       # description: La description dans la doc
       #
       def register_bool_filter(name, field, description = nil)
-        raise "A '#{name}' filter already exists for class #{self.class}" unless custom_filters[name].nil?
+        raise "A '#{name}' filter already exists for class #{self.class}" unless filter_exists?(name)
         custom_filters[name] = {
-          proc: -> (value) { value.first == 'true' ? where.not(field => nil) : where(field => nil) },
+          proc: Filter.get_named_lambda(field),
           all: %w(true false),
           description: description || "Return only #{resource_model.to_s.underscore.humanize.downcase.pluralize} with a #{field}"
         }
         filtering_keys << name
       end
+
+      # Check if the given custom filter name already exists
+      def filter_exists?(name)
+        !custom_filters[name].nil?
+      end
     end
   end
 end

data/lib/rice_cooker/search.rb

@@ -0,0 +1,51 @@
+require 'active_support'
+
+module RiceCooker
+  module Search
+    extend ActiveSupport::Concern
+
+    FILTER_PARAM = :search
+
+    module ClassMethods
+      include Helpers
+
+      def searched(additional_searching_params = {})
+        cattr_accessor :searching_keys
+        cattr_accessor :custom_searchs
+
+        # On normalize tout ca
+        additional_searching_params = format_additional_param(additional_searching_params, 'filtering')
+
+        # On recupere tous les filtres autorisés
+        allowed_keys = (searchable_fields_for(resource_model) + additional_searching_params.keys)
+
+        # On recupere le default
+        self.searching_keys = allowed_keys
+        self.custom_searchs = additional_searching_params
+
+        has_scope :search, type: :hash, only: [:index] do |_controller, scope, value|
+          params = parse_searching_param(value, searching_keys)
+          scope = apply_search_to_collection(scope, params, custom_searchs)
+          scope
+        end
+      end
+
+      # Ajoute un filtre custom
+      #
+      # name: le nom du filtre custom (ex: with_mark)
+      # proc: le filtre, prend un arg `val` qui est un tableau des args du filtre
+      # all: l'ensemble des valeurs acceptées pour le filtre. Laisser nil ou [] pour tout accepter
+      # description: La description dans la doc
+      #
+      def register_search(name, proc, all = nil, description = nil)
+        raise "A '#{name}' search already exists for class #{self.class}" unless custom_searchs[name].nil?
+        custom_searchs[name] = {
+          proc: proc,
+          all: all || [],
+          description: description || ''
+        }
+        searching_keys << name
+      end
+    end
+  end
+end

data/lib/rice_cooker/version.rb

@@ -1,3 +1,3 @@
 module RiceCooker
-  VERSION = '0.1.3'.freeze
+  VERSION = '0.1.4'.freeze
 end

data/lib/rice_cooker.rb

@@ -1,29 +1,32 @@
 require 'action_controller'
 
 module RiceCooker
-  autoload :Helpers,      'rice_cooker/helpers'
+  autoload :Helpers, 'rice_cooker/base/helpers'
+  autoload :Base, 'rice_cooker/base/base'
   autoload :ClassMethods, 'rice_cooker/class_methods'
-  autoload :Filter,       'rice_cooker/filter'
-  autoload :Sort,         'rice_cooker/sort'
-  autoload :Range,        'rice_cooker/range'
-  autoload :VERSION,      'rice_cooker/version'
-end
+  autoload :Filter, 'rice_cooker/filter'
+  autoload :Sort, 'rice_cooker/sort'
+  autoload :Range, 'rice_cooker/range'
+  autoload :Search, 'rice_cooker/search'
+  autoload :VERSION, 'rice_cooker/version'
 
-module ActionController
-  class Base
-    def self.rice_cooked(base)
-      base.class_eval do
-        include RiceCooker::Sort
-        include RiceCooker::Filter
-        include RiceCooker::Range
-        extend  RiceCooker::ClassMethods
+  def self.rice_cooked(base)
+    base.class_eval do
+      include RiceCooker::Sort
+      include RiceCooker::Filter
+      include RiceCooker::Range
+      include RiceCooker::Search
+      extend  RiceCooker::ClassMethods
 
-        class_attribute :resource_model, instance_writer: false
+      class_attribute :resource_model, instance_writer: false
 
-        protected :resource_model
-      end
+      protected :resource_model
     end
+  end
+end
 
-    rice_cooked(self)
+module ActionController
+  class Base
+    RiceCooker.rice_cooked(self)
   end
 end

data/spec/mocks/controllers/users_controller.rb

@@ -49,6 +49,7 @@ class UsersController < ActionController::Base
   sorted
   filtered
   ranged
+  searched
 
   def index
     @users = apply_scopes(User).all

data/spec/search/search_spec.rb

@@ -0,0 +1,267 @@
+require 'pry'
+require 'rice_cooker'
+require 'active_record'
+require 'spec_helper'
+
+RSpec.describe RiceCooker::Search do
+  include RiceCooker::Helpers
+
+  # class User < ActiveRecord::Base; end
+
+  before do
+    @collection_class = User
+    @allowed_params = searchable_fields_for(@collection_class)
+    @collection = @collection_class.all
+
+    @test_search = {
+      with_the_letter: { proc: -> (value) { where('first_name ILIKE ?', value.map { |e| "%#{e}%" }) } },
+      without_the_letter: { proc: -> (value) { where.not('first_name ILIKE ?', value.map { |e| "%#{e}%" }) } }
+    }
+
+    @proc = -> (value) { value }
+    @all = -> (_value) { [1, 2, 3] }
+  end
+
+  describe 'Search params must be okay' do
+    it 'Null searching' do
+      # Default null searching
+      searching_params = parse_searching_param('', @allowed_params)
+      expect(searching_params).to be_eql({})
+    end
+
+    it 'Default searching' do
+      params = {
+        login: 'aaubin'
+      }
+
+      searching_params = parse_searching_param(params, @allowed_params)
+      expect(searching_params).to be_eql(login: ['aaubin'])
+    end
+
+    it 'Double searching' do
+      params = {
+        login: 'aaubin,qbollach'
+      }
+
+      searching_params = parse_searching_param(params, @allowed_params)
+      expect(searching_params).to be_eql(login: %w(aaubin qbollach))
+    end
+
+    it 'Multiple searching' do
+      params = {
+        login: 'aaubin,qbollach,andre',
+        id: '74,75,76'
+      }
+
+      searching_params = parse_searching_param(params, @allowed_params)
+      expect(searching_params).to be_eql(login: %w(aaubin qbollach andre),
+                                         id: %w(74 75 76))
+    end
+
+    it 'invalid args' do
+      # invalid args
+
+      params = {
+        wtf: 'aaubin,qbollach,andre',
+        id: '74,75,76'
+      }
+
+      expect { parse_searching_param(params, @allowed_params) }.to raise_error(RiceCooker::InvalidSearchException)
+    end
+  end
+
+  describe 'Must apply search to given collection' do
+    it 'Default null searching' do
+      searched_collection = apply_search_to_collection(@collection, {})
+      # puts searched_collection.to_sql
+      expect(searched_collection.to_sql).to match(/^((?!WHERE).)*$/)
+    end
+
+    it 'Default searching' do
+      searched_collection = apply_search_to_collection(@collection, login: ['aaubin'])
+      # puts searched_collection.to_sql
+      expect(searched_collection.to_sql).to match(/WHERE/)
+      expect(searched_collection.to_sql).to match(/\"login\" LIKE '%aaubin%'/)
+    end
+
+    it 'Double searching' do
+      # Desc searching
+      searched_collection = apply_search_to_collection(@collection, login: %w(aaubin qbollach))
+      # puts searched_collection.to_sql
+      expect(searched_collection.to_sql).to match(/WHERE/)
+      expect(searched_collection.to_sql).to match(/\"login\" LIKE '%aaubin%'/)
+      expect(searched_collection.to_sql).to match(/\"login\" LIKE '%qbollach%'/)
+    end
+
+    it 'Multiple searching' do
+      # Desc searching
+      searched_collection = apply_search_to_collection(@collection, login: %w(aaubin qbollach andre),
+                                                                    id: %w('74' '75' '76'))
+      # puts searched_collection.to_sql
+      expect(searched_collection.to_sql).to match(/\"login\" LIKE '%aaubin%'/)
+      expect(searched_collection.to_sql).to match(/\"login\" LIKE '%qbollach%'/)
+      expect(searched_collection.to_sql).to match(/\) AND \(/)
+      # puts searched_collection.to_sql
+      expect(searched_collection.to_sql).to match(/\"id\" LIKE 0/)
+      expect(searched_collection.to_sql).to match(/\"id\" LIKE 0/)
+      expect(searched_collection.to_sql).to match(/\) AND \(/)
+    end
+  end
+
+  describe 'Must apply custom searchs to given collection' do
+    it 'Default null searching' do
+      searched_collection = apply_search_to_collection(@collection, {}, @test_search)
+      # puts searched_collection.to_sql
+      expect(searched_collection.to_sql).to match(/^((?!WHERE).)*$/)
+    end
+
+    it 'Default searching' do
+      searched_collection = apply_search_to_collection(@collection, { with_the_letter: ['a'] }, @test_search)
+      # puts searched_collection.to_sql
+      expect(searched_collection.to_sql).to match(/WHERE/)
+      expect(searched_collection.to_sql).to match(/ILIKE/)
+    end
+
+    it 'Double searching' do
+      # Desc searching
+      searched_collection = apply_search_to_collection(@collection, { with_the_letter: ['a'], without_the_letter: ['l'] }, @test_search)
+      # puts searched_collection.to_sql
+      expect(searched_collection.to_sql).to match(/WHERE/)
+      expect(searched_collection.to_sql).to match(/first_name ILIKE '%a%'/)
+      expect(searched_collection.to_sql).to match(/NOT \(first_name ILIKE '%l%'\)/)
+    end
+
+    # it 'invalid args' do
+    #   # invalid args
+    #   expect do
+    #     apply_search_to_collection(
+    #       @collection,
+    #       { sorted: %w(true baguette) },
+    #       format_additional_param(sorted: [-> (v) { v }, %w(true false maybe)])
+    #     )
+    #   end.to raise_error(RiceCooker::InvalidSearchValueException)
+    # end
+  end
+
+  describe 'Additional params must be correctly formated' do
+    it 'No additional params' do
+      formated = format_additional_param({})
+      expect(formated).to be_eql({})
+    end
+
+    it 'Already correctly formatted additional params' do
+      p = { search: {
+        proc: @proc,
+        all: [1, 2, 3],
+        description: 'A good search'
+      } }
+      formated = format_additional_param(p)
+      expect(formated).to be_eql(p)
+    end
+
+    it 'Missing description additional params' do
+      p = { search: {
+        proc: @proc,
+        all: [1, 2, 3]
+      } }
+      expected = { search: {
+        proc: @proc,
+        all: [1, 2, 3],
+        description: ''
+      } }
+      formated = format_additional_param(p)
+      expect(formated).to be_eql(expected)
+    end
+
+    it 'Only proc additional params' do
+      p = { search: @proc }
+      expected = { search: {
+        proc: @proc,
+        all: [],
+        description: ''
+      } }
+      formated = format_additional_param(p)
+      expect(formated).to be_eql(expected)
+    end
+
+    it 'Array with proc and all additional params' do
+      p = { search: [@proc, @all] }
+      expected = { search: {
+        proc: @proc,
+        all: @all,
+        description: ''
+      } }
+      formated = format_additional_param(p)
+      expect(formated).to be_eql(expected)
+    end
+
+    it 'Multiple, std + Array with proc and all additional params' do
+      p = {
+        tata: @proc,
+        toto: { proc: @proc, all: [1, 2] },
+        search: [@proc, @all],
+        tutu: { proc: @proc, description: 'Buuuuh' }
+      }
+      expected = {
+        tata: {
+          proc: @proc,
+          all: [],
+          description: ''
+        },
+        toto: {
+          proc: @proc,
+          all: [1, 2],
+          description: ''
+        },
+        search: {
+          proc: @proc,
+          all: @all,
+          description: ''
+        },
+        tutu: {
+          proc: @proc,
+          all: [],
+          description: 'Buuuuh'
+        }
+      }
+      formated = format_additional_param(p)
+      expect(formated).to be_eql(expected)
+    end
+  end
+end
+
+RSpec.describe UsersController, type: :controller do
+  include RiceCooker::Helpers
+
+  before { request.host = 'example.org' }
+
+  describe 'GET #index' do
+    it 'without search parameter' do
+      process :index, method: :get, params: { search: '', format: :json }
+      expect(response.body).to eq(User.all.order(id: :desc).to_json)
+    end
+
+    it 'with simple search parameter' do
+      process :index, method: :get, params: { search: { login: 'a' }, format: :json }
+      expect(response.body).to eq(User.where(User.arel_table[:login].matches("%a%")).order(id: :desc).to_json)
+    end
+
+    it 'with double search parameter' do
+      process :index, method: :get, params: { search: { login: 'a,q' }, format: :json }
+      expect(response.body).to eq(User.where(
+        User.arel_table[:login].matches("%a%").or(User.arel_table[:login].matches("%q%"))
+      ).order(id: :desc).to_json)
+    end
+
+    it 'with double and multiple search parameter' do
+      process :index, method: :get, params: { search: { login: 'a,q', email: 't' }, format: :json }
+      expect(response.body).to eq(
+        User.where(
+          User.arel_table[:login].matches("%a%").or(User.arel_table[:login].matches("%q%"))
+        ).where(
+          User.arel_table[:email].matches("%t%")
+        ).order(id: :desc).to_json
+      )
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rice_cooker
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Andre Aubin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-06 00:00:00.000000000 Z
+date: 2016-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -288,10 +288,12 @@ files:
 - README.md
 - Rakefile
 - lib/rice_cooker.rb
+- lib/rice_cooker/base/base.rb
+- lib/rice_cooker/base/helpers.rb
 - lib/rice_cooker/class_methods.rb
 - lib/rice_cooker/filter.rb
-- lib/rice_cooker/helpers.rb
 - lib/rice_cooker/range.rb
+- lib/rice_cooker/search.rb
 - lib/rice_cooker/sort.rb
 - lib/rice_cooker/version.rb
 - lib/tasks/rice_cooker_tasks.rake
@@ -302,6 +304,7 @@ files:
 - spec/mocks/mocks.rb
 - spec/mocks/models/user.rb
 - spec/range/range_spec.rb
+- spec/search/search_spec.rb
 - spec/sort/sort_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/lambda2/rice_cooker
@@ -335,5 +338,6 @@ test_files:
 - spec/mocks/mocks.rb
 - spec/mocks/models/user.rb
 - spec/range/range_spec.rb
+- spec/search/search_spec.rb
 - spec/sort/sort_spec.rb
 - spec/spec_helper.rb