mincer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8e653063bab2730285042586172b1542c9049bb3
+  data.tar.gz: ca4b849d4f77baa0bda11828ac41cc24fae54569
+SHA512:
+  metadata.gz: f08dfbf9d5b4a37b0232421a2265fa6759e837827847ed3ab9aa552dc902d695a5c9a2ea98aae97c01a3719d557ac33e3489f03c40cbc244b61cdce03c53c376
+  data.tar.gz: c144b4b21d23414def052b9b904187246d3d134d13ce0242f2507ff6a581eac2a8a97a34422f03cff4b5b122bc53e569b999d4ac1f47f35dcfa03733fdd2b0f2

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea
+Guardfile
+atlassian-ide-plugin.xml
+.rspec
+spec/database.yml

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mincer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Alex Krasinsky
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# Mincer
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mincer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mincer
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+Copyright (c) 2013-2014 Alex Krasynskyi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/mincer.rb

@@ -0,0 +1,60 @@
+require 'mincer/version'
+
+
+require 'mincer/base'
+
+module Mincer
+  def self.processors
+    @processors ||= []
+  end
+
+  def self.postgres?
+    self.connection.is_a?(::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) rescue false
+  end
+
+  def self.connection
+    ::ActiveRecord::Base.connection()
+  end
+end
+
+
+# Loading processors
+require 'mincer/processors/sort'
+require 'mincer/processors/paginate'
+require 'mincer/processors/search'
+require 'mincer/processors/cache_digest'
+require 'mincer/processors/pg_json_dumper'
+::Mincer::Processors.constants.each do |k|
+  klass = ::Mincer::Processors.const_get(k)
+  if klass.is_a?(Class)
+    ::Mincer.processors << klass
+  elsif klass.is_a?(Module)
+    ::Mincer::Base.send(:include, klass)
+  end
+end
+
+
+# Loading ActionView helpers
+if defined?(ActionView)
+  require 'mincer/action_view/sort_helper'
+  ::Mincer::ActionView.constants.each do |k|
+    klass = ::Mincer::ActionView.const_get(k)
+    ActionView::Base.send(:include, klass) if klass.is_a?(Module)
+  end
+end
+
+
+#if defined?(::Rails)
+#  module Mincer
+#    class Railtie < ::Rails::Railtie
+#      initializer 'mincer.setup_paths' do
+#      end
+#
+#      initializer 'carrierwave.active_record' do
+#        #ActiveSupport.on_load :active_record do
+#        #  require 'carrierwave/orm/activerecord'
+#        #end
+#      end
+#    end
+#  end
+#end

data/lib/mincer/action_view/sort_helper.rb

@@ -0,0 +1,41 @@
+module Mincer
+  module ActionView
+    module SortHelper
+      # Returns sorting URL for collection and attribute
+      #
+      # <tt>collection</tt> - instance of QueryObject
+      # <tt>attribute</tt> - Attribute that will be used to sort table
+      def sort_url_for(collection, attribute)
+        url_for(params.merge(:sort => attribute, :order => opposite_order_for(collection, attribute)))
+      end
+
+      def opposite_order_for(collection, attribute)
+        return nil unless collection.sort_attribute == attribute.to_s
+        if collection.sort_order.to_s.upcase == 'ASC'
+          'DESC'
+        elsif collection.sort_order.to_s.upcase == 'DESC'
+          'ASC'
+        else
+          'ASC'
+        end
+      end
+
+
+      # Returns chevron class, if attribute is the one that was used for sorting
+      #
+      # <tt>collection</tt> - instance of QueryObject
+      # <tt>attribute</tt> - Attribute that will be used to sort table
+      def sort_class_for(collection, attribute)
+        return nil unless collection.sort_attribute == attribute.to_s
+        if collection.sort_order.upcase == 'ASC'
+          'sorted order_down'
+        elsif collection.sort_order.upcase == 'DESC'
+          'sorted order_up'
+        else
+          ''
+        end
+      end
+
+    end
+  end
+end

