afmotion 2.6 → 3.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZGU4YjcxZDY0YTVlMmM2OTIxNzYyZDhmMDBiOGQwYjhkMzkzNDJkYg==
-  data.tar.gz: !binary |-
-    NDFlOWRlZmFlOTkzNTgyMTQyMGUxMzlkYWI1MDcwNDQxYjA4NWMxNg==
+SHA256:
+  metadata.gz: b0972df3e642f569351b4c4f0897ca9969188a776751add18a3a58e0b9df0fbb
+  data.tar.gz: 7d6968c3d2cadd9b9b9a8185e912307bf43c2f7ed1fd26a49b0437eececa1bf3
 SHA512:
-  metadata.gz: !binary |-
-    MWRhOGVkYzNiYTE3MDRlNmExYzQ5YTQ3N2MyYjU4ZmYxNTRlMDA5OTNiMjAx
-    ZDI2MjMwNTVjNzA5MWM4Y2E5NmE3NTBhNWQyNWIwNTA1NGQ5NDBlNmYxNDE1
-    Njk2MzJhMjk3YWNkMjY4OWUwYzgwYWU0Yjc3NmIzMTk3MmU4YTQ=
-  data.tar.gz: !binary |-
-    ZWFlYjBiNjhiZDU3NmFhNTE4ZWNiNzU2OTk3YzY5N2M3MWY2NGUxZmVkMzQ3
-    NTZiZWU2Yzg1NzIwNTRjNjlkYzdmMDJmYTIyNTk4ZGY0YTI3ZmVlODYxMzFm
-    NWFmZmEzM2IwN2UwM2Y5M2M5YmQwNzcxM2UwZWZhMTM1ZTRkMGU=
+  metadata.gz: fff5abc13b536be3b7318989271362532ebecfb9a50c7bbbfc52379eed79c575c0574f8794a1dfa13b1343fb7b0afec3d586a2481ac7a9787c3d387c05c523c1
+  data.tar.gz: ea3ae7b135bd574f31b0dd16ba990cc672c83823f56d6a1defe1fecdd0cbece06c066460347da7027ef7ad0b193b5ec191aa58f8582c18946dc6cb34e5740583

data/.gitignore

@@ -14,4 +14,5 @@ nbproject
 *~
 *.sw[po]
 .eprj
