ryana-inequal_opportunity 0.1.1 → 0.1.2

data/README

@@ -21,9 +21,19 @@ With Inequal Opportunity, you can write:
 Where Object#ne wraps 42 in a ActiveRecord::Inequality::NotEqual class,
 which is then used to insert the proper operator into the generated SQL.
 
-Test coverage is real sparse right now.  I also am not completely satisfied with
-the way I overwrite ActiveRecord.expand_range_bind_variables, but it works for now.
+Other supported inequalities are:
 
+  gte()     =>      >=
+  gt()      =>      >
+  lte()     =>      <=
+  le()      =>      <
+  ne()      =>      <>
+  ne(nil)   =>      IS NOT
+
+
+Test coverage is real sparse right now.  And it's only been tested
+on MySQL.  I also am not completely satisfied with the way I overwrite
+ActiveRecord.expand_range_bind_variables, but it works.
 
 == License
 

data/lib/inequal_opportunity.rb

@@ -1,6 +1,9 @@
 module ActiveRecord
   module Inequality
 
+    class InequalError < Exception
+    end
+
     class Base
       attr_accessor :value
   
@@ -67,8 +70,15 @@ module ActiveRecord
         'LIKE'
       end
  
-      def value
-        "%#{super}%"
+      # This method is why I love Ruby
+      def value(override = false)
+        v = super(*[])
+
+        if !override && !v.is_a?(Numeric) && !v.is_a?(String)
+          raise InequalError, "Passing #{v.class} to Like.  You can't possibly want to do this"
+        end
+
+        "%#{v}%"
       end
     end
 
@@ -107,7 +117,8 @@ module ActiveRecord
       alias attribute_condition_orig attribute_condition
       def attribute_condition(quoted_column_name, argument)
         if argument.is_a? ActiveRecord::Inequality::Base
-          "#{quoted_column_name} #{argument.operator} ?"
+          question = argument.value.is_a?(Array) ? '(?)' : '?'
+          "#{quoted_column_name} #{argument.operator} #{question}"
         else
           attribute_condition_orig(quoted_column_name, argument)
         end

data/test/inequal_opportunity_test.rb

@@ -1,36 +1,27 @@
-require File.dirname(__FILE__) + '/test_helper'
-require 'ruby-debug'
-
-DB = YAML::load(File.open(File.join(File.dirname(__FILE__), 'database.yml'))).symbolize_keys!
-ActiveRecord::Base.establish_connection(DB[:source])
-
-TABLES = %w(mains seconds)
-
-class Main < ActiveRecord::Base
-  belongs_to :seconds
-  named_scope :newer_than, lambda {|time| {:conditions => {:created_at => gte(time) }} }
-end
+require File.join(File.dirname(__FILE__), 'test_helper')
+require File.join(File.dirname(__FILE__), 'db_setup')
 
-class Second < ActiveRecord::Base
-  has_many :mains
-end
+require 'ruby-debug'
 
-#ActiveRecord::Base.logger = Logger.new(STDOUT)
+  METHOD_SYMBOLS = [:gt, :gte, :lt, :lte, :ne, :like]
 
-class InequalOpportunityTest < Test::Unit::TestCase
+  class Main < ActiveRecord::Base
+    belongs_to :seconds
+    named_scope :newer_than, lambda {|time| {:conditions => {:created_at => gte(time) }} }
 
-  def setup
-    TABLES.each do |t|
-      ActiveRecord::Base.connection.execute("create table #{t} (id integer, val integer, seconds_id integer, mains_id integer, created_at datetime default null);")
+    METHOD_SYMBOLS.each do |s|
+      named_scope :"try_#{s}", lambda {|i| {:conditions => {:id => send(s, i)}} }
     end
+
   end
 
-  def teardown
-    TABLES.each do |t|
-      ActiveRecord::Base.connection.execute("drop table #{t};")
-    end
+  class Second < ActiveRecord::Base
+    has_many :mains
   end
 
