motion-http 0.2.0 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a32a0271f1f711f5a11522c48894a06ea9e8924615d38bae2a235572f15d2135
-  data.tar.gz: 590d6d30eb2889d97f47ed0e072313eb93dd38eb3e6485f0f894e526869f6a79
+  metadata.gz: 6fdd9853db4edb1720e95dac2ab15074cfe361e21a8c80b940854d22a8c1fe38
+  data.tar.gz: eb9b3042d28b232921fd1adda2ece8e17fd4397a63bf6a7bdeaba0fcd045929a
 SHA512:
-  metadata.gz: a01adbafd00b594929e7b7f86de05e55ff60e1040db5e736247dcb5dca8f01d21804c54ae5ecca7f365a6181dfb030794acfb667a93694bf0a0da0cd4a17f0d4
-  data.tar.gz: 684d0b718b0d84c7e4222cc16c97f39b4bf875e43b752c7d3f72d9e6540b9cc2e938a690a4542678eb5bff4d89f6409197750a4c608df0a48c9e7a327794901f
+  metadata.gz: 1c151143736e9dc4ca7e9b4ace845ffec8a6deb1316fcfd083c0ec9ce1577d3f32b41059f27fe228d3161076a3b63bda26f514c2c4f0573d464f9a43088da9f8
+  data.tar.gz: 7f5525e0c1f1f7155feda2ef235ad8a124a34da785d180aa211d5c04e2dc8d5b355eea3abb912fd7af8a192f132bb06a38fcf66b9302ff1da9236ec51324b66b

data/README.md

@@ -6,9 +6,9 @@ Supported platforms:
 - iOS, macOS, tvOS, watchOS
 - Android
 
