filter_me 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 48be03e95db1c79700cb86c0e4d7d5fc3bb0105f
+  data.tar.gz: 1dadc42cd98cf3c249139deff59d5bb381e02f93
+SHA512:
+  metadata.gz: 0176700ff8445af02e848c65c8ad4e9018bce1c863ad8dab7932d349c1a5574a67c68190a0e21f28eacf320d82ef6b27c2d7a3e6414ebe7d4c656600b153d764
+  data.tar.gz: ef3971291473338f4d2728d9fa99d11e12be7f78b3bc962da835567b2f64bea9ea6e728ba404aa3027dd10458395d18d2fefd3c72a48165fe17414f5d7089d15

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+spec/internal/db/*sqlite
+pkg/

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+script: bundle exec rspec spec
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENCE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Sam Clopton
+
+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,11 @@
+[![Code Climate](https://codeclimate.com/github/Samsinite/filter_me.png)](https://codeclimate.com/github/Samsinite/filter_me)
+filter_me
+=========
+
+A Rails/ActiveRecord filtering gem
+
+### Coming Soon to a application near you!
+
+
+## License
+Copyright (c) 2014, Filter Me is developed and maintained by Sam Clopton, and is released under the open MIT Licence.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+task :console do
+	require 'irb'
+	require 'irb/completion'
+	require 'filter_me' # You know what to do.
+	ARGV.clear
+	IRB.start
+end
+	

data/config.ru

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require :default, :development
+
+Combustion.initialize!
+run Combustion::Application

data/filter_me.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'filter_me/version'
+
+Gem::Specification.new do |s|
+	s.name        = 'filter_me'
+	s.version     = FilterMe::VERSION
+	s.authors     = ['Sam Clopton']
+	s.email       = ['samsinite@gmail.com']
+	s.homepage    = 'https://github.com/samsinite/filter_me'
+	s.summary     = 'Filter Me'
+	s.description = 'This friendly library gives you ActiveRecord/Arel filtering in your Rails app.'
+	s.license     = 'MIT'
+
+	s.files         = `git ls-files`.split("\n")
+	s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+	s.require_paths = ['lib']
+
+	s.add_runtime_dependency     'activerecord', '>= 3.2.0'
+	s.add_runtime_dependency     'activesupport', '>= 3.2.0'
+	#s.add_runtime_dependency     'activemodel', '>= 3.2.0'
+	s.add_development_dependency 'combustion',   '~> 0.5.1'
+	s.add_development_dependency 'rspec-rails',  '~> 2.13'
+	s.add_development_dependency 'sqlite3',      '~> 1.3.7'
+end

data/lib/filter_me/filter/arel_field_filter.rb

@@ -0,0 +1,51 @@
+module FilterMe
+	class Filter
+		class ArelFieldFilter
+			attr_accessor :filters, :configuration
+
+			def initialize(filters, configuration)
+				@filters = filters
+				@configuration = configuration
+
+				unless validator.valid_filters?(filters)
+					raise FiltersNotWhiteListedError, "The filter types #{validator.invalid_filters(filters)} are not allowed."
+				end
+			end
+
+			def filter(relation)
+				arel_filters.inject { |arel_relation, filter| filter.and(arel_relation) }
+			end
+
+			private
+
+			def arel_filters
+				self.filters.map { |filter_array| build_filters_from_filter_array(filter_array) }.flatten
+			end
+
+			def build_filters_from_filter_array(filter_array)
+				type = filter_array[0]
+				filter_array[1].map { |value| build_arel_filter(type, value) }
+			end
+
+			def build_arel_filter(type, value)
+				arel_filter = arel_table[field].send(type, value)
+			end
+
+			def arel_table
+				model_class.arel_table
+			end
+
+			def model_class
+				configuration[:model_class]
+			end
+
+			def validator
+				configuration[:validator]
+			end
+
+			def field
+				configuration[:field].to_sym
+			end
+		end
+	end
+end

data/lib/filter_me/filter/dsl.rb

@@ -0,0 +1,67 @@
+module FilterMe
+	class Filter
+
+		###
+		# DSL Syntax (early version, highly subject to change):
+		#
+		# class UserFilter < FilterMe::ArelFilter
+		#   model User
+		#
+		#   association :account
+		#   association :company, filter_class: SuperDuperCompanyFilter
+		#
+		#   field :login, [:matches]
+		#   field :created_at, [:gt, :gteq, :lt, :lteq, :eq]
+		#   field :email, :all
+		#   ...
+		# end
+		###
+		class ArelDSL
+			attr_reader :filter_class
+
+			extend Forwardable
+
+			def initialize(filter_class)
+				@filter_class = filter_class
+			end
+
+			def model(klass)
+				@filter_class._model = klass
+			end
+
+			def filter_for_name(name)
+				"#{name.to_s.pluralize.camelize}Filter".constantize
+			end
+
+			def field(name, filter_types)
+				field_validator = filter_types == :all ? AllValidator.new : FieldValidator.new(filter_types)
+				filter(name, ArelFieldFilter, { :field => name,
+				                                :validator => field_validator,
+				                                :model_class => self.filter_class._model })
+			end
+
+			def association(name, options={})
+				association_filter_class  = options.fetch(:filter_class) { filter_for_name(name) }
+				configuration = options.fetch(:configuration, {})
+				filter_class._associations[name] = association_filter_class
+
+				filter(name, association_filter_class, configuration, filter_class._model)
+			end
+
+			private
+
+			def filter(name, klass, configuration, association = nil)
+				this = self
+				filter_class.send(:define_method, name) do |relation, filters|
+					filter = klass.new(filters, configuration)
+					if association
+						relation = relation.joins(name.to_sym)
+						filter.filter(relation)
+					else
+						relation.where(filter.filter(relation))
+					end
+				end
+			end
+		end
+	end
+end

data/lib/filter_me/filter/field_validator.rb

@@ -0,0 +1,32 @@
+module FilterMe
+	class Filter
+		class AllValidator
+			def valid_filters?(filters)
+				true
+			end
+
+			def invalid_filters(filters)
+				[]
+			end
+
+			def whitelisted_filters
+				:all
+			end
+		end
+		class FieldValidator
+			attr_reader :whitelisted_filters
+
+			def initialize(whitelisted_filters)
+				@whitelisted_filters = whitelisted_filters
+			end
+
+			def valid_filters?(filters)
+				filters.all? { |filter| whitelisted_filters.include? filter[0] }
+			end
+
+			def invalid_filters(filters)
+				filters.select { |filter| !(whitelisted_filters.include? filter[0]) }
+			end
+		end
+	end
+end

data/lib/filter_me/filter.rb

@@ -0,0 +1,73 @@
+require "forwardable"
+
+require 'filter_me/filterable'
+require 'filter_me/filter/field_validator'
+require 'filter_me/filter/arel_field_filter'
+require 'filter_me/filter/dsl'
+
+module FilterMe
+	class ActiveRecordFilter
+		include Filterable
+
+		class << self
+			def inherited(subclass)
+				subclass._associations = (_associations || {}).dup
+			end
+
+			def filter_for(relation)
+				"#{relation.klass.name.pluralize}Filter".constantize
+			end
+
+			attr_accessor :_associations, :_model
+
+			extend Forwardable
+
+			def_delegators :dsl, :field, :association, :model
+
+			private
+
+			def dsl
+				@dsl ||= Filter::ArelDSL.new(self)
+			end
+		end
+
+		attr_accessor :configuration, :filters
+
+		# Filters are expected to be an array of arrays where the first value is 
+		# the filter type and the remaining values are the values to filter by. Or if the 
+		# filter type is a relation, the rest are sub filters (sub-array).
+		#
+		### Ex:
+		# class AccountsFilter < FilterMe::ActiveRecordFilter
+		#   model Account
+		#
+		#   field :type, [:matches, :eq, :not_eq]
+		# end
+		# class UsersFilter < FilterMe::ActiveRecordFilter
+		#   model User
+		#
+		#   association :account, :filter_class => AccountsFilter
+		#   field :username, [:matches, :eq, :not_eq]
+		# end
+		#
+		# then the 'filters' param for an initialization of a user filter which would then
+		# filter users by accounts of types that match '%paid%' would look like:
+		# [
+		#   # filters on the associaton account
+		#   [:account, [
+		#     [:type, [
+		#       [:matches, ["%paid%"]]
+		#     ]]
+		#   ]],
+		#   # filters on field username
+		#   [:username, [
+		#     [:not_eq, ["user1", "user2"]],
+		#     [:matches, ["%user_%"]]
+		#   ]]
+		# ]
+		def initialize(filters, configuration)
+			@filters = filters
+			@configuration = configuration
+		end
+	end
+end

data/lib/filter_me/filterable.rb

@@ -0,0 +1,9 @@
+module FilterMe
+	module Filterable
+		def filter(relation)
+			self.filters.inject(relation) do |relation, filter|
+				self.send filter[0], relation, filter[1]
+			end
+		end
+	end
+end

data/lib/filter_me/version.rb

@@ -0,0 +1,3 @@
+module FilterMe
+	VERSION = '0.1.0'
+end

data/lib/filter_me.rb

@@ -0,0 +1,88 @@
+require 'active_support/concern'
+
+require 'filter_me/filter'
+require 'filter_me/version'
+
+module FilterMe
+	class FiltersNotWhiteListedError < StandardError; end
+
+	extend ActiveSupport::Concern
+
+	class << self
+		def normalize_param(param)
+			param.inject([]) do |filter, (k, v)|
+				case v
+				when Hash
+					filter.push([k, FilterMe.normalize_param(v)])
+				when Array
+					filter.push([k, v])
+				else
+					filter.push([k, [v]])
+				end
+			end
+		end
+	end
+
+	included do
+		if respond_to?(:helper_method)
+			helper_method :filter_me
+		end
+
+		if respond_to?(:hide_action)
+			hide_action :filter_me
+			hide_action :filter_configuration
+			hide_action :build_filter
+			hide_action :filter_params
+		end
+	end
+
+	def filter_me(relation, filter_class=nil)
+		klass = filter_class || ActiveRecordFilter.filter_for(relation)
+		filter = build_filter(klass)
+
+		filter.filter(relation)
+	end
+
+	def filter_configuration
+		{}
+	end
+
+	def build_filter(filter_class)
+		filter_class.new(filter_params, filter_configuration)
+	end
+
+	# Normalized Filter params Example:
+	# [
+	#   # filters on the associaton account
+	#   [:account, [
+	#     [:type, [
+	#       [:eq, ["admin"]]
+    #     ]]
+	#   ]],
+	#   # filters on field username
+	#   [:username, [
+	#     [:not_in_any, ["sam", "samsinite"]],
+	#     [:matches, ["sam%"]]
+	#   ]],
+	#   [:company, [
+	#     [:job, [
+	#       [:name, [
+	#         [:matches, ["%software%"]]
+	#       ]]
+	#     ]]
+	#   ]]
+	# ]
+
+	# FilterMe default params example (Seems straight forward for Rails to parse):
+	#   {filters: {
+	#     username: {matches: "sam%", not_in_any: ["sam", "samsinite"]},
+	#     account: {type: {eq: "admin"}},
+	#     company: {job: {name: {matches: "%software%"}}}
+	#   }}
+	#
+	# Instead of Django Tastypie's style (original inspiration):
+	#   [{username__matches: "%sam%"}, {account__type__eq: "admin"}]
+	def filter_params
+		FilterMe.normalize_param(params.fetch(:filters, {}))
+	end
+end

data/spec/acceptance/filters/accounts_filter_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe AccountsFilter do
+	before(:each) do
+		load_accounts
+	end
+
+	let(:mock_controller_class) do
+		controller = Class.new do
+			include FilterMe
+
+			attr_accessor :params
+
+			def index 
+				filter_me(Account.all)
+			end
+		end
+	end
+
+	let(:mock_controller) do
+		mock_controller_class.new
+	end
+
+	it "returns all accounts without any filtering" do
+		mock_controller.params = {}
+
+		expect(mock_controller.index.length).to eq(Account.all.length)
+	end
+
+	it "returns accounts that cost less than 100000 and greater than 10000" do
+		mock_controller.params = {:filters => {
+			:cost => {:lt => 100000, :gt => 10000}
+		}}
+
+		mock_controller.index.each do |account|
+			expect(account.cost).to be > 10000
+			expect(account.cost).to be < 100000
+		end
+	end
+
+	it "returns accounts that cost less than or equal to 100000 and greater than 10000" do
+		mock_controller.params = {:filters => {
+			:cost => {:lteq => 100000, :gt => 10000}
+		}}
+
+		mock_controller.index.each do |account|
+			expect(account.cost).to be > 10000
+			expect(account.cost).to be <= 100000
+		end
+	end
+
+	it "returns accounts that cost less than 100000 and greater than or equal to 10000" do
+		mock_controller.params = {:filters => {
+			:cost => {:lt => 100000, :gteq => 10000}
+		}}
+
+		mock_controller.index.each do |account|
+			expect(account.cost).to be >= 10000
+			expect(account.cost).to be < 100000
+		end
+	end
+
+	it "returns accounts that cost less than or equal to 100000 and greater than or equal to 10000" do
+		mock_controller.params = {:filters => {
+			:cost => {:lteq => 100000, :gteq => 10000}
+		}}
+
+		mock_controller.index.each do |account|
+			expect(account.cost).to be >= 10000
+			expect(account.cost).to be <= 100000
+		end
+	end
+end

data/spec/acceptance/filters/users_filter_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe UsersFilter do
+	before(:each) do
+		load_users
+	end
+
+	let(:mock_controller_class) do
+		controller = Class.new do
+			include FilterMe
+
+			attr_accessor :params
+
+			def index 
+				filter_me(User.all)
+			end
+		end
+	end
+
+	let(:mock_controller) do
+		mock_controller_class.new
+	end
+
+	it "returns all users without any filtering" do
+		mock_controller.params = {}
+
+		expect(mock_controller.index.length).to eq(User.all.length)
+	end
+
+	it "returns users with e-mails from the domain test.com" do
+		mock_controller.params = {:filters => {
+			:email => {:matches => "%test.com"}
+		}}
+
+		mock_controller.index.each do |user|
+			expect(user.email).to end_with "test.com"
+		end
+	end
+
+	it "returns users with e-mails from the domain test.com with accounts that cost less than 100000" do
+		mock_controller.params = {:filters => {
+			:email => {:matches => "%test.com"},
+			:account => {:cost => {:lt => 100000}}
+		}}
+
+		mock_controller.index.each do |user|
+			expect(user.email).to end_with "test.com"
+			expect(user.account.cost).to be < 100000
+		end
+	end
+end

data/spec/internal/app/filters/accounts_filter.rb

@@ -0,0 +1,5 @@
+class AccountsFilter < FilterMe::ActiveRecordFilter
+	model Account
+
+	field :cost, [:lt, :lteq, :gt, :gteq, :eq]
+end

data/spec/internal/app/filters/users_filter.rb

@@ -0,0 +1,7 @@
+class UsersFilter < FilterMe::ActiveRecordFilter
+	model User
+
+	association :account, :filter_class => AccountsFilter
+	field :email, :all
+	field :username, :matches
+end

data/spec/internal/app/models/account.rb

@@ -0,0 +1,3 @@
+class Account < ActiveRecord::Base
+	belongs_to :user
+end

data/spec/internal/app/models/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+	has_one :account
+end

data/spec/internal/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: db/combustion_test.sqlite

data/spec/internal/db/fixtures/accounts.rb

@@ -0,0 +1,17 @@
+module Fixtures
+	module Accounts
+		def load_accounts
+			Account.create! do |account|
+				account.cost = 10000
+			end
+
+			Account.create! do |account|
+				account.cost = 50000
+			end
+
+			Account.create! do |account|
+				account.cost = 100000
+			end
+		end
+	end
+end

data/spec/internal/db/fixtures/users.rb

@@ -0,0 +1,26 @@
+module Fixtures
+	module Users
+		def load_users
+			User.create! do |user|
+				user.username = "test1"
+				user.email = "test2@test.com"
+
+				user.create_account!(:cost => 100000)
+			end
+
+			User.create! do |user|
+				user.username = "test2"
+				user.email = "test2@test.com"
+
+				user.create_account!(:cost => 50000)
+			end
+
+			User.create! do |user|
+				user.username = "test3"
+				user.email = "test3@spaz.com"
+
+				user.create_account!(:cost => 10000)
+			end
+		end
+	end
+end

data/spec/internal/db/schema.rb

@@ -0,0 +1,13 @@
+ActiveRecord::Schema.define do
+	create_table :users, :force => true do |t|
+		t.string :username
+		t.string :email
+		t.timestamps
+	end
+
+	create_table :accounts, :force => true do |t|
+		t.integer :user_id
+		t.integer :cost
+		t.timestamps
+	end
+end

data/spec/internal/log/.gitignore

@@ -0,0 +1 @@
+*.log

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'combustion'
+
+Bundler.require :default, :development
+
+# Add rails modules here to have combustion load:
+Combustion.initialize! :active_record
+
+require 'rspec/rails'
+
+# Load fixture helpers for testing
+Dir[File.join(File.dirname(__FILE__), 'internal', 'db', "fixtures", "**", '*.rb')].each { |file| require file }
+
+RSpec.configure do |config|
+	config.use_transactional_fixtures = true
+
+	config.include Fixtures::Accounts
+	config.include Fixtures::Users
+end

data/spec/unit/active_record_filter_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe FilterMe::ActiveRecordFilter do
+	let(:filters) do
+		[
+			# filters on associaton account
+			[:account, [
+				[:type, [
+					[:matches, ["%paid%"]]
+				]]
+			]],
+			# filters on field username
+			[:username, [
+				[:not_eq, ["user1", "user2"]],
+				[:matches, ["%user_%"]]
+			]]
+		]
+	end
+
+	it "calls each filter method for every filter it is passed" do
+		relation_mock = double("relation")
+		model_filter = FilterMe::ActiveRecordFilter.new(filters, {})
+
+		expect(model_filter).to receive(:account).with(relation_mock, filters[0][1]) { relation_mock }
+		expect(model_filter).to receive(:username).with(relation_mock, filters[1][1]) { relation_mock }
+		model_filter.filter(relation_mock)
+	end
+end

data/spec/unit/arel_field_filter_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe FilterMe::Filter::ArelFieldFilter do
+	context "with only greater than and less than allowed" do
+		let(:field) { :test }
+		let(:arel_table) do
+			Arel::Table.new("model")
+		end
+
+		let(:filters) { [:lt, :gt] }
+
+		let(:model_class) do
+			model = double("model")
+			allow(model).to receive(:arel_table) { arel_table }
+
+			model
+		end
+
+		let(:configuration) do
+			{
+				:field => field,
+				:model_class => model_class,
+				:validator => FilterMe::Filter::FieldValidator.new(filters)
+			}
+		end
+
+		it "can create an arel field filter with a less than filter" do
+			field_filter = FilterMe::Filter::ArelFieldFilter.new([[:lt, [10]]], configuration)
+		end
+
+		it "can create an arel field filter with a greater than filter" do
+			field_filter = FilterMe::Filter::ArelFieldFilter.new([[:gt, [10]]], configuration)
+		end
+
+		it "can create an arel field filter with a greater than and less than filter" do
+			field_filter = FilterMe::Filter::ArelFieldFilter.new([[:gt, [10]], [:lt, [20]]], configuration)
+		end
+
+		it "cannot create an arel field filter with a equal filter" do
+			expect { FilterMe::Filter::ArelFieldFilter.new([[:eq, [10]]], configuration) }.to raise_error
+		end
+	end
+	context "with all types allowed" do
+		let(:field) { :test }
+		let(:arel_table) do
+			Arel::Table.new("model")
+		end
+
+		let(:model_class) do
+			model = double("model")
+			allow(model).to receive(:arel_table) { arel_table }
+
+			model
+		end
+
+		let(:configuration) do
+			{
+				:field => field,
+				:model_class => model_class,
+				:validator => FilterMe::Filter::AllValidator.new
+			}
+		end
+
+		it "can create a arel field filter" do
+			field_filter = FilterMe::Filter::ArelFieldFilter.new([[:lt, [10]], [:gt, [1]]], configuration)
+		end
+
+		it "builds the correct arel filter with one filter type of one filter value" do
+			field_filter = FilterMe::Filter::ArelFieldFilter.new([[:lt, [10]]], configuration)
+			relation_mock = double("relation")
+
+			arel_filter = arel_table[field].lt(10)
+			expect(field_filter.filter(relation_mock)).to eq(arel_filter)
+		end
+
+		it "builds the correct arel filter with one filter type of two filter values" do
+			field_filter = FilterMe::Filter::ArelFieldFilter.new([[:matches, ["%hi%", "%hey%"]]], configuration)
+			relation_mock = double("relation")
+
+			arel_filter = arel_table[field].matches("%hey%").and(arel_table[field].matches("%hi%"))
+			expect(field_filter.filter(relation_mock)).to eq(arel_filter)
+		end
+
+		it "builds the correct arel filter with two filter types of one filter value each" do
+			field_filter = FilterMe::Filter::ArelFieldFilter.new([[:gt, [1]], [:lt, [10]]], configuration)
+			relation_mock = double("relation")
+
+			arel_filter = arel_table[field].lt(10).and(arel_table[field].gt(1))
+			expect(field_filter.filter(relation_mock)).to eq(arel_filter)
+		end
+
+		it "builds the correct arel filter with two filter types of two filter value each" do
+			field_filter = FilterMe::Filter::ArelFieldFilter.new([[:matches, ["%hi%", "%hey%"]], [:lt, ["z", "Z"]]], configuration)
+			relation_mock = double("relation")
+
+			arel_filter = arel_table[field].lt("Z")
+			                               .and(arel_table[field].lt("z")
+			                               .and(arel_table[field].matches("%hey%")
+			                               .and(arel_table[field].matches("%hi%"))))
+			expect(field_filter.filter(relation_mock)).to eq(arel_filter)
+		end
+	end
+end

data/spec/unit/filter_arel_dsl_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe FilterMe::Filter::ArelDSL do
+	it "creates a new arel field filter method named after the field" do
+		model = double("model")
+		filter_class = double("filter_class")
+		filter_class.stub(:_model).and_return(model)
+		filter_class.should_receive(:define_method) do |name, &block|
+			name.should eq(:test)
+			block.should_not be_nil
+		end
+
+		dsl = FilterMe::Filter::ArelDSL.new(filter_class)
+		dsl.field(:test, [:gt, :lt, :eq])
+	end
+
+	context "after defining a field filter the dynamically created filter method" do
+		it "initializes a ArelFieldFilter instance with the values to filter and the filter field configuration" do
+			filters = [:test1, :test2]
+			relation_mock = double("relation")
+			expect(relation_mock).to receive(:where) { |relation| relation }
+			
+			model_mock = double("model")
+
+			FilterMe::Filter::FieldValidator.send(:define_method, "==") do |obj|
+				obj.whitelisted_filters == self.whitelisted_filters
+			end
+
+			field_filter_instance = double("field filter instance")
+			allow(field_filter_instance).to receive(:filter).once
+
+			field_filter_class = double("field filter class")
+			allow(field_filter_class).to receive(:new) do |filters, configuration|
+				expect(filters).to eq(filters)
+				expect(configuration).to eq({
+					:field => :test,
+					:validator => FilterMe::Filter::FieldValidator.new([:gt, :lt, :eq]),
+					:model_class => model_mock
+				})
+
+				field_filter_instance
+			end
+
+			stub_const("FilterMe::Filter::ArelFieldFilter", field_filter_class)
+
+			# We just need an object that supports and implements #define_method so the 
+			# dynamic filter method can be created.
+			filter_class = Class.new do
+			end
+
+			allow(filter_class).to receive(:_model) { model_mock }
+
+			dsl = FilterMe::Filter::ArelDSL.new(filter_class)
+			dsl.field(:test, [:gt, :lt, :eq])
+
+			filter_instance = filter_class.new
+			filter_instance.test(relation_mock, filters)
+		end
+
+		it "calls filter on the initialized ArelFieldFilter instance with the relation" do
+			relation_mock = double("relation")
+			expect(relation_mock).to receive(:where) { |relation| relation }
+
+			model_mock = double("model")
+
+			field_filter_instance = double("field filter instance")
+			expect(field_filter_instance).to receive(:filter) { |relation| relation }
+
+			field_filter_class = double("field filter class")
+			allow(field_filter_class).to receive(:new) { |filters, configuration| field_filter_instance }
+
+			stub_const("FilterMe::Filter::ArelFieldFilter", field_filter_class)
+
+			# We just need an object that supports and implements #define_method so the 
+			# dynamic filter method can be created.
+			filter_class = Class.new do
+			end
+
+			allow(filter_class).to receive(:_model) { model_mock }
+
+			dsl = FilterMe::Filter::ArelDSL.new(filter_class)
+			dsl.field(:test, [:gt, :lt, :eq])
+
+			filter_instance = filter_class.new
+
+			expect(filter_instance.test(relation_mock, [:test1, :test2])).to eq(relation_mock)
+		end
+	end
+
+
+	it "creates a new arel relation filter method named after the association" do
+		model = double("model")
+		filter_class = double("filter_class")
+		filter_class.stub(:_model).and_return(model)
+		filter_class.stub(:_associations).and_return({})
+		filter_class.should_receive(:define_method) do |name, &block|
+			name.should eq(:some_models)
+			block.should_not be_nil
+		end
+
+		dsl = FilterMe::Filter::ArelDSL.new(filter_class)
+		dsl.association(:some_models, {:filter_class => filter_class})
+	end
+
+	context "after defining an association filter the dynamically created filter method" do
+		it "initializes the association filter instance with the values to filter and the filter configuration" do
+			filters = [:test1, :test2]
+			relation_mock = double("relation")
+			allow(relation_mock).to receive(:joins) { relation_mock }
+			allow(relation_mock).to receive(:where) { relation_mock }
+
+			model = double("model")
+			allow(model).to receive(:name) { "Model" }
+
+			mock_association_filter = double("association filter")
+			allow(mock_association_filter).to receive(:filter) { relation_mock }
+
+			mock_association_filter_class = double("assocation filter class")
+			mock_association_filter_class.stub(:new).and_return(mock_association_filter)
+
+			expect(mock_association_filter_class).to receive(:new) do |filters, configuration| 
+				expect(filters).to eq(filters)
+				expect(configuration).to eq({})
+				mock_association_filter 
+			end
+
+			allow(mock_association_filter_class).to receive(:define_method) do |name, &block|
+				allow(mock_association_filter).to receive(name, &block)
+			end
+
+			mock_association_filter_class.stub(:_model).and_return(model)
+
+			# We just need an object that supports and implements #define_method so the 
+			# dynamic filter method can be created.
+			filter_class = Class.new do
+			end
+
+			allow(filter_class).to receive(:_model) { model }
+			allow(filter_class).to receive(:_associations) { {} }
+
+			dsl = FilterMe::Filter::ArelDSL.new(filter_class)
+			dsl.association(:test, {:filter_class => mock_association_filter_class})
+
+			filter_instance = filter_class.new
+			filter_instance.test(relation_mock, filters)
+		end
+
+		it "calls filter on the association filter instance with the relation" do
+			filters = [:test1, :test2]
+			relation_mock = double("relation")
+			allow(relation_mock).to receive(:joins) { relation_mock }
+			allow(relation_mock).to receive(:where) { relation_mock }
+
+			model = double("model")
+			allow(model).to receive(:name) { "Model" }
+
+			mock_association_filter = double("association filter")
+			expect(mock_association_filter).to receive(:filter) do |relation|
+				expect(relation).to eq(relation_mock)
+
+				relation
+			end
+			mock_association_filter_class = double("assocation filter class")
+
+			mock_association_filter_class.stub(:new).and_return(mock_association_filter)
+
+			mock_association_filter_class.stub(:_model).and_return(model)
+			allow(mock_association_filter_class).to receive(:define_method) do |name, &block|
+				allow(mock_association_filter).to receive(name, &block)
+			end
+
+			# We just need an object that supports and implements #define_method so the 
+			# dynamic filter method can be created.
+			filter_class = Class.new do
+			end
+
+			allow(filter_class).to receive(:_model) { model }
+			allow(filter_class).to receive(:_associations) { {} }
+
+			dsl = FilterMe::Filter::ArelDSL.new(filter_class)
+			dsl.association(:test, {:filter_class => mock_association_filter_class})
+
+			filter_instance = filter_class.new
+			filter_instance.test(relation_mock, filters)
+		end
+	end
+end

data/spec/unit/filter_me_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe FilterMe do
+	let(:class_with_module) do
+		Class.new do
+			include FilterMe
+
+			attr_accessor params
+		end
+	end
+
+	it "should normalize field params correctly" do
+		username_field_params = {:matches => "sam%", :not_in_any => ["sam", "samsinite"]}
+		username_params_normalized = [
+			[:matches, ["sam%"]],
+			[:not_in_any, ["sam", "samsinite"]]
+		]
+
+		expect(FilterMe.normalize_param(username_field_params)).to eq(username_params_normalized)
+	end
+
+	it "should normalize shallow association params correctly" do
+		account_association_params = {:type => {:eq => "admin"}}
+		account_params_normalized = [[:type, [
+			[:eq, ["admin"]]
+		]]]
+
+		expect(FilterMe.normalize_param(account_association_params)).to eq(account_params_normalized)
+	end
+
+	it "should normalize deeply nested association params correctly" do
+		company_association_with_nested_job_association_params = {:job => {:name => {:matches => "%software%"}}}
+		company_params_normalized = [[:job, [
+			[:name, [
+				[:matches, ["%software%"]]
+			]]
+			]]]
+
+		expect(FilterMe.normalize_param(company_association_with_nested_job_association_params)).to eq(company_params_normalized)
+	end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: filter_me
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sam Clopton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.7
+description: This friendly library gives you ActiveRecord/Arel filtering in your Rails
+  app.
+email:
+- samsinite@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENCE
+- README.md
+- Rakefile
+- config.ru
+- filter_me.gemspec
+- lib/filter_me.rb
+- lib/filter_me/filter.rb
+- lib/filter_me/filter/arel_field_filter.rb
+- lib/filter_me/filter/dsl.rb
+- lib/filter_me/filter/field_validator.rb
+- lib/filter_me/filterable.rb
+- lib/filter_me/version.rb
+- spec/acceptance/filters/accounts_filter_spec.rb
+- spec/acceptance/filters/users_filter_spec.rb
+- spec/internal/app/filters/accounts_filter.rb
+- spec/internal/app/filters/users_filter.rb
+- spec/internal/app/models/account.rb
+- spec/internal/app/models/user.rb
+- spec/internal/config/database.yml
+- spec/internal/db/fixtures/accounts.rb
+- spec/internal/db/fixtures/users.rb
+- spec/internal/db/schema.rb
+- spec/internal/log/.gitignore
+- spec/spec_helper.rb
+- spec/unit/active_record_filter_spec.rb
+- spec/unit/arel_field_filter_spec.rb
+- spec/unit/filter_arel_dsl_spec.rb
+- spec/unit/filter_me_spec.rb
+homepage: https://github.com/samsinite/filter_me
+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: Filter Me
+test_files: []