filterrific 1.0.1 → 1.1.0

data/doc/development_notes/controller_api.txt

@@ -20,8 +20,15 @@ def index
   * :debug => false  # if true, prints out debug info. This also exists in view helper. Maybe one to
     logger/STDOUT, the other to view?
   * :param_prefix => "filterrific"  # the param prefix used to shuttle params between view and controller.
-  
+
   @publications = Publication.filterrific_find(@filterrific).paginate....
   @publications = current_user.publications.filterrific_find(@filterrific).paginate....
   ...
 end
+
+@filterrific = Filterrific.new(User, params_hash)
+@users = User.filterrific_find(@filterrific).where(...)
+
+@filterrific = Filterrific.new(self, User)
+@filterrific = filterrific_init(User, options) (loads and persists in session)
+@users = User.filterrific_find(@filterrific).paginate(:page => params[:page])

data/doc/meta.md

@@ -0,0 +1,27 @@
+Workflow to Maintain This Gem
+=============================
+
+I use the gem-release gem
+
+For more info see: https://github.com/svenfuchs/gem-release#usage
+
+Steps for an update
+-------------------
+
+1. Update code and commit it.
+2. Add entry to CHANGELOG:
+   * h1 for major release
+   * h2 for minor release
+   * h3 for patch release
+3. Bump the version with one of these commands:
+   * `gem bump --version 1.1.1` # Bump the gem version to the given version number
+   * `gem bump --version major` # 0.0.1 -> 1.0.0
+   * `gem bump --version minor` # 0.0.1 -> 0.1.0
+   * `gem bump --version patch` # 0.0.1 -> 0.0.2
+4. Release it.
+   * `gem release`
+5. Create a git tag and push to origin.
+   `gem tag`
+
+
+http://prioritized.net/blog/gemify-assets-for-rails/

data/lib/filterrific.rb

@@ -1,11 +1,5 @@
-# = The Rails User Interface Solution for Filtering Your ActiveRecord Lists
-#
-module Filterrific
-
-  if defined?(Rails) && Rails::VERSION::MAJOR == 3
-    require 'filterrific/railtie'
-  else
-    raise "Filterrific requires Rails 3"
-  end
+require 'filterrific/version'
+require 'filterrific/engine'
 
+module Filterrific
 end

data/lib/filterrific/action_view_extension.rb

@@ -0,0 +1,15 @@
+#
+# Adds view helpers to ActionView
+#
+module Filterrific::ActionViewExtension
+
+  # Renders a spinner while the list is being updated
+  def render_filterrific_spinner
+    %(
+      <span class="filterrific_spinner" style="display:none;">
+        #{ image_tag('filterrific-spinner.gif') }
+      </span>
+    ).html_safe
+  end
+
+end

data/lib/filterrific/active_record_extension.rb

@@ -0,0 +1,71 @@
+#
+# Adds filterrific methods to ActiveRecord::Base and sub classes.
+#
+require 'filterrific/param_set'
+
+module Filterrific::ActiveRecordExtension
+
+  module ClassMethods
+
+    # Adds filterrific behavior to class when called like so:
+    #
+    # filterrific(
+    #   :default_settings => { :sorted_by => "created_at_asc" },
+    #   :filter_names => [:sorted_by, :search_query, :with_state]
+    # )
+    #
+    # @params[Hash] options
+    #    Required keys are:
+    #     * :filter_names: a list of filter_names to be exposed by Filterrific
+    #    Optional keys are:
+    #     * :default_settings: default filter settings
+    def filterrific(options)
+      cattr_accessor :filterrific_default_settings
+      cattr_accessor :filterrific_filter_names
+
+      options.stringify_keys!
+
+      # Raise exception if not filter_names are given
+      self.filterrific_filter_names = (
+        options['filter_names'] || options['scope_names'] || []
+      ).map { |e| e.to_s }
+      raise(ArgumentError, ":filter_names can't be empty")  if filterrific_filter_names.blank?
+
+      self.filterrific_default_settings = (
+        options['default_settings'] || options['defaults'] || {}
+      ).stringify_keys
+      # Raise exception if defaults contain keys that are not present in filter_names
+      if (
+        invalid_defaults = (filterrific_default_settings.keys - filterrific_filter_names)
+      ).any?
+        raise(ArgumentError, "Invalid default keys: #{ invalid_defaults.inspect }")
+      end
+    end
+
+    # Returns ActiveRecord relation based on given filterrific_param_set.
+    # Use like so:
+    # ModelClass.filterrific_find(@filterrific_param_set)
+    #
+    # @param[Filterrific::ParamSet] filterrific_param_set
+    # @return[ActiveRecord::Relation] an ActiveRecord relation.
+    def filterrific_find(filterrific_param_set)
+      unless filterrific_param_set.is_a?(Filterrific::ParamSet)
+        raise(ArgumentError, "Invalid Filterrific::ParamSet: #{ filterrific_param_set.inspect }")
+      end
+
+      # set initial ar_proxy to including class
+      ar_proxy = self
+
+      # apply filterrific params
+      self.filterrific_filter_names.each do |filter_name|
+        filter_param = filterrific_param_set.send(filter_name)
+        next if filter_param.blank? # skip blank filter_params
+        ar_proxy = ar_proxy.send(filter_name, filter_param)
+      end
+
+      ar_proxy
+    end
+
+  end
+
+end

data/lib/filterrific/engine.rb

@@ -0,0 +1,26 @@
+require 'rails'
+
+module Filterrific
+  class Engine < ::Rails::Engine
+
+    # It's an engine so that we can add javascript and image assets
+    # to the asset pipeline.
+
+    require 'filterrific/param_set'
+
+    initializer "filterrific.active_record_extension" do |app|
+      require 'filterrific/active_record_extension'
+      class ::ActiveRecord::Base
+        extend Filterrific::ActiveRecordExtension::ClassMethods
+      end
+    end
+
+    initializer "filterrific.action_view_extension" do |app|
+      require 'filterrific/action_view_extension'
+      class ::ActionView::Base
+        include Filterrific::ActionViewExtension
+      end
+    end
+
+  end
+end

data/lib/filterrific/param_set.rb

@@ -1,21 +1,23 @@
+require 'active_support/all'
+
 module Filterrific
 
-  # FilterParamSet is a container to store FilterParams for a resource class that is filterrific
+  # FilterParamSet is a container to store FilterParams
   class ParamSet
 
     attr_accessor :resource_class
 
-    def initialize(resource_class, filterrific_params = {})
+    def initialize(a_resource_class, filterrific_params = {})
 
-      self.resource_class = resource_class
+      self.resource_class = a_resource_class
 
-      # use either passed in options or resource class' default list_options
-      # don't merge them. This causes trouble if an option is set to nil
-      # by the user, then it will be overriden by default list_options
+      # Use either passed in filterrific_params or resource class' default_settings.
+      # Don't merge the hashes. This causes trouble if an option is set to nil
+      # by the user, then it will be overriden by default_settings.
       # You might wonder "what if I want to change only one thing from the defaults?"
       # Persistence, baby. By the time you submit changes to one dimension, all the others
       # will be already initialized with the defaults.
-      filterrific_params = resource_class.default_filterrific_params if filterrific_params.blank?
+      filterrific_params = resource_class.filterrific_default_settings  if filterrific_params.blank?
 
       # force all keys to strings
       filterrific_params.stringify_keys!
@@ -27,47 +29,54 @@ module Filterrific
           # evaulate Procs
           filterrific_params[key] = val.call
         when val.is_a?(Array)
-          # type cast integers
+          # type cast integers in the array
           filterrific_params[key] = filterrific_params[key].map { |e| e =~ /^\d+$/ ? e.to_i : e }
         when val =~ /^\d+$/
-          # type cast integers
+          # type cast integer
           filterrific_params[key] = filterrific_params[key].to_i
         end
       end
 
-      # Define attr_accessor for each FilterrificScope
+      # Define attr_accessor for each filterrific_filter_name
       # on Filterrific::ParamSet instance and assign values from options
-      resource_class.filterrific_scope_names.each do |scope_name|
-        self.class.send(:attr_accessor, scope_name)
-        v = filterrific_params[scope_name.to_s]
-        self.send("#{ scope_name }=", v)  if v.present?
+      resource_class.filterrific_filter_names.each do |filter_name|
+        self.class.send(:attr_accessor, filter_name)
+        v = filterrific_params[filter_name]
+        self.send("#{ filter_name }=", v)  if v.present?
       end
 
     end
 
-    # Returns FilterrificParams as hash (used for URL params and serialization)
+    # Returns Filterrific::ParamSet as hash (used for URL params and serialization)
     def to_hash
       {}.tap { |h|
-        resource_class.filterrific_scope_names.each do |scope_name|
-          param_value = self.send(scope_name)
+        resource_class.filterrific_filter_names.each do |filter_name|
+          param_value = self.send(filter_name)
           case
           when param_value.blank?
             # do nothing
           when param_value.is_a?(Proc)
             # evaluate Proc so it can be serialized
-            h[scope_name.to_s] = param_value.call
+            h[filter_name] = param_value.call
           else
-            h[scope_name.to_s] = param_value
+            h[filter_name] = param_value
           end
         end
       }
     end
 
-    # Returns true if this Filterrific::ParamSet is not the model's default.
-    def customized?
-      resource_class.default_filterrific_params != to_hash
+    def to_json
+      to_hash.to_json
     end
 
+    # Returns true if this Filterrific::ParamSet is not the model's default.
+    # TODO: this doesn't work for procs. I need to evaluate the 
+    # filterrific_default_settings before comparing them to to_hash.
+    #
+    # def customized?
+    #   resource_class.filterrific_default_settings != to_hash
+    # end
+
   end
 
 end

data/lib/filterrific/version.rb

@@ -0,0 +1,3 @@
+module Filterrific
+  VERSION = "1.1.0"
+end

