sqldsl 1.2.2 → 1.3.0

data/README

@@ -21,6 +21,11 @@ See the tests for more examples
 === Test Helper
 
     require 'test/unit'
+    unless File.directory? File.dirname(__FILE__) + '/../vendor/mocha-0.4.0/'
+      raise "mocha 4.0 is required to run the test suite. create the 'vendor' directory as a sibling of test and 'gem unpack mocha' in 'vendor'"
+    end
+    $:.unshift File.dirname(__FILE__) + '/../vendor/mocha-0.4.0/lib/'
+    require File.dirname(__FILE__) + '/../vendor/mocha-0.4.0/lib/mocha'
     require File.dirname(__FILE__) + '/../lib/sqldsl'
 
 === Insert Example
@@ -72,22 +77,102 @@ See the tests for more examples
     require File.dirname(__FILE__) + '/test_helper'
     
     class SelectAcceptanceTest < Test::Unit::TestCase
-      def test_simple_select
-        statement = Select[:column1, 'book', 10].from[:table1].where do
+      def test_select_with_where_methods
+        statement = Select[:column1, 'book', 10].from[:table1, :table2].where do
           equal :column1, 99
-          equal :column2, 'star'
+          not_equal :column1, 100
+          less_than :column2, 'foo'
+          less_than_or_equal :column3, :column4
+          greater_than :column1, 0
+          greater_than_or_equal :column2, 'bar'
+          is_not_null :column1
+          is_in :column1, [1,2]
+          is_not_in :column2, [3, 4]
+          exists 0
+          not_exists 0
         end
-        expected = "select column1, 'book', 10 from table1 where column1 = 99 and column2 = 'star'"
-        assert_equal expected, statement.to_sql
+        expected = "select column1, 'book', 10 from table1, table2
+                      where column1 = 99 and column1 <> 100 and column2 < 'foo' 
+                      and column3 <= column4 and column1 > 0 and column2 >= 'bar' 
+                      and column1 is not null and column1 in (1, 2) and column2 not in (3, 4) 
+                      and exists (0) and not exists (0)"
+        assert_equal expected.delete("\n").squeeze(" "), statement.to_sql
+      end
+      
+      def test_select_with_receive_any_objects_and_operators
+        statement = Select[:column1, 'book', 10].from[:table1, :table2].where do
+          table1.column1 = 99
+          column1 <=> 100
+          column2 < 'foo'
+          column3 <= column4
+          column1 > 0
+          column2 >= 'bar'
+          column1 ^ nil
+          column1 >> [1,2]
+          column2 << [3, 4]
+        end
+        expected = "select column1, 'book', 10 from table1, table2
+                      where table1.column1 = 99 and column1 <> 100 and column2 < 'foo' 
+                      and column3 <= column4 and column1 > 0 and column2 >= 'bar' 
+                      and column1 is not null and column1 in (1, 2) and column2 not in (3, 4)"
+        assert_equal expected.delete("\n").squeeze(" "), statement.to_sql
       end
       
-      def test_select_with_join
-        statement = Select[:column1, :column2].from[:table1, :table2].where do
-          equal :'table1.id', :'table2.table1_id'
+      def test_select_with_receive_any_objects_and_method_calls
+        statement = Select[:column1, 'book', 10].from[:table1, :table2].where do
+          column1.equal 99
+          column1.not_equal 100
+          column2.less_than 'foo'
+          column3.less_than_or_equal column4
+          column1.greater_than 0
+          column2.greater_than_or_equal 'bar'
+          column1.is_not_null
+          column1.is_in [1,2]
+          column2.is_not_in [3, 4]
         end
-        expected = "select column1, column2 from table1, table2 where table1.id = table2.table1_id"
+        expected = "select column1, 'book', 10 from table1, table2
+                      where column1 = 99 and column1 <> 100 and column2 < 'foo' 
+                      and column3 <= column4 and column1 > 0 and column2 >= 'bar' 
+                      and column1 is not null and column1 in (1, 2) and column2 not in (3, 4)"
+        assert_equal expected.delete("\n").squeeze(" "), statement.to_sql
+      end
+      
+      def test_select_with_receive_any_objects_and_method_calls
+        statement = Select[:column1, 'book', 10].from[:table1, :table2].where do
+          column1.equal 0
+        end.or do
+          column1 > 100
+        end
+        expected = "select column1, 'book', 10 from table1, table2 where column1 = 0 or column1 > 100"
         assert_equal expected, statement.to_sql
       end
+      
+      def test_columns_in_inner_where_are_validated_against_outer_tables
+        statement = Select.all.from[:table].where do
+          exists(Select.all.from[:inner_table => :aliased].where do
+            table.column1 = aliased.column1
+          end)
+        end
+        assert_equal 'select * from table where exists (select * from inner_table aliased where table.column1 = aliased.column1)', statement.to_sql
+      end
+    
+      def test_columns_in_where_are_validated_against_tables
+        assert_raises ArgumentError do
+          Select.all.from[:table].where do
+            not_table.cat = 12
+          end
+        end
+      end
+    
+      def test_columns_in_inner_where_are_validated_against_outer_and_inner_tables
+        assert_raises ArgumentError do
+          Select.all.from[:table].where do
+            exists(Select.all.from[:inner_table].where do
+              table.column1 = not_table.cat
+            end)
+          end
+        end
+      end
     end
 
 === Contributors

data/lib/array.rb

