activerecord-futures 0.2.0 → 0.3.0

data/lib/active_record/futures/future_calculation.rb

@@ -1,30 +0,0 @@
-module ActiveRecord
-  module Futures
-    class FutureCalculation < Future
-      attr_reader :query, :execution
-      private :query, :execution
-
-      def initialize(relation, query, execution)
-        super(relation)
-        @query = query
-        @execution = execution
-      end
-
-      def to_sql
-        query
-      end
-
-    private
-
-      def execute
-        @value = execution.call unless executed?
-        @executed = true
-        @value
-      end
-
-      def executed?
-        @executed
-      end
-    end
-  end
-end

data/lib/active_record/futures/future_calculation_array.rb

@@ -1,8 +0,0 @@
-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

@@ -1,7 +0,0 @@
-module ActiveRecord
-  module Futures
-    class FutureCalculationValue < FutureCalculation
-      fetch_with(:value)
-    end
-  end
-end

data/lib/active_record/futures/future_relation.rb

@@ -1,34 +0,0 @@
-module ActiveRecord
-  module Futures
-    class FutureRelation < Future
-      include ActiveRecord::Delegation
-
-      def initialize(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
-
-      fetch_with(:to_a)
-
-      def to_sql
-        @query
-      end
-
-    private
-
-      def execute
-        relation.to_a
-      end
-
-      def executed?
-        relation.loaded?
-      end
-    end
-  end
-end

data/spec/active_record/futures/future_calculation_array_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-module ActiveRecord::Futures
-  describe FutureCalculationArray do
-    let(:relation) do
-      double(ActiveRecord::Relation, {
-        connection: double("connection", supports_futures?: true)
-      })
-    end
-
-    let(:query) { "select 1" }
-    let(:exec_result) { double("exec result", inspect: nil) }
-    let(:exec) { ->{ exec_result } }
-
-    subject { FutureCalculationArray.new(relation, query, exec) }
-
-    describe "#inspect" do
-      before do
-        subject.inspect
-      end
-
-      it { should be_executed }
-
-      it "delegates to exec result's inspect" do
-        exec_result.should have_received(:inspect)
-      end
-    end
-  end
-end

data/spec/active_record/futures/future_calculation_value_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-module ActiveRecord::Futures
-  describe FutureCalculationValue do
-    let(:relation) do
-      double(ActiveRecord::Relation, {
-        connection: double("connection", supports_futures?: true)
-      })
-    end
-
-    let(:query) { "select 1" }
-    let(:exec_result) { double("exec result", inspect: nil) }
-    let(:exec) { ->{ exec_result } }
-
-    subject { FutureCalculationValue.new(relation, query, exec) }
-
-    describe "#inspect" do
-      before do
-        subject.inspect
-      end
-
-      it { should be_executed }
-
-      it "delegates to exec result's inspect" do
-        exec_result.should have_received(:inspect)
-      end
-    end
-  end
-end

data/spec/active_record/futures/future_relation_spec.rb

@@ -1,81 +0,0 @@
-require "spec_helper"
-
-module ActiveRecord::Futures
-  describe FutureRelation do
-    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
-      before do
-        subject
-      end
-
-      it "gets registered" do
-        Future.all.should have(1).future
-        Future.all.first.should == subject
-      end
-
-      its(:relation) { should eq relation }
-
-      it { should_not be_fulfilled }
-    end
-
-    describe "#fulfill" do
-      let(:result) { "Some cool result" }
-
-      before do
-        subject.fulfill(result)
-      end
-
-      it { should be_fulfilled }
-    end
-
-    describe "#load" do
-      before do
-        relation.stub(:to_a) do
-          @current_future = Future.current
-          nil
-        end
-
-        subject.load
-      end
-
-      it "calls #to_a in the relation" do
-        relation.should have_received(:to_a)
-      end
-
-      it "sets the current future to itself while #to_a was being called in the relation" do
-        @current_future.should == subject
-      end
-
-      it "sets to nil the current future afterwards" do
-        Future.current.should == nil
-      end
-    end
-
-    describe "#inspect" do
-      let(:resulting_array) { double(Array, inspect: nil) }
-
-      before do
-        relation.stub(loaded?: true)
-        relation.stub(:to_a).and_return(resulting_array)
-
-        subject.inspect
-      end
-
-      it { should be_executed }
-
-      it "delegates to relation.to_a.inspect" do
-        resulting_array.should have_received(:inspect)
-      end
-    end
-  end
-end