defunkt-ambition 0.5.3

data/app_generators/ambition_adapter/templates/test/select_test.rb.erb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "<%= adapter_module %> Adapter :: Select" do
+  setup do
+    @klass = User
+  end
+
+  xspecify "==" do
+    translator = @klass.select { |m| m.name == 'jon' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "!=" do
+    translator = @klass.select { |m| m.name != 'jon' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "== && ==" do
+    translator = @klass.select { |m| m.name == 'jon' && m.age == 21 }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "== || ==" do
+    translator = @klass.select { |m| m.name == 'jon' || m.age == 21 }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "mixed && and ||" do
+    translator = @klass.select { |m| m.name == 'jon' || m.age == 21 && m.password == 'pass' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "grouped && and ||" do
+    translator = @klass.select { |m| (m.name == 'jon' || m.name == 'rick') && m.age == 21 }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify ">/<" do
+    translator = @klass.select { |m| m.age > 21 }
+    translator.to_s.should == %Q(foo)
+
+    translator = @klass.select { |m| m.age >= 21 }
+    translator.to_s.should == %Q(foo)
+
+    translator = @klass.select { |m| m.age < 21 }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "array.include? item" do
+    translator = @klass.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 = @klass.select { |m| array.include? m.id }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "== with variables" do
+    me = 'chris'
+    translator = @klass.select { |m| m.name == me }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "== with method arguments" do
+    def test_it(name)
+      translator = @klass.select { |m| m.name == name }
+      translator.to_s.should == %Q(foo)
+    end
+
+    test_it('chris')
+  end
+
+  xspecify "== with instance variables" do
+    @me = 'chris'
+    translator = @klass.select { |m| m.name == @me }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "== with instance variable method call" do
+    require 'ostruct'
+    @person = OpenStruct.new(:name => 'chris')
+
+    translator = @klass.select { |m| m.name == @person.name }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "== with global variables" do
+    $my_name = 'boston'
+    translator = @klass.select { |m| m.name == $my_name }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "== with method call" do
+    def band
+      'skinny puppy'
+    end
+
+    translator = @klass.select { |m| m.name == band }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "=~ with string" do
+    translator = @klass.select { |m| m.name =~ 'chris' }
+    translator.to_s.should == %Q(foo)
+
+    translator = @klass.select { |m| m.name =~ 'chri%' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "!~ with string" do
+    translator = @klass.select { |m| m.name !~ 'chris' }
+    translator.to_s.should == %Q(foo)
+
+    translator = @klass.select { |m| !(m.name =~ 'chris') }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "=~ with regexp" do
+    translator = @klass.select { |m| m.name =~ /chris/ }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "=~ with regexp flags" do
+    translator = @klass.select { |m| m.name =~ /chris/i }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "downcase" do
+    translator = @klass.select { |m| m.name.downcase =~ 'chris%' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "upcase" do
+    translator = @klass.select { |m| m.name.upcase =~ 'chris%' }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "undefined equality symbol" do
+    should.raise { @klass.select { |m| m.name =* /chris/ } }
+  end
+
+  xspecify "block variable / assigning variable conflict" do
+    m = @klass.select { |m| m.name == 'chris' }
+    m.should == %Q(foo)
+  end
+  
+  xspecify "== with inline ruby" do
+    translator = @klass.select { |m| m.created_at == Time.now.to_s }
+    translator.to_s.should == %Q(foo)
+  end
+
+  xspecify "inspect" do
+    @klass.select { |u| u.name }.inspect.should.match %r(call #to_s or #to_hash)
+  end
+end

data/app_generators/ambition_adapter/templates/test/slice_test.rb.erb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "<%= adapter_module %> Adapter :: Slice" do
+  setup do
+    @klass = User
+    @block = @klass.select { |m| m.name == 'jon' }
+  end
+
+  xspecify "first" do
+    @klass.expects(:find).with(:limit => 1, :name => 'jon')
+    @block.first
+  end
+
+  xspecify "first with argument" do
+    @klass.expects(:find).with(:limit => 5, :name => 'jon')
+    @block.first(5).entries
+  end
+  
+  xspecify "[] with two elements" do
+    @klass.expects(:find).with(:limit => 20, :offset => 10, :name => 'jon')
+    @block[10, 20].entries
+
+    @klass.expects(:find).with(:limit => 20, :offset => 20, :name => 'jon')
+    @block[20, 20].entries
+  end
+  
+  xspecify "slice is an alias of []" do
+    @klass.expects(:find).with(:limit => 20, :offset => 10, :name => 'jon')
+    @block.slice(10, 20).entries
+  end
+  
+  xspecify "[] with range" do
+    @klass.expects(:find).with(:limit => 10, :offset => 10, :name => 'jon')
+    @block[11..20].entries
+  end
+end

data/app_generators/ambition_adapter/templates/test/sort_test.rb.erb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "<%= adapter_module %> Adapter :: Sort" do
+  setup do
+    @klass = User
+    @block = @klass.select { |m| m.name == 'jon' }
+  end
+
+  xspecify "order" do
+    string = @block.sort_by { |m| m.name }.to_s
+    string.should == "foo"
+  end
+
+  xspecify "combined order" do
+    string = @block.sort_by { |m| [ m.name,  m.age ] }.to_s
+    string.should == "foo"
+  end
+
+  xspecify "combined order with single reverse" do
+    string = @block.sort_by { |m| [ m.name,  -m.age ] }.to_s
+    string.should == "foo"
+  end
+
+  xspecify "combined order with two reverses" do
+    string = @block.sort_by { |m| [ -m.name,  -m.age ] }.to_s
+    string.should == "foo"
+  end
+
+  xspecify "reverse order with -" do
+    string = @block.sort_by { |m| -m.age }.to_s
+    string.should == "foo"
+  end
+
+  xspecify "reverse order with #reverse" do
+    # TODO: not implemented
+    string = @block.sort_by { |m| m.age }.reverse.to_s
+    string.should == "foo"
+  end
+
+  xspecify "random order" do
+    string = @block.sort_by { rand }.to_s
+    string.should == "foo"
+  end
+  
+  xspecify "non-existent method to sort by" do
+    should.raise(NoMethodError) { @block.sort_by { foo }.to_s }
+  end
+
+  xspecify "Symbol#to_proc" do
+    string = @klass.sort_by(&:name).to_s
+    string.should == "foo"
+  end
+end

data/bin/ambition_adapter

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rubigen'
+
+if %w(-v --version).include? ARGV.first
+  version = File.read('./Rakefile').scan(/Version = '(.+)'/).first.first
+  puts "#{File.basename($0)} #{version}"
+  exit(0)
+end
+
+require 'rubigen/scripts/generate'
+RubiGen::Base.use_application_sources! :ambition_adapter
+RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'ambition_adapter')

data/lib/ambition/api.rb

@@ -0,0 +1,98 @@
+module Ambition #:nodoc:
+  # Module that you will extend from in your adapters in your toplevel file.
+  # 
+  # For example, for ambitious_sphinx in lib/ambition/adapters/ambitious_sphinx.rb, we have:
+  #   ActiveRecord::Base.extend Ambition::API
+  module API
+    include Enumerable
+
+    ##
+    # Entry methods
+    def select(&block)
+      context = ambition_context 
+      context << Processors::Select.new(context, block)
+    end
+
+    def sort_by(&block)
+      context = ambition_context 
+      context << Processors::Sort.new(context, block)
+    end
+
+    # Entries that our context is able to find.
+    def entries
+      ambition_context.kick
+    end
+    alias_method :to_a, :entries
+
+    def size
+      ambition_context == self ? super : ambition_context.size
+    end
+
+    def slice(start, length = nil)
+      context = ambition_context 
+      context << Processors::Slice.new(context, start, length)
+    end
+    alias_method :[], :slice
+
+    ##
+    # Convenience methods
+    
+    # See Enumerable#detect
+    def detect(&block)
+      select(&block).first
+    end
+
+    # See Array#first
+    def first(count = 1)
+      sliced = slice(0, count)
+      count == 1 ? Array(sliced.kick).first : sliced
+    end
+
+    # See Array#each, applied to +entries+
+    def each(&block)
+      entries.each(&block)
+    end
+
+    # See Enumerable#any?
+    def any?(&block)
+      select(&block).size > 0
+    end
+
+    # See Enumerable#all?
+    def all?(&block)
+      size == select(&block).size
+    end
+
+    # See Array#empty?
+    def empty?
+      size.zero?
+    end
+
+    # Builds a new +Context+.
+    def ambition_context
+      Context.new(self)
+    end
+
+    # Gives you the current ambitious adapter.
+    def ambition_adapter
+      name   = respond_to?(:name) ? name : self.class.name
+      parent = respond_to?(:superclass) ? superclass : self.class.superclass
+      @@ambition_adapter[name] || @@ambition_adapter[parent.name]
+    end
+
+    # Assign the ambition adapter. Typically, you use this in the toplevel file of your adapter.
+    #
+    # For example, for ambitious_sphinx, in our lib/ambition/adapters/ambitious_sphinx.rb:
+    #
+    #   ActiveRecord::Base.ambition_adapter = Ambition::Adapters::AmbitiousSphinx
+    def ambition_adapter=(klass)
+      @@ambition_adapter ||= {}
+      # should this be doing the same check for respond_to?(:name) like above?
+      @@ambition_adapter[name] = klass
+    end
+
+    def ambition_owner
+      @owner || self
+    end
+  end
+end

data/lib/ambition/context.rb

@@ -0,0 +1,62 @@
+module Ambition #:nodoc:
+  # This class includes several methods you will likely want to be accessing through your
+  # Query and Translator classes:
+  #
+  # * +clauses+
+  # * +owner+
+  # * +stash+
+  class Context
+    undef_method :to_s
+    include API
+    
+    # A hash of arrays, one key per processor.
+    # So, if someone called User.select, your
+    # +clauses+ hash would have a :select key with
+    # an array of translated strings via your Select
+    # class.
+    # 
+    # This is accessible from your Query and Translator classes.
+    attr_reader :clauses
+    
+    # The class everything was called on.  Like `User`
+    #
+    # This is accessible from your Query and Translator classes.
+    attr_reader :owner
+    
+    # A place for you to stick stuff.  Available to all Translators and your Query class.
+    #
+    # This is accessible from your Query and Translator classes.
+    attr_reader :stash
+
+    def initialize(owner)
+      @owner   = owner
+      @clauses = {}
+      @stash   = {}
+    end
+
+    # Gets the ambition_context. From a Ambition::Context, this is actually +self+.
+    def ambition_context
+      self
+    end
+
+    # Adds a clause to this context.
+    def <<(clause)
+      @clauses[clause.key] ||= []
+      @clauses[clause.key] << clause.to_s
+      self
+    end
+
+    def adapter_query
+      Processors::Base.translator(self, :Query)
+    end
+
+    def method_missing(method, *args, &block)
+      return super unless adapter_query.respond_to? method
+      adapter_query.send(method, *args, &block)
+    end
+
+    def inspect
+      "(Query object: call #to_s or #to_hash to inspect, call an Enumerable (such as #each or #first) to request data)"
+    end
+  end
+end

data/lib/ambition/core_ext.rb

@@ -0,0 +1,7 @@
+# Object extensions to make metaprogramming a little easier.
+class Object
+  def metaclass; (class << self; self end) end
+  def meta_eval(&blk) metaclass.instance_eval(&blk) end
+  def meta_def(name, &blk) meta_eval { define_method name, &blk } end
+  def class_def(name, &blk) class_eval { define_method name, &blk } end
+end

data/lib/ambition/enumerable.rb

@@ -0,0 +1,6 @@
+module Ambition #:nodoc:
+  Enumerable = ::Enumerable.dup
+  Enumerable.class_eval do
+    remove_method :find, :find_all
+  end
+end

data/lib/ambition/processors/base.rb

@@ -0,0 +1,134 @@
+module Ambition #:nodoc:
+  module Processors #:nodoc:
+    class Base
+      ##
+      # Processing methods
+      def process_proc(exp)
+        # puts "=> #{exp.inspect}"
+        receiver, body = process(exp.shift), exp.shift
+        process(body)
+      end
+
+      def process_dasgn_curr(exp)
+        (@receiver = exp.first).to_s
+      end
+      alias_method :process_dasgn, :process_dasgn_curr
+
+      def process_array(exp)
+        # Branch on whether this is straight Ruby or a real array
+        rubify(exp) || exp.map { |m| process(m) }
+      end
+
+      def process_str(exp)
+        exp.first
+      end
+
+      def process_lit(exp)
+        exp.first
+      end
+
+      def process_nil(exp)
+        nil
+      end
+
+      def process_true(exp)
+        true
+      end
+
+      def process_false(exp)
+        false
+      end
+
+      def process_dvar(exp)
+        target = exp.shift
+        value(target.to_s[0..-1])
+      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(node)
+        node ||= []
+
+        if node.is_a? Symbol
+          node
+        elsif 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
+
+      ##
+      # Helper methods
+      def to_s
+        process SexpTranslator.translate(@block)
+      end
+
+      def key
+        self.class.name.split('::').last.downcase.intern
+      end
+
+      def value(variable)
+        eval variable, @block
+      end
+
+      # Gives you the current translator. Uses +self.translator+ to look it up,
+      # if it isn't known yet.
+      def translator
+        @translator ||= self.class.translator(@context)
+      end
+
+      def self.translator(context, name = nil)
+        # Grok the adapter name
+        name   ||= self.name.split('::').last
+
+        # Get the module for it
+        klass    = context.owner.ambition_adapter.const_get(name)
+        instance = klass.new
+
+        # Make sure that the instance has everything it will need:
+        #
+        # * context
+        # * owner
+        # * clauses
+        # * stash
+        # * negated?
+        unless instance.respond_to? :context
+          klass.class_eval do
+            attr_accessor :context, :negated
+            def owner;    @context.owner   end
+            def clauses;  @context.clauses end
+            def stash;    @context.stash   end
+            def negated?; @negated         end
+          end
+        end
+
+        instance.context = context
+        instance
+      end
+
+      def rubify(exp)
+        # TODO: encapsulate this check in Ruby.should_process?(exp)
+        if exp.first.first == :call && exp.first[1].last != @receiver && Array(exp.first[1][1]).last != @receiver
+          value Ruby.process(exp.first)
+        end
+      end
+    end
+  end
+end

data/lib/ambition/processors/ruby.rb

@@ -0,0 +1,26 @@
+require 'ruby2ruby'
+
+module Ambition #:nodoc:
+  module Processors #:nodoc:
+    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 #:nodoc:
+  module Processors #:nodoc:
+    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 = translator.negated = true
+        yield
+      ensure
+        @negated = translator.negated = false
+      end
+    end
+  end
+end