@@ -8,13 +8,4 @@ class Array
   def to_sql
     self.collect { |element| element.to_sql }.join(', ')
   end
-  
-  # call-seq: array.to_sql_equal(any) -> a_string
-  # 
-  # Returns a string containing the sql in expression
-  # 
-  #    [10, :column2, 'book'].to_sql_equal(:column1)       #=> "column1 in (10, column2, 'book')"
-  def to_sql_equal(lval)
-    "#{lval.to_sql } in (#{ self.to_sql })" 
-  end
 end

data/lib/delete.rb

@@ -17,6 +17,7 @@ class Delete < SqlStatement
   #    Delete.from[:table1].to_sql       #=> "delete from table1"
   def [](table)
     @to_sql += table.to_sql
+    @tables = [table]
     self
   end
 end

data/lib/numeric.rb

@@ -1,5 +1,4 @@
 class Numeric
-  include WhereValue
   # call-seq: numeric.to_sql -> a_numeric
   # 
   # Returns self

data/lib/or_where_builder.rb

@@ -0,0 +1,15 @@
+class OrWhereBuilder < WhereBuilder
+  
+  # call-seq: or_where.to_sql -> a_string
+  # 
+  # Returns a string by collecting all the conditions and joins them with ' and '.
+  # 
+  #    OrWhereBuilder.new [] do 
+  #      equal :column1, 10
+  #      equal :column2, 'book'
+  #    end.to_sql         #=> " or column1 = 10 and column2 = 'book'"
+  def to_sql
+    " or #{sql_parts.join(' and ')}"
+  end
+
+end

data/lib/receive_any.rb

@@ -1,26 +1,59 @@
 class ReceiveAny  #:nodoc:
-  attr_reader :to_sql
+  attr_reader :to_sql, :builder
   
   def initialize(identifier, builder)
     @to_sql = identifier.to_s
     @builder = builder
   end
   
-  def <=(arg)
-    @builder.sql_parts << "#{self.to_sql} <= #{arg.to_sql}"
+  def equal(arg)
+    builder.equal self, arg
   end
   
-  def >=(arg)
-    @builder.sql_parts << "#{self.to_sql} >= #{arg.to_sql}"
+  def not_equal(arg)
+    builder.not_equal self, arg
   end
+  alias <=> not_equal
   
-  def append_on_setter(lval, rval)
-    @builder.equal(lval.to_sym, rval)
+  def less_than(arg)
+    builder.less_than self, arg
   end
+  alias < less_than
+  
+  def less_than_or_equal(arg)
+    builder.less_than_or_equal self, arg
+  end
+  alias <= less_than_or_equal
+  
+  def greater_than(arg)
+    builder.greater_than self, arg
+  end
+  alias > greater_than
+  
+  def greater_than_or_equal(arg)
+    builder.greater_than_or_equal self, arg
+  end
+  alias >= greater_than_or_equal
+  
+  def is_in(arg)
+    builder.is_in self, arg
+  end
+  alias >> is_in
+  
+  def is_not_in(arg)
+    builder.is_not_in self, arg
+  end
+  alias << is_not_in
+  
+  def is_not_null(arg=nil)
+    builder.is_not_null self
+  end
+  alias ^ is_not_null
   
   def method_missing(sym, *args)
+    raise ArgumentError.new("#{self.to_sql} is not specified as a table in your from statement") unless @builder.tables.include?(self.to_sql.to_sym)
     @to_sql << ".#{sym.to_s}".chomp("=")
-    append_on_setter(self.to_sql, args.first) if sym.to_s =~ /=$/
+    self.equal args.first if sym.to_s =~ /=$/
     self
   end
 end

data/lib/select.rb

@@ -45,7 +45,11 @@ class Select < SqlStatement
   # 
   #    Select[1, :column1, 'book'].from[:table1, :table2].to_sql       #=> "select 1, column1, 'book' from table1, table2"
   def [](*table_names)
-    @to_sql += table_names.sort{ |x,y| x.to_s <=> y.to_s }.to_sql
+    @tables = table_names.inject([]) { |result, element| result + (element.is_a?(Hash) ? element.values : [element]) }
+
+    @to_sql += table_names.inject([]) do |result, element|
+      result + (element.is_a?(Symbol) ? [element] : element.to_a.inject([]) { |result, pair| result << :"#{pair.first} #{pair.last}" })
+    end.sort{ |x,y| x.to_s <=> y.to_s }.to_sql
     self
   end
   

data/lib/sql_statement.rb

@@ -1,4 +1,5 @@
 class SqlStatement
+  attr_accessor :tables
   attr_reader :to_sql
 
   def initialize(sql)  #:nodoc:
@@ -13,7 +14,19 @@ class SqlStatement
   # 
   #    Select[1].where { equal :column1, 1 }.to_sql       #=> "select 1 where column1 = 1"
   def where(&block)
-    @to_sql += WhereBuilder.new(&block).to_sql
+    @to_sql += WhereBuilder.new(self.tables, &block).to_sql
+    self
+  end
+  
+  # call-seq: sql_statement.or { block } -> a_sql_statement
+  # 
+  # Creates a new OrWhereBuilder instance, passing the block as a parameter, then executes to_sql on the OrWhereBuilder instance.
+  # The resulting string from the OrWhereBuilder instance is appended to the SQL statement.
+  # Returns self.
+  # 
+  #    Select[1].where { equal :column1, 1 }.or { equal :column1, 100 }.to_sql       #=> "select 1 where column1 = 1 or column1 = 100"
+  def or(&block)
+    @to_sql += OrWhereBuilder.new(self.tables, &block).to_sql
     self
   end
 end

