ambition 0.1.0

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2007 Chris Wanstrath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
+the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest

@@ -0,0 +1,23 @@
+./init.rb
+./lib/ambition/count.rb
+./lib/ambition/enumerable.rb
+./lib/ambition/limit.rb
+./lib/ambition/order.rb
+./lib/ambition/processor.rb
+./lib/ambition/query.rb
+./lib/ambition/where.rb
+./lib/ambition.rb
+./lib/proc_to_ruby.rb
+./LICENSE
+./Rakefile
+./README
+./test/chaining_test.rb
+./test/count_test.rb
+./test/enumerable_test.rb
+./test/helper.rb
+./test/join_test.rb
+./test/limit_test.rb
+./test/order_test.rb
+./test/types_test.rb
+./test/where_test.rb
+./Manifest

data/README

@@ -0,0 +1,175 @@
+== Ambitious SQL
+
+A simple experiment and even simpler query library.
+
+I could tell you all about how awesome the internals are, or 
+how fun it was to write, or how it'll make you rich and famous, 
+but instead I'm just going to show you some examples. 
+
+The goal is this: write once, run with ActiveRecord, Sequel, DataMapper, whatever.  Kind
+of like Rack for databases.
+
+== Git It (Not with Git, though)
+
+  $ sudo gem install ambition -y
+
+This will suck in Ambition and its dependencies (ParseTree & ActiveRecord).  It's fully usable
+outside of Rails (I use it in a Camping app or two), as long as you're riding ActiveRecord.
+
+To use with Rails, after installing the gem:
+  
+  $ cd vendor/plugins
+  $ gem unpack ambition
+
+RDoc exists: http://rock.errtheblog.com/ambition
+
+== Examples
+
+Basically, you write your SQL in Ruby.  No, not in Ruby.  As Ruby.
+
+  User.select { |u| u.city == 'San Francisco' }.each do |user|
+    puts user.name
+  end
+
+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.
+
+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+, though.  Mostly ignore
+these methods and treat everything like you normally would.
+
+See, +to_sql+:
+  >> User.select { |m| m.name == 'jon' }.to_sql
+  => "SELECT * FROM users WHERE users.`name` = 'jon'"
+
+See, +to_hash+:
+  >> User.select { |m| m.name == 'jon' }.to_hash
+  => {:conditions=>"users.`name` = 'jon'"} 
+
+== Limitations
+
+You can use variables, but any more complex Ruby (right now) won't work
+inside your blocks.  Just do it outside the block and assign it to a variable, okay?
+
+Instead of:
+  User.select { |m| m.date == 2.days.ago }
+
+Just do:
+  date = 2.days.ago
+  User.select { |m| m.date == date }
+
+Instance variables and globals work, too.  Same with method calls.
+
+== Equality -- select { |u| u.field == 'bob' }
+
+  User.select { |m| m.name == 'jon' }
+  "SELECT * FROM users WHERE users.`name` = 'jon'"
+
+  User.select { |m| m.name != 'jon' }
+  "SELECT * FROM users WHERE users.`name` <> 'jon'"
+
+  User.select { |m| m.name == 'jon' && m.age == 21 }
+  "SELECT * FROM users WHERE (users.`name` = 'jon' AND users.`age` = 21)"
+
+  User.select { |m| m.name == 'jon' || m.age == 21 }
+  "SELECT * FROM users WHERE (users.`name` = 'jon' OR users.`age` = 21)"
+    
+  User.select { |m| m.name == 'jon' || m.age == 21 && m.password == 'pass' }
+  "SELECT * FROM users WHERE (users.`name` = 'jon' OR (users.`age` = 21 AND users.`password` = 'pass'))"
+
+  User.select { |m| (m.name == 'jon' || m.name == 'rick') && m.age == 21 }
+  "SELECT * FROM users WHERE ((users.`name` = 'jon' OR users.`name` = 'rick') AND users.`age` = 21)"
+
+== Associations -- select { |u| u.field == 'bob' && u.association.field == 'bob@bob.com' }
+
+The +to_sql+ method doesn't work on associations yet, but that's okay: they can still query through
+ActiveRecord just fine.
+
+  User.select { |u| u.email == 'chris@ozmm.org' && u.profile.name == 'chris wanstrath' }.map(&:title)
+  SELECT users.`id` AS t0_r0, ... FROM users LEFT OUTER JOIN profiles ON profiles.user_id = users.id WHERE ((users.`email` = 'chris@ozmm.org' AND profiles.name = 'chris wanstrath')) 
+
+== Comparisons -- select { |u| u.age > 21 }
+
+  User.select { |m| m.age > 21 }
+  "SELECT * FROM users WHERE users.`age` > 21"
+
+  User.select { |m| m.age < 21 }.to_sql
+  "SELECT * FROM users WHERE users.`age` < 21"
+
+  User.select { |m| [1, 2, 3, 4].include? m.id }
+  "SELECT * FROM users WHERE users.`id` IN (1, 2, 3, 4)"
+
+== LIKE and REGEXP (RLIKE) -- select { |m| m.name =~ 'chris' }
+
+  User.select { |m| m.name =~ 'chris' }
+  "SELECT * FROM users WHERE users.`name` LIKE 'chris'"
+
+  User.select { |m| m.name =~ 'chri%' }
+  "SELECT * FROM users WHERE users.`name` LIKE 'chri%'"
+
+  User.select { |m| m.name !~ 'chris' }
+  "SELECT * FROM users WHERE users.`name` NOT LIKE 'chris'"
+
+  User.select { |m| !(m.name =~ 'chris') }
+  "SELECT * FROM users WHERE users.`name` NOT LIKE 'chris'"
+
+  User.select { |m| m.name =~ /chris/ }
+  "SELECT * FROM users WHERE users.`name` REGEXP 'chris'"
+
+== #detect
+
+  User.detect { |m| m.name == 'chris' }
+  "SELECT * FROM users WHERE users.`name` = 'chris' LIMIT 1"
+
+== LIMITs -- first, first(x), [offset, limit], [range]
+
+  User.select { |m| m.name == 'jon' }.first
+  "SELECT * FROM users WHERE users.`name` = 'jon' LIMIT 1"
+
+  User.select { |m| m.name == 'jon' }.first(5)
+  "SELECT * FROM users WHERE users.`name` = 'jon' LIMIT 5"
+
+  User.select { |m| m.name == 'jon' }[10, 20]
+  "SELECT * FROM users WHERE users.`name` = 'jon' LIMIT 10, 20"
+
+  User.select { |m| m.name == 'jon' }[10..20]
+  "SELECT * FROM users WHERE users.`name` = 'jon' LIMIT 10, 10"
+
+== ORDER -- sort_by { |u| u.field }
+
+  User.select { |m| m.name == 'jon' }.sort_by { |m| m.name }
+  "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.name"
+
+  User.select { |m| m.name == 'jon' }.sort_by { |m| [ m.name,  m.age ] }
+  "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.name, users.age"
+
+  User.select { |m| m.name == 'jon' }.sort_by { |m| [ m.name,  -m.age ] }
+  "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.name, users.age DESC"
+
+  User.select { |m| m.name == 'jon' }.sort_by { |m| [ -m.name,  -m.age ] }
+  "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.name DESC, users.age DESC"
+
+  User.select { |m| m.name == 'jon' }.sort_by { |m| -m.age }
+  "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.age DESC"
+
+  User.select { |m| m.name == 'jon' }.sort_by { rand }
+  "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY RAND()"
+
+== COUNT -- select { |u| u.name == 'jon' }.size
+
+  User.select { |m| m.name == 'jon' }.size
+  SELECT count(*) AS count_all FROM users WHERE (users.`name` = 'jon') 
+
+  >> User.select { |m| m.name == 'jon' }.size
+  => 21
+
+== SELECT * FROM bugs 
+
+Found a bug?  Sweet.  Add it at the Lighthouse: http://err.lighthouseapp.com/projects/466-plugins/tickets/new
+
+Feature requests are welcome. 
+
+* Chris Wanstrath [ chris@ozmm.org ]

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test it!'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate RDoc documentation'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  files = ['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "ambition"
+  rdoc.template = File.exists?(t="/Users/chris/ruby/projects/err/rock/template.rb") ? t : "/var/www/rock/template.rb"
+  rdoc.rdoc_dir = 'doc' # rdoc output folder
+  rdoc.options << '--inline-source'
+end
+
+desc 'Generate coverage reports'
+task :rcov do
+  `rcov -e gems test/*_test.rb`
+  puts 'Generated coverage reports.'
+end
+
+
+begin
+  require 'rubygems'
+  gem 'echoe', '=1.3'
+  ENV['RUBY_FLAGS'] = ""
+  require 'echoe'
+
+  Echoe.new('ambition', '0.1.0') do |p|
+    p.rubyforge_name = 'err'
+    p.summary = "Ambition builds SQL from plain jane Ruby."
+    p.description = "Ambition builds SQL from plain jane Ruby."
+    p.url = "http://errtheblog.com/"
+    p.author = 'Chris Wanstrath'
+    p.email = "chris@ozmm.org"
+    p.extra_deps << ['ParseTree',    '=2.0.1']
+    p.extra_deps << ['activerecord', '>=1.15.0']
+  end
+
+rescue LoadError => boom
+  puts "You are missing a dependency required for meta-operations on this gem."
+  puts "#{boom.to_s.capitalize}."
+end

data/init.rb

@@ -0,0 +1 @@
+require 'ambition'

data/lib/ambition.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'proc_to_ruby'
+require 'ambition/processor'
+require 'ambition/query'
+require 'ambition/where'
+require 'ambition/order'
+require 'ambition/limit'
+require 'ambition/count'
+require 'ambition/enumerable'
+
+module Ambition 
+  include Where, Order, Limit, Enumerable, Count
+
+  attr_accessor :query_context
+
+  def query_context
+    @query_context || Query.new(self)
+  end
+end
+
+ActiveRecord::Base.extend Ambition

data/lib/ambition/count.rb

@@ -0,0 +1,8 @@
+module Ambition
+  module Count
+    def size
+      count(query_context.to_hash)
+    end
+    alias_method :length, :size
+  end
+end

data/lib/ambition/enumerable.rb

@@ -0,0 +1,9 @@
+module Ambition
+  module Enumerable
+    include ::Enumerable
+
+    def each(&block)
+      find(:all, query_context.to_hash).each(&block)
+    end
+  end
+end

data/lib/ambition/limit.rb

@@ -0,0 +1,34 @@
+module Ambition
+  module Limit
+    def first(limit = 1, offset = nil)
+      query_context.add LimitProcessor.new(limit, offset)
+      find(limit == 1 ? :first : :all, query_context.to_hash)
+    end
+
+    def [](offset, limit = nil)
+      return first(offset, limit) if limit
+
+      if offset.is_a? Range
+        limit  = offset.end
+        limit -= 1 if offset.exclude_end?
+        first(offset.first, limit - offset.first)
+      else
+        first(offset, 1)
+      end
+    end
+  end
+
+  class LimitProcessor 
+    def initialize(*args)
+      @args = args
+    end
+
+    def key
+      :limit
+    end
+
+    def to_s
+      @args.compact * ', '
+    end
+  end
+end

data/lib/ambition/order.rb

@@ -0,0 +1,52 @@
+module Ambition
+  module Order
+    def sort_by(&block)
+      query_context.add OrderProcessor.new(table_name, block)
+    end
+  end
+
+  class OrderProcessor < Processor 
+    def initialize(table_name, block)
+      super()
+      @receiver    = nil
+      @table_name  = table_name
+      @block       = block
+      @key         = :order
+    end
+
+    ##
+    # Sexp Processing Methods
+    def process_call(exp)
+      receiver, method, other = *exp
+      exp.clear
+
+      translation(receiver, method, other)
+    end
+
+    def process_vcall(exp)
+      if (method = exp.shift) == :rand
+        'RAND()'
+      else
+        raise "Not implemented: :vcall for #{method}"
+      end
+    end
+
+    def process_masgn(exp)
+      exp.clear
+      ''
+    end
+
+    ##
+    # Helpers!
+    def translation(receiver, method, other)
+      case method
+      when :-@
+        "#{process(receiver)} DESC"
+      when :__send__
+        "#{@table_name}.#{eval('to_s', @block)}"
+      else
+        "#{@table_name}.#{method}"
+      end
+    end
+  end
+end

data/lib/ambition/processor.rb

@@ -0,0 +1,54 @@
+require 'active_record/connection_adapters/abstract/quoting'
+
+module Ambition
+  class Processor < SexpProcessor 
+    include ActiveRecord::ConnectionAdapters::Quoting
+
+    attr_reader :key, :join_string, :prefix
+
+    def initialize
+      super()
+      @strict          = false
+      @expected        = String
+      @auto_shift_type = true
+      @warn_on_default = false
+      @default_method  = :process_error
+    end
+
+    ##
+    # Processing methods
+    def process_error(exp)
+      raise "Missing process method for sexp: #{exp.inspect}"
+    end
+
+    def process_proc(exp)
+      receiver, body = process(exp.shift), exp.shift
+      return process(body)
+    end
+
+    def process_dasgn_curr(exp)
+      @receiver = exp.shift
+      return @receiver.to_s
+    end
+
+    def process_array(exp)
+      arrayed = exp.map { |m| process(m) }
+      exp.clear
+      return arrayed.join(', ')
+    end
+
+    ##
+    # Helper methods
+    def to_s
+      process(@block.to_sexp).squeeze(' ')
+    end
+
+    def sanitize(value)
+      case value.to_s
+      when 'true'  then '1'
+      when 'false' then '0'
+      else ActiveRecord::Base.connection.quote(value) rescue quote(value)
+      end
+    end
+  end
+end

data/lib/ambition/query.rb

@@ -0,0 +1,81 @@
+module Ambition
+  class Query
+    @@select = 'SELECT * FROM %s %s'
+
+    def initialize(owner)
+      @table_name = owner.table_name
+      @owner      = owner
+      @clauses    = []
+    end
+
+    def add(clause) 
+      @clauses << clause
+      self
+    end
+
+    def method_missing(method, *args, &block) 
+      with_context do
+        @owner.send(method, *args, &block)
+      end
+    end
+
+    def with_context 
+      @owner.query_context = self
+      ret = yield
+    ensure
+      @owner.query_context = nil
+      ret
+    end
+
+    def to_hash
+      keyed = keyed_clauses
+      hash  = {}
+
+      unless (where = keyed[:conditions]).blank?
+        hash[:conditions] = Array(where)
+        hash[:conditions] *= ' AND '
+      end
+
+      unless (includes = keyed[:includes]).blank?
+        hash[:include] = includes.flatten
+      end
+
+      if order = keyed[:order]
+        hash[:order] = order.join(', ')
+      end
+
+      if limit = keyed[:limit]
+        hash[:limit] = limit.join(', ')
+      end
+
+      hash
+    end
+
+    def to_s
+      hash = keyed_clauses
+
+      sql = []
+      sql << "JOIN #{hash[:includes].join(', ')}"       unless hash[:includes].blank?
+      sql << "WHERE #{hash[:conditions].join(' AND ')}" unless hash[:conditions].blank?
+      sql << "ORDER BY #{hash[:order].join(', ')}"      unless hash[:order].blank?
+      sql << "LIMIT #{hash[:limit].join(', ')}"         unless hash[:limit].blank?
+
+      @@select % [ @table_name, sql.join(' ') ]
+    end
+    alias_method :to_sql, :to_s
+
+    def keyed_clauses
+      @clauses.inject({}) do |hash, clause|
+        hash[clause.key] ||= []
+        hash[clause.key] << clause.to_s
+
+        if clause.respond_to?(:includes) && !clause.includes.blank?
+          hash[:includes] ||= []
+          hash[:includes] << clause.includes
+        end
+
+        hash
+      end
+    end
+  end
+end

data/lib/ambition/where.rb

@@ -0,0 +1,158 @@
+module Ambition
+  module Where
+    def select(*args, &block)
+      query_context.add WhereProcessor.new(self, block)
+    end
+
+    def detect(&block)
+      select(&block).first
+    end
+  end
+
+  class WhereProcessor < Processor 
+    attr_reader :includes
+
+    def initialize(owner, block)
+      super()
+      @receiver    = nil
+      @owner       = owner
+      @table_name  = owner.table_name
+      @block       = block
+      @key         = :conditions
+      @includes    = []
+    end
+
+    ##
+    # Sexp Processing Methods
+    def process_and(exp)
+      joined_expressions 'AND', exp
+    end
+
+    def process_or(exp)
+      joined_expressions 'OR', exp
+    end
+
+    def process_not(exp)
+      _, receiver, method, other = *exp.first
+      exp.clear
+      return translation(receiver, negate(method), other)
+    end
+
+    def process_call(exp)
+      receiver, method, other = *exp
+      exp.clear
+
+      return translation(receiver, method, other)
+    end
+
+    def process_lit(exp)
+      exp.shift.to_s
+    end
+
+    def process_str(exp)
+      sanitize exp.shift
+    end
+
+    def process_nil(exp)
+      'NULL'
+    end
+
+    def process_false(exp)
+      sanitize 'false'
+    end
+
+    def process_true(exp)
+      sanitize 'true'
+    end
+
+    def process_match3(exp)
+      regexp, target = exp.shift.last.inspect.gsub('/',''), process(exp.shift)
+      "#{target} REGEXP '#{regexp}'"
+    end
+
+    def process_dvar(exp)
+      target = exp.shift
+      if target == @receiver
+        return @table_name
+      else
+        return value(target.to_s[0..-1])
+      end
+    end
+
+    def process_ivar(exp)
+      value(exp.shift.to_s[0..-1])
+    end
+
+    def process_lvar(exp)
+      value(exp.shift.to_s)
+    end
+
+    def process_vcall(exp)
+      value(exp.shift.to_s)
+    end
+
+    def process_gvar(exp)
+      value(exp.shift.to_s)
+    end
+
+    def process_attrasgn(exp)
+      exp.clear
+      raise "Assignment not supported.  Maybe you meant ==?"
+    end
+
+    ##
+    #  Processor helper methods
+    def joined_expressions(with, exp)
+      clauses = []
+      while clause = exp.shift
+        clauses << clause
+      end
+      return "(" + clauses.map { |c| process(c) }.join(" #{with} ") + ")"
+    end
+
+    def value(variable)
+      sanitize eval(variable, @block)
+    end
+
+    def negate(method)
+      case method
+      when :== 
+        '<>'
+      when :=~
+        '!~'
+      else 
+        raise "Not implemented: #{method}"
+      end
+    end
+
+    def translation(receiver, method, other)
+      case method.to_s
+      when '=='
+        "#{process(receiver)} = #{process(other)}"
+      when '<>', '>', '<'
+        "#{process(receiver)} #{method} #{process(other)}"
+      when 'include?'
+        "#{process(other)} IN (#{process(receiver)})"
+      when '=~'
+        "#{process(receiver)} LIKE #{process(other)}"
+      when '!~'
+        "#{process(receiver)} NOT LIKE #{process(other)}"
+      else
+        build_condition(receiver, method, other)
+      end
+    end
+
+    def build_condition(receiver, method, other)
+      if receiver.first == :call && receiver[1].last == @receiver
+        if reflection = @owner.reflections[receiver.last]
+          @includes << reflection.name unless @includes.include? reflection.name
+          "#{reflection.table_name}.#{method}"
+        else
+          raise "No reflection `#{receiver.last}' found on #{@owner}"
+        end
+      else
+        "#{process(receiver)}.`#{method}` #{process(other)}"
+      end
+    end
+  end
+end

data/lib/proc_to_ruby.rb

@@ -0,0 +1,36 @@
+##
+# Taken from ruby2ruby, Copyright (c) 2006 Ryan Davis under the MIT License
+require 'parse_tree'
+require 'unique'
+require 'sexp_processor'
+
+class Method
+  def with_class_and_method_name
+    if self.inspect =~ /<Method: (.*)\#(.*)>/ then
+      klass = eval $1
+      method  = $2.intern
+      raise "Couldn't determine class from #{self.inspect}" if klass.nil?
+      return yield(klass, method)
+    else
+      raise "Can't parse signature: #{self.inspect}"
+    end
+  end
+
+  def to_sexp
+    with_class_and_method_name do |klass, method|
+      ParseTree.new(false).parse_tree_for_method(klass, method)
+    end
+  end
+end
+
+class Proc
+  def to_method
+    Unique.send(:define_method, :proc_to_method, self)
+    Unique.new.method(:proc_to_method)
+  end
+
+  def to_sexp
+    body = self.to_method.to_sexp[2][1..-1]
+    [:proc, *body]
+  end
+end

data/test/chaining_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "Chaining" do
+  specify "should join selects with AND" do
+    sql = User.select { |m| m.name == 'jon' }
+    sql = sql.select { |m| m.age == 22 }
+    sql.to_sql.should == "SELECT * FROM users WHERE users.`name` = 'jon' AND users.`age` = 22"
+  end
+
+  specify "should join sort_bys with a comma" do
+    sql = User.select { |m| m.name == 'jon' }
+    sql = sql.sort_by { |m| m.name }
+    sql = sql.sort_by { |m| m.age }
+    sql.to_sql.should == "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.name, users.age"
+  end
+
+  specify "should join selects and sorts intelligently" do
+    sql = User.select { |m| m.name == 'jon' }
+    sql = sql.select { |m| m.age == 22 }
+    sql = sql.sort_by { |m| -m.name }
+    sql = sql.sort_by { |m| m.age }
+    sql.to_sql.should == "SELECT * FROM users WHERE users.`name` = 'jon' AND users.`age` = 22 ORDER BY users.name DESC, users.age"
+  end
+
+  specify "should join lots of selects and sorts intelligently" do
+    sql = User.select { |m| m.name == 'jon' }
+    sql = sql.select { |m| m.age == 22 }
+    sql = sql.sort_by { |m| m.name }
+    sql = sql.select { |m| m.power == true }
+    sql = sql.sort_by { |m| m.email }
+    sql = sql.select { |m| m.admin == true && m.email == 'chris@ozmm.org' }
+    sql.to_sql.should == "SELECT * FROM users WHERE users.`name` = 'jon' AND users.`age` = 22 AND users.`power` = 1 AND (users.`admin` = 1 AND users.`email` = 'chris@ozmm.org') ORDER BY users.name, users.email"
+  end
+end

data/test/count_test.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "Count" do
+  setup do
+    hash = { :conditions => "users.`name` = 'jon'" }
+    User.expects(:count).with(hash)
+    @sql = User.select { |m| m.name == 'jon' }
+  end
+
+  specify "size" do
+    @sql.size
+  end
+
+  specify "length" do
+    @sql.length
+  end
+end

data/test/enumerable_test.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "Each" do
+  specify "simple ==" do
+    hash = { :conditions => "users.`age` = 21" }
+    User.expects(:find).with(:all, hash).returns([])
+    User.select { |m| m.age == 21 }.each do |user|
+      puts user.name
+    end
+  end
+
+  specify "limit and conditions" do
+    hash = { :limit => '5', :conditions => "users.`age` = 21" }
+    User.expects(:find).with(:all, hash).returns([])
+    User.select { |m| m.age == 21 }.first(5).each do |user|
+      puts user.name
+    end
+  end
+
+  specify "limit and conditions and order" do
+    hash = { :limit => '5', :conditions => "users.`age` = 21", :order => 'users.name' }
+    User.expects(:find).with(:all, hash).returns([])
+    User.select { |m| m.age == 21 }.sort_by { |m| m.name }.first(5).each do |user|
+      puts user.name
+    end
+  end
+
+  specify "limit and order" do
+    hash = { :limit => '5', :order => 'users.name' }
+    User.expects(:find).with(:all, hash).returns([])
+    User.sort_by { |m| m.name }.first(5).each do |user|
+      puts user.name
+    end
+  end
+end
+
+context "Enumerable Methods" do
+  specify "map" do
+    hash = { :conditions => "users.`age` = 21" }
+    User.expects(:find).with(:all, hash).returns([])
+    User.select { |m| m.age == 21 }.map { |u| u.name }
+  end
+
+  specify "each_with_index" do
+    hash = { :conditions => "users.`age` = 21" }
+    User.expects(:find).with(:all, hash).returns([])
+    User.select { |m| m.age == 21 }.each_with_index do |user, i|
+      puts "#{i}: #{user.name}"
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'test/spec'
+require 'mocha'
+require 'redgreen'
+require 'active_support'
+require 'active_record'
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'ambition'
+
+class User
+  extend Ambition
+
+  def self.reflections
+    return @reflections if @reflections
+    @reflections = {}
+    @reflections[:ideas]    = Reflection.new(:has_many,   'user_id',     :ideas,   'ideas')
+    @reflections[:invites]  = Reflection.new(:has_many,   'referrer_id', :invites, 'invites')
+    @reflections[:profile]  = Reflection.new(:has_one,    'user_id',     :profile, 'profiles')
+    @reflections[:account]  = Reflection.new(:belongs_to, 'account_id',  :account, 'accounts')
+    @reflections
+  end
+
+  def self.table_name
+    'users'
+  end
+end
+
+class Reflection < Struct.new(:macro, :primary_key_name, :name, :table_name)
+end

data/test/join_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "Joins" do
+  specify "simple == on an association" do
+    sql = User.select { |m| m.account.email == 'chris@ozmm.org' }
+    sql.to_hash.should ==  { 
+      :conditions => "accounts.email = 'chris@ozmm.org'", 
+      :include => [:account] 
+    }
+  end
+
+  specify "simple mixed == on an association" do
+    sql = User.select { |m| m.name == 'chris' && m.account.email == 'chris@ozmm.org' }
+    sql.to_hash.should ==  { 
+      :conditions => "(users.`name` = 'chris' AND accounts.email = 'chris@ozmm.org')", 
+      :include => [:account] 
+    }
+  end
+
+  specify "multiple associations" do
+    sql = User.select { |m| m.ideas.title == 'New Freezer' || m.invites.email == 'pj@hyett.com' }
+    sql.to_hash.should ==  { 
+      :conditions => "(ideas.title = 'New Freezer' OR invites.email = 'pj@hyett.com')",
+      :include => [:ideas, :invites]
+    }
+  end
+
+  specify "non-existant associations" do
+    sql = User.select { |m| m.liquor.brand == 'Jack' }
+    should.raise { sql.to_hash } 
+  end
+end

data/test/limit_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "Limit" do
+  setup do
+    @sql = User.select { |m| m.name == 'jon' }
+  end
+
+  specify "first" do
+    conditions = { :conditions => "users.`name` = 'jon'", :limit => '1' }
+    User.expects(:find).with(:first, conditions)
+    @sql.first
+  end
+
+  specify "first with argument" do
+    conditions = { :conditions => "users.`name` = 'jon'", :limit => '5' }
+    User.expects(:find).with(:all, conditions)
+    @sql.first(5)
+  end
+
+  specify "[] with one element" do
+    conditions = { :conditions => "users.`name` = 'jon'", :limit => '10, 1' }
+    User.expects(:find).with(:all, conditions)
+    @sql[10]
+  end
+  
+  specify "[] with two elements" do
+    conditions = { :conditions => "users.`name` = 'jon'", :limit => '10, 20' }
+    User.expects(:find).with(:all, conditions)
+    @sql[10, 20]
+  end
+  
+  specify "[] with range" do
+    conditions = { :conditions => "users.`name` = 'jon'", :limit => '10, 10' }
+    User.expects(:find).with(:all, conditions)
+    @sql[10..20]
+  end
+end

data/test/order_test.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "Order" do
+  setup do
+    @sql = User.select { |m| m.name == 'jon' }
+  end
+
+  specify "simple order" do
+    string = @sql.sort_by { |m| m.name }.to_sql
+    string.should == "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.name"
+  end
+
+  specify "simple combined order" do
+    string = @sql.sort_by { |m| [ m.name,  m.age ] }.to_sql
+    string.should == "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.name, users.age"
+  end
+
+  specify "simple combined order with single reverse" do
+    string = @sql.sort_by { |m| [ m.name,  -m.age ] }.to_sql
+    string.should == "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.name, users.age DESC"
+  end
+
+  specify "simple combined order with two reverses" do
+    string = @sql.sort_by { |m| [ -m.name,  -m.age ] }.to_sql
+    string.should == "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.name DESC, users.age DESC"
+  end
+
+  specify "reverse order with -" do
+    string = @sql.sort_by { |m| -m.age }.to_sql
+    string.should == "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.age DESC"
+  end
+
+  xspecify "reverse order with #reverse" do
+    # TODO: not implemented
+    string = @sql.sort_by { |m| m.age }.reverse.to_sql
+    string.should == "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY users.age DESC"
+  end
+
+  specify "random order" do
+    string = @sql.sort_by { rand }.to_sql
+    string.should == "SELECT * FROM users WHERE users.`name` = 'jon' ORDER BY RAND()"
+  end
+  
+  specify "non-existent method to sort by" do
+    should.raise { @sql.sort_by { foo }.to_sql }
+  end
+
+  specify "Symbol#to_proc" do
+    string = User.sort_by(&:name).to_sql
+    string.should == "SELECT * FROM users ORDER BY users.name"
+  end
+end

data/test/types_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/helper'
+
+##
+# Once dynamically, once hardcoded
+context "Different types" do
+  types_hash = {
+    'string' => "'string'",
+    :symbol  => "'--- :symbol\n'",
+    1        => '1',
+    1.2      => '1.2',
+    nil      => 'NULL',
+    true     => '1',
+    false    => '0',
+    Time.now     => "'#{Time.now.to_s(:db)}'",
+    DateTime.now => "'#{DateTime.now.to_s(:db)}'",
+    Date.today   => "'#{Date.today.to_s(:db)}'"
+  }
+
+  types_hash.each do |type, translation|
+    specify "simple using #{type}" do
+      sql = User.select { |m| m.name == type }.to_sql
+      sql.should == "SELECT * FROM users WHERE users.`name` = #{translation}"
+    end
+  end
+
+  specify "float" do
+    sql = User.select { |m| m.name == 1.2 }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = 1.2"
+  end
+
+  specify "integer" do
+    sql = User.select { |m| m.name == 1 }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = 1"
+  end
+
+  specify "true" do
+    sql = User.select { |m| m.name == true }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = 1"
+  end
+
+  specify "false" do
+    sql = User.select { |m| m.name == false }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = 0"
+  end
+
+  specify "nil" do
+    sql = User.select { |m| m.name == nil }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = NULL"
+  end
+
+  xspecify "Time" do
+    # TODO: nothing but variables inside blocks for now
+    sql = User.select { |m| m.name == Time.now }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = NULL"
+  end
+end

data/test/where_test.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "Where (using select)" do
+  specify "simple ==" do
+    sql = User.select { |m| m.name == 'jon' }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = 'jon'"
+  end
+
+  specify "simple !=" do
+    sql = User.select { |m| m.name != 'jon' }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` <> 'jon'"
+  end
+
+  specify "simple == && ==" do
+    sql = User.select { |m| m.name == 'jon' && m.age == 21 }.to_sql
+    sql.should == "SELECT * FROM users WHERE (users.`name` = 'jon' AND users.`age` = 21)"
+  end
+
+  specify "simple == || ==" do
+    sql = User.select { |m| m.name == 'jon' || m.age == 21 }.to_sql
+    sql.should == "SELECT * FROM users WHERE (users.`name` = 'jon' OR users.`age` = 21)"
+  end
+
+  specify "mixed && and ||" do
+    sql = User.select { |m| m.name == 'jon' || m.age == 21 && m.password == 'pass' }.to_sql
+    sql.should == "SELECT * FROM users WHERE (users.`name` = 'jon' OR (users.`age` = 21 AND users.`password` = 'pass'))"
+  end
+
+  specify "grouped && and ||" do
+    sql = User.select { |m| (m.name == 'jon' || m.name == 'rick') && m.age == 21 }.to_sql
+    sql.should == "SELECT * FROM users WHERE ((users.`name` = 'jon' OR users.`name` = 'rick') AND users.`age` = 21)"
+  end
+
+  specify "simple >/<" do
+    sql = User.select { |m| m.age > 21 }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`age` > 21"
+
+    sql = User.select { |m| m.age < 21 }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`age` < 21"
+  end
+
+  specify "array.include? item" do
+    sql = User.select { |m| [1, 2, 3, 4].include? m.id }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`id` IN (1, 2, 3, 4)"
+  end
+
+  specify "simple == with variables" do
+    me = 'chris'
+    sql = User.select { |m| m.name == me }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = '#{me}'"
+  end
+
+  specify "simple == with method arguments" do
+    def test_it(name)
+      sql = User.select { |m| m.name == name }.to_sql
+      sql.should == "SELECT * FROM users WHERE users.`name` = '#{name}'"
+    end
+
+    test_it('chris')
+  end
+
+  specify "simple == with instance variables" do
+    @me = 'chris'
+    sql = User.select { |m| m.name == @me }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = '#{@me}'"
+  end
+
+  xspecify "simple == with instance variable method call" do
+    require 'ostruct'
+    @person = OpenStruct.new(:name => 'chris')
+
+    sql = User.select { |m| m.name == @person.name }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = '#{@person.name}'"
+  end
+
+  specify "simple == with global variables" do
+    $my_name = 'boston'
+    sql = User.select { |m| m.name == $my_name }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = '#{$my_name}'"
+  end
+
+  specify "simple == with method call" do
+    def band
+      'megadeth'
+    end
+
+    sql = User.select { |m| m.name == band }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` = '#{band}'"
+  end
+
+  specify "simple =~ with string" do
+    sql = User.select { |m| m.name =~ 'chris' }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` LIKE 'chris'"
+
+    sql = User.select { |m| m.name =~ 'chri%' }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` LIKE 'chri%'"
+  end
+
+  specify "simple !~ with string" do
+    sql = User.select { |m| m.name !~ 'chris' }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` NOT LIKE 'chris'"
+
+    sql = User.select { |m| !(m.name =~ 'chris') }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` NOT LIKE 'chris'"
+  end
+
+  specify "simple =~ with regexp" do
+    sql = User.select { |m| m.name =~ /chris/ }.to_sql
+    sql.should == "SELECT * FROM users WHERE users.`name` REGEXP 'chris'"
+  end
+
+  specify "undefined equality symbol" do
+    should.raise { User.select { |m| m.name =* /chris/ }.to_sql }
+  end
+  
+  specify "undefined inequality symbol" do
+    should.raise { User.select { |m| m.name !+ 'chris' }.to_sql }
+  end
+
+  xspecify "simple == with inline ruby" do
+    # TODO: implement this
+    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
+end
+
+context "Where (using detect)" do
+  specify "simple ==" do
+    conditions = { :conditions => "users.`name` = 'chris'", :limit => '1' }
+    User.expects(:find).with(:first, conditions)
+    User.detect { |m| m.name == 'chris' }
+  end
+
+  specify "nothing found" do
+    conditions = { :conditions => "users.`name` = 'chris'", :limit => '1' }
+    User.expects(:find).with(:first, conditions).returns(nil)
+    User.detect { |m| m.name == 'chris' }.should.be.nil
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: ambition
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-08-29 00:00:00 -07:00
+summary: Ambition builds SQL from plain jane Ruby.
+require_paths: 
+- lib
+email: chris@ozmm.org
+homepage: http://errtheblog.com/
+rubyforge_project: err
+description: Ambition builds SQL from plain jane Ruby.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Chris Wanstrath
+files: 
+- ./init.rb
+- ./lib/ambition/count.rb
+- ./lib/ambition/enumerable.rb
+- ./lib/ambition/limit.rb
+- ./lib/ambition/order.rb
+- ./lib/ambition/processor.rb
+- ./lib/ambition/query.rb
+- ./lib/ambition/where.rb
+- ./lib/ambition.rb
+- ./lib/proc_to_ruby.rb
+- ./LICENSE
+- ./Rakefile
+- ./README
+- ./test/chaining_test.rb
+- ./test/count_test.rb
+- ./test/enumerable_test.rb
+- ./test/helper.rb
+- ./test/join_test.rb
+- ./test/limit_test.rb
+- ./test/order_test.rb
+- ./test/types_test.rb
+- ./test/where_test.rb
+- ./Manifest
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ParseTree
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.0.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.15.0
+    version: