google-api-client 0.4.7 → 0.5.0

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 0.5.0
+
+* Beta candidate, potential incompatible changes with how requests are processed. 
+    * All requests should be made using execute() or execute!()
+    * :api_method in request can no longer be a string
+    * Deprecated ResumableUpload.send_* methods.
+* Reduce memory utilization when uploading large files
+* Automatic refresh of OAuth 2 credentials & retry of request when 401 errors
+  are returned
+* Simplify internal request processing.
+
 # 0.4.7
 
 * Added the ability to convert client secrets to an authorization object

data/Gemfile

@@ -9,12 +9,17 @@ gem 'autoparse', '>= 0.3.2'
 gem 'faraday', '~> 0.8.1'
 gem 'multi_json', '>= 1.0.0'
 gem 'extlib', '>= 0.9.15'
+gem 'jwt', '~> 0.1.5'
 gem 'jruby-openssl', :platforms => :jruby
 
 group :development do
   gem 'launchy', '>= 2.1.1'
   gem 'yard'
-  gem 'redcarpet'
+  if File.exist?('/usr/bin/gcc-4.2')
+    # Not a critically important gem to have around.
+    # If it's not going to build, skip it.
+    gem 'redcarpet'
+  end
 end
 
 group :examples do

data/Gemfile.lock

@@ -0,0 +1,80 @@
+PATH
+  remote: .
+  specs:
+    google-api-client (0.5.0)
+      addressable (>= 2.3.2)
+      autoparse (>= 0.3.2)
+      extlib (>= 0.9.15)
+      faraday (~> 0.8.1)
+      jwt (>= 0.1.5)
+      launchy (>= 2.1.1)
+      multi_json (>= 1.0.0)
+      signet (>= 0.4.1)
+      uuidtools (>= 2.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.3.2)
+    autoparse (0.3.2)
+      addressable (>= 2.3.1)
+      extlib (>= 0.9.15)
+      multi_json (>= 1.0.0)
+    diff-lcs (1.1.3)
+    extlib (0.9.15)
+    faraday (0.8.4)
+      multipart-post (~> 1.1)
+    idn (0.0.2)
+    jwt (0.1.5)
+      multi_json (>= 1.0)
+    launchy (2.1.2)
+      addressable (~> 2.3)
+    multi_json (1.3.6)
+    multipart-post (1.1.5)
+    rack (1.4.1)
+    rack-protection (1.2.0)
+      rack
+    rake (0.9.2.2)
+    rcov (1.0.0)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+    signet (0.4.3)
+      addressable (>= 2.2.3)
+      faraday (~> 0.8.1)
+      jwt (>= 0.1.5)
+      multi_json (>= 1.0.0)
+    sinatra (1.3.3)
+      rack (~> 1.3, >= 1.3.6)
+      rack-protection (~> 1.2)
+      tilt (~> 1.3, >= 1.3.3)
+    tilt (1.3.3)
+    uuidtools (2.1.3)
+    yard (0.8.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  addressable (>= 2.3.2)
+  autoparse (>= 0.3.2)
+  extlib (>= 0.9.15)
+  faraday (~> 0.8.1)
+  google-api-client!
+  idn
+  jruby-openssl
+  jwt (~> 0.1.5)
+  launchy (>= 2.1.1)
+  multi_json (>= 1.0.0)
+  rake (>= 0.9.0)
+  rcov (>= 0.9.9)
+  rspec (>= 2.11.0)
+  signet (>= 0.4.1)
+  sinatra
+  uuidtools (>= 2.1.0)
+  yard

data/README.md

@@ -1,8 +1,8 @@
-# APIClient
+# Google API Client
 
 <dl>
   <dt>Homepage</dt><dd><a href="http://code.google.com/p/google-api-ruby-client">http://code.google.com/p/google-api-ruby-client</a></dd>
-  <dt>Author</dt><dd><a href="mailto:bobaman@google.com">Bob Aman</a></dd>
+  <dt>Authoris</dt><dd>Bob Aman, <a href="mailto:sbazyl@google.com">Steven Bazyl</a></dd>
   <dt>Copyright</dt><dd>Copyright © 2011 Google, Inc.</dd>
   <dt>License</dt><dd>Apache 2.0</dd>
 </dl>
@@ -10,62 +10,169 @@
 [![Build Status](https://secure.travis-ci.org/google/google-api-ruby-client.png)](http://travis-ci.org/google/google-api-ruby-client)
 [![Dependency Status](https://gemnasium.com/google/google-api-ruby-client.png)](https://gemnasium.com/google/google-api-ruby-client)
 
-# Description
+## Description
 
 The Google API Ruby Client makes it trivial to discover and access supported
 APIs.
 
-# Example Usage
+## Install
 
-    # Initialize the client
+Be sure `http://rubygems.org/` is in your gem sources.
+
+For normal client usage, this is sufficient:
+
+    $ sudo gem install google-api-client
+
+The command line interface, the example applications, and the test suite
+require additional dependencies. These may be obtained with:
+
+    $ sudo gem install google-api-client --development --force --no-rdoc --no-ri
+
+## Example Usage
+
+    # Initialize the client & Google+ API
     require 'google/api_client'
-    require 'signet/oauth_1/client'
-    client = Google::APIClient.new(
-      :service => 'buzz',
-      # Buzz has API-specific endpoints
-      :authorization => Signet::OAuth1::Client.new(
-        :temporary_credential_uri =>
-          'https://www.google.com/accounts/OAuthGetRequestToken',
-        :authorization_uri =>
-          'https://www.google.com/buzz/api/auth/OAuthAuthorizeToken',
-        :token_credential_uri =>
-          'https://www.google.com/accounts/OAuthGetAccessToken',
-        :client_credential_key => 'anonymous',
-        :client_credential_secret => 'anonymous'
-      )
-    )
-    client.authorization.fetch_temporary_credential!(
-      :additional_parameters => {
-        'scope' => 'https://www.googleapis.com/auth/buzz'
-      }
-    )
-    redirect_uri = client.authorization.authorization_uri(
-      :additional_parameters => {
-        'domain' => client.authorization.client_credential_key,
-        'scope' => 'https://www.googleapis.com/auth/buzz'
-      }
-    )
-    # Redirect user here
-    client.authorization.fetch_token_credential!(:verifier => '12345')
-    
-    # Discover available methods
-    method_names = client.discovered_api('plus').to_h.keys
+    client = Google::APIClient.new
+    plus = client.discovered_api('plus')
+
+    # Initialize OAuth 2.0 client    
+    client.authorization.client_id = '<CLIENT_ID_FROM_API_CONSOLE>'
+    client.authorization.client_secret = '<CLIENT_SECRET>'
+    client.authorization.redirect_uri = '<YOUR_REDIRECT_URI>'
     
+    client.authorization.scope = 'https://www.googleapis.com/auth/plus.me'
+
+    # Request authorization
+    redirect_uri = client.authorization.authorization_uri
+
+    # Wait for authorization code then exchange for token
+    client.authorization.code = '....'
+    client.authorization.fetch_access_token!
+
     # Make an API call
     result = client.execute(
-      'plus.activities.list',
-      {'collection' => 'public', 'userId' => 'me'}
+      :api_method => plus.activities.list,
+      :parameters => {'collection' => 'public', 'userId' => 'me'}
     )
 
-# Install
+    puts result.data
 
-Be sure `http://rubygems.org/` is in your gem sources.
+## API Features
 
-For normal client usage, this is sufficient:
+### API Discovery
+
+To take full advantage of the client, load API definitions prior to use. To load an API:
+
+    urlshortener = client.discovered_api('urlshortener')
+
+Specific versions of the API can be loaded as well:
+
+    drive = client.discovered_api('drive', 'v2')
+
+Locally cached discovery documents may be used as well. To load an API from a local file:
+
+    doc = File.read('my-api.json')
+    my_api = client.register_discovery_document('myapi', 'v1', doc)
+
+### Authorization
+
+Most interactions with Google APIs require users to authorize applications via OAuth 2.0. The client library uses [Signet](https://github.com/google/signet) to handle most aspects of authorization. For additional details about Google's OAuth support, see [Google Developers](https://developers.google.com/accounts/docs/OAuth2). 
+
+Credentials can be managed at the connection level, as shown, or supplied on a per-request basis when calling `execute`.
+    
+For server-to-server interactions, like those between a web application and Google Cloud Storage, Prediction, or BigQuery APIs, use service accounts. Assertions for service accounts are made with `Google::APIClient::JWTAsserter`.
+
+    client = Google::APIClient.new
+    key = Google::APIClient::PKCS12.load_key('client.p12', 'notasecret')
+    service_account = Google::APIClient::JWTAsserter(
+        '123456-abcdef@developer.gserviceaccount.com',
+        'https://www.googleapis.com/auth/prediction',
+        key)
+    client.authorization = service_account.authorize
+
+### Batching Requests
+
+Some Google APIs support batching requests into a single HTTP request. Use `Google::APIClient::BatchRequest`
+to bundle multiple requests together.
+
+Example:
+
+    client = Google::APIClient.new
+    urlshortener = client.discovered_api('urlshortner')
+    
+    batch = Google::APIClient::BatchRequest.new do |result|
+        puts result.data
+    end
+    
+    batch.add(:api_method=>urlshortener.url.insert, 
+              :body_object => { 'longUrl' => 'http://example.com/foo' })
+    batch.add(:api_method=>urlshortener.url.insert, 
+              :body_object => { 'longUrl' => 'http://example.com/bar' })
+    client.execute(batch)
+    
+Blocks for handling responses can be specified either at the batch level or when adding an individual API call. For example:
+
+    batch.add(:api_method=>urlshortener.url.insert, :body_object => { 'longUrl' => 'http://example.com/bar' }) do |result|
+       puts result.data
+    end
+
+### Media Upload
+
+For APIs that support file uploads, use `Google::APIClient::UploadIO` to load the stream. Both multipart and resumable
+uploads can be used. For example, to upload a file to Google Drive using multipart
+
+    drive = client.discovered_api('drive', 'v2')
+   
+    media = Google::APIClient::UploadIO.new('mymovie.m4v', 'video/mp4')
+    metadata = {
+        'title' => 'My movie',
+        'description' => 'The best home movie ever made'
+    }
+    client.execute(:api_method => drive.files.insert,
+                   :parameters => { 'uploadType' => 'multipart' },
+                   :body_object => metadata,
+                   :media => media )
+   
+To use resumable uploads, change the `uploadType` parameter to `resumable`. To check the status of the upload
+and continue if necessary, check `result.resumable_upload`.
+
+    client.execute(:api_method => drive.files.insert,
+               :parameters => { 'uploadType' => 'resumable' },
+               :body_object => metadata,
+               :media => media )
+    upload = result.resumable_upload
+
+    # Resume if needed
+    if upload.resumable?
+        client.execute(upload)
+    end
+
+## Command Line
+
+Included with the gem is a command line interface for working with Google APIs.
+
+    # Log in
+    google-api oauth-2-login --client-id='...' --client-secret='...' --scope="https://www.googleapis.com/auth/plus.me"
+
+    # List the signed-in user's activities
+    google-api execute plus.activities.list --api=plus -- userId="me" collection="public"
+
+    # Start an interactive API session
+    google-api irb
+    >> plus = $client.discovered_api('plus')
+    >> $client.execute(plus.activities.list, {'userId' => 'me', 'collection' => 'public'})
+    => # returns a response from the API
+
+For more information, use `google-api --help`
+
+## Samples
+
+See the full list of [samples on Google Code](http://code.google.com/p/google-api-ruby-client/source/browse?repo=samples).
+
+
+## Support
+
+Please [report bugs at the project on Google Code](http://code.google.com/p/google-api-ruby-client/issues/entry). Don't hesitate to [ask questions](http://stackoverflow.com/questions/tagged/google-api) about the client or APIs on [StackOverflow](http://stackoverflow.com).
 
-    $ sudo gem install google-api-client
 
-The command line interface, the example applications, and the test suite
-require additional dependencies. These may be obtained with:
 
-    $ sudo gem install google-api-client --development --force --no-rdoc --no-ri

data/Rakefile

@@ -15,8 +15,8 @@ PKG_HOMEPAGE       = 'http://code.google.com/p/google-api-ruby-client/'
 
 RELEASE_NAME       = "REL #{PKG_VERSION}"
 
-PKG_AUTHOR         = "Bob Aman"
-PKG_AUTHOR_EMAIL   = "bobaman@google.com"
+PKG_AUTHOR         = ["Bob Aman", "Steve Bazyl"]
+PKG_AUTHOR_EMAIL   = "sbazyl@google.com"
 PKG_SUMMARY        = 'Package Summary'
 PKG_DESCRIPTION    = <<-TEXT
 The Google API Ruby Client makes it trivial to discover and access supported

data/bin/google-api

@@ -10,11 +10,8 @@ OAUTH_SERVER_PORT = 12736
 
 require 'rubygems'
 require 'optparse'
-
-gem 'faraday', '~> 0.8.1'
 require 'faraday'
 require 'faraday/utils'
-
 require 'webrick'
 require 'google/api_client/version'
 require 'google/api_client'
@@ -187,7 +184,6 @@ HTML
       end
 
       def client
-        gem 'signet', '~> 0.4.0'
         require 'signet/oauth_1/client'
         require 'yaml'
         require 'irb'
@@ -281,7 +277,6 @@ HTML
       ]
 
       def oauth_1_login
-        gem 'signet', '~> 0.4.0'
         require 'signet/oauth_1/client'
         require 'launchy'
         require 'yaml'
@@ -349,7 +344,6 @@ HTML
       end
 
       def oauth_2_login
-        gem 'signet', '~> 0.4.0'
         require 'signet/oauth_2/client'
         require 'launchy'
         require 'yaml'
@@ -471,9 +465,8 @@ HTML
           method = options[:http_method]
           method ||= request_body == '' ? 'GET' : 'POST'
           method.upcase!
-          request = [method, uri.to_str, headers, [request_body]]
-          request = client.generate_authenticated_request(:request => request)
-          response = client.transmit(request)
+          response = client.execute(:http_method => method, :uri => uri.to_str, 
+            :headers => headers, :body => request_body)
           puts response.body
           exit(0)
         else

data/lib/compat/multi_json.rb

@@ -1,14 +1,13 @@
-gem 'multi_json', '>= 1.0.0'
 require 'multi_json'
 
-unless MultiJson.respond_to?(:load)
+if !MultiJson.respond_to?(:load) || MultiJson.method(:load).owner == Kernel
   module MultiJson
     class <<self
       alias :load :decode
     end
   end
 end
-unless MultiJson.respond_to?(:dump)
+if !MultiJson.respond_to?(:dump)
   module MultiJson
     class <<self
       alias :dump :encode

data/lib/google/api_client.rb

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 
-gem 'faraday', '~> 0.8.1'
 require 'faraday'
 require 'faraday/utils'
 require 'multi_json'
@@ -24,6 +23,7 @@ require 'google/api_client/version'
 require 'google/api_client/errors'
 require 'google/api_client/environment'
 require 'google/api_client/discovery'
+require 'google/api_client/request'
 require 'google/api_client/reference'
 require 'google/api_client/result'
 require 'google/api_client/media'
@@ -31,9 +31,6 @@ require 'google/api_client/service_account'
 require 'google/api_client/batch'
 
 module Google
-  # TODO(bobaman): Document all this stuff.
-
-
   ##
   # This class manages APIs communication.
   class APIClient
@@ -67,23 +64,23 @@ module Google
     def initialize(options={})
       # Normalize key to String to allow indifferent access.
       options = options.inject({}) do |accu, (key, value)|
-        accu[key.to_s] = value
+        accu[key.to_sym] = value
         accu
       end
       # Almost all API usage will have a host of 'www.googleapis.com'.
-      self.host = options["host"] || 'www.googleapis.com'
-      self.port = options["port"] || 443
-      self.discovery_path = options["discovery_path"] || '/discovery/v1'
+      self.host = options[:host] || 'www.googleapis.com'
+      self.port = options[:port] || 443
+      self.discovery_path = options[:discovery_path] || '/discovery/v1'
 
       # Most developers will want to leave this value alone and use the
       # application_name option.
       application_string = (
-        options["application_name"] ? (
-          "#{options["application_name"]}/" +
-          "#{options["application_version"] || '0.0.0'}"
+        options[:application_name] ? (
+          "#{options[:application_name]}/" +
+          "#{options[:application_version] || '0.0.0'}"
         ) : ""
       )
-      self.user_agent = options["user_agent"] || (
+      self.user_agent = options[:user_agent] || (
         "#{application_string} " +
         "google-api-ruby-client/#{VERSION::STRING} " +
          ENV::OS_VERSION
@@ -91,9 +88,9 @@ module Google
       # The writer method understands a few Symbols and will generate useful
       # default authentication mechanisms.
       self.authorization =
-        options.key?("authorization") ? options["authorization"] : :oauth_2
-      self.key = options["key"]
-      self.user_ip = options["user_ip"]
+        options.key?(:authorization) ? options[:authorization] : :oauth_2
+      self.key = options[:key]
+      self.user_ip = options[:user_ip]
       @discovery_uris = {}
       @discovery_documents = {}
       @discovered_apis = {}
@@ -114,7 +111,6 @@ module Google
     def authorization=(new_authorization)
       case new_authorization
       when :oauth_1, :oauth
-        gem 'signet', '~> 0.4.0'
         require 'signet/oauth_1/client'
         # NOTE: Do not rely on this default value, as it may change
         new_authorization = Signet::OAuth1::Client.new(
@@ -128,7 +124,6 @@ module Google
           :client_credential_secret => 'anonymous'
         )
       when :two_legged_oauth_1, :two_legged_oauth
-        gem 'signet', '~> 0.4.0'
         require 'signet/oauth_1/client'
         # NOTE: Do not rely on this default value, as it may change
         new_authorization = Signet::OAuth1::Client.new(
@@ -137,7 +132,6 @@ module Google
           :two_legged => true
         )
       when :oauth_2
-        gem 'signet', '~> 0.4.0'
         require 'signet/oauth_2/client'
         # NOTE: Do not rely on this default value, as it may change
         new_authorization = Signet::OAuth2::Client.new(
@@ -199,31 +193,6 @@ module Google
     #   The base path. Should almost always be '/discovery/v1'.
     attr_accessor :discovery_path
 
-    ##
-    # Resolves a URI template against the client's configured base.
-    #
-    # @param [String, Addressable::URI, Addressable::Template] template
-    #   The template to resolve.
-    # @param [Hash] mapping The mapping that corresponds to the template.
-    # @return [Addressable::URI] The expanded URI.
-    def resolve_uri(template, mapping={})
-      @base_uri ||= Addressable::URI.new(
-        :scheme => 'https',
-        :host => self.host,
-        :port => self.port
-      ).normalize
-      template = if template.kind_of?(Addressable::Template)
-        template.pattern
-      elsif template.respond_to?(:to_str)
-        template.to_str
-      else
-        raise TypeError,
-          "Expected String, Addressable::URI, or Addressable::Template, " +
-          "got #{template.class}."
-      end
-      return Addressable::Template.new(@base_uri + template).expand(mapping)
-    end
-
     ##
     # Returns the URI for the directory document.
     #
@@ -293,27 +262,12 @@ module Google
     # @return [Hash] The parsed JSON from the directory document.
     def directory_document
       return @directory_document ||= (begin
-        request = self.generate_request(
+        response = self.execute!(
           :http_method => :get,
           :uri => self.directory_uri,
           :authenticated => false
         )
-        response = self.transmit(:request => request)
-        if response.status >= 200 && response.status < 300
-          MultiJson.load(response.body)
-        elsif response.status >= 400
-          case response.status
-          when 400...500
-            exception_type = ClientError
-          when 500...600
-            exception_type = ServerError
-          else
-            exception_type = TransmissionError
-          end
-          url = request.to_env(Faraday.default_connection)[:url]
-          raise exception_type,
-            "Could not retrieve directory document at: #{url}"
-        end
+        response.data
       end)
     end
 
@@ -327,27 +281,12 @@ module Google
       api = api.to_s
       version = version || 'v1'
       return @discovery_documents["#{api}:#{version}"] ||= (begin
-        request = self.generate_request(
+        response = self.execute!(
           :http_method => :get,
           :uri => self.discovery_uri(api, version),
           :authenticated => false
         )
-        response = self.transmit(:request => request)
-        if response.status >= 200 && response.status < 300
-          MultiJson.load(response.body)
-        elsif response.status >= 400
-          case response.status
-          when 400...500
-            exception_type = ClientError
-          when 500...600
-            exception_type = ServerError
-          else
-            exception_type = TransmissionError
-          end
-          url = request.to_env(Faraday.default_connection)[:url]
-          raise exception_type,
-            "Could not retrieve discovery document at: #{url}"
-        end
+        response.data
       end)
     end
 
@@ -403,7 +342,7 @@ module Google
     # Returns the method object for a given RPC name and service version.
     #
     # @param [String, Symbol] rpc_name The RPC name of the desired method.
-    # @param [String, Symbol] rpc_name The API the method is within.
+    # @param [String, Symbol] api The API the method is within.
     # @param [String] version The desired version of the API.
     #
     # @return [Google::APIClient::Method] The method object.
@@ -449,7 +388,6 @@ module Google
     # an ID token supplied by an untrusted client-side mechanism is valid.
     # Raises an error if the token is invalid or missing.
     def verify_id_token!
-      gem 'jwt', '~> 0.1.4'
       require 'jwt'
       require 'openssl'
       @certificates ||= {}
@@ -479,31 +417,16 @@ module Google
         if check_cached_certs.call()
           return true
         end
-        request = self.generate_request(
+        response = self.execute!(
           :http_method => :get,
           :uri => 'https://www.googleapis.com/oauth2/v1/certs',
           :authenticated => false
         )
-        response = self.transmit(:request => request)
-        if response.status >= 200 && response.status < 300
-          @certificates.merge!(
-            Hash[MultiJson.load(response.body).map do |key, cert|
-              [key, OpenSSL::X509::Certificate.new(cert)]
-            end]
-          )
-        elsif response.status >= 400
-          case response.status
-          when 400...500
-            exception_type = ClientError
-          when 500...600
-            exception_type = ServerError
-          else
-            exception_type = TransmissionError
-          end
-          url = request.to_env(Faraday.default_connection)[:url]
-          raise exception_type,
-            "Could not retrieve certificates from: #{url}"
-        end
+        @certificates.merge!(
+          Hash[MultiJson.load(response.body).map do |key, cert|
+            [key, OpenSSL::X509::Certificate.new(cert)]
+          end]
+        )
         if check_cached_certs.call()
           return true
         else
@@ -517,7 +440,7 @@ module Google
     ##
     # Generates a request.
     #
-    # @option options [Google::APIClient::Method, String] :api_method
+    # @option options [Google::APIClient::Method] :api_method
     #   The method object or the RPC name of the method being executed.
     # @option options [Hash, Array] :parameters
     #   The parameters to send to the method.
@@ -532,7 +455,7 @@ module Google
     #   `true` if the request must be signed or somehow
     #   authenticated, `false` otherwise.
     #
-    # @return [Faraday::Request] The generated request.
+    # @return [Google::APIClient::Reference] The generated request.
     #
     # @example
     #   request = client.generate_request(
@@ -541,153 +464,30 @@ module Google
     #       {'collection' => 'public', 'userId' => 'me'}
     #   )
     def generate_request(options={})
-      # Note: The merge method on a Hash object will coerce an API Reference
-      # object into a Hash and merge with the default options.
-
-      options={
-        :version => 'v1',
-        :authorization => self.authorization,
-        :key => self.key,
-        :user_ip => self.user_ip,
-        :connection => Faraday.default_connection
+      options = {
+        :api_client => self
       }.merge(options)
-
-      # The Reference object is going to need this to do method ID lookups.
-      options[:client] = self
-      # The default value for the :authenticated option depends on whether an
-      # authorization mechanism has been set.
-      if options[:authorization]
-        options = {:authenticated => true}.merge(options)
-      else
-        options = {:authenticated => false}.merge(options)
-      end
-      reference = Google::APIClient::Reference.new(options)
-      request = reference.to_request
-      if options[:authenticated]
-        request = options[:authorization].generate_authenticated_request(
-          :request => request,
-          :connection => options[:connection]
-        )
-      end
-      return request
-    end
-
-    ##
-    # Signs a request using the current authorization mechanism.
-    #
-    # @param [Hash] options a customizable set of options
-    #
-    # @return [Faraday::Request] The signed or otherwise authenticated request.
-    # @deprecated No longer used internally
-    def generate_authenticated_request(options={})
-      return authorization.generate_authenticated_request(options)
-    end
-
-    ##
-    # Transmits the request using the current HTTP adapter.
-    #
-    # @option options [Array, Faraday::Request] :request
-    #   The HTTP request to transmit.
-    # @option options [String, Symbol] :method
-    #   The method for the HTTP request.
-    # @option options [String, Addressable::URI] :uri
-    #   The URI for the HTTP request.
-    # @option options [Array, Hash] :headers
-    #   The headers for the HTTP request.
-    # @option options [String] :body
-    #   The body for the HTTP request.
-    # @option options [Faraday::Connection] :connection
-    #   The HTTP connection to use.
-    #
-    # @return [Faraday::Response] The response from the server.
-    def transmit(options={})
-      options[:connection] ||= Faraday.default_connection
-      if options[:request]
-        if options[:request].kind_of?(Array)
-          method, uri, headers, body = options[:request]
-        elsif options[:request].kind_of?(Faraday::Request)
-          unless options[:connection]
-            raise ArgumentError,
-              "Faraday::Request used, requires a connection to be provided."
-          end
-          method = options[:request].method.to_s.downcase.to_sym
-          uri = options[:connection].build_url(
-            options[:request].path, options[:request].params
-          )
-          headers = options[:request].headers || {}
-          body = options[:request].body || ''
-        end
-      else
-        method = options[:method] || :get
-        uri = options[:uri]
-        headers = options[:headers] || []
-        body = options[:body] || ''
-      end
-      headers = headers.to_a if headers.kind_of?(Hash)
-      request_components = {
-        :method => method,
-        :uri => uri,
-        :headers => headers,
-        :body => body
-      }
-      # Verify that we have all pieces required to transmit an HTTP request
-      request_components.each do |(key, value)|
-        unless value
-          raise ArgumentError, "Missing :#{key} parameter."
-        end
-      end
-
-      if self.user_agent != nil
-        # If there's no User-Agent header, set one.
-        unless headers.kind_of?(Enumerable)
-          # We need to use some Enumerable methods, relying on the presence of
-          # the #each method.
-          class << headers
-            include Enumerable
-          end
-        end
-        if self.user_agent.kind_of?(String)
-          unless headers.any? { |k, v| k.downcase == 'User-Agent'.downcase }
-            headers = headers.to_a.insert(0, ['User-Agent', self.user_agent])
-          end
-        elsif self.user_agent != nil
-          raise TypeError,
-            "Expected User-Agent to be String, got #{self.user_agent.class}"
-        end
-      end
-
-      request = options[:connection].build_request(
-        method.to_s.downcase.to_sym
-      ) do |req|
-        req.url(Addressable::URI.parse(uri).normalize.to_s)
-        req.headers = Faraday::Utils::Headers.new(headers)
-        req.body = body
-      end
-      request_env = request.to_env(options[:connection])
-      response = options[:connection].app.call(request_env)
-      return response
+      return Google::APIClient::Request.new(options)
     end
 
     ##
     # Executes a request, wrapping it in a Result object.
     #
-    # @param [Google::APIClient::BatchRequest, Hash, Array] params
-    #   Either a Google::APIClient::BatchRequest, a Hash, or an Array.
+    # @param [Google::APIClient::Request, Hash, Array] params
+    #   Either a Google::APIClient::Request, a Hash, or an Array.
     #
-    #   If a Google::APIClient::BatchRequest, no other parameters are expected.
+    #   If a Google::APIClient::Request, no other parameters are expected.
     #
     #   If a Hash, the below parameters are handled. If an Array, the
     #   parameters are assumed to be in the below order:
     #
-    #   - (Google::APIClient::Method, String) api_method:
+    #   - (Google::APIClient::Method) api_method:
     #     The method object or the RPC name of the method being executed.
     #   - (Hash, Array) parameters:
     #     The parameters to send to the method.
     #   - (String) body: The body of the request.
     #   - (Hash, Array) headers: The HTTP headers for the request.
     #   - (Hash) options: A set of options for the request, of which:
-    #     - (String) :version (default: "v1") -
-    #       The service version. Only used if `api_method` is a `String`.
     #     - (#generate_authenticated_request) :authorization (default: true) -
     #       The authorization mechanism for the response. Used only if
     #       `:authenticated` is `true`.
@@ -701,50 +501,18 @@ module Google
     #   result = client.execute(batch_request)
     #
     # @example
+    #   plus = client.discovered_api('plus')
     #   result = client.execute(
-    #     :api_method => 'plus.activities.list',
+    #     :api_method => plus.activities.list,
     #     :parameters => {'collection' => 'public', 'userId' => 'me'}
     #   )
     #
     # @see Google::APIClient#generate_request
     def execute(*params)
-      if params.last.kind_of?(Google::APIClient::BatchRequest) &&
+      if params.last.kind_of?(Google::APIClient::Request) &&
           params.size == 1
-        batch = params.pop
-        options = batch.options
-        options[:connection] ||= Faraday.default_connection
-        http_request = batch.to_http_request
-        request = nil
-
-        if @authorization
-          method, uri, headers, body = http_request
-          method = method.to_s.downcase.to_sym
-
-          faraday_request = options[:connection].build_request(
-            method.to_s.downcase.to_sym
-          ) do |req|
-            req.url(Addressable::URI.parse(uri).normalize.to_s)
-            req.headers = Faraday::Utils::Headers.new(headers)
-            req.body = body
-          end
-
-          request = {
-            :request => self.generate_authenticated_request(
-              :request => faraday_request,
-              :connection => options[:connection]
-            ),
-            :connection => options[:connection]
-          }
-        else
-          request = {
-            :request => http_request,
-            :connection => options[:connection]
-          }
-        end
-
-        response = self.transmit(request)
-        batch.process_response(response)
-        return nil
+        request = params.pop
+        options = {}
       else
         # This block of code allows us to accept multiple parameter passing
         # styles, and maintaining some backwards compatibility.
@@ -760,16 +528,28 @@ module Google
         options[:parameters] = params.shift if params.size > 0
         options[:body] = params.shift if params.size > 0
         options[:headers] = params.shift if params.size > 0
-        options[:client] = self
-        options[:connection] ||= Faraday.default_connection
-        reference = Google::APIClient::Reference.new(options)
-        request = self.generate_request(reference)
-        response = self.transmit(
-          :request => request,
-          :connection => options[:connection]
-        )
-        return Google::APIClient::Result.new(reference, request, response)
+        options.update(params.shift) if params.size > 0
+        request = self.generate_request(options)
+      end
+      
+      request.headers['User-Agent'] ||= '' + self.user_agent unless self.user_agent.nil?
+      request.parameters['key'] ||= self.key unless self.key.nil?
+      request.parameters['userIp'] ||= self.user_ip unless self.user_ip.nil?
+
+      connection = options[:connection] || Faraday.default_connection
+      request.authorization = options[:authorization] || self.authorization unless options[:authenticated] == false
+
+      result = request.send(connection)
+      if result.status == 401 && authorization.respond_to?(:refresh_token) 
+        begin
+          authorization.fetch_access_token!
+          result = request.send(connection)
+        rescue Signet::AuthorizationError
+           # Ignore since we want the original error
+        end
       end
+      
+      return result
     end
 
     ##
@@ -796,6 +576,35 @@ module Google
       end
       return result
     end
+    
+    protected
+    
+    ##
+    # Resolves a URI template against the client's configured base.
+    #
+    # @api private
+    # @param [String, Addressable::URI, Addressable::Template] template
+    #   The template to resolve.
+    # @param [Hash] mapping The mapping that corresponds to the template.
+    # @return [Addressable::URI] The expanded URI.
+    def resolve_uri(template, mapping={})
+      @base_uri ||= Addressable::URI.new(
+        :scheme => 'https',
+        :host => self.host,
+        :port => self.port
+      ).normalize
+      template = if template.kind_of?(Addressable::Template)
+        template.pattern
+      elsif template.respond_to?(:to_str)
+        template.to_str
+      else
+        raise TypeError,
+          "Expected String, Addressable::URI, or Addressable::Template, " +
+          "got #{template.class}."
+      end
+      return Addressable::Template.new(@base_uri + template).expand(mapping)
+    end
+    
   end
 end