activerecord-futures 0.0.1 → 0.1.0

data/lib/active_record/futures/future_calculation.rb

@@ -4,21 +4,12 @@ module ActiveRecord
       attr_reader :query, :execution
       private :query, :execution
 
-      def initialize(query, execution)
-        super()
+      def initialize(relation, query, execution)
+        super(relation)
         @query = query
         @execution = execution
       end
 
-      def value
-        Future.flush unless executed?
-        @value
-      end
-
-      def inspect
-        value.inspect
-      end
-
       def to_sql
         query
       end
@@ -26,8 +17,9 @@ module ActiveRecord
     private
 
       def execute
-        @value = execution.call
+        @value = execution.call unless executed?
         @executed = true
+        @value
       end
 
       def executed?

data/lib/active_record/futures/future_calculation_array.rb

@@ -0,0 +1,8 @@
+module ActiveRecord
+  module Futures
+    class FutureCalculationArray < FutureCalculation
+      include ActiveRecord::Delegation
+      fetch_with(:to_a)
+    end
+  end
+end

data/lib/active_record/futures/future_calculation_value.rb

@@ -0,0 +1,11 @@
+module ActiveRecord
+  module Futures
+    class FutureCalculationValue < FutureCalculation
+      fetch_with(:value)
+
+      def inspect
+        value.inspect
+      end
+    end
+  end
+end

data/lib/active_record/futures/future_relation.rb

@@ -1,22 +1,23 @@
 module ActiveRecord
   module Futures
     class FutureRelation < Future
-      include Delegation
-      delegate :to_sql, to: :relation
-
-      attr_reader :relation
-      private :relation
+      include ActiveRecord::Delegation
 
       def initialize(relation)
-        super()
-        @relation = relation
+        super
         @klass = relation.klass
+
+        # Eagerly get sql from relation, since PostgreSQL adapter may use the
+        # same method `exec_query` to retrieve the columns when executing
+        # `to_sql`, and that will cause an infinite loop if a current future
+        # exists
+        @query = relation.to_sql
       end
 
-      def to_a
-        # Flush all the futures upon first attempt to exec a future
-        Future.flush unless executed?
-        execute
+      fetch_with(:to_a)
+
+      def to_sql
+        @query
       end
 
     private

data/lib/active_record/futures/proxy.rb

@@ -0,0 +1,37 @@
+module ActiveRecord
+  module Futures
+    class Proxy
+      attr_reader :proxied
+
+      def initialize(obj)
+        @proxied = obj
+      end
+
+      def proxy?
+        true
+      end
+
+      def ==(other)
+        other = other.proxied if other.is_a? self.class
+        @proxied == other
+      end
+
+      def !=(other)
+        other = other.proxied if other.is_a? self.class
+        @proxied != other
+      end
+
+      def method_missing(method, *args, &block)
+        if @proxied.respond_to?(method)
+          @proxied.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to?(method, include_all = false)
+        method.to_sym == :proxy? || super || @proxied.respond_to?(method, include_all)
+      end
+    end
+  end
+end

data/lib/active_record/futures/query_recording.rb

@@ -8,61 +8,47 @@ module ActiveRecord
         connection = ConnectionProxy.new(@klass.connection)
         @klass = KlassProxy.new(@klass, connection)
         yield
-        connection.recorded_query
+        [connection.recorded_query, connection.query_type]
       ensure
         @klass = orig_klass
       end
 
-      class KlassProxy
+      class KlassProxy < Proxy
         attr_reader :klass, :connection
 
         def initialize(klass, connection)
+          super(klass)
           @klass = klass
           @connection = connection
         end
 
-        def method_missing(method, *args, &block)
-          if klass.respond_to?(method)
-            klass.send(method, *args, &block)
-          else
-            super
-          end
-        end
-
-        def respond_to?(method, include_all = false)
-          super || klass.respond_to?(method, include_all)
+        def build_default_scope
+          scope = @klass.send(:build_default_scope)
+          scope.instance_variable_set(:@klass, self)
+          scope
         end
       end
 
-      class ConnectionProxy
+      class ConnectionProxy < Proxy
         attr_reader :connection
-        attr_accessor :recorded_query
+        attr_accessor :recorded_query, :query_type
 
         def initialize(connection)
+          super(connection)
           @connection = connection
         end
 
         def select_value(arel, name = nil)
+          self.query_type = :value
           self.recorded_query = arel.to_sql
           nil
         end
 
         def select_all(arel, name = nil, binds = [])
