ambition 0.3.1 → 0.5.0

data/lib/ambition/ruby_processor.rb

@@ -1,22 +0,0 @@
-module Ambition
-  class RubyProcessor < RubyToRuby
-    def self.process(node)
-      @processor ||= new
-      @processor.process node
-    end
-
-    ##
-    # This is not DRY, and I don't care.
-    def process(node)
-      node ||= []
-
-      if respond_to?(method = "process_#{node.first}") 
-        send(method, node[1..-1]) 
-      elsif node.blank?
-        ''
-      else
-        raise "Missing process method for sexp: #{node.inspect}"
-      end
-    end
-  end
-end

data/lib/ambition/select_processor.rb

@@ -1,149 +0,0 @@
-module Ambition
-  class SelectProcessor < Processor 
-    def initialize(owner, block)
-      super()
-      @receiver    = nil
-      @owner       = owner
-      @table_name  = owner.table_name
-      @block       = block
-      @key         = :conditions
-    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)
-      type, receiver, method, other = *exp.first
-
-      case type
-      when :call
-        translation(receiver, negate(method, other), other)
-      when :match3
-        regexp = receiver.last
-        "#{process(method)} #{statement(:negated_regexp, regexp)} #{sanitize(regexp)}"
-      else
-        process_error(exp)
-      end
-    end
-
-    def process_call(exp)
-      receiver, method, other = *exp
-
-      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, process(exp.shift)
-      "#{target} #{statement(:regexp, regexp)} #{sanitize(regexp)}"
-    end
-
-    def process_dvar(exp)
-      target = exp.shift
-      if target == @receiver
-        @table_name
-      else
-        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)
-      raise "Assignment not supported.  Maybe you meant ==?"
-    end
-
-    ##
-    #  Processor helper methods
-    def joined_expressions(with, exp)
-      clauses = []
-      while clause = exp.shift
-        clauses << clause
-      end
-      "(" + clauses.map { |c| process(c) }.join(" #{with} ") + ")"
-    end
-
-    def negate(method, target = nil)
-      if Array(target).last == [:nil]
-        return 'IS NOT'
-      end
-
-      case method
-      when :== 
-        '<>'
-      when :=~
-        '!~'
-      else 
-        raise "Not implemented: #{method.inspect}"
-      end
-    end
-    
-    def translation(receiver, method, other = nil)
-      case method.to_s
-      when 'IS NOT'
-        "#{process(receiver)} IS NOT #{process(other)}"
-      when '=='
-        case other_value = process(other)
-        when "NULL"
-          "#{process(receiver)} IS #{other_value}"
-        else
-          "#{process(receiver)} = #{other_value}"
-        end
-      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)}"
-      when 'upcase'
-        "UPPER(#{process(receiver)})"
-      when 'downcase'
-        "LOWER(#{process(receiver)})"
-      else
-        extract_includes(receiver, method) || "#{process(receiver)}.#{quote_column_name(method)}"
-      end
-    end
-  end
-end

data/lib/ambition/simple_processor.rb

@@ -1,10 +0,0 @@
-module Ambition
-  class SimpleProcessor 
-    attr_reader  :key, :value
-    alias_method :to_s, :value
-
-    def initialize(info = {})
-      @key, @value = info.to_a.first
-    end
-  end
-end

data/lib/ambition/sort_processor.rb

@@ -1,47 +0,0 @@
-module Ambition
-  class SortProcessor < Processor 
-    def initialize(owner, block)
-      super()
-      @receiver    = nil
-      @owner       = owner
-      @table_name  = owner.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
-        extract_includes(receiver, method) || "#{@table_name}.#{method}"
-      end
-    end
-  end
-end

data/lib/ambition/source.rb

