afmotion 0.9.0 → 2.0.0.rc1

data/lib/afmotion/http_client.rb

@@ -1,74 +1,25 @@
-module AFMotion
-  class ClientDSL
-    def initialize(client)
-      @client = client
-    end
-
-    def header(header, value)
-      @client.setDefaultHeader(header, value: value)
-    end
-
-    def authorization(options = {})
-      @client.authorization = options
-    end
-
-    def operation(operation)
-      klass = operation
-      if operation.is_a?(Symbol) or operation.is_a?(String)
-        klass = case operation.to_s
-                when "json"
-                  AFJSONRequestOperation
-                when "plist"
-                  AFPropertyListRequestOperation
-                when "xml"
-                  AFXMLRequestOperation
-                when "http"
-                  AFHTTPRequestOperation
-                else
-                  raise "Not a valid operation: #{operation.inspect}"
-                end
-      end
-
-      @client.registerHTTPOperationClass(klass)
-    end
-
-    def parameter_encoding(encoding)
-      enc = encoding
-      if encoding.is_a?(Symbol) or encoding.is_a?(String)
-        enc = case encoding.to_s
-              when "json"
-                AFJSONParameterEncoding
-              when "plist"
-                AFPropertyListParameterEncoding
-              when "form"
-                AFFormURLParameterEncoding
-              else
-                p "Not a valid parameter encoding: #{encoding.inspect}; using AFFormURLParameterEncoding"
-                AFFormURLParameterEncoding
-              end
-      end
-      @client.parameterEncoding = enc
-    end
-  end
-end
+motion_require 'version'
+motion_require 'client_shared'
 
 module AFMotion
   class Client
     class << self
       attr_accessor :shared
 
-      # Returns an instance of AFHTTPClient
+      # Returns an instance of AFHTTPRequestOperationManager
       def build(base_url, &block)
-        client = AFHTTPClient.clientWithBaseURL(base_url.to_url)
+        operation_manager = AFHTTPRequestOperationManager.alloc.initWithBaseURL(base_url.to_url)
         if block
-          dsl = AFMotion::ClientDSL.new(client)
+          dsl = AFMotion::ClientDSL.new(operation_manager)
           dsl.instance_eval(&block)
         end
-        client
+        if !operation_manager.operationQueue
+          operation_manager.operationQueue = NSOperationQueue.mainQueue
+        end
+        operation_manager
       end
 
       # Sets AFMotion::Client.shared as the built client
-      # TODO: Make sure this only happens once (dispatch_once not available)
       def build_shared(base_url, &block)
         self.shared = self.build(base_url, &block)
       end
@@ -76,135 +27,111 @@ module AFMotion
   end
 end
 
-class AFHTTPClient
-  AFMotion::HTTP_METHODS.each do |method|
-    # EX client.get('my/resource.json')
-    define_method "#{method}", -> (path, parameters = {}, &callback) do
-      if multipart?
-        @operation = create_multipart_operation(method, path, parameters, &callback)
-        self.enqueueHTTPRequestOperation(@operation)
-        @multipart = nil
-      else
-        @operation = create_operation(method, path, parameters, &callback)
-        self.enqueueHTTPRequestOperation(@operation)
-      end
-      @operation
+module AFMotion
+  class ClientDSL
+    def initialize(operation_manager)
+      @operation_manager = WeakRef.new(operation_manager)
     end
-  end
 
-  def create_multipart_operation(method, path, parameters = {}, &callback)
-    multipart_callback = callback.arity == 1 ? nil : lambda { |formData|
-      callback.call(nil, formData)
-    }
-    upload_callback = callback.arity > 2 ? lambda { |bytes_written_now, total_bytes_written, total_bytes_expect|
-      case callback.arity
-      when 3
-        callback.call(nil, nil, total_bytes_written.to_f / total_bytes_expect.to_f)
-      when 5
-        callback.call(nil, nil, bytes_written_now, total_bytes_written, total_bytes_expect)
-      end
-    } : nil
-    request = self.multipartFormRequestWithMethod(method, path: path,
-      parameters: parameters,constructingBodyWithBlock: multipart_callback)
-    operation = self.HTTPRequestOperationWithRequest(request,
-      success: lambda {|operation, responseObject|
-        result = AFMotion::HTTPResult.new(operation, responseObject, nil)
-        case callback.arity
-        when 1
-          callback.call(result)
-        when 2
-          callback.call(result, nil)
-        when 3
-          callback.call(result, nil, nil)
-        when 5
-          callback.call(result, nil, nil, nil, nil)
-        end
-      }, failure: lambda {|operation, error|
-        result = AFMotion::HTTPResult.new(operation, nil, error)
-        case callback.arity
-        when 1
-          callback.call(result)
-        when 2
-          callback.call(result, nil)
-        when 3
-          callback.call(result, nil, nil)
-        when 5
-          callback.call(result, nil, nil, nil, nil)
-        end
-      })
-    if upload_callback
-      operation.setUploadProgressBlock(upload_callback)
+    def header(header, value)
+      @operation_manager.headers[header] = value
     end
-    operation
-  end
 
-  def create_operation(method, path, parameters = {}, &callback)
-    request = self.requestWithMethod(method.upcase, path:path, parameters:parameters)
-    self.HTTPRequestOperationWithRequest(request, success: lambda {|operation, responseObject|
-            result = AFMotion::HTTPResult.new(operation, responseObject, nil)
-            callback.call(result)
-          }, failure: lambda {|operation, error|
-            result = AFMotion::HTTPResult.new(operation, nil, error)
-            callback.call(result)
-          })
-  end
+    def authorization(options = {})
+      @operation_manager.requestSerializer.authorization = options
+    end
 
-  def multipart!
-    @multipart = true
-    self
-  end
+    def operation_queue(operation_queue)
+      @operation_manager.operationQueue = operation_queue
+    end
 
-  def multipart?
-    !!@multipart
-  end
+    OPERATION_TO_REQUEST_SERIALIZER = {
+      json: AFJSONRequestSerializer,
+      plist: AFPropertyListRequestSerializer
+    }
+    def request_serializer(serializer)
+      if serializer.is_a?(Symbol) || serializer.is_a?(String)
+        @operation_manager.requestSerializer = OPERATION_TO_REQUEST_SERIALIZER[serializer.to_sym].serializer
+      elsif serializer.is_a?(Class)
+        @operation_manager.requestSerializer = serializer.serializer
+      else
+        @operation_manager.requestSerializer = serializer
+      end
+    end
 
-  # options can be
-  # - {username: ___, password: ____}
-  # or
-  # - {token: ___ }
-  def authorization=(options = {})
-    if options.nil?
-      clearAuthorizationHeader
-    elsif options[:username] && options[:password]
-      setAuthorizationHeaderWithUsername(options[:username], password: options[:password])
-    elsif options[:token]
-      setAuthorizationHeaderWithToken(options[:token])
-    else
-      raise "Not a valid authorization hash: #{options.inspect}"
+    OPERATION_TO_RESPONSE_SERIALIZER = {
+      json: AFJSONResponseSerializer,
+      xml: AFXMLParserResponseSerializer,
+      plist: AFPropertyListResponseSerializer,
+      image: AFImageResponseSerializer,
+      http: AFHTTPResponseSerializer,
+      form: AFHTTPResponseSerializer
+    }
+    def response_serializer(serializer)
+      if serializer.is_a?(Symbol) || serializer.is_a?(String)
+        @operation_manager.responseSerializer = OPERATION_TO_RESPONSE_SERIALIZER[serializer.to_sym].serializer
+      elsif serializer.is_a?(Class)
+        @operation_manager.responseSerializer = serializer.serializer
+      else
+        @operation_manager.responseSerializer = serializer
+      end
     end
   end
+end
 
-  class HeaderWrapper
-    def initialize(client)
-      @client = WeakRef.new(client)
-    end
+# TODO: remove this when/if https://github.com/AFNetworking/AFNetworking/issues/1388 resolved
+module AFMotion
+  module QueryPairHelper
+    module_function
 
-    def [](header)
-      @client.defaultValueForHeader(header)
+    def af_QueryStringPairsFromDictionary(dictionary)
+      af_QueryStringPairsFromKeyAndValue(nil, dictionary)
     end
 
-    def []=(header, value)
-      @client.setDefaultHeader(header, value: value)
-    end
+    def af_QueryStringPairsFromKeyAndValue(key, value)
+      mutableQueryStringComponents = []
+      if value.is_a?(NSDictionary)
+        sortDescriptor = NSSortDescriptor.sortDescriptorWithKey("description", ascending: true, selector:'caseInsensitiveCompare:')
+        value.allKeys.sortedArrayUsingDescriptors([sortDescriptor]).each do |nestedKey|
+          nestedValue = value[nestedKey]
+          if nestedValue
+            mutableQueryStringComponents += af_QueryStringPairsFromKeyAndValue(key ? "#{key}[#{nestedKey}]" : nestedKey, nestedValue)
+          end
+        end
+      elsif value.is_a?(NSArray)
+        value.each do |obj|
+          mutableQueryStringComponents += af_QueryStringPairsFromKeyAndValue(key, obj)
+        end
+      elsif value.is_a?(NSSet)
+        value.each do |obj|
+          mutableQueryStringComponents += af_QueryStringPairsFromKeyAndValue(key, obj)
+        end
+      else
+        mutableQueryStringComponents << AFQueryStringPair.alloc.initWithField(key, value: value)
+      end
 
-    def delete(header)
-      value = self[header]
-      @client.setDefaultHeader(header, value: nil)
-      value
+      mutableQueryStringComponents
     end
   end
 
-  def headers
-    @header_wrapper ||= HeaderWrapper.new(self)
+  class MultipartParametersWrapper < Hash
+    def initialize(parameters)
+      super()
+      query_pairs = QueryPairHelper.af_QueryStringPairsFromDictionary(parameters)
+      query_pairs.each do |key_pair|
+        self[key_pair.field] = key_pair.value
+      end
+    end
   end
+end
 
-  private
-  # To force RubyMotion pre-compilation of these methods
-  def dummy
-    self.getPath("", parameters: nil, success: nil, failure: nil)
-    self.postPath("", parameters: nil, success: nil, failure: nil)
-    self.putPath("", parameters: nil, success: nil, failure: nil)
-    self.deletePath("", parameters: nil, success: nil, failure: nil)
-    self.patchPath("", parameters: nil, success: nil, failure: nil)
+class AFHTTPRequestOperationManager
+  include AFMotion::ClientShared
+
+  AFMotion::HTTP_METHODS.each do |method|
+    # EX client.get('my/resource.json')
+    define_method "#{method}", -> (path, parameters = {}, &callback) do
+      create_operation(method, path, parameters, &callback)
+    end
   end
 end

data/lib/afmotion/http_result.rb

@@ -1,9 +1,15 @@
 module AFMotion
   class HTTPResult
-    attr_accessor :operation, :object, :error
+    attr_accessor :operation, :object, :error, :task
 
-    def initialize(operation, responseObject, error)
-      self.operation = operation
+    def initialize(operation_or_task, responseObject, error)
+      if operation_or_task.is_a?(NSURLSessionTask) ||
+        # cluser class ugh
+        operation_or_task.class.to_s.include?("Task")
+        self.task = operation_or_task
+      else
+        self.operation = operation_or_task
+      end
       self.object = responseObject
       self.error = error
     end
@@ -17,6 +23,9 @@ module AFMotion
     end
 
     def body
+      if task && task.currentRequest
+        raise "Cannot call result.body of a task"
+      end
       if operation && operation.responseString
         operation.responseString
       end

data/lib/afmotion/operation.rb

@@ -1,83 +1,69 @@
 module AFMotion
   module Operation
-    module HTTP
-      def self.for_request(request, &callback)
-        operation = AFHTTPRequestOperation.alloc.initWithRequest(request)
-        operation.setCompletionBlockWithSuccess(
-          lambda { |operation, responseObject|
-            result = AFMotion::HTTPResult.new(operation, responseObject, nil)
-            callback.call(result)
-          },
-          failure: lambda {|operation, error|
-            result = AFMotion::HTTPResult.new(operation, nil, error)
-            callback.call(result)
-          }
-        )
-        operation
+    module_function
+    def for_request(ns_url_request, &callback)
+      operation = AFHTTPRequestOperation.alloc.initWithRequest(ns_url_request)
+      success_block = success_block_for_http_method(ns_url_request.HTTPMethod, callback)
+      operation.setCompletionBlockWithSuccess(success_block, failure: failure_block(callback))
+      operation
+    end
+
+    def success_block_for_http_method(http_method, callback)
+      if http_method.downcase.to_sym == :head
+        return lambda { |operation|
+          AFMotion::HTTPResult.new(operation, nil, nil)
+        }
       end
+
+      lambda { |operation, responseObject|
+        result = AFMotion::HTTPResult.new(operation, responseObject, nil)
+        callback.call(result)
+      }
     end
 
-    module JSON
-      def self.for_request(request, &callback)
-        operation = AFJSONRequestOperation.JSONRequestOperationWithRequest(request,
-          success: lambda { |request, response, json|
-            result = AFMotion::HTTPResult.new(operation, json, nil)
-            callback.call(result)
-          },
-          failure: lambda { |request, response, error, json|
-            result = AFMotion::HTTPResult.new(operation, json, error)
-            callback.call(result)
-          }
-        )
-      end    
+    def failure_block(callback)
+      lambda { |operation, error|
+        result = AFMotion::HTTPResult.new(operation, nil, error)
+        callback.call(result)
+      }
     end
+  end
 
-    module XML
-      def self.for_request(request, &callback)
-        operation = AFXMLRequestOperation.XMLParserRequestOperationWithRequest(request,
-          success: lambda { |request, response, document_or_parser|
-            result = AFMotion::HTTPResult.new(operation, document_or_parser, nil)
-            callback.call(result)
-          },
-          failure: lambda { |request, response, error, document_or_parser|
-            result = AFMotion::HTTPResult.new(operation, document_or_parser, error)
-            callback.call(result)
-          }
-        )
-      end    
+  module Serialization
+    def with_request_serializer(serializer_klass)
+      self.requestSerializer = serializer_klass.serializer
+      self
     end
 
-    module PLIST
-      def self.for_request(request, &callback)
-        operation = AFPropertyListRequestOperation.propertyListRequestOperationWithRequest(request,
-          success: lambda { |request, response, propertyList|
-            result = AFMotion::HTTPResult.new(operation, propertyList, nil)
-            callback.call(result)
-          },
-          failure: lambda { |request, response, error, propertyList|
-            result = AFMotion::HTTPResult.new(operation, propertyList, error)
-            callback.call(result)
-          }
-        )
-      end    
+    def with_response_serializer(serializer_klass)
+      self.responseSerializer = serializer_klass.serializer
+      self
     end
 
-    module Image
-      def self.for_request(request, &callback)
-        operation = AFImageRequestOperation.imageRequestOperationWithRequest(request,
-          imageProcessingBlock: lambda {|ui_image|
-            return ui_image
-          },
-          success: lambda { |request, response, ui_image|
-            result = AFMotion::HTTPResult.new(operation, ui_image, nil)
-            callback.call(result)
-          },
-          failure: lambda { |request, response, error|
-            result = AFMotion::HTTPResult.new(operation, nil, error)
-            callback.call(result)
-          }
-        )
-      end
+    def json!
+      with_request_serializer(AFJSONRequestSerializer).
+        with_response_serializer(AFJSONResponseSerializer)
+    end
+
+    def xml!
+        with_response_serializer(AFXMLParserResponseSerializer)
+    end
+
+    def plist!
+      with_request_serializer(AFPropertyListRequestSerializer).
+        with_response_serializer(AFPropertyListResponseSerializer)
+    end
+
+    def image!
+      with_response_serializer(AFImageResponseSerializer)
     end
   end
+end
+
+class AFHTTPRequestOperation
+  include AFMotion::Serialization
+end
+
+class AFHTTPRequestOperationManager
+  include AFMotion::Serialization
 end

data/lib/afmotion/serializer.rb

@@ -0,0 +1,41 @@
+class AFHTTPRequestSerializer
+  class HeaderWrapper
+    def initialize(serializer)
+      @serializer = WeakRef.new(serializer)
+    end
+
+    def [](header)
+      @serializer.HTTPRequestHeaders[header]
+    end
+
+    def []=(header, value)
+      @serializer.setValue(value, forHTTPHeaderField: header)
+    end
+
+    def delete(header)
+      value = self[header]
+      self[header] = nil
+      value
+    end
+  end
+
+  def headers
+    @header_wrapper ||= HeaderWrapper.new(self)
+  end
+
+  # options can be
+  # - {username: ___, password: ____}
+  # or
+  # - {token: ___ }
+  def authorization=(options = {})
+    if options.nil?
+      clearAuthorizationHeader
+    elsif options[:username] && options[:password]
+      setAuthorizationHeaderFieldWithUsername(options[:username], password: options[:password])
+    elsif options[:token]
+      setAuthorizationHeaderFieldWithToken(options[:token])
+    else
+      raise "Not a valid authorization hash: #{options.inspect}"
+    end
+  end
+end

data/lib/afmotion/session_client.rb

@@ -0,0 +1,128 @@
+motion_require 'http_client'
+motion_require 'version'
+
+=begin
+  AFMotion::SessionClient.build("http://google.com") do |client|
+    client.session_configuration :default # :ephemeral
+    client.session_configuration :background, "com.usepropeller.afmotion"
+    client.session_configuration my_session_configuration
+
+    response_serializer
+
+    request_serializer
+  end
+=end
+module AFMotion
+  class SessionClient
+    class << self
+
+      attr_accessor :shared
+
+      # Returns an instance of AFHTTPRequestOperationManager
+      def build(base_url, &block)
+        dsl = AFMotion::SessionClientDSL.new(base_url)
+        case block.arity
+        when 0
+          dsl.instance_eval(&block)
+        when 1
+          block.call(dsl)
+        end
+
+        dsl.to_session_manager
+      end
+
+      # Sets AFMotion::Client.shared as the built client
+      def build_shared(base_url, &block)
+        self.shared = self.build(base_url, &block)
+      end
+    end
+  end
+end
+
+module AFMotion
+  class SessionClientDSL < ClientDSL
+    class Config
+      attr_accessor :responseSerializer, :operationQueue, :requestSerializer, :sessionConfiguration
+
+      class MockRequestSerializer
+        attr_accessor :authorization
+      end
+
+      def requestSerializer
+        @requestSerializer ||= MockRequestSerializer.new
+      end
+
+      def requestSerializer=(requestSerializer)
+        if @requestSerializer && @requestSerializer.is_a?(MockRequestSerializer)
+          requestSerializer.authorization = @requestSerializer.authorization
+        end
+        @requestSerializer = requestSerializer
+      end
+
+      def headers
+        @headers ||= {}
+      end
+    end
+
+    attr_accessor :operation_manager
+    alias_method :config, :operation_manager
+
+    def initialize(base_url)
+      @base_url = base_url
+      @operation_manager = Config.new
+    end
+
+    def to_session_manager
+      session_manager = AFHTTPSessionManager.alloc.initWithBaseURL(@base_url.to_url,
+          sessionConfiguration: config.sessionConfiguration)
+      session_manager.responseSerializer = config.responseSerializer if config.responseSerializer
+      if !config.requestSerializer.is_a?(Config::MockRequestSerializer)
+        session_manager.requestSerializer = config.requestSerializer
+      elsif config.requestSerializer.authorization
+        session_manager.requestSerializer.authorization = config.requestSerializer.authorization
+      end
+      config.headers.each do |key, value|
+        session_manager.requestSerializer.headers[key] = value
+      end
+      session_manager.operationQueue = config.operationQueue if config.operationQueue
+      session_manager
+    end
+
+    SESSION_CONFIGURATION_SHORTHAND = {
+      default: :defaultSessionConfiguration,
+      ephemeral: :ephemeralSessionConfiguration,
+      background: "backgroundSessionConfiguration:".to_sym
+    }
+
+    def session_configuration(session_configuration, identifier = nil)
+      if session_configuration.is_a?(Symbol) || session_configuration.is_a?(String)
+        method_signature = SESSION_CONFIGURATION_SHORTHAND[session_configuration.to_sym]
+        ns_url_session_configuration = begin
+          if identifier
+            NSURLSessionConfiguration.send(method_signature, identifier)
+          else
+            NSURLSessionConfiguration.send(method_signature)
+          end
+        end
+        self.config.sessionConfiguration = ns_url_session_configuration
+      elsif session_configuration.is_a?(NSURLSessionConfiguration) ||
+          # cluster class smh
+          session_configuration.class.to_s.include?("URLSessionConfiguration")
+        self.config.sessionConfiguration = session_configuration
+      else
+        raise "Invalid type for session_configuration; need Symbol, String, or NSURLSessionConfiguration, but got #{session_configuration.class}"
+      end
+    end
+  end
+end
+
+class AFHTTPSessionManager
+  include AFMotion::ClientShared
+
+  AFMotion::HTTP_METHODS.each do |method|
+    # EX client.get('my/resource.json')
+    define_method "#{method}", -> (path, parameters = {}, &callback) do
+      create_task(method, path, parameters, &callback)
+    end
+  end
+end

data/lib/afmotion/version.rb

@@ -1,5 +1,5 @@
 module AFMotion
-  VERSION = "0.9.0"
+  VERSION = "2.0.0.rc1"
 
   HTTP_METHODS = [:get, :post, :put, :delete, :patch, :head]
 end

data/lib/afmotion.rb

@@ -1,15 +1,21 @@
 require "afmotion/version"
 require 'motion-cocoapods'
+require 'motion-require'
 
 unless defined?(Motion::Project::Config)
   raise "This file must be required within a RubyMotion project Rakefile."
 end
 
+Motion::Require.all(Dir.glob(File.join(File.dirname(__FILE__), 'afmotion/**/*.rb')))
+
 Motion::Project::App.setup do |app|
   Dir.glob(File.join(File.dirname(__FILE__), 'afmotion/**/*.rb')).each do |file|
-    app.files.unshift(file)
     if app.respond_to?("exclude_from_detect_dependencies")
       app.exclude_from_detect_dependencies << file
     end
   end
+
+  app.pods do
+    pod 'AFNetworking', '~> 2.0.0'
+  end
 end