+          self.query_type = :all
           self.recorded_query = arel.to_sql
           []
         end
-
-        def method_missing(method, *args, &block)
-          if connection.respond_to?(method)
-            connection.send(method, *args, &block)
-          else
-            super
-          end
-        end
-
-        def respond_to?(method, include_all = false)
-          super || connection.respond_to?(method, include_all)
-        end
       end
     end
   end

data/lib/activerecord-futures.rb

@@ -5,7 +5,10 @@ require "activerecord-futures/version"
 require "active_record/futures/future"
 require "active_record/futures/future_relation"
 require "active_record/futures/future_calculation"
+require "active_record/futures/future_calculation_value"
+require "active_record/futures/future_calculation_array"
 
+require "active_record/futures/proxy"
 require "active_record/futures/query_recording"
 require "active_record/futures"
 require "active_record/futures/delegation"

data/lib/activerecord-futures/version.rb

@@ -1,5 +1,5 @@
 module Activerecord
   module Futures
-    VERSION = "0.0.1"
+    VERSION = "0.1.0"
   end
 end

data/spec/active_record/futures/future_relation_spec.rb

@@ -2,7 +2,15 @@ require "spec_helper"
 
 module ActiveRecord::Futures
   describe FutureRelation do
-    let(:relation) { double(ActiveRecord::Relation, klass: Class.new, to_a: nil) }
+    let(:relation) do
+      double(ActiveRecord::Relation, {
+        klass: Class.new,
+        to_a: nil,
+        to_sql: "select 1",
+        connection: double("connection", supports_futures?: true)
+      })
+    end
+
     subject { FutureRelation.new(relation) }
 
     describe ".new" do

data/spec/active_record/futures/proxy_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+module ActiveRecord::Futures
+  describe Proxy do
+
+    let(:obj) { Object.new }
+    subject { Proxy.new(obj) }
+
+    it "delegates method calls to the proxied object" do
+      obj.should_receive(:inspect)
+
+      subject.inspect
+    end
+
+    describe "#==" do
+      it "is equal to the proxied object" do
+        subject.should == obj
+      end
+
+      it "is equal to a proxy of the same object" do
+        subject.should == Proxy.new(obj)
+      end
+
+      it "is not equal to another object" do
+        subject.should_not == Object.new
+      end
+
+      it "is not equal to another object of another type" do
+        subject.should_not == "A string object"
+      end
+    end
+
+    describe "#!=" do
+      it "is equal to the proxied object" do
+        (subject != obj).should be_false
+      end
+
+      it "is equal to a proxy of the same object" do
+        (subject != Proxy.new(obj)).should be_false
+      end
+
+      it "is not equal to another object" do
+        (subject != Object.new).should be_true
+      end
+
+      it "is not equal to another object of another type" do
+        (subject != "A string object").should be_true
+      end
+    end
+  end
+end

data/spec/db/schema.rb

@@ -1,11 +1,5 @@
 ActiveRecord::Schema.define(:version => 1) do
 
-  create_table "countries", :force => true do |t|
-    t.string   "name"
-    t.datetime "created_at", :null => false
-    t.datetime "updated_at", :null => false
-  end
-
   create_table "users", :force => true do |t|
     t.string   "name"
     t.string   "email"
@@ -13,4 +7,19 @@ ActiveRecord::Schema.define(:version => 1) do
     t.datetime "updated_at", :null => false
   end
 
+  create_table "posts", :force => true do |t|
+    t.string    "title"
+    t.text      "body"
+    t.datetime  "published_at"
+    t.datetime  "created_at", :null => false
+    t.datetime  "updated_at", :null => false
+  end
+
+  create_table "comments", :force => true do |t|
+    t.string     "body"
+    t.references "user"
+    t.references "post"
+    t.datetime   "created_at", :null => false
+    t.datetime   "updated_at", :null => false
+  end
 end

data/spec/in_action/combination_of_futures_spec.rb

