elevate 0.6.0 → 0.7.0

data/lib/elevate/http/response.rb

@@ -9,7 +9,7 @@ module HTTP
       @headers = nil
       @status_code = nil
       @error = nil
-      @raw_body = nil
+      @raw_body = NSMutableData.alloc.init
       @url = nil
     end
 
@@ -17,7 +17,6 @@ module HTTP
     #
     # @api private
     def append_data(data)
-      @raw_body ||= NSMutableData.alloc.init
       @raw_body.appendData(data)
     end
 

data/lib/elevate/operation.rb

@@ -8,33 +8,12 @@ module Elevate
     #   newly initialized instance
     #
     # @api private
-    def initWithTarget(target, args:args)
+    def initWithTarget(target, args: args, channel: channel)
       if init
         @coordinator = IOCoordinator.new
-        @context = TaskContext.new(args, &target)
-        @timeout_callback = nil
-        @timer = nil
-        @update_callback = nil
-        @finish_callback = nil
-
-        setCompletionBlock(lambda do
-          if @finish_callback
-            @finish_callback.call(@result, @exception) unless isCancelled
-          end
-
-          Dispatch::Queue.main.sync do
-            @context = nil
-
-            if @timer
-              @timer.invalidate
-              @timer = nil
-            end
-
-            @timeout_callback = nil
-            @update_callback = nil
-            @finish_callback = nil
-          end
-        end)
+        @context = TaskContext.new(target, channel, args)
+        @exception = nil
+        @result = nil
       end
 
       self
@@ -51,56 +30,26 @@ module Elevate
       super
     end
 
-    # Returns information about this task.
-    #
-    # @return [String]
-    #   String suitable for debugging purposes.
-    #
-    # @api public
-    def inspect
-      details = []
-      details << "<canceled>" if @coordinator.cancelled?
-
-      "#<#{self.class.name}: #{details.join(" ")}>"
-    end
-
-    # Logs debugging information in certain configurations.
-    #
-    # @return [void]
-    #
-    # @api private
-    def log(line)
-      puts line unless RUBYMOTION_ENV == "test"
-    end
-
     # Runs the specified task.
     #
     # @return [void]
     #
     # @api private
     def main
-      log " START: #{inspect}"
-
       @coordinator.install
 
       begin
         unless @coordinator.cancelled?
-          @result = @context.execute do |*args|
-            @update_callback.call(*args) if @update_callback
-          end
+          @result = @context.execute
         end
 
-      rescue Exception => e
+      rescue => e
         @exception = e
-
-        if e.is_a?(TimeoutError)
-          @timeout_callback.call if @timeout_callback
-        end
       end
 
       @coordinator.uninstall
 
-      log "FINISH: #{inspect}"
+      @context = nil
     end
 
     # Returns the exception that terminated this task, if any.
@@ -123,96 +72,14 @@ module Elevate
     # @api public
     attr_reader :result
 
-    # Sets the callback to be run upon completion of this task. Do not call
-    # this method after the task has started.
-    #
-    # @param callback [Elevate::Callback]
-    #   completion callback
-    #
-    # @return [void]
-    #
-    # @api private
-    def on_finish=(callback)
-      @finish_callback = callback
-    end
-
-    # Sets the callback to be run when this task is queued.
-    #
-    # Do not call this method after the task has started.
-    #
-    # @param callback [Elevate::Callback]
-    #   callback to be invoked when queueing
-    #
-    # @return [void]
-    #
-    # @api private
-    def on_start=(callback)
-      start_callback = callback
-      start_callback.retain
-
-      Dispatch::Queue.main.async do
-        start_callback.call unless isCancelled
-        start_callback.release
-      end
-    end
-
-    # Handles timeout expiration.
-    #
-    # @return [void]
-    #
-    # @api private
-    def on_timeout_elapsed(timer)
-      @coordinator.cancel(TimeoutError)
-    end
-
-    # Sets the timeout callback.
-    #
-    # @param callback [Elevate::Callback]
-    #   callback to run on timeout
-    #
-    # @return [void]
-    #
-    # @api private
-    def on_timeout=(callback)
-      @timeout_callback = callback
-    end
-
-    # Sets the update callback, which is invoked for any yield statements in the task.
-    #
-    # @param callback [Elevate::Callback]
-    # @return [void]
-    #
-    # @api private
-    def on_update=(callback)
-      @update_callback = callback
-    end
-
-    # Sets the timeout interval for this task.
-    #
-    # The timeout starts when the task is queued, not when it is started.
-    #
-    # @param interval [Fixnum]
-    #   seconds to allow for task completion
+    # Cancels any waiting operation with a TimeoutError, interrupting
+    # execution. This is not the same as #cancel.
     #
     # @return [void]
     #
