toqua 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43a5f057196fff4c8cd5b4b182eae2e1f53ea7b7
+  data.tar.gz: db0835906e1e11b74eec8dda63519326684be04a
+SHA512:
+  metadata.gz: a2beeb545bf067166984712a900ecbce55e4ece2828bb844b4aab65f27950990856d4f87e53737522613f0ae1ef2f6d6155ac9868a7662ee9e219071f5784e53
+  data.tar.gz: bd3b513750b11822c272e037be436126f9c9a209a2fd7821680fb3ce7d138c22b71aefca3253c6e8674a22d018fcdae5aec66e7a30d864c7e42a3fa22355e9a0

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+log/*

data/.travis.yml

@@ -0,0 +1,9 @@
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.1.8
+  - 2.2.4
+  - 2.3.0
+  - 2.4.0
+before_install: gem install bundler -v 1.15.4

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in toqua.gemspec
+gemspec

data/README.md

@@ -0,0 +1,304 @@
+# Toqua
+
+[![Build Status](https://travis-ci.org/rogercampos/toqua.svg?branch=master)](https://travis-ci.org/rogercampos/toqua)
+
+Collection of controller utilities for rails applications. Created with the intention of bringing back most of the nice things
+about inherited resources, but in a more simple and explicit way.  
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'toqua'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install toqua
+
+## Usage
+
+This library contain different tools that can be used independently, described below.
+
+### Transform params
+
+Use this to change the value of a `params` key, for example:
+
+```ruby
+class MyController < ApplicationController
+  include Toqua::TransformParams
+  transform_params(:q) { |v| JSON.parse(v) }
+end
+```
+
+This would transform the value of `params[:q]` from a raw string into its json representation. The new value is whatever returns your block. Also works on nested keys:
+
+`transform_params(user: :q) {|v| DataManipulation.change(v) }`
+
+Or more levels of nesting:
+
+`transform_params(user: {data: :q}) {|v| DataManipulation.change(v) }`
+
+
+### Scoping
+
+This allows you to further refine an `ActiveRecord::Relation`, optionally depending on conditionals. For example:
+
+
+```ruby
+class MyController < ApplicationController
+  include Toqua::Scoping
+  
+  scope {|s| s.where(parent_id: params[:parent_id])}
+  
+  def index
+    @elements = apply_scopes(Element)
+  end
+end
+``` 
+
+The `scope` definitions are lambdas that receive an `ActiveRecord::Relation` as parameter and must return another
+`AR::Relation`. They are chained in the order they're defined. To use them, you explicitly call `apply_scopes` with the initial
+argument.
+
+You can use `:if` or `:unless` to conditionally choose if execute the scope or not. Examples:
+
+`scope(if: :show_all?) { |s| s.includes(:a, :b) }`
+
+This will call the method `show_all?` defined in the controller and their return value (truthy or falsey) will indicate if the scope
+applies or not. You can also use anything that responds to `:call` directly, ex:
+
+`scope(if: -> { false }) { |s| s.all }`
+
+Finally, you can also condition the scope execution based on the action on the controller:
+
+`scope(only: :index) { |s| s.includes(:a, :b) }` 
+
+This is the foundation used to build searching, sorting and pagination over an `AR::Relation`.
+
+Used as an independent tool, it provides a way to define scopes used by multiple actions in the same place (authorization, eager loading, etc.).
+
+
+### Pagination
+
+This tool can be used to paginate collections using [Kaminari](https://github.com/kaminari/kaminari), providing some additional useful things. Example of basic usage:
+
+```ruby
+class MyController < ApplicationController
+  include Toqua::Pagination
+  
+  paginate
+  
+  def index
+    @elements = apply_scopes(Element)
+  end
+end
+```
+
+As the `paginate` method uses scoping, you can pass the options of `:if, :unless and :action` that will get forwarded to the `scope` method, allowing
+you to conditionally decide when to paginate. Ex:
+
+`paginate(only: :index)`
+
+Or, to paginate only on html but not xlsx format:
+
+`paginate(unless: :xlsx?)`
+
+The names of the url parameters used to identify the current page and the number of results per page are `page` and `per_page` by default, but can be changed using:
+
+`paginate(page_key: "page", per_page_key: "per_page")`
+
+The number of results in each page can be controlled with the `:per` option:
+
+`paginate(per: 100)`
+
+The last option available is `:headers`. If used, 3 additional headers will be attached into the response allowing you to know info about the pagination of the collection. This is useful for API clients. Ex:
+
+`paginate(headers: true)`
+
+The response will include the following headers:
+
+- 'X-Pagination-Total': Total number of elements in the collection without pagination
+- 'X-Pagination-Per-Page': Number of elements per page
+- 'X-Pagination-Page': Number of the current page
+
+Finally, the method `paginated?` available in both the controller and the views will tell you if the collection has been paginated or not.
+ 
+
+### Search
+
+Small utility to help in the implementation of searching, using [Doure](https://github.com/rogercampos/doure) as a way to filter an AR model. Given that you have a model with filters defined, ex:
+
+```ruby
+class Post < ApplicationRecord
+  extend Doure::Filterable
+  filter_class PostFilter
+end
+
+class PostFilter
+  cont_filter(:title)
+  cont_filter(:slug)
+  present_filter(:scheduled_at)
+  eq_filter(:id)
+  filter(:category_id_eq) { |s, value| s.joins(:post_categories).where(post_categories: {category_id: value}) }
+end
+```
+
+You can setup searching in the controller using:
+
+ 
+```ruby
+class PostsController < ApplicationController
+  include Toqua::Search
+  
+  searchable
+  
+  def index
+    @elements = apply_scopes(Post)
+  end
+end
+```
+
+The parameter used to represent the search criteria is `:q`. 
+
+The method `search_params` will give you a hash representing the contents of `:q`, which is the current search criteria, for example:
+
+`{title_cont: "Air", category_id_eq: "12", slug_cont: "", scheduled_at_present: "", id_eq: ""}`
+
+The method `active_search_params` will give you only the search parameters containing some value:
+
+`{title_cont: "Air", category_id_eq: "12"}`
+
+The method `search_object`, available in the view, gives an `ActiveModel` like object stuffed with the current `search_params`, so you can use that as the object 
+of the search form to automatically pre-fill all the search inputs with their current value. Ex:
+
+```slim
+= form_for search_object do |f|
+  = f.input :title_cont
+  = f.input :category_id_eq, collection: ...
+``` 
+
+The method `searching?` will tell you if there's a current search or not.
+
+Finally, you can define a `default_search_params` method in the controller to setup default search criteria:
+
+```ruby
+def default_search_params
+  { visible_by_role: "editor" }
+end
+```
+
+
+
+### Sorting
+
+The sorting utility allows you to sort the collection, using the parameter `s` in the url with a format like `title+asc` or `title+desc`. Usage example:
+
+```ruby
+class PostsController < ApplicationController
+  include Toqua::Sorting
+  
+  sorting
+  
+  def index
+    @elements = apply_scopes(Post)
+  end
+end
+```
+
+A helper to create sorting links easily is not directly provided by the gem, but can be something like this:
+ 
+```ruby
+  def sort_link(name, label = nil, opts = {})
+    label ||= name.to_s.humanize
+    current_attr_name, current_direction = params[:s].present? && params[:s].split("+").map(&:strip)
+
+    next_direction = opts.fetch(:default_order, current_direction == "asc" ? "desc" : "asc")
+
+    parameters = request.query_parameters
+    parameters.merge!(opts[:link_params]) if opts[:link_params]
+
+    dest_url = url_for(parameters.merge(s: "#{name}+#{next_direction}"))
+    direction_icon = current_direction == "asc" ? "↑" : "↓"
+    anchor = current_attr_name == name.to_s ? "#{label} #{direction_icon}" : label
+
+    link_opts = opts.fetch(:link_opts, {})
+
+    link_to(anchor, dest_url, link_opts)
+  end
+```
+
+Then used as:
+
+`= sort_link :title, "Title"`
+
+### Keyset pagination
+
+The keyset pagination is similar to the pagination utility, but working with [OrderQuery](https://github.com/glebm/order_query) to provide pagination that works with no offsets. Example usage:
+
+```ruby
+class PostsController < ApplicationController
+  include Toqua::KeysetPagination
+  
+  keyset_paginate :score_order
+  
+  def index
+    @elements = apply_scopes(Post)
+  end
+end
+```
+
+It takes care of applying the correct scoping based on the id of the current element, as identified by the `:idx` parameter as default. With the optional `:headers` parameter some headers are also added into the response:
+
+`keyset_paginate :score_order, headers: true`
+
+Will generate those headers:
+
+- `'X-KeysetPagination-Index'`: The `id` of the current element index.
+- `'X-KeysetPagination-Next-Index'`: The `id` of the element to use as the next page.
+- `'X-KeysetPagination-Prev-Index'`: The `id` of the element to use as the previous page.
+
+The next and prev indexes are also available via the instance vars `@keyset_pagination_prev_index` and `@keyset_pagination_next_index`. 
+
+If the value of `@keyset_pagination_prev_index` (or via header) is `-1` it means the previous page is the initial one. If it's `nil`, there's no previous page.
+
+To generate pagination links, you can use something like this: 
+
+```ruby
+  def keyset_pagination_next_link(index_key = :idx)
+    if @keyset_pagination_next_index
+      url_for(request.GET.merge(index_key => @keyset_pagination_next_index))
+    end
+  end
+
+  def keyset_pagination_prev_link(index_key = :idx)
+    if @keyset_pagination_prev_index
+      if @keyset_pagination_prev_index == -1
+        url_for(request.GET.merge(index_key => nil))
+      else
+        url_for(request.GET.merge(index_key => @keyset_pagination_prev_index))
+      end
+    end
+  end
+```
+
+### Final notes
+
+If you use multiple scope declarations either mixed with the other utilities shown here or not, be aware of the order. For example, pagination must
+always go last.  
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/toqua.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "toqua"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/toqua/keyset_pagination.rb

@@ -0,0 +1,63 @@
+module Toqua
+  module KeysetPagination
+    extend ActiveSupport::Concern
+    include Scoping
+
+    DEFAULT_INDEX_KEY = :idx
+    DEFAULT_PER_PAGE = 30
+
+    included do
+      helper_method :paginated?
+    end
+
+    def paginated?
+      @paginated
+    end
+
+    class_methods do
+      def keyset_paginate(order_query_name, opts = {})
+        opts.assert_valid_keys(:per, :index_key, :headers)
+        per = opts.fetch(:per, DEFAULT_PER_PAGE)
+        index_key = opts.fetch(:index_key, DEFAULT_INDEX_KEY)
+
+        scope do |scope|
+          idx = params[index_key].presence
+
+          if idx
+            current_object = scope.model.find_by(id: idx)
+          end
+
+          current_object ||= scope.send(order_query_name).first
+
+          if current_object # Only in case there are no objects to paginate
+            @paginated = true
+
+            point = scope.model.send("#{order_query_name}_at", current_object)
+
+            two_previous_points = point.before.merge(scope.except(:order, :preload, :eager_load)).offset(per - 1).limit(2).to_a
+
+            if two_previous_points.empty?
+              @keyset_pagination_prev_index = nil
+            elsif two_previous_points.size == 1
+              @keyset_pagination_prev_index = -1
+            else
+              @keyset_pagination_prev_index = two_previous_points.first.id
+            end
+
+            @keyset_pagination_next_index = point.after.merge(scope.except(:order, :preload, :eager_load)).offset(per - 1).first.try(:id)
+
+            if opts[:headers]
+              headers['X-KeysetPagination-Index'] = current_object.id
+              headers['X-KeysetPagination-Next-Index'] = @keyset_pagination_next_index
+              headers['X-KeysetPagination-Prev-Index'] = @keyset_pagination_prev_index
+            end
+
+            scope.except(:order).merge(point.after(false).limit(per)).send(order_query_name)
+          else
+            scope
+          end
+        end
+      end
+    end
+  end
+end

data/lib/toqua/pagination.rb

@@ -0,0 +1,44 @@
+module Toqua
+  module Pagination
+    extend ActiveSupport::Concern
+    include Scoping
+
+    DEFAULT_PAGE = 1
+    DEFAULT_PAGE_KEY = :page
+    DEFAULT_PER_PAGE = 30
+    DEFAULT_PER_PAGE_KEY = :per_page
+
+    included do
+      helper_method :paginated?
+    end
+
+    def paginated?
+      @paginated
+    end
+
+    class_methods do
+      def paginate(opts = {})
+        page_key = opts.fetch(:page_key, DEFAULT_PAGE_KEY)
+        per_page_key = opts.fetch(:per_page_key, DEFAULT_PER_PAGE_KEY)
+
+        scope_opts = opts.slice(:if, :unless, :only)
+
+        scope(scope_opts) do |scope|
+          @paginated = true
+
+          @page = params.fetch(page_key, opts.fetch(:page, DEFAULT_PAGE))
+          per = params.fetch(per_page_key, opts.fetch(:per, DEFAULT_PER_PAGE))
+
+          if opts[:headers]
+            scope_count = scope.count
+            headers['X-Pagination-Total'] = scope_count.is_a?(Hash) ? scope_count.keys.count.to_s : scope_count.to_s
+            headers['X-Pagination-Per-Page'] = per.to_s
+            headers['X-Pagination-Page'] = @page.to_s
+          end
+
+          per == '0' ? scope : scope.page(@page).per(per)
+        end
+      end
+    end
+  end
+end

data/lib/toqua/scoping.rb

@@ -0,0 +1,46 @@
+module Toqua
+  module Scoping
+    extend ActiveSupport::Concern
+
+    def apply_scopes(start)
+      s = start
+      self.class.__scopes.each do |scope, opts|
+        s = __run_scope(s, scope, opts)
+      end
+      s
+    end
+
+    def __run_scope(relation, scope, opts)
+      if_condition = if opts[:if]
+                       opts[:if].respond_to?(:call) ? !!instance_exec(&opts[:if]) : send(opts[:if])
+                     elsif opts[:unless]
+                       opts[:unless].respond_to?(:call) ? !instance_exec(&opts[:unless]) : !send(opts[:unless])
+                     else
+                       true
+                     end
+
+      action_condition = if opts[:only]
+                           [opts[:only]].flatten.include?(action_name.to_sym)
+                         else
+                           true
+                         end
+
+      if if_condition && action_condition
+        self.instance_exec(relation, &scope)
+      else
+        relation
+      end
+    end
+
+    included do
+      class_attribute(:__scopes)
+      self.__scopes = []
+    end
+
+    class_methods do
+      def scope(opts = {}, &block)
+        self.__scopes += [[block, opts]]
+      end
+    end
+  end
+end

data/lib/toqua/search.rb

@@ -0,0 +1,45 @@
+module Toqua
+  module Search
+    extend ActiveSupport::Concern
+    include Scoping
+
+    included do
+      helper_method :search_params, :searching?, :search_object, :active_search_params
+    end
+
+    def search_params
+      params[:q].permit!
+      (params[:q] || {}).to_h.reverse_merge(default_search_params)
+    end
+
+    def active_search_params
+      search_params.select { |_, b| !b.nil? && b != "" }.to_h
+    end
+
+    def search_object
+      @search_object ||= begin
+        Class.new(Hashie::Mash) do
+          extend ActiveModel::Naming
+
+          def self.model_name
+            ActiveModel::Name.new(Class, nil, "q")
+          end
+        end.new(search_params)
+      end
+    end
+
+    def searching?
+      params.key?(:q)
+    end
+
+    def default_search_params
+      {}
+    end
+
+    class_methods do
+      def searchable
+        scope { |s| s.filter(search_params) }
+      end
+    end
+  end
+end

data/lib/toqua/sorting.rb

@@ -0,0 +1,25 @@
+module Toqua
+  module Sorting
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def sorting(opts = {})
+        reorder = opts.fetch(:reorder, true)
+
+        scope do |s|
+          if params[:s].present?
+            attr_name, direction = params[:s].to_s.split("+").map(&:strip)
+            raise "You must provide an attribute to sort by" unless attr_name
+            raise "You must provide a direction" unless direction
+            direction.downcase!
+            raise "Direction must be ASC or DESC" unless ["asc", "desc"].include?(direction)
+
+            s.send(reorder ? :reorder : :order, s.arel_table[attr_name].send(direction))
+          else
+            s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/toqua/transform_params.rb

@@ -0,0 +1,38 @@
+module Toqua
+  module TransformParams
+    extend ActiveSupport::Concern
+
+    class ParameterConverter
+      def parse(params, hash, block)
+        if Hash === hash
+          key = hash.keys.first
+
+          if params.key?(key)
+            parse(params[key], hash[key], block)
+          end
+        else
+          if params.key?(hash)
+            params[hash] = block.call(params[hash])
+          end
+        end
+      end
+    end
+
+    included do
+      class_attribute(:__transform_params)
+      self.__transform_params = []
+
+      prepend_before_action do
+        self.class.__transform_params.each do |hash, block|
+          ParameterConverter.new.parse(params, hash, block)
+        end
+      end
+    end
+
+    class_methods do
+      def transform_params(hash, &block)
+        self.__transform_params += [[hash, block]]
+      end
+    end
+  end
+end

data/lib/toqua/version.rb

@@ -0,0 +1,3 @@
+module Toqua
+  VERSION = "0.1.0"
+end

data/lib/toqua.rb

@@ -0,0 +1,15 @@
+require "toqua/version"
+
+require 'active_support/all'
+
+require 'toqua/scoping'
+require 'toqua/pagination'
+require 'toqua/search'
+require 'toqua/sorting'
+require 'toqua/transform_params'
+require 'toqua/keyset_pagination'
+
+
+module Toqua
+  # Your code goes here...
+end

data/toqua.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "toqua/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "toqua"
+  spec.version       = Toqua::VERSION
+  spec.authors       = ["Roger Campos"]
+  spec.email         = ["roger@rogercampos.com"]
+
+  spec.summary       = %q{Collection of small utilities for controllers in rails applications}
+  spec.description   = %q{Collection of small utilities for controllers in rails applications}
+  spec.homepage      = "https://github.com/rogercampos/toqua"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", ">= 4.0.0"
+  spec.add_dependency "actionpack", ">= 4.0.0"
+  spec.add_dependency "activerecord", ">= 4.0.0"
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-rails"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "order_query", ">= 0.3.4"
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: toqua
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Roger Campos
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-08-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: order_query
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+description: Collection of small utilities for controllers in rails applications
+email:
+- roger@rogercampos.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/toqua.rb
+- lib/toqua/keyset_pagination.rb
+- lib/toqua/pagination.rb
+- lib/toqua/scoping.rb
+- lib/toqua/search.rb
+- lib/toqua/sorting.rb
+- lib/toqua/transform_params.rb
+- lib/toqua/version.rb
+- toqua.gemspec
+homepage: https://github.com/rogercampos/toqua
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Collection of small utilities for controllers in rails applications
+test_files: []