motion-http 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 295321b18316c5b3a47c29692b4831e25ed4b1c7
-  data.tar.gz: afcdbfc33304f05cf290fcdd33e339ad693fcb74
+SHA256:
+  metadata.gz: a32a0271f1f711f5a11522c48894a06ea9e8924615d38bae2a235572f15d2135
+  data.tar.gz: 590d6d30eb2889d97f47ed0e072313eb93dd38eb3e6485f0f894e526869f6a79
 SHA512:
-  metadata.gz: '095e68b01bca380833a6e93c2e25e5e6abd389727b6ff92aa1b39c9fef79132bec440ea2b280b4e0e5436535534dc158e234d1ed54bc9c99cc518a246fa5cf77'
-  data.tar.gz: 0667af5350564fb4f4199437a3ae827435f5ce942842ca333adba98ed46efaa7a8c4ff1dce85dc67c17b9fa382abdf28b7ba5645fa0e6064581cf405e9e3e5ed
+  metadata.gz: a01adbafd00b594929e7b7f86de05e55ff60e1040db5e736247dcb5dca8f01d21804c54ae5ecca7f365a6181dfb030794acfb667a93694bf0a0da0cd4a17f0d4
+  data.tar.gz: 684d0b718b0d84c7e4222cc16c97f39b4bf875e43b752c7d3f72d9e6540b9cc2e938a690a4542678eb5bff4d89f6409197750a4c608df0a48c9e7a327794901f

data/README.md

@@ -1,14 +1,12 @@
 # motion-http
 
-Motion::HTTP is a cross-platform HTTP Client for RubyMotion that's quick and easy to use.
+A cross-platform HTTP Client for RubyMotion that's quick and easy to use.
 
 Supported platforms:
 - iOS, macOS, tvOS, watchOS
 - Android
 
