activerecord-futures 0.2.0 → 0.3.0

data/lib/active_record/futures/future_value.rb

@@ -0,0 +1,20 @@
+module ActiveRecord
+  module Futures
+    class FutureValue
+      attr_reader :future_execution
+      private :future_execution
+
+      def initialize(future_execution)
+        @future_execution = future_execution
+      end
+
+      def value
+        future_execution.execute
+      end
+
+      def inspect
+        value
+      end
+    end
+  end
+end

data/lib/active_record/futures/query_recording.rb

@@ -8,7 +8,8 @@ module ActiveRecord
         connection = ConnectionProxy.new(@klass.connection)
         @klass = KlassProxy.new(@klass, connection)
         yield
-        connection.recorded_query
+        @loaded = false
+        [connection.recorded_query, connection.recorded_binds]
       ensure
         @klass = orig_klass
       end
@@ -27,11 +28,17 @@ module ActiveRecord
           scope.instance_variable_set(:@klass, self)
           scope
         end
+
+        def find_by_sql(sql, binds = [])
+          connection.recorded_query = sanitize_sql(sql)
+          connection.recorded_binds = binds
+          []
+        end
       end
 
       class ConnectionProxy < Proxy
         attr_reader :connection
-        attr_accessor :recorded_query
+        attr_accessor :recorded_query, :recorded_binds
 
         def initialize(connection)
           super(connection)
@@ -39,12 +46,12 @@ module ActiveRecord
         end
 
         def select_value(arel, name = nil)
-          self.recorded_query = arel.to_sql
+          self.recorded_query = arel
           nil
         end
 
         def select_all(arel, name = nil, binds = [])
-          self.recorded_query = arel.to_sql
+          self.recorded_query = arel
           []
         end
       end

data/lib/activerecord-futures.rb

@@ -2,14 +2,15 @@ require 'active_record'
 require 'active_support/core_ext/module/delegation'
 require "activerecord-futures/version"
 
+require "active_record/futures/future_registry"
 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/future_array"
+require "active_record/futures/future_value"
 
 require "active_record/futures/proxy"
 require "active_record/futures/query_recording"
+require "active_record/futures/finder_methods"
+require "active_record/futures/calculation_methods"
 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.2.0"
+    VERSION = "0.3.0"
   end
 end

data/spec/active_record/futures/future_array_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+module ActiveRecord::Futures
+  describe FutureArray do
+    let(:future) do
+      double(Future, execute: nil)
+    end
+    subject { FutureArray.new(future) }
+
+    describe "#to_a" do
+      before do
+        subject.to_a
+      end
+
+      specify { future.should have_received(:execute) }
+    end
+
+    describe "#inspect" do
+      before do
+        subject.inspect
+      end
+
+      specify { future.should have_received(:execute) }
+    end
+  end
+end

