motion-http 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a32a0271f1f711f5a11522c48894a06ea9e8924615d38bae2a235572f15d2135
-  data.tar.gz: 590d6d30eb2889d97f47ed0e072313eb93dd38eb3e6485f0f894e526869f6a79
+  metadata.gz: 38301fffb680c2ff73c68cc0cafef260be772a4c09892c8f6706bb415014bdc6
+  data.tar.gz: 562ac8347a504aa3c061beeb6555ec54b73d0ec5c6d27266349150c1e4239c45
 SHA512:
-  metadata.gz: a01adbafd00b594929e7b7f86de05e55ff60e1040db5e736247dcb5dca8f01d21804c54ae5ecca7f365a6181dfb030794acfb667a93694bf0a0da0cd4a17f0d4
-  data.tar.gz: 684d0b718b0d84c7e4222cc16c97f39b4bf875e43b752c7d3f72d9e6540b9cc2e938a690a4542678eb5bff4d89f6409197750a4c608df0a48c9e7a327794901f
+  metadata.gz: d34d53372cd85ff50915ca586a36fdba710852a62e9f60c511139d0d72887084e974cc7a39faedc02a5737c96d858900e66ef661960572c22970aebccc613e32
+  data.tar.gz: 01d2e62e89ed670128c423c4f005383cc2ff46e351c3dc2163cf567a88ee7a5507257c3321cac4ba151f1bb91f2865af9ebd4ce1aae9f0c06b369d46ba63117a

data/README.md

@@ -35,11 +35,11 @@ Using `motion-http` is quick and easy. You can use the simple approach for makin
 
 The basic syntax for a request looks like this:
 ```ruby
-HTTP.method(url, params, options) do |response|
-  # this block will be called asynchronously
+HTTP.method(url, options) do |response|
+  # this will be called asynchronously
 end
 ```
-Where `method` can be `get`, `post`, `put`, `patch`, or `delete`.
+Where `method` can be either `get`, `post`, `put`, `patch`, `delete`, `head`, `options`, or `trace`.
 
 For example, to make a simple `GET` request:
 ```ruby
@@ -52,23 +52,27 @@ HTTP.get("http://www.example.com") do |response|
 end
 ```
 
-You can specify query params as the second argument:
+If you need to specify query params:
 ```ruby
-HTTP.get("http://www.example.com/search", term: "my search term") do |response|
+HTTP.get("http://www.example.com/search", params: { term: "my search term" }) do |response|
   # ...
 end
 ```
 
-The response object contains the status code, headers, and body from the response as well:
+The response object contains the status code, headers, body, and shortcut methods for checking the response status:
 ```ruby
 HTTP.get("http://example.com") do |response|
-  puts response.status_code
+  puts response.status_code.to_s
   puts response.headers.inspect
   puts response.body
+  response.success?      # 2xx status
+  response.redirect?     # 3xx status
+  response.client_error? # 4xx status
+  response.server_error? # 5xx status
 end
 ```
 
-JSON responses will automatically be parsed when requesting the `response.object`:
+If the response body has a JSON content type it will automatically be parsed when requesting the `response.object`:
 ```ruby
 HTTP.get("http://api.example.com/people.json") do |response|
   if response.success?
@@ -81,17 +85,29 @@ 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:
+Use the `follow_redirects` option to specify whether or not to follow redirects. It defaults to true:
 ```ruby
