afmotion 2.6 → 3.0

data/lib/afmotion/http.rb

@@ -2,9 +2,9 @@ motion_require 'version'
 
 module AFMotion
   class HTTP
-    def self.operation_manager
-      @operation_manager ||= begin
-        manager = AFHTTPRequestOperationManager.manager
+    def self.manager
+      @manager ||= begin
+        manager = AFHTTPSessionManager.manager
         configure_manager(manager)
         manager
       end
@@ -35,20 +35,35 @@ module AFMotion
   end
 
   class Image < HTTP
-    def self.configure_manager(operation)
-      operation.image!
+    def self.configure_manager(manager)
+      manager.image!
     end
   end
 
   [HTTP, JSON, XML, PLIST, Image].each do |base|
     AFMotion::HTTP_METHODS.each do |method_name|
-      method_signature = "#{method_name.to_s.upcase}:parameters:success:failure:"
-      base.define_singleton_method(method_name, -> (url, parameters = nil, &callback) do
-        manager = base.operation_manager
-        manager.send(method_signature, url,
+      http_method = method_name.to_s.upcase
+
+      method_signature = "#{http_method}:parameters:headers:progress:success:failure:"
+      method_signature.gsub!("progress:", "") if http_method == "HEAD"
+
+      base.define_singleton_method(method_name, -> (url, options = {}, &callback) do
+        parameters = options.fetch(:params, {})
+        headers = options[:headers]
+        progress = options[:progress_block]
+
+        args = [ method_signature,
+          url,
           parameters,
-          AFMotion::Operation.success_block_for_http_method(method_name, callback),
-          AFMotion::Operation.failure_block(callback))
+          headers,
+          progress,
+          manager.success_block_for_http_method(method_name, callback),
+          manager.failure_block(callback)
+        ]
+
+        args.delete_at(4) if http_method == "HEAD" # HEAD doesn't take a progress arg
+
+        base.manager.send(*args)
       end)
     end
   end

data/lib/afmotion/http_result.rb

@@ -1,15 +1,9 @@
 module AFMotion
   class HTTPResult
-    attr_accessor :operation, :object, :error, :task
+    attr_accessor :object, :error, :task
 
-    def initialize(operation_or_task, responseObject, error)
-      if defined?(NSURLSessionTask) && 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
+    def initialize(task, responseObject, error)
+      self.task = task
       self.object = responseObject
       self.error = error
     end
@@ -21,11 +15,15 @@ module AFMotion
     def failure?
       !!error
     end
+    
+    # include this for backwards compatibility (?)
+    def operation
+      puts "HTTPResult#operation is deprecated and returns a task, switch to using #task"
+      task
+    end
 
     def status_code
-      if self.operation && self.operation.response
-        self.operation.response.statusCode
-      elsif self.task
+      if self.task && self.task.response
         self.task.response.statusCode
       else
         nil
@@ -33,12 +31,7 @@ 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
+      self.object
     end
   end
 end

data/lib/afmotion/operation.rb

@@ -1,17 +1,12 @@
 module AFMotion
   module 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_or_task|
-          AFMotion::HTTPResult.new(operation_or_task, nil, nil)
+          result = AFMotion::HTTPResult.new(operation_or_task, nil, nil)
+          callback.call(result)
         }
       end
 
@@ -23,53 +18,9 @@ module AFMotion
 
     def failure_block(callback)
       lambda { |operation_or_task, error|
-        response_object = operation_or_task.is_a?(AFHTTPRequestOperation) ? operation_or_task.responseObject : nil
-        result = AFMotion::HTTPResult.new(operation_or_task, response_object, error)
+        result = AFMotion::HTTPResult.new(operation_or_task, nil, error)
         callback.call(result)
       }
     end
   end
-
-  module Serialization
-    def with_request_serializer(serializer_klass)
-      self.requestSerializer = serializer_klass.serializer
-      self
-    end
-
-    def with_response_serializer(serializer_klass)
-      self.responseSerializer = serializer_klass.serializer
-      self
-    end
-
-    def http!
-      with_request_serializer(AFHTTPRequestSerializer).
-        with_response_serializer(AFHTTPResponseSerializer)
-    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

@@ -32,8 +32,6 @@ class AFHTTPRequestSerializer
       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

data/lib/afmotion/session_client.rb

@@ -1,5 +1,7 @@
-motion_require 'http_client'
 motion_require 'version'