-    # @api private
-    def timeout=(interval)
-      @timer = NSTimer.scheduledTimerWithTimeInterval(interval,
-                                                      target: self,
-                                                      selector: :"on_timeout_elapsed:",
-                                                      userInfo: nil,
-                                                      repeats: false)
-    end
-
-    # Returns whether this task timed out.
-    #
-    # @return [Boolean]
-    #   true if this task was aborted due to a time out.
-    #
     # @api public
-    def timed_out?
-      @exception.class == TimeoutError
+    def timeout
+      @coordinator.cancel(TimeoutError)
     end
   end
 end

data/lib/elevate/task.rb

@@ -0,0 +1,122 @@
+module Elevate
+  class Task
+    def initialize(definition, controller, active_tasks)
+      @definition = definition
+      @controller = WeakRef.new(controller)
+      @active_tasks = active_tasks
+      @operation = nil
+      @channel = Channel.new(method(:on_update))
+      @args = nil
+      @timer = nil
+    end
+
+    def cancel
+      if @operation
+        @operation.cancel
+
+        if @timer
+          @timer.invalidate
+        end
+      end
+    end
+
+    def name
+      @definition.name
+    end
+
+    def start(args)
+      @operation = ElevateOperation.alloc.initWithTarget(@definition.handlers[:background],
+                                                         args: args,
+                                                         channel: WeakRef.new(@channel))
+
+      @operation.addObserver(self, forKeyPath: "isFinished", options: NSKeyValueObservingOptionNew, context: nil)
+      queue.addOperation(@operation)
+      @active_tasks << self
+
+      @args = args
+
+      if interval = @definition.options[:timeout_interval]
+        @timer = NSTimer.scheduledTimerWithTimeInterval(interval,
+                                                        target: self,
+                                                        selector: :"on_timeout:",
+                                                        userInfo: nil,
+                                                        repeats: false)
+      end
+
+      performSelectorOnMainThread(:on_start, withObject: nil, waitUntilDone: false)
+    end
+
+    private
+
+    def error_handler_for(exception)
+      handler_name = exception.class.name
+      handler_name = handler_name.split("::").last
+      handler_name.gsub!(/Error$/, "")
+      handler_name.gsub!(/(.)([A-Z])/) { |m| "#{$1}_#{$2.downcase}" }
+      handler_name = "on_" + handler_name.downcase
+
+      handler_name.to_sym
+    end
+
+    def invoke(handler_name, *args)
+      return false if @operation.isCancelled
+
+      block = @definition.handlers[handler_name]
+      return false unless block
+
+      @controller.task_args = @args
+      @controller.instance_exec(*args, &block)
+      @controller.task_args = nil
+
+      true
+    end
+
+    def queue
+      Dispatch.once do
+        $elevate_queue = NSOperationQueue.alloc.init
+        $elevate_queue.maxConcurrentOperationCount = 1
+      end
+
+      $elevate_queue
+    end
+
+    def observeValueForKeyPath(path, ofObject: operation, change: change, context: ctx)
+      case path
+      when "isFinished"
+        performSelectorOnMainThread(:on_finish, withObject: nil, waitUntilDone: false)
+      end
+    end
+
+    def on_start
+      invoke(:on_start)
+    end
+
+    def on_finish
+      @operation.removeObserver(self, forKeyPath: "isFinished")
+      @active_tasks.delete(self)
+
+      if @timer
+        @timer.invalidate
+      end
+
+      if exception = @operation.exception
+        invoke(error_handler_for(exception), exception) || invoke(:on_error, exception)
+      end
+
+      invoke(:on_finish, @operation.result, @operation.exception)
+    end
+
+    def on_timeout(timer)
+      @operation.timeout
+    end
+
+    def on_update(args)
+      unless NSThread.isMainThread
+        performSelectorOnMainThread(:"on_update:", withObject: args, waitUntilDone: false)
+        return
+      end
+
+      invoke(:on_update, *args)
+    end
+  end
+end