-HTTP.get("http://example.com/redirect", nil, follow_redirects: false) do |response|
+HTTP.get("http://example.com/redirect", 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:
+When making a `POST` request, specify the `:form` option and it will automatically be encoded as `application/x-www-form-urlencoded` request body:
 ```ruby
-json = { widget: { name: "Foobar" } }
-HTTP.post("http://www.example.com/widgets", json) do |response|
+HTTP.post("http://www.example.com/login", form: { user: 'andrew', pass: 'secret'}) do |response|
+  if response.success?
+    puts "Authenticated!"
+  elsif response.client_error?
+    puts "Bad username or password"
+  else
+    puts "Oops! Something went wrong."
+  end
+end
+```
+
+Likewise, to send a JSON encoded request body, use the `:json` option:
+```ruby
+HTTP.post("http://www.example.com/widgets", json: { widget: { name: "Foobar" } }) do |response|
   if response.success?
     puts "Widget created!"
   elsif response.status_code == 422
@@ -102,11 +118,24 @@ HTTP.post("http://www.example.com/widgets", json) do |response|
 end
 ```
 
-`PUT`, `PATCH`, and `DELETE` requests work the same way:
+Request specific headers can also be specified with the `:headers` option (overriding any previously set headers):
+```ruby
+HTTP.post("http://www.example.com/widgets",
+    headers: { 'Content-Type' => 'application/vnd.api+json' },
+    json: { widget: { name: "Foobar" } }
+  ) do |response|
+  # ...
+end
+```
+
+All other HTTP method requests work the same way:
 ```ruby
 HTTP.put(url, params) { ... }
 HTTP.patch(url, params) { ... }
 HTTP.delete(url, params) { ... }
+HTTP.head(url, params) { ... }
+HTTP.options(url, params) { ... }
+HTTP.trace(url, params) { ... }
 ```
 
 ### Advanced Usage
@@ -117,6 +146,7 @@ A common use case is to create a reusable HTTP client that uses a common base UR
 client = HTTP::Client.new("http://api.example.com")
 # Set or replace a single header:
 client.header "X-API-TOKEN", "abc123xyz"
+client.header["X-API-TOKEN"] = "abc123xyz"
 
 # To set or replace multiple headers:
 client.headers "X-API-TOKEN" => "abc123xyz",
@@ -125,7 +155,7 @@ client.headers "X-API-TOKEN" => "abc123xyz",
 # 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"
+client.headers.add "Accept", "application/json"
 ```
 
 Then you can make your requests relative to the base URL that you specified when creating your client.
@@ -135,6 +165,35 @@ client.get("/people") do |response|
 end
 ```
 
+### Basic Auth / Token Auth
+
+To make Basic Auth requests, either set the credentials before the request, or set it on your client:
+
+```ruby
+HTTP.basic_auth('username', 'password').get('https://example.com/protected')
+# or
+client.basic_auth('username', 'password')
+client.get('/protected')
+```
+
+The `auth` method is another shortcut for setting any value of the Authorization header:
+
+```ruby
+HTTP.auth("Token token=#{my_token}")
+# or
+client.auth("Token token=#{my_token}")
+# same as
+client.headers['Authorization'] = "Token token=#{my_token}"
+```
+
+### Logging
+
+By default, requests and responses will be logged. If you would like to disable this:
+
+```
+HTTP.logger.disable!
+```
+
 ## Contributing
 
 1. Fork it

data/lib/android/adapter.rb

@@ -1,61 +1,13 @@
 class Motion
   class HTTP
     class Adapter
-      JSONMediaType = Okhttp3::MediaType.parse("application/json; charset=utf-8")
-
-      def self.client
-        @client ||= Okhttp3::OkHttpClient.new
-      end
-
       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|
-          if value.is_a? Array
-            value.each {|val| request.addHeader(key, val) }
-          else
-            request.header(key, value)
-          end
-        end
-        if http_method != :get
-          puts "would have set body for #{http_method.to_s.upcase} #{url}"
-          # 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(request, callback))
+        volley_request = VolleyRequest.create(request, callback)
+        queue.add(volley_request)
       end
 
-      class OkhttpCallback
-        def initialize(request, callback)
-          @request = request
-          @callback = callback
-        end
-
-        def onFailure(call, e)
-          puts "Error: #{e.getMessage}"
-          @callback.call(Response.new(@request, nil, Headers.new, e.getMessage))
-        end
-
-        def onResponse(call, response)
-          @callback.call(parse_response(response))
-        end
-
-        def parse_response(response)
-          headers = Headers.new
-          i = 0
-          while i < response.headers.size
-            key = response.headers.name(i)
-            value = response.headers.value(i)
-            headers.add(key, value)
-            i += 1
-          end
-          Response.new(@request, response.code, headers, response.body.string)
-        end
+      def self.queue
+        @queue ||= Com::Android::Volley::Toolbox::Volley.newRequestQueue(Motion::HTTP.application_context)
       end
     end
   end

data/lib/android/base64.rb

@@ -0,0 +1,13 @@
+# Copied from https://github.com/HipByte/Flow/blob/44283b31a63bc826d2c068557b6357dc1195680b/flow/base64/android/base64.rb
+class Base64
+  def self.encode(string)
+    bytes = Java::Lang::String.new(string).getBytes("UTF-8")
+    Android::Util::Base64.encodeToString(bytes, Android::Util::Base64::NO_WRAP)
+  end
+
+  def self.decode(string)
+    java_string = Java::Lang::String.new(string)
+    bytes = Android::Util::Base64.decode(java_string, Android::Util::Base64::NO_WRAP)
+    Java::Lang::String.new(bytes, "UTF-8")
+  end
+end

data/lib/android/json.rb

@@ -1,6 +1,6 @@
 # NOTE: Copied from https://github.com/HipByte/Flow/blob/master/flow/json/android/json.rb
 class JSON
-  def self.load(str)
+  def self.parse(str)
     tok = Org::JSON::JSONTokener.new(str)
     obj = tok.nextValue
     if obj == nil

data/lib/android/params_encoder.rb

@@ -0,0 +1,5 @@
+class ParamsEncoder
+  def self.encode(arg)
+    Java::Net::URLEncoder.encode(arg, 'UTF-8')
+  end
+end

data/lib/android/volley_request.rb

@@ -0,0 +1,52 @@
+class VolleyRequest < Com::Android::Volley::Request
+  attr_accessor :original_request, :callback
+
+  METHOD_CODES = {
+    get: 0,
+    post: 1,
+    put: 2,
+    delete: 3,
+    head: 4,
+    options: 5,
+    trace: 6,
+    patch: 7,
+  }
+
+  def self.create(request, callback)
+    volley_request = new(METHOD_CODES[request.http_method], request.url, nil)
+    volley_request.original_request = request
+    volley_request.headers = request.headers.to_hash
+    volley_request.body = request.body
+    volley_request.callback = callback
+    volley_request
+  end
+
+  def parseNetworkResponse(networkResponse)
+    response = build_response(networkResponse)
+    Com::Android::Volley::Response.success(response, Com::Android::Volley::Toolbox::HttpHeaderParser.parseCacheHeaders(networkResponse))
+  end
+
+  def deliverResponse(response)
+    Motion::HTTP.logger.log_response(response)
+    callback.call(response) if callback
+  end
+
+  def deliverError(error)
+    if error.networkResponse
+      response = build_response(error.networkResponse)
+      deliverResponse(response)
+    else
+      Motion::HTTP.logger.error("Error while requesting #{original_request.url}: #{error.getMessage}")
+      error.getStackTrace.each do |line|
+        puts line.toString
+      end
+      response = Motion::HTTP::Response.new(original_request, nil, nil, error.getMessage)
+      callback.call(response) if callback
+    end
+  end
+
+  def build_response(networkResponse)
+    body = parse_body_from_response(networkResponse)
+    Motion::HTTP::Response.new(original_request, networkResponse.statusCode, Motion::HTTP::Headers.new(networkResponse.headers), body)
+  end
+end

data/lib/cocoa/adapter.rb

@@ -16,15 +16,14 @@ class Motion
           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)