data/lib/mincer/base.rb

@@ -0,0 +1,48 @@
+# This should be extracted and moved to gem
+module Mincer
+  class Base
+    include Enumerable
+
+    attr_accessor :args, :sql, :relation
+
+    # Builds query object
+    def initialize(scope, args = {})
+      @scope, @args, @relation = scope, args, build_query(scope, args)
+      execute_processors
+    end
+
+    def execute_processors
+      self.class.active_processors.each {|processor| @relation = processor.new(self).apply }
+    end
+
+    def self.active_processors
+      @processors ||= Mincer.processors.clone
+    end
+
+    # Grabs relation raw sql
+    def sql
+      @sql ||= @relation.connection.unprepared_statement { @relation.to_sql }
+    end
+
+    # Allows enumerable methods to be called directly on object
+    def each(&block)
+      @collection ||= if @relation.is_a?(ActiveRecord::Relation)
+                        @relation.to_a
+                      else
+                        @relation.all
+                      end
+      @collection.each(&block)
+    end
+
+    # Must be implemented in any subclass
+    def build_query(relation, args)
+      relation
+    end
+
+    # Pass methods to relation object
+    def method_missing(method_id, *params)
+      @relation.send(method_id, *params)
+    end
+
+  end
+end

data/lib/mincer/processors/cache_digest.rb

