mincer 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e7dd6365cd2d30f20a4595d0c5200254069203c
-  data.tar.gz: d0ed94870519e2b8942ada6e8a832d036b4ab94e
+  metadata.gz: 8cf265c8b6c7d273af1a0b224a9a775a920aa662
+  data.tar.gz: 2979c71e82775a3d6f7d5b49eac0e7e022501f2c
 SHA512:
-  metadata.gz: 64bdc85e7bfb0fb9f5be0cbd9e151c9da26360d3fdd01024ba5a7fcd9fcba320def5fa53ee171b6bac818ef3b50668664fc1631589fbb38a0577743b7d70cfb4
-  data.tar.gz: eee05868aa5857630101de2a085dcaf5275390b2a248c3ea5fe50c1226458cd8c5e932637f975c7add37f468a57ef3f427f67a7cbeacee3a59274b010507fb20
+  metadata.gz: 7e54d841658cd07e2366f13a66454d58c54882a96dbfbd277ade65653392c43257d0934f7bd193e3cf71afd7830a5adcc1ef3e89c95f40735a29c7c5c61824c6
+  data.tar.gz: 973a998ff2a27db653605b8448047c484720468eea2f2ae8fd8a33122a93e1f1652bd9aa663f6f494ccf23d3303b0a592820690a1aebd2c6aa4c43aba77d4b7a

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 rvm:
+  - 2.1.1
   - 2.0.0
   - 1.9.3
   - ruby-head
@@ -7,6 +8,8 @@ rvm:
 before_script:
   - psql -c 'create database mincer;' -U postgres
   - psql -d mincer -c 'CREATE EXTENSION IF NOT EXISTS pgcrypto;' -U postgres
+  - psql -d mincer -c 'CREATE EXTENSION IF NOT EXISTS unaccent;' -U postgres
+  - psql -d mincer -c 'CREATE EXTENSION IF NOT EXISTS pg_trgm;' -U postgres
 
 addons:
   postgresql: "9.3"

data/Gemfile

@@ -4,6 +4,7 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
-  gem 'codeclimate-test-reporter', require: nil
+  gem 'rspec', '~> 2.14.1'
   gem 'simplecov'
+  gem 'coveralls', require: false
 end

data/README.md