+              error_message = "#{error.localizedDescription} #{error.userInfo['NSLocalizedDescriptionKey']}"
+              Motion::HTTP.logger.error("Error while requesting #{@request.url}: #{error_message}")
+              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)
+              Motion::HTTP.logger.log_response(response)
             end
-            Motion::HTTP.logger.log_response(response)
-            callback.call(response)
+            callback.call(response) if callback
           })
           task.resume
         end
@@ -32,11 +31,18 @@ class Motion
         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)
+          @request.headers.each do |key, value|
+            if value.is_a? Array
+              value.each {|v2| ns_url_request.addValue(v2, forHTTPHeaderField: key) }
+            else
+              ns_url_request.setValue(value, forHTTPHeaderField: key)
+            end
           end
+
+          if @request.body
+            ns_url_request.HTTPBody = NSString.alloc.initWithString(@request.body).dataUsingEncoding(NSUTF8StringEncoding)
+          end
+
           # TODO: add other headers
           ns_url_request
         end

data/lib/cocoa/base64.rb

@@ -0,0 +1,12 @@
+# Copied from https://github.com/HipByte/Flow/blob/44283b31a63bc826d2c068557b6357dc1195680b/flow/base64/cocoa/base64.rb
+class Base64
+  def self.encode(string)
+    data = string.dataUsingEncoding(NSUTF8StringEncoding)
+    data.base64EncodedStringWithOptions(0)
+  end
+
+  def self.decode(string)
+    data = NSData.alloc.initWithBase64EncodedString(string, options: 0)
+    NSString.alloc.initWithData(data, encoding: NSUTF8StringEncoding)
+  end
+end