data/lib/sqldsl.rb

@@ -1,6 +1,4 @@
 require File.dirname(__FILE__) + '/receive_any.rb'
-require File.dirname(__FILE__) + '/where_value.rb'
-require File.dirname(__FILE__) + '/object.rb'
 require File.dirname(__FILE__) + '/symbol.rb'
 require File.dirname(__FILE__) + '/array.rb'
 require File.dirname(__FILE__) + '/string.rb'
@@ -9,6 +7,7 @@ require File.dirname(__FILE__) + '/numeric.rb'
 require File.dirname(__FILE__) + '/time.rb'
 require File.dirname(__FILE__) + '/sql_statement.rb'
 require File.dirname(__FILE__) + '/where_builder.rb'
+require File.dirname(__FILE__) + '/or_where_builder.rb'
 require File.dirname(__FILE__) + '/select.rb'
 require File.dirname(__FILE__) + '/distinct_select.rb'
 require File.dirname(__FILE__) + '/insert.rb'

data/lib/string.rb

@@ -1,6 +1,4 @@
 class String
-  include WhereValue
-  
   # call-seq: string.to_sql -> a_string
   # 
   # Returns a string with single quotes escaped.

data/lib/symbol.rb

@@ -1,5 +1,4 @@
 class Symbol
-  include WhereValue
   # call-seq: symbol.to_sql -> a_string
   # 
   # Returns a string with single quotes escaped.

data/lib/update.rb

@@ -6,7 +6,9 @@ class Update < SqlStatement
     # 
     #    Update[:table1].to_sql       #=> "update table1"
     def [](table)
-      self.new("update #{table.to_sql}")
+      update = self.new("update #{table.to_sql}")
+      update.tables = [table]
+      update
     end
   end
   

data/lib/where_builder.rb

@@ -1,12 +1,15 @@
 class WhereBuilder
-
-  # call-seq: WhereBuilder.new(&block) -> a_where_builder
+  attr_reader :tables
+  
+  # call-seq: WhereBuilder.new(tables, &block) -> a_where_builder
   # 
   # Returns a new WhereBuilder.  At initialization time the block is instance evaled on the
   # new WhereBuilder instance.
   # 
-  #    WhereBuilder.new { equal :column1, 10 }.to_sql       #=> " where column1 = 10"
-  def initialize(&block)
+  #    WhereBuilder.new [:table1] { equal :column1, 10 }.to_sql       #=> " where column1 = 10"
+  def initialize(tables, &block)
+    raise ArgumentError.new("no block given to where, check for parenthesis usage") unless block_given?
+    @tables = tables.concat(eval("respond_to?(:tables) ? tables : []", block.binding))
     instance_eval(&block)
   end
   
@@ -14,25 +17,88 @@ class WhereBuilder
   # 
   # Appends an equality condition to the where SQL clause.
   # 
-  #    WhereBuilder.new { equal :column1, 10 }.to_sql       #=> " where column1 = 10"
+  #    where { equal :column1, 10 }.to_sql       #=> " where column1 = 10"
   def equal(lval, rval)
-    sql_parts << rval.to_sql_equal(lval)
+    add_condition(lval, "=", rval)
+  end
+  
+  # call-seq: where.not_equal(arg1, arg2)
+  # 
+  # Appends a not equal condition to the where SQL clause.
+  # 
+  #    where { not_equal :column1, 10 }.to_sql       #=> " where column1 <> 10"
+  def not_equal(lval, rval)
+    add_condition(lval, "<>", rval)
+  end
+  
+  # call-seq: where.less_than(arg1, arg2)
+  # 
+  # Appends a less than condition to the where SQL clause.
+  # 
+  #    where { less_than :column1, 10 }.to_sql       #=> " where column1 < 10"
+  def less_than(lval, rval)
+    add_condition(lval, "<", rval)
+  end
+  
+  # call-seq: where.less_than_or_equal(arg1, arg2)
+  # 
+  # Appends a less than or equal condition to the where SQL clause.
+  # 
+  #    where { less_than_or_equal :column1, 10 }.to_sql       #=> " where column1 <= 10"
+  def less_than_or_equal(lval, rval)
+    add_condition(lval, "<=", rval)
+  end
+  
+  # call-seq: where.greater_than(arg1, arg2)
+  # 
+  # Appends a greater than condition to the where SQL clause.
+  # 
+  #    where { greater_than :column1, 10 }.to_sql       #=> " where column1 > 10"
+  def greater_than(lval, rval)
+    add_condition(lval, ">", rval)
+  end
+  
+  # call-seq: where.greater_than_or_equal(arg1, arg2)
+  # 
+  # Appends a greater than or equal condition to the where SQL clause.
+  # 
+  #    where { greater_than_or_equal :column1, 10 }.to_sql       #=> " where column1 >= 10"
+  def greater_than_or_equal(lval, rval)
+    add_condition(lval, ">=", rval)
+  end
+  
+  # call-seq: where.is_in(arg1, arg2)
+  # 
+  # Appends an in condition to the where SQL clause.
+  # 
+  #    where { is_in :column1, [10, 20] }.to_sql       #=> " where column1 in (10, 20)"
+  def is_in(lval, rval)
+    add_parenthesis_condition(lval, "in", rval)
+  end
+  
+  # call-seq: where.is_not_in(arg1, arg2)
+  # 
+  # Appends a not in condition to the where SQL clause.
+  # 
+  #    where { is_not_in :column1, [10, 20] }.to_sql       #=> " where column1 not in (10, 20)"
+  def is_not_in(lval, rval)
+    add_parenthesis_condition(lval, "not in", rval)
   end
   
   # call-seq: where.not_null(arg1)
   # 
   # Appends a not null condition to the where SQL clause.
   # 