data/spec/action_view_extension_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'filterrific/action_view_extension'
+
+class ViewContext
+
+  include Filterrific::ActionViewExtension
+
+end
+
+describe Filterrific::ActionViewExtension do
+
+  it "renders filterrific spinner" do
+    ViewContext.new.should respond_to(:render_filterrific_spinner)
+  end
+
+end

data/spec/active_record_extension_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'active_record'
+require 'filterrific/active_record_extension'
+::ActiveRecord::Base.extend Filterrific::ActiveRecordExtension::ClassMethods
+
+# Container for test data
+class TestData
+
+  def self.filterrific_filter_names
+    %w[sorted_by search_query with_country_id]
+  end
+
+  def self.filterrific_default_settings
+    { 'sorted_by' => 'name_asc' }
+  end
+
+end
+
+describe Filterrific::ActiveRecordExtension do
+
+  let(:filterrific_class){
+    Class.new(ActiveRecord::Base) do
+      filterrific(
+        :filter_names => TestData.filterrific_filter_names,
+        :default_settings => TestData.filterrific_default_settings
+      )
+    end
+  }
+
+  describe "Class method extensions" do
+
+    it "adds a 'filterrific' class method" do
+      filterrific_class.should respond_to(:filterrific)
+    end
+
+    it "adds a 'filterrific_find' class method" do
+      filterrific_class.should respond_to(:filterrific_find)
+    end
+
+  end
+
+  describe "Filterrific initialization" do
+
+    it "initializes filterrific_filter_names" do
+      filterrific_class.filterrific_filter_names.should == TestData.filterrific_filter_names
+    end
+
+    it "initializes filterrific_default_settings" do
+      filterrific_class.filterrific_default_settings.should == TestData.filterrific_default_settings
+    end
+
+    it "raises when no filter_names are given" do
+      expect {
+        Class.new(ActiveRecord::Base) do
+          filterrific(
+            :filter_names => []
+          )
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+    it "raises when default_settings contains keys that are not in filter_names" do
+      expect {
+        Class.new(ActiveRecord::Base) do
+          filterrific(
+            :filter_names => [:one, :two],
+            :default_settings => { :three => '' }
+          )
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+  end
+
+  describe "filterrific_find" do
+
+    it "raises when given invalid params" do
+      expect {
+        filterrific_class.filterrific_find('an invalid argument')
+      }.to raise_error(ArgumentError)
+    end
+
+  end
+
+end

data/spec/filterrific_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Filterrific do
+  pending "write it"
+end

data/spec/param_set_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'filterrific/param_set'
+
+# Container for test data
+class TestData
+
+  def self.filterrific_filter_names
+    %w[
+      filter_proc
+      filter_array_int
+      filter_array_string
+      filter_int
+      filter_string
+    ]
+  end
+
+  def self.filterrific_default_settings
+    { 'filter_int' => 42 }
+  end
+
+  def self.filterrific_params
+    {
+      'filter_proc' => lambda { 1 + 1 },
+      'filter_array_int' => %w[1 2 3],
+      'filter_array_string' => %w[one two three],
+      'filter_int' => '42',
+      'filter_string' => 'forty-two'
+    }
+  end
+
+  def self.filterrific_params_after_sanitizing
+    {
+      'filter_proc' => 2,
+      'filter_array_int' => [1, 2, 3],
+      'filter_array_string' => %w[one two three],
+      'filter_int' => 42,
+      'filter_string' => 'forty-two'
+    }
+  end
+
+end
+
+# Simulates a class that would include the filterrific directive
+class ResourceClass
+
+  def self.filterrific_default_settings
+    TestData.filterrific_default_settings
+  end
+  def self.filterrific_filter_names
+    TestData.filterrific_filter_names
+  end
+
+end
+
+describe Filterrific::ParamSet do
+
+  let(:filterrific_param_set){
+    Filterrific::ParamSet.new(ResourceClass, TestData.filterrific_params)
+  }
+
+  describe "initialization" do
+
+    it "assigns resource class" do
+      filterrific_param_set.resource_class.should == ResourceClass
+    end
+
+    describe "dynamic filter_name attr_accessors" do
+
+      TestData.filterrific_filter_names.each do |filter_name|
+
+        it "defines a getter for '#{ filter_name }'" do
+          filterrific_param_set.should respond_to(filter_name)
+        end
+
+        it "defines a setter for '#{ filter_name }'" do
+          filterrific_param_set.should respond_to("#{ filter_name }=")
+        end
+
+      end
+
+      TestData.filterrific_params.keys.each do |key|
+
+        it "assigns sanitized param to '#{ key }' attr" do
+          filterrific_param_set.send(key).should == TestData.filterrific_params_after_sanitizing[key]
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "to_hash" do
+
+    it "returns all filterrific_params as hash" do
+      filterrific_param_set.to_hash.should == TestData.filterrific_params_after_sanitizing
+    end
+
+  end
+
+  describe "to_json" do
+
+    it "returns all filterrific_params as json string" do
+      filterrific_param_set.to_json.should == TestData.filterrific_params_after_sanitizing.to_json
+    end
+
+  end
+
+end