ambition 0.1.2 → 0.1.3

data/README

@@ -34,10 +34,13 @@ Basically, you write your SQL in Ruby.  No, not in Ruby.  As Ruby.
 
 And that's it.
 
-The key is the +each+ method.  You build up a +Query+ using +select+, +first+,
-and +sort_by+, then call +each+ on it.  This'll run the query and enumerate
-through the results.  Really, you can use any Enumerable method: +map+,
-+each_with_index+, etc.
+The key is that queries arent actually run until the data they represent is 
+requested. Usually this is done with what I call a kicker method. You can call them 
+that, too.
+
+Kicker methods are guys like +detect+, +each+, +each_with_index+, +map+, +entries+, 
++to_a+, and +first+ (with no argument). Methods like +select+, +sort_by+, and +first+ 
+(with an argument) are not kicker methods and return a +Query+ object without running any SQL.
 
 Our +Query+ object has two useful methods: +to_sql+ and +to_hash+.  With these,
 we can check out what exactly we're building.  Not everyone has +to_sql+,
@@ -127,7 +130,7 @@ still query through ActiveRecord just fine.
   User.detect { |m| m.name == 'chris' }
   "SELECT * FROM users WHERE users.`name` = 'chris' LIMIT 1"
 
-== LIMITs -- first, first(x), [offset, limit], [range]
+== LIMITs -- first, first(x), [offset, limit], [range], slice
 
   User.select { |m| m.name == 'jon' }.first
   "SELECT * FROM users WHERE users.`name` = 'jon' LIMIT 1"
@@ -173,6 +176,15 @@ still query through ActiveRecord just fine.
   >> User.select { |m| m.name == 'jon' }.size
   => 21
 
+== Other Enumerables
+
+  These methods perform COUNT() operations rather than loading your array into memory.  They're all 
+  kickers.
+  
+  User.any? { |m| m.name == 'jon' }
+  User.all? { |m| m.name == 'jon' }
+  User.select { |m| m.name == 'jon' }.empty?
+
 == SELECT * FROM bugs 
 
 Found a bug?  Sweet.  Add it at the Lighthouse: http://err.lighthouseapp.com/projects/466-plugins/tickets/new

data/Rakefile

@@ -8,7 +8,7 @@ begin
   ENV['RUBY_FLAGS'] = ""
   require 'echoe'
 
-  Echoe.new('ambition', '0.1.2') do |p|
+  Echoe.new('ambition', '0.1.3') do |p|
     p.rubyforge_name = 'err'
     p.summary = "Ambition builds SQL from plain jane Ruby."
     p.description = "Ambition builds SQL from plain jane Ruby."

data/lib/ambition/enumerable.rb

@@ -5,5 +5,22 @@ module Ambition
     def each(&block)
       find(:all, query_context.to_hash).each(&block)
     end
+
+    def any?(&block)
+      select(&block).size > 0
+    end
+
+    def all?(&block)
+      size == select(&block).size
+    end
+
+    def empty?
+      size.zero?
+    end
+
+    def entries
+      find(:all, query_context.to_hash)
+    end
+    alias_method :to_a, :entries
   end
 end

data/lib/ambition/limit.rb

@@ -16,6 +16,7 @@ module Ambition
         first(offset, 1)
       end
     end
+    alias_method :slice, :[]
   end
 
   class LimitProcessor 

data/test/constructive_test.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/helper'
+
+
+context "Constructive" do
+  xspecify "concat" do
+  end
+
+  xspecify "<<" do
+  end
+
+  xspecify "+=" do
+  end
+
+  xspecify "push" do
+  end
+end

data/test/destructive_test.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "Destructive" do
+  xspecify "clear" do
+  end
+  
+  xspecify "delete" do
+  end
+
+  xspecify "delete_if" do
+  end
+
+  xspecify "<<" do
+  end
+
+  xspecify "concat" do
+  end
+
+  xspecify "delete_at" do
+  end
+end

data/test/enumerable_test.rb

@@ -48,4 +48,48 @@ context "Enumerable Methods" do
       puts "#{i}: #{user.name}"
     end
   end
+
+  specify "any?" do
+    User.expects(:count).with(:conditions => "users.`age` > 21").returns(1)
+    User.any? { |u| u.age > 21 }.should == true
+  end
+
+  specify "all?" do
+    User.expects(:count).at_least_once.returns(10, 20)
+    User.all? { |u| u.age > 21 }.should == false
+
+    User.expects(:count).at_least_once.returns(10, 10)
+    User.all? { |u| u.age > 21 }.should == true
+  end
+
+  specify "empty?" do
+    User.expects(:count).with(:conditions => "users.`age` > 21").returns(1)
+    User.select { |u| u.age > 21 }.empty?.should.equal false
+
+    User.expects(:count).with(:conditions => "users.`age` > 21").returns(0)
+    User.select { |u| u.age > 21 }.empty?.should.equal true
+  end
+
+  specify "entries" do
+    User.expects(:find).with(:all, {})
+    User.entries
+
+    hash = { :conditions => "users.`age` = 21" }
+    User.expects(:find).with(:all, hash).returns([])
+    User.select { |m| m.age == 21 }.entries
+  end
+
+  specify "to_a" do
+    User.expects(:find).with(:all, {})
+    User.to_a
+  end
+
+  xspecify "each_slice" do
+  end
+
+  xspecify "max" do
+  end
+
+  xspecify "min" do
+  end
 end

data/test/limit_test.rb

@@ -29,6 +29,12 @@ context "Limit" do
     @sql[10, 20]
   end
   
+  specify "slice is an alias of []" do
+    conditions = { :conditions => "users.`name` = 'jon'", :limit => '10, 20' }
+    User.expects(:find).with(:all, conditions)
+    @sql.slice(10, 20)
+  end
+  
   specify "[] with range" do
     conditions = { :conditions => "users.`name` = 'jon'", :limit => '10, 10' }
     User.expects(:find).with(:all, conditions)

data/test/where_test.rb

@@ -122,6 +122,10 @@ context "Where (using select)" do
     sql = User.select { |m| m.created_at == 2.days.ago.to_s(:db) }.to_sql
     sql.should == "SELECT * FROM users WHERE users.`created_at` = #{2.days.ago.to_s(:db)}"
   end
+
+  specify "inspect" do
+    User.select { |u| u.name }.inspect.should.match %r(call #to_sql or #to_hash)
+  end
 end
 
 context "Where (using detect)" do

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ambition
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 date: 2007-08-30 00:00:00 -07:00
 summary: Ambition builds SQL from plain jane Ruby.
 require_paths: 
@@ -54,7 +54,9 @@ files:
 - ./Manifest
 test_files: 
 - test/chaining_test.rb
+- test/constructive_test.rb
 - test/count_test.rb
+- test/destructive_test.rb
 - test/enumerable_test.rb
 - test/join_test.rb
 - test/limit_test.rb