filter_factory 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.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

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in filter_factory.gemspec
+gemspec
+
+gem 'rails', '>= 3.0'
+
+group :development do
+  gem 'mongoid', '>= 3.0'
+  gem 'mysql2'
+end
+
+group :test do
+  gem 'rspec'
+  gem 'database_cleaner'
+  gem 'factory_girl'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Hck
+
+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,66 @@
+# FilterFactory
+
+FilterFactory allows you to easily fetch ActiveRecord/Mongoid models that match specified filters.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'filter_factory'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install filter_factory
+
+## Usage
+
+Describe your filter:
+
+    @filter = FilterFactory.create do
+      # filter field definition: field name for ActiveRecord/Mongoid model, filter type
+      field :title, :regex
+      field :author, :eq
+      field :views, :gte
+      # ...
+    end
+
+Render form as you want in your view:
+
+    <%= form_for @filter, as: :filter do |f| %>
+    <div>
+        <%= f.label :title %>
+        <br/>
+        <%= f.text_field %>
+    </div>
+    <div>
+        <%= f.label :author %>
+        <br/>
+        <%= f.select Author.all.map{|r| [r.name, r.id]} %>
+    </div>
+    <div>
+        <%= f.label :views %>
+        <br/>
+        <%= f.number_field :views %>
+    </div>
+    <div class="actions">
+        <%= f.submit "Filter" %>
+    </div>
+    <% end %>
+
+Filter your models in controller:
+
+    @filter.attributes(params[:filter]) # update filter with values supplied from the form
+
+    @posts = Post.filter(@filter) # fetch records that match specified filters
+
+## 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

data/Rakefile

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

data/filter_factory.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'filter_factory/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "filter_factory"
+  gem.version       = FilterFactory::VERSION
+  gem.authors       = ["Hck"]
+  gem.description   = %q{Gem for easy ActiveRecord/Mongoid models filtering}
+  gem.summary       = %q{FilterFactory allows you to easily fetch ActiveRecord/Mongoid models that match specified filters.}
+  gem.homepage      = "https://github.com/hck/filter_factory"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/filter_factory/active_record/condition.rb

@@ -0,0 +1,53 @@
+module FilterFactory
+  module ActiveRecord
+    class Condition < FilterFactory::Condition
+      def eq(obj)
+        obj.where(field_name => value)
+      end
+
+      def ne(obj)
+        obj.where("#{field_name} != ?", value)
+      end
+
+      def lt(obj)
+        obj.where("#{field_name} < ?", value)
+      end
+
+      def lte(obj)
+        obj.where("#{field_name} <= ?", value)
+      end
+
+      def gt(obj)
+        obj.where("#{field_name} > ?", value)
+      end
+
+      def gte(obj)
+        obj.where("#{field_name} >= ?", value)
+      end
+
+      def all(obj)
+        raise NotImplementedError, "all operator is not available for ActiveRecord"
+      end
+
+      def in(obj)
+        obj.where("#{field_name} IN (?)", value)
+      end
+
+      def nin(obj)
+        obj.where("#{field_name} NOT IN (?)", value)
+      end
+
+      def regex(obj)
+        obj.where("#{field_name} REGEXP ?", value)
+      end
+
+      def exists(obj)
+        raise NotImplementedError, "all operator is not available for ActiveRecord"
+      end
+
+      def presents(obj)
+        obj.where("(#{field_name} IS NOT NULL) = ?", value)
+      end
+    end
+  end
+end

data/lib/filter_factory/active_record/filter.rb

@@ -0,0 +1,17 @@
+module FilterFactory
+  module ActiveRecord
+    module Filter
+      def filter(filter_object)
+        conditions = filter_object.filled_fields.map do |field|
+          FilterFactory::ActiveRecord::Condition.new(field.name, field.value).method(field.condition)
+        end
+
+        conditions.inject(nil) do |res,condition|
+          res ? res.instance_eval(&condition) : instance_eval(&condition)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, FilterFactory::ActiveRecord::Filter) if defined?(ActiveRecord::Base)

data/lib/filter_factory/condition.rb

@@ -0,0 +1,9 @@
+module FilterFactory
+  class Condition
+    attr_reader :field_name, :value
+
+    def initialize(field_name, value)
+      @field_name, @value = field_name, value
+    end
+  end
+end

data/lib/filter_factory/field.rb