-pkg/*
+pkg/*
+Gemfile.lock

data/AFMotion.gemspec

@@ -15,8 +15,8 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]
 
-  s.add_dependency "motion-cocoapods", ">= 1.4.1"
+  s.add_dependency "motion-cocoapods", ">= 1.9.1"
   s.add_dependency "motion-require", ">= 0.1"
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'webstub', "~> 1.1"
+  s.add_development_dependency 'webstub', "~> 1.1.6"
 end

data/README.md

@@ -1,8 +1,8 @@
 # AFMotion
 
-[![Build Status](https://travis-ci.org/clayallsopp/afmotion.png?branch=master)](https://travis-ci.org/clayallsopp/afmotion)
+[![Build Status](https://travis-ci.org/clayallsopp/afmotion.png?branch=master)](https://travis-ci.org/clayallsopp/afmotion) [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fclayallsopp%2Fafmotion.svg?size=small)](https://app.fossa.io/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fclayallsopp%2Fafmotion?ref=badge_small)
 
-AFMotion is a thin RubyMotion wrapper for [AFNetworking](https://github.com/AFNetworking/AFNetworking), the absolute best networking library on iOS.
+AFMotion is a thin RubyMotion wrapper for [AFNetworking](https://github.com/AFNetworking/AFNetworking), the absolute best networking library on iOS and OS X.
 
 ## Usage
 
@@ -33,32 +33,45 @@ end
 end
 ```
 
-You can either use `AFMotion::Client` or `AFMotion::SessionClient` to group similar requests. They have identical APIs, except for their creation and that their request `result` objects contain either `result.operation` (for `::Client`) or `result.task` (for `::SessionClient`).
+#### Migration from AFMotion 2.x
 
-#### AFMotion::Client
+_Breaking Change_
+Parameters must now be specified with the `params:` keyword arg.
 
-If you're interacting with a web service, you can use [`AFHTTPRequestOperationManager`](http://cocoadocs.org/docsets/AFNetworking/2.0.0/Classes/AFHTTPRequestOperationManager.html) with this nice wrapper:
+AFMotion 2.x
 
 ```ruby
-# DSL Mapping to properties of AFHTTPRequestOperationManager
+AFMotion::HTTP.get("http://google.com", q: "rubymotion") do |result|
+  # sends request to http://google.com?q=rubymotion
+end
+```
 
-@client = AFMotion::Client.build("https://alpha-api.app.net/") do
-  header "Accept", "application/json"
+AFMotion 3.x
 
-  response_serializer :json
+```ruby
+AFMotion::HTTP.get("http://google.com", params: { q: "rubymotion" }) do |result|
+  # sends request to http://google.com?q=rubymotion
 end
 ```
 
-#### AFMotion::SessionClient
-
-If you're using iOS7, you can use [`AFHTTPSessionManager`](http://cocoadocs.org/docsets/AFNetworking/2.0.0/Classes/AFHTTPSessionManager.html):
+This allows you to also pass in a progress_block or additional headers on the fly:
 
 ```ruby
-# DSL Mapping to properties of AFHTTPSessionManager
+AFMotion::HTTP.get("http://url.com/large_file.mov", params: { quality: "high" }, progress_block: proc { |progress| update_progress(progress) }, headers: {}) do |result|
+  # sends request to http://google.com?q=rubymotion
+end
+```
 
-@client = AFMotion::SessionClient.build("https://alpha-api.app.net/") do
-  session_configuration :default
+For grouping similar requests (AFHTTPSession), use `AFMotion::Client` (now exactly the same as `AFMotion::SessionClient`)
 
+#### AFMotion::Client
+
+If you're interacting with a web service, you can use [`AFHTTPRequestOperationManager`](http://cocoadocs.org/docsets/AFNetworking/2.0.0/Classes/AFHTTPRequestOperationManager.html) with this nice wrapper:
+
+```ruby
+# DSL Mapping to properties of AFHTTPRequestOperationManager
+
+@client = AFMotion::Client.build("https://alpha-api.app.net/") do
   header "Accept", "application/json"
 
   response_serializer :json
@@ -103,8 +116,7 @@ Each AFMotion wrapper callback yields an `AFMotion::HTTPResult` object. This obj
 
 ```ruby
 AFMotion::some_function do |result|
-  # result.operation is the AFURLConnectionOperation instance
-  p result.operation.inspect
+  p result.task.inspect
   p result.status_code
 
   if result.success?
@@ -135,7 +147,7 @@ end
 Example:
 
 ```ruby
-AFMotion::HTTP.get("http://google.com", q: "rubymotion") do |result|
+AFMotion::HTTP.get("http://google.com", params: { q: "rubymotion" }) do |result|
   # sends request to http://google.com?q=rubymotion
 end
 ```
@@ -148,7 +160,7 @@ end
 
 ### HTTP Client
 
-If you're constantly accesing a web service, it's a good idea to use an `AFHTTPRequestOperationManager`. Things lets you add a common base URL and request headers to all the requests issued through it, like so:
+If you're constantly accesing a web service, it's a good idea to use an `AFHTTPSessionManager`. Things lets you add a common base URL and request headers to all the requests issued through it, like so:
 
 ```ruby
 client = AFMotion::Client.build("https://alpha-api.app.net/") do
@@ -163,42 +175,23 @@ client.get("stream/0/posts/stream/global") do |result|
 end
 ```
 
-If you're using iOS7, you can use [`AFHTTPSessionManager`](http://cocoadocs.org/docsets/AFNetworking/2.0.0/Classes/AFHTTPSessionManager.html):
-
-```ruby
-# DSL Mapping to properties of AFHTTPSessionManager
-
-client = AFMotion::SessionClient.build("https://alpha-api.app.net/") do
-  session_configuration :default
-
-  header "Accept", "application/json"
-
-  response_serializer :json
-end
-
-client.get("stream/0/posts/stream/global") do |result|
-  # result.task exists
-  ...
-end
-```
-
 If you're constantly used one web service, you can use the `AFMotion::Client.shared` variable have a common reference. It can be set like a normal variable or created with `AFMotion::Client.build_shared`.
 
 `AFHTTPRequestOperationManager` & `AFHTTPSessionManager` support methods of the form `Client#get/post/put/patch/delete(url, request_parameters)`. The `request_parameters` is a hash containing your parameters to attach as the request body or URL parameters, depending on request type. For example:
 
 ```ruby
-client.get("users", id: 1) do |result|
+client.get("users", params: { id: 1 }) do |result|
   ...
 end
 
-client.post("users", name: "@clayallsopp", library: "AFMotion") do |result|
+client.post("users", params: { name: "@clayallsopp", library: "AFMotion" }) do |result|
   ...
 end
 ```
 
 #### Multipart Requests
 
-`AFHTTPRequestOperationManager` & `AFHTTPSessionManager` support multipart form requests (i.e. for image uploading) - simply use `multipart_post` and it'll convert your parameters into properly encoded multipart data. For all other types of request data, use the `form_data` object passed to your callback:
+`AFHTTPSessionManager` support multipart form requests (i.e. for image uploading) - simply use `multipart_post` and it'll convert your parameters into properly encoded multipart data. For all other types of request data, use the `form_data` object passed to your callback:
 
 ```ruby
 # an instance of UIImage
@@ -220,17 +213,14 @@ end
 
 This is an instance of [`AFMultipartFormData`](http://cocoadocs.org/docsets/AFNetworking/2.0.0/Protocols/AFMultipartFormData.html).
 
-If you want to track upload progress, you can add a third callback argument which returns the upload percentage between 0.0 and 1.0:
+If you want to track upload progress, simply add a progress_block (Taking a single arg: `NSProgress`)
 
 ```ruby
-client.multipart_post("avatars") do |result, form_data, progress|
+client.multipart_post("avatars", progress_block: proc { |progress| update_progress(progress) }) do |result, form_data|
   if form_data
     # Called before request runs
     # see: https://github.com/AFNetworking/AFNetworking/wiki/AFNetworking-FAQ
     form_data.appendPartWithFileData(data, name: "avatar", fileName:"avatar.png", mimeType: "image/png")
-  elsif progress
-    # 0.0 < progress < 1.0
-    my_widget.update_progress(progress)
   else
   ...
 end
@@ -273,3 +263,7 @@ client = AFMotion::SessionClient.build("https://alpha-api.app.net/") do |client|
   client.header "Accept", @custom_header
 end
 ```
+
+## License
+
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fclayallsopp%2Fafmotion.svg?size=large)](https://app.fossa.io/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fclayallsopp%2Fafmotion?ref=badge_large)

data/Rakefile

@@ -1,7 +1,8 @@
 # -*- coding: utf-8 -*-
 $:.unshift("/Library/RubyMotion/lib")
+$:.unshift("~/.rubymotion/rubymotion-templates") # Add this line
+require 'motion/project/template/gem/gem_tasks'
 require 'motion/project/template/ios'
-require "bundler/gem_tasks"
 require "bundler/setup"
 Bundler.require :default
 
@@ -13,5 +14,5 @@ require 'webstub'
 Motion::Project::App.setup do |app|
   # Use `rake config' to see complete project settings.
   app.name = 'AFMotion'
-  app.deployment_target = "7.1"
+  app.deployment_target = "10.0"
 end

data/lib/afmotion.rb

@@ -16,6 +16,6 @@ Motion::Project::App.setup do |app|
   end
 
   app.pods do
-    pod 'AFNetworking', '~> 2.5.0'
+    pod 'AFNetworking', '~> 4.0.0'
   end
 end

data/lib/afmotion/client_shared.rb

@@ -1,31 +1,4 @@
 module AFMotion
-  # ported from https://github.com/AFNetworking/AFNetworking/blob/master/UIKit%2BAFNetworking/UIProgressView%2BAFNetworking.m
-  class SessionObserver
-
-    def initialize(task, callback)
-      @callback = callback
-      task.addObserver(self, forKeyPath:"state", options:0, context:nil)
-      task.addObserver(self, forKeyPath:"countOfBytesSent", options:0, context:nil)
-    end
-
-    def observeValueForKeyPath(keyPath, ofObject: object, change: change, context: context)
-      if keyPath == "countOfBytesSent"
-        # Could be -1, see https://github.com/AFNetworking/AFNetworking/issues/1354
-        expectation = (object.countOfBytesExpectedToSend > 0) ? object.countOfBytesExpectedToSend.to_f : nil
-        @callback.call(nil, object.countOfBytesSent.to_f, expectation)
-      end
-
-      if keyPath == "state" && object.state == NSURLSessionTaskStateCompleted
-        begin
-          object.removeObserver(self, forKeyPath: "state")
-          object.removeObserver(self, forKeyPath: "countOfBytesSent")
-          @callback = nil
-        rescue
-        end
-      end
-    end
-  end
-
   module ClientShared
     def headers
       requestSerializer.headers
@@ -39,29 +12,25 @@ module AFMotion
       requestSerializer.authorization = authorization
     end
 
-    def multipart_post(path, parameters = {}, &callback)
-      create_multipart_operation(:post, path, parameters, &callback)
+    def multipart_post(path, options = {}, &callback)
+      create_multipart_task(:post, path, options, &callback)
     end
 
-    def multipart_put(path, parameters = {}, &callback)
-      create_multipart_operation(:put, path, parameters, &callback)
+    def multipart_put(path, options = {}, &callback)
+      create_multipart_task(:put, path, options, &callback)
     end
 
-    def create_multipart_operation(http_method, path, parameters = {}, &callback)
-      inner_callback = Proc.new do |result, form_data,  bytes_written_now,  total_bytes_written, total_bytes_expect|
+    def create_multipart_task(http_method, path, options = {}, &callback)
+      parameters = options[:params]
+      headers = options.fetch(:headers, {})
+      progress = options[:progress_block]
+
+      inner_callback = Proc.new do |result, form_data|
         case callback.arity
         when 1
           callback.call(result)
         when 2
           callback.call(result, form_data)
-        when 3
-          progress = nil
-          if total_bytes_written && total_bytes_expect
-            progress = total_bytes_written.to_f / total_bytes_expect.to_f
-          end
-          callback.call(result, form_data, progress)
-        when 5
-          callback.call(result, form_data, bytes_written_now, total_bytes_written, total_bytes_expect)
         end
       end
 
@@ -72,62 +41,77 @@ module AFMotion
         }
       end
 
-      upload_callback = nil
-      if callback.arity > 2
-        upload_callback = lambda { |bytes_written_now, total_bytes_written, total_bytes_expect|
-          inner_callback.call(nil, nil, bytes_written_now, total_bytes_written, total_bytes_expect)
-        }
-      end
-
       http_method = http_method.to_s.upcase
       if http_method == "POST"
-        operation_or_task = self.POST(path,
+        task = self.POST(path,
           parameters: parameters,
+          headers: headers,
           constructingBodyWithBlock: multipart_callback,
-          success: AFMotion::Operation.success_block_for_http_method(:post, inner_callback),
-          failure: AFMotion::Operation.failure_block(inner_callback))
+          progress: progress,
+          success: success_block_for_http_method(:post, inner_callback),
+          failure: failure_block(inner_callback))
       else
-        operation_or_task = self.PUT(path,
+        task = self.PUT(path,
           parameters: parameters,
+          headers: headers,
           constructingBodyWithBlock: multipart_callback,
-          success: AFMotion::Operation.success_block_for_http_method(:post, inner_callback),
-          failure: AFMotion::Operation.failure_block(inner_callback))
+          progress: progress,
+          success: success_block_for_http_method(:post, inner_callback),
+          failure: failure_block(inner_callback))
       end
-      if upload_callback
-        if operation_or_task.is_a?(AFURLConnectionOperation)
-          operation_or_task.setUploadProgressBlock(upload_callback)
-        else
-          # using NSURLSession - messy, probably leaks
-          @observer = SessionObserver.new(operation_or_task, upload_callback)
-        end
+      task
+    end
+
+    def create_task(http_method, path, options = {}, &callback)
+      parameters = options.fetch(:params, {})
+      headers = options.fetch(:headers, {})
+      progress = options[:progress_block]
+
+      method_signature = "#{http_method.to_s.upcase}:parameters:headers:progress:success:failure"
+      success = success_block_for_http_method(http_method, callback)
+      failure = failure_block(callback)
+      method_and_args = [method_signature, path, parameters, headers, progress, success, failure]
+
+      # HEAD doesn't take a progress arg
+      if http_method.to_s.upcase == "HEAD"
+        method_signature.gsub!("progress:", "")
+        method_and_args.delete_at(4)
       end
-      operation_or_task
+
+      self.public_send(*method_and_args)
     end
 
-    def create_operation(http_method, path, parameters = {}, &callback)
-      method_signature = "#{http_method.upcase}:parameters:success:failure:"
-      method = self.method(method_signature)
-      success_block = AFMotion::Operation.success_block_for_http_method(http_method, callback)
-      failure_block = AFMotion::Operation.failure_block(callback)
-      operation = method.call(path, parameters, success_block, failure_block)
-      if parameters && parameters[:progress_block] && operation.respond_to?(:setDownloadProgressBlock)
-        operation.setDownloadProgressBlock(parameters.delete(:progress_block))
+    def success_block_for_http_method(http_method, callback)
+      if http_method.downcase.to_sym == :head
+        return ->(task) {
+          result = AFMotion::HTTPResult.new(task, nil, nil)
+          callback.call(result)
+        }
       end
-      operation
+
+      ->(task, responseObject) {
+        result = AFMotion::HTTPResult.new(task, responseObject, nil)
+        callback.call(result)
+      }
     end
 
-    alias_method :create_task, :create_operation
+    def failure_block(callback)
+      ->(task, error) {
+        result = AFMotion::HTTPResult.new(task, nil, error)
+        callback.call(result)
+      }
+    end
 
     private
     # To force RubyMotion pre-compilation of these methods
     def dummy
-      self.GET("", parameters: nil, success: nil, failure: nil)
-      self.HEAD("", parameters: nil, success: nil, failure: nil)
-      self.POST("", parameters: nil, success: nil, failure: nil)
-      self.POST("", parameters: nil, constructingBodyWithBlock: nil, success: nil, failure: nil)
-      self.PUT("", parameters: nil, success: nil, failure: nil)
-      self.DELETE("", parameters: nil, success: nil, failure: nil)
-      self.PATCH("", parameters: nil, success: nil, failure: nil)
+      self.GET("", parameters: nil, headers: nil, progress: nil, success: nil, failure: nil)
+      self.HEAD("", parameters: nil, headers: nil, success: nil, failure: nil)
+      self.POST("", parameters: nil, headers: nil, progress: nil, success: nil, failure: nil)
+      self.POST("", parameters: nil, headers: nil, constructingBodyWithBlock: nil, progress: nil, success: nil, failure: nil)
+      self.PUT("", parameters: nil, headers: nil, progress: nil, success: nil, failure: nil)
+      self.DELETE("", parameters: nil, headers: nil, progress: nil, success: nil, failure: nil)
+      self.PATCH("", parameters: nil, headers: nil, progress: nil, success: nil, failure: nil)
     end
   end
 end

data/lib/afmotion/ext/AFHTTPSessionManager.rb

@@ -0,0 +1,73 @@
+motion_require '../client_shared'
+
+module AFMotion
+  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 AFHTTPSessionManager
+  include AFMotion::Serialization
+  include AFMotion::ClientShared
+  
+  AFMotion::HTTP_METHODS.each do |method|
+    # EX client.get('my/resource.json')
+    define_method "#{method}", -> (path, options = {}, &callback) do
+      create_task(method, path, options, &callback)
+    end
+  end
+
+  # options = {parameters: , constructingBodyWithBlock: , success:, failure:}
+  def PUT(url_string, options = {})
+    parameters = options[:parameters]
+    block = options[:constructingBodyWithBlock]
+    progress = options[:progress_block]
+    success = options[:success]
+    failure = options[:failure]
+  
+    request = self.requestSerializer.multipartFormRequestWithMethod("PUT", URLString: NSURL.URLWithString(url_string, relativeToURL: self.baseURL).absoluteString, parameters:parameters, constructingBodyWithBlock:block, error:nil)
+  
+    task = self.dataTaskWithRequest(request, uploadProgress: progress, downloadProgress: nil, completionHandler: ->(response, responseObject, error) {
+      if error && failure
+      failure.call(task, error)
+      elsif success
+      success.call(task, responseObject)
+      end
+    })
+  
+    task.resume
+  
+    task
+  end
+end