+motion_require 'client_shared'
+motion_require 'session_client_dsl'
+motion_require 'ext/AFHTTPSessionManager'
 
 =begin
   AFMotion::SessionClient.build("http://google.com") do |client|
@@ -21,13 +23,16 @@ module AFMotion
       # 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)
+        
+        if block_given?
+          case block.arity
+          when 0
+            dsl.instance_eval(&block)
+          when 1
+            block.call(dsl)
+          end  
         end
-
+        
         dsl.to_session_manager
       end
 
@@ -37,114 +42,8 @@ module AFMotion
       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: (UIDevice.currentDevice.systemVersion.to_f >= 8.0 ? "backgroundSessionConfigurationWithIdentifier:" : "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
-
-  # options = {parameters: , constructingBodyWithBlock: , success:, failure:}
-  def PUT(url_string, options = {})
-    parameters = options[:parameters]
-    block = options[:constructingBodyWithBlock]
-    success = options[:success]
-    failure = options[:failure]
-
-    request = self.requestSerializer.multipartFormRequestWithMethod("PUT", URLString: NSURL.URLWithString(url_string, relativeToURL: self.baseURL).absoluteString, parameters:parameters, constructingBodyWithBlock:block)
-
-    task = self.dataTaskWithRequest(request, completionHandler: ->(response, responseObject, error) {
-      if error && failure
-        failure.call(task, error)
-      elsif success
-        success.call(task, responseObject)
-      end
-    })
-
-    task.resume
-
-    task
+  
+  # These are now the same thing
+  class Client < SessionClient
   end
 end

data/lib/afmotion/session_client_dsl.rb

@@ -0,0 +1,143 @@
+module AFMotion
+  class SessionClientDSL
+  class Config
+    attr_accessor :responseSerializer, :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 :config
+
+  def initialize(base_url)
+    @base_url = base_url
+    @config = 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
+  end
+
+  SESSION_CONFIGURATION_SHORTHAND = {
+    default: :defaultSessionConfiguration,
+    ephemeral: :ephemeralSessionConfiguration,
+    background: (Object.const_defined?("UIDevice") && UIDevice.currentDevice.systemVersion.to_f >= 8.0 ? "backgroundSessionConfigurationWithIdentifier:" : "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
+  
+  def header(header, value)
+    @headers ||= {}
+    @headers[header] = value
+    apply_header(header, value)
+  end
+
+  def authorization(options = {})
+    @authorization = options
+    apply_authorization(options)
+  end
+
+  OPERATION_TO_REQUEST_SERIALIZER = {
+    json: AFJSONRequestSerializer,
+    plist: AFPropertyListRequestSerializer
+  }
+  def request_serializer(serializer)
+    if serializer.is_a?(Symbol) || serializer.is_a?(String)
+    config.requestSerializer = OPERATION_TO_REQUEST_SERIALIZER[serializer.to_sym].serializer
+    elsif serializer.is_a?(Class)
+    config.requestSerializer = serializer.serializer
+    else
+    config.requestSerializer = serializer
+    end
+    reapply_options
+  end
+
+  OPERATION_TO_RESPONSE_SERIALIZER = {
+    json: AFJSONResponseSerializer,
+    xml: AFXMLParserResponseSerializer,
+    plist: AFPropertyListResponseSerializer,
+    image: AFImageResponseSerializer,
+    http: AFHTTPResponseSerializer,
+    form: AFHTTPResponseSerializer
+  }
+  def response_serializer(serializer)
+    write_json_options = true
+    if serializer.is_a?(Symbol) || serializer.is_a?(String)
+    config.responseSerializer = OPERATION_TO_RESPONSE_SERIALIZER[serializer.to_sym].serializer
+    elsif serializer.is_a?(Class)
+    config.responseSerializer = serializer.serializer
+    else
+    config.responseSerializer = serializer
+    write_json_options = false
+    end
+    af_serializer = config.responseSerializer
+    if af_serializer.is_a?(AFJSONResponseSerializer) && write_json_options
+    af_serializer.readingOptions = NSJSONReadingMutableContainers
+    end
+    af_serializer
+  end
+
+  private
+
+  def reapply_options
+    @headers.each{ |h,v| apply_header(h, v) } unless @headers.nil?
+    apply_authorization(@authorization) unless @authorization.nil?
+  end
+
+  def apply_header(header, value)
+    config.headers[header] = value
+  end
+
+  def apply_authorization(options)
+    config.requestSerializer.authorization = options
+  end
+  
+  end
+end