data/lib/cocoa/params_encoder.rb

@@ -0,0 +1,8 @@
+class ParamsEncoder
+  # TODO: check if iOS implements anything more performant/reliable that we should be using.
+  def self.encode(arg)
+    arg.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/) do |m|
+      '%' + m.unpack('H2' * m.bytesize).join('%').upcase
+    end.tr(' ', '+')
+  end
+end

data/lib/common/http.rb

@@ -1,39 +1,54 @@
 class Motion
   class HTTP
     class << self
+      attr_accessor :application_context # Android
+
       def logger
         @logger ||= Logger.new
       end
 
-      def client
-        @client ||= Client.new
+      def client(*args)
+        Client.new(*args)
+      end
+
+      def basic_auth(username, password)
+        client.basic_auth(username, password)
+      end
+
+      def auth(header_value)
+        client.auth(header_value)
       end
 
-      # FIXME: doesn't work on Android
-      # [:get, :post, :put, :patch, :delete].each do |method|
-      #   define_method "#{method}", do |url, params = nil, options = nil, &callback|
-      #     client.send(method, url, params, options, &callback)
-      #   end
-      # end
+      def get(url, options = nil, &callback)
+        client.get(url, options, &callback)
+      end
+
+      def post(url, options = nil, &callback)
+        client.post(url, options, &callback)
+      end
+
+      def put(url, options = nil, &callback)
+        client.put(url, options, &callback)
+      end
 
-      def get(url, params = nil, options = nil, &callback)
-        client.get(url, params, options, &callback)
+      def patch(url, options = nil, &callback)
+        client.patch(url, options, &callback)
       end
 
-      def post(url, params = nil, options = nil, &callback)
-        client.post(url, params, options, &callback)
+      def delete(url, options = nil, &callback)
+        client.delete(url, options, &callback)
       end
 
-      def put(url, params = nil, options = nil, &callback)
-        client.put(url, params, options, &callback)
+      def head(url, options = nil, &callback)
+        client.head(url, options, &callback)
       end
 
-      def patch(url, params = nil, options = nil, &callback)
-        client.patch(url, params, options, &callback)
+      def options(url, options = nil, &callback)
+        client.options(url, options, &callback)
       end
 
-      def delete(url, params = nil, options = nil, &callback)
-        client.delete(url, params, options, &callback)
+      def trace(url, options = nil, &callback)
+        client.trace(url, options, &callback)
       end
     end
   end

data/lib/common/http/client.rb

@@ -3,9 +3,10 @@ class Motion
     class Client
       attr_reader :base_url
 
-      def initialize(base_url = nil)
+      def initialize(base_url = nil, options = nil)
         @base_url = base_url || ''
-        @headers = Headers.new
+        options ||= {}
+        @headers = Headers.new(options.delete(:headers))
       end
 
       def header(key, value)
@@ -25,31 +26,57 @@ class Motion
         @headers
       end
 
-      # FIXME: doesn't work on Android for some reason
-      # [:get, :post, :put, :patch, :delete].each do |method|
-      #   define_method "#{method}", do |path, params = nil, options = nil, &callback|
-      #     Request.new(method, base_url + path, headers, params, options).perform(&callback)
-      #   end
-      # end
+      def basic_auth(username, password)
+        header_value = 'Basic ' + Base64.encode("#{username}:#{password}")
+        auth(header_value)
+        self
+      end
+
+      def auth(header_value)
+        @headers.set 'Authorization', header_value
+        self
+      end
+
+      def get(path, options = nil, &callback)
+        request(:get, path, options, &callback)
+      end
+
+      def post(path, options = nil, &callback)
+        request(:post, path, options, &callback)
+      end
+
+      def put(path, options = nil, &callback)
+        request(:put, path, options, &callback)
+      end
 
-      def get(path, params = nil, options = nil, &callback)
-        Request.new(:get, base_url + path, headers, params, options).perform(&callback)
+      def patch(path, options = nil, &callback)
+        request(:patch, path, options, &callback)
       end
 
-      def post(path, params = nil, options = nil, &callback)
-        Request.new(:post, base_url + path, headers, params, options).perform(&callback)
+      def delete(path, options = nil, &callback)
+        request(:delete, path, options, &callback)
       end
 
-      def put(path, params = nil, options = nil, &callback)
-        Request.new(:put, base_url + path, headers, params, options).perform(&callback)
+      def head(path, options = nil, &callback)
+        request(:head, path, options, &callback)
       end
 
-      def patch(path, params = nil, options = nil, &callback)
-        Request.new(:patch, base_url + path, headers, params, options).perform(&callback)
+      def options(path, options = nil, &callback)
+        request(:options, path, options, &callback)
       end
 
-      def delete(path, params = nil, options = nil, &callback)
-        Request.new(:delete, base_url + path, headers, params, options).perform(&callback)
+      def trace(path, options = nil, &callback)
+        request(:trace, path, options, &callback)
+      end
+
+      def request(http_method, path, options = nil, &callback)
+        options ||= {}
+        headers_dup = headers.dup
+        if options[:headers]
+          options.delete(:headers).each {|key, value| headers_dup.set(key, value) }
+        end
+        options[:headers] = headers_dup
+        Request.new(http_method, base_url + path, options).perform(&callback)
       end
     end
   end

data/lib/common/http/headers.rb

@@ -2,12 +2,27 @@ class Motion
   class HTTP
     class Headers
       def initialize(headers = {})
-        @headers = headers
+        @headers = {}
+        if headers
+          headers.each {|key, value| set(key, value) }
+        end
+      end
+
+      def get(key)
+        @headers[key.downcase]
+      end
+      # alias :[] :get # FIXME: doesn't work in Android
+      def [](key)
+        get(key)
       end
 
       def set(key, value)
         @headers[key.downcase] = value
       end
+      # alias :[]= :set # FIXME: doesn't work in Android
+      def []=(key, value)
+        set(key, value)
+      end
 
       def add(key, value)
         key = key.downcase
@@ -17,13 +32,22 @@ class Motion
         end
         @headers[key] << value
       end
+      # alias :<< :add # FIXME: doesn't work in Android
+      def <<(key, value)
+        add(key, value)
+      end
 
       def each(&block)
         @headers.each(&block)
       end
 
-      def [](key)
-        @headers[key.downcase]
+      def to_hash
+        @headers # TODO: flatten array values
+      end
+
+      # FIXME: Android doesn't support dup (Java exception raised: java.lang.CloneNotSupportedException: Class com.yourcompany.motion_http.Headers doesn't implement Cloneable)
+      def dup
+        Headers.new(@headers)
       end
     end
   end

data/lib/common/http/logger.rb

@@ -1,36 +1,76 @@
 class Motion
   class HTTP
     class Logger
-      def log(message)
-        puts message # TODO: add option to enable/disable logging
+      attr_reader :enabled
+
+      def initialize(enabled = true)
+        @enabled = enabled
+      end
+
+      def enable!
+        @enabled = true
+      end
+
+      def disable!
+        @enabled = false
+      end
+
+      def log(message, color = :white)
+        puts colorize(color, message) if enabled
+      end
+
+      def error(message)
+        puts colorize(:red, message)
       end
 
       def log_request(request)
-        log "Request:\n#{request.http_method.to_s.upcase} #{request.url}"
+        log "\nRequest:\n#{request.http_method.to_s.upcase} #{request.url}", :dark_gray
 
         if request.headers
           request.headers.each do |k,v|
-            log "#{k}: #{v.inspect}"
+            log "#{k}: #{v}", :dark_gray
           end
         end
 
-        if request.params
-          # log serialized_params
-          request.params.each do |k,v|
-            log "\t#{k}=#{v.inspect}"
-          end
-        end
-        log "\n"
+        log(request.body, :dark_gray) if request.body
       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}"
+        log "\nResponse:", :dark_gray
+        if response.original_request
+          log "URL: #{response.original_request.url}", :dark_gray
+        end
+        log "Status: #{response.status_code}", :dark_gray
+        response.headers.each do |k,v|
+          log "#{k}: #{v}", :dark_gray
+        end
+        log "\n#{response.body}", :dark_gray
+      end
+
+      def colorize(color, string)
+        return string unless simulator? # Only colorize in the simulator
+
+        code = {
+          red: 31,
+          dark_gray: 90,
+        }[color]
+
+        if code
+          "\e[#{code}m#{string}\e[0m"
+        else
+          string
+        end
+      end
+
+      # Copied from https://github.com/rubymotion/BubbleWrap/blob/8eaf99a0966f2b375e774f5940279a704c10ad29/motion/core/ios/device.rb#L46
+      def simulator?
+        @simulator_state ||= begin
+          if defined?(NSObject) # iOS
+            !NSBundle.mainBundle.bundlePath.start_with?('/var/')
+          else # android
+            false
+          end
         end