@@ -0,0 +1,10 @@
+module FilterFactory
+  class Field
+    attr_reader :name, :condition, :options
+    attr_accessor :value
+
+    def initialize(name, condition, options = {})
+      @name, @condition, @options = name, condition, options
+    end
+  end
+end

data/lib/filter_factory/filter.rb

@@ -0,0 +1,52 @@
+require 'active_model'
+
+module FilterFactory
+  class Filter
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
+
+    attr_reader :fields
+
+    def initialize
+      @fields = []
+    end
+
+    def attributes
+      @fields.inject(HashWithIndifferentAccess.new) do |acc,field|
+        acc[field.name] = field.value
+        acc
+      end
+    end
+
+    def attributes=(attributes = {})
+      return unless attributes
+      attributes.each do |name, value|
+        public_send("#{name}=", value)
+      end
+    end
+
+    def filled_fields
+      fields.select{|f| !f.value.nil? && f.value != ''}
+    end
+
+    def persisted?
+      false
+    end
+
+    private
+    def field(name, condition)
+      Field.new(name, condition).tap do |field|
+        define_singleton_method(name){ field.value }
+        define_singleton_method("#{name}="){|val| field.value = val }
+
+        @fields << field
+      end
+    end
+
+    class << self
+      def create &block
+        new.tap{|filter| filter.instance_eval &block}
+      end
+    end
+  end
+end

data/lib/filter_factory/mongoid/condition.rb