data/lib/elevate/task_context.rb

@@ -2,17 +2,26 @@ module Elevate
   # A blank slate for hosting task blocks.
   #
   # Because task blocks run in another thread, it is dangerous to expose them
-  # to the calling context. This class acts as a sandbox for task blocks. 
+  # to the calling context. This class acts as a sandbox for task blocks.
   #
   # @api private
   class TaskContext
-    def initialize(args, &block)
-      metaclass = class << self; self; end
-      metaclass.send(:define_method, :execute, &block)
+    def initialize(block, channel, args)
+      @__block = block
+      @__channel = channel
+      @__args = args
+    end
+
+    def execute
+      instance_exec(&@__block)
+    end
+
+    def task_args
+      @__args
+    end
 
-      args.each do |key, value|
-        instance_variable_set("@#{key}", value)
-      end
+    def update(*args)
+      @__channel << args if @__channel
     end
   end
 end

data/lib/elevate/task_definition.rb

@@ -0,0 +1,62 @@
+module Elevate
+  class TaskDefinition
+    def initialize(name, options, &block)
+      @name = name
+      @options = options
+      @handlers = {}
+
+      instance_eval(&block)
+    end
+
+    attr_reader :name
+    attr_reader :handlers
+    attr_reader :options
+
+    def method_missing(method, *args, &block)
+      if method.to_s.start_with?("on_")
+        raise ArgumentError, "wrong number of arguments" unless args.empty?
+        raise ArgumentError, "block not supplied" unless block_given?
+
+        @handlers[method.to_sym] = block
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      method.to_s.start_with?("on_") || super
+    end
+
+    def background(&block)
+      @handlers[:background] = block
+    end
+
+    def on_error(&block)
+      raise "on_error blocks must accept one parameter" unless block.arity == 1
+
+      @handlers[:on_error] = block
+    end
+
+    def on_finish(&block)
+      raise "on_finish blocks must accept two parameters" unless block.arity == 2
+
+      @handlers[:on_finish] = block
+    end
+
+    def on_start(&block)
+      raise "on_start blocks must accept zero parameters" unless block.arity == 0
+
+      @handlers[:on_start] = block
+    end
+
+    def on_update(&block)
+      @handlers[:on_update] = block
+    end
+
+    def timeout(seconds)
+      raise "timeout argument must be a number" unless seconds.is_a?(Numeric)
+
+      @options[:timeout_interval] = seconds
+    end
+  end
+end

data/lib/elevate/version.rb

@@ -1,3 +1,3 @@
 module Elevate
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/spec/elevate_spec.rb

@@ -1,159 +1,311 @@
-module Bacon
-  class Context
-    include ::Elevate
+class TestController
+  include Elevate
+
+  def initialize
+    @invocations = {}
+    @counter = 0
+    @threads = []
+    @updates = []
+    @callback_args = nil
+    @completion = nil
+  end
+
+  attr_accessor :started
+  attr_accessor :result
+  attr_accessor :exception
+  attr_accessor :invocations
+  attr_accessor :counter
+  attr_accessor :threads
+  attr_accessor :updates
+  attr_accessor :callback_args
+  attr_accessor :completion
+
+  task :cancellable do
+    background do
+      task_args[:semaphore].wait
+      update 42
+
+      nil
+    end
+
+    on_start do
+      self.invocations[:start] = counter
+      self.counter += 1
+    end
+
+    on_finish do |result, ex|
+      self.invocations[:finish] = counter
+      self.counter += 1
+    end
+
+    on_update do |n|
+      self.invocations[:update] = counter
+      self.counter += 1
+    end
+  end
+
+  task :custom_error_handlers do
+    background do
+      raise TimeoutError
+    end
+
+    on_error do |e|
+      self.invocations[:error] = counter
+      self.counter += 1
+    end
+
+    on_timeout do |e|
+      self.invocations[:timeout] = counter
+      self.counter += 1
+    end
+  end
+
+  task :test_task do
+    background do
+      sleep 0.05
+      update 1
+      raise Elevate::TimeoutError if task_args[:raise]
+      sleep 0.1
+      update 2
+
+      42
+    end
+
+    on_start do
+      self.invocations[:start] = counter
+      self.callback_args = task_args
+      self.counter += 1
+
+      self.threads << NSThread.currentThread
+    end
+
+    on_update do |num|
+      self.updates << num
+
+      self.invocations[:update] = counter
+      self.counter += 1
+
+      self.threads << NSThread.currentThread
+    end
+
+    on_error do |e|
+      self.invocations[:error] = counter
+      self.counter += 1
+    end
+
+    on_finish do |result, exception|
+      self.invocations[:finish] = counter
+      self.counter += 1
+
+      self.threads << NSThread.currentThread
+
+      self.result = result
+      self.exception = exception
+
+      #Dispatch::Queue.main.async { resume }
+    end
+  end
+
+  task :timeout_test do
+    timeout 0.3
+
+    background do
+      Elevate::HTTP.get("http://example.com/")
+    end
+
+    on_timeout do |e|
+      self.invocations[:timeout] = counter
+      self.counter += 1
+    end
+
+    on_finish do |result, ex|
+      self.invocations[:finish] = counter
+      self.counter += 1
+
+      @completion.call if @completion
+    end
   end
 end
 
 describe Elevate do
   extend WebStub::SpecHelpers
 
