filterer 0.4.3 → 1.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b96dd492a73ed7c13be50344b87d56a5600b2d4b
-  data.tar.gz: 8042241a505eb55ce5adb1e7b158ba2faeac7f64
+  metadata.gz: b44892d5a150d19bef25b69c217cf1fa0fa76cb7
+  data.tar.gz: c8f02087f8d7ee437e936f841d23f9c2200f0462
 SHA512:
-  metadata.gz: 4b1dfc79a3bef9c2c8583dba2221c7543d112484c4e201b8bd99117f7b109da624fdcf761fe439c79cd64abf6b07ee300363bf6d3f4a0731be1c68aaac807f14
-  data.tar.gz: 2bfa646276b08ec0babdb6997621c8e735d622d65658d69b687c6787d5d6f33e0843f3142d7049c4cdd0cc6b8528213a833f7e4721fa8c4f7acff2212c09e219
+  metadata.gz: 3afe610c8e745b68f336a32078246cf94987a44803d8452384987acdd52886bfc4573ae33f146b12a1286e80deb901b487c15d37e8a671f4a302cd572e02f701
+  data.tar.gz: 79ca8ab44c8d266eed187033a2fb22f4554695af64489a75afccbcdeaba78f77d1d8322ed769ca94444607db864e9abbc0176130a0d40f47296f02d804ea0810

data/lib/filterer.rb

@@ -1,6 +1,5 @@
 require 'filterer/engine'
 require 'filterer/base'
-require 'filterer/paginator'
 
 module Filterer
 end

data/lib/filterer/active_record.rb

@@ -0,0 +1,24 @@
+module Filterer
+  module ActiveRecord
+    extend ActiveSupport::Concern
+
+    included do
+      def self.filter(params = {}, opts = {})
+        filterer_class(opts[:filterer_class]).
+          filter(params, { starting_query: all }.merge(opts))
+      end
+
+      def self.filterer_class(override)
+        if override
+          override.constantize
+        else
+          const_get("#{name}Filterer")
+        end
+      rescue
+        fail "Looked for #{name}Filterer and couldn't find one!"
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Filterer::ActiveRecord)

data/lib/filterer/base.rb

@@ -1,8 +1,10 @@
 module Filterer
   class Base
-    IGNORED_PARAMS = %w(page)
-
-    attr_accessor :results, :meta, :direction, :sort, :params, :opts
+    attr_accessor :results,
+                  :meta,
+                  :sort,
+                  :params,
+                  :opts
 
     class_attribute :sort_options
     self.sort_options = []
@@ -10,21 +12,22 @@ module Filterer
     class_attribute :per_page
     self.per_page = 20
 
-    class_attribute :per_page_allow_override
-    self.per_page_allow_override = false
+    class_attribute :allow_per_page_override
+    self.allow_per_page_override = false
 
     class_attribute :per_page_max
     self.per_page_max = 1000
 
     class << self
-      def sort_option(key, query_string_or_proc = nil, opts = {})
-        if query_string_or_proc.is_a?(Hash)
-          opts, query_string_or_proc = query_string_or_proc.clone, nil
+      # Macro for adding sort options
+      def sort_option(key, string_or_proc = nil, opts = {})
+        if string_or_proc.is_a?(Hash)
+          opts, string_or_proc = string_or_proc.clone, nil
         end
 
-        if !query_string_or_proc
+        if !string_or_proc
           if key.is_a?(String)
-            query_string_or_proc = key
+            string_or_proc = key
           else
             raise 'Please provide a query string or a proc.'
           end
@@ -34,120 +37,128 @@ module Filterer
           raise "Default sort option can't have a Regexp key."
         end
 
-        if query_string_or_proc.is_a?(Proc) && opts[:tiebreaker]
+        if string_or_proc.is_a?(Proc) && opts[:tiebreaker]
           raise "Tiebreaker can't be a proc."
         end
 
         self.sort_options += [{
           key: key,
-          query_string_or_proc: query_string_or_proc,
+          string_or_proc: string_or_proc,
           opts: opts
         }]
       end
 
