filter_factory 0.0.3 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a20357253719ea11df36bea4aa7d70143b595c69
+  data.tar.gz: f9ba46a6e9d1e41e8690dde28861fa5ff00c5d78
+SHA512:
+  metadata.gz: 053d07b99b084c136f9982e7b65f30fdb922759f6e669e1e0def7a31e45684e58961322cd160edce9bf08fbc87063ef940db8805cee1730a5f7a382b013644be
+  data.tar.gz: fc547558634b40fe8a0859d5ffb08d9948d3c04b238b36ad2e333f5c8dd61a2d14a45aaa2bf5b0f84d613b09f2f8ae7b747b67659a8a82474bc23d844790db82

data/.gitignore

@@ -3,7 +3,6 @@
 .bundle
 .config
 .yardoc
-Gemfile.lock
 InstalledFiles
 _yardoc
 coverage
@@ -15,4 +14,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-.idea
+.idea
+.gems

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - "2.3.0"
+services:
+  - mongodb
+  - mysql
+script: bundle exec rspec spec

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,141 @@
+PATH
+  remote: .
+  specs:
+    filter_factory (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (4.2.6)
+      actionpack (= 4.2.6)
+      actionview (= 4.2.6)
+      activejob (= 4.2.6)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+    actionpack (4.2.6)
+      actionview (= 4.2.6)
+      activesupport (= 4.2.6)
+      rack (~> 1.6)
+      rack-test (~> 0.6.2)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (4.2.6)
+      activesupport (= 4.2.6)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    activejob (4.2.6)
+      activesupport (= 4.2.6)
+      globalid (>= 0.3.0)
+    activemodel (4.2.6)
+      activesupport (= 4.2.6)
+      builder (~> 3.1)
+    activerecord (4.2.6)
+      activemodel (= 4.2.6)
+      activesupport (= 4.2.6)
+      arel (~> 6.0)
+    activesupport (4.2.6)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.3)
+    bson (4.0.4)
+    builder (3.2.2)
+    concurrent-ruby (1.0.1)
+    diff-lcs (1.2.5)
+    erubis (2.7.0)
+    factory_girl (4.7.0)
+      activesupport (>= 3.0.0)
+    globalid (0.3.6)
+      activesupport (>= 4.1.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    loofah (2.0.3)
+      nokogiri (>= 1.5.9)
+    mail (2.6.4)
+      mime-types (>= 1.16, < 4)
+    mime-types (3.0)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2016.0221)
+    mini_portile2 (2.0.0)
+    minitest (5.8.4)
+    mongo (2.2.4)
+      bson (~> 4.0)
+    mongoid (5.1.2)
+      activemodel (~> 4.0)
+      mongo (~> 2.1)
+      origin (~> 2.2)
+      tzinfo (>= 0.3.37)
+    mysql2 (0.4.3)
+    nokogiri (1.6.7.2)
+      mini_portile2 (~> 2.0.0.rc2)
+    origin (2.2.0)
+    rack (1.6.4)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rails (4.2.6)
+      actionmailer (= 4.2.6)
+      actionpack (= 4.2.6)
+      actionview (= 4.2.6)
+      activejob (= 4.2.6)
+      activemodel (= 4.2.6)
+      activerecord (= 4.2.6)
+      activesupport (= 4.2.6)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.2.6)
+      sprockets-rails
+    rails-deprecated_sanitizer (1.0.3)
+      activesupport (>= 4.2.0.alpha)
+    rails-dom-testing (1.0.7)
+      activesupport (>= 4.2.0.beta, < 5.0)
+      nokogiri (~> 1.6.0)
+      rails-deprecated_sanitizer (>= 1.0.1)
+    rails-html-sanitizer (1.0.3)
+      loofah (~> 2.0)
+    railties (4.2.6)
+      actionpack (= 4.2.6)
+      activesupport (= 4.2.6)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (11.1.2)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    sprockets (3.6.0)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
+    sprockets-rails (3.0.4)
+      actionpack (>= 4.0)
+      activesupport (>= 4.0)
+      sprockets (>= 3.0.0)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  factory_girl
+  filter_factory!
+  mongoid (>= 5.0)
+  mysql2
+  rails (>= 4.0)
+  rspec
+
+BUNDLED WITH
+   1.11.2