-On Android, this gem depends on the super popular [OkHttp](http://square.github.io/okhttp/) networking library.
+It makes use of the officially supported networking libraries provided by Apple and Google. The goal of this gem is to provide you with a stable alternative to using these libraries directly, using a syntax that is much easier to use.
 
-Please note that this library is still a work in progress. Please report bugs and suggestions for improvement!
+Please report any bugs or suggestions for improvement!
 
 ## Installation
 
@@ -19,27 +19,31 @@ Add this line to your application's Gemfile:
 And then execute:
 
     $ bundle
-    $ rake gradle:install # for Android apps
+    $ rake gradle:install # Android only
 
 ### iOS Specific Configuration
 
-If you will be making insecure HTTP requests (not HTTPS), you will need to explicitly allow insecure HTTP requests by adding this line to your app's configuration in your Rakefile:
+If you will be making insecure requests (not using HTTPS), you will need to explicitly allow insecure HTTP requests by adding this line to your app's configuration (in your `Rakefile`). You might want to do this if you are trying to access localhost in development.
 
-    app.info_plist['NSAppTransportSecurity'] = { 'NSAllowsArbitraryLoads' => true }
+```ruby
+app.development do
+  app.info_plist['NSAppTransportSecurity'] = { 'NSAllowsArbitraryLoads' => true }
+end
+```
 
 ## 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 either make one-off requests or create a reusable API client for further customization.
 
-### Simple Usage
+### Basic Usage
 
 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 +56,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 +89,38 @@ 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. The default is `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:
+#### POST Requests
+
+When making a `POST` request, specifying the request body is easy:
 ```ruby
-json = { widget: { name: "Foobar" } }
-HTTP.post("http://www.example.com/widgets", json) do |response|
+HTTP.post("http://www.example.com/endpoint", body: raw_request_body) do |response|
+  # ...
+end
+```
+
+Specify the `:form` option and it will automatically be encoded as `application/x-www-form-urlencoded` request body:
+```ruby
+HTTP.post("http://www.example.com/login", form: { user: 'andrew', password: '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 +131,24 @@ HTTP.post("http://www.example.com/widgets", json) do |response|
 end
 ```
 
-`PUT`, `PATCH`, and `DELETE` requests work the same way:
+To specify request specific headers, use the `:headers` option. This overrides any previously set headers. In this example, we override the default JSON content type:
 ```ruby
-HTTP.put(url, params) { ... }
-HTTP.patch(url, params) { ... }
-HTTP.delete(url, params) { ... }
+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, options) { ... }
+HTTP.patch(url, options) { ... }
+HTTP.delete(url, options) { ... }
+HTTP.head(url, options) { ... }
+HTTP.options(url, options) { ... }
+HTTP.trace(url, options) { ... }
 ```
 
 ### Advanced Usage
@@ -117,6 +159,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 +168,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 +178,41 @@ 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
+
+Logging is disabled by default. To enable logging:
+
+```
+HTTP.logger.enable!
+```
+
+To disable it again:
+
+```
+HTTP.logger.disable!
+```
+
 ## Contributing
 
 1. Fork it
@@ -143,12 +221,37 @@ end
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
-## MIT License
+## License
 
-Copyright 2018 Andrew Havens
+Copyright 2018-2019 Andrew Havens
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Parts of the source are under the following license:
+
+Copyright (c) 2015-2016, HipByte (info@hipbyte.com) and contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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,36 @@
+# Copyright (c) 2015-2016, HipByte (info@hipbyte.com) and contributors.
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met: 
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer. 
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution. 
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# 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,29 @@
+# Copyright (c) 2015-2016, HipByte (info@hipbyte.com) and contributors.
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met: 
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer. 
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution. 
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 # 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,23 @@ 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
+            if @request.body.is_a?(NSData)
+              body_data = @request.body
+            else
+              body_data = NSString.alloc.initWithString(@request.body).dataUsingEncoding(NSUTF8StringEncoding)
+            end
+            ns_url_request.HTTPBody = body_data
+          end
+
           # TODO: add other headers
           ns_url_request
         end

data/lib/cocoa/base64.rb

@@ -0,0 +1,35 @@
+# Copyright (c) 2015-2016, HipByte (info@hipbyte.com) and contributors.
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met: 
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer. 
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution. 
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# 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/json.rb

@@ -1,3 +1,27 @@
+# Copyright (c) 2015-2016, HipByte (info@hipbyte.com) and contributors.
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met: 
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer. 
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution. 
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Copied from https://github.com/HipByte/Flow/blob/44283b31a63bc826d2c068557b6357dc1195680b/flow/json/cocoa/json.rb
 class JSON
   def self.parse(json_string)
     error_ptr = Pointer.new(:id)

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/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,37 +1,56 @@
 class Motion
   class HTTP
     class Logger
-      def log(message)
-        puts message # TODO: add option to enable/disable logging
+      attr_reader :enabled
+
+      def initialize
+        @enabled = false # logging is disabled by default
       end
 
-      def log_request(request)
-        log "Request:\n#{request.http_method.to_s.upcase} #{request.url}"
+      def enable!
+        @enabled = true
+      end
 
-        if request.headers
-          request.headers.each do |k,v|
-            log "#{k}: #{v.inspect}"
-          end
-        end
+      def disable!
+        @enabled = false
+      end
+
+      def _logger
+        @_logger ||= Motion::Lager.new
+      end
+
+      def debug(message, color = :gray)
+        _logger.debug(message, color) if enabled
+      end
+
+      def log(message, color = :white)
+        _logger.log(message, color) if enabled
+      end
+
+      def error(message, color = :red)
+        _logger.error(message, color) # always log even if logging is disabled
+      end
 
-        if request.params
-          # log serialized_params
-          request.params.each do |k,v|
-            log "\t#{k}=#{v.inspect}"
-          end
+      def log_request(request)
+        debug "\nRequest:\n#{request.http_method.to_s.upcase} #{request.url}"
+        request.headers.each do |k,v|
+          debug "#{k}: #{v}"
         end
-        log "\n"
+        debug(request.body) 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}"
+        debug "\nResponse:"
+        if response.original_request
+          debug "URL: #{response.original_request.url}"
         end
-        log "\n#{response.body}"
+        debug "Status: #{response.status_code}"
+        response.headers.each do |k,v|
+          debug "#{k}: #{v}"
+        end
+        debug("\n#{response.body}")
       end
+
     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/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/motion-http.rb

@@ -4,6 +4,8 @@ unless defined?(Motion::Project::Config)
   raise "This gem is only intended to be used in a RubyMotion project."
 end
 
+require 'motion-lager'
+
 lib_dir_path = File.dirname(File.expand_path(__FILE__))
 Motion::Project::App.setup do |app|
   app.files.unshift(*Dir.glob(File.join(lib_dir_path, "common/**/*.rb")))
@@ -12,9 +14,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,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: motion-http
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.3
 platform: ruby
 authors:
 - Andrew Havens
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-03-15 00:00:00.000000000 Z
-dependencies: []
+date: 2021-10-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: motion-lager
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A cross-platform HTTP client for RubyMotion that's quick and easy to
   use.
 email:
@@ -20,10 +34,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
@@ -31,11 +49,11 @@ files:
 - lib/common/http/request.rb
 - lib/common/http/response.rb
 - lib/motion-http.rb
-homepage: https://github.com/andrewhavens/motion-http
+homepage: https://github.com/rubymotion-community/motion-http
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -50,9 +68,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: A cross-platform HTTP client for RubyMotion that's quick and easy to use.
 test_files: []

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