-  describe "#async" do
-    it "runs the specified task asynchronously" do
-      async do
-        task do
-          true
-        end
+  before do
+    @controller = TestController.new
+  end
 
-        on_finish do |result, exception|
-          @called = result
-          resume
-        end
+  describe "#cancel" do
+    describe "when no tasks are running" do
+      it "does nothing" do
+        ->{ @controller.cancel(:test_task) }.should.not.raise
       end
+    end
 
-      wait_max 1.0 do
-        @called.should.be.true
+    describe "when a single task is running" do
+      it "cancels the task and does not invoke callbacks" do
+        semaphore = Dispatch::Semaphore.new(0)
+        @controller.launch(:cancellable, semaphore: semaphore)
+
+        @controller.cancel(:cancellable)
+        semaphore.signal
+
+        wait 0.5 do
+          @controller.invocations[:update].should.be.nil
+          @controller.invocations[:finish].should.be.nil
+        end
       end
     end
 
-    it "passes provided args to the task as instance variables" do
-      async name: "harry" do
-        task do
-          @name
-        end
+    describe "when several tasks are running" do
+      it "cancels all of them" do
+        semaphore = Dispatch::Semaphore.new(0)
+
+        @controller.launch(:cancellable, semaphore: semaphore)
+        @controller.launch(:cancellable, semaphore: semaphore)
+        @controller.launch(:cancellable, semaphore: semaphore)
+
+        @controller.cancel(:cancellable)
+        semaphore.signal
 
-        on_finish do |name, exception|
-          @result = name
-          resume
+        wait 0.5 do
+          @controller.invocations[:update].should.be.nil
+          @controller.invocations[:finish].should.be.nil
         end
+
       end
+    end
+  end
 
-      wait_max 1.0 do
-        @result.should == "harry"
+  describe "#launch" do
+    it "runs the task asynchronously, returning the result" do
+      @controller.launch(:test_task, raise: false)
+
+      wait 0.5 do
+        @controller.result.should == 42
       end
     end
 
     it "allows tasks to report progress" do
-      @updates = []
-
-      async do
-        task do
-          sleep 0.1
-          yield 1
-          sleep 0.2
-          yield 2
-          sleep 0.3
-          yield 3
-
-          true
-        end
+      @controller.launch(:test_task, raise: false)
 
-        on_update do |count|
-          @updates << count
-        end
-
-        on_finish do |result, exception|
-          resume
-        end
+      wait 0.5 do
+        @controller.updates.should == [1, 2]
       end
+    end
 
-      wait_max 1.0 do
-        @updates.should == [1,2,3]
+    it "invokes all callbacks on the UI thread" do
+      @controller.launch(:test_task, raise: false)
+
+      wait 0.5 do
+        @controller.threads.each { |t| t.isMainThread.should.be.true }
       end
     end
 
-    describe "timeouts" do
-      before do
-        stub_request(:get, "http://example.com/").
-          to_return(body: "Hello!", content_type: "text/plain", delay: 1.0)
+    it "sets task_args to args used at launch" do
+      @controller.launch(:test_task, raise: true)
+
+      wait 0.5 do
+        @controller.callback_args.should == { raise: true }
       end
