elevate 0.3

data/lib/elevate/http/http_client.rb

@@ -0,0 +1,100 @@
+module Elevate
+module HTTP
+  class HTTPClient
+    def initialize(base_url)
+      @base_url = NSURL.URLWithString(base_url)
+      @credentials = nil
+    end
+
+    def get(path, query={}, &block)
+      issue(:GET, path, nil, query: query, &block)
+    end
+
+    def post(path, body, &block)
+      issue(:post, path, body, &block)
+    end
+
+    def put(path, body, &block)
+      issue(:put, path, body, &block)
+    end
+
+    def delete(path, &block)
+      issue(:delete, path, nil, &block)
+    end
+
+    def set_credentials(username, password)
+      @credentials = { username: username, password: password }
+    end
+
+    private
+
+    def issue(method, path, body, options={}, &block)
+      url = url_for(path)
+
+      options[:headers] ||= {}
+      options[:headers]["Accept"] = "application/json"
+
+      if @credentials
+        options[:credentials] = @credentials
+      end
+
+      if body
+        options[:body] = NSJSONSerialization.dataWithJSONObject(body, options:0, error:nil)
+        options[:headers]["Content-Type"] = "application/json"
+      end
+
+      request = HTTPRequest.new(method, url, options)
+
+      coordinator = IOCoordinator.for_thread
+
+      coordinator.signal_blocked(request) if coordinator
+      response = JSONHTTPResponse.new(request.response)
+      coordinator.signal_unblocked(request) if coordinator
+
+      if response.error == nil && block_given?
+        result = yield response.body
+        puts result.inspect
+
+        result
+      else
+        response
+      end
+    end
+
+    def url_for(path)
+      path = CFURLCreateStringByAddingPercentEscapes(nil, path.to_s, "[]", ";=&,", KCFStringEncodingUTF8)
+
+      NSURL.URLWithString(path, relativeToURL:@base_url).absoluteString
+    end
+  end
+
+  class JSONHTTPResponse
+    def initialize(response)
+      @response = response
+      @body = decode(response.body)
+    end
+
+    def decode(data)
+      return nil if data.nil?
+
+      NSJSONSerialization.JSONObjectWithData(data, options:0, error:nil)
+    end
+
+    attr_reader :body
+
+    # TODO: delegate
+    def error
+      @response.error
+    end
+
+    def headers
+      @response.headers
+    end
+
+    def status_code
+      @response.status_code
+    end
+    
+  end
+end
+end

data/lib/elevate/http/request.rb

@@ -0,0 +1,95 @@
+module Elevate
+module HTTP
+  # TODO: redirects
+  class HTTPRequest
+    METHODS = [:get, :post, :put, :delete, :patch, :head, :options].freeze
+    QUEUE = NSOperationQueue.alloc.init
+
+    def initialize(method, url, options={})
+      raise ArgumentError, "invalid HTTP method" unless METHODS.include? method.downcase
+      raise ArgumentError, "invalid URL" unless url.start_with? "http"
+      raise ArgumentError, "invalid body type; must be NSData" if options[:body] && ! options[:body].is_a?(NSData)
+
+      unless options.fetch(:query, {}).empty?
+        url += "?" + URI.encode_query(options[:query])
+      end
+
+      @request = NSMutableURLRequest.alloc.init
+      @request.CachePolicy = NSURLRequestReloadIgnoringLocalCacheData
+      @request.HTTPBody = options[:body]
+      @request.HTTPMethod = method
+      @request.URL = NSURL.URLWithString(url)
+
+      headers = options.fetch(:headers, {})
+
+      if credentials = options[:credentials]
+        headers["Authorization"] = get_authorization_header(credentials)
+      end
+
+      headers.each do |key, value|
+        @request.setValue(value.to_s, forHTTPHeaderField:key.to_s)
+      end
+
+      @response = HTTPResponse.new
+
+      @connection = nil
+      @promise = Promise.new
+    end
+
+    def cancel
+      return unless started?
+
+      @connection.cancel()
+      @promise.set(nil)
+    end
+
+    def response
+      unless started?
+        start()
+      end
+
+      @promise.get()
+    end
+
+    def start
+      @connection = NSURLConnection.alloc.initWithRequest(@request, delegate:self, startImmediately:false)
+      @connection.setDelegateQueue(QUEUE)
+      @connection.start()
+    end
+
+    def started?
+      @connection != nil
+    end
+
+    private
+
+    def connection(connection, didReceiveResponse: response)
+      @response.headers = response.allHeaderFields
+      @response.status_code = response.statusCode
+    end
+
+    def connection(connection, didReceiveData: data)
+      @response.append_data(data)
+    end
+
+    def connection(connection, didFailWithError: error)
+      puts "ERROR: #{error.localizedDescription}"
+
+      @response.error = error
+      @response.freeze
+
+      @promise.set(@response)
+    end
+
+    def connectionDidFinishLoading(connection)
+      @response.freeze
+
+      @promise.set(@response)
+    end
+
+    def get_authorization_header(credentials)
+      "Basic " + Base64.encode("#{credentials[:username]}:#{credentials[:password]}")
+    end    
+  end
+end
+end

data/lib/elevate/http/response.rb

@@ -0,0 +1,22 @@
+module Elevate
+module HTTP
+  class HTTPResponse
+    def initialize
+      @body = nil
+      @headers = nil
+      @status_code = nil
+      @error = nil
+    end
+
+    def append_data(data)
+      @body ||= NSMutableData.alloc.init
+      @body.appendData(data)
+    end
+
+    attr_reader   :body
+    attr_accessor :headers
+    attr_accessor :status_code
+    attr_accessor :error
+  end
+end
+end