data/spec/active_record/futures/future_registry_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+module ActiveRecord::Futures
+  describe FutureRegistry do
+    subject { FutureRegistry }
+
+    describe ".futures" do
+      context "with futures in two threads" do
+        let(:futures_key) { "#{subject.name}_futures" }
+
+        let(:a_thread) do
+          thread = double("Thread 1")
+          thread.stub(:[]).with(futures_key).and_return([])
+          thread
+        end
+
+        let(:another_thread) do
+          thread = double("Thread 2")
+          thread.stub(:[]).with(futures_key).and_return([])
+          thread
+        end
+
+        before do
+          Thread.stub(:current).and_return(a_thread)
+
+          subject.futures << "Future 1"
+          subject.futures << "Future 2"
+
+          Thread.stub(:current).and_return(another_thread)
+
+          subject.futures << "Future 3"
+          subject.futures << "Future 4"
+        end
+
+        context "the futures in thread 1" do
+          let(:futures) { a_thread[futures_key] }
+
+          specify { futures.should include("Future 1") }
+          specify { futures.should include("Future 2") }
+          specify { futures.should_not include("Future 3") }
+          specify { futures.should_not include("Future 4") }
+        end
+
+        context "the futures in thread 2" do
+          let(:futures) { another_thread[futures_key] }
+
+          specify { futures.should_not include("Future 1") }
+          specify { futures.should_not include("Future 2") }
+          specify { futures.should include("Future 3") }
+          specify { futures.should include("Future 4") }
+        end
+      end
+    end
+
+    describe ".current" do
+      context "with currents in two threads" do
+        let(:current_key) { "#{subject.name}_current" }
+
+        let(:a_thread) { Hash.new }
+        let(:another_thread) { Hash.new }
+
+        before do
+          Thread.stub(:current).and_return(a_thread)
+
+          subject.current = "Future 1"
+
+          Thread.stub(:current).and_return(another_thread)
+
+          subject.current = "Future 2"
+        end
+
+        context "the current in thread 1" do
+          let(:current) { a_thread[current_key] }
+
+          specify { current.should eq "Future 1" }
+        end
+
+        context "the current in thread 2" do
+          let(:current) { another_thread[current_key] }
+
+          specify { current.should eq "Future 2" }
+        end
+      end
+    end
+  end
+end

data/spec/active_record/futures/future_spec.rb

@@ -1,90 +1,63 @@
-require 'spec_helper'
+require "spec_helper"
 
 module ActiveRecord::Futures
   describe Future do
-    context "class methods" do
-      describe ".futures" do
-        context "with futures in two threads" do
-          let(:futures_key) { "#{Future.name}_futures" }
-
-          let(:a_thread) do
-            thread = double("Thread 1")
-            thread.stub(:[]).with(futures_key).and_return([])
-            thread
-          end
-
-          let(:another_thread) do
-            thread = double("Thread 2")
-            thread.stub(:[]).with(futures_key).and_return([])
-            thread
-          end
-
-          before do
-            Thread.stub(:current).and_return(a_thread)
-
-            Future.futures << "Future 1"
-            Future.futures << "Future 2"
-
-            Thread.stub(:current).and_return(another_thread)
-
-            Future.futures << "Future 3"
-            Future.futures << "Future 4"
-          end
+    let(:relation) do
+      double(ActiveRecord::Relation, {
+         connection: double("connection", supports_futures?: true)
+      })
+    end
 
-          context "the futures in thread 1" do
-            let(:futures) { a_thread[futures_key] }
+    let(:query) { double("A query") }
+    let(:binds) { double("Some query binds") }
+    let(:execution) { double("The query execution", call: nil) }
 
-            specify { futures.should include("Future 1") }
-            specify { futures.should include("Future 2") }
-            specify { futures.should_not include("Future 3") }
-            specify { futures.should_not include("Future 4") }
-          end
+    subject { Future.new(relation, query, binds, execution) }
 
-          context "the futures in thread 2" do
-            let(:futures) { another_thread[futures_key] }
+    describe ".new" do
+      before { FutureRegistry.stub(:register) }
+      before { subject }
 
-            specify { futures.should_not include("Future 1") }
-            specify { futures.should_not include("Future 2") }
-            specify { futures.should include("Future 3") }
-            specify { futures.should include("Future 4") }
-          end
-        end
+      it "gets registered" do
+        FutureRegistry.should have_received(:register).with(subject)
       end
 
-      describe ".current" do
-        context "with currents in two threads" do
-          let(:current_key) { "#{Future.name}_current" }
-
-          let(:a_thread) do
-            thread = Hash.new
-          end
+      its(:query) { should eq query }
+      its(:binds) { should eq binds }
 
-          let(:another_thread) do
-            thread = Hash.new
-          end
+      it { should_not be_fulfilled }
+    end
 
-          before do
-            Thread.stub(:current).and_return(a_thread)
+    describe "#fulfill" do
+      let(:result) { "Some cool result" }
 
-            Future.current = "Future 1"
+      before do
+        subject.fulfill(result)
+      end
 