data/README.md

@@ -1,5 +1,7 @@
 # FilterFactory
 
+[![Build Status](https://travis-ci.org/hck/filter_factory.png)](https://travis-ci.org/hck/filter_factory)
+
 FilterFactory allows you to easily fetch ActiveRecord/Mongoid models that match specified filters.
 
 ## Installation

data/lib/filter_factory/field.rb

@@ -7,7 +7,7 @@ module FilterFactory
       raise ArgumentError unless FilterFactory::Filter::CONDITIONS.include?(condition)
 
       valid_options = [:alias]
-      @name, @condition, @options = name, condition, options.reject{|k,v| !valid_options.include?(k)}
+      @name, @condition, @options = name, condition, options.reject{|k,| !valid_options.include?(k)}
       @alias = @options[:alias] || @name
     end
 

data/lib/filter_factory/filter.rb

@@ -7,14 +7,14 @@ module FilterFactory
 
     attr_reader :fields
 
-    CONDITIONS = [:eq, :ne, :lt, :lte, :gt, :gte, :all, :in, :nin, :regex, :exists, :presents]
+    CONDITIONS = [:eq, :ne, :lt, :lte, :gt, :gte, :all, :in, :nin, :regex, :exists, :presents].freeze
 
     def initialize
       @fields = []
     end
 
     def attributes
-      @fields.inject(HashWithIndifferentAccess.new) do |acc,field|
+      @fields.inject(HashWithIndifferentAccess.new) do |acc, field|
         acc[field.alias] = field.value
         acc
       end
@@ -28,11 +28,11 @@ module FilterFactory
     end
 
     def filled_fields
-      fields.select{|f| !f.value.nil? && f.value != ''}
+      fields.select { |f| !f.value.nil? && f.value != '' }
     end
 
     def get_field(name)
-      fields.find{|f| f.name == name}
+      fields.find { |f| f.name == name }
     end
 
     def persisted?
@@ -40,29 +40,31 @@ module FilterFactory
     end
 
     CONDITIONS.each do |condition|
-      define_method condition do |name,options={}|
+      define_method condition do |name, options={}|
         field(name, condition, options)
       end
     end
 
+    class << self
+      def create(&block)
+        new.tap { |filter| filter.instance_eval &block }
+      end
+    end
+
+    class DuplicateFieldError < StandardError;
+    end
+
     private
+
     def field(name, condition, options={})
       Field.new(name, condition, options).tap do |field|
         raise DuplicateFieldError if fields.include?(field)
 
-        define_singleton_method(field.alias){ field.value }
-        define_singleton_method("#{field.alias}="){|val| field.value = val }
+        define_singleton_method(field.alias) { field.value }
+        define_singleton_method("#{field.alias}=") { |val| field.value = val }
 
         @fields << field
       end
     end
-
-    class << self
-      def create &block
-        new.tap{|filter| filter.instance_eval &block}
-      end
-    end
-
-    class DuplicateFieldError < StandardError; end
   end
-end
+end

data/lib/filter_factory/mongoid/condition.rb

@@ -6,35 +6,35 @@ module FilterFactory
       end
 
       def ne(obj)
-        obj.where(field_name => {'$ne' => value})
+        obj.where(field_name => { '$ne' => value })
       end
 
       def lt(obj)
-        obj.where(field_name => {'$lt' => value})
+        obj.where(field_name => { '$lt' => value })
       end
 
       def lte(obj)
-        obj.where(field_name => {'$lte' => value})
+        obj.where(field_name => { '$lte' => value })
       end
 
       def gt(obj)
-        obj.where(field_name => {'$gt' => value})
+        obj.where(field_name => { '$gt' => value })
       end
 
       def gte(obj)
-        obj.where(field_name => {'$gte' => value})
+        obj.where(field_name => { '$gte' => value })
       end
 
       def all(obj)
-        obj.where(field_name => {'$all' => value})
+        obj.where(field_name => { '$all' => value })
       end
 
       def in(obj)
-        obj.where(field_name => {'$in' => value})
+        obj.where(field_name => { '$in' => value })
       end
 
       def nin(obj)
-        obj.where(field_name => {'$nin' => value})
+        obj.where(field_name => { '$nin' => value })
       end
 
       def regex(obj)
@@ -42,12 +42,18 @@ module FilterFactory
       end
 
       def exists(obj)
-        obj.where(field_name => {'$exists' => value})
+        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, '', []]})
+        query_opts = if ['true', '1', 1].include?(value)
+          { field_name => { '$nin' => [nil, '', []] } }
+        else
+          { field_name => { '$in' => [nil, '', []] } }
+        end
+
+        obj.where(query_opts)
       end
     end
   end