@@ -0,0 +1,50 @@
+module Mincer
+  module Processors
+    class CacheDigest
+
+      def initialize(mincer)
+        @mincer, @args, @relation = mincer, mincer.args, mincer.relation
+      end
+
+      def apply
+        @relation
+      end
+
+      def digest
+        Mincer.connection.execute(digest_sql).first.values.first
+      end
+
+      private
+
+      def digest_sql
+        <<-SQL
+          SELECT digest(#{digest_columns_as_sql}, 'md5') as digest
+          FROM (#{@relation.connection.unprepared_statement { @relation.to_sql }}) as digest_q
+        SQL
+      end
+
+      def digest_columns_as_sql
+        @mincer.class.digest_columns.map { |column| "string_agg(digest_q.#{column}::text, '')" }.join(' || ')
+      end
+
+    end
+
+    module CacheDigestOptions
+      extend ActiveSupport::Concern
+
+      def digest
+        CacheDigest.new(self).digest
+      end
+
+      module ClassMethods
+        def digest!(*digest_columns)
+          @digest_columns = digest_columns
+        end
+
+        def digest_columns
+          @digest_columns || []
+        end
+      end
+    end
+  end
+end

data/lib/mincer/processors/paginate.rb

@@ -0,0 +1,41 @@
+module Mincer
+  module Processors
+
+    class Paginate
+      def initialize(mincer)
+        @mincer, @args, @relation = mincer, mincer.args, mincer.relation
+      end
+
+      def apply
+        if kaminari?
+          @relation.page(@args['page']).per(@args['per_page'])
+        elsif will_paginate?
+          @relation.paginate(page: @args['page'], per_page: @args['per_page'])
+        else
+          warn 'To enable pagination please add kaminari or will_paginate to your Gemfile'
+          @relation
+        end
+      end
+
+      #private
+
+      def kaminari?
+        defined?(::Kaminari)
+      end
+
+      def will_paginate?
+        defined?(::WillPaginate)
+      end
+    end
+
+    module PaginatorOptions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def skip_pagination!
+          active_processors.delete(Mincer::Processors::Paginate)
+        end
+      end
+    end
+  end
+end

data/lib/mincer/processors/pg_json_dumper.rb

@@ -0,0 +1,51 @@
+module Mincer
+  module Processors
+    class PgJsonDumper
+
+      def initialize(mincer, options = {})
+        @mincer, @args, @relation, @options = mincer, mincer.args, mincer.relation, options
+      end
+
+      def apply
+        @relation
+      end
+
+      def to_json
+        if dump_supported?
+          Mincer.connection.execute(@options[:root] ? query_with_root(@options[:root]) : query).first['json']
+        else
+          warn 'To dump data to json with postgres you need to use postgres server version >= 9.2'
+        end
+      end
+
+      private
+
+      def dump_supported?
+        Mincer.postgres? && (Mincer.connection.send(:postgresql_version) >= 90200)
+      end
+
+      def query(root = 'json')
+        <<-SQL
+          SELECT COALESCE(array_to_json(array_agg(row_to_json(subq))), '[]') AS #{root}
+          FROM (#{@mincer.sql}) as subq
+        SQL
+      end
+
+      def query_with_root(root)
+        <<-SQL
+          SELECT row_to_json(t) as json FROM ( #{query(root)} ) as t
+        SQL
+      end
+
+    end
+
+    module PgJsonDumperOptions
+      extend ActiveSupport::Concern
+
+      def to_json(options = {})
+        PgJsonDumper.new(self, options).to_json
+      end
+    end
+
+  end
+end

data/lib/mincer/processors/search.rb

@@ -0,0 +1,34 @@
+module Mincer
+  module Processors
+    class Search
+      def initialize(mincer)
+        @mincer, @args, @relation = mincer, mincer.args, mincer.relation
+      end
+
+      def apply
+        if Mincer.postgres? && !textacular?
+          warn 'You must include "textacular" to  your Gemfile to use search'
+          @relation
+        elsif Mincer.postgres? && @args['pattern']
+          @relation.basic_search(@args['pattern']).presence || @relation.fuzzy_search(@args['pattern'])
+        else
+          @relation
+        end
+      end
+
+      def textacular?
+        defined?(::Textacular)
+      end
+    end
+
+    module SearchOptions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def skip_search!
+          active_processors.delete(Mincer::Processors::Search)
+        end
+      end
+    end
+  end
+end

data/lib/mincer/processors/sort.rb

@@ -0,0 +1,55 @@
+module Mincer
+  module Processors
+
+    class Sort
+      def initialize(mincer)
+        @mincer, @args, @relation = mincer, mincer.args, mincer.relation
+      end
+
+      def apply
+        relation = @relation.order("#{sort_attr} #{order_attr}")
+        @mincer.sort_attribute, @mincer.sort_order = relation.try(:order_values).try(:first).try(:split)
+        relation
+      end
+
+      def sort_attr
+        (@mincer.allowed_sort_attributes.include?(@args['sort']) && @args['sort']) || @mincer.default_sort_attribute
+      end
+
+      def order_attr
+        (%w{ASC DESC}.include?(@args['order']) && @args['order']) || @mincer.default_sort_order
+      end
+    end
+
+
+    module SortOptions
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :sort_attribute, :sort_order
+      end
+
+      module ClassMethods
+        def skip_sorting!
+          active_processors.delete(Mincer::Processors::Sort)
+        end
+      end
+
+      # Default sort attribute. You must override this method if you want something else
+      def default_sort_attribute
+        'id'
+      end
+
+      # Default order attribute. You must override this method if you want something else
+      def default_sort_order
+        'ASC'
+      end
+
+      # Allowed sort attributes, should return array of strings
+      def allowed_sort_attributes
+        @scope.attribute_names
+      end
+    end
+
+  end
+end

data/lib/mincer/version.rb

@@ -0,0 +1,18 @@
+module Mincer
+
+  def self.version
+    Gem::Version.new '0.0.1'
+  end
+
+  module VERSION #:nodoc:
+    MAJOR, MINOR, TINY, PRE = Mincer.version.segments
+    STRING = Mincer.version.to_s
+  end
+end
+
+
+
+
+
+
+

data/mincer.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mincer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mincer'
+  spec.version       = Mincer.version
+  spec.authors       = ['Alex Krasinsky']
+  spec.email         = ['lyoshakr@gmail.com']
+  spec.description   = %q{Add pagination, cache_digest, order, json generation with postgres, simple search support to all your queries}
+  spec.summary       = %q{ActiveRecord::Relation wrapper for pagination, order, json, search, cache_digest support}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord', '>= 4.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'pg'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'kaminari'
+  spec.add_development_dependency 'will_paginate'
+  spec.add_development_dependency 'textacular'
+  spec.add_development_dependency 'simplecov'
+end

data/spec/database.yml.example

@@ -0,0 +1,5 @@
+database: mincer
+username: <%= ENV[ 'USER' ] %>
+pool: 5
+timeout: 5000
+adapter: postgresql

data/spec/lib/processors/cache_digest_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe ::Mincer::Processors::CacheDigest do
+  context 'when postgres used' do
+    before do
+      config = YAML.load_file File.expand_path(File.dirname(__FILE__) + '../../../database.yml')
+      ActiveRecord::Base.establish_connection config.merge(:adapter => :postgresql)
+      ActiveRecord::Base.connection.execute('DROP TABLE IF EXISTS active_record_models')
+      ActiveRecord::Base.connection.execute('CREATE TABLE IF NOT EXISTS active_record_models (id SERIAL PRIMARY KEY, text TEXT)')
+      class ActiveRecordModel < ActiveRecord::Base
+      end
+      ActiveRecordModel.create!(text: 'Test1')
+      ActiveRecordModel.create!(text: 'Test2')
+    end
+
+    describe 'digesting any basic model without any Mincer::Base configuration' do
+      subject(:model) do
+        Class.new(Mincer::Base) do
+          digest! 'text'
+        end
+      end
+
+      it 'dumps data via postgres' do
+        query = subject.new(ActiveRecordModel)
+        digest = query.digest
+        digest.should be_a(String)
+        digest.should == '\xe2ffe3413a3d5ee8752a89c0e7a37270'
+      end
+    end
+  end
+
+
+  context 'when postgres used' do
+
+  end
+
+end

data/spec/lib/processors/paginate_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe ::Mincer::Processors::Paginate do
+  before do
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+    ActiveRecord::Base.connection.execute('CREATE TABLE active_record_models (id INTEGER UNIQUE, text STRING)')
+    class ActiveRecordModel < ActiveRecord::Base
+    end
+    30.times { |i| ActiveRecordModel.create(text: i) }
+  end
+
+  context 'when Kaminari is used for pagination' do
+    describe 'paginating with basic model without any Mincer::Base configuration' do
+      subject(:model) do
+        Class.new(Mincer::Base)
+      end
+
+      it 'paginates by with provided page and per_page in args' do
+        query = subject.new(ActiveRecordModel, { 'page' => '2', 'per_page' => '20' })
+        query.to_a.count.should eq(10)
+      end
+
+      it 'paginates by default page(1) and per_page(10) when nothing passed to args' do
+        query = subject.new(ActiveRecordModel)
+        query.to_a.count.should eq(25)
+      end
+    end
+
+
+    describe 'paginating when basic model has disabled pagination' do
+      it 'returns all items' do
+        subject = Class.new(Mincer::Base) do
+          skip_pagination!
+        end
+        query = subject.new(ActiveRecordModel)
+        query.to_a.count.should eq(30)
+      end
+    end
+  end
+
+  context 'when WillPaginate is used for pagination' do
+    before do
+      pending 'Need to fix test, need to unload Kaminari to test this'
+      #::Mincer::Processors::Paginator.any_instance.stub(:kaminari?).and_return(false)
+      #require 'will_paginate'
+      #require 'will_paginate/active_record'
+    end
+
+    describe 'paginating with basic model without any Mincer::Base configuration' do
+      subject(:model) do
+        Class.new(Mincer::Base)
+      end
+
+      it 'paginates by with provided page and per_page in args' do
+        query = subject.new(ActiveRecordModel, { 'page' => '2', 'per_page' => '20' })
+        query.to_a.count.should eq(10)
+      end
+
+      it 'paginates by default page(1) and per_page(10) when nothing passed to args' do
+        query = subject.new(ActiveRecordModel)
+        query.to_a.count.should eq(25)
+      end
+    end
+
+
+    describe 'paginating when basic model has disabled pagination' do
+      it 'returns all items' do
+        subject = Class.new(Mincer::Base) do
+          skip_pagination!
+        end
+        query = subject.new(ActiveRecordModel)
+        query.to_a.count.should eq(30)
+      end
+    end
+  end
+
+  context 'when there is no gem for pagination in loaded' do
+    it 'returns all items' do
+      subject = Class.new(Mincer::Base)
+      ::Mincer::Processors::Paginate.any_instance.stub(:kaminari?).and_return(false)
+      ::Mincer::Processors::Paginate.any_instance.stub(:will_paginate?).and_return(false)
+
+      query = subject.new(ActiveRecordModel)
+      query.to_a.count.should eq(30)
+    end
+
+  end
+
+end

data/spec/lib/processors/pg_json_dumper_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe ::Mincer::Processors::PgJsonDumper do
+  context 'when postgres is NOT used' do
+    before do
+      config = YAML.load_file File.expand_path(File.dirname(__FILE__) + '../../../database.yml')
+      ActiveRecord::Base.establish_connection config.merge(:adapter => :postgresql)
+      ActiveRecord::Base.connection.execute('DROP TABLE IF EXISTS active_record_models')
+      ActiveRecord::Base.connection.execute('CREATE TABLE IF NOT EXISTS active_record_models (id SERIAL PRIMARY KEY, text TEXT)')
+      class ActiveRecordModel < ActiveRecord::Base
+      end
+      ActiveRecordModel.create!(text: 'Test1')
+      ActiveRecordModel.create!(text: 'Test2')
+    end
+
+    describe 'dumping to json with basic model without any Mincer::Base configuration' do
+      subject(:model) do
+        Class.new(Mincer::Base)
+      end
+
+      it 'dumps data via postgres' do
+        query = subject.new(ActiveRecordModel)
+        ActiveRecord::Base.connection.should_receive(:execute).and_call_original
+        json_string = query.to_json
+        json_string.should be_a(String)
+        json_hash = JSON.parse(json_string)
+        json_hash.size.should eq(2)
+        json_hash[0]['id'].should == 1
+        json_hash[0]['text'].should == 'Test1'
+        json_hash[1]['id'].should == 2
+        json_hash[1]['text'].should == 'Test2'
+      end
+
+      context 'when root option is passed' do
+        it 'puts responce inside under root key' do
+          query = subject.new(ActiveRecordModel)
+          ActiveRecord::Base.connection.should_receive(:execute).and_call_original
+          json_string = query.to_json(root: 'items')
+          json_string.should be_a(String)
+          json_hash = JSON.parse(json_string)
+          json_hash['items'].size.should eq(2)
+          json_hash['items'][0]['id'].should == 1
+          json_hash['items'][0]['text'].should == 'Test1'
+          json_hash['items'][1]['id'].should == 2
+          json_hash['items'][1]['text'].should == 'Test2'
+        end
+      end
+
+    end
+  end
+  context 'when postgres is NOT used' do
+    before do
+      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+      ActiveRecord::Base.connection.execute('CREATE TABLE active_record_models (id INTEGER UNIQUE, text STRING)')
+      class ActiveRecordModel < ActiveRecord::Base
+      end
+      ActiveRecordModel.create!(id: 1, text: 'Test1')
+      ActiveRecordModel.create!(id: 2, text: 'Test2')
+    end
+
+    subject(:model) do
+      Class.new(Mincer::Base)
+    end
+
+    it 'dumps data via calling super' do
+      query = subject.new(ActiveRecordModel)
+      ActiveRecord::Base.connection.should_not_receive(:execute)
+      json_string = query.to_json
+      json_string.should be_nil
+    end
+  end
+
+end

data/spec/lib/processors/search_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe ::Mincer::Processors::Search do
+  context 'when postgres used' do
+    before do
+      config = YAML.load_file File.expand_path(File.dirname(__FILE__) + '../../../database.yml')
+      ActiveRecord::Base.establish_connection config.merge(:adapter => :postgresql)
+      ActiveRecord::Base.connection.execute('DROP TABLE IF EXISTS active_record_models')
+      ActiveRecord::Base.connection.execute('CREATE TABLE IF NOT EXISTS active_record_models (id SERIAL PRIMARY KEY, text TEXT)')
+      class ActiveRecordModel < ActiveRecord::Base
+      end
+      ActiveRecordModel.create!(text: 'Test')
+      ActiveRecordModel.create!(text: 'Bingo')
+      ActiveRecordModel.create!(text: 'Bongo')
+    end
+
+    describe 'search without "textacular"' do
+      subject(:model) do
+        Class.new(Mincer::Base)
+      end
+
+      it 'searches by pattern in args' do
+        ::Mincer::Processors::Search.any_instance.stub(:textacular?).and_return(false)
+        query = subject.new(ActiveRecordModel, { 'pattern' => 'Bingo' })
+        query.to_a.count.should eq(3)
+      end
+    end
+
+    describe 'search with "textacular"' do
+      describe 'searches with basic model without any Mincer::Base configuration' do
+        subject(:model) do
+          Class.new(Mincer::Base)
+        end
+
+        it 'searches by pattern in args' do
+          query = subject.new(ActiveRecordModel, { 'pattern' => 'Bingo' })
+          query.to_a.count.should eq(1)
+        end
+      end
+
+
+      describe 'paginating when basic model has disabled pagination' do
+        it 'does not modifies relation' do
+          subject = Class.new(Mincer::Base) do
+            skip_search!
+          end
+          query = subject.new(ActiveRecordModel, { 'pattern' => 'Bingo' })
+          query.to_a.count.should eq(3)
+        end
+      end
+    end
+  end
+
+  context 'when postgres is NOT used' do
+    before do
+      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+      ActiveRecord::Base.connection.execute('CREATE TABLE active_record_models (id INTEGER UNIQUE, text STRING)')
+      class ActiveRecordModel < ActiveRecord::Base
+      end
+      ActiveRecordModel.create!(text: 'Test')
+      ActiveRecordModel.create!(text: 'Bingo')
+      ActiveRecordModel.create!(text: 'Bongo')
+    end
+
+    subject(:model) do
+      Class.new(Mincer::Base)
+    end
+
+    it 'returns all records' do
+      query = subject.new(ActiveRecordModel, { 'pattern' => 'Bingo' })
+      query.to_a.count.should eq(3)
+    end
+  end
+
+
+end

data/spec/lib/processors/sort_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe ::Mincer::Processors::Sort do
+  before do
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+    ActiveRecord::Base.connection.execute('CREATE TABLE active_record_models (id INTEGER UNIQUE, text STRING)')
+    class ActiveRecordModel < ActiveRecord::Base
+    end
+    %w{a c b}.each { |i| ActiveRecordModel.create(text: i) }
+  end
+
+  describe 'sorting with basic model without any Mincer::Base configuration' do
+    subject(:model) do
+      Class.new(Mincer::Base)
+    end
+
+    it 'sorts by valid attribute and order when they are passed in args' do
+      query = subject.new(ActiveRecordModel, { 'sort' => 'text', 'order' => 'DESC' })
+      query.to_a.map(&:text).should == %w{c b a}
+    end
+
+    it 'sorts by default attributes(id) abd order(ASC) when nothing passed to args' do
+      query = subject.new(ActiveRecordModel)
+      query.to_a.map(&:text).should == %w{a c b}
+    end
+
+    it 'ignores sort attribute that is not allowed and use default(id)' do
+      query = subject.new(ActiveRecordModel, { 'sort' => 'text2', 'order' => 'DESC' })
+      query.to_a.map(&:text).should == %w{b c a}
+    end
+
+    it 'ignores order that is not allowed and use default(ASC)' do
+      query = subject.new(ActiveRecordModel, { 'sort' => 'text', 'order' => 'DESCA' })
+      query.to_a.map(&:text).should == %w{a b c}
+    end
+  end
+
+
+  describe 'sorting with basic model with defaults changed' do
+    it 'sorts by default attributes(id) abd order(ASC) when nothing passed to args' do
+      subject = Class.new(Mincer::Base) do
+        def default_sort_attribute
+          'text'
+        end
+        def default_sort_order
+          'DESC'
+        end
+      end
+      query = subject.new(ActiveRecordModel)
+      query.to_a.map(&:text).should == %w{c b a}
+    end
+  end
+
+  describe 'sorting with basic model with defaults changed' do
+    it 'sorts by default attributes(id) abd order(ASC) when nothing passed to args' do
+      subject = Class.new(Mincer::Base) do
+        def allowed_sort_attributes
+          ['id']
+        end
+      end
+      query = subject.new(ActiveRecordModel, { 'sort' => 'text' })
+      query.to_a.map(&:text).should == %w{a c b}
+    end
+  end
+
+
+  describe 'sorting when basic model has disabled sorting' do
+    it 'sorts by default attributes(id) abd order(ASC) when nothing passed to args' do
+      subject = Class.new(Mincer::Base) do
+        skip_sorting!
+      end
+      query = subject.new(ActiveRecordModel, { 'sort' => 'text' })
+      query.to_a.map(&:text).should == %w{a c b}
+    end
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec'
+  add_group 'Processors', '/lib/mincer/processors'
+  add_group 'ActionView', '/lib/mincer/action_view'
+end
+require 'rubygems'
+require 'bundler/setup'
+require 'active_record'
+require 'kaminari'
+Kaminari::Hooks.init
+require 'textacular'
+ActiveRecord::Base.extend(Textacular)
+require 'mincer'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.after do
+    ActiveRecord::Base.clear_active_connections!
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,234 @@
+--- !ruby/object:Gem::Specification
+name: mincer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alex Krasinsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  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: guard-rspec
+  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: pg
+  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: kaminari
+  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: will_paginate
+  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: textacular
+  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: simplecov
+  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'
+description: Add pagination, cache_digest, order, json generation with postgres, simple
+  search support to all your queries
+email:
+- lyoshakr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .idea/encodings.xml
+- .idea/misc.xml
+- .idea/modules.xml
+- .idea/scopes/scope_settings.xml
+- .idea/vcs.xml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mincer.rb
+- lib/mincer/action_view/sort_helper.rb
+- lib/mincer/base.rb
+- lib/mincer/processors/cache_digest.rb
+- lib/mincer/processors/paginate.rb
+- lib/mincer/processors/pg_json_dumper.rb
+- lib/mincer/processors/search.rb
+- lib/mincer/processors/sort.rb
+- lib/mincer/version.rb
+- mincer.gemspec
+- spec/database.yml.example
+- spec/lib/processors/cache_digest_spec.rb
+- spec/lib/processors/paginate_spec.rb
+- spec/lib/processors/pg_json_dumper_spec.rb
+- spec/lib/processors/search_spec.rb
+- spec/lib/processors/sort_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+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.0.3
+signing_key: 
+specification_version: 4
+summary: ActiveRecord::Relation wrapper for pagination, order, json, search, cache_digest
+  support
+test_files:
+- spec/database.yml.example
+- spec/lib/processors/cache_digest_spec.rb
+- spec/lib/processors/paginate_spec.rb
+- spec/lib/processors/pg_json_dumper_spec.rb
+- spec/lib/processors/search_spec.rb
+- spec/lib/processors/sort_spec.rb
+- spec/spec_helper.rb