@@ -1,15 +1,16 @@
 # Mincer
 [![Build Status](https://travis-ci.org/spilin/mincer.png)](https://travis-ci.org/spilin/mincer)
-[![Code Climate](https://codeclimate.com/repos/52b775836956801ba7000bdb/badges/ec5d5862e4b89d10695c/gpa.png)](https://codeclimate.com/repos/52b775836956801ba7000bdb/feed)
+[![Code Climate](https://codeclimate.com/github/spilin/mincer.png)](https://codeclimate.com/github/spilin/mincer)
+[![Coverage Status](https://coveralls.io/repos/spilin/mincer/badge.png)](https://coveralls.io/r/spilin/mincer)
 [![Gem Version](https://badge.fury.io/rb/mincer.png)](http://badge.fury.io/rb/mincer)
 
 Mincer is an ActiveRecord::Relation wrapper that applies usefull features to your queries. It can:
 
-[Paginate](#pagination)     
-[Sort](#sort)   
-[Search](#search)   
-[Dump to Json(Using postgres >= 9.2)](#json)    
-[Generate digest(usefull for caching)](#digest) 
+[Paginate](#pagination)
+[Sort](#sort)
+[Search](#search)
+[Dump to Json(Using postgres >= 9.2)](#json)
+[Generate digest(useful for caching)](#digest)
 
 
 ## Installation
@@ -32,57 +33,59 @@ Lets assume we have 2 models
     class Employee < ActiveRecord::Base
         belongs_to :company
     end
-    
+
     class Company < ActiveRecord::Base
         has_many :employees
     end
-    
+
 Lets create class EmployeesListQuery class that will inherit from Mincer::Base, and instantiate it
 
     class EmployeesListQuery < Mincer::Base
         # method should always return relation
         def build_query(relation, args)
             custom_select = <<-SQL
-                employees.id, 
-                employees.full_name as employee_name, 
+                employees.id,
+                employees.full_name as employee_name,
                 companies.name as company_name
             SQL
             relation.joins(:company).select(custom_select)
         end
     end
-    
+
     employees = EmployeesListQuery.new(Employee)
 
 `employees` will delegate all methods, that it can't find on itself, to relation objects. This means you can use
-`employess` as you would use any ActiveRecord::Relation object:
+`employees` as you would use any ActiveRecord::Relation object:
 
     <% employees.each do |employee| %>
         <%= employee.employee_name %>
         <%= employee.company_name %>
     <% end %>
-    
 
-Now lets's look what more can we do with this object
+
+Now lets look what more can we do with this object
 
 <a name="pagination"/>
 ### Pagination
-Mincer supports [kaminari](https://github.com/amatsuda/kaminari) and [will_paginate](https://github.com/mislav/will_paginate). In order to use pagination you need to include one of them 
-to your `Gemfile`. Example of using pagination
+Mincer supports [kaminari](https://github.com/amatsuda/kaminari) and [will_paginate](https://github.com/mislav/will_paginate).
+In order to use pagination you need to include one of them
+in your `Gemfile`. Example of using pagination
 
     employees = EmployeesListQuery.new(Employee, {'page' => 2, 'per_page' => 10})
-    
-By default all `Micner` objects will use pagination, even if no arguments are passed. To set default values for pagination please refer to `kaminari` or `will_paginate` documentation.
+
+By default all `Mincer` objects will use pagination, even if no arguments are passed.
+To set default values for pagination please refer to `kaminari` or `will_paginate` documentation.
 
 To disable pagination you can use class method `skip_pagination!`:
 
     class EmployeesListQuery < Mincer::Base
         skip_pagination!
-        
+
         # method should always return relation
         def build_query(relation, args)
             custom_select = <<-SQL
-                employees.id, 
-                employees.full_name as employee_name, 
+                employees.id,
+                employees.full_name as employee_name,
                 companies.name as company_name
             SQL
             relation.joins(:company).select(custom_select)
@@ -95,21 +98,21 @@ To disable pagination you can use class method `skip_pagination!`:
 Example of using sorting:
 
     employees = EmployeesListQuery.new(Employee, {'sort' => 'employee_name', 'order' => 'DESC'})
-    
-By default all Mincer objects will sort by attribute `id` and order `ASC`. To change defaults you can override 
+
+By default all Mincer objects will sort by attribute `id` in `ASC` order. To change defaults you can override
 them like this
 
     class EmployeesListQuery < Mincer::Base
         # method should always return relation
         def build_query(relation, args)
             custom_select = <<-SQL
-                employees.id, 
-                employees.full_name as employee_name, 
+                employees.id,
+                employees.full_name as employee_name,
                 companies.name as company_name
             SQL
             relation.joins(:company).select(custom_select)
         end
-        
+
       def default_sort_attribute
         'employee_name'
       end
@@ -117,18 +120,18 @@ them like this
       def default_sort_order
         'DESC'
       end
-    end    
-    
+    end
+
 To disable sorting use class method `skip_sorting!` like this:
 
     class EmployeesListQuery < Mincer::Base
         skip_sorting!
-        
+
         # method should always return relation
         def build_query(relation, args)
             custom_select = <<-SQL
-                employees.id, 
-                employees.full_name as employee_name, 
+                employees.id,
+                employees.full_name as employee_name,
                 companies.name as company_name
             SQL
             relation.joins(:company).select(custom_select)
@@ -136,15 +139,15 @@ To disable sorting use class method `skip_sorting!` like this:
     end
 
 Mincer will validate `sort` and `order` params and will not allow to sort by attributes that do not exist.
-Default white list consists of all atttributes from original scope, in our example `Employee.attribute_name`.
-You can expand the list overriding `allowed_sort_attributes` list like this:
+Default white list consists of all attributes from original scope, in our example `Employee.attribute_name`.
+You can expand the list by overriding `allowed_sort_attributes` list like this:
 
     def allowed_sort_attributes
         super + %w{employee_name company_name}
     end
 This will allow to sort by all Employee attributes + `employee_name` and `company_name`
 
-Or restrict like this:
+Or restrict it like this:
 
     def allowed_sort_attributes
         %w{employee_name}
@@ -157,7 +160,7 @@ If you are using Rails or bare ActionView there are few helper methods at your d
 for sorting. Currently there are 2 methods available: `sort_url_for` and `sort_class_for`.
 
 Example of usage in HAML:
-    
+
     %ul
         %li{ :class => (sort_class_for employees, 'id') }
             = link_to 'ID', sort_url_for(employees, 'id')
@@ -165,32 +168,76 @@ Example of usage in HAML:
             = link_to 'Employee', sort_url_for(employees, 'employee_name')
         %li{ :class => (sort_class_for employees, 'company_name') }
             = link_to 'Company', sort_url_for(employees, 'company_name')
-      
-In this example `li` will receive `class="sorted order_down"` or `class="sorted order_up"` if this attribue was used for search.
-Generated url will be enchanced with `sort` and `order` attributes.
+
+In this example `li` will receive `class="sorted order_down"` or `class="sorted order_up"` if this attribute was used for search.
+Generated url will be enhanced with `sort` and `order` attributes.
 
 <a name="search"/>
 ### Search
 
-Currently Mincer uses [Textacular](https://github.com/textacular/textacular) for search. This sets alot of restrictions: 
-1. Works only with postgres
-2. You have to include `textacular` to your Gemfile
-3. You have to install postgres extension that [Textacular](https://github.com/textacular/textacular) uses for searching.
+Mincer borrowed allot of search logic from [PgSearch](https://github.com/Casecommons/pg_search).
+Currently search only works with postgres.
 
 Example of usage:
 
     employees = EmployeesListQuery.new(Employee, {'pattern' => 'whatever'})
 
-This will use `simple_search`, and if it will return no entries Mincer will run `fuzzy_search`. For more details on what
-is the difference between them, plese look refer to `textacular` github [page](https://github.com/textacular/textacular).
+By default search will be performed on all text/string columns of current model. If you want to explicitly set searchable columns or you can do so using `pg_search` method:
+
+    pg_search [{ :columns => %w{employees.full_name companies.name} } ]
+
+By default search will use [unaccent] to ignore accent marks. You can read more about `unaccent` [here](http://www.postgresql.org/docs/current/static/unaccent.html)
+You need to enable `unaccent` extension. If you use Rails, please use migration for that:
+
+    enable_extension 'unaccent'
+
+or run `CREATE EXTENSION IF NOT EXISTS unaccent;`
+
+If by any chance you need to disable `unaccent`:
+
+    pg_search [{ :columns => %w{employees.full_name companies.name} }, :ignore_accent => false ]
+
+If you set `any_word` attribute to true - search will return all items containing any word in the search terms.
+
+    pg_search [{ :columns => %w{employees.full_name companies.name} }, :any_word => true ]
+
+If you set `ignore_case` attribute to true - search will ignore case.
+
+    pg_search [{ :columns => %w{employees.full_name companies.name} }, :ignore_case => true ]
+
+If you set `param_name` attribute to any other string - this string will be used to extract search term from params(Default param_name = 'patern').
+
+    pg_search [{ :columns => %w{employees.full_name companies.name} }, :param_name => 's']
+    employees = EmployeesListQuery.new(Employee, {'s' => 'whatever'})
+
+There are 3 search engines you can use: `trigram`, `fulltext` and `array`.
+You can specify which one to use, along with other options like this:
+
+    pg_search [{ :columns => %w{employees.full_name companies.name}, :engines => [:fulltext, :trigram] ,:ignore_case => true, :threshold => 0.5, :dictionary => :english }]
+You can also add several search statements:
+
+    pg_search [
+        { :columns => %w{employees.full_name}, :engines => [:fulltext, :trigram] ,:ignore_case => true},
+        { :columns => %w{employees.tags}, :engines => [:array] ,:ignore_case => true, :any_word => true, param_name: 'tag'}
+    ]
+
+    employees = EmployeesListQuery.new(Employee, {'patern' => 'whatever', 'tag' => 'fired'})
+In this Mincer will search for all employees that are fired OR patern matches full_name. You can use additional option `join_with: :and`. To specify that you need only employees whith matching full name and tag
+
+    pg_search [
+        { :columns => %w{employees.full_name}, :engines => [:fulltext, :trigram] ,:ignore_case => true},
+        { :columns => %w{employees.tags}, :engines => [:array] ,:ignore_case => true, :any_word => true, param_name: 'tag'}
+    ], join_with: :and
+
+You can read details on search engines here: [Trigram](http://www.postgresql.org/docs/9.3/static/pgtrgm.html), [Fulltext](http://www.postgresql.org/docs/9.3/static/textsearch.html)
 
 <a name="json"/>
 ### JSON generation
 
-Mincer allowes you to dump query result to JSON using [Postgres JSON Functions](http://www.postgresql.org/docs/9.3/static/functions-json.html)
-Didn't had time to do benchmarks - but its' extremely fast.
+Mincer allows you to dump query result to JSON using [Postgres JSON Functions](http://www.postgresql.org/docs/9.3/static/functions-json.html)
+Didn't had time to do benchmarking, but it's extremely fast.
 
-Pros: 
+Pros:
 
 1. Speed
 2. No extra dependencies(you don't need any other JSON generators)
@@ -203,31 +250,31 @@ Cons:
 To dump query result to json string you have to call `to_json` on Mincer object:
 
     EmployeesListQuery.new(Employee).to_json
-    
-In our example it will return something like this 
+
+In our example it will return something like this
 
     "[{\"id\":1,\"employee_name\":\"John Smith\",\"company_name\":\"Microsoft\"},{\"id\":2,\"employee_name\":\"Jane Smith\",\"company_name\":\"37 Signals\"}]"
-    
+
 In addition you can pass option `root` to `to_json` method if you need to include root to json string:
-    
+
     EmployeesListQuery.new(Employee).to_json(root: 'employees')
     # returns
     "{\"employees\":[{\"id\":1,\"employee_name\":\"John Smith\",\"company_name\":\"Microsoft\"},{\"id\":2,\"employee_name\":\"Jane Smith\",\"company_name\":\"37 Signals\"}]}"
 
-<a name="digest"/> 
+<a name="digest"/>
 ### Digest
 
-Digest is very usefull for cache invalidation on your views when you are using custom queries. We will modify a bit example:
+Digest is very useful for cache invalidation on your views when you are using custom queries. We will modify a bit example:
 
     class EmployeesListQuery < Mincer::Base
         digest! %w{employee_updated_at company_updated_at}
-    
+
         def build_query(relation, args)
             custom_select = <<-SQL
-                employees.id, 
-                employees.full_name as employee_name, 
+                employees.id,
+                employees.full_name as employee_name,
                 companies.name as company_name,
-                employees.updated_at as employee_updated_at, 
+                employees.updated_at as employee_updated_at,
                 companies.updated_at as company_updated_at
             SQL
             relation.joins(:company).select(custom_select)
@@ -237,20 +284,20 @@ Digest is very usefull for cache invalidation on your views when you are using c
 In this example we will use 2 updated_at timestamps to generate digest. Whenever one of them will change - digest will change also. To get digest you should use method `digest` on Mincer model
 
     EmployeesListQuery.new(Employee).digest # "\\x20e93b4dc5e029130f3d60d697137934"
-    
+
 To generate digest you need to install extension 'pgcrypto'. If you use Rails, please use migration for that
-    
+
     enable_extension 'pgcrypto'
-    
+
 or run `CREATE EXTENSION IF NOT EXISTS pgcrypto;`
 
 
 ## TODO
 
-1. Create general configuration for Mincer that would allow:
-    1. Changing sort html classes
-    2. Changing default arguments(sort, order, pattern, page, per_page..)
-    3. Disabling some processors for all Mincer objects
+1. Create general configuration for Mincer that would allow to:
+    1. Change sort html classes
+    2. Change default arguments(sort, order, pattern, page, per_page..)
+    3. Disable some processors for all Mincer objects
 2. Create rails generators.
 
 

data/lib/mincer/action_view/sort_helper.rb

@@ -12,11 +12,11 @@ module Mincer
       def opposite_order_for(collection, attribute)
         return nil unless collection.sort_attribute == attribute.to_s
         if collection.sort_order.to_s.downcase == 'asc'
-          'DESC'
+          'desc'
         elsif collection.sort_order.to_s.downcase == 'desc'
-          'ASC'
+          'asc'
         else
-          'ASC'
+          'asc'
         end
       end
 
@@ -27,10 +27,10 @@ module Mincer
       # <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'
+        if collection.sort_order.downcase == 'asc'
+          ::Mincer.config.sorting.asc_class
+        elsif collection.sort_order.downcase == 'desc'
+          ::Mincer.config.sorting.desc_class
         else
           ''
         end

data/lib/mincer/base.rb

@@ -7,7 +7,7 @@ module Mincer
 
     # Builds query object
     def initialize(scope, args = {})
-      @scope, @args, @relation = scope, args, build_query(scope, args)
+      @scope, @args, @relation = scope, ::ActiveSupport::HashWithIndifferentAccess.new(args), build_query(scope, args)
       execute_processors
     end
 

data/lib/mincer/config.rb

@@ -0,0 +1,29 @@
+# This should be extracted and moved to gem
+module Mincer
+
+  def self.configure
+    yield(config)
+  end
+
+  def self.config
+    @config ||= ::Mincer::Configuration.new
+  end
+
+  class Configuration
+
+    def add(processor, config_class)
+      define_config_accessors(processor, config_class)
+    end
+
+    def define_config_accessors(processor, config_class)
+      class_eval <<-ACCESORS, __FILE__
+        def #{processor}
+          @#{processor} ||= #{config_class}.new
+          block_given? ? yield(@#{processor}) : @#{processor}
+        end
+      ACCESORS
+    end
+
+  end
+end
+

data/lib/mincer/core_ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def to_sql
+    self.to_s
+  end
+end

data/lib/mincer/processors/cache_digest/processor.rb

@@ -0,0 +1,54 @@
+module Mincer
+  module Processors
+    module CacheDigest
+      class Processor
+
+        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 Options
+        extend ActiveSupport::Concern
+
+        def digest
+          CacheDigest::Processor.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
+end
+
+::Mincer.add_processor(:cache_digest)

data/lib/mincer/processors/helpers.rb

@@ -0,0 +1,15 @@
+module Mincer
+  module Processors
+    module Helpers
+
+      def join_expressions(expressions, join_with)
+        case join_with
+        when :and then Arel::Nodes::And.new(expressions)
+        when :or then expressions.inject { |accumulator, expression| Arel::Nodes::Or.new(accumulator, expression) }
+        else expressions.inject { |accumulator, expression| Arel::Nodes::InfixOperation.new(join_with, accumulator, expression) }
+        end
+      end
+
+    end
+  end
+end

data/lib/mincer/processors/pagination/processor.rb

@@ -0,0 +1,63 @@
+module Mincer
+  module Processors
+    module Pagination
+      class Processor
+        def initialize(mincer)
+          @mincer, @args, @relation = mincer, mincer.args, mincer.relation
+        end
+
+        def apply
+          if self.class.kaminari?
+            @relation.page(page).per(per_page)
+          elsif self.class.will_paginate?
+            @relation.paginate(page: page, per_page: per_page)
+          else
+            warn 'To enable pagination please add kaminari or will_paginate to your Gemfile'
+            @relation
+          end
+        end
+
+        def self.kaminari?
+          defined?(::Kaminari)
+        end
+
+        def self.will_paginate?
+          defined?(::WillPaginate)
+        end
+
+        def page
+          @args[::Mincer.config.pagination.page_param_name]
+        end
+
+        def per_page
+          @args[::Mincer.config.pagination.per_page_param_name]
+        end
+      end
+
+      module Options
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def skip_pagination!
+            active_processors.delete(Mincer::Processors::Pagination::Processor)
+          end
+        end
+      end
+
+      class Configuration
+        include ActiveSupport::Configurable
+
+        config_accessor :page_param_name do
+          (::Mincer::Processors::Pagination::Processor.kaminari? && ::Kaminari.config.param_name) || :page
+        end
+
+        config_accessor :per_page_param_name do
+          :per_page
+        end
+      end
+    end
+  end
+end
+
+
+::Mincer.add_processor(:pagination)

data/lib/mincer/processors/pg_json_dumper/processor.rb

@@ -0,0 +1,69 @@
+module Mincer
+  module Processors
+    module PgJsonDumper
+      class Processor
+
+        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(json_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 json_query
+          if @options[:root]
+            json_query_with_root(@options[:root])
+          else
+            basic_json_query
+          end
+        end
+
+        def base_sql
+          @mincer.sql
+        end
+
+        # Query for basic json generation. Ex: [{'id': 1}, {...}]
+        def basic_json_query(root = 'json')
+          <<-SQL
+            SELECT COALESCE(array_to_json(array_agg(row_to_json(subq))), '[]') AS #{root}
+            FROM (#{base_sql}) as subq
+          SQL
+        end
+
+        # Generates json with root. Ex: If root = 'items' resulting json will be { 'items' => [...] }
+        def json_query_with_root(root)
+          <<-SQL
+            SELECT row_to_json(t) as json FROM ( #{basic_json_query(root)} ) as t
+          SQL
+        end
+
+      end
+
+      module Options
+        extend ActiveSupport::Concern
+
+        def to_json(options = {})
+          PgJsonDumper::Processor.new(self, options).to_json
+        end
+      end
+
+    end
+  end
+end
+
+::Mincer.add_processor(:pg_json_dumper)