-end
+end

data/lib/filter_factory/mongoid/filter.rb

@@ -6,8 +6,8 @@ module FilterFactory
           FilterFactory::Mongoid::Condition.new(field.name, field.value).method(field.condition)
         end
 
-        conditions.inject(self) do |res,condition|
-          res = res.instance_eval(&condition)
+        conditions.inject(self) do |res, condition|
+          res.instance_eval(&condition)
         end
       end
     end
@@ -20,4 +20,4 @@ if defined?(Mongoid::Document)
       base.extend FilterFactory::Mongoid::Filter
     end
   end
-end
+end

data/lib/filter_factory/version.rb

@@ -1,3 +1,3 @@
 module FilterFactory
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/lib/filter_factory.rb

@@ -1,17 +1,17 @@
-require "filter_factory/version"
+require 'filter_factory/version'
 
-require "filter_factory/condition"
-require "filter_factory/field"
-require "filter_factory/filter"
+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/active_record/condition'
+require 'filter_factory/active_record/filter'
 
-require "filter_factory/mongoid/condition"
-require "filter_factory/mongoid/filter"
+require 'filter_factory/mongoid/condition'
+require 'filter_factory/mongoid/filter'
 
 module FilterFactory
-  def self.create &block
-    FilterFactory::Filter.create &block
+  def self.create(&block)
+    FilterFactory::Filter.create(&block)
   end
-end
+end

data/spec/factories/factories.rb

@@ -3,13 +3,11 @@ FactoryGirl.define 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
+end

data/spec/filter_factory/active_record/model_spec.rb

@@ -1,157 +1,143 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe ARPost do
-  before(:each) do
-    @posts = FactoryGirl.create_list(:active_record_post, 10)
-  end
+RSpec.describe ARPost do
+  let!(:posts) { posts = FactoryGirl.create_list(:active_record_post, 5) }
 
-  it "should respond to ::filter method" do
-    described_class.should respond_to(:filter)
+  it 'responds to ::filter method' do
+    expect(described_class).to respond_to(:filter)
   end
 
-  it "should execute filter methods chain" do
+  it 'executes filter methods chain' do
+    sample = posts.sample
+
     filter = FilterFactory.create do
-      field :title, :eq
-      field :author, :eq, alias: :user
-      field :views, :gte
+      eq :title
+      eq :author, alias: :user
+      gte :views
     end
 
-    sample = @posts.sample
-
     filter.title = sample.title
     filter.user = sample.author
 
-    described_class.filter(filter).to_a.should == [sample]
+    expect(described_class.filter(filter).to_a).to eq([sample])
   end
 
-  it "should return records with column' values equal to specified value" do
-    sample = @posts.sample
+  it 'returns records with column values equal to specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :id,  :eq
-    end
+    filter = FilterFactory.create { eq :id }
     filter.id = sample.id
 