@@ -0,0 +1,53 @@
+module FilterFactory
+  module Mongoid
+    class Condition < FilterFactory::Condition
+      def eq(obj)
+        obj.where(field_name => value)
+      end
+
+      def ne(obj)
+        obj.where(field_name => {'$ne' => value})
+      end
+
+      def lt(obj)
+        obj.where(field_name => {'$lt' => value})
+      end
+
+      def lte(obj)
+        obj.where(field_name => {'$lte' => value})
+      end
+
+      def gt(obj)
+        obj.where(field_name => {'$gt' => value})
+      end
+
+      def gte(obj)
+        obj.where(field_name => {'$gte' => value})
+      end
+
+      def all(obj)
+        obj.where(field_name => {'$all' => value})
+      end
+
+      def in(obj)
+        obj.where(field_name => {'$in' => value})
+      end
+
+      def nin(obj)
+        obj.where(field_name => {'$nin' => value})
+      end
+
+      def regex(obj)
+        obj.where(field_name => /#{Regexp.escape(value)}/)
+      end
+
+      def exists(obj)
+        obj.where(field_name => {'$exists' => value})
+      end
+
+      def presents(obj)
+        ['true', '1', 1].include?(value) ? obj.where(field_name => {'$nin' => [nil, '', []]}) : obj.where(field_name => {'$in' => [nil, '', []]})
+      end
+    end
+  end
+end

data/lib/filter_factory/mongoid/filter.rb

@@ -0,0 +1,23 @@
+module FilterFactory
+  module Mongoid
+    module Filter
+      def filter(filter_object)
+        conditions = filter_object.filled_fields.map do |field|
+          FilterFactory::Mongoid::Condition.new(field.name, field.value).method(field.condition)
+        end
+
+        conditions.inject(nil) do |res,condition|
+          res ? res.instance_eval(&condition) : instance_eval(&condition)
+        end || self
+      end
+    end
+  end
+end
+
+if defined?(Mongoid::Document)
+  Mongoid::Document.module_eval do
+    def self.included(base)
+      base.extend FilterFactory::Mongoid::Filter
+    end
+  end
+end

data/lib/filter_factory/version.rb

@@ -0,0 +1,3 @@
+module FilterFactory
+  VERSION = "0.0.1"
+end

data/lib/filter_factory.rb

@@ -0,0 +1,17 @@
+require "filter_factory/version"
+
+require "filter_factory/condition"
+require "filter_factory/field"
+require "filter_factory/filter"
+
+require "filter_factory/active_record/condition"
+require "filter_factory/active_record/filter"
+
+require "filter_factory/mongoid/condition"
+require "filter_factory/mongoid/filter"
+
+module FilterFactory
+  def self.create &block
+    FilterFactory::Filter.create &block
+  end
+end

data/spec/factories/factories.rb

@@ -0,0 +1,15 @@
+FactoryGirl.define do
+  factory :mongoid_post, class: MPost do
+    sequence(:title) {|n| "post_#{n}"}
+    sequence(:author) {|n| "author_#{n}"}
+    sequence(:views) {|n| n}
+    #views {rand(0..1000)}
+  end
+
+  factory :active_record_post, class: ARPost do
+    sequence(:title) {|n| "post_#{n}"}
+    sequence(:author) {|n| "author_#{n}"}
+    sequence(:views) {|n| n}
+    #views {rand(0..1000)}
+  end
+end

data/spec/filter_factory/active_record/model_spec.rb

@@ -0,0 +1,157 @@
+require "spec_helper"
+
+describe ARPost do
+  before(:each) do
+    @posts = FactoryGirl.create_list(:active_record_post, 10)
+  end
+
+  it "should respond to ::filter method" do
+    described_class.should respond_to(:filter)
+  end
+
+  it "should execute filter methods chain" do
+    filter = FilterFactory.create do
+      field :title, :eq
+      field :author, :eq
+      field :views, :gte
+    end
+
+    sample = @posts.sample
+
+    filter.title = sample.title
+    filter.author = sample.author
+
+    described_class.filter(filter).to_a.should == [sample]
+  end
+
+  it "should return records with column' values equal to specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :id,  :eq
+    end
+    filter.id = sample.id
+
+    described_class.filter(filter).to_a.should == [sample]
+  end
+
+  it "should return records with column' values not equal specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :id,  :ne
+    end
+    filter.id = sample.id
+
+    described_class.filter(filter).to_a.sort.should == @posts.reject{|p| p.id == sample.id}
+  end
+
+  it "should return records with column' values less than specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :views,  :lt
+    end
+    filter.views = sample.views
+
+    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views < sample.views}.map(&:id).sort
+  end
+
+  it "should return records with column' values less than or equal to specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :views,  :lte
+    end
+    filter.views = sample.views
+
+    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views <= sample.views}.map(&:id).sort
+  end
+
+  it "should return records with column' values greater than specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :views,  :gt
+    end
+    filter.views = sample.views
+
+    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views > sample.views}.map(&:id).sort
+  end
+
+  it "should return records with column' values greater than or equal to specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :views,  :gte
+    end
+    filter.views = sample.views
+
+    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views >= sample.views}.map(&:id).sort
+  end
+
+  it "should raise NotImplementedError if using 'all' condition" do
+    filter = FilterFactory.create do
+      field :opts,  :all
+    end
+    filter.opts = [1, 2, 3, 4]
+
+    expect {described_class.filter(filter)}.to raise_error(NotImplementedError)
+  end
+
+  it "should return records with column' values in specified values" do
+    sample = @posts.sample(3)
+
+    filter = FilterFactory.create do
+      field :id,  :in
+    end
+    filter.id = sample.map(&:id)
+
+    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+  end
+
+  it "should return records with column' values not in specified values" do
+    sample = @posts.sample(3)
+
+    filter = FilterFactory.create do
+      field :id,  :nin
+    end
+    filter.id = sample.map(&:id)
+
+    described_class.filter(filter).map(&:id).sort.should == (@posts.map(&:id) - sample.map(&:id)).sort
+  end
+
+  it "should return records with column' values which match the specified regexp" do
+    sample = @posts.sample(3)
+    sample.each_with_index{|r,i| r.update_attribute(:title, "my_title_#{i}")}
+
+    filter = FilterFactory.create do
+      field :title,  :regex
+    end
+
+    filter.title = '_title_'
+
+    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+  end
+
+  it "should raise NotImplementedError if using 'exists' condition" do
+    filter = FilterFactory.create do
+      field :not_exists, :exists
+    end
+    filter.not_exists = true
+
+    expect {described_class.filter(filter)}.to raise_error(NotImplementedError)
+  end
+
+  it "should return records with column' values not nil equal to specified value" do
+    sample = @posts.sample(3)
+    sample.each{|r| r.update_attribute(:title, nil)}
+
+    filter = FilterFactory.create do
+      field :title,  :presents
+    end
+    filter.title = false
+
+    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+  end
+end

