ambition 0.3.1 → 0.5.0

data/lib/ambition/processors/ruby.rb

@@ -0,0 +1,24 @@
+module Ambition
+  module Processors
+    class Ruby < 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
+end

data/lib/ambition/processors/select.rb

@@ -0,0 +1,105 @@
+module Ambition
+  module Processors
+    class Select < Base
+      def initialize(context, block)
+        @context  = context
+        @block    = block
+      end
+
+      def process_call(args)
+        # Operation (m.name == 'chris')
+        #   [[:call, [:dvar, :m], :name], :==, [:array, [:str, "chris"]]]
+        if args.size == 3
+          left, operator, right = args
+
+          # params are passed as an array, even when only one element:
+          #  abc(1)
+          #  => [:fcall, :abc, [:array, [:lit, 1]]
+          #  abc([1])
+          #  => [:fcall, :abc, [:array, [:array, [:lit, 1]]]]
+          if right.first == :array 
+            right = process(right)
+            right = right.is_a?(Array) ? right.first : right
+          else
+            right = process(right)
+          end
+
+          translator.send(process_operator(operator), process(left), right)
+
+        # Property of passed arg:
+        #   [[:dvar, :m], :name]
+        elsif args.first.last == @receiver
+          translator.call(*args[1..-1])
+
+        # Method call: 
+        #   [[:call, [:dvar, :m], :name], :upcase]
+        elsif args.first.first == :call && args.first[1].last == @receiver
+          receiver, method = args
+          translator.chained_call(receiver.last, method)
+
+        # Deep, chained call:
+        #   [[:call, [:call, [:call, [:dvar, :m], :created_at], :something], :else], :perhaps]
+        elsif args.flatten.include? @receiver
+          calls = []
+
+          until args.empty?
+            args = args.last if args.last.is_a?(Array)
+            break if args.last == @receiver
+            calls << args.pop
+          end
+
+          translator.chained_call(*calls.reverse)
+
+        else
+          raise args.inspect
+        end
+      end
+
+      def process_match3(exp)
+        right, left = exp
+        process_call [ left, :=~, right ]
+      end
+
+      def process_and(exp)
+        joined_expressions exp, :both
+      end
+
+      def process_or(exp)
+        joined_expressions exp, :either
+      end
+
+      def joined_expressions(exp, with = nil)
+        expressions = []
+
+        while expression = exp.shift
+          expressions << process(expression)
+        end
+
+        translator.send(with, *expressions)
+      end
+
+      def process_not(args)
+        negate { process(args.first) }
+      end
+
+      def process_operator(operator)
+        @negated ? negate_operator(operator) : operator
+      end
+
+      def negate_operator(operator)
+        case operator
+        when :== then :not_equal
+        when :=~ then :not_regexp
+        else raise "Missing negated operator definition: #{operator}"
+        end
+      end
+
+      def negate
+        @negated = true
+        yield
+      ensure
+        @negated = false
+      end
+    end
+  end
+end

data/lib/ambition/processors/slice.rb

@@ -0,0 +1,15 @@
+module Ambition
+  module Processors
+    class Slice < Base
+      def initialize(context, start, length=nil)
+        @context = context
+        @start   = start
+        @length  = length
+      end
+
+      def to_s
+        translator.slice(@start, @length)
+      end
+    end
+  end
+end

data/lib/ambition/processors/sort.rb

@@ -0,0 +1,51 @@
+module Ambition
+  module Processors
+    class Sort < Base
+      def initialize(context, block)
+        @context = context
+        @block   = block
+      end
+
+      def process_call(args)
+        if args.first.last == @receiver
+          translator.sort_by(*args[1..-1])
+
+        # sort_by { |m| -m.age }
+        # [[:call, [:dvar, :m], :age], :-@]
+        elsif args[0][1][-1] == @receiver && args.last == :-@
+          translator.reverse_sort_by(*args.first[2..-1])
+
+        # sort_by(&:name).to_s
+        # [[:call, [:dvar, :args], :shift], :__send__, [:argscat, [:array, [:self]], [:dvar, :args]]]
+        elsif args[1] == :__send__
+          translator.to_proc(value('to_s'))
+
+        # sort_by { |m| m.ideas.title } 
+        # [[:call, [:dvar, :m], :ideas], :title]
+        elsif args[0][1][-1] == @receiver
+          first = args.first.last
+          last  = args.last
+          translator.chained_sort_by(first, last)
+
+        # sort_by { |m| [ m.ideas.title, -m.invites.email ] } 
+        # [[:call, [:call, [:dvar, :m], :invites], :email], :-@]
+        elsif args[0][1][1][-1] == @receiver && args.last == :-@
+          first = args.first[1].last
+          last  = args.first.last
+          translator.chained_reverse_sort_by(first, last)
+
+        else
+          raise args.inspect
+        end
+      end
+
+      def process_vcall(args)
+        translator.send(args.shift, *args)
+      end
+
+      def process_masgn(exp)
+        ''
+      end
+    end
+  end
+end

data/test/adapters/exemplar/association_test.rb

@@ -0,0 +1,34 @@
+# Analog of the join_test.rb in the ActiveRecord adapter.
+# Not all adapters will need these behaviors.  E.g. there are no joins in LDAP.
+# ActiveLdap has associations, but doesn't try to fake joins.
+# CouchDb doesn't so much have joins as it has the capacity for creative
+# use of its views.
+
+require File.dirname(__FILE__) + '/helper'
+
+context "Object associations" do
+  xspecify "simple ==" do
+    result = User.select { |m| m.account.email == 'chris@ozmm.org' }
+  end
+
+  xspecify "simple mixed == on object and an association" do
+    result = User.select { |m| m.name == 'chris' && m.account.email == 'chris@ozmm.org' }
+  end
+
+  xspecify "multiple associations" do
+    result = User.select { |m| m.ideas.title == 'New Freezer' || m.invites.email == 'pj@hyett.com' }
+  end
+
+  xspecify "non-existant associations" do
+    result = User.select { |m| m.liquor.brand == 'Jack' }
+    should.raise { result.to_hash } 
+  end
+
+  xspecify "simple order by association attribute" do
+    result = User.sort_by { |m| m.ideas.title }
+  end
+
+  xspecify "in a more complex order" do
+    result = User.sort_by { |m| [ m.ideas.title, -m.invites.email ] }
+  end
+end

data/test/adapters/exemplar/detect_test.rb

@@ -0,0 +1,9 @@
+context "Exemplar Adapter :: Detect" do
+  xspecify "simple ==" do
+    User.detect { |m| m.name == 'chris' }
+  end
+
+  xspecify "nothing found" do
+    User.detect { |m| m.name == 'chris' }.should.be.nil
+  end
+end

data/test/adapters/exemplar/helper.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + '/../../helper'
+
+# require 'ambition/adapters/exemplar'

data/test/adapters/exemplar/index_operator.rb

@@ -0,0 +1,6 @@
+xcontext "Exemplar Adapter :: [] operator" do
+  specify "finds a single row" do
+    User.expects(:find).with(1)
+    User[1]
+  end
+end

data/test/adapters/exemplar/select_test.rb

@@ -0,0 +1,151 @@
+context "Exemplar Adapter :: Select" do
+  xspecify "simple ==" do
+    translator = User.select { |m| m.name == 'jon' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple !=" do
+    translator = User.select { |m| m.name != 'jon' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple == && ==" do
+    translator = User.select { |m| m.name == 'jon' && m.age == 21 }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple == || ==" do
+    translator = User.select { |m| m.name == 'jon' || m.age == 21 }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "mixed && and ||" do
+    translator = User.select { |m| m.name == 'jon' || m.age == 21 && m.password == 'pass' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "grouped && and ||" do
+    translator = User.select { |m| (m.name == 'jon' || m.name == 'rick') && m.age == 21 }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple >/<" do
+    translator = User.select { |m| m.age > 21 }
+    translator.to_s.should == %Q(foo)
+
+    translator = User.select { |m| m.age >= 21 }
+    translator.to_s.should == %Q(foo)
+
+    translator = User.select { |m| m.age < 21 }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "array.include? item" do
+    translator = User.select { |m| [1, 2, 3, 4].include? m.id }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "variabled array.include? item" do
+    array = [1, 2, 3, 4]
+    translator = User.select { |m| array.include? m.id }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple == with variables" do
+    me = 'chris'
+    translator = User.select { |m| m.name == me }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple == with method arguments" do
+    def test_it(name)
+      translator = User.select { |m| m.name == name }
+      translator.to_s.should == %Q(foo)
+    end
+
+    test_it('chris')
+  end
+
+  xspecify "simple == with instance variables" do
+    @me = 'chris'
+    translator = User.select { |m| m.name == @me }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple == with instance variable method call" do
+    require 'ostruct'
+    @person = OpenStruct.new(:name => 'chris')
+
+    translator = User.select { |m| m.name == @person.name }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple == with global variables" do
+    $my_name = 'boston'
+    translator = User.select { |m| m.name == $my_name }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple == with method call" do
+    def band
+      'skinny puppy'
+    end
+
+    translator = User.select { |m| m.name == band }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple =~ with string" do
+    translator = User.select { |m| m.name =~ 'chris' }
+    translator.to_s.should == %Q(foo)
+
+    translator = User.select { |m| m.name =~ 'chri%' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple !~ with string" do
+    translator = User.select { |m| m.name !~ 'chris' }
+    translator.to_s.should == %Q(foo)
+
+    translator = User.select { |m| !(m.name =~ 'chris') }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple =~ with regexp" do
+    translator = User.select { |m| m.name =~ /chris/ }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple =~ with regexp flags" do
+    translator = User.select { |m| m.name =~ /chris/i }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple downcase" do
+    translator = User.select { |m| m.name.downcase =~ 'chris%' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "simple upcase" do
+    translator = User.select { |m| m.name.upcase =~ 'chris%' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "undefined equality symbol" do
+    should.raise { User.select { |m| m.name =* /chris/ } }
+  end
+
+  xspecify "block variable / assigning variable conflict" do
+    m = User.select { |m| m.name == 'chris' }
+    m.should == %Q(foo)
+  end
+  
+  xspecify "simple == with inline ruby" do
+    translator = User.select { |m| m.created_at == 2.days.ago(:db) }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "inspect" do
+    User.select { |u| u.name }.inspect.should.match %r(call #to_s or #to_hash)
+  end
+end

data/test/debug

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

data/test/helper.rb

@@ -1,54 +1,4 @@
-require 'rubygems'
-begin
-  require 'test/spec' unless $NO_TEST
-  require 'mocha'
-rescue LoadError
-  puts "=> You need the test-spec and mocha gems to run these tests."
-  exit
-end
-require 'active_support'
-require 'active_record'
+%w( rubygems test/spec mocha redgreen English ).each { |f| require f }
 
-begin require 'redgreen'; rescue LoadError; end unless $NO_TEST
-
-$:.unshift File.dirname(__FILE__) + '/../lib'
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'ambition'
-
-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
-
-module ActiveRecord
-  module ConnectionAdapters
-    class MysqlAdapter  
-      def connect(*args)
-        true
-      end
-    end
-
-    class PostgreSQLAdapter  
-      def connect(*args)
-        true
-      end
-      class PGError; end
-    end
-
-    class FakeAdapter < AbstractAdapter
-    end
-  end
-end