+    end
 
-      it "does not cancel the operation if it completes in time" do
-        @timed_out = false
+    it "invokes on_error when an exception occurs" do
+      @controller.launch(:test_task, raise: true)
 
-        async do
-          timeout 3.0
+      wait 0.5 do
+        @controller.invocations[:error].should.not.be.nil
+      end
+    end
 
-          task do
-            Elevate::HTTP.get("http://example.com/")
+    it "invokes on_start before on_finish" do
+      @controller.launch(:test_task, raise: false)
 
-            "finished"
-          end
+      wait 0.5 do
+        @controller.invocations[:start].should < @controller.invocations[:finish]
+      end
+    end
 
-          on_finish do |result, exception|
-            @result = result
-            resume
-          end
-        end
+    it "invokes on_update before on_finish" do
+      @controller.launch(:test_task, raise: false)
 
-        wait_max 5.0 do
-          @result.should == "finished"
-          @timed_out.should.be.false
-        end
+      wait 0.5 do
+        invocations = @controller.invocations
+
+        invocations[:update].should < invocations[:finish]
       end
+    end
 
-      it "stops the operation when timeout interval has elapsed" do
-        @result = nil
+    it "invokes on_update after on_start" do
+      @controller.launch(:test_task, raise: false)
+
+      wait 0.5 do
+        invocations = @controller.invocations
+
+        invocations[:update].should > invocations[:start]
+      end
+    end
+  end
 
-        @task = async do
-          timeout 0.5
+  describe "error handling" do
+    it "invokes an error handling correspding to the raised exception" do
+      @controller.launch(:custom_error_handlers)
 
-          task do
-            Elevate::HTTP.get("http://example.com/")
+      wait 0.5 do
+        invocations = @controller.invocations
 
-            "finished"
-          end
+        invocations[:timeout].should.not.be.nil
+        invocations[:error].should.be.nil
+      end
+    end
 
-          on_finish do |result, exception|
-            @result = result
-            resume
-          end
-        end
+    it "invokes on_error if there is not a specific handler" do
+      @controller.launch(:test_task, raise: true)
 
-        wait_max 5.0 do
-          @result.should.not == "finished"
+      wait 0.5 do
+        invocations = @controller.invocations
 
-          @task.timed_out?.should.be.true
-        end
+        invocations[:error].should.not.be.nil
       end
+    end
+  end
 
-      it "invokes on_timeout when a timeout occurs" do
-        @result = ""
-        @timed_out = false
+  describe "timeouts" do
+    it "does not cancel the operation if it completes in time" do
+      stub_request(:get, "http://example.com/").
+        to_return(body: "Hello!", content_type: "text/plain")
 
-        async do
-          timeout 0.5
+      @controller.completion = -> { resume }
+      @controller.launch(:timeout_test)
 
-          task do
-            Elevate::HTTP.get("http://example.com/")
+      wait_max 0.9 do
+        @controller.invocations[:timeout].should.be.nil
+        @controller.invocations[:finish].should.not.be.nil
+      end
+    end
 
-            "finished"
-          end
+    it "stops the operation when it exceeds the timeout" do
+      stub_request(:get, "http://example.com/").
+        to_return(body: "Hello!", content_type: "text/plain", delay: 1.0)
 
-          on_timeout do
-            @timed_out = true
-          end
+      @controller.completion = -> { resume }
+      @controller.launch(:timeout_test)
 
-          on_finish do |result, exception|
-            @result = result
-            resume
-          end
-        end
+      wait_max 0.9 do
+        @controller.invocations[:finish].should.not.be.nil
+      end
+    end
 
-        wait_max 5.0 do
-          @result.should.not == "finished"
-          @timed_out.should.be.true
-        end
+    it "invokes on_timeout when the operation times out" do
+      stub_request(:get, "http://example.com/").
+        to_return(body: "Hello!", content_type: "text/plain", delay: 1.0)
+
+      @controller.completion = -> { resume }
+      @controller.launch(:timeout_test)
+
+      wait_max 0.9 do
+        @controller.invocations[:timeout].should.not.be.nil
       end
+
     end
   end
 end