-  #    WhereBuilder.new { not_null :column1 }.to_sql       #=> " where column1 is not null"
-  def not_null(column)
-    sql_parts << "#{column} is not null"
+  #    where { is_not_null :column1 }.to_sql       #=> " where column1 is not null"
+  def is_not_null(column)
+    sql_parts << "#{column.to_sql} is not null"
   end
     
   # call-seq: where.exists(clause)
   # 
   # Appends an exists condition to the where SQL clause.
   # 
-  #    WhereBuilder.new { exists 'select id from table1' }.to_sql       #=> " where exists (select id from table1)"
+  #    where { exists 'select id from table1' }.to_sql       #=> " where exists (select id from table1)"
   def exists(clause)
     sql_parts << "exists (#{clause.to_sql})"
   end
@@ -41,7 +107,7 @@ class WhereBuilder
   # 
   # Appends an exists condition to the where SQL clause.
   # 
-  #    WhereBuilder.new { not_exists 'select id from table1' }.to_sql       #=> " where not exists (select id from table1)"
+  #    where { not_exists 'select id from table1' }.to_sql       #=> " where not exists (select id from table1)"
   def not_exists(clause)
     sql_parts << "not exists (#{clause.to_sql})"
   end
@@ -50,7 +116,7 @@ class WhereBuilder
   # 
   # Returns a string by collecting all the conditions and joins them with ' and '.
   # 
-  #    WhereBuilder.new do 
+  #    WhereBuilder.new [] do 
   #      equal :column1, 10
   #      equal :column2, 'book'
   #    end.to_sql         #=> " where column1 = 10 and column2 = 'book'"
@@ -58,12 +124,21 @@ class WhereBuilder
     " where #{sql_parts.join(' and ')}"
   end
   
+  def add_condition(lval, operator, rval) #:nodoc:
+    sql_parts << "#{lval.to_sql} #{operator} #{rval.to_sql}"
+  end
+  
+  def add_parenthesis_condition(lval, operator, rval) #:nodoc:
+    sql_parts << "#{lval.to_sql} #{operator} (#{rval.to_sql})"
+  end
+  
+  protected
   def sql_parts #:nodoc:
     @sql_parts ||= []
   end
   
   def method_missing(sym, *args) #:nodoc:
+    super unless args.empty?
     ReceiveAny.new(sym, self)
   end
-  
 end

data/rakefile.rb

@@ -27,7 +27,7 @@ Gem::manage_gems
 specification = Gem::Specification.new do |s|
 	s.name   = "sqldsl"
   s.summary = "A DSL for creating SQL Statements"
-	s.version = "1.2.2"
+	s.version = "1.3.0"
 	s.author = 'Jay Fields'
 	s.description = "A DSL for creating SQL Statements"
 	s.email = 'sqldsl-developer@rubyforge.org'

data/test/all_tests.rb

@@ -1 +1 @@
-Dir['**/*_test.rb'].each { |testCase| require testCase }
+Dir["#{File.dirname __FILE__}/*_test.rb"].each { |test_case| require test_case }

data/test/array_test.rb

@@ -4,8 +4,4 @@ class ArrayTest < Test::Unit::TestCase
   def test_to_sql_gives_of_to_sql_objects_comma_delimited
     assert_equal "too, 'the', 2", [:too, 'the', 2].to_sql
   end
-  
-  def test_sql_equal_uses_in
-    assert_equal "column1 in (too, 'the', 2)", [:too, 'the', 2].to_sql_equal(:column1)
-  end
 end

data/test/delete_test.rb

@@ -23,7 +23,7 @@ class DeleteTest < Test::Unit::TestCase
     assert_equal expected, statement.to_sql
   end
   
-  def test_if_where_is_called_with_no_block_gives_reminder_to_use_parents
+  def test_if_where_is_called_with_no_block_gives_reminder_to_use_parens
     assert_raise(ArgumentError) do
       statement = Delete.from[:potential_account_offers].where do
         exists Select[:'potential_account_offers.id'].from[:foo].where do

data/test/numeric_test.rb

@@ -4,9 +4,4 @@ class NumbericTest < Test::Unit::TestCase
   def test_to_sql_gives_self
     assert_equal 123, 123.to_sql
   end
-
-  def test_is_a_where_value_duck
-    assert_equal true, 123.respond_to?(:is_not_in)
-  end
-  
 end

