usefull_scopes 0.1.0 → 0.2.1

data/.coveralls.yml

@@ -0,0 +1 @@
+repo_token: hHSEHjAw28Kly9dKy4u9dHPyDwIIWEKGI

data/.gitignore

@@ -2,3 +2,5 @@
 .bundle
 Gemfile.lock
 pkg/*
+.DS_Store
+coverage

data/Gemfile

@@ -2,3 +2,13 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in usefull_scopes.gemspec
 gemspec
+
+gem 'rake'
+gem 'sqlite3'
+gem 'minitest'
+gem 'tconsole'
+gem 'turn'
+gem 'activerecord'
+gem 'factory_girl'
+gem 'simplecov'
+gem 'coveralls', require: false

data/README.md

@@ -1,4 +1,7 @@
 # UsefullScopes
+[![Build Status](https://travis-ci.org/kaize/usefull_scopes.png?branch=master)](https://travis-ci.org/kaize/usefull_scopes)
+[![Coverage
+status](https://coveralls.io/repos/kaize/usefull_scopes/badge.png?branch=master)](https://coveralls.io/r/kaize/usefull_scopes)
 
 This gem provides additional scopes for your ActiveRecord models.
 
@@ -70,14 +73,6 @@ These are the scopes created for each model's attribute.
     <td>ilike_by_attribute</td>
     <td>Сase insensitive implementation of `like_by_attribute`</td>
   </tr>
-  <tr>
-    <td>with_attribute</td>
-    <td>Returns records, where attribute's value is equal to a given value.<br/><b>Note: this scope is deprecated and will be removed in the following versions. Please, use `with` scope instead.</b></td>
-  </tr>
-  <tr>
-    <td>without_attribute</td>
-    <td>Returns records, where attribute's value is `NULL`.<br/><b>Note: this scope is deprecated and will be removed in the following versions. Please, use `without` scope instead.</b></td>
-  </tr>
 </table>
 
 ### Example

data/Rakefile

@@ -1 +1,11 @@
 require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/lib/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/lib/usefull_scopes.rb

@@ -4,16 +4,17 @@ module UsefullScopes
 
   included do
     scope :random, order("RANDOM()")
-    scope :exclude, lambda {|collection_or_object|
+
+    scope :exclude, ->(collection_or_object) {
       collection = Array(collection_or_object)
       values = collection.map do |id_or_object|
-        id_or_object.is_a?(ActiveRecord::Base) ? id_or_object.id : id_or_object
+        find_object_value_or_value(id_or_object)
       end
       return scoped unless values.any?
-      where("#{quoted_table_name}.id not in (?)", values)
+      where(arel_table[:id].not_in(values))
     }
 
-    scope :with, lambda {|attrs_hash|
+    scope :with, ->(attrs_hash) {
       case attrs_hash
       when Hash
         where(attrs_hash)
@@ -22,35 +23,141 @@ module UsefullScopes
       end
     }
 
-    scope :without, lambda {|*attrs|
+    scope :without, ->(*attrs) {
       attrs_hash = attrs.extract_options!
       query_params = []
 
       attrs.each do |attr_name|
-        query_params << "#{quoted_table_name}.#{attr_name} IS NULL"
+        query_params << arel_table[attr_name].eq(nil)
       end
 
       attrs_hash.each do |attr_name, attr_value|
-        query_params << "#{quoted_table_name}.#{attr_name} NOT IN (:#{attr_name})"
+        query_params << arel_table[attr_name].not_in(attr_value)
       end
 
       return scoped if query_params.blank?
-      where query_params.join(" AND "), attrs_hash
+
+      where arel_table.create_and query_params
+    }
+
+    scope :desc_by, ->(attrs) {
+      order(collect_order_query_rules(attrs, :desc))
+    }
+
+    scope :asc_by, ->(attrs) {
+      order(collect_order_query_rules(attrs, :asc))
+    }
+
+    scope :more_than, ->(attrs) {
+      where_and(attrs, :gt)
+    }
+
+    scope :less_than, ->(attrs) {
+      where_and(attrs, :lt)
+    }
+
+    scope :more_or_equal, ->(attrs) {
+      where_and(attrs, :gteq)
     }
 
+    scope :less_or_equal, ->(attrs) {
+      where_and(attrs, :lteq)
+    }
+
+    def self.collect_order_query_rules(array, rule)
+      query_params = []
+
+      attrs =
+        case array
+        when Array
+          array
+        when Symbol
+          [array]
+        else
+          raise TypeError, "Symbol or Array of symbols is expected"
+        end
+
+      attrs.each do |attr_name, attr_value|
+        query_params << arel_table[attr_name].send(rule)
+      end
+
+      raise ArgumentError, "Empty Array" if query_params.blank?
+
+      query_params
+    end
+
+    def self.collect_query_rules(hash_or_object, rule, field = :id)
+      query_params = []
+
+      attrs =
+        case hash_or_object
+        when ActiveRecord::Base
+          { field => hash_or_object.send(field) }
+        when Hash
+          hash_or_object
+        when Array
+          
+        else
+          raise TypeError, "Hash or AR object is expected"
+        end
+
+      attrs.each do |attr_name, attr_value|
+        attr_value = attr_value.send(attr_name) if attr_value.is_a? ActiveRecord::Base
+        query_params << arel_table[attr_name].send(rule, attr_value)
+      end
+
+      raise ArgumentError, "Empty Hash" if query_params.blank?
+
+      query_params
+    end
+
     attribute_names.each do |a|
-      scope "by_#{a}", order("#{quoted_table_name}.#{a} DESC")
-      scope "asc_by_#{a}", order("#{quoted_table_name}.#{a} ASC")
+      a = a.to_sym
 
-      scope "like_by_#{a}", lambda {|term|
+      scope "by_#{a}", order(arel_table[a].desc)
+
+      scope "asc_by_#{a}", order(arel_table[a].asc)
+
+      scope "like_by_#{a}", ->(term) {
         quoted_term = connection.quote(term + '%')
         where("lower(#{quoted_table_name}.#{a}) like #{quoted_term}")
       }
-      scope "ilike_by_#{a}", lambda {|term|
-        quoted_term = connection.quote(term + '%')
-        where("#{quoted_table_name}.#{a} ilike #{quoted_term}")
+
+      scope "ilike_by_#{a}", ->(term) {
+        quoted_term = term + '%'
+        where(arel_table[a].matches(quoted_term))
+      }
+
+      scope "#{a}_more", ->(value_or_object) {
+        value = find_object_value_or_value(value_or_object, a)
+        where(arel_table[a].gt(value))
+      }
+
+      scope "#{a}_less", ->(value_or_object) {
+        value = find_object_value_or_value(value_or_object, a)
+        where(arel_table[a].lt(value))
+      }
+
+      scope "#{a}_more_or_equal", ->(value_or_object) {
+        value = find_object_value_or_value(value_or_object, a)
+        where(arel_table[a].gteq(value))
+      }
+
+      scope "#{a}_less_or_equal", ->(value_or_object) {
+        value = find_object_value_or_value(value_or_object, a)
+        where(arel_table[a].lteq(value))
       }
     end
+
+    def self.find_object_value_or_value(value_or_object, field = :id)
+      value_or_object.is_a?(ActiveRecord::Base) ? value_or_object.send(field) : value_or_object
+    end
+
+    def self.where_and(attrs, rule)
+      query_params = collect_query_rules(attrs, rule)
+      where arel_table.create_and query_params
+    end
+
   end
 end
 

data/lib/usefull_scopes/version.rb

@@ -1,3 +1,3 @@
 module UsefullScopes
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/test/factories/models.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :model do
+    field_1
+    field_2
+    field_3
+  end
+end

data/test/factories/sequences.rb

@@ -0,0 +1,13 @@
+FactoryGirl.define do
+  sequence :field_1 do |n|
+    n
+  end
+
+  sequence :field_2 do |n|
+    "string-#{n}"
+  end
+
+  sequence :field_3 do
+    rand(3) % 2 == 0 ? true : false
+  end
+end

data/test/lib/usefull_scopes_test.rb

@@ -0,0 +1,652 @@
+require 'test_helper'
+
+module UsefullScopes
+  class ScopesTest < TestCase
+    def setup
+      3.times { create :model }
+      @model = Model.first
+    end
+
+    def test_random_order_condition
+      random_request = Model.random
+
+      request_arel = random_request.arel
+      order = request_arel.order
+      order_conditions = order.orders
+
+      assert_includes order_conditions, "RANDOM()"
+    end
+
+    def test_random_sql
+      random_request = Model.random
+
+      assert_equal "SELECT \"models\".* FROM \"models\"  ORDER BY RANDOM()", random_request.to_sql
+    end
+
+    def test_exclude_result
+      @models = Model.exclude(@model)
+
+      models_count = Model.count - 1
+
+      assert_equal models_count, @models.count
+    end
+
+    def test_exclude_conditions
+      @models = Model.exclude(@model)
+
+      request_arel = @models.arel
+      condition = request_arel.where_clauses
+      assert_equal 1, condition.count
+      assert condition.first.match "NOT IN"
+    end
+
+    def test_with_result
+      @models = Model.with({field_1: @model.field_1})
+
+      assert @models
+
+      assert_includes @models, @model
+    end
+
+    def test_with_conditions
+      @models = Model.with({field_1: @model.field_1})
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        condition.children.each do |condition_part|
+          assert_kind_of Arel::Nodes::Equality, condition_part
+        end
+      end
+    end
+
+    def test_with_incorrect_params
+      begin
+        @models = Model.with("field_1 = #{@model.field_1}")
+      rescue Exception => e
+        assert_equal "Hash is expected", e.message
+      end
+    end
+
+    def test_without_result
+      @models = Model.without({field_1: @model.field_1})
+
+      assert @models
+
+      refute @models.include?(@model)
+    end
+
+    def test_without_conditions
+      @models = Model.without({field_1: @model.field_1})
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        condition.expr.children.each do |condition_part|
+          assert_kind_of Arel::Nodes::NotIn, condition_part
+
+          assert_kind_of Arel::Attributes::Attribute, condition_part.left
+
+          assert_equal :field_1, condition_part.left.name
+          assert_equal 1, condition_part.right
+        end
+      end
+    end
+
+    def test_without_incorrect_params
+      begin
+        @models = Model.without("field_1 = #{@model.field_1}")
+      rescue Exception => e
+        assert_equal "Hash is expected", e.message
+      end
+    end
+
+    def test_like_by_result
+
+      assert_respond_to Model, :like_by_field_2
+
+      @models = Model.like_by_field_2(@model.field_2[0..3])
+
+      assert @models.any?
+      assert_includes @models, @model
+    end
+
+    def test_like_by_condition
+
+      @models = Model.like_by_field_2(@model.field_2[0..3])
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        assert condition.expr.match "like"
+      end
+    end
+
+    def test_ilike_by_result
+      assert_respond_to Model, :ilike_by_field_2
+
+      # SQLite error %(
+      #@models = Model.ilike_by_field_2(@model.field_2[0..3])
+
+      #assert @models.any?
+      #assert_includes @models, @model
+    end
+
+    def test_ilike_by_condition
+      @models = Model.ilike_by_field_2(@model.field_2[0..3])
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        assert_kind_of Arel::Nodes::Matches, condition.expr
+
+        assert_kind_of Arel::Attributes::Attribute, condition.expr.left
+        assert_equal :field_2, condition.expr.left.name
+        assert_equal "stri%", condition.expr.right
+      end
+    end
+
+    def test_desc_by_result
+      assert_respond_to Model, :desc_by
+
+      @models = Model.desc_by(:field_1)
+
+      assert @models.any?
+    end
+
+    def test_desc_by_condition_array_attrs
+      attrs = [:field_1, :field_2]
+
+      @models = Model.desc_by(attrs)
+
+      arel = @models.arel
+      orders_conditions = arel.orders
+
+      assert orders_conditions.any?
+
+      orders_conditions.each_with_index do |condition, index|
+        assert_kind_of Arel::Nodes::Descending, condition
+        assert_kind_of Arel::Attributes::Attribute, condition.expr
+
+        assert_equal attrs[index], condition.expr.name
+      end
+    end
+
+    def test_desc_by_condition
+      @models = Model.desc_by(:field_1)
+
+      arel = @models.arel
+      orders_conditions = arel.orders
+
+      assert orders_conditions.any?
+
+      orders_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Descending, condition
+        assert_kind_of Arel::Attributes::Attribute, condition.expr
+
+        assert_equal :field_1, condition.expr.name
+      end
+    end
+
+    def test_desc_by_incorrect_params
+      begin
+        @models = Model.desc_by("field_1")
+      rescue Exception => e
+        assert_equal "Symbol or Array of symbols is expected", e.message
+      end
+    end
+
+    def test_asc_by_result
+      assert_respond_to Model, :asc_by
+
+      @models = Model.asc_by(:field_1)
+
+      assert @models.any?
+    end
+
+    def test_asc_by_condition_array_attrs
+      attrs = [:field_1, :field_2]
+
+      @models = Model.asc_by(attrs)
+
+      arel = @models.arel
+      orders_conditions = arel.orders
+
+      assert orders_conditions.any?
+
+      orders_conditions.each_with_index do |condition, index|
+        assert_kind_of Arel::Nodes::Ascending, condition
+        assert_kind_of Arel::Attributes::Attribute, condition.expr
+
+        assert_equal attrs[index], condition.expr.name
+      end
+    end
+
+    def test_asc_by_condition
+      @models = Model.asc_by(:field_1)
+
+      arel = @models.arel
+      orders_conditions = arel.orders
+
+      assert orders_conditions.any?
+
+      orders_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Ascending, condition
+        assert_kind_of Arel::Attributes::Attribute, condition.expr
+
+        assert_equal :field_1, condition.expr.name
+      end
+    end
+
+    def test_asc_by_incorrect_params
+      begin
+        @models = Model.asc_by("field_1")
+      rescue Exception => e
+        assert_equal "Symbol or Array of symbols is expected", e.message
+      end
+    end
+
+    def test_field_more_than_value_by_result
+      @model_less = create :model
+      @model_more = create :model, field_1: @model_less.field_1 + 1
+
+      @models = Model.field_1_more(@model_less.field_1)
+
+      assert @models.any?
+      assert @models.include?(@model_more)
+      refute @models.include?(@model_less)
+    end
+
+    def test_field_more_than_object_by_result
+      @model_less = create :model
+      @model_more = create :model, field_1: @model_less.field_1 + 1
+
+      @models = Model.field_1_more(@model_less)
+
+      assert @models.any?
+      assert @models.include?(@model_more)
+      refute @models.include?(@model_less)
+    end
+
+    def test_field_more_by_condition
+      @models = Model.field_1_more(@model.field_1)
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        assert_kind_of Arel::Nodes::GreaterThan, condition.expr
+        assert_equal @model.field_1, condition.expr.right
+      end
+    end
+
+    def test_field_less_than_value_by_result
+      @model_less = create :model
+      @model_more = create :model, field_1: @model_less.field_1 + 1
+
+      @models = Model.field_1_less(@model_more.field_1)
+
+      assert @models.any?
+      assert @models.include?(@model_less)
+      refute @models.include?(@model_more)
+    end
+
+    def test_field_less_than_object_by_result
+      @model_less = create :model
+      @model_more = create :model, field_1: @model_less.field_1 + 1
+
+      @models = Model.field_1_less(@model_more)
+
+      assert @models.any?
+      assert @models.include?(@model_less)
+      refute @models.include?(@model_more)
+    end
+
+    def test_field_less_by_condition
+      @models = Model.field_1_less(@model.field_1)
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        assert_kind_of Arel::Nodes::LessThan, condition.expr
+        assert_equal @model.field_1, condition.expr.right
+      end
+    end
+
+    def test_field_more_or_equal_than_value_by_result
+      @model_less = create :model
+      @model_more = create :model, field_1: @model_less.field_1 + 1
+
+      @models = Model.field_1_more_or_equal(@model_more.field_1)
+
+      assert @models.any?
+      assert @models.include?(@model_more)
+      refute @models.include?(@model_less)
+    end
+
+    def test_field_more_or_equal_than_object_by_result
+      @model_less = create :model
+      @model_more = create :model, field_1: @model_less.field_1 + 1
+
+      @models = Model.field_1_more_or_equal(@model_more)
+
+      assert @models.any?
+      assert @models.include?(@model_more)
+      refute @models.include?(@model_less)
+    end
+
+    def test_field_more_or_equal_by_condition
+      @models = Model.field_1_more_or_equal(@model.field_1)
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        assert_kind_of Arel::Nodes::GreaterThanOrEqual, condition.expr
+        assert_equal @model.field_1, condition.expr.right
+      end
+    end
+
+    def test_field_less_or_equal_than_value_by_result
+      @model_less = create :model
+      @model_more = create :model, field_1: @model_less.field_1 + 1
+
+      @models = Model.field_1_less_or_equal(@model_less.field_1)
+
+      assert @models.any?
+      assert @models.include?(@model_less)
+      refute @models.include?(@model_more)
+    end
+
+    def test_field_less_or_equal_than_object_by_result
+      @model_less = create :model
+      @model_more = create :model, field_1: @model_less.field_1 + 1
+
+      @models = Model.field_1_less_or_equal(@model_less)
+
+      assert @models.any?
+      assert @models.include?(@model_less)
+      refute @models.include?(@model_more)
+    end
+    def test_field_less_or_equal_by_condition
+      @models = Model.field_1_less_or_equal(@model.field_1)
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        assert_kind_of Arel::Nodes::LessThanOrEqual, condition.expr
+        assert_equal @model.field_1, condition.expr.right
+      end
+    end
+
+    def test_more_than_result
+      @model = Model.last
+
+      @models = Model.more_than({field_1: 1})
+
+      assert @models.any?
+      assert @models.include?(@model)
+    end
+
+    def test_more_than_condition_value
+      @models = Model.more_than({field_1: 1})
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        condition.expr.children.each do |condition_part|
+          assert_kind_of Arel::Nodes::GreaterThan, condition_part
+
+          assert_kind_of Arel::Attributes::Attribute, condition_part.left
+
+          assert_equal :field_1, condition_part.left.name
+          assert_equal 1, condition_part.right
+        end
+      end
+    end
+
+    def test_more_than_condition_ar_object
+      @models = Model.more_than(@model)
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        condition.expr.children.each do |condition_part|
+          assert_kind_of Arel::Nodes::GreaterThan, condition_part
+
+          assert_kind_of Arel::Attributes::Attribute, condition_part.left
+
+          assert_equal :id, condition_part.left.name
+          assert_equal 1, condition_part.right
+        end
+      end
+    end
+
+    def test_more_than_incorrect_params
+      begin
+        @models = Model.more_than("field_1")
+      rescue Exception => e
+        assert_equal "Hash or AR object is expected", e.message
+      end
+    end
+
+    def test_less_than_result
+      @model_first = Model.first
+      @model_last = Model.last
+
+      @models = Model.less_than({field_1: @model_last.field_1})
+
+      assert @models.any?
+      assert @models.include?(@model_first)
+    end
+
+    def test_less_than_condition_value
+      @models = Model.less_than({field_1: 1})
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        condition.expr.children.each do |condition_part|
+          assert_kind_of Arel::Nodes::LessThan, condition_part
+
+          assert_kind_of Arel::Attributes::Attribute, condition_part.left
+
+          assert_equal :field_1, condition_part.left.name
+          assert_equal 1, condition_part.right
+        end
+      end
+    end
+
+    def test_less_than_condition_ar_object
+      @models = Model.less_than(@model)
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        condition.expr.children.each do |condition_part|
+          assert_kind_of Arel::Nodes::LessThan, condition_part
+
+          assert_kind_of Arel::Attributes::Attribute, condition_part.left
+
+          assert_equal :id, condition_part.left.name
+          assert_equal 1, condition_part.right
+        end
+      end
+    end
+
+    def test_less_than_incorrect_params
+      begin
+        @models = Model.less_than("field_1")
+      rescue Exception => e
+        assert_equal "Hash or AR object is expected", e.message
+      end
+    end
+
+    def test_more_or_equal_result
+      @model_first = Model.first
+      @model_last = Model.last
+
+      @models = Model.more_or_equal({field_1: @model_last.field_1})
+
+      assert @models.any?
+      assert @models.include?(@model_last)
+      assert_equal @models.count, 1
+    end
+
+    def test_more_or_equal_condition_value
+      @models = Model.more_or_equal({field_1: 1})
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        condition.expr.children.each do |condition_part|
+          assert_kind_of Arel::Nodes::GreaterThanOrEqual, condition_part
+
+          assert_kind_of Arel::Attributes::Attribute, condition_part.left
+
+          assert_equal :field_1, condition_part.left.name
+          assert_equal 1, condition_part.right
+        end
+      end
+    end
+
+    def test_more_or_equal_condition_ar_object
+      @models = Model.more_or_equal(@model)
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        condition.expr.children.each do |condition_part|
+          assert_kind_of Arel::Nodes::GreaterThanOrEqual, condition_part
+
+          assert_kind_of Arel::Attributes::Attribute, condition_part.left
+
+          assert_equal :id, condition_part.left.name
+          assert_equal 1, condition_part.right
+        end
+      end
+    end
+
+    def test_more_or_equal_incorrect_params
+      begin
+        @models = Model.more_or_equal("field_1")
+      rescue Exception => e
+        assert_equal "Hash or AR object is expected", e.message
+      end
+    end
+
+    def test_less_or_equal_result
+      @model_first = Model.first
+      @model_last = Model.last
+
+      @models = Model.less_or_equal({field_1: @model_first.field_1})
+
+      assert @models.any?
+      assert @models.include?(@model_first)
+      assert_equal @models.count, 1
+    end
+
+    def test_less_or_equal_condition_value
+      @models = Model.less_or_equal({field_1: 1})
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        condition.expr.children.each do |condition_part|
+          assert_kind_of Arel::Nodes::LessThanOrEqual, condition_part
+
+          assert_kind_of Arel::Attributes::Attribute, condition_part.left
+
+          assert_equal :field_1, condition_part.left.name
+          assert_equal 1, condition_part.right
+        end
+      end
+    end
+
+    def test_less_or_equal_condition_ar_object
+      @models = Model.less_or_equal(@model)
+
+      ctx = @models.arel.as_json["ctx"]
+      where_conditions = ctx.wheres
+
+      assert where_conditions.any?
+
+      where_conditions.each do |condition|
+        assert_kind_of Arel::Nodes::Grouping, condition
+        condition.expr.children.each do |condition_part|
+          assert_kind_of Arel::Nodes::LessThanOrEqual, condition_part
+
+          assert_kind_of Arel::Attributes::Attribute, condition_part.left
+
+          assert_equal :id, condition_part.left.name
+          assert_equal 1, condition_part.right
+        end
+      end
+    end
+
+    def test_less_or_equal_incorrect_params
+      begin
+        @models = Model.less_or_equal("field_1")
+      rescue Exception => e
+        assert_equal "Hash or AR object is expected", e.message
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,37 @@
+require 'bundler/setup'
+require 'active_record'
+require 'simplecov'
+require 'coveralls'
+Coveralls.wear!
+
+ENV["COVERAGE"] = "true"
+SimpleCov.start if ENV["COVERAGE"]
+
+Bundler.require
+
+MiniTest::Unit.autorun
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+ActiveRecord::Migration.create_table :models do |t|
+  t.integer       :field_1
+  t.string        :field_2
+  t.boolean       :field_3
+  t.text          :field_4
+  t.timestamps
+end
+
+class Model < ActiveRecord::Base
+  include UsefullScopes
+end
+
+class TestCase < MiniTest::Unit::TestCase
+  def load_fixture(filename)
+    File.read(File.dirname(__FILE__) + "/fixtures/#{filename}")
+  end
+
+  require 'factory_girl'
+  FactoryGirl.reload
+
+  include FactoryGirl::Syntax::Methods
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: usefull_scopes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-21 00:00:00.000000000 Z
+date: 2013-02-11 00:00:00.000000000 Z
 dependencies: []
 description: This gem provides additional scopes for your Active:Record models within
   Ruby on Rails framework.
@@ -19,6 +19,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .coveralls.yml
 - .gitignore
 - Gemfile
 - LICENSE
@@ -26,6 +27,10 @@ files:
 - Rakefile
 - lib/usefull_scopes.rb
 - lib/usefull_scopes/version.rb
+- test/factories/models.rb
+- test/factories/sequences.rb
+- test/lib/usefull_scopes_test.rb
+- test/test_helper.rb
 - usefull_scopes.gemspec
 homepage: http://github.com/kaize/usefull_scopes
 licenses: []
@@ -51,5 +56,8 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Additional scopes for Active:Record models.
-test_files: []
-has_rdoc: 
+test_files:
+- test/factories/models.rb
+- test/factories/sequences.rb
+- test/lib/usefull_scopes_test.rb
+- test/test_helper.rb