cheat 1.2.1 → 1.3.0

data/lib/ambition/lib/ambition/where.rb

@@ -0,0 +1,164 @@
+module Ambition
+  module Where
+    def select(*args, &block)
+      ##
+      # XXX: AR::Base hack / workaround
+      if args.empty?
+        query_context.add WhereProcessor.new(self, block)
+      else
+        super
+      end
+    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/ambition/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/lib/ambition/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/lib/ambition/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/lib/ambition/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/lib/ambition/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/lib/ambition/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'", 
+      :includes => [: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')", 
+      :includes => [: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')",
+      :includes => [:ideas, :invites]
+    }
+  end
+
+  specify "non-existant associations" do
+    sql = User.select { |m| m.liquor.brand == 'Jack' }
+    should.raise { sql.to_hash } 
+  end
+end

data/lib/ambition/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/lib/ambition/test/order_test.rb

@@ -0,0 +1,48 @@
+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 "Symbol#to_proc" do
+    string = User.sort_by(&:name).to_sql
+    string.should == "SELECT * FROM users ORDER BY users.name"
+  end
+end