-      def count(params = {}, opts = {})
-        self.new(params, { meta_only: true }.merge(opts)).meta[:total]
+      # Public API
+      # @return [ActiveRecord::Association]
+      def filter(*args)
+        new(*args).results
       end
+    end
 
-      def chain(params = {}, opts = {})
-        self.new(params, { chainable: true }.merge(opts)).results
-      end
+    def initialize(params = {}, opts = {})
+      self.params = defaults.merge(params).with_indifferent_access
+      self.opts = opts
+      self.results = opts[:starting_query] || starting_query
+      self.results = apply_default_filters || results
+      add_params_to_query
+      order_results unless opts[:skip_ordering]
+      paginate_results unless opts[:skip_pagination]
+      extend_active_record_relation
     end
 
     def defaults
       {}
     end
 
-    def initialize(params = {}, opts = {})
-      @params, @opts = defaults.merge(params).with_indifferent_access, opts
-      setup_meta
-      find_results
+    def starting_query
+      raise 'You must override this method!'
     end
 
-    def paginator
-      @paginator ||= Filterer::Paginator.new(self)
+    def direction
+      params[:direction].try(:downcase) == 'desc' ? 'desc' : 'asc'
     end
 
-    def setup_meta
-      @meta = {
-        page: [@params[:page].to_i, 1].max,
-        per_page: get_per_page
-      }
+    def sort
+      @sort ||= begin
+        if params[:sort] && find_sort_option_from_param(params[:sort])
+          params[:sort]
+        else
+          default_sort_option.try(:[], :key)
+        end
+      end
     end
 
-    def get_per_page
-      if self.class.per_page_allow_override && @params[:per_page].present?
-        [@params[:per_page].to_i, self.per_page_max].min
-      else
-        self.class.per_page
+    private
+
+    def paginate_results
+      if per_page && paginator
+        send("paginate_results_with_#{paginator}")
       end
     end
 
-    def find_results
-      @results = opts.delete(:starting_query) || starting_query
-      add_params_to_query
-      return if @opts[:chainable] && !@opts[:include_ordering]
-      order_results
-      return if @opts[:chainable]
-      add_meta
-      return if @opts[:meta_only]
+    def paginator
+      if defined?(Kaminari)
+        :kaminari
+      elsif defined?(WillPaginate)
+        :will_paginate
+      end
+    end
 
-      # Add custom meta data if we've defined the method
-      @meta.merge!(self.custom_meta_data) if self.respond_to?(:custom_meta_data)
+    def paginate_results_with_kaminari
+      self.results = results.page(current_page).per(per_page)
+    end
 
-      # Return the paginated results
-      @results = @results.limit(@meta[:per_page]).offset((@meta[:page] - 1)*@meta[:per_page])
+    def paginate_results_with_will_paginate
+      self.results = results.paginate(page: current_page, per_page: per_page)
     end
 
-    def add_meta
-      @meta[:total] = @results.unscope(:select).count
-      @meta[:last_page] = [(@meta[:total].to_f / @meta[:per_page]).ceil, 1].max
-      @meta[:page] = [@meta[:last_page], @meta[:page]].min
+    def apply_default_filters
+      results
     end
 
     def add_params_to_query
-      @params.reject { |k, v| k.to_s.in?(IGNORED_PARAMS) }
-             .select { |k, v| v.present? }
-             .each do |k, v|
-
+      present_params.each do |k, v|
         method_name = "param_#{k}"
-        @results = respond_to?(method_name) ? send(method_name, v) : @results
+
+        if respond_to?(method_name)
+          self.results = send(method_name, v)
+        end
       end
     end
 
-    def order_results
-      @direction = @params[:direction] == 'desc' ? 'DESC' : 'ASC'
-      @sort = (params[:sort] && get_sort_option(params[:sort])) ? params[:sort] : default_sort_param
-
-      if !get_sort_option(@sort)
-        @results = @results.order default_sort_sql
-      elsif get_sort_option(@sort)[:query_string_or_proc].is_a?(String)
-        @results = @results.order basic_sort_sql
-      elsif get_sort_option(@sort)[:query_string_or_proc].is_a?(Proc)
-        apply_sort_proc
+    def present_params
+      params.select do |_k, v|
+        v.present?
       end
     end
 
-    def default_sort_sql
-      "#{@results.model.table_name}.id ASC"
+    def order_results
+      self.results = if !sort_option
+                       results.order(default_sort_sql)
+                     elsif sort_option[:string_or_proc].is_a?(String)
+                       results.order(basic_sort_sql)
+                     elsif sort_option[:string_or_proc].is_a?(Proc)
+                       apply_sort_proc
+                     end
+    end
+
+    def per_page
+      if self.class.allow_per_page_override && params[:per_page].present?
+        [params[:per_page], per_page_max].min
+      else
+        self.class.per_page
+      end
     end
 
-    def basic_sort_sql
-      %{
-        #{get_sort_option(@sort)[:query_string_or_proc]}
-        #{@direction}
-        #{get_sort_option(@sort)[:opts][:nulls_last] ? 'NULLS LAST' : ''}
-        #{tiebreaker_sort_string ? ',' + tiebreaker_sort_string : ''}
-      }.squish
+    def current_page
+      [params[:page].to_i, 1].max
     end
 
-    def apply_sort_proc
-      sort_key = get_sort_option(@sort)[:key]
-      matches = sort_key.is_a?(Regexp) && @sort.match(sort_key)
-      @results = get_sort_option(@sort)[:query_string_or_proc].call(@results, matches, self)
+    def sort_option
+      @sort_option ||= find_sort_option_from_param(sort)
     end
 
-    def get_sort_option(x)
+    def find_sort_option_from_param(x)
       self.class.sort_options.detect do |sort_option|
         if sort_option[:key].is_a?(Regexp)
           x.match(sort_option[:key])
@@ -157,20 +168,45 @@ module Filterer
       end
     end
 
-    def default_sort_param
+    def default_sort_sql
+      "#{results.model.table_name}.id asc"
+    end
+
+    def basic_sort_sql
+      %{
+        #{sort_option[:string_or_proc]}
+        #{direction}
+        #{sort_option[:opts][:nulls_last] ? 'NULLS LAST' : ''}
+        #{tiebreaker_sort_string ? ', ' + tiebreaker_sort_string : ''}
+      }.squish
+    end
+
+    def apply_sort_proc
+      sort_key = sort_option[:key]
+      matches = sort_key.is_a?(Regexp) && params[:sort].match(sort_key)
+      sort_option[:string_or_proc].call(results, matches, self)
+    end
+
+    def default_sort_option
       self.class.sort_options.detect do |sort_option|
         sort_option[:opts][:default]
-      end.try(:[], :key)
+      end
     end
 
     def tiebreaker_sort_string
       self.class.sort_options.detect do |sort_option|
         sort_option[:opts][:tiebreaker]
-      end.try(:[], :query_string_or_proc)
+      end.try(:[], :string_or_proc)
     end
 
-    def starting_query
-      raise 'You must override this method!'
+    def extend_active_record_relation
+      results.instance_variable_set(:@filterer, self)
+
+      results.extending! do
+        def filterer
+          @filterer
+        end
+      end
     end
   end
 end

data/lib/filterer/engine.rb

@@ -1,5 +1,9 @@
 module Filterer
   class Engine < ::Rails::Engine
     isolate_namespace Filterer
+
+    ActiveSupport.on_load(:active_record) do
+      require 'filterer/active_record'
+    end
   end
 end

data/lib/filterer/version.rb

@@ -1,3 +1,3 @@
 module Filterer
-  VERSION = '0.4.3'
+  VERSION = '1.0.0.beta.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: filterer
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 1.0.0.beta.1
 platform: ruby
 authors:
 - Adam Becker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-30 00:00:00.000000000 Z
+date: 2015-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  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: capybara
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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-rails
   requirement: !ruby/object:Gem::Requirement
@@ -145,11 +173,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Rakefile
-- app/helpers/filterer/pagination_helper.rb
 - lib/filterer.rb
+- lib/filterer/active_record.rb
 - lib/filterer/base.rb
 - lib/filterer/engine.rb
-- lib/filterer/paginator.rb
 - lib/filterer/version.rb
 - lib/generators/filterer/filterer_generator.rb
 - lib/generators/filterer/templates/filter.rb