+  ActiveRecord::Base.logger = Logger.new(STDERR)
+
+class InequalOpportunityTest < Test::Unit::TestCase
   context "a model" do
     setup do
       @model = Main
@@ -41,7 +32,38 @@ class InequalOpportunityTest < Test::Unit::TestCase
     end
 
     should "should work with a named_scope" do
-      assert_equal Main.newer_than(2.days.ago), []
+      assert_equal Main.newer_than(2.days.from_now).all, []
+    end
+
+    should "generate proper sql for array" do
+      METHOD_SYMBOLS.each do |s|
+
+        if s == :ne
+          assert_equal Main.try_ne([1,2,3]).first, nil
+        elsif s == :like
+          assert_raises ActiveRecord::Inequality::InequalError do
+            assert_equal Main.try_like([1,2,3]).first, nil
+          end
+        else
+          assert_raises ActiveRecord::StatementInvalid do
+            assert_equal Main.send(:"try_#{s}", [1,2,3]).first, nil
+          end
+        end
+      end
+
+      assert_equal Main.try_ne([1,2,3]).first, nil
+      assert_equal Main.try_ne([1,2,3]).count, 0
+    end
+
+    should "generate proper sql for nil and not nil" do
+      METHOD_SYMBOLS.each do |s|
+        assert_equal Main.send(:"try_#{s}", 1).first, nil
+        assert_equal Main.send(:"try_#{s}", nil).first, nil unless s == :like
+      end
+
+      assert_raises ActiveRecord::Inequality::InequalError do
+        Main.try_like(nil).first
+      end
     end
 
     should "properly scope based on gte" do
@@ -76,4 +98,61 @@ class InequalOpportunityTest < Test::Unit::TestCase
     end
   end
 
+  context "Object" do
+    should "have gte" do
+      wrapped = gte(5)
+      assert_equal wrapped.operator, '>='
+      assert_equal wrapped, ActiveRecord::Inequality::GreaterThanEqual.new(5)
+    end
+
+    should "have gt" do
+      wrapped = gt(5)
+      assert_equal wrapped.operator, '>'
+      assert_equal wrapped, ActiveRecord::Inequality::GreaterThan.new(5)
+    end
+
+    should "have lte" do
+      wrapped = lte(5)
+      assert_equal wrapped.operator, '<='
+      assert_equal wrapped, ActiveRecord::Inequality::LessThanEqual.new(5)
+    end
+
+    should "have lt" do
+      wrapped = lt(5)
+      assert_equal wrapped.operator, '<'
+      assert_equal wrapped, ActiveRecord::Inequality::LessThan.new(5)
+    end
+
+    should "have ne" do
+      wrapped = ne(5)
+      assert_equal wrapped.operator, '<>'
+      assert_equal wrapped, ActiveRecord::Inequality::NotEqual.new(5)
+    end
+
+    should "have a different operator when calling ne w/ nil" do
+      wrapped = ne(nil)
+      assert_equal wrapped.operator, 'IS NOT'
+      assert_equal wrapped, ActiveRecord::Inequality::NotEqual.new(nil)
+    end
+
+    should "have like" do
+      wrapped = like('ryan')
+      assert_equal wrapped.operator, 'LIKE'
+      assert_equal wrapped, ActiveRecord::Inequality::Like.new('ryan')
+    end
+
+  end
+
+  context "expand_range_bind_variables_orig" do
+    should "return a proper array" do
+      range_start = 1
+      range_end = 9
+
+      input = [{:a => 1}, (range_start..range_end), "Yo", {:c => 'd'}, 23, [1,2,3]]
+      res = ActiveRecord::Base.send :expand_range_bind_variables_orig, input
+
+      assert_equal res, [range_start, range_end, "Yo", 23, [1,2,3]]
+    end
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ryana-inequal_opportunity
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Ryan Angilly