-            Thread.stub(:current).and_return(another_thread)
+      it { should be_fulfilled }
+    end
 
-            Future.current = "Future 2"
-          end
+    describe "#load" do
+      before do
+        execution.stub(:call) do
+          @current_future = FutureRegistry.current
+          nil
+        end
 
-          context "the current in thread 1" do
-            let(:current) { a_thread[current_key] }
+        subject.load
+      end
 
-            specify { current.should eq "Future 1" }
-          end
+      it "calls the execution" do
+        execution.should have_received(:call)
+      end
 
-          context "the current in thread 2" do
-            let(:current) { another_thread[current_key] }
+      it "sets the current future to itself while execution was being called in the relation" do
+        @current_future.should == subject
+      end
 
-            specify { current.should eq "Future 2" }
-          end
-        end
+      it "sets to nil the current future afterwards" do
+        FutureRegistry.current.should == nil
       end
     end
   end

data/spec/active_record/futures/future_value_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+module ActiveRecord::Futures
+  describe FutureValue do
+    let(:future) do
+      double(Future, execute: nil)
+    end
+    subject { FutureValue.new(future) }
+
+    describe "#value" do
+      before do
+        subject.value
+      end
+
+      specify { future.should have_received(:execute) }
+    end
+
+    describe "#inspect" do
+      before do
+        subject.inspect
+      end
+
+      specify { future.should have_received(:execute) }
+    end
+  end
+end

data/spec/in_action/combination_of_futures_spec.rb

@@ -45,7 +45,7 @@ describe "Combination of futures" do
 
     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) }
+      it { should exec_query(post_relation.to_sql) }
     end
   end
 
@@ -57,8 +57,8 @@ describe "Combination of futures" do
     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 }
+      it(nil, :supporting_adapter) { execution(subject).should be_fulfilled }
+      it(nil, :not_supporting_adapter) { execution(subject).should_not be_fulfilled }
 
       describe "#to_a" do
         let(:calling_to_a) { ->{ subject.to_a } }
@@ -79,8 +79,8 @@ describe "Combination of futures" do
     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 }
+      it(nil, :supporting_adapter) { execution(subject).should be_fulfilled }
+      it(nil, :not_supporting_adapter) { execution(subject).should_not be_fulfilled }
 
       describe "#value" do
         let(:calling_value) { ->{ subject.value } }
@@ -101,8 +101,8 @@ describe "Combination of futures" do
     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 }
+      it(nil, :supporting_adapter) { execution(subject).should be_fulfilled }
+      it(nil, :not_supporting_adapter) { execution(subject).should_not be_fulfilled }
 
       describe "#to_a" do
         let(:calling_to_a) { ->{ subject.to_a } }
@@ -124,8 +124,8 @@ describe "Combination of futures" do
     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 }
+      it(nil, :supporting_adapter) { execution(subject).should be_fulfilled }
+      it(nil, :not_supporting_adapter) { execution(subject).should_not be_fulfilled }
 
       describe "#value" do
         let(:calling_value) { ->{ subject.value } }
@@ -144,6 +144,10 @@ describe "Combination of futures" do
     end
   end
 
+  def execution(future)
+    future.send(:future_execution)
+  end
+
   def count(relation)
     arel = relation.arel
     arel.projections = []

data/spec/in_action/future_all_execution_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe "future_all method" do
+  context "with no parameters" do
+    let(:relation) { Post.where("published_at < ?", Time.new(2013, 1, 1)) }
+    let(:future) { relation.future_all }
+    let(:relation_result) { relation.all }
+    let(:future_sql) do
+      relation.to_sql
+    end
+
+    before do
+      Post.create(published_at: Time.new(2012, 12, 10))
+      Post.create(published_at: Time.new(2012, 6, 23))
+      Post.create(published_at: Time.new(2013, 4, 5))
+    end
+
+    it_behaves_like "a futurized method", :to_a
+  end
+end