@@ -1,53 +0,0 @@
-module Ambition
-  module Source
-    def self.api_methods
-      Ambition::API.instance_methods(false).reject do |method|
-        method =~ /ambition|context/
-      end
-    end
-
-    def self.included(base)
-      singleton = (class << base; self end)
-      api_methods.each do |method|
-        ##
-        # This is less than cool, but we do it to get what we want.
-        # When define_method can create a method which is block-aware,
-        # then we can move to pure Ruby.
-        singleton.class_eval <<-end_eval
-          def #{method}(*args, &block)
-            return super unless @ambition_source
-            @ambition_source.#{method}(*args, &block)
-          end
-        end_eval
-      end
-    end
-  end
-
-  module API
-    attr_reader :ambition_source
-
-    ##
-    # This is a destructive method.  When given an array,
-    # all Enumerable operations will be performed on the array
-    # rather than on the database.
-    #
-    #   User.ambition_source = users(:chris, :pj) 
-    #   User.select { |u| u.age > 30 }
-    #
-    # You don't have to use fixtures, of course.  Make stuff up on the fly.
-    #
-    #   users = [ User.new(:name => 'chris', :age => 11), User.new(:name => 'pj', :age => 100) ]
-    #   User.ambition_source = users
-    #   User.select { |u| u.age > 30 }
-    #
-    # Revert back to normal by setting ambition_source to nil.
-    #
-    #   User.ambition_source = nil
-    #   User.select { |u| u.age > 30 }
-    #
-    def ambition_source=(records)
-      @ambition_source = records
-      include Source unless ancestors.include? Source
-    end
-  end
-end

data/test/benchmark.rb

@@ -1,68 +0,0 @@
-$:.unshift File.dirname(__FILE__) + '/../lib'
-$NO_TEST = true
-%w( ambition rubygems active_record benchmark ).each { |f| require f }
-
-class User < ActiveRecord::Base
-  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
-
-Times = 1000
-
-Benchmark.bm(30) do |x|
-  x.report 'simple select' do
-    Times.times do
-      User.select { |u| u.id == 20 }.to_hash
-    end
-  end
-
-  x.report 'simple select w/ eval' do
-    Times.times do
-      User.select { |u| u.created_at == Time.now }.to_hash
-    end
-  end
-
-  x.report 'dual select' do
-    Times.times do
-      User.select { |u| u.id == 20 && u.age > 20 }.to_hash
-    end
-  end
-
-  x.report 'join select' do
-    Times.times do
-      User.select { |u| u.id == 20 && u.ideas.name =~ /stuff/ }.to_hash
-    end
-  end
-
-  x.report 'dual select w/ sort' do
-    Times.times do
-      User.select { |u| u.id == 20 && u.age > 20 }.sort_by { |u| u.id }.to_hash
-    end
-  end
-
-  x.report 'dual select w/ sort & first' do
-    Times.times do
-      User.select { |u| u.id == 20 && u.age > 20 }.sort_by { |u| u.id }.first(20).to_hash
-    end
-  end
-
-  x.report "it's complicated" do
-    Times.times do
-      User.select { |u| (u.id == 20 && u.age > 20) || u.profile.name == 'Jon' }.sort_by { |u| [u.id, -u.name] }.first(20).to_hash
-    end
-  end
-end

data/test/chaining_test.rb

@@ -1,34 +0,0 @@
-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/console

@@ -1,9 +0,0 @@
-#!/usr/bin/env ruby
-irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-libs = []
-dirname = File.dirname(__FILE__)
-
-libs << 'irb/completion'
-libs << File.join(dirname, 'databases', 'boot')
-
-exec "#{irb} #{libs.map{|l| " -r #{l}" }.join} --simple-prompt"

data/test/count_test.rb

@@ -1,17 +0,0 @@
-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/databases/boot.rb

@@ -1,3 +0,0 @@
-require File.dirname(__FILE__) + '/lib/load_fixtures'
-$:.unshift File.dirname(__FILE__) + '/../../lib'
-require 'ambition'

data/test/databases/database.yml

@@ -1,17 +0,0 @@
-sqlite3:
-  adapter: sqlite3
-  database: db/development.sqlite3
-
-mysql:
-  adapter: mysql
-  database: ambition_development
-  username: root
-  password: 
-  host: localhost
-
-postgres:
-  adapter: postgresql
-  database: ambition_development
-  username: root
-  password: 
-  host: localhost