bubble-wrap-http 1.6.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aefaa21254b706e9bfc9fae4fb19435f0ef526bd
+  data.tar.gz: 662e834e0a96c3b04e919beed10f108898a7a49f
+SHA512:
+  metadata.gz: d3d5ae993ee8cd50cbcd539eb501ca53dd82ea0d135500488380ba1f101ee40091de9c3855633c386fb0772e551be237ba8ee6f4e755bddcdf9f031ce8061293
+  data.tar.gz: e133ca52ac112ef4c12ea92d732b663c73066c9910999b798f8cbabab6bfb823d13417bc1fc985a064d183a175dfbcdb336c76b16b5f5ddfd9fcd84955fc3567

data/README.md

@@ -0,0 +1,129 @@
+# BubbleWrap::HTTP
+
+[![Build Status](https://travis-ci.org/rubymotion/BubbleWrap-HTTP.svg?branch=master)](https://travis-ci.org/rubymotion/BubbleWrap-HTTP)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```
+gem 'bubble-wrap-http'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+gem install bubble-wrap-http
+```
+
+## Usage
+
+`BubbleWrap::HTTP` wraps `NSURLRequest`, `NSURLConnection` and friends to provide Ruby developers with a more familiar and easier to use API.
+The API uses async calls and blocks to stay as simple as possible.
+
+To enable it add the following require line to your `Rakefile`:
+```ruby
+require 'bubble-wrap-http'
+```
+
+Usage example:
+
+```ruby
+BubbleWrap::HTTP.get("https://api.github.com/users/mattetti") do |response|
+  p response.body.to_str
+end
+```
+
+```ruby
+BubbleWrap::HTTP.get("https://api.github.com/users/mattetti", {credentials: {username: 'matt', password: 'aimonetti'}}) do |response|
+  p response.body.to_str # prints the response's body
+end
+```
+
+```ruby
+data = {first_name: 'Matt', last_name: 'Aimonetti'}
+BubbleWrap::HTTP.post("http://foo.bar.com/", {payload: data}) do |response|
+  if response.ok?
+    json = BW::JSON.parse(response.body.to_str)
+    p json['id']
+  elsif response.status_code.to_s =~ /40\d/
+    App.alert("Login failed")
+  else
+    App.alert(response.error_message)
+  end
+end
+```
+
+To upload files to a server, provide a `files:` hash:
+
+```ruby
+data = {token: "some-api-token"}
+avatar_data = UIImagePNGRepresentation(UIImage.imageNamed("some-image"))
+avatar = { data: avatar_data, filename: "some-image.png", content_type: "image/png" }
+
+BubbleWrap::HTTP.post("http://foo.bar.com/", {payload: data}, files: { avatar: avatar }) do |response|
+  if response.ok?
+    # files are uploaded
+  end
+end
+```
+
+A `:download_progress` option can also be passed. The expected object
+would be a Proc that takes two arguments: a float representing the
+amount of data currently received and another float representing the
+total amount of data expected.
+
+Connections can also be cancelled. Just keep a refrence,
+
+```ruby
+@conn = BubbleWrap::HTTP.get("https://api.github.com/users/mattetti") do |response|
+  p response.body.to_str
+end
+```
+
+and send the `cancel` method to it asynchronously as desired. The block will not be executed.
+
+```ruby
+@conn.cancel
+```
+
+### Gotchas
+
+Because of how RubyMotion currently works, you sometimes need to assign objects as `@instance_variables` in order to retain their callbacks.
+
+For example:
+
+```ruby
+class HttpClient
+  def get_user(user_id, &callback)
+    BubbleWrap::HTTP.get(user_url(user_id)) do |response|
+      # ..
+    end
+  end
+end
+```
+
+This class should be invoked in your code as:
+
+```ruby
+@http_client = HttpClient.new
+@http_client.get_user(user_id) do |user|
+  # ..
+end
+```
+
+(instead of doing an instance-variable-less `HttpClient.new.get_user`)
+
+## 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

data/lib/bubble-wrap-http.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+lib_dir_path = File.expand_path(File.join(File.dirname(File.expand_path(__FILE__)), '..'))
+Motion::Project::App.setup do |app|
+  app.files.unshift(Dir.glob(File.join(lib_dir_path, "motion/**/*.rb")))
+end

data/motion/http.rb

@@ -0,0 +1,101 @@
+module BubbleWrap
+
+  # The HTTP module provides a simple interface to make HTTP requests.
+  #
+  # TODO: preflight support, easier/better cookie support, better error handling
+  module HTTP
+
+    # Make a GET request and process the response asynchronously via a block.
+    #
+    # @examples
+    #  # Simple GET request printing the body
+    #   BubbleWrap::HTTP.get("https://api.github.com/users/mattetti") do |response|
+    #     p response.body.to_str
+    #   end
+    #
+    #  # GET request with basic auth credentials
+    #   BubbleWrap::HTTP.get("https://api.github.com/users/mattetti", {credentials: {username: 'matt', password: 'aimonetti'}}) do |response|
+    #     p response.body.to_str # prints the response's body
+    #   end
+    #
+
+    [:get, :post, :put, :delete, :head, :options, :patch].each do |http_verb|
+
+      define_singleton_method(http_verb) do |url, options = {}, &block|
+        options[:action] = block if block
+        HTTP::Query.new(url, http_verb, options)
+      end
+
+    end
+
+    module Patch
+      module_function
+      def use_weak_callbacks?
+        if BubbleWrap.respond_to?("use_weak_callbacks?")
+          return BubbleWrap.use_weak_callbacks?
+        end
+        true
+      end
+
+      def ios?
+        Kernel.const_defined?(:UIApplication)
+      end
+
+      def osx?
+        Kernel.const_defined?(:NSApplication)
+      end
+
+      def debug?
+        if BubbleWrap.respond_to?("debug?")
+          return BubbleWrap.debug?
+        end
+        false
+      end
+
+      def create_uuid
+        uuid = CFUUIDCreate(nil)
+        CFUUIDCreateString(nil, uuid)
+      end
+
+      module JSON
+        module_function
+        def generate(obj)
+          NSJSONSerialization.dataWithJSONObject(obj, options:0, error:nil).to_str
+        end
+
+        def parse(str_data, &block)
+          return nil unless str_data
+          data = str_data.respond_to?(:to_data) ? str_data.to_data : str_data
+          opts = NSJSONReadingMutableContainers | NSJSONReadingMutableLeaves | NSJSONReadingAllowFragments
+          error = Pointer.new(:id)
+          obj = NSJSONSerialization.JSONObjectWithData(data, options:opts, error:error)
+          raise ParserError, error[0].description if error[0]
+          if block_given?
+            yield obj
+          else 
+            obj
+          end
+        end
+      end
+
+      module NetworkIndicator
+        module_function
+        def show
+          if BubbleWrap.const_defined?("NetworkIndicator")
+            BubbleWrap::NetworkIndicator.show
+          end
+        end
+
+        def hide
+          if BubbleWrap.const_defined?("NetworkIndicator")
+            BubbleWrap::NetworkIndicator.hide
+          end
+        end
+      end
+    end
+
+  end
+end
+
+class InvalidURLError < StandardError; end
+class InvalidFileError < StandardError; end

data/motion/http/query.rb

@@ -0,0 +1,412 @@
+# Class wrapping NSConnection and often used indirectly by the BubbleWrap::HTTP module methods.
+module BubbleWrap; module HTTP; class Query
+  attr_accessor :request
+  attr_accessor :connection
+  attr_accessor :credentials # username & password has a hash
+  attr_accessor :proxy_credential # credential supplied to proxy servers
+  attr_accessor :post_data
+  attr_reader   :method
+
+  attr_reader :response
+  attr_reader :status_code
+  attr_reader :response_headers
+  attr_reader :response_size
+  attr_reader :options
+  CLRF = "\r\n"
+  # ==== Parameters
+  # url<String>:: url of the resource to download
+  # http_method<Symbol>:: Value representing the HTTP method to use
+  # options<Hash>:: optional options used for the query
+  #
+  # ==== Options
+  # :payload<String>   - data to pass to a POST, PUT, DELETE query.
+  # :action            - Proc, class or object to call when the file is downloaded.
+  # a proc will receive a Response object while the passed object
+  # will receive the handle_query_response method
+  # :headers<Hash>     - headers send with the request
+  # :cookies<Boolean>  - Set whether cookies should be sent with request or not (Default: true)
+  # Anything else will be available via the options attribute reader.
+  #
+  def initialize(url_string, http_method = :get, options={})
+    @method = http_method.upcase.to_s
+    @delegator = options.delete(:action) || self
+    if @delegator.respond_to?("weak!")
+      @delegator.weak! if BubbleWrap::HTTP::Patch.use_weak_callbacks?
+    end
+
+    @payload = options.delete(:payload)
+    @encoding = options.delete(:encoding) || NSUTF8StringEncoding
+    @files = options.delete(:files)
+    @boundary = options.delete(:boundary) || BubbleWrap::HTTP::Patch.create_uuid
+    @credentials = options.delete(:credentials) || {}
+    @credentials = {:username => nil, :password => nil}.merge(@credentials)
+    @timeout = options.delete(:timeout) || 30.0
+    @headers = escape_line_feeds(options.delete :headers)
+    @format = options.delete(:format)
+    @cache_policy = options.delete(:cache_policy) || NSURLRequestUseProtocolCachePolicy
+    @credential_persistence = options.delete(:credential_persistence) || NSURLCredentialPersistenceForSession
+    @cookies = options.key?(:cookies) ? options.delete(:cookies) : true
+    @options = options
+    @response = BubbleWrap::HTTP::Response.new
+    @follow_urls = options[:follow_urls] || true
+    @present_credentials = options[:present_credentials] == nil ? true : options.delete(:present_credentials)
+
+    @url = create_url(url_string)
+    @body = create_request_body
+    @request = create_request
+    @original_url = @url.copy
+
+    @connection = create_connection(request, self)
+    @connection.scheduleInRunLoop(NSRunLoop.currentRunLoop, forMode:NSRunLoopCommonModes)
+    @connection.start
+
+    show_status_indicator true
+  end
+
+  def to_s
+    "#<#{self.class}:#{self.object_id} - Method: #{@method}, url: #{@url.description}, body: #{@body.description}, Payload: #{@payload}, Headers: #{@headers} Credentials: #{@credentials}, Timeout: #{@timeout}, \
+Cache policy: #{@cache_policy}, response: #{@response.inspect} >"
+  end
+  alias description to_s
+
+  def done?
+    @did_fail_error || @did_finish_loading || @canceled
+  end
+
+  def connection(connection, didReceiveResponse:response)
+    # On OSX, if using an FTP connection, this method will fire *immediately* after creating an
+    # NSURLConnection, even if the connection has not yet started. The `response`
+    # object will be a NSURLResponse, *not* an `NSHTTPURLResponse`, and so will start to crash.
+    if BubbleWrap::HTTP::Patch.osx? && !response.is_a?(NSHTTPURLResponse)
+      return
+    end
+    did_receive_response(response)
+  end
+
+  # This delegate method get called every time a chunk of data is being received
+  def connection(connection, didReceiveData:received_data)
+    @received_data ||= NSMutableData.new
+    @received_data.appendData(received_data)
+
+    if download_progress = options[:download_progress]
+      download_progress.call(@received_data.length.to_f, response_size)
+    end
+  end
+
+  def connection(connection, willSendRequest:request, redirectResponse:redirect_response)
+    # abort early if the user has explicitly disabled redirects
+    if @options[:no_redirect] and redirect_response then
+      return nil
+    end
+    @redirect_count ||= 0
+    @redirect_count += 1
+    log "##{@redirect_count} HTTP redirect_count: #{request.inspect} - #{self.description}"
+
+    if @redirect_count >= 30
+      error = NSError.errorWithDomain('BubbleWrap::HTTP', code:NSURLErrorHTTPTooManyRedirects,
+                                                userInfo:NSDictionary.dictionaryWithObject("Too many redirections",
+                                                                                           forKey: NSLocalizedDescriptionKey))
+      self.connection(connection, didFailWithError: error)
+      nil
+    else
+      @url = request.URL if @follow_urls
+      request
+    end
+  end
+
+  def connection(connection, didFailWithError: error)
+    return if done?
+
+    @did_fail_error = error
+    log "HTTP Connection to #{@url.absoluteString} failed #{error.localizedDescription}"
+    show_status_indicator false
+    @request.done_loading!
+    @response.error = error
+    @response.error_message = error.localizedDescription
+    call_delegator_with_response
+  end
+
+  def connection(connection, didSendBodyData:sending, totalBytesWritten:written, totalBytesExpectedToWrite:expected)
+    if upload_progress = options[:upload_progress]
+      upload_progress.call(sending, written, expected)
+    end
+  end
+
+  def connectionDidFinishLoading(connection)
+    return if done?
+    @did_finish_loading = true
+
+    show_status_indicator false
+    @request.done_loading!
+    response_body = NSData.dataWithData(@received_data) if @received_data
+    @response.update(status_code: status_code, body: response_body, headers: response_headers, url: @url, original_url: @original_url)
+
+    call_delegator_with_response
+  end
+
+  def connection(connection, didReceiveAuthenticationChallenge:challenge)
+    if (challenge.previousFailureCount == 0)
+      if credentials[:username].to_s.empty? && credentials[:password].to_s.empty?
+        challenge.sender.continueWithoutCredentialForAuthenticationChallenge(challenge)
+        log 'Continue without credentials to get 401 status in response'
+      else
+        new_credential = NSURLCredential.credentialWithUser(credentials[:username], password:credentials[:password], persistence:@credential_persistence)
+        challenge.sender.useCredential(new_credential, forAuthenticationChallenge:challenge)
+        log "auth challenged, answered with credentials: #{credentials.inspect}"
+      end
+    else
+      did_receive_response(challenge.failureResponse)
+      @response.update(status_code: status_code, headers: response_headers, url: @url, original_url: @original_url)
+      challenge.sender.cancelAuthenticationChallenge(challenge)
+      log 'Auth Failed :('
+    end
+  end
+
+  def cancel
+    return if done?
+    @canceled = true
+
+    @connection.cancel
+    show_status_indicator false
+    @request.done_loading!
+  end
+
+  private
+
+  def did_receive_response(response)
+    @status_code = response.statusCode
+    @response_headers = response.allHeaderFields
+    @response_size = response.expectedContentLength.to_f
+  end
+
+  def show_status_indicator(show)
+    if BubbleWrap::HTTP::Patch.ios? && (@status.nil? || @status != !!show)
+      @status = !!show
+      if show
+        BubbleWrap::HTTP::Patch::NetworkIndicator.show
+      else
+        BubbleWrap::HTTP::Patch::NetworkIndicator.hide
+      end
+    end
+  end
+
+  def create_request
+    log "BubbleWrap::HTTP building a NSRequest for #{@url.description}"
+
+    request = NSMutableURLRequest.requestWithURL(@url,
+                                                  cachePolicy:@cache_policy,
+                                                  timeoutInterval:@timeout)
+    request.setHTTPMethod(@method)
+    set_content_type
+    append_auth_header
+    request.setAllHTTPHeaderFields(@headers)
+    request.setHTTPBody(@body)
+    request.setHTTPShouldHandleCookies(@cookies)
+    patch_nsurl_request(request)
+
+    request
+  end
+
+  def set_content_type
+    return if headers_provided?
+    return if (@method == "GET" || @method == "HEAD" || @method == "OPTIONS")
+    @headers ||= {}
+    @headers["Content-Type"] = case @format
+    when :json
+      "application/json"
+    when :xml
+      "application/xml"
+    when :text
+      "text/plain"
+    else
+      if @format == :form_data || @payload_or_files_were_appended
+        "multipart/form-data; boundary=#{@boundary}"
+      else
+        "application/x-www-form-urlencoded"
+      end
+    end
+  end
+
+  def headers_provided?
+    @headers && @headers.keys.find {|k| k.downcase == 'content-type'}
+  end
+
+  def credentials_provided?
+    @credentials[:username] && @credentials[:password]
+  end
+
+  def create_request_body
+    return nil if (@method == "GET" || @method == "HEAD" || @method == "OPTIONS")
+    return nil unless (@payload || @files)
+
+    body = NSMutableData.data
+
+    append_payload(body) if @payload
+    append_files(body) if @files
+    append_body_boundary(body) if @payload_or_files_were_appended
+
+    log "Built HTTP body: \n #{body.to_str}"
+    body
+  end
+
+  def append_payload(body)
+    if @payload.is_a?(NSData)
+      body.appendData(@payload)
+    elsif @payload.is_a?(String)
+      body.appendData encode_to_data(@payload, @encoding)
+    elsif @format == :json
+      json_string = BubbleWrap::HTTP::Patch::JSON.generate(@payload)
+      body.appendData encode_to_data(json_string, @encoding)
+    else
+      append_form_params(body)
+    end
+    body
+  end
+
+  def append_form_params(body)
+    list = process_payload_hash(@payload)
+    list.each do |key, value|
+      s = "--#{@boundary}\r\n"
+      s += "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n"
+      s += value.to_s
+      s += "\r\n"
+      body.appendData encode_to_data(s, @encoding)
+    end
+    @payload_or_files_were_appended = true
+    body
+  end
+
+  def append_auth_header
+    return if @headers && @headers["Authorization"]
+
+    if credentials_provided? && @present_credentials
+      mock_request = CFHTTPMessageCreateRequest(nil, nil, nil, nil)
+      CFHTTPMessageAddAuthentication(mock_request, nil, @credentials[:username], @credentials[:password], KCFHTTPAuthenticationSchemeBasic, false)
+
+      @headers ||= {}
+      @headers["Authorization"] = CFHTTPMessageCopyHeaderFieldValue(mock_request, "Authorization")
+    end
+  end
+
+  def parse_file(key, value)
+    value = {data: value} unless value.is_a?(Hash)
+    raise(InvalidFileError, "You need to supply a `:data` entry in #{value} for file '#{key}' in your HTTP `:files`") if value[:data].nil?
+    {
+      data: value[:data],
+      filename: value.fetch(:filename, key),
+      content_type: value.fetch(:content_type, "application/octet-stream")
+    }
+  end
+
+  def append_files(body)
+    @files.each do |key, value|
+      file = parse_file(key, value)
+      s = "--#{@boundary}\r\n"
+      s += "Content-Disposition: attachment; name=\"#{key}\"; filename=\"#{file[:filename]}\"\r\n"
+      s += "Content-Type: #{file[:content_type]}\r\n\r\n"
+      file_data = NSMutableData.new
+      file_data.appendData encode_to_data(s, @encoding)
+      file_data.appendData(file[:data])
+      file_data.appendData encode_to_data("\r\n", @encoding)
+      body.appendData(file_data)
+    end
+    @payload_or_files_were_appended = true
+    body
+  end
+
+  def append_body_boundary(body)
+    body.appendData encode_to_data("--#{@boundary}--\r\n", @encoding)
+  end
+
+  def create_url(url_string)
+    url_string = url_string.stringByAddingPercentEscapesUsingEncoding NSUTF8StringEncoding
+    if (@method == "GET" || @method == "HEAD" || @method == "OPTIONS") && @payload
+      unless @payload.empty?
+        convert_payload_to_url if @payload.is_a?(Hash)
+        url_string += "?#{@payload}"
+      end
+    end
+    url = NSURL.URLWithString(url_string)
+
+    validate_url(url)
+    url
+  end
+
+  def validate_url(url)
+    if !NSURLConnection.canHandleRequest(NSURLRequest.requestWithURL(url))
+      raise InvalidURLError, "Invalid URL provided (Make sure you include a valid URL scheme, e.g. http:// or similar)."
+    end
+  end
+
+  def escape(string)
+    string_to_escape = string.to_s
+    if string_to_escape
+      CFURLCreateStringByAddingPercentEscapes nil, string_to_escape, nil, "!*'();:@&=+$,/?%#[]", KCFStringEncodingUTF8
+    end
+  end
+
+  def convert_payload_to_url
+    params_array = process_payload_hash(@payload)
+    params_array.map! { |key, value| "#{escape key}=#{escape value}" }
+    @payload = params_array.join("&")
+  end
+
+  def process_payload_hash(payload, prefix=nil)
+    list = []
+    payload.each do |k,v|
+      if v.is_a?(Hash)
+        new_prefix = prefix ? "#{prefix}[#{k.to_s}]" : k.to_s
+        param = process_payload_hash(v, new_prefix)
+        list += param
+      elsif v.is_a?(Array)
+        v.each do |val|
+          param = prefix ? "#{prefix}[#{k.to_s}][]" : "#{k.to_s}[]"
+          if val.is_a?(Hash)
+            list += process_payload_hash(val, param)
+          else
+            list << [param, val]
+          end
+        end
+      else
+        param = prefix ? "#{prefix}[#{k.to_s}]" : k.to_s
+        list << [param, v]
+      end
+    end
+    list
+  end
+
+  def log(message)
+    NSLog message if BubbleWrap::HTTP::Patch.debug?
+  end
+
+  def escape_line_feeds(hash)
+    return nil if hash.nil?
+    escaped_hash = {}
+
+    hash.each{|k,v| escaped_hash[k] = v.gsub("\n", CLRF) if v }
+    escaped_hash
+  end
+
+  def patch_nsurl_request(request)
+    request.instance_variable_set("@done_loading", false)
+
+    def request.done_loading?; @done_loading; end
+    def request.done_loading!; @done_loading = true; end
+  end
+
+  def call_delegator_with_response
+    if @delegator.respond_to?(:call)
+      @delegator.call( @response, self )
+    end
+  end
+
+  # This is a temporary method used for mocking.
+  def create_connection(request, delegate)
+    NSURLConnection.alloc.initWithRequest(request, delegate:delegate, startImmediately:false)
+  end
+
+  def encode_to_data(string, encoding)
+    string.dataUsingEncoding encoding
+  end
+
+end; end; end

data/motion/http/response.rb

@@ -0,0 +1,32 @@
+# Response class wrapping the results of a Query's response
+module BubbleWrap; module HTTP; class Response
+  attr_reader :body
+  attr_reader :headers
+  attr_accessor :status_code, :status_description, :error_message, :error
+  attr_reader :url
+  attr_reader :original_url
+
+  def initialize(values={})
+    self.update(values)
+  end
+
+  def update(values)
+    values.each do |k,v|
+      self.instance_variable_set("@#{k}", v)
+    end
+    update_status_description
+  end
+
+  def ok?
+    status_code.to_s =~ /2\d\d/ ? true : false
+  end
+
+  def to_s
+    "#<#{self.class}:#{self.object_id} - url: #{self.url}, body: #{self.body}, headers: #{self.headers}, status code: #{self.status_code}, error message: #{self.error_message} >"
+  end
+  alias description to_s
+
+  def update_status_description
+    @status_description = status_code.nil? ? nil : NSHTTPURLResponse.localizedStringForStatusCode(status_code)
+  end
+end; end; end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: bubble-wrap-http
+version: !ruby/object:Gem::Version
+  version: 1.6.0.rc1
+platform: ruby
+authors:
+- Matt Aimonetti
+- Francis Chong
+- James Harton
+- Clay Allsopp
+- Dylan Markow
+- Jan Weinkauff
+- Marin Usalj
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: BubbleWrap's deprecated HTTP library
+email:
+- mattaimonetti@gmail.com
+- francis@ignition.hk
+- james@sociable.co.nz
+- clay.allsopp@gmail.com
+- dylan@dylanmarkow.com
+- jan@dreimannzelt.de
+- mneorr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/bubble-wrap-http.rb
+- motion/http/query.rb
+- motion/http/response.rb
+- motion/http.rb
+homepage: https://github.com/rubymotion/BubbleWrap-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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: BubbleWrap's deprecated HTTP library
+test_files: []