ambition 0.3.1 → 0.5.0

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.rb

@@ -1,15 +1,10 @@
-unless defined? ActiveRecord
-  require 'rubygems'
-  require 'active_record' 
-end
+require 'ambition/enumerable'
 require 'ambition/api'
-require 'ambition/source'
-require 'ambition/processor'
-require 'ambition/ruby_processor'
-require 'ambition/select_processor'
-require 'ambition/sort_processor'
-require 'ambition/simple_processor'
-require 'ambition/query'
-require 'ambition/database_statements'
+require 'ambition/context'
+require 'ambition/core_ext'
 
-ActiveRecord::Base.extend Ambition::API
+require 'ambition/processors/base'
+require 'ambition/processors/select'
+require 'ambition/processors/sort'
+require 'ambition/processors/slice'
+require 'ambition/processors/ruby'

data/lib/ambition/api.rb

@@ -2,57 +2,43 @@ module Ambition
   module API
     include Enumerable
 
-    attr_accessor :query_context 
-    def query_context
-      @query_context || Query.new(self)
+    ##
+    # Entry methods
+    def select(&block)
+      context = ambition_context 
+      context << Processors::Select.new(context, block)
     end
 
-    def entries
-      find(:all, query_context.to_hash)
+    def sort_by(&block)
+      context = ambition_context 
+      context << Processors::Sort.new(context, block)
     end
-    alias_method :to_a, :entries
 
-    def select(*args, &block)
-      query_context.add SelectProcessor.new(self, block)
+    def entries
+      ambition_context.kick
     end
+    alias_method :to_a, :entries
 
-    def first(limit = 1)
-      query_context.add SimpleProcessor.new(:limit => limit)
-
-      if limit == 1
-        find(:first, query_context.to_hash)
-      else
-        query_context
-      end
+    def size
+      ambition_context.size
     end
 
-    def slice(offset, limit = nil)
-      if offset.is_a? Range
-        limit  = offset.end
-        limit -= 1 if offset.exclude_end?
-        offset = offset.first
-        limit -= offset
-      elsif limit.nil?
-        return find(offset)
-      end
-
-      query_context.add SimpleProcessor.new(:offset => offset)
-      query_context.add SimpleProcessor.new(:limit  => limit)
+    def slice(start, length = nil)
+      context = ambition_context 
+      context << Processors::Slice.new(context, start, length)
     end
     alias_method :[], :slice
 
-    def sort_by(&block)
-      query_context.add SortProcessor.new(self, block)
-    end
-
+    ##
+    # Convenience methods
     def detect(&block)
       select(&block).first
     end
 
-    def size
-      count(query_context.to_hash)
+    def first(count = 1)
+      sliced = slice(0, count)
+      count == 1 ? sliced.kick : sliced
     end
-    alias_method :length, :size
 
     def each(&block)
       entries.each(&block)
@@ -69,5 +55,26 @@ module Ambition
     def empty?
       size.zero?
     end
+
+    ##
+    # Plumbing
+    def ambition_context
+      Context.new(self)
+    end
+
+    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
+
+    def ambition_adapter=(klass)
+      @@ambition_adapter ||= {}
+      @@ambition_adapter[name] = klass
+    end
+
+    def ambition_owner
+      @owner || self
+    end
   end
 end

data/lib/ambition/context.rb

@@ -0,0 +1,62 @@
+module Ambition
+  class Context
+    include API
+
+    ##
+    # These are the methods your Query and Translator classes will 
+    # want to access.
+    #
+    #   +owner+   The class everything was called on.  Like `User' 
+    #
+    #   +clauses+ 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.
+    #
+    #   +stash+   A place for you to stick stuff.  Available to
+    #             all Translators and your Query class.
+    attr_reader :clauses, :owner, :stash
+
+    def initialize(owner)
+      @owner   = owner
+      @clauses = {}
+      @stash   = {}
+    end
+
+    def ambition_context
+      self
+    end
+
+    def <<(clause)
+      @clauses[clause.key] ||= []
+      @clauses[clause.key] << clause.to_s
+      self
+    end
+
+    def adapter_query
+      Processors::Base.translator(self, :Query)
+    end
+
+    def to_hash
+      adapter_query.to_hash
+    end
+
+    def to_s
+      adapter_query.to_s
+    end
+
+    def kick
+      adapter_query.kick
+    end
+
+    def size
+      adapter_query.size
+    end
+    alias_method :length, :size
+
+    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/{proc_to_ruby.rb → core_ext.rb}

@@ -3,6 +3,19 @@
 require 'parse_tree'
 require 'ruby2ruby'
 
+class Object
+  def to_sexp
+    instance_eval <<-end_eval
+      return proc { #{inspect} }.to_sexp.last
+    end_eval
+  end
+
+  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
+
 class ProcHolder
 end
 

data/lib/ambition/enumerable.rb

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

data/lib/ambition/processors/base.rb

@@ -0,0 +1,126 @@
+module Ambition
+  module Processors
+    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
+        @receiver.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
+        if ruby = rubify(exp)
+          ruby
+        else
+          exp.map { |m| process(m) }
+        end
+      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 @block.to_sexp
+      end
+
+      def key
+        self.class.name.split('::').last.downcase.intern
+      end
+
+      def value(variable)
+        eval variable, @block
+      end
+
+      def translator
+        @translator ||= self.class.translator(@context)
+      end
+
+      def self.translator(context, name = nil)
+        name   ||= self.name.split('::').last
+        klass    = context.owner.ambition_adapter.const_get(name)
+        instance = klass.new
+
+        unless instance.respond_to? :context
+          klass.class_eval do
+            attr_accessor :context
+            def owner;    @context.owner   end
+            def clauses;  @context.clauses end
+            def stash;    @context.stash   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