-        log "\n#{response.body}"
       end
     end
   end

data/lib/common/http/request.rb

@@ -1,14 +1,55 @@
 class Motion
   class HTTP
     class Request
-      attr_reader :http_method, :url, :headers, :params, :options
+      attr_reader :http_method, :url, :headers, :body, :options
 
-      def initialize(http_method, url, headers = nil, params = nil, options = nil)
+      def initialize(http_method, url, options = nil)
         @http_method = http_method
         @url = url
-        @headers = headers || Headers.new
-        @params = params
-        @options = options
+        @options = options ||= {}
+        @headers = @options.delete(:headers) || Headers.new
+        @body = @options.delete(:body)
+
+        if @options[:params]
+          @params = @options.delete(:params)
+          flatten_params!
+          encode_params!
+          @url = "#{url}?#{@params.map{|k,v|"#{k}=#{v}"}.join('&')}"
+
+        elsif @options[:form]
+          @headers['Content-Type'] ||= 'application/x-www-form-urlencoded'
+          @params = @options.delete(:form)
+          flatten_params!
+          encode_params!
+          @body = @params.map{|k,v|"#{k}=#{v}"}.join('&')
+
+        elsif @options[:json]
+          @headers['Content-Type'] ||= 'application/json; charset=utf-8'
+          @body = @options.delete(:json).to_json
+        end
+      end
+
+      def flatten_params!
+        new_params = {}
+        @params.each do |k,v|
+          if v.is_a? Hash
+            v.each do |nested_k, nested_v|
+              new_params["#{k}[#{nested_k}]"] = nested_v
+            end
+          else
+            new_params[k] = v
+          end
+        end
+        @params = new_params
+        flatten_params! if @params.any? {|k,v| v.is_a? Hash }
+      end
+
+      def encode_params!
+        new_params = {}
+        @params.each do |k,v|
+          new_params[ParamsEncoder.encode(k)] = ParamsEncoder.encode(v)
+        end
+        @params = new_params
       end
 
       def perform(&callback)

data/lib/common/http/response.rb

@@ -11,8 +11,19 @@ class Motion
       end
 
       def success?
-        return false unless status_code
-        status_code >= 200 && status_code < 300
+        status_code && (200..299) === status_code
+      end
+
+      def redirect?
+        status_code && (300..399) === status_code
+      end
+
+      def client_error?
+        status_code && (400..499) === status_code
+      end
+
+      def server_error?
+        status_code && (500..599) === status_code
       end
 
       def object

data/lib/motion-http.rb

@@ -12,9 +12,8 @@ Motion::Project::App.setup do |app|
   when :android
     require "motion-gradle"
     app.files.unshift(*Dir.glob(File.join(lib_dir_path, "android/**/*.rb")))
-    app.gradle do
-      dependency "com.squareup.okhttp3:okhttp:3.9.0"
-    end
+    app.permissions << :internet
+    app.gradle { dependency 'com.android.volley:volley:1.1.1' }
   when :ios, :tvos, :osx, :watchos, :'ios-extension'
     app.files.unshift(*Dir.glob(File.join(lib_dir_path, "cocoa/**/*.rb")))
   else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motion-http
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Andrew Havens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-15 00:00:00.000000000 Z
+date: 2019-03-28 00:00:00.000000000 Z
 dependencies: []
 description: A cross-platform HTTP client for RubyMotion that's quick and easy to
   use.
@@ -20,10 +20,14 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/android/adapter.rb
+- lib/android/base64.rb
 - lib/android/json.rb
+- lib/android/params_encoder.rb
+- lib/android/volley_request.rb
 - lib/cocoa/adapter.rb
-- lib/cocoa/form_data_serializer.rb
+- lib/cocoa/base64.rb
 - lib/cocoa/json.rb
+- lib/cocoa/params_encoder.rb
 - lib/common/http.rb
 - lib/common/http/client.rb
 - lib/common/http/headers.rb

data/lib/cocoa/form_data_serializer.rb

@@ -1,29 +0,0 @@
-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