data/test/receive_any_test.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ReceiveAnyTest < Test::Unit::TestCase
+
+  def test_method_calls_to_valid_table_names_are_okay
+    builder = stub(:tables => [:foo])
+    ReceiveAny.new(:foo, builder).column1
+  end
+  
+  def test_method_calls_to_invalid_table_names_raise_Argument_Error
+    assert_raises ArgumentError do
+      builder = stub(:tables => [])
+      ReceiveAny.new(:foo, builder).column1
+    end
+  end
+  
+  def test_equal
+    builder = mock
+    builder.expects(:equal).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    ReceiveAny.new(:foo, builder).equal 1
+  end
+  
+  def test_equal_operator
+    builder = mock
+    builder.expects(:equal).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    builder.expects(:tables).returns [:foo]
+    ReceiveAny.new(:foo, builder).bar = 1
+  end
+  
+  def test_not_equal
+    builder = mock
+    builder.expects(:not_equal).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    ReceiveAny.new(:foo, builder).not_equal 1
+  end
+  
+  def test_not_equal_operator
+    builder = mock
+    builder.expects(:equal).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    ReceiveAny.new(:foo, builder) <=> 1
+  end
+  
+  def test_less_than
+    builder = mock
+    builder.expects(:less_than).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    ReceiveAny.new(:foo, builder).less_than 1
+  end
+  
+  def test_less_than_operator
+    builder = mock
+    builder.expects(:less_than).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    ReceiveAny.new(:foo, builder) < 1
+  end
+  
+  def test_less_than_or_equal
+    builder = mock
+    builder.expects(:less_than_or_equal).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    ReceiveAny.new(:foo, builder).less_than_or_equal 1
+  end
+  
+  def test_less_than_or_equal_operator
+    builder = mock
+    builder.expects(:less_than_or_equal).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    ReceiveAny.new(:foo, builder) <= 1
+  end
+  
+  def test_greater_than
+    builder = mock
+    builder.expects(:greater_than).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    ReceiveAny.new(:foo, builder).greater_than 1
+  end
+  
+  def test_greater_than_operator
+    builder = mock
+    builder.expects(:greater_than).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    ReceiveAny.new(:foo, builder) > 1
+  end
+  
+  def test_greater_than_or_equal
+    builder = mock
+    builder.expects(:greater_than_or_equal).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    ReceiveAny.new(:foo, builder).greater_than_or_equal 1
+  end
+  
+  def test_greater_than_or_equal_operator
+    builder = mock
+    builder.expects(:greater_than_or_equal).with do |lval, rval|
+      lval.class == ReceiveAny && rval == 1
+    end
+    ReceiveAny.new(:foo, builder) >= 1
+  end
+  
+  def test_is_in
+    builder = mock
+    builder.expects(:is_in).with do |lval, rval|
+      lval.class == ReceiveAny && rval == [1,2]
+    end
+    ReceiveAny.new(:foo, builder).is_in [1,2]
+  end
+
+  def test_is_in_operator
+    builder = mock
+    builder.expects(:is_in).with do |lval, rval|
+      lval.class == ReceiveAny && rval == [1,2]
+    end
+    ReceiveAny.new(:foo, builder) >> [1,2]
+  end
+
+  def test_is_not_in
+    builder = mock
+    builder.expects(:is_not_in).with do |lval, rval|
+      lval.class == ReceiveAny && rval == [1,2]
+    end
+    ReceiveAny.new(:foo, builder).is_not_in [1,2]
+  end
+
+  def test_is_not_in_operator
+    builder = mock
+    builder.expects(:is_not_in).with do |lval, rval|
+      lval.class == ReceiveAny && rval == [1,2]
+    end
+    ReceiveAny.new(:foo, builder) << [1,2]
+  end
+
+  def test_is_not_null
+    builder = mock
+    builder.expects(:is_not_null).with do |lval|
+      lval.class == ReceiveAny
+    end
+    ReceiveAny.new(:foo, builder).is_not_null
+  end
+
+  def test_is_not_null_operator
+    builder = mock
+    builder.expects(:is_not_in).with do |lval|
+      lval.class == ReceiveAny
+    end
+    ReceiveAny.new(:foo, builder) ^ nil
+  end
+end

data/test/select_acceptance_test.rb

@@ -1,20 +1,100 @@
 require File.dirname(__FILE__) + '/test_helper'
 
 class SelectAcceptanceTest < Test::Unit::TestCase
-  def test_simple_select
-    statement = Select[:column1, 'book', 10].from[:table1].where do
+  def test_select_with_where_methods
+    statement = Select[:column1, 'book', 10].from[:table1, :table2].where do
       equal :column1, 99
-      equal :column2, 'star'
+      not_equal :column1, 100
+      less_than :column2, 'foo'
+      less_than_or_equal :column3, :column4
+      greater_than :column1, 0
+      greater_than_or_equal :column2, 'bar'
+      is_not_null :column1
+      is_in :column1, [1,2]
+      is_not_in :column2, [3, 4]
+      exists 0
+      not_exists 0
     end
-    expected = "select column1, 'book', 10 from table1 where column1 = 99 and column2 = 'star'"
-    assert_equal expected, statement.to_sql
+    expected = "select column1, 'book', 10 from table1, table2
+                  where column1 = 99 and column1 <> 100 and column2 < 'foo' 
+                  and column3 <= column4 and column1 > 0 and column2 >= 'bar' 
+                  and column1 is not null and column1 in (1, 2) and column2 not in (3, 4) 
+                  and exists (0) and not exists (0)"
+    assert_equal expected.delete("\n").squeeze(" "), statement.to_sql
+  end
+  
+  def test_select_with_receive_any_objects_and_operators
+    statement = Select[:column1, 'book', 10].from[:table1, :table2].where do
+      table1.column1 = 99
+      column1 <=> 100
+      column2 < 'foo'
+      column3 <= column4
+      column1 > 0
+      column2 >= 'bar'
+      column1 ^ nil
+      column1 >> [1,2]
+      column2 << [3, 4]
+    end
+    expected = "select column1, 'book', 10 from table1, table2
+                  where table1.column1 = 99 and column1 <> 100 and column2 < 'foo' 
+                  and column3 <= column4 and column1 > 0 and column2 >= 'bar' 
+                  and column1 is not null and column1 in (1, 2) and column2 not in (3, 4)"
+    assert_equal expected.delete("\n").squeeze(" "), statement.to_sql
   end
   
-  def test_select_with_join
-    statement = Select[:column1, :column2].from[:table1, :table2].where do
-      equal :'table1.id', :'table2.table1_id'
+  def test_select_with_receive_any_objects_and_method_calls
+    statement = Select[:column1, 'book', 10].from[:table1, :table2].where do
+      column1.equal 99
+      column1.not_equal 100
+      column2.less_than 'foo'
+      column3.less_than_or_equal column4
+      column1.greater_than 0
+      column2.greater_than_or_equal 'bar'
+      column1.is_not_null
+      column1.is_in [1,2]
+      column2.is_not_in [3, 4]
     end
-    expected = "select column1, column2 from table1, table2 where table1.id = table2.table1_id"
+    expected = "select column1, 'book', 10 from table1, table2
+                  where column1 = 99 and column1 <> 100 and column2 < 'foo' 
+                  and column3 <= column4 and column1 > 0 and column2 >= 'bar' 
+                  and column1 is not null and column1 in (1, 2) and column2 not in (3, 4)"
+    assert_equal expected.delete("\n").squeeze(" "), statement.to_sql
+  end
+  
+  def test_select_with_receive_any_objects_and_method_calls
+    statement = Select[:column1, 'book', 10].from[:table1, :table2].where do
+      column1.equal 0
+    end.or do
+      column1 > 100
+    end
+    expected = "select column1, 'book', 10 from table1, table2 where column1 = 0 or column1 > 100"
     assert_equal expected, statement.to_sql
   end
+  
+  def test_columns_in_inner_where_are_validated_against_outer_tables
+    statement = Select.all.from[:table].where do
+      exists(Select.all.from[:inner_table => :aliased].where do
+        table.column1 = aliased.column1
+      end)
+    end
+    assert_equal 'select * from table where exists (select * from inner_table aliased where table.column1 = aliased.column1)', statement.to_sql
+  end
+
+  def test_columns_in_where_are_validated_against_tables
+    assert_raises ArgumentError do
+      Select.all.from[:table].where do
+        not_table.cat = 12
+      end
+    end
+  end
+
+  def test_columns_in_inner_where_are_validated_against_outer_and_inner_tables
+    assert_raises ArgumentError do
+      Select.all.from[:table].where do
+        exists(Select.all.from[:inner_table].where do
+          table.column1 = not_table.cat
+        end)
+      end
+    end
+  end
 end

data/test/select_test.rb

@@ -23,8 +23,7 @@ class SelectTest < Test::Unit::TestCase
   end
     
   def test_select_with_multiple_tables
-    assert_equal 'select column from bar, foo',
-                 Select[:column].from[:foo, :bar].to_sql
+    assert_equal 'select column from bar, foo', Select[:column].from[:foo, :bar].to_sql
   end
   
   def test_order_by
@@ -44,11 +43,19 @@ class SelectTest < Test::Unit::TestCase
   end
   
   def test_table_aliasing
-    assert_equal 'select * from table1 as foo, table2 as bar', Select.all.from[:table1 => :foo, :table2 => :bar].to_sql
+    assert_equal 'select * from table1 foo, table2 bar', Select.all.from[:table1 => :foo, :table2 => :bar].to_sql
+  end
+  
+  def test_tables_no_aliasing
+    assert_equal 'select * from table1, table2', Select.all.from[:table1, :table2].to_sql
   end
   
   def test_select_all
     assert_equal 'select *', Select.all.to_sql
   end
   
+  def test_table_array
+    assert_equal [:table1, :table2], Select.all.from[:table1, :table2].instance_variable_get("@tables")
+  end
+  
 end 

data/test/string_test.rb

@@ -8,9 +8,4 @@ class StringTest < Test::Unit::TestCase
   def test_to_sql_gives_quoted_and_escapes_single_quotes
     assert_equal "'it''s'", "it's".to_sql
   end
-  
-  def test_is_a_where_value_duck
-    assert_equal true, "foo".respond_to?(:is_not_in)
-  end
-  
 end

data/test/symbol_test.rb

@@ -4,9 +4,4 @@ class SymbolTest < Test::Unit::TestCase
   def test_to_sql_returns_to_s
     assert_equal 'asdf', :asdf.to_sql
   end
-  
-  def test_is_a_where_value_duck
-    assert_equal true, :sym.respond_to?(:is_not_in)
-  end
-  
 end

data/test/test_helper.rb

@@ -1,2 +1,7 @@
 require 'test/unit'
+unless File.directory? File.dirname(__FILE__) + '/../vendor/mocha-0.4.0/'
+  raise "mocha 4.0 is required to run the test suite. create the 'vendor' directory as a sibling of test and 'gem unpack mocha' in 'vendor'"
+end
+$:.unshift File.dirname(__FILE__) + '/../vendor/mocha-0.4.0/lib/'
+require File.dirname(__FILE__) + '/../vendor/mocha-0.4.0/lib/mocha'
 require File.dirname(__FILE__) + '/../lib/sqldsl'

data/test/where_builder_test.rb

@@ -2,108 +2,117 @@ require File.dirname(__FILE__) + '/test_helper'
 
 class WhereBuilderTest < Test::Unit::TestCase
   