data/spec/filter_factory/filter_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+
+describe FilterFactory::Filter do
+  it "should create filter and execute block" do
+    test_fields = [[:field1, :eq], [:field2, :eq], [:field3, :eq]]
+
+    filter = described_class.create do
+      test_fields.each do |arr|
+        field *arr
+      end
+    end
+
+    filter.should be_a(described_class)
+
+    filter.fields.map{|f| [f.name, f.condition]}.should == test_fields
+  end
+
+  it "should define singleton method for defined field" do
+    filter = described_class.create do
+      field :name, :eq
+    end
+
+    filter.should respond_to(:name, :'name=')
+  end
+
+  it "should get field value" do
+    filter = described_class.create do
+      field :name, :eq
+    end
+
+    filter.fields.first.value = "sample name"
+    filter.name.should == "sample name"
+  end
+
+  it "should set field value" do
+    filter = described_class.create do
+      field :name, :eq
+    end
+
+    filter.name = "sample name"
+    filter.fields.first.value.should == "sample name"
+  end
+
+  it "should respond_to attributes & attributes= methods" do
+    filter = described_class.create do
+      field :name, :eq
+    end
+
+    filter.should respond_to(:attributes, :attributes=)
+  end
+
+  it "should return valid attributes" do
+    filter = described_class.create do
+      field :name, :eq
+      field :surname, :regex
+    end
+    filter.name = "test name"
+
+    filter.attributes.should == HashWithIndifferentAccess.new({name: "test name", surname: nil})
+  end
+
+  it "should fill filter values from hash" do
+    filter = described_class.create do
+      field :name, :eq
+      field :surname, :regex
+    end
+
+    attributes = {name: "my test name", surname: "surname here"}
+    filter.attributes = attributes
+    filter.attributes.should == HashWithIndifferentAccess.new(attributes)
+  end
+
+  #describe "#conditions" do
+  #  it "should return result of query method for each of the condition as a Method object" do
+  #    filter = described_class.create do
+  #      field :name, :eq
+  #    end
+  #
+  #    filter.name = "sample name"
+  #    filter.conditions.first.should be_a(Method)
+  #  end
+  #end
+end

data/spec/filter_factory/mongoid/model_spec.rb

@@ -0,0 +1,152 @@
+require "spec_helper"
+
+describe MPost do
+  before(:each) do
+    @posts = FactoryGirl.create_list(:mongoid_post, 10)
+  end
+
+  it "should respond to ::filter method" do
+    described_class.should respond_to(:filter)
+  end
+
+  it "should execute filter methods chain" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :title,  :eq
+      field :author, :eq
+      field :views,  :gte
+    end
+
+    filter.title = sample.title
+    filter.author = sample.author
+
+    described_class.filter(filter).to_a.should == [sample]
+  end
+
+  it "should return records with column' values equal to specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :id,  :eq
+    end
+    filter.id = sample.id
+
+    described_class.filter(filter).to_a.should == [sample]
+  end
+
+  it "should return records with column' values not equal specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :id,  :ne
+    end
+    filter.id = sample.id
+
+    described_class.filter(filter).to_a.sort.should == @posts.reject{|p| p.id == sample.id}
+  end
+
+  it "should return records with column' values less than specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :views,  :lt
+    end
+    filter.views = sample.views
+
+    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views < sample.views}.map(&:id).sort
+  end
+
+  it "should return records with column' values less than or equal to specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :views,  :lte
+    end
+    filter.views = sample.views
+
+    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views <= sample.views}.map(&:id).sort
+  end
+
+  it "should return records with column' values greater than specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :views,  :gt
+    end
+    filter.views = sample.views
+
+    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views > sample.views}.map(&:id).sort
+  end
+
+  it "should return records with column' values greater than or equal to specified value" do
+    sample = @posts.sample
+
+    filter = FilterFactory.create do
+      field :views,  :gte
+    end
+    filter.views = sample.views
+
+    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views >= sample.views}.map(&:id).sort
+  end
+
+  it "should return records with column' values all equal to specified value" do
+    sample = @posts.sample(2)
+    sample.each{|r| r.update_attribute(:opts, [1, 2, 3, 4])}
+
+    filter = FilterFactory.create do
+      field :opts,  :all
+    end
+    filter.opts = [1, 2, 3, 4]
+
+    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+  end
+
+  it "should return records with column' values in specified values" do
+    sample = @posts.sample(3)
+
+    filter = FilterFactory.create do
+      field :id,  :in
+    end
+    filter.id = sample.map(&:id)
+
+    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+  end
+
+  it "should return records with column' values not in specified values" do
+    sample = @posts.sample(3)
+
+    filter = FilterFactory.create do
+      field :id,  :nin
+    end
+    filter.id = sample.map(&:id)
+
+    described_class.filter(filter).map(&:id).sort.should == (@posts.map(&:id) - sample.map(&:id)).sort
+  end
+
+  it "should return records with column' values which match the specified regexp" do
+    sample = @posts.sample(3)
+    sample.each_with_index{|r,i| r.update_attribute(:title, "my_title_#{i}")}
+
+    filter = FilterFactory.create do
+      field :title,  :regex
+    end
+
+    filter.title = '_title_'
+
+    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+  end
+
+  it "should return records with existing column' values" do
+    sample = @posts.sample(3)
+    sample.each{|r| r.update_attribute(:not_exists, rand(0..25))}
+
+    filter = FilterFactory.create do
+      field :not_exists, :exists
+    end
+
+    filter.not_exists = true
+
+    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+  end
+end