@@ -157,7 +184,6 @@ files:
 - lib/generators/rspec/templates/filter_spec.rb
 - lib/generators/test_unit/filterer_generator.rb
 - lib/generators/test_unit/templates/filter_test.rb
-- lib/tasks/filterer_tasks.rake
 homepage: https://github.com/dobtco/filterer
 licenses:
 - MIT
@@ -173,9 +199,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2

data/app/helpers/filterer/pagination_helper.rb

@@ -1,54 +0,0 @@
-module Filterer
-  module PaginationHelper
-
-    RIGHT_ARROW = '›'.html_safe
-    LEFT_ARROW = '‹'.html_safe
-
-    def render_filterer_pagination(filterer)
-      content_tag(:div, class: 'pagination-wrapper') do
-        content_tag(:ul, class: 'unstyled') do
-          render_filterer_previous_link(filterer) +
-          filterer.paginator.pages.map { |p| render_filterer_page_link(filterer, p) }.join('').html_safe +
-          render_filterer_next_link(filterer)
-        end
-      end
-    end
-
-    private
-    def calculate_filterer_pagination_url(page)
-      url_for(params.merge(page: page))
-    end
-
-    def render_filterer_previous_link(filterer)
-      content_tag(:li, class: filterer.meta[:page] == 1 ? "disabled" : '') do
-        if filterer.meta[:page] == 1
-          content_tag(:span) { LEFT_ARROW }
-        else
-          content_tag(:a, class: 'pagination-previous',
-                      href: calculate_filterer_pagination_url(filterer.meta[:page] - 1)) { LEFT_ARROW }
-        end
-      end
-    end
-
-    def render_filterer_next_link(filterer)
-      content_tag(:li, class: filterer.meta[:page] == filterer.meta[:last_page] ? "disabled" : '') do
-        if filterer.meta[:page] == filterer.meta[:last_page]
-          content_tag(:span) { RIGHT_ARROW }
-        else
-          content_tag(:a, class: 'pagination-next', href: calculate_filterer_pagination_url(filterer.meta[:page] + 1)) { RIGHT_ARROW }
-        end
-      end
-    end
-
-    def render_filterer_page_link(filterer, p)
-      if p == 'break'
-        "<li><span>&hellip;</span></li>"
-      else
-        content_tag(:li, class: p == filterer.meta[:page] ? 'active' : '') do
-          content_tag(:a, href: calculate_filterer_pagination_url(p)) { p.to_s }
-        end
-      end
-    end
-
-  end
-end

data/lib/filterer/paginator.rb

@@ -1,51 +0,0 @@
-module Filterer
-  class Paginator
-
-    attr_reader :pages
-
-    def initialize(filterer)
-      @filterer = filterer
-      return @pages = [1] if @filterer.meta[:last_page] == 1
-      push_default_pages
-      calculate_additional_pages
-      add_breaks
-    end
-
-    def push_default_pages
-      @pages = [1, 2]
-      push_page(@filterer.meta[:last_page], @filterer.meta[:last_page] - 1)
-    end
-
-    def calculate_additional_pages
-      offset = 0
-      current_page = @filterer.meta[:page]
-
-      while @pages.length < 11 && ( (current_page - offset >= 1) || (current_page + offset <= @filterer.meta[:last_page]) ) do
-        push_page(current_page - offset, current_page + offset)
-        offset += 1
-      end
-    end
-
-    def add_breaks
-      pages_without_breaks = @pages.sort
-      pages_with_breaks = []
-
-      pages_without_breaks.each_with_index do |p, i|
-        if pages_without_breaks[i - 1] && (p - pages_without_breaks[i - 1] > 1)
-          pages_with_breaks.push 'break'
-        end
-
-        pages_with_breaks.push p
-      end
-
-      @pages = pages_with_breaks
-    end
-
-    def push_page(*args)
-      args.each do |page|
-        @pages.push(page) unless @pages.include?(page) || (page > @filterer.meta[:last_page]) || (page < 1)
-      end
-    end
-
-  end
-end

data/lib/tasks/filterer_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :filterer do
-#   # Task goes here
-# end