motion-http 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ee2f69f478379a7838d88c114210624948da74f8
+  data.tar.gz: d5ac4b833aec97568819341f555a07ef48507fb3
+SHA512:
+  metadata.gz: 32c6a1ade57a803e9a99416d6591d9b6afc510d3dbe06edba804c4f5c35cbe8b36f27282c718ed7231bfb0af22a98984831eba9c7256da2571310dc03a83f62a
+  data.tar.gz: ca7d792bb704dcd23da1d1454c138f426eadeb1fba2003750243b053a8df07b9cd2a94494283d58fae2b2b8dde1789b36e3411412e1de4cdcfabb3de78ea820b

data/README.md

@@ -0,0 +1,125 @@
+# motion-http
+
+Motion::HTTP is a cross-platform HTTP Client for RubyMotion that's quick and easy to use.
+
+Supported platforms:
+- iOS, macOS, tvOS, watchOS
+- Android
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'motion-http'
+
+And then execute:
+
+    $ bundle
+    $ rake pod:install # for iOS apps
+    $ rake gradle:install # for Android apps
+
+## 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.
+
+### Simple Usage
+
+The basic syntax for a simple request looks like this:
+```ruby
+Motion::HTTP.method(url, params) do |response|
+  # this block will be called asynchronously
+end
+```
+
+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}"
+  if response.success?
+    puts "Success!"
+  else
+    puts "Oops! Something went wrong."
+  end
+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|
+  # ...
+end
+```
+
+`Motion::HTTP` will automatically parse JSON responses:
+```ruby
+Motion::HTTP.get("http://api.example.com/people.json") do |response|
+  if response.success?
+    response.object["people"].each do |person|
+      puts "name: #{person["name"]}"
+    end
+  else
+    puts "Error: #{response.object["errors"]}"
+  end
+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|
+  if response.success?
+    puts "Widget created!"
+  elsif response.client_error?
+    puts "Oops, you did something wrong: #{response.object["error_message"]}"
+  else
+    puts "Oops! Something else 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)
+```
+
+### Advanced Usage
+
+A common use case is to create a reusable HTTP client that uses a common base URL or request headers.
+
+```ruby
+client = Motion::HTTPClient.new("http://www.example.com")
+# Set or replace a header
+client.header "X-API-TOKEN", "abc123xyz"
+# It is valid for some headers to appear multiple times (Accept, Vary, etc).
+# Use add_header to append multiple headers of the same name.
+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.
+```ruby
+client.get("/people") do |response|
+  # ...
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## MIT License
+
+Copyright 2018 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.

data/lib/android/adapter.rb

@@ -0,0 +1,59 @@
+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.request(http_method, url, headers, params = nil, &callback)
+        puts "starting #{http_method.to_s.upcase} #{url}"
+        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(callback))
+      end
+
+      class OkhttpCallback
+        def initialize(callback)
+          @callback = callback
+        end
+
+        def onFailure(call, e)
+          puts "Error: #{e.getMessage}"
+          @callback.call(Response.new(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
+          body_string = response.body.string
+          json = JSON.load(body_string) if headers['content-type'] =~ /application\/json/
+          Response.new(response.code, headers, body_string, json)
+        end
+      end
+    end
+  end
+end

data/lib/android/json.rb

@@ -0,0 +1,36 @@
+# NOTE: Copied from https://github.com/HipByte/Flow/blob/master/flow/json/android/json.rb
+class JSON
+  def self.load(str)
+    tok = Org::JSON::JSONTokener.new(str)
+    obj = tok.nextValue
+    if obj == nil
+      raise "Can't deserialize object from JSON"
+    end
+
+    # Transform pure-Java JSON objects to Ruby types.
+    convert_java(obj)
+  end
+
+  def self.convert_java(obj)
+    case obj
+      when Org::JSON::JSONArray
+        obj.length.times.map { |i| convert_java(obj.get(i)) }
+      when Org::JSON::JSONObject
+        iter = obj.keys
+        hash = Hash.new
+        loop do
+          break unless iter.hasNext
+          key = iter.next
+          value = obj.get(key)
+          hash[convert_java(key)] = convert_java(value)
+        end
+        hash
+      when Java::Lang::String
+        obj.to_s
+      when Org::JSON::JSONObject::NULL
+        nil
+      else
+        obj
+    end
+  end
+end

data/lib/cocoa/adapter.rb

@@ -0,0 +1,45 @@
+class Motion
+  class HTTP
+    class Adapter
+      def self.manager
+        @manager ||= AFHTTPSessionManager.manager
+      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))
+        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)
+          )
+        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
+        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)
+      end
+    end
+  end
+end

data/lib/common/http.rb

@@ -0,0 +1,36 @@
+class Motion
+  class HTTP
+    class << self
+      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)
+      #   end
+      # end
+
+      def get(url, params = nil, &callback)
+        client.get(url, params, &callback)
+      end
+
+      def post(url, params = nil, &callback)
+        client.post(url, params, &callback)
+      end
+
+      def put(url, params = nil, &callback)
+        client.put(url, params, &callback)
+      end
+
+      def patch(url, params = nil, &callback)
+        client.patch(url, params, &callback)
+      end
+
+      def delete(url, params = nil, &callback)
+        client.delete(url, params, &callback)
+      end
+    end
+  end
+end

data/lib/common/http/client.rb

@@ -0,0 +1,35 @@
+class Motion
+  class HTTP
+    class Client
+      attr_reader :base_url, :headers
+
+      def initialize(base_url = nil)
+        @base_url = base_url || ""
+        @headers = Headers.new
+      end
+
+      def header(key, value)
+        headers.set(key, value)
+      end
+
+      def add_header(key, value)
+        headers.add(key, value)
+      end
+
+      # FIXME: doesn't work on Android
+      # [: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
+      #   end
+      # end
+
+      def get(path, params = nil, &callback)
+        Request.new(:get, base_url + path, headers, params, &callback).call
+      end
+
+      def post(path, params = nil, &callback)
+        Request.new(:post, base_url + path, headers, params, &callback).call
+      end
+    end
+  end
+end

data/lib/common/http/headers.rb

@@ -0,0 +1,29 @@
+class Motion
+  class HTTP
+    class Headers
+      def initialize(headers = {})
+        @headers = headers
+      end
+
+      def set(key, value)
+        @headers[key.downcase] = value
+      end
+
+      def add(key, value)
+        key = key.downcase
+        if @headers[key] && !@headers[key].is_a?(Array)
+          @headers[key] = [@headers[key]]
+        end
+        @headers[key] << value
+      end
+
+      def each(&block)
+        @headers.each(&block)
+      end
+
+      def [](key)
+        @headers[key.downcase]
+      end
+    end
+  end
+end

data/lib/common/http/request.rb

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

data/lib/common/http/response.rb

@@ -0,0 +1,23 @@
+class Motion
+  class HTTP
+    class Response
+      attr_reader :status_code, :headers, :body, :object
+
+      def initialize(status_code, headers, body_string, body_object = nil)
+        @status_code = status_code
+        @headers = headers
+        @body = body_string
+        @object = body_object
+      end
+
+      def success?
+        return false unless status_code
+        status_code >= 200 && status_code < 300
+      end
+
+      def inspect
+        "<Motion::HTTP::Response status_code:#{status_code} headers:<#{headers.class}> body:<#{body.class}>>"
+      end
+    end
+  end
+end

data/lib/motion-http.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+unless defined?(Motion::Project::Config)
+  raise "This gem is only intended to be used in a RubyMotion project."
+end
+
+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")))
+
+  case Motion::Project::App.template
+  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
+  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
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: motion-http
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Havens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-16 00:00:00.000000000 Z
+dependencies: []
+description: A cross-platform HTTP client for RubyMotion that's quick and easy to
+  use.
+email:
+- email@andrewhavens.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/android/adapter.rb
+- lib/android/json.rb
+- lib/cocoa/adapter.rb
+- lib/common/http.rb
+- lib/common/http/client.rb
+- lib/common/http/headers.rb
+- lib/common/http/request.rb
+- lib/common/http/response.rb
+- lib/motion-http.rb
+homepage: https://github.com/andrewhavens/motion-http
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: A cross-platform HTTP client for RubyMotion that's quick and easy to use.
+test_files: []