data/spec/models/ar_post.rb

@@ -0,0 +1,2 @@
+class ARPost < ActiveRecord::Base
+end

data/spec/models/m_post.rb

@@ -0,0 +1,9 @@
+class MPost
+  include Mongoid::Document
+
+  field :title,  type: String
+  field :author, type: String
+  field :views,  type: Integer
+  field :opts,   type: Array
+  field :not_exists, type: Boolean
+end

data/spec/spec_helper.rb

@@ -0,0 +1,57 @@
+MODELS = File.join(File.dirname(__FILE__), 'models')
+
+require 'rubygems'
+
+require 'mongoid'
+require 'active_record'
+require 'database_cleaner'
+require 'factory_girl'
+
+require 'filter_factory'
+
+Dir["#{MODELS}/*.rb"].each { |f| require f }
+
+Mongoid.configure do |config|
+  config.connect_to 'mongoid_filter_factory_test'
+end
+#Mongoid.logger = Logger.new($stdout)
+#Moped.logger = Logger.new($stdout)
+
+ActiveRecord::Base.establish_connection(
+  adapter: "mysql2",
+  database: "active_record_filter_factory_test"
+)
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS ar_posts")
+ActiveRecord::Base.connection.create_table(:ar_posts) do |t|
+  t.string :title
+  t.string :author
+  t.integer :views
+end
+#ActiveRecord::Base.logger = Logger.new($stdout)
+#ActiveRecord::Base.logger.level = Logger::DEBUG
+
+FactoryGirl.definition_file_paths = [File.join(File.dirname(__FILE__), 'factories')]
+FactoryGirl.find_definitions
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.color_enabled = true
+
+  config.before(:suite) do
+    mongoid = DatabaseCleaner[:mongoid]
+    mongoid.strategy = :truncation
+    mongoid.clean_with(:truncation)
+
+    active_record = DatabaseCleaner[:active_record]
+    active_record.strategy = :truncation
+    active_record.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: filter_factory
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Hck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-05 00:00:00.000000000 Z
+dependencies: []
+description: Gem for easy ActiveRecord/Mongoid models filtering
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- filter_factory.gemspec
+- lib/filter_factory.rb
+- lib/filter_factory/active_record/condition.rb
+- lib/filter_factory/active_record/filter.rb
+- lib/filter_factory/condition.rb
+- lib/filter_factory/field.rb
+- lib/filter_factory/filter.rb
+- lib/filter_factory/mongoid/condition.rb
+- lib/filter_factory/mongoid/filter.rb
+- lib/filter_factory/version.rb
+- spec/factories/factories.rb
+- spec/filter_factory/active_record/model_spec.rb
+- spec/filter_factory/filter_spec.rb
+- spec/filter_factory/mongoid/model_spec.rb
+- spec/models/ar_post.rb
+- spec/models/m_post.rb
+- spec/spec_helper.rb
+homepage: https://github.com/hck/filter_factory
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: FilterFactory allows you to easily fetch ActiveRecord/Mongoid models that
+  match specified filters.
+test_files:
+- spec/factories/factories.rb
+- spec/filter_factory/active_record/model_spec.rb
+- spec/filter_factory/filter_spec.rb
+- spec/filter_factory/mongoid/model_spec.rb
+- spec/models/ar_post.rb
+- spec/models/m_post.rb
+- spec/spec_helper.rb