-  def test_single_equal_where_criteria
-    statement = WhereBuilder.new do
-      equal :'foo.column1', :'bar.column2'
-    end
-    assert_equal ' where foo.column1 = bar.column2', statement.to_sql
+  def test_condition_calls_to_sql
+    lval, rval = mock, mock
+    lval.expects(:to_sql).returns "lval"
+    rval.expects(:to_sql).returns "rval"
+    where = WhereBuilder.new([], &lambda {})
+    where.add_condition(lval, "op", rval)
+    assert_equal "lval op rval", where.send(:sql_parts).first
   end
-
-  def test_less_then_equal_where_criteria
-    statement = WhereBuilder.new do
-      column1 <= column2
-    end
-    assert_equal " where column1 <= column2", statement.to_sql
+  
+  def test_parenthesis_condition_calls_to_sql
+    lval, rval = mock, mock
+    lval.expects(:to_sql).returns "lval"
+    rval.expects(:to_sql).returns "rval"
+    where = WhereBuilder.new([], &lambda {})
+    where.add_parenthesis_condition(lval, "op", rval)
+    assert_equal "lval op (rval)", where.send(:sql_parts).first
   end
-
-  def test_less_then_equal_with_table_aliasing_where_criteria
-    statement = WhereBuilder.new do
-      table1.column1 <= table2.column2
+  
+  def test_method_missing_for_receive_any_creation
+    assert_equal ReceiveAny, WhereBuilder.new([], &lambda {}).missing_method.class
+  end
+  
+  def test_method_missing_when_method_call_is_likely_a_mistake
+    assert_raises NoMethodError do
+      WhereBuilder.new([], &lambda {}).missing_method(:with_args)
     end
-    assert_equal " where table1.column1 <= table2.column2", statement.to_sql
   end
   
-  def test_less_then_equal_with_table_aliasing_where_criteria
-    statement = WhereBuilder.new do
-      table1.column1 >= table2.column2
+  def test_equal
+    statement = WhereBuilder.new [] do
+      equal :column1, :column2
     end
-    assert_equal " where table1.column1 >= table2.column2", statement.to_sql
+    assert_equal ' where column1 = column2', statement.to_sql
   end
   
-  def test_equal_with_table_aliasing_where_criteria
-    statement = WhereBuilder.new do
-      table1.Column1 = table2.Folumn2
+  def test_not_equal
+    statement = WhereBuilder.new [] do
+      not_equal :column1, :column2
     end
-    assert_equal " where table1.Column1 = table2.Folumn2", statement.to_sql
+    assert_equal " where column1 <> column2", statement.to_sql
   end
 
-  def test_equal_with_a_numeric
-    statement = WhereBuilder.new do
-      table1.Column1 = 1
+  def test_is_in_array
+    statement = WhereBuilder.new [] do
+      is_in :column1, [1,2]
     end
-    assert_equal " where table1.Column1 = 1", statement.to_sql
+    assert_equal " where column1 in (1, 2)", statement.to_sql
   end
 
-  def test_equal_with_a_string
-    statement = WhereBuilder.new do
-      table1.Column1 = "foo"
+  def test_is_not_in_where_criteria
+    statement = WhereBuilder.new [] do
+      is_not_in :column1, [1,2]
     end
-    assert_equal " where table1.Column1 = 'foo'", statement.to_sql
+    assert_equal ' where column1 not in (1, 2)', statement.to_sql
   end
 
-  def test_single_equal_with_array_where_criteria
-    statement = WhereBuilder.new do
-      equal :'foo.column1', ['foo','bar']
+  def test_less_than
+    statement = WhereBuilder.new [] do
+      less_than :column1, :column2
     end
-    assert_equal " where foo.column1 in ('foo', 'bar')", statement.to_sql
+    assert_equal " where column1 < column2", statement.to_sql
+  end
+  
+  def test_less_than_or_equal
+    statement = WhereBuilder.new [] do
+      less_than_or_equal :column1, :column2
+    end
+    assert_equal " where column1 <= column2", statement.to_sql
   end
 
-  def test_multiple_equal_with_more_than_one_where_criteria
-    statement = WhereBuilder.new do
-      equal :'foo.column1', :'bar.column2'
-      equal :'foo.column3', :'bar.column5'
+  def test_greater_than
+    statement = WhereBuilder.new [] do
+      greater_than :column1, :column2
     end
-    expected = " where foo.column1 = bar.column2 and foo.column3 = bar.column5"
-    assert_equal expected, statement.to_sql
+    assert_equal " where column1 > column2", statement.to_sql
+  end
+  
+  def test_greater_than_or_equal
+    statement = WhereBuilder.new [] do
+      greater_than_or_equal :column1, :column2
+    end
+    assert_equal " where column1 >= column2", statement.to_sql
   end
   
-  def test_with_literal_where_criteria
-    statement = WhereBuilder.new do
-      equal 'foo.column1', :'bar.column2'
-      equal :'foo.column3', 'bar.column5'
+  def test_where_clause_is_built_with_multiple_conditions
+    statement = WhereBuilder.new [] do
+      equal :column1, :column2
+      equal :column3, :column5
     end
-    expected = " where 'foo.column1' = bar.column2 and foo.column3 = 'bar.column5'"
+    expected = " where column1 = column2 and column3 = column5"
     assert_equal expected, statement.to_sql
   end
   
-  def test_exists_evaluates_sql_statement_followed
-    statement = WhereBuilder.new do
+  def test_exists_evaluates_sql_statement_argument
+    statement = WhereBuilder.new [] do
       exists Struct.new(:to_sql).new('select foo')
     end
     assert_equal ' where exists (select foo)', statement.to_sql
   end
   
-  def test_not_exists_evaluates_sql_statement_followed
-    statement = WhereBuilder.new do
+  def test_not_exists_evaluates_sql_statement_argument
+    statement = WhereBuilder.new [] do
       not_exists Struct.new(:to_sql).new('select foo')
     end
     assert_equal ' where not exists (select foo)', statement.to_sql
   end
   
   def test_is_not_null_where_criteria
-    statement = WhereBuilder.new do
-      not_null :something
+    statement = WhereBuilder.new [] do
+      is_not_null Struct.new(:to_sql).new('something')
     end
     assert_equal ' where something is not null', statement.to_sql
   end
-  
-  def test_is_not_in_where_criteria
-    statement = WhereBuilder.new do
-      :column1.is_not_in do
-        Select[:shipment_option_id]
-      end
-    end
-    assert_equal ' where column1 not in (select shipment_option_id)', statement.to_sql
-  end
-  
-end
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
+rubygems_version: 0.8.11
 specification_version: 1
 name: sqldsl
 version: !ruby/object:Gem::Version 
-  version: 1.2.2
-date: 2007-03-01 00:00:00 -05:00
+  version: 1.3.0
+date: 2007-03-11 00:00:00 -05:00
 summary: A DSL for creating SQL Statements
 require_paths: 
 - lib
@@ -25,7 +25,6 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
-post_install_message: 
 authors: 
 - Jay Fields
 files: 
@@ -35,7 +34,7 @@ files:
 - lib/hash.rb
 - lib/insert.rb
 - lib/numeric.rb
-- lib/object.rb
+- lib/or_where_builder.rb
 - lib/receive_any.rb
 - lib/select.rb
 - lib/sql_statement.rb
@@ -45,7 +44,6 @@ files:
 - lib/time.rb
 - lib/update.rb
 - lib/where_builder.rb
-- lib/where_value.rb
 - test/all_tests.rb
 - test/array_test.rb
 - test/delete_acceptance_test.rb
@@ -54,7 +52,7 @@ files:
 - test/insert_acceptance_test.rb
 - test/insert_test.rb
 - test/numeric_test.rb
-- test/object_test.rb
+- test/receive_any_test.rb
 - test/select_acceptance_test.rb
 - test/select_test.rb
 - test/string_test.rb
@@ -64,7 +62,6 @@ files:
 - test/update_acceptance_test.rb
 - test/update_test.rb
 - test/where_builder_test.rb
-- test/where_value_test.rb
 - rakefile.rb
 - README
 test_files: 

data/lib/object.rb

@@ -1,34 +0,0 @@
-class Object
-
-  # call-seq: obj.to_sql_equal(any) -> a_string
-  # 
-  # Returns a string containing the sql equality expression
-  # 
-  #    10.to_sql_equal(:column1)       #=> "column1 = 10"
-  def to_sql_equal(lval)
-    sql_expression(lval, "=")
-  end
-  
-  def to_sql_more_than(lval) #:nodoc:
-    sql_expression(lval, ">")
-  end
-  
-  def to_sql_less_than(lval) #:nodoc:
-    sql_expression(lval, "<")
-  end
-  
-  def to_sql_less_than_or_equal_to(lval) #:nodoc:
-    sql_expression(lval, "<=")
-  end
-
-  def to_sql_more_than_or_equal_to(lval) #:nodoc:
-    sql_expression(lval, ">=")
-  end  
-
-  protected
-
-  def sql_expression(lval, operator) #:nodoc:
-    "#{ lval.to_sql } #{operator} #{ self.to_sql }"
-  end
-
-end

data/lib/where_value.rb

@@ -1,8 +0,0 @@
-module WhereValue
-  
-  def is_not_in &block
-    builder = eval "self", block.binding
-    builder.sql_parts << "#{self.to_sql} not in (#{block.call.to_sql})"
-  end
-  
-end

data/test/object_test.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class ObjectTest < Test::Unit::TestCase 
-
-  def test_to_sql_equal
-    assert_equal "column1 = foo", foo.to_sql_equal(:column1)
-  end  
-  
-  def test_to_sql_more_than
-    assert_equal "column1 > foo", foo.to_sql_more_than(:column1)
-  end
-  
-  def test_to_sql_less_than
-    assert_equal "column1 < foo", foo.to_sql_less_than(:column1)
-  end
-  
-  def test_to_sql_less_than_equal
-    assert_equal "column1 <= foo", foo.to_sql_less_than_or_equal_to(:column1)
-  end
-  
-  def test_to_sql_more_than_equal
-    assert_equal "column1 >= foo", foo.to_sql_more_than_or_equal_to(:column1)
-  end
-  
-  def foo
-    Struct.new(:to_sql).new(:foo)
-  end
-
-end 

data/test/where_value_test.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class WhereValueTest < Test::Unit::TestCase
-  
-  def test_not_in_sql_statement_with_value
-    klass = Class.new() do
-      include WhereValue
-      
-      def to_sql
-        "klass"
-      end
-    end
-    
-    statement = Select[:foo].where do
-      klass.new.is_not_in do
-        "anything"
-      end
-    end
-    assert_equal "select foo where klass not in ('anything')", statement.to_sql
-  end
-  
-end