-    described_class.filter(filter).to_a.should == [sample]
+    expect(described_class.filter(filter).to_a).to eq([sample])
   end
 
-  it "should return records with column' values not equal specified value" do
-    sample = @posts.sample
+  it 'returns records with column values not equal specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :id,  :ne
-    end
+    filter = FilterFactory.create { ne :id }
     filter.id = sample.id
 
-    described_class.filter(filter).to_a.sort.should == @posts.reject{|p| p.id == sample.id}
+    expected_result = posts.reject { |p| p.id == sample.id }
+    expect(described_class.filter(filter).to_a.sort).to eq(expected_result)
   end
 
-  it "should return records with column' values less than specified value" do
-    sample = @posts.sample
+  it 'returns records with column values less than specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :views,  :lt
-    end
+    filter = FilterFactory.create { lt :views }
     filter.views = sample.views
 
-    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views < sample.views}.map(&:id).sort
+    expected_result = posts.select { |p| p.views < sample.views }.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with column' values less than or equal to specified value" do
-    sample = @posts.sample
+  it 'returns records with column values less than or equal to specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :views,  :lte
-    end
+    filter = FilterFactory.create { lte :views }
     filter.views = sample.views
 
-    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views <= sample.views}.map(&:id).sort
+    expected_result = posts.select { |p| p.views <= sample.views }.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with column' values greater than specified value" do
-    sample = @posts.sample
+  it 'returns records with column values greater than specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :views,  :gt
-    end
+    filter = FilterFactory.create { gt :views }
     filter.views = sample.views
 
-    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views > sample.views}.map(&:id).sort
+    expected_result = posts.select { |p| p.views > sample.views }.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with column' values greater than or equal to specified value" do
-    sample = @posts.sample
+  it 'returns records with column values greater than or equal to specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :views,  :gte
-    end
+    filter = FilterFactory.create { gte :views }
     filter.views = sample.views
 
-    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views >= sample.views}.map(&:id).sort
+    expected_result = posts.select { |p| p.views >= sample.views }.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should raise NotImplementedError if using 'all' condition" do
+  it 'raises NotImplementedError if using \'all\' condition' do
     filter = FilterFactory.create do
-      field :opts,  :all
+      field :opts, :all
     end
     filter.opts = [1, 2, 3, 4]
 
-    expect {described_class.filter(filter)}.to raise_error(NotImplementedError)
+    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)
+  it 'returns records with column values in specified values' do
+    sample = posts.sample(3)
 
     filter = FilterFactory.create do
-      field :id,  :in
+      field :id, :in
     end
     filter.id = sample.map(&:id)
 
-    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+    expected_result = sample.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with column' values not in specified values" do
-    sample = @posts.sample(3)
+  it 'returns records with column values not in specified values' do
+    sample = posts.sample(3)
 
-    filter = FilterFactory.create do
-      field :id,  :nin
-    end
+    filter = FilterFactory.create { nin :id }
     filter.id = sample.map(&:id)
 
-    described_class.filter(filter).map(&:id).sort.should == (@posts.map(&:id) - sample.map(&:id)).sort
+    expected_result = (posts.map(&:id) - sample.map(&:id)).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   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
+  it 'returns 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 { regex :title }
     filter.title = '_title_'
 
-    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+    expected_result = sample.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should raise NotImplementedError if using 'exists' condition" do
-    filter = FilterFactory.create do
-      field :not_exists, :exists
-    end
+  it 'raises NotImplementedError if using \'exists\' condition' do
+    filter = FilterFactory.create { exists :not_exists }
     filter.not_exists = true
 
-    expect {described_class.filter(filter)}.to raise_error(NotImplementedError)
+    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)}
+  it 'returns 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 = FilterFactory.create { presents :title }
     filter.title = false
 
-    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+    expected_result = sample.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
-end
+end