-This gem depends on two really popular networking libraries:
-- [AFNetworking](https://github.com/AFNetworking/AFNetworking) (for Cocoa platforms)
-- [OkHttp](http://square.github.io/okhttp/) (for Android)
+On Android, this gem depends on the super popular [OkHttp](http://square.github.io/okhttp/) networking library.
 
 Please note that this library is still a work in progress. Please report bugs and suggestions for improvement!
 
@@ -21,7 +19,6 @@ Add this line to your application's Gemfile:
 And then execute:
 
     $ bundle
-    $ rake pod:install # for iOS apps
     $ rake gradle:install # for Android apps
 
 ### iOS Specific Configuration
@@ -32,22 +29,21 @@ If you will be making insecure HTTP requests (not HTTPS), you will need to expli
 
 ## Usage
 
-Using `Motion::HTTP` is quick and easy. You can use the simple approach for making one-off requests, or the advanced approach of creating a reusable API client for further customization.
+Using `motion-http` is quick and easy. You can use the simple approach for making one-off requests, or the advanced approach of creating a reusable API client for further customization.
 
 ### Simple Usage
 
-The basic syntax for a simple request looks like this:
+The basic syntax for a request looks like this:
 ```ruby
-Motion::HTTP.method(url, params) do |response|
+HTTP.method(url, params, options) do |response|
   # this block will be called asynchronously
 end
 ```
+Where `method` can be `get`, `post`, `put`, `patch`, or `delete`.
 
-To make a simple `GET` request:
+For example, to make a simple `GET` request:
 ```ruby
-Motion::HTTP.get("http://www.example.com") do |response|
-  puts "status code: #{response.status_code}"
-  puts "response body: #{response.body}"
+HTTP.get("http://www.example.com") do |response|
   if response.success?
     puts "Success!"
   else
@@ -58,14 +54,23 @@ end
 
 You can specify query params as the second argument:
 ```ruby
-Motion::HTTP.get("http://www.example.com/search", term: "my search term") do |response|
+HTTP.get("http://www.example.com/search", term: "my search term") do |response|
   # ...
 end
 ```
 
-`Motion::HTTP` will automatically parse JSON responses:
+The response object contains the status code, headers, and body from the response as well:
 ```ruby
-Motion::HTTP.get("http://api.example.com/people.json") do |response|
+HTTP.get("http://example.com") do |response|
+  puts response.status_code
+  puts response.headers.inspect
+  puts response.body
+end
+```
+
+JSON responses will automatically be parsed when requesting the `response.object`:
+```ruby
+HTTP.get("http://api.example.com/people.json") do |response|
   if response.success?
     response.object["people"].each do |person|
       puts "name: #{person["name"]}"
@@ -76,25 +81,32 @@ Motion::HTTP.get("http://api.example.com/people.json") do |response|
 end
 ```
 
+The third argument is a hash of options. Currently the only option supported at this time is `follow_redirects` which defaults to true:
+```ruby
+HTTP.get("http://example.com/redirect", nil, follow_redirects: false) do |response|
+  # ...
+end
+```
+
 To make a simple `POST` request, the value passed as the second argument will be encoded as the request body:
 ```ruby
 json = { widget: { name: "Foobar" } }
-Motion::HTTP.post("http://www.example.com/widgets", json) do |response|
+HTTP.post("http://www.example.com/widgets", json) do |response|
   if response.success?
     puts "Widget created!"
-  elsif response.client_error?
+  elsif response.status_code == 422
     puts "Oops, you did something wrong: #{response.object["error_message"]}"
   else
-    puts "Oops! Something else went wrong."
+    puts "Oops! Something went wrong."
   end
 end
 ```
 
 `PUT`, `PATCH`, and `DELETE` requests work the same way:
 ```ruby
-Motion::HTTP.put(url, params) { ... }
-Motion::HTTP.patch(url, params) { ... }
-Motion::HTTP.delete(url, params) { ... }
+HTTP.put(url, params) { ... }
+HTTP.patch(url, params) { ... }
+HTTP.delete(url, params) { ... }
 ```
 
 ### Advanced Usage
@@ -102,7 +114,7 @@ Motion::HTTP.delete(url, params) { ... }
 A common use case is to create a reusable HTTP client that uses a common base URL or request headers.
 
 ```ruby
-client = Motion::HTTP::Client.new("http://www.example.com")
+client = HTTP::Client.new("http://api.example.com")
 # Set or replace a single header:
 client.header "X-API-TOKEN", "abc123xyz"
 
@@ -110,13 +122,13 @@ client.header "X-API-TOKEN", "abc123xyz"
 client.headers "X-API-TOKEN" => "abc123xyz",
                "Accept" => "application/json"
 
-# It is valid for some headers to appear multiple times (Accept, Vary, etc).
+# Note that it is valid for some headers to appear multiple times (Accept, Vary, etc).
 # To append multiple headers of the same key:
 client.add_header "Accept", "application/json"
 client.add_header "Accept", "application/vnd.api+json"
 ```
 
-Then make your requests relative to the base URL that you specified when creating your client.
+Then you can make your requests relative to the base URL that you specified when creating your client.
 ```ruby
 client.get("/people") do |response|
   # ...

data/lib/android/adapter.rb

@@ -7,8 +7,12 @@ class Motion
         @client ||= Okhttp3::OkHttpClient.new
       end
 
-      def self.request(http_method, url, headers, params = nil, &callback)
-        puts "starting #{http_method.to_s.upcase} #{url}"
+      def self.perform(request, &callback)
+        http_method = request.http_method
+        url = request.url
+        headers = request.headers
+        params = request.params
+
         request = OkHttp3::Request::Builder.new
         request.url(url) # TODO: encode GET params and append to URL prior to calling this method
         headers.each do |key, value|
@@ -23,17 +27,18 @@ class Motion
           # body = OkHttp3::RequestBody.create(JSONMediaType, params) # TODO: allow other content types
           # request.method(http_method.to_s, body)
         end
-        client.newCall(request.build).enqueue(OkhttpCallback.new(callback))
+        client.newCall(request.build).enqueue(OkhttpCallback.new(request, callback))
       end
 
       class OkhttpCallback
-        def initialize(callback)
+        def initialize(request, callback)
+          @request = request
           @callback = callback
         end
 
         def onFailure(call, e)
           puts "Error: #{e.getMessage}"
-          @callback.call(Response.new(nil, Headers.new, e.getMessage))
+          @callback.call(Response.new(@request, nil, Headers.new, e.getMessage))
         end
 
         def onResponse(call, response)
@@ -49,9 +54,7 @@ class Motion
             headers.add(key, value)
             i += 1
           end
-          body_string = response.body.string
-          json = JSON.load(body_string) if headers['content-type'] =~ /application\/json/
-          Response.new(response.code, headers, body_string, json)
+          Response.new(@request, response.code, headers, response.body.string)
         end
       end
     end

data/lib/android/json.rb

@@ -34,3 +34,34 @@ class JSON
     end
   end
 end
+
+class Object
+  def to_json
+    # The Android JSON API expects real Java String objects.
+    @@fix_string ||= (lambda do |obj|
+      case obj
+        when String, Symbol
+          obj = obj.toString
+        when Hash
+          map = Hash.new
+          obj.each do |key, value|
+            key = key.toString if key.is_a?(String) || key.is_a?(Symbol)
+            value = @@fix_string.call(value)
+            map[key] = value
+          end
+          obj = map
+        when Array
+          obj = obj.map do |item|
+            (item.is_a?(String) || item.is_a?(Symbol)) ? item.toString : @@fix_string.call(item)
+          end
+      end
+      obj
+    end)
+
+    obj = Org::JSON::JSONObject.wrap(@@fix_string.call(self))
+    if obj == nil
+      raise "Can't serialize object to JSON"
+    end
+    obj.toString.to_s
+  end
+end

data/lib/cocoa/adapter.rb

@@ -1,44 +1,55 @@
 class Motion
   class HTTP
     class Adapter
-      def self.manager
-        @manager ||= AFHTTPSessionManager.manager
+      def self.perform(request, &callback)
+        Motion::HTTP::Adapter::Request.new(request).perform(&callback)
       end
 
-      def self.request(http_method, url, headers, params = nil, &callback)
-        progress = nil
-        on_success = lambda do |task, response_object|
-          response = task.response
-          callback.call(Response.new(response.statusCode, Headers.new(response.allHeaderFields), nil, response_object))
+      class Request
+        def initialize(request)
+          @request = request
+          @session = NSURLSession.sessionWithConfiguration(NSURLSessionConfiguration.defaultSessionConfiguration, delegate: self, delegateQueue: nil)
         end
-        on_error = lambda do |operation, error|
-          NSLog("Error: %@", error)
-          response = operation.response
-          status_code = response.statusCode if response
-          response_headers = response.allHeaderFields if response
-          error_message = error.localizedDescription
-          error_message += error.userInfo[NSLocalizedDescriptionKey] if error.userInfo[NSLocalizedDescriptionKey]
-          callback.call(
-            Response.new(status_code, Headers.new(response_headers), error_message)
-          )
+
+        def perform(&callback)
+          # TODO: dataTask is good for general HTTP requests but not for file downloads
+          ns_url_request = build_ns_url_request
+          task = @session.dataTaskWithRequest(ns_url_request, completionHandler: -> (data, response, error) {
+            if error
+              NSLog("Error: %@", error) # TODO: use configurable logging
+              error_message = error.localizedDescription
+              error_message += error.userInfo[NSLocalizedDescriptionKey] if error.userInfo[NSLocalizedDescriptionKey]
+              response = Response.new(@request, response.statusCode, Headers.new(response.allHeaderFields), error_message)
+            else
+              response = Response.new(@request, response.statusCode, Headers.new(response.allHeaderFields), data.to_s)
+            end
+            Motion::HTTP.logger.log_response(response)
+            callback.call(response)
+          })
+          task.resume
         end
 
-        case http_method
-        when :get
-          manager.GET url, parameters: params, progress: progress, success: on_success, failure: on_error
-        when :post
-          manager.POST url, parameters: params, progress: progress, success: on_success, failure: on_error
-        when :put
-          manager.PUT url, parameters: params, progress: progress, success: on_success, failure: on_error
-        when :patch
-          manager.PATCH url, parameters: params, progress: progress, success: on_success, failure: on_error
-        when :delete
-          manager.DELETE url, parameters: params, progress: progress, success: on_success, failure: on_error
+        def build_ns_url_request
+          ns_url_request = NSMutableURLRequest.alloc.initWithURL(NSURL.URLWithString(@request.url))
+          ns_url_request.HTTPMethod = @request.http_method.to_s.upcase
+          if @request.params
+            # TODO: json serialization
+            ns_url_request.setValue('application/x-www-form-urlencoded', forHTTPHeaderField: 'Content-Type')
+            ns_url_request.HTTPBody = FormDataSerializer.serialize(@request.params).dataUsingEncoding(NSUTF8StringEncoding)
+          end
+          # TODO: add other headers
+          ns_url_request
         end
 
-        # FIXME: dynamically calling the method using send results in a crash
-        # method_signature = "#{http_method.to_s.upcase}:parameters:progress:success:failure:"
-        # # manager.send(method_signature, url, params, nil, on_success, on_error)
+        # NSURLSessionTaskDelegate methods
+
+        def URLSession(session, task: task, willPerformHTTPRedirection: response, newRequest: request, completionHandler: completion_handler)
+          if @request.options[:follow_redirects] == false
+            completion_handler.call(nil)
+          else
+            completion_handler.call(request)
+          end
+        end
       end
     end
   end

data/lib/cocoa/form_data_serializer.rb

@@ -0,0 +1,29 @@
+class FormDataSerializer
+  def self.serialize(params)
+    flattened_params = {}
+    params.each do |k, v|
+      add_param(flattened_params, k, v)
+    end
+    serialized_params = []
+    flattened_params.each do |k, v|
+      serialized_params << "#{k}=#{serialize_value(v)}"
+    end
+    serialized_params.join('&')
+  end
+
+  def self.add_param(hash, k, v)
+    if v.is_a? Hash
+      v.each do |sub_k, sub_v|
+        add_param(hash, "#{k}[#{sub_k}]", sub_v)
+      end
+    else
+      hash[k] = v
+    end
+  end
+
+  def self.serialize_value(v)
+    allowed_characters = NSCharacterSet.URLQueryAllowedCharacterSet.mutableCopy
+    allowed_characters.removeCharactersInString(":#[]@!$&'()*+,;=")
+    NSString.alloc.initWithString(v.to_s).stringByAddingPercentEncodingWithAllowedCharacters(allowed_characters)
+  end
+end

data/lib/cocoa/json.rb

@@ -0,0 +1,26 @@
+class JSON
+  def self.parse(json_string)
+    error_ptr = Pointer.new(:id)
+    object = NSJSONSerialization.JSONObjectWithData(json_string.dataUsingEncoding(NSUTF8StringEncoding), options: 0, error: error_ptr)
+    unless object
+      raise error_ptr[0].description
+    end
+    object
+  end
+
+  def self.generate(object)
+    raise "Invalid JSON object" unless NSJSONSerialization.isValidJSONObject(object)
+    error_ptr = Pointer.new(:id)
+    data = NSJSONSerialization.dataWithJSONObject(object, options: 0, error: error_ptr)
+    unless data
+      raise error_ptr[0].description
+    end
+    data.to_s
+  end
+end
+
+class Object
+  def to_json
+    JSON.generate(self)
+  end
+end

data/lib/common/http/client.rb

@@ -4,7 +4,7 @@ class Motion
       attr_reader :base_url
 
       def initialize(base_url = nil)
-        @base_url = base_url || ""
+        @base_url = base_url || ''
         @headers = Headers.new
       end
 
@@ -25,19 +25,31 @@ class Motion
         @headers
       end
 
-      # FIXME: doesn't work on Android
+      # FIXME: doesn't work on Android for some reason
       # [:get, :post, :put, :patch, :delete].each do |method|
-      #   define_method "#{method}", do |path, params = nil, &callback|
-      #     Request.new(method, base_url + path, headers, params, &callback).call
+      #   define_method "#{method}", do |path, params = nil, options = nil, &callback|
+      #     Request.new(method, base_url + path, headers, params, options).perform(&callback)
       #   end
       # end
 
-      def get(path, params = nil, &callback)
-        Request.new(:get, base_url + path, @headers, params, &callback).call
+      def get(path, params = nil, options = nil, &callback)
+        Request.new(:get, base_url + path, headers, params, options).perform(&callback)
       end
 
-      def post(path, params = nil, &callback)
-        Request.new(:post, base_url + path, @headers, params, &callback).call
+      def post(path, params = nil, options = nil, &callback)
+        Request.new(:post, base_url + path, headers, params, options).perform(&callback)
+      end
+
+      def put(path, params = nil, options = nil, &callback)
+        Request.new(:put, base_url + path, headers, params, options).perform(&callback)
+      end
+
+      def patch(path, params = nil, options = nil, &callback)
+        Request.new(:patch, base_url + path, headers, params, options).perform(&callback)
+      end
+
+      def delete(path, params = nil, options = nil, &callback)
+        Request.new(:delete, base_url + path, headers, params, options).perform(&callback)
       end
     end
   end

data/lib/common/http/logger.rb

@@ -0,0 +1,37 @@
+class Motion
+  class HTTP
+    class Logger
+      def log(message)
+        puts message # TODO: add option to enable/disable logging
+      end
+
+      def log_request(request)
+        log "Request:\n#{request.http_method.to_s.upcase} #{request.url}"
+
+        if request.headers
+          request.headers.each do |k,v|
+            log "#{k}: #{v.inspect}"
+          end
+        end
+
+        if request.params
+          # log serialized_params
+          request.params.each do |k,v|
+            log "\t#{k}=#{v.inspect}"
+          end
+        end
+        log "\n"
+      end
+
+      def log_response(response)
+        log "Response:"
+        log "URL: #{response.original_request.url}"
+        log "Status: #{response.status_code}"
+        response.headers.each do |key, value|
+          log "#{key}: #{value}"
+        end
+        log "\n#{response.body}"
+      end
+    end
+  end
+end

data/lib/common/http/request.rb

@@ -1,19 +1,19 @@
 class Motion
   class HTTP
     class Request
-      attr_reader :method, :url, :headers, :body, :callback
+      attr_reader :http_method, :url, :headers, :params, :options
 
-      def initialize(method, url, headers = nil, params = nil, &callback)
-        @method = method
+      def initialize(http_method, url, headers = nil, params = nil, options = nil)
+        @http_method = http_method
         @url = url
         @headers = headers || Headers.new
-        @body = params # TODO: turn params into body and set content-type?
-        @callback = callback || ->(response) {}
+        @params = params
+        @options = options
       end
 
-      def call
-        # TODO: maybe pass self instead of args
-        Adapter.request(method, url, headers, body, &callback)
+      def perform(&callback)
+        Motion::HTTP.logger.log_request(self)
+        Adapter.perform(self, &callback)
       end
     end
   end

data/lib/common/http/response.rb

@@ -1,13 +1,13 @@
 class Motion
   class HTTP
     class Response
-      attr_reader :status_code, :headers, :body, :object
+      attr_reader :original_request, :status_code, :headers, :body
 
-      def initialize(status_code, headers, body_string, body_object = nil)
+      def initialize(original_request, status_code, headers, body)
+        @original_request = original_request
         @status_code = status_code
         @headers = headers
-        @body = body_string
-        @object = body_object
+        @body = body
       end
 
       def success?
@@ -15,8 +15,17 @@ class Motion
         status_code >= 200 && status_code < 300
       end
 
+      def object
+        @object ||= case headers['Content-Type']
+          when /^application\/json/, /^application\/vnd.api\+json/
+            JSON.parse(body)
+          else
+            body
+          end
+      end
+
       def inspect
-        "<Motion::HTTP::Response status_code:#{status_code} headers:<#{headers.class}> body:<#{body.class}>>"
+        "<Motion::HTTP::Response status_code:#{status_code} headers:#{headers.inspect} body:#{body.inspect}>"
       end
     end
   end

data/lib/common/http.rb

@@ -1,36 +1,42 @@
 class Motion
   class HTTP
     class << self
+      def logger
+        @logger ||= Logger.new
+      end
+
       def client
         @client ||= Client.new
       end
 
       # FIXME: doesn't work on Android
       # [:get, :post, :put, :patch, :delete].each do |method|
-      #   define_method "#{method}", do |url, params = nil, &callback|
-      #     client.send(method, url, params, &callback)
+      #   define_method "#{method}", do |url, params = nil, options = nil, &callback|
+      #     client.send(method, url, params, options, &callback)
       #   end
       # end
 
-      def get(url, params = nil, &callback)
-        client.get(url, params, &callback)
+      def get(url, params = nil, options = nil, &callback)
+        client.get(url, params, options, &callback)
       end
 
-      def post(url, params = nil, &callback)
-        client.post(url, params, &callback)
+      def post(url, params = nil, options = nil, &callback)
+        client.post(url, params, options, &callback)
       end
 
-      def put(url, params = nil, &callback)
-        client.put(url, params, &callback)
+      def put(url, params = nil, options = nil, &callback)
+        client.put(url, params, options, &callback)
       end
 
-      def patch(url, params = nil, &callback)
-        client.patch(url, params, &callback)
+      def patch(url, params = nil, options = nil, &callback)
+        client.patch(url, params, options, &callback)
       end
 
-      def delete(url, params = nil, &callback)
-        client.delete(url, params, &callback)
+      def delete(url, params = nil, options = nil, &callback)
+        client.delete(url, params, options, &callback)
       end
     end
   end
 end
+
+HTTP = Motion::HTTP # alias as simply HTTP

data/lib/motion-http.rb

@@ -16,11 +16,7 @@ Motion::Project::App.setup do |app|
       dependency "com.squareup.okhttp3:okhttp:3.9.0"
     end
   when :ios, :tvos, :osx, :watchos, :'ios-extension'
-    require "motion-cocoapods"
     app.files.unshift(*Dir.glob(File.join(lib_dir_path, "cocoa/**/*.rb")))
-    app.pods do
-      pod "AFNetworking", "~> 3.1"
-    end
   else
     raise "Project template #{Motion::Project::App.template} not supported by motion-http"
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motion-http
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Havens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-26 00:00:00.000000000 Z
+date: 2019-03-15 00:00:00.000000000 Z
 dependencies: []
 description: A cross-platform HTTP client for RubyMotion that's quick and easy to
   use.
@@ -22,9 +22,12 @@ files:
 - lib/android/adapter.rb
 - lib/android/json.rb
 - lib/cocoa/adapter.rb
+- lib/cocoa/form_data_serializer.rb
+- lib/cocoa/json.rb
 - lib/common/http.rb
 - lib/common/http/client.rb
 - lib/common/http/headers.rb
+- lib/common/http/logger.rb
 - lib/common/http/request.rb
 - lib/common/http/response.rb
 - lib/motion-http.rb
@@ -48,7 +51,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A cross-platform HTTP client for RubyMotion that's quick and easy to use.