data/lib/elevate/http/uri.rb

@@ -0,0 +1,19 @@
+module Elevate
+module HTTP
+  module URI
+    def self.encode_query(hash)
+      return "" if hash.nil? || hash.empty?
+
+      hash.map do |key, value|
+        "#{URI.escape_query_component(key.to_s)}=#{URI.escape_query_component(value.to_s)}"
+      end.join("&")
+    end
+
+    def self.escape_query_component(component)
+      component.gsub(/([^ a-zA-Z0-9_.-]+)/) do
+        '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+      end.tr(' ', '+')
+    end
+  end
+end
+end

data/lib/elevate/io_coordinator.rb

@@ -0,0 +1,69 @@
+module Elevate
+  class IOCoordinator
+    def self.for_thread
+      Thread.current[:io_coordinator]
+    end
+
+    def initialize
+      @lock = NSLock.alloc.init
+      @blocking_operation = nil
+      @cancelled = false
+    end
+
+    def cancel
+      blocking_operation = nil
+
+      @lock.lock()
+      @cancelled = true
+      blocking_operation = @blocking_operation
+      @lock.unlock()
+
+      if blocking_operation
+        blocking_operation.cancel()
+      end
+    end
+
+    def cancelled?
+      cancelled = nil
+
+      @lock.lock()
+      cancelled = @cancelled
+      @lock.unlock()
+
+      cancelled
+    end
+
+    def install
+      Thread.current[:io_coordinator] = self
+    end
+
+    def signal_blocked(operation)
+      check_for_cancellation
+
+      @lock.lock()
+      @blocking_operation = operation
+      @lock.unlock()
+    end
+
+    def signal_unblocked(operation)
+      @lock.lock()
+      @blocking_operation = nil
+      @lock.unlock()
+
+      check_for_cancellation
+    end
+
+    def uninstall
+      Thread.current[:io_coordinator] = nil
+    end
+
+    private
+
+    def check_for_cancellation
+      raise CancelledError if cancelled?
+    end
+  end
+
+  class CancelledError < StandardError
+  end
+end

data/lib/elevate/operation.rb

@@ -0,0 +1,74 @@
+module Elevate
+  class ElevateOperation < NSOperation
+    def initWithTarget(target)
+      if init()
+        @target = target
+        @coordinator = IOCoordinator.new
+        @dispatcher = Dispatcher.new
+
+        setCompletionBlock(lambda do
+          @target = nil
+
+          @dispatcher.invoke_finished_callback() unless isCancelled()
+          @dispatcher.dispose()
+        end)
+      end
+
+      self
+    end
+
+    def cancel
+      @coordinator.cancel()
+
+      super
+    end
+
+    def dealloc
+      #puts 'dealloc!'
+
+      super
+    end
+
+    def inspect
+      details = []
+      details << "<canceled>" if @coordinator.cancelled?
+      details << "@target=#{@target.class.name}"
+
+      "#<#{self.class.name}: #{details.join(" ")}>"
+    end
+
+    def log(line)
+      puts line unless RUBYMOTION_ENV == "test"
+    end
+
+    def main
+      log " START: #{inspect}"
+
+      @coordinator.install()
+
+      begin
+        unless @coordinator.cancelled?
+          @result = @target.execute
+        end
+
+      rescue => e
+        @exception = e
+      end
+
+      @coordinator.uninstall()
+
+      log "FINISH: #{inspect}"
+    end
+
+    attr_reader :exception
+    attr_reader :result
+
+    def on_started=(callback)
+      @dispatcher.on_started = callback
+    end
+
+    def on_finished=(callback)
+      @dispatcher.on_finished = callback
+    end
+  end
+end

data/lib/elevate/promise.rb

@@ -0,0 +1,27 @@
+module Elevate
+  class Promise
+    OUTSTANDING = 0
+    FULFILLED = 1
+
+    def initialize
+      @lock = NSConditionLock.alloc.initWithCondition(OUTSTANDING)
+      @result = nil
+    end
+
+    def get
+      result = nil
+
+      @lock.lockWhenCondition(FULFILLED)
+      result = @result
+      @lock.unlockWithCondition(FULFILLED)
+
+      result
+    end
+
+    def set(result)
+      @lock.lockWhenCondition(OUTSTANDING)
+      @result = result
+      @lock.unlockWithCondition(FULFILLED)
+    end
+  end
+end

data/lib/elevate/version.rb

@@ -0,0 +1,3 @@
+module Elevate
+  VERSION = "0.3"
+end

data/spec/api_spec.rb

@@ -0,0 +1,23 @@
+module Bacon
+  class Context
+    include ::Elevate
+  end
+end
+
+describe Elevate do
+  describe "#async" do
+    it "runs the specified interactor asynchronously" do
+
+      async Target.new() do
+        on_completed do |operation|
+          @called = true
+          resume
+        end
+      end
+
+      wait_max 1.0 do
+        @called.should.be.true
+      end
+    end
+  end
+end

data/spec/callback_spec.rb

@@ -0,0 +1,12 @@
+describe Elevate::Callback do
+  describe "#call" do
+    it "invokes the block using instance_*" do
+      callback = Elevate::Callback.new(self, 42, lambda { |v| @value = v })
+      callback.call
+
+      @value.should == 42
+    end
+
+  end
+end
+