@@ -0,0 +1,153 @@
+require "spec_helper"
+
+describe "Combination of futures" do
+  before do
+    User.create(name: "Lenny")
+    User.create(name: "John")
+    User.create(name: "Julie")
+
+    Post.create(title: "Post title 1", published_at: Time.new(2013, 3, 14))
+    Post.create(title: "Post title 2", published_at: Time.new(2012, 11, 9))
+    Post.create(title: "Post title 3")
+  end
+
+  let(:user_relation) { User.where(name: "Lenny") }
+  let(:user_relation_sql) { user_relation.to_sql }
+  let!(:user_future_relation) { user_relation.future }
+
+  let(:other_user_relation) { User.where("name like 'J%'") }
+  let(:other_user_relation_count_sql) { count(other_user_relation).to_sql }
+  let!(:user_future_value) { other_user_relation.future_count }
+
+  let(:post_relation) { Post.where(title: "Post title 2") }
+  let(:post_relation_sql) { post_relation.to_sql }
+  let!(:post_future_relation) { post_relation.future }
+
+  let(:post_count_sql) { count(Post.scoped).to_sql }
+  let!(:post_future_value) { Post.future_count }
+
+  context "the execution of any future" do
+    subject { -> { post_future_relation.to_a } }
+
+    context "execs only once with all queries", :supporting_adapter do
+      let(:futures_sql) do
+        [
+          user_relation_sql,
+          other_user_relation_count_sql,
+          post_relation_sql,
+          post_count_sql
+        ].join(';')
+      end
+
+      it { should exec(1).query }
+      it { should exec_query(futures_sql) }
+    end
+
+    context "execs just the executed future's query", :not_supporting_adapter do
+      it { should exec(1).query }
+      it { should exec_query(post_future_relation.to_sql) }
+    end
+  end
+
+  context "having executed the post future" do
+    before do
+      post_future_relation.to_a
+    end
+
+    context "the user future relation" do
+      subject { user_future_relation }
+
+      it(nil, :supporting_adapter) { should be_fulfilled }
+      it(nil, :not_supporting_adapter) { should_not be_fulfilled }
+
+      describe "#to_a" do
+        let(:calling_to_a) { ->{ subject.to_a } }
+
+        its(:to_a) { should eq user_relation.to_a }
+
+        context "when adapter supports futures", :supporting_adapter do
+          specify { calling_to_a.should exec(0).queries }
+        end
+
+        context "when adapter does not support futures", :not_supporting_adapter do
+          specify { calling_to_a.should exec(1).query }
+          specify { calling_to_a.should exec_query(user_relation_sql) }
+        end
+      end
+    end
+
+    context "the user future value" do
+      subject { user_future_value }
+
+      it(nil, :supporting_adapter) { should be_fulfilled }
+      it(nil, :not_supporting_adapter) { should_not be_fulfilled }
+
+      describe "#value" do
+        let(:calling_value) { ->{ subject.value } }
+
+        its(:value) { should eq other_user_relation.count }
+
+        context "when adapter supports futures", :supporting_adapter do
+          specify { calling_value.should exec(0).queries }
+        end
+
+        context "when adapter does not support futures", :not_supporting_adapter do
+          specify { calling_value.should exec(1).query }
+          specify { calling_value.should exec_query(other_user_relation_count_sql) }
+        end
+      end
+    end
+
+    context "the post future relation" do
+      subject { post_future_relation }
+
+      it(nil, :supporting_adapter) { should be_fulfilled }
+      it(nil, :not_supporting_adapter) { should_not be_fulfilled }
+
+      describe "#to_a" do
+        let(:calling_to_a) { ->{ subject.to_a } }
+
+        its(:to_a) { should eq post_relation.to_a }
+
+        context "when adapter supports futures", :supporting_adapter do
+          specify { calling_to_a.should exec(0).queries }
+        end
+
+        context "when adapter does not support futures", :not_supporting_adapter do
+          specify { calling_to_a.should exec(0).query }
+          # No queries should be executed, since this is the future we executed
+          # before
+        end
+      end
+    end
+
+    context "the post future value" do
+      subject { post_future_value }
+
+      it(nil, :supporting_adapter) { should be_fulfilled }
+      it(nil, :not_supporting_adapter) { should_not be_fulfilled }
+
+      describe "#value" do
+        let(:calling_value) { ->{ subject.value } }
+
+        its(:value) { should eq Post.count }
+
+        context "when adapter supports futures", :supporting_adapter do
+          specify { calling_value.should exec(0).queries }
+        end
+
+        context "when adapter does not support futures", :not_supporting_adapter do
+          specify { calling_value.should exec(1).query }
+          specify { calling_value.should exec_query(post_count_sql) }
+        end
+      end
+    end
+  end
+
+  def count(relation)
+    arel = relation.arel
+    arel.projections = []
+    arel.project("COUNT(*)")
+    arel
+  end
+end