Initial commit

vendor/google/apiclient/.gitattributes

@@ -0,0 +1,9 @@
+/.github export-ignore
+/.gitignore export-ignore
+/.travis.yml export-ignore
+/CONTRIBUTING.md export-ignore
+/examples export-ignore
+/phpunit.xml.dist export-ignore
+/style export-ignore
+/tests export-ignore
+/UPGRADING.md export-ignore

vendor/google/apiclient/LICENSE

@@ -0,0 +1,203 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+that You distribute, all copyright, patent, trademark, and
+attribution notices from the Source form of the Work,
+excluding those notices that do not pertain to any part of
+the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+distribution, then any Derivative Works that You distribute must
+include a readable copy of the attribution notices contained
+within such NOTICE file, excluding those notices that do not
+pertain to any part of the Derivative Works, in at least one
+of the following places: within a NOTICE text file distributed
+as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or,
+within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and
+do not modify the License. You may add Your own attribution
+notices within Derivative Works that You distribute, alongside
+or as an addendum to the NOTICE text from the Work, provided
+that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets "[]"
+replaced with your own identifying information. (Don't include
+the brackets!) The text should be enclosed in the appropriate
+comment syntax for the file format. We also recommend that a
+file or class name and description of purpose be included on the
+same "printed page" as the copyright notice for easier
+identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+

vendor/google/apiclient/README.md

@@ -0,0 +1,366 @@
+[![Build Status](https://travis-ci.org/google/google-api-php-client.svg?branch=master)](https://travis-ci.org/google/google-api-php-client)
+
+# Google APIs Client Library for PHP #
+
+## Description ##
+The Google API Client Library enables you to work with Google APIs such as Google+, Drive, or YouTube on your server.
+
+## Beta ##
+This library is in Beta. We're comfortable enough with the stability and features of the library that we want you to build real production applications on it. We will make an effort to support the public and protected surface of the library and maintain backwards compatibility in the future. While we are still in Beta, we reserve the right to make incompatible changes.
+
+## Requirements ##
+* [PHP 5.4.0 or higher](http://www.php.net/)
+
+## Google Cloud Platform APIs
+If you're looking to call the **Google Cloud Platform** APIs, you will want to use the [Google Cloud PHP](https://github.com/googlecloudplatform/google-cloud-php) library instead of this one.
+
+## Developer Documentation ##
+http://developers.google.com/api-client-library/php
+
+## Installation ##
+
+You can use **Composer** or simply **Download the Release**
+
+### Composer
+
+The preferred method is via [composer](https://getcomposer.org). Follow the
+[installation instructions](https://getcomposer.org/doc/00-intro.md) if you do not already have
+composer installed.
+
+Once composer is installed, execute the following command in your project root to install this library:
+
+```sh
+composer require google/apiclient:^2.0
+```
+
+Finally, be sure to include the autoloader:
+
+```php
+require_once '/path/to/your-project/vendor/autoload.php';
+```
+
+### Download the Release
+
+If you abhor using composer, you can download the package in its entirety. The [Releases](https://github.com/google/google-api-php-client/releases) page lists all stable versions. Download any file
+with the name `google-api-php-client-[RELEASE_NAME].zip` for a package including this library and its dependencies.
+
+Uncompress the zip file you download, and include the autoloader in your project:
+
+```php
+require_once '/path/to/google-api-php-client/vendor/autoload.php';
+```
+
+For additional installation and setup instructions, see [the documentation](https://developers.google.com/api-client-library/php/start/installation).
+
+## Examples ##
+See the [`examples/`](examples) directory for examples of the key client features. You can
+view them in your browser by running the php built-in web server.
+
+```
+$ php -S localhost:8000 -t examples/
+```
+
+And then browsing to the host and port you specified
+(in the above example, `http://localhost:8000`).
+
+### Basic Example ###
+
+```php
+// include your composer dependencies
+require_once 'vendor/autoload.php';
+
+$client = new Google_Client();
+$client->setApplicationName("Client_Library_Examples");
+$client->setDeveloperKey("YOUR_APP_KEY");
+
+$service = new Google_Service_Books($client);
+$optParams = array('filter' => 'free-ebooks');
+$results = $service->volumes->listVolumes('Henry David Thoreau', $optParams);
+
+foreach ($results as $item) {
+  echo $item['volumeInfo']['title'], "<br /> \n";
+}
+```
+
+### Authentication with OAuth ###
+
+> An example of this can be seen in [`examples/simple-file-upload.php`](examples/simple-file-upload.php).
+
+1. Follow the instructions to [Create Web Application Credentials](https://developers.google.com/api-client-library/php/auth/web-app#creatingcred)
+1. Download the JSON credentials
+1. Set the path to these credentials using `Google_Client::setAuthConfig`:
+
+    ```php
+    $client = new Google_Client();
+    $client->setAuthConfig('/path/to/client_credentials.json');
+    ```
+
+1. Set the scopes required for the API you are going to call
+
+    ```php
+    $client->addScope(Google_Service_Drive::DRIVE);
+    ```
+
+1. Set your application's redirect URI
+
+    ```php
+    // Your redirect URI can be any registered URI, but in this example
+    // we redirect back to this same page
+    $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . $_SERVER['PHP_SELF'];
+    $client->setRedirectUri($redirect_uri);
+    ```
+
+1. In the script handling the redirect URI, exchange the authorization code for an access token:
+
+    ```php
+    if (isset($_GET['code'])) {
+        $token = $client->fetchAccessTokenWithAuthCode($_GET['code']);
+        $client->setAccessToken($token);
+    }
+    ```
+
+### Authentication with Service Accounts ###
+
+> An example of this can be seen in [`examples/service-account.php`](examples/service-account.php).
+
+1. Follow the instructions to [Create a Service Account](https://developers.google.com/api-client-library/php/auth/service-accounts#creatinganaccount)
+1. Download the JSON credentials
+1. Set the path to these credentials using the `GOOGLE_APPLICATION_CREDENTIALS` environment variable:
+
+    ```php
+    putenv('GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json');
+    ```
+
+1. Tell the Google client to use your service account credentials to authenticate:
+
+    ```php
+    $client = new Google_Client();
+    $client->useApplicationDefaultCredentials();
+    ```
+
+1. Set the scopes required for the API you are going to call
+
+    ```php
+    $client->addScope(Google_Service_Drive::DRIVE);
+    ```
+
+1. If you have delegated domain-wide access to the service account and you want to impersonate a user account, specify the email address of the user account using the method setSubject:
+
+    ```php
+    $client->setSubject($user_to_impersonate);
+    ```
+
+### Making Requests ###
+
+The classes used to call the API in [google-api-php-client-services](https://github.com/Google/google-api-php-client-services) are autogenerated. They map directly to the JSON requests and responses found in the [APIs Explorer](https://developers.google.com/apis-explorer/#p/).
+
+A JSON request to the [Datastore API](https://developers.google.com/apis-explorer/#p/datastore/v1beta3/datastore.projects.runQuery) would look like this:
+
+```json
+POST https://datastore.googleapis.com/v1beta3/projects/YOUR_PROJECT_ID:runQuery?key=YOUR_API_KEY
+
+{
+    "query": {
+        "kind": [{
+            "name": "Book"
+        }],
+        "order": [{
+            "property": {
+                "name": "title"
+            },
+            "direction": "descending"
+        }],
+        "limit": 10
+    }
+}
+```
+
+Using this library, the same call would look something like this:
+
+```php
+// create the datastore service class
+$datastore = new Google_Service_Datastore($client);
+
+// build the query - this maps directly to the JSON
+$query = new Google_Service_Datastore_Query([
+    'kind' => [
+        [
+            'name' => 'Book',
+        ],
+    ],
+    'order' => [
+        'property' => [
+            'name' => 'title',
+        ],
+        'direction' => 'descending',
+    ],
+    'limit' => 10,
+]);
+
+// build the request and response
+$request = new Google_Service_Datastore_RunQueryRequest(['query' => $query]);
+$response = $datastore->projects->runQuery('YOUR_DATASET_ID', $request);
+```
+
+However, as each property of the JSON API has a corresponding generated class, the above code could also be written like this:
+
+```php
+// create the datastore service class
+$datastore = new Google_Service_Datastore($client);
+
+// build the query
+$request = new Google_Service_Datastore_RunQueryRequest();
+$query = new Google_Service_Datastore_Query();
+//   - set the order
+$order = new Google_Service_Datastore_PropertyOrder();
+$order->setDirection('descending');
+$property = new Google_Service_Datastore_PropertyReference();
+$property->setName('title');
+$order->setProperty($property);
+$query->setOrder([$order]);
+//   - set the kinds
+$kind = new Google_Service_Datastore_KindExpression();
+$kind->setName('Book');
+$query->setKinds([$kind]);
+//   - set the limit
+$query->setLimit(10);
+
+// add the query to the request and make the request
+$request->setQuery($query);
+$response = $datastore->projects->runQuery('YOUR_DATASET_ID', $request);
+```
+
+The method used is a matter of preference, but *it will be very difficult to use this library without first understanding the JSON syntax for the API*, so it is recommended to look at the [APIs Explorer](https://developers.google.com/apis-explorer/#p/) before using any of the services here.
+
+### Making HTTP Requests Directly ###
+
+If Google Authentication is desired for external applications, or a Google API is not available yet in this library, HTTP requests can be made directly.
+
+The `authorize` method returns an authorized [Guzzle Client](http://docs.guzzlephp.org/), so any request made using the client will contain the corresponding authorization.
+
+```php
+// create the Google client
+$client = new Google_Client();
+
+/**
+ * Set your method for authentication. Depending on the API, This could be
+ * directly with an access token, API key, or (recommended) using
+ * Application Default Credentials.
+ */
+$client->useApplicationDefaultCredentials();
+$client->addScope(Google_Service_Plus::PLUS_ME);
+
+// returns a Guzzle HTTP Client
+$httpClient = $client->authorize();
+
+// make an HTTP request
+$response = $httpClient->get('https://www.googleapis.com/plus/v1/people/me');
+```
+
+### Caching ###
+
+It is recommended to use another caching library to improve performance. This can be done by passing a [PSR-6](http://www.php-fig.org/psr/psr-6/) compatible library to the client:
+
+```php
+$cache = new Stash\Pool(new Stash\Driver\FileSystem);
+$client->setCache($cache);
+```
+
+In this example we use [StashPHP](http://www.stashphp.com/). Add this to your project with composer:
+
+```
+composer require tedivm/stash
+```
+
+### Updating Tokens ###
+
+When using [Refresh Tokens](https://developers.google.com/identity/protocols/OAuth2InstalledApp#refresh) or [Service Account Credentials](https://developers.google.com/identity/protocols/OAuth2ServiceAccount#overview), it may be useful to perform some action when a new access token is granted. To do this, pass a callable to the `setTokenCallback` method on the client:
+
+```php
+$logger = new Monolog\Logger;
+$tokenCallback = function ($cacheKey, $accessToken) use ($logger) {
+  $logger->debug(sprintf('new access token received at cache key %s', $cacheKey));
+};
+$client->setTokenCallback($tokenCallback);
+```
+
+### Debugging Your HTTP Request using Charles ###
+
+It is often very useful to debug your API calls by viewing the raw HTTP request. This library supports the use of [Charles Web Proxy](https://www.charlesproxy.com/documentation/getting-started/). Download and run Charles, and then capture all HTTP traffic through Charles with the following code:
+
+```php
+// FOR DEBUGGING ONLY
+$httpClient = new GuzzleHttp\Client([
+    'proxy' => 'localhost:8888', // by default, Charles runs on localhost port 8888
+    'verify' => false, // otherwise HTTPS requests will fail.
+]);
+
+$client = new Google_Client();
+$client->setHttpClient($httpClient);
+```
+
+Now all calls made by this library will appear in the Charles UI.
+
+One additional step is required in Charles to view SSL requests. Go to **Charles > Proxy > SSL Proxying Settings** and add the domain you'd like captured. In the case of the Google APIs, this is usually `*.googleapis.com`.
+
+### Service Specific Examples ###
+
+YouTube: https://github.com/youtube/api-samples/tree/master/php
+
+## How Do I Contribute? ##
+
+Please see the [contributing](CONTRIBUTING.md) page for more information. In particular, we love pull requests - but please make sure to sign the [contributor license agreement](https://developers.google.com/api-client-library/php/contribute).
+
+## Frequently Asked Questions ##
+
+### What do I do if something isn't working? ###
+
+For support with the library the best place to ask is via the google-api-php-client tag on StackOverflow: http://stackoverflow.com/questions/tagged/google-api-php-client
+
+If there is a specific bug with the library, please [file a issue](https://github.com/google/google-api-php-client/issues) in the Github issues tracker, including an example of the failing code and any specific errors retrieved. Feature requests can also be filed, as long as they are core library requests, and not-API specific: for those, refer to the documentation for the individual APIs for the best place to file requests. Please try to provide a clear statement of the problem that the feature would address.
+
+### I want an example of X! ###
+
+If X is a feature of the library, file away! If X is an example of using a specific service, the best place to go is to the teams for those specific APIs - our preference is to link to their examples rather than add them to the library, as they can then pin to specific versions of the library. If you have any examples for other APIs, let us know and we will happily add a link to the README above!
+
+### Why do you still support 5.2? ###
+
+When we started working on the 1.0.0 branch we knew there were several fundamental issues to fix with the 0.6 releases of the library. At that time we looked at the usage of the library, and other related projects, and determined that there was still a large and active base of PHP 5.2 installs. You can see this in statistics such as the PHP versions chart in the WordPress stats: http://wordpress.org/about/stats/. We will keep looking at the types of usage we see, and try to take advantage of newer PHP features where possible.
+
+### Why does Google_..._Service have weird names? ###
+
+The _Service classes are generally automatically generated from the API discovery documents: https://developers.google.com/discovery/. Sometimes new features are added to APIs with unusual names, which can cause some unexpected or non-standard style naming in the PHP classes.
+
+### How do I deal with non-JSON response types? ###
+
+Some services return XML or similar by default, rather than JSON, which is what the library supports. You can request a JSON response by adding an 'alt' argument to optional params that is normally the last argument to a method call:
+
+```
+$opt_params = array(
+  'alt' => "json"
+);
+```
+
+### How do I set a field to null? ###
+
+The library strips out nulls from the objects sent to the Google APIs as its the default value of all of the uninitialized properties. To work around this, set the field you want to null to `Google_Model::NULL_VALUE`. This is a placeholder that will be replaced with a true null when sent over the wire.
+
+## Code Quality ##
+
+Run the PHPUnit tests with PHPUnit. You can configure an API key and token in BaseTest.php to run all calls, but this will require some setup on the Google Developer Console.
+
+    phpunit tests/
+
+### Coding Style
+
+To check for coding style violations, run
+
+```
+vendor/bin/phpcs src --standard=style/ruleset.xml -np
+```
+
+To automatically fix (fixable) coding style violations, run
+
+```
+vendor/bin/phpcbf src --standard=style/ruleset.xml
+```

vendor/google/apiclient/composer.json

@@ -0,0 +1,41 @@
+{
+    "name": "google/apiclient",
+    "type": "library",
+    "description": "Client library for Google APIs",
+    "keywords": ["google"],
+    "homepage": "http://developers.google.com/api-client-library/php",
+    "license": "Apache-2.0",
+    "require": {
+        "php": ">=5.4",
+        "google/auth": "^0.11",
+        "google/apiclient-services": "^0.11",
+        "firebase/php-jwt": "~2.0|~3.0|~4.0",
+        "monolog/monolog": "^1.17",
+        "phpseclib/phpseclib": "~0.3.10|~2.0",
+        "guzzlehttp/guzzle": "~5.2|~6.0",
+        "guzzlehttp/psr7": "^1.2"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "~4",
+        "squizlabs/php_codesniffer": "~2.3",
+        "symfony/dom-crawler": "~2.1",
+        "symfony/css-selector": "~2.1",
+        "cache/filesystem-adapter": "^0.3.2"
+    },
+    "suggest": {
+        "cache/filesystem-adapter": "For caching certs and tokens (using Google_Client::setCache)"
+    },
+    "autoload": {
+        "psr-0": {
+            "Google_": "src/"
+        },
+        "classmap": [
+            "src/Google/Service/"
+        ]
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "2.x-dev"
+        }
+    }
+}

vendor/google/apiclient/src/Google/AccessToken/Revoke.php

@@ -0,0 +1,78 @@
+<?php
+
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use Google\Auth\HttpHandler\HttpHandlerFactory;
+use GuzzleHttp\ClientInterface;
+use GuzzleHttp\Psr7;
+use GuzzleHttp\Psr7\Request;
+
+/**
+ * Wrapper around Google Access Tokens which provides convenience functions
+ *
+ */
+class Google_AccessToken_Revoke
+{
+  /**
+   * @var GuzzleHttp\ClientInterface The http client
+   */
+  private $http;
+
+  /**
+   * Instantiates the class, but does not initiate the login flow, leaving it
+   * to the discretion of the caller.
+   */
+  public function __construct(ClientInterface $http = null)
+  {
+    $this->http = $http;
+  }
+
+  /**
+   * Revoke an OAuth2 access token or refresh token. This method will revoke the current access
+   * token, if a token isn't provided.
+   *
+   * @param string|array $token The token (access token or a refresh token) that should be revoked.
+   * @return boolean Returns True if the revocation was successful, otherwise False.
+   */
+  public function revokeToken($token)
+  {
+    if (is_array($token)) {
+      if (isset($token['refresh_token'])) {
+        $token = $token['refresh_token'];
+      } else {
+        $token = $token['access_token'];
+      }
+    }
+
+    $body = Psr7\stream_for(http_build_query(array('token' => $token)));
+    $request = new Request(
+        'POST',
+        Google_Client::OAUTH2_REVOKE_URI,
+        [
+          'Cache-Control' => 'no-store',
+          'Content-Type'  => 'application/x-www-form-urlencoded',
+        ],
+        $body
+    );
+
+    $httpHandler = HttpHandlerFactory::build($this->http);
+
+    $response = $httpHandler($request);
+
+    return $response->getStatusCode() == 200;
+  }
+}

vendor/google/apiclient/src/Google/AccessToken/Verify.php

@@ -0,0 +1,269 @@
+<?php
+
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use Firebase\JWT\ExpiredException as ExpiredExceptionV3;
+use GuzzleHttp\Client;
+use GuzzleHttp\ClientInterface;
+use Psr\Cache\CacheItemPoolInterface;
+use Google\Auth\Cache\MemoryCacheItemPool;
+use Stash\Driver\FileSystem;
+use Stash\Pool;
+
+/**
+ * Wrapper around Google Access Tokens which provides convenience functions
+ *
+ */
+class Google_AccessToken_Verify
+{
+  const FEDERATED_SIGNON_CERT_URL = 'https://www.googleapis.com/oauth2/v3/certs';
+  const OAUTH2_ISSUER = 'accounts.google.com';
+  const OAUTH2_ISSUER_HTTPS = 'https://accounts.google.com';
+
+  /**
+   * @var GuzzleHttp\ClientInterface The http client
+   */
+  private $http;
+
+  /**
+   * @var Psr\Cache\CacheItemPoolInterface cache class
+   */
+  private $cache;
+
+  /**
+   * Instantiates the class, but does not initiate the login flow, leaving it
+   * to the discretion of the caller.
+   */
+  public function __construct(
+      ClientInterface $http = null,
+      CacheItemPoolInterface $cache = null,
+      $jwt = null
+  ) {
+    if (null === $http) {
+      $http = new Client();
+    }
+
+    if (null === $cache) {
+      $cache = new MemoryCacheItemPool;
+    }
+
+    $this->http = $http;
+    $this->cache = $cache;
+    $this->jwt = $jwt ?: $this->getJwtService();
+  }
+
+  /**
+   * Verifies an id token and returns the authenticated apiLoginTicket.
+   * Throws an exception if the id token is not valid.
+   * The audience parameter can be used to control which id tokens are
+   * accepted.  By default, the id token must have been issued to this OAuth2 client.
+   *
+   * @param $audience
+   * @return array the token payload, if successful
+   */
+  public function verifyIdToken($idToken, $audience = null)
+  {
+    if (empty($idToken)) {
+      throw new LogicException('id_token cannot be null');
+    }
+
+    // set phpseclib constants if applicable
+    $this->setPhpsecConstants();
+
+    // Check signature
+    $certs = $this->getFederatedSignOnCerts();
+    foreach ($certs as $cert) {
+      $bigIntClass = $this->getBigIntClass();
+      $rsaClass = $this->getRsaClass();
+      $modulus = new $bigIntClass($this->jwt->urlsafeB64Decode($cert['n']), 256);
+      $exponent = new $bigIntClass($this->jwt->urlsafeB64Decode($cert['e']), 256);
+
+      $rsa = new $rsaClass();
+      $rsa->loadKey(array('n' => $modulus, 'e' => $exponent));
+
+      try {
+        $payload = $this->jwt->decode(
+            $idToken,
+            $rsa->getPublicKey(),
+            array('RS256')
+        );
+
+        if (property_exists($payload, 'aud')) {
+          if ($audience && $payload->aud != $audience) {
+            return false;
+          }
+        }
+
+        // support HTTP and HTTPS issuers
+        // @see https://developers.google.com/identity/sign-in/web/backend-auth
+        $issuers = array(self::OAUTH2_ISSUER, self::OAUTH2_ISSUER_HTTPS);
+        if (!isset($payload->iss) || !in_array($payload->iss, $issuers)) {
+          return false;
+        }
+
+        return (array) $payload;
+      } catch (ExpiredException $e) {
+        return false;
+      } catch (ExpiredExceptionV3 $e) {
+        return false;
+      } catch (DomainException $e) {
+        // continue
+      }
+    }
+
+    return false;
+  }
+
+  private function getCache()
+  {
+    return $this->cache;
+  }
+
+  /**
+   * Retrieve and cache a certificates file.
+   *
+   * @param $url string location
+   * @throws Google_Exception
+   * @return array certificates
+   */
+  private function retrieveCertsFromLocation($url)
+  {
+    // If we're retrieving a local file, just grab it.
+    if (0 !== strpos($url, 'http')) {
+      if (!$file = file_get_contents($url)) {
+        throw new Google_Exception(
+            "Failed to retrieve verification certificates: '" .
+            $url . "'."
+        );
+      }
+
+      return json_decode($file, true);
+    }
+
+    $response = $this->http->get($url);
+
+    if ($response->getStatusCode() == 200) {
+      return json_decode((string) $response->getBody(), true);
+    }
+    throw new Google_Exception(
+        sprintf(
+            'Failed to retrieve verification certificates: "%s".',
+            $response->getBody()->getContents()
+        ),
+        $response->getStatusCode()
+    );
+  }
+
+  // Gets federated sign-on certificates to use for verifying identity tokens.
+  // Returns certs as array structure, where keys are key ids, and values
+  // are PEM encoded certificates.
+  private function getFederatedSignOnCerts()
+  {
+    $certs = null;
+    if ($cache = $this->getCache()) {
+      $cacheItem = $cache->getItem('federated_signon_certs_v3', 3600);
+      $certs = $cacheItem->get();
+    }
+
+
+    if (!$certs) {
+      $certs = $this->retrieveCertsFromLocation(
+          self::FEDERATED_SIGNON_CERT_URL
+      );
+
+      if ($cache) {
+        $cacheItem->set($certs);
+        $cache->save($cacheItem);
+      }
+    }
+
+    if (!isset($certs['keys'])) {
+      throw new InvalidArgumentException(
+          'federated sign-on certs expects "keys" to be set'
+      );
+    }
+
+    return $certs['keys'];
+  }
+
+  private function getJwtService()
+  {
+    $jwtClass = 'JWT';
+    if (class_exists('\Firebase\JWT\JWT')) {
+      $jwtClass = 'Firebase\JWT\JWT';
+    }
+
+    if (property_exists($jwtClass, 'leeway')) {
+      // adds 1 second to JWT leeway
+      // @see https://github.com/google/google-api-php-client/issues/827
+      $jwtClass::$leeway = 1;
+    }
+
+    return new $jwtClass;
+  }
+
+  private function getRsaClass()
+  {
+    if (class_exists('phpseclib\Crypt\RSA')) {
+      return 'phpseclib\Crypt\RSA';
+    }
+
+    return 'Crypt_RSA';
+  }
+
+  private function getBigIntClass()
+  {
+    if (class_exists('phpseclib\Math\BigInteger')) {
+      return 'phpseclib\Math\BigInteger';
+    }
+
+    return 'Math_BigInteger';
+  }
+
+  private function getOpenSslConstant()
+  {
+    if (class_exists('phpseclib\Crypt\RSA')) {
+      return 'phpseclib\Crypt\RSA::MODE_OPENSSL';
+    }
+
+    if (class_exists('Crypt_RSA')) {
+      return 'CRYPT_RSA_MODE_OPENSSL';
+    }
+
+    throw new \Exception('Cannot find RSA class');
+  }
+
+  /**
+   * phpseclib calls "phpinfo" by default, which requires special
+   * whitelisting in the AppEngine VM environment. This function
+   * sets constants to bypass the need for phpseclib to check phpinfo
+   *
+   * @see phpseclib/Math/BigInteger
+   * @see https://github.com/GoogleCloudPlatform/getting-started-php/issues/85
+   */
+  private function setPhpsecConstants()
+  {
+    if (filter_var(getenv('GAE_VM'), FILTER_VALIDATE_BOOLEAN)) {
+      if (!defined('MATH_BIGINTEGER_OPENSSL_ENABLED')) {
+        define('MATH_BIGINTEGER_OPENSSL_ENABLED', true);
+      }
+      if (!defined('CRYPT_RSA_MODE')) {
+        define('CRYPT_RSA_MODE', constant($this->getOpenSslConstant()));
+      }
+    }
+  }
+}

vendor/google/apiclient/src/Google/AuthHandler/AuthHandlerFactory.php

@@ -0,0 +1,42 @@
+<?php
+/**
+ * Copyright 2015 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use GuzzleHttp\Client;
+use GuzzleHttp\ClientInterface;
+
+class Google_AuthHandler_AuthHandlerFactory
+{
+  /**
+   * Builds out a default http handler for the installed version of guzzle.
+   *
+   * @return Google_AuthHandler_Guzzle5AuthHandler|Google_AuthHandler_Guzzle6AuthHandler
+   * @throws Exception
+   */
+  public static function build($cache = null, array $cacheConfig = [])
+  {
+    $version = ClientInterface::VERSION;
+
+    switch ($version[0]) {
+      case '5':
+        return new Google_AuthHandler_Guzzle5AuthHandler($cache, $cacheConfig);
+      case '6':
+        return new Google_AuthHandler_Guzzle6AuthHandler($cache, $cacheConfig);
+      default:
+        throw new Exception('Version not supported');
+    }
+  }
+}

vendor/google/apiclient/src/Google/AuthHandler/Guzzle5AuthHandler.php

@@ -0,0 +1,99 @@
+<?php
+
+use Google\Auth\CredentialsLoader;
+use Google\Auth\HttpHandler\HttpHandlerFactory;
+use Google\Auth\FetchAuthTokenCache;
+use Google\Auth\Subscriber\AuthTokenSubscriber;
+use Google\Auth\Subscriber\ScopedAccessTokenSubscriber;
+use Google\Auth\Subscriber\SimpleSubscriber;
+use GuzzleHttp\Client;
+use GuzzleHttp\ClientInterface;
+use Psr\Cache\CacheItemPoolInterface;
+
+/**
+*
+*/
+class Google_AuthHandler_Guzzle5AuthHandler
+{
+  protected $cache;
+  protected $cacheConfig;
+
+  public function __construct(CacheItemPoolInterface $cache = null, array $cacheConfig = [])
+  {
+    $this->cache = $cache;
+    $this->cacheConfig = $cacheConfig;
+  }
+
+  public function attachCredentials(
+      ClientInterface $http,
+      CredentialsLoader $credentials,
+      callable $tokenCallback = null
+  ) {
+    // use the provided cache
+    if ($this->cache) {
+      $credentials = new FetchAuthTokenCache(
+          $credentials,
+          $this->cacheConfig,
+          $this->cache
+      );
+    }
+    // if we end up needing to make an HTTP request to retrieve credentials, we
+    // can use our existing one, but we need to throw exceptions so the error
+    // bubbles up.
+    $authHttp = $this->createAuthHttp($http);
+    $authHttpHandler = HttpHandlerFactory::build($authHttp);
+    $subscriber = new AuthTokenSubscriber(
+        $credentials,
+        $authHttpHandler,
+        $tokenCallback
+    );
+
+    $http->setDefaultOption('auth', 'google_auth');
+    $http->getEmitter()->attach($subscriber);
+
+    return $http;
+  }
+
+  public function attachToken(ClientInterface $http, array $token, array $scopes)
+  {
+    $tokenFunc = function ($scopes) use ($token) {
+      return $token['access_token'];
+    };
+
+    $subscriber = new ScopedAccessTokenSubscriber(
+        $tokenFunc,
+        $scopes,
+        $this->cacheConfig,
+        $this->cache
+    );
+
+    $http->setDefaultOption('auth', 'scoped');
+    $http->getEmitter()->attach($subscriber);
+
+    return $http;
+  }
+
+  public function attachKey(ClientInterface $http, $key)
+  {
+    $subscriber = new SimpleSubscriber(['key' => $key]);
+
+    $http->setDefaultOption('auth', 'simple');
+    $http->getEmitter()->attach($subscriber);
+
+    return $http;
+  }
+
+  private function createAuthHttp(ClientInterface $http)
+  {
+    return new Client(
+        [
+          'base_url' => $http->getBaseUrl(),
+          'defaults' => [
+            'exceptions' => true,
+            'verify' => $http->getDefaultOption('verify'),
+            'proxy' => $http->getDefaultOption('proxy'),
+          ]
+        ]
+    );
+  }
+}

vendor/google/apiclient/src/Google/AuthHandler/Guzzle6AuthHandler.php

@@ -0,0 +1,106 @@
+<?php
+
+use Google\Auth\CredentialsLoader;
+use Google\Auth\HttpHandler\HttpHandlerFactory;
+use Google\Auth\FetchAuthTokenCache;
+use Google\Auth\Middleware\AuthTokenMiddleware;
+use Google\Auth\Middleware\ScopedAccessTokenMiddleware;
+use Google\Auth\Middleware\SimpleMiddleware;
+use GuzzleHttp\Client;
+use GuzzleHttp\ClientInterface;
+use Psr\Cache\CacheItemPoolInterface;
+
+/**
+*
+*/
+class Google_AuthHandler_Guzzle6AuthHandler
+{
+  protected $cache;
+  protected $cacheConfig;
+
+  public function __construct(CacheItemPoolInterface $cache = null, array $cacheConfig = [])
+  {
+    $this->cache = $cache;
+    $this->cacheConfig = $cacheConfig;
+  }
+
+  public function attachCredentials(
+      ClientInterface $http,
+      CredentialsLoader $credentials,
+      callable $tokenCallback = null
+  ) {
+    // use the provided cache
+    if ($this->cache) {
+      $credentials = new FetchAuthTokenCache(
+          $credentials,
+          $this->cacheConfig,
+          $this->cache
+      );
+    }
+    // if we end up needing to make an HTTP request to retrieve credentials, we
+    // can use our existing one, but we need to throw exceptions so the error
+    // bubbles up.
+    $authHttp = $this->createAuthHttp($http);
+    $authHttpHandler = HttpHandlerFactory::build($authHttp);
+    $middleware = new AuthTokenMiddleware(
+        $credentials,
+        $authHttpHandler,
+        $tokenCallback
+    );
+
+    $config = $http->getConfig();
+    $config['handler']->remove('google_auth');
+    $config['handler']->push($middleware, 'google_auth');
+    $config['auth'] = 'google_auth';
+    $http = new Client($config);
+
+    return $http;
+  }
+
+  public function attachToken(ClientInterface $http, array $token, array $scopes)
+  {
+    $tokenFunc = function ($scopes) use ($token) {
+      return $token['access_token'];
+    };
+
+    $middleware = new ScopedAccessTokenMiddleware(
+        $tokenFunc,
+        $scopes,
+        $this->cacheConfig,
+        $this->cache
+    );
+
+    $config = $http->getConfig();
+    $config['handler']->remove('google_auth');
+    $config['handler']->push($middleware, 'google_auth');
+    $config['auth'] = 'scoped';
+    $http = new Client($config);
+
+    return $http;
+  }
+
+  public function attachKey(ClientInterface $http, $key)
+  {
+    $middleware = new SimpleMiddleware(['key' => $key]);
+
+    $config = $http->getConfig();
+    $config['handler']->remove('google_auth');
+    $config['handler']->push($middleware, 'google_auth');
+    $config['auth'] = 'simple';
+    $http = new Client($config);
+
+    return $http;
+  }
+
+  private function createAuthHttp(ClientInterface $http)
+  {
+    return new Client(
+        [
+          'base_uri' => $http->getConfig('base_uri'),
+          'exceptions' => true,
+          'verify' => $http->getConfig('verify'),
+          'proxy' => $http->getConfig('proxy'),
+        ]
+    );
+  }
+}

vendor/google/apiclient/src/Google/Collection.php

@@ -0,0 +1,101 @@
+<?php
+
+if (!class_exists('Google_Client')) {
+  require_once __DIR__ . '/autoload.php';
+}
+
+/**
+ * Extension to the regular Google_Model that automatically
+ * exposes the items array for iteration, so you can just
+ * iterate over the object rather than a reference inside.
+ */
+class Google_Collection extends Google_Model implements Iterator, Countable
+{
+  protected $collection_key = 'items';
+
+  public function rewind()
+  {
+    if (isset($this->modelData[$this->collection_key])
+        && is_array($this->modelData[$this->collection_key])) {
+      reset($this->modelData[$this->collection_key]);
+    }
+  }
+
+  public function current()
+  {
+    $this->coerceType($this->key());
+    if (is_array($this->modelData[$this->collection_key])) {
+      return current($this->modelData[$this->collection_key]);
+    }
+  }
+
+  public function key()
+  {
+    if (isset($this->modelData[$this->collection_key])
+        && is_array($this->modelData[$this->collection_key])) {
+      return key($this->modelData[$this->collection_key]);
+    }
+  }
+
+  public function next()
+  {
+    return next($this->modelData[$this->collection_key]);
+  }
+
+  public function valid()
+  {
+    $key = $this->key();
+    return $key !== null && $key !== false;
+  }
+
+  public function count()
+  {
+    if (!isset($this->modelData[$this->collection_key])) {
+      return 0;
+    }
+    return count($this->modelData[$this->collection_key]);
+  }
+
+  public function offsetExists($offset)
+  {
+    if (!is_numeric($offset)) {
+      return parent::offsetExists($offset);
+    }
+    return isset($this->modelData[$this->collection_key][$offset]);
+  }
+
+  public function offsetGet($offset)
+  {
+    if (!is_numeric($offset)) {
+      return parent::offsetGet($offset);
+    }
+    $this->coerceType($offset);
+    return $this->modelData[$this->collection_key][$offset];
+  }
+
+  public function offsetSet($offset, $value)
+  {
+    if (!is_numeric($offset)) {
+      return parent::offsetSet($offset, $value);
+    }
+    $this->modelData[$this->collection_key][$offset] = $value;
+  }
+
+  public function offsetUnset($offset)
+  {
+    if (!is_numeric($offset)) {
+      return parent::offsetUnset($offset);
+    }
+    unset($this->modelData[$this->collection_key][$offset]);
+  }
+
+  private function coerceType($offset)
+  {
+    $typeKey = $this->keyType($this->collection_key);
+    if (isset($this->$typeKey) && !is_object($this->modelData[$this->collection_key][$offset])) {
+      $type = $this->$typeKey;
+      $this->modelData[$this->collection_key][$offset] =
+          new $type($this->modelData[$this->collection_key][$offset]);
+    }
+  }
+}

vendor/google/apiclient/src/Google/Exception.php

@@ -0,0 +1,20 @@
+<?php
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class Google_Exception extends Exception
+{
+}

vendor/google/apiclient/src/Google/Http/Batch.php

@@ -0,0 +1,249 @@
+<?php
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use GuzzleHttp\Psr7;
+use GuzzleHttp\Psr7\Request;
+use GuzzleHttp\Psr7\Response;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Class to handle batched requests to the Google API service.
+ */
+class Google_Http_Batch
+{
+  const BATCH_PATH = 'batch';
+
+  private static $CONNECTION_ESTABLISHED_HEADERS = array(
+    "HTTP/1.0 200 Connection established\r\n\r\n",
+    "HTTP/1.1 200 Connection established\r\n\r\n",
+  );
+
+  /** @var string Multipart Boundary. */
+  private $boundary;
+
+  /** @var array service requests to be executed. */
+  private $requests = array();
+
+  /** @var Google_Client */
+  private $client;
+
+  private $rootUrl;
+
+  private $batchPath;
+
+  public function __construct(
+      Google_Client $client,
+      $boundary = false,
+      $rootUrl = null,
+      $batchPath = null
+  ) {
+    $this->client = $client;
+    $this->boundary = $boundary ?: mt_rand();
+    $this->rootUrl = rtrim($rootUrl ?: $this->client->getConfig('base_path'), '/');
+    $this->batchPath = $batchPath ?: self::BATCH_PATH;
+  }
+
+  public function add(RequestInterface $request, $key = false)
+  {
+    if (false == $key) {
+      $key = mt_rand();
+    }
+
+    $this->requests[$key] = $request;
+  }
+
+  public function execute()
+  {
+    $body = '';
+    $classes = array();
+    $batchHttpTemplate = <<<EOF
+--%s
+Content-Type: application/http
+Content-Transfer-Encoding: binary
+MIME-Version: 1.0
+Content-ID: %s
+
+%s
+%s%s
+
+
+EOF;
+
+    /** @var Google_Http_Request $req */
+    foreach ($this->requests as $key => $request) {
+      $firstLine = sprintf(
+          '%s %s HTTP/%s',
+          $request->getMethod(),
+          $request->getRequestTarget(),
+          $request->getProtocolVersion()
+      );
+
+      $content = (string) $request->getBody();
+
+      $headers = '';
+      foreach ($request->getHeaders() as $name => $values) {
+          $headers .= sprintf("%s:%s\r\n", $name, implode(', ', $values));
+      }
+
+      $body .= sprintf(
+          $batchHttpTemplate,
+          $this->boundary,
+          $key,
+          $firstLine,
+          $headers,
+          $content ? "\n".$content : ''
+      );
+
+      $classes['response-' . $key] = $request->getHeaderLine('X-Php-Expected-Class');
+    }
+
+    $body .= "--{$this->boundary}--";
+    $body = trim($body);
+    $url = $this->rootUrl . '/' . $this->batchPath;
+    $headers = array(
+      'Content-Type' => sprintf('multipart/mixed; boundary=%s', $this->boundary),
+      'Content-Length' => strlen($body),
+    );
+
+    $request = new Request(
+        'POST',
+        $url,
+        $headers,
+        $body
+    );
+
+    $response = $this->client->execute($request);
+
+    return $this->parseResponse($response, $classes);
+  }
+
+  public function parseResponse(ResponseInterface $response, $classes = array())
+  {
+    $contentType = $response->getHeaderLine('content-type');
+    $contentType = explode(';', $contentType);
+    $boundary = false;
+    foreach ($contentType as $part) {
+      $part = explode('=', $part, 2);
+      if (isset($part[0]) && 'boundary' == trim($part[0])) {
+        $boundary = $part[1];
+      }
+    }
+
+    $body = (string) $response->getBody();
+    if (!empty($body)) {
+      $body = str_replace("--$boundary--", "--$boundary", $body);
+      $parts = explode("--$boundary", $body);
+      $responses = array();
+      $requests = array_values($this->requests);
+
+      foreach ($parts as $i => $part) {
+        $part = trim($part);
+        if (!empty($part)) {
+          list($rawHeaders, $part) = explode("\r\n\r\n", $part, 2);
+          $headers = $this->parseRawHeaders($rawHeaders);
+
+          $status = substr($part, 0, strpos($part, "\n"));
+          $status = explode(" ", $status);
+          $status = $status[1];
+
+          list($partHeaders, $partBody) = $this->parseHttpResponse($part, false);
+          $response = new Response(
+              $status,
+              $partHeaders,
+              Psr7\stream_for($partBody)
+          );
+
+          // Need content id.
+          $key = $headers['content-id'];
+
+          try {
+            $response = Google_Http_REST::decodeHttpResponse($response, $requests[$i-1]);
+          } catch (Google_Service_Exception $e) {
+            // Store the exception as the response, so successful responses
+            // can be processed.
+            $response = $e;
+          }
+
+          $responses[$key] = $response;
+        }
+      }
+
+      return $responses;
+    }
+
+    return null;
+  }
+
+  private function parseRawHeaders($rawHeaders)
+  {
+    $headers = array();
+    $responseHeaderLines = explode("\r\n", $rawHeaders);
+    foreach ($responseHeaderLines as $headerLine) {
+      if ($headerLine && strpos($headerLine, ':') !== false) {
+        list($header, $value) = explode(': ', $headerLine, 2);
+        $header = strtolower($header);
+        if (isset($headers[$header])) {
+          $headers[$header] .= "\n" . $value;
+        } else {
+          $headers[$header] = $value;
+        }
+      }
+    }
+    return $headers;
+  }
+
+  /**
+   * Used by the IO lib and also the batch processing.
+   *
+   * @param $respData
+   * @param $headerSize
+   * @return array
+   */
+  private function parseHttpResponse($respData, $headerSize)
+  {
+    // check proxy header
+    foreach (self::$CONNECTION_ESTABLISHED_HEADERS as $established_header) {
+      if (stripos($respData, $established_header) !== false) {
+        // existed, remove it
+        $respData = str_ireplace($established_header, '', $respData);
+        // Subtract the proxy header size unless the cURL bug prior to 7.30.0
+        // is present which prevented the proxy header size from being taken into
+        // account.
+        // @TODO look into this
+        // if (!$this->needsQuirk()) {
+        //   $headerSize -= strlen($established_header);
+        // }
+        break;
+      }
+    }
+
+    if ($headerSize) {
+      $responseBody = substr($respData, $headerSize);
+      $responseHeaders = substr($respData, 0, $headerSize);
+    } else {
+      $responseSegments = explode("\r\n\r\n", $respData, 2);
+      $responseHeaders = $responseSegments[0];
+      $responseBody = isset($responseSegments[1]) ? $responseSegments[1] :
+                                                    null;
+    }
+
+    $responseHeaders = $this->parseRawHeaders($responseHeaders);
+
+    return array($responseHeaders, $responseBody);
+  }
+}

vendor/google/apiclient/src/Google/Http/MediaFileUpload.php

@@ -0,0 +1,348 @@
+<?php
+/**
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use GuzzleHttp\Psr7;
+use GuzzleHttp\Psr7\Request;
+use GuzzleHttp\Psr7\Uri;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Manage large file uploads, which may be media but can be any type
+ * of sizable data.
+ */
+class Google_Http_MediaFileUpload
+{
+  const UPLOAD_MEDIA_TYPE = 'media';
+  const UPLOAD_MULTIPART_TYPE = 'multipart';
+  const UPLOAD_RESUMABLE_TYPE = 'resumable';
+
+  /** @var string $mimeType */
+  private $mimeType;
+
+  /** @var string $data */
+  private $data;
+
+  /** @var bool $resumable */
+  private $resumable;
+
+  /** @var int $chunkSize */
+  private $chunkSize;
+
+  /** @var int $size */
+  private $size;
+
+  /** @var string $resumeUri */
+  private $resumeUri;
+
+  /** @var int $progress */
+  private $progress;
+
+  /** @var Google_Client */
+  private $client;
+
+  /** @var Psr\Http\Message\RequestInterface */
+  private $request;
+
+  /** @var string */
+  private $boundary;
+
+  /**
+   * Result code from last HTTP call
+   * @var int
+   */
+  private $httpResultCode;
+
+  /**
+   * @param $mimeType string
+   * @param $data string The bytes you want to upload.
+   * @param $resumable bool
+   * @param bool $chunkSize File will be uploaded in chunks of this many bytes.
+   * only used if resumable=True
+   */
+  public function __construct(
+      Google_Client $client,
+      RequestInterface $request,
+      $mimeType,
+      $data,
+      $resumable = false,
+      $chunkSize = false
+  ) {
+    $this->client = $client;
+    $this->request = $request;
+    $this->mimeType = $mimeType;
+    $this->data = $data;
+    $this->resumable = $resumable;
+    $this->chunkSize = $chunkSize;
+    $this->progress = 0;
+
+    $this->process();
+  }
+
+  /**
+   * Set the size of the file that is being uploaded.
+   * @param $size - int file size in bytes
+   */
+  public function setFileSize($size)
+  {
+    $this->size = $size;
+  }
+
+  /**
+   * Return the progress on the upload
+   * @return int progress in bytes uploaded.
+   */
+  public function getProgress()
+  {
+    return $this->progress;
+  }
+
+  /**
+   * Send the next part of the file to upload.
+   * @param [$chunk] the next set of bytes to send. If false will used $data passed
+   * at construct time.
+   */
+  public function nextChunk($chunk = false)
+  {
+    $resumeUri = $this->getResumeUri();
+
+    if (false == $chunk) {
+      $chunk = substr($this->data, $this->progress, $this->chunkSize);
+    }
+
+    $lastBytePos = $this->progress + strlen($chunk) - 1;
+    $headers = array(
+      'content-range' => "bytes $this->progress-$lastBytePos/$this->size",
+      'content-length' => strlen($chunk),
+      'expect' => '',
+    );
+
+    $request = new Request(
+        'PUT',
+        $resumeUri,
+        $headers,
+        Psr7\stream_for($chunk)
+    );
+
+    return $this->makePutRequest($request);
+  }
+
+  /**
+   * Return the HTTP result code from the last call made.
+   * @return int code
+   */
+  public function getHttpResultCode()
+  {
+    return $this->httpResultCode;
+  }
+
+  /**
+  * Sends a PUT-Request to google drive and parses the response,
+  * setting the appropiate variables from the response()
+  *
+  * @param Google_Http_Request $httpRequest the Reuqest which will be send
+  *
+  * @return false|mixed false when the upload is unfinished or the decoded http response
+  *
+  */
+  private function makePutRequest(RequestInterface $request)
+  {
+    $response = $this->client->execute($request);
+    $this->httpResultCode = $response->getStatusCode();
+
+    if (308 == $this->httpResultCode) {
+      // Track the amount uploaded.
+      $range = explode('-', $response->getHeaderLine('range'));
+      $this->progress = $range[1] + 1;
+
+      // Allow for changing upload URLs.
+      $location = $response->getHeaderLine('location');
+      if ($location) {
+        $this->resumeUri = $location;
+      }
+
+      // No problems, but upload not complete.
+      return false;
+    }
+
+    return Google_Http_REST::decodeHttpResponse($response, $this->request);
+  }
+
+  /**
+   * Resume a previously unfinished upload
+   * @param $resumeUri the resume-URI of the unfinished, resumable upload.
+   */
+  public function resume($resumeUri)
+  {
+     $this->resumeUri = $resumeUri;
+     $headers = array(
+       'content-range' => "bytes */$this->size",
+       'content-length' => 0,
+     );
+     $httpRequest = new Request(
+         'PUT',
+         $this->resumeUri,
+         $headers
+     );
+
+     return $this->makePutRequest($httpRequest);
+  }
+
+  /**
+   * @return Psr\Http\Message\RequestInterface $request
+   * @visible for testing
+   */
+  private function process()
+  {
+    $this->transformToUploadUrl();
+    $request = $this->request;
+
+    $postBody = '';
+    $contentType = false;
+
+    $meta = (string) $request->getBody();
+    $meta = is_string($meta) ? json_decode($meta, true) : $meta;
+
+    $uploadType = $this->getUploadType($meta);
+    $request = $request->withUri(
+        Uri::withQueryValue($request->getUri(), 'uploadType', $uploadType)
+    );
+
+    $mimeType = $this->mimeType ?: $request->getHeaderLine('content-type');
+
+    if (self::UPLOAD_RESUMABLE_TYPE == $uploadType) {
+      $contentType = $mimeType;
+      $postBody = is_string($meta) ? $meta : json_encode($meta);
+    } else if (self::UPLOAD_MEDIA_TYPE == $uploadType) {
+      $contentType = $mimeType;
+      $postBody = $this->data;
+    } else if (self::UPLOAD_MULTIPART_TYPE == $uploadType) {
+      // This is a multipart/related upload.
+      $boundary = $this->boundary ?: mt_rand();
+      $boundary = str_replace('"', '', $boundary);
+      $contentType = 'multipart/related; boundary=' . $boundary;
+      $related = "--$boundary\r\n";
+      $related .= "Content-Type: application/json; charset=UTF-8\r\n";
+      $related .= "\r\n" . json_encode($meta) . "\r\n";
+      $related .= "--$boundary\r\n";
+      $related .= "Content-Type: $mimeType\r\n";
+      $related .= "Content-Transfer-Encoding: base64\r\n";
+      $related .= "\r\n" . base64_encode($this->data) . "\r\n";
+      $related .= "--$boundary--";
+      $postBody = $related;
+    }
+
+    $request = $request->withBody(Psr7\stream_for($postBody));
+
+    if (isset($contentType) && $contentType) {
+      $request = $request->withHeader('content-type', $contentType);
+    }
+
+    return $this->request = $request;
+  }
+
+  /**
+   * Valid upload types:
+   * - resumable (UPLOAD_RESUMABLE_TYPE)
+   * - media (UPLOAD_MEDIA_TYPE)
+   * - multipart (UPLOAD_MULTIPART_TYPE)
+   * @param $meta
+   * @return string
+   * @visible for testing
+   */
+  public function getUploadType($meta)
+  {
+    if ($this->resumable) {
+      return self::UPLOAD_RESUMABLE_TYPE;
+    }
+
+    if (false == $meta && $this->data) {
+      return self::UPLOAD_MEDIA_TYPE;
+    }
+
+    return self::UPLOAD_MULTIPART_TYPE;
+  }
+
+  public function getResumeUri()
+  {
+    if (null === $this->resumeUri) {
+      $this->resumeUri = $this->fetchResumeUri();
+    }
+
+    return $this->resumeUri;
+  }
+
+  private function fetchResumeUri()
+  {
+    $body = $this->request->getBody();
+    if ($body) {
+      $headers = array(
+        'content-type' => 'application/json; charset=UTF-8',
+        'content-length' => $body->getSize(),
+        'x-upload-content-type' => $this->mimeType,
+        'x-upload-content-length' => $this->size,
+        'expect' => '',
+      );
+      foreach ($headers as $key => $value) {
+        $this->request = $this->request->withHeader($key, $value);
+      }
+    }
+
+    $response = $this->client->execute($this->request, false);
+    $location = $response->getHeaderLine('location');
+    $code = $response->getStatusCode();
+
+    if (200 == $code && true == $location) {
+      return $location;
+    }
+
+    $message = $code;
+    $body = json_decode((string) $this->request->getBody(), true);
+    if (isset($body['error']['errors'])) {
+      $message .= ': ';
+      foreach ($body['error']['errors'] as $error) {
+        $message .= "{$error[domain]}, {$error[message]};";
+      }
+      $message = rtrim($message, ';');
+    }
+
+    $error = "Failed to start the resumable upload (HTTP {$message})";
+    $this->client->getLogger()->error($error);
+
+    throw new Google_Exception($error);
+  }
+
+  private function transformToUploadUrl()
+  {
+    $parts = parse_url((string) $this->request->getUri());
+    if (!isset($parts['path'])) {
+      $parts['path'] = '';
+    }
+    $parts['path'] = '/upload' . $parts['path'];
+    $uri = Uri::fromParts($parts);
+    $this->request = $this->request->withUri($uri);
+  }
+
+  public function setChunkSize($chunkSize)
+  {
+    $this->chunkSize = $chunkSize;
+  }
+
+  public function getRequest()
+  {
+    return $this->request;
+  }
+}

vendor/google/apiclient/src/Google/Http/REST.php

@@ -0,0 +1,182 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use Google\Auth\HttpHandler\HttpHandlerFactory;
+use GuzzleHttp\ClientInterface;
+use GuzzleHttp\Exception\RequestException;
+use GuzzleHttp\Psr7\Response;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * This class implements the RESTful transport of apiServiceRequest()'s
+ */
+class Google_Http_REST
+{
+  /**
+   * Executes a Psr\Http\Message\RequestInterface and (if applicable) automatically retries
+   * when errors occur.
+   *
+   * @param Google_Client $client
+   * @param Psr\Http\Message\RequestInterface $req
+   * @return array decoded result
+   * @throws Google_Service_Exception on server side error (ie: not authenticated,
+   *  invalid or malformed post body, invalid url)
+   */
+  public static function execute(
+      ClientInterface $client,
+      RequestInterface $request,
+      $expectedClass = null,
+      $config = array(),
+      $retryMap = null
+  ) {
+    $runner = new Google_Task_Runner(
+        $config,
+        sprintf('%s %s', $request->getMethod(), (string) $request->getUri()),
+        array(get_class(), 'doExecute'),
+        array($client, $request, $expectedClass)
+    );
+
+    if (null !== $retryMap) {
+      $runner->setRetryMap($retryMap);
+    }
+
+    return $runner->run();
+  }
+
+  /**
+   * Executes a Psr\Http\Message\RequestInterface
+   *
+   * @param Google_Client $client
+   * @param Psr\Http\Message\RequestInterface $request
+   * @return array decoded result
+   * @throws Google_Service_Exception on server side error (ie: not authenticated,
+   *  invalid or malformed post body, invalid url)
+   */
+  public static function doExecute(ClientInterface $client, RequestInterface $request, $expectedClass = null)
+  {
+    try {
+      $httpHandler = HttpHandlerFactory::build($client);
+      $response = $httpHandler($request);
+    } catch (RequestException $e) {
+      // if Guzzle throws an exception, catch it and handle the response
+      if (!$e->hasResponse()) {
+        throw $e;
+      }
+
+      $response = $e->getResponse();
+      // specific checking for Guzzle 5: convert to PSR7 response
+      if ($response instanceof \GuzzleHttp\Message\ResponseInterface) {
+        $response = new Response(
+            $response->getStatusCode(),
+            $response->getHeaders() ?: [],
+            $response->getBody(),
+            $response->getProtocolVersion(),
+            $response->getReasonPhrase()
+        );
+      }
+    }
+
+    return self::decodeHttpResponse($response, $request, $expectedClass);
+  }
+
+  /**
+   * Decode an HTTP Response.
+   * @static
+   * @throws Google_Service_Exception
+   * @param Psr\Http\Message\RequestInterface $response The http response to be decoded.
+   * @param Psr\Http\Message\ResponseInterface $response
+   * @return mixed|null
+   */
+  public static function decodeHttpResponse(
+      ResponseInterface $response,
+      RequestInterface $request = null,
+      $expectedClass = null
+  ) {
+    $code = $response->getStatusCode();
+
+    // retry strategy
+    if (intVal($code) >= 400) {
+      // if we errored out, it should be safe to grab the response body
+      $body = (string) $response->getBody();
+
+      // Check if we received errors, and add those to the Exception for convenience
+      throw new Google_Service_Exception($body, $code, null, self::getResponseErrors($body));
+    }
+
+    // Ensure we only pull the entire body into memory if the request is not
+    // of media type
+    $body = self::decodeBody($response, $request);
+
+    if ($expectedClass = self::determineExpectedClass($expectedClass, $request)) {
+      $json = json_decode($body, true);
+
+      return new $expectedClass($json);
+    }
+
+    return $response;
+  }
+
+  private static function decodeBody(ResponseInterface $response, RequestInterface $request = null)
+  {
+    if (self::isAltMedia($request)) {
+      // don't decode the body, it's probably a really long string
+      return '';
+    }
+
+    return (string) $response->getBody();
+  }
+
+  private static function determineExpectedClass($expectedClass, RequestInterface $request = null)
+  {
+    // "false" is used to explicitly prevent an expected class from being returned
+    if (false === $expectedClass) {
+      return null;
+    }
+
+    // if we don't have a request, we just use what's passed in
+    if (null === $request) {
+      return $expectedClass;
+    }
+
+    // return what we have in the request header if one was not supplied
+    return $expectedClass ?: $request->getHeaderLine('X-Php-Expected-Class');
+  }
+
+  private static function getResponseErrors($body)
+  {
+    $json = json_decode($body, true);
+
+    if (isset($json['error']['errors'])) {
+      return $json['error']['errors'];
+    }
+
+    return null;
+  }
+
+  private static function isAltMedia(RequestInterface $request = null)
+  {
+    if ($request && $qs = $request->getUri()->getQuery()) {
+      parse_str($qs, $query);
+      if (isset($query['alt']) && $query['alt'] == 'media') {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}

vendor/google/apiclient/src/Google/Model.php

@@ -0,0 +1,307 @@
+<?php
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This class defines attributes, valid values, and usage which is generated
+ * from a given json schema.
+ * http://tools.ietf.org/html/draft-zyp-json-schema-03#section-5
+ *
+ */
+class Google_Model implements ArrayAccess
+{
+  /**
+   * If you need to specify a NULL JSON value, use Google_Model::NULL_VALUE
+   * instead - it will be replaced when converting to JSON with a real null.
+   */
+  const NULL_VALUE = "{}gapi-php-null";
+  protected $internal_gapi_mappings = array();
+  protected $modelData = array();
+  protected $processed = array();
+
+  /**
+   * Polymorphic - accepts a variable number of arguments dependent
+   * on the type of the model subclass.
+   */
+  final public function __construct()
+  {
+    if (func_num_args() == 1 && is_array(func_get_arg(0))) {
+      // Initialize the model with the array's contents.
+      $array = func_get_arg(0);
+      $this->mapTypes($array);
+    }
+    $this->gapiInit();
+  }
+
+  /**
+   * Getter that handles passthrough access to the data array, and lazy object creation.
+   * @param string $key Property name.
+   * @return mixed The value if any, or null.
+   */
+  public function __get($key)
+  {
+    $keyTypeName = $this->keyType($key);
+    $keyDataType = $this->dataType($key);
+    if (isset($this->$keyTypeName) && !isset($this->processed[$key])) {
+      if (isset($this->modelData[$key])) {
+        $val = $this->modelData[$key];
+      } else if (isset($this->$keyDataType) &&
+          ($this->$keyDataType == 'array' || $this->$keyDataType == 'map')) {
+        $val = array();
+      } else {
+        $val = null;
+      }
+
+      if ($this->isAssociativeArray($val)) {
+        if (isset($this->$keyDataType) && 'map' == $this->$keyDataType) {
+          foreach ($val as $arrayKey => $arrayItem) {
+              $this->modelData[$key][$arrayKey] =
+                $this->createObjectFromName($keyTypeName, $arrayItem);
+          }
+        } else {
+          $this->modelData[$key] = $this->createObjectFromName($keyTypeName, $val);
+        }
+      } else if (is_array($val)) {
+        $arrayObject = array();
+        foreach ($val as $arrayIndex => $arrayItem) {
+          $arrayObject[$arrayIndex] =
+            $this->createObjectFromName($keyTypeName, $arrayItem);
+        }
+        $this->modelData[$key] = $arrayObject;
+      }
+      $this->processed[$key] = true;
+    }
+
+    return isset($this->modelData[$key]) ? $this->modelData[$key] : null;
+  }
+
+  /**
+   * Initialize this object's properties from an array.
+   *
+   * @param array $array Used to seed this object's properties.
+   * @return void
+   */
+  protected function mapTypes($array)
+  {
+    // Hard initialise simple types, lazy load more complex ones.
+    foreach ($array as $key => $val) {
+      if ( !property_exists($this, $this->keyType($key)) &&
+        property_exists($this, $key)) {
+          $this->$key = $val;
+          unset($array[$key]);
+      } elseif (property_exists($this, $camelKey = $this->camelCase($key))) {
+          // This checks if property exists as camelCase, leaving it in array as snake_case
+          // in case of backwards compatibility issues.
+          $this->$camelKey = $val;
+      }
+    }
+    $this->modelData = $array;
+  }
+
+  /**
+   * Blank initialiser to be used in subclasses to do  post-construction initialisation - this
+   * avoids the need for subclasses to have to implement the variadics handling in their
+   * constructors.
+   */
+  protected function gapiInit()
+  {
+    return;
+  }
+
+  /**
+   * Create a simplified object suitable for straightforward
+   * conversion to JSON. This is relatively expensive
+   * due to the usage of reflection, but shouldn't be called
+   * a whole lot, and is the most straightforward way to filter.
+   */
+  public function toSimpleObject()
+  {
+    $object = new stdClass();
+
+    // Process all other data.
+    foreach ($this->modelData as $key => $val) {
+      $result = $this->getSimpleValue($val);
+      if ($result !== null) {
+        $object->$key = $this->nullPlaceholderCheck($result);
+      }
+    }
+
+    // Process all public properties.
+    $reflect = new ReflectionObject($this);
+    $props = $reflect->getProperties(ReflectionProperty::IS_PUBLIC);
+    foreach ($props as $member) {
+      $name = $member->getName();
+      $result = $this->getSimpleValue($this->$name);
+      if ($result !== null) {
+        $name = $this->getMappedName($name);
+        $object->$name = $this->nullPlaceholderCheck($result);
+      }
+    }
+
+    return $object;
+  }
+
+  /**
+   * Handle different types of values, primarily
+   * other objects and map and array data types.
+   */
+  private function getSimpleValue($value)
+  {
+    if ($value instanceof Google_Model) {
+      return $value->toSimpleObject();
+    } else if (is_array($value)) {
+      $return = array();
+      foreach ($value as $key => $a_value) {
+        $a_value = $this->getSimpleValue($a_value);
+        if ($a_value !== null) {
+          $key = $this->getMappedName($key);
+          $return[$key] = $this->nullPlaceholderCheck($a_value);
+        }
+      }
+      return $return;
+    }
+    return $value;
+  }
+
+  /**
+   * Check whether the value is the null placeholder and return true null.
+   */
+  private function nullPlaceholderCheck($value)
+  {
+    if ($value === self::NULL_VALUE) {
+      return null;
+    }
+    return $value;
+  }
+
+  /**
+   * If there is an internal name mapping, use that.
+   */
+  private function getMappedName($key)
+  {
+    if (isset($this->internal_gapi_mappings, $this->internal_gapi_mappings[$key])) {
+      $key = $this->internal_gapi_mappings[$key];
+    }
+    return $key;
+  }
+
+  /**
+   * Returns true only if the array is associative.
+   * @param array $array
+   * @return bool True if the array is associative.
+   */
+  protected function isAssociativeArray($array)
+  {
+    if (!is_array($array)) {
+      return false;
+    }
+    $keys = array_keys($array);
+    foreach ($keys as $key) {
+      if (is_string($key)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Given a variable name, discover its type.
+   *
+   * @param $name
+   * @param $item
+   * @return object The object from the item.
+   */
+  private function createObjectFromName($name, $item)
+  {
+    $type = $this->$name;
+    return new $type($item);
+  }
+
+  /**
+   * Verify if $obj is an array.
+   * @throws Google_Exception Thrown if $obj isn't an array.
+   * @param array $obj Items that should be validated.
+   * @param string $method Method expecting an array as an argument.
+   */
+  public function assertIsArray($obj, $method)
+  {
+    if ($obj && !is_array($obj)) {
+      throw new Google_Exception(
+          "Incorrect parameter type passed to $method(). Expected an array."
+      );
+    }
+  }
+
+  public function offsetExists($offset)
+  {
+    return isset($this->$offset) || isset($this->modelData[$offset]);
+  }
+
+  public function offsetGet($offset)
+  {
+    return isset($this->$offset) ?
+        $this->$offset :
+        $this->__get($offset);
+  }
+
+  public function offsetSet($offset, $value)
+  {
+    if (property_exists($this, $offset)) {
+      $this->$offset = $value;
+    } else {
+      $this->modelData[$offset] = $value;
+      $this->processed[$offset] = true;
+    }
+  }
+
+  public function offsetUnset($offset)
+  {
+    unset($this->modelData[$offset]);
+  }
+
+  protected function keyType($key)
+  {
+    return $key . "Type";
+  }
+
+  protected function dataType($key)
+  {
+    return $key . "DataType";
+  }
+
+  public function __isset($key)
+  {
+    return isset($this->modelData[$key]);
+  }
+
+  public function __unset($key)
+  {
+    unset($this->modelData[$key]);
+  }
+
+  /**
+   * Convert a string to camelCase
+   * @param  string $value
+   * @return string
+   */
+  private function camelCase($value)
+  {
+    $value = ucwords(str_replace(array('-', '_'), ' ', $value));
+    $value = str_replace(' ', '', $value);
+    $value[0] = strtolower($value[0]);
+    return $value;
+  }
+}

vendor/google/apiclient/src/Google/Service.php

@@ -0,0 +1,56 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class Google_Service
+{
+  public $batchPath;
+  public $rootUrl;
+  public $version;
+  public $servicePath;
+  public $availableScopes;
+  public $resource;
+  private $client;
+
+  public function __construct(Google_Client $client)
+  {
+    $this->client = $client;
+  }
+
+  /**
+   * Return the associated Google_Client class.
+   * @return Google_Client
+   */
+  public function getClient()
+  {
+    return $this->client;
+  }
+
+  /**
+   * Create a new HTTP Batch handler for this service
+   *
+   * @return Google_Http_Batch
+   */
+  public function createBatch()
+  {
+    return new Google_Http_Batch(
+        $this->client,
+        false,
+        $this->rootUrl,
+        $this->batchPath
+    );
+  }
+}

vendor/google/apiclient/src/Google/Service/Exception.php

@@ -0,0 +1,68 @@
+<?php
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class Google_Service_Exception extends Google_Exception
+{
+  /**
+   * Optional list of errors returned in a JSON body of an HTTP error response.
+   */
+  protected $errors = array();
+
+  /**
+   * Override default constructor to add the ability to set $errors and a retry
+   * map.
+   *
+   * @param string $message
+   * @param int $code
+   * @param Exception|null $previous
+   * @param [{string, string}] errors List of errors returned in an HTTP
+   * response.  Defaults to [].
+   * @param array|null $retryMap Map of errors with retry counts.
+   */
+  public function __construct(
+      $message,
+      $code = 0,
+      Exception $previous = null,
+      $errors = array()
+  ) {
+    if (version_compare(PHP_VERSION, '5.3.0') >= 0) {
+      parent::__construct($message, $code, $previous);
+    } else {
+      parent::__construct($message, $code);
+    }
+
+    $this->errors = $errors;
+  }
+
+  /**
+   * An example of the possible errors returned.
+   *
+   * {
+   *   "domain": "global",
+   *   "reason": "authError",
+   *   "message": "Invalid Credentials",
+   *   "locationType": "header",
+   *   "location": "Authorization",
+   * }
+   *
+   * @return [{string, string}] List of errors return in an HTTP response or [].
+   */
+  public function getErrors()
+  {
+    return $this->errors;
+  }
+}

vendor/google/apiclient/src/Google/Service/README.md

@@ -0,0 +1,5 @@
+# Google API Client Services
+
+Google API Client Service classes have been moved to the 
+[google-api-php-client-services](https://github.com/google/google-api-php-client-services) 
+repository. 

vendor/google/apiclient/src/Google/Service/Resource.php

@@ -0,0 +1,296 @@
+<?php
+/**
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use GuzzleHttp\Psr7\Request;
+
+/**
+ * Implements the actual methods/resources of the discovered Google API using magic function
+ * calling overloading (__call()), which on call will see if the method name (plus.activities.list)
+ * is available in this service, and if so construct an apiHttpRequest representing it.
+ *
+ */
+class Google_Service_Resource
+{
+  // Valid query parameters that work, but don't appear in discovery.
+  private $stackParameters = array(
+      'alt' => array('type' => 'string', 'location' => 'query'),
+      'fields' => array('type' => 'string', 'location' => 'query'),
+      'trace' => array('type' => 'string', 'location' => 'query'),
+      'userIp' => array('type' => 'string', 'location' => 'query'),
+      'quotaUser' => array('type' => 'string', 'location' => 'query'),
+      'data' => array('type' => 'string', 'location' => 'body'),
+      'mimeType' => array('type' => 'string', 'location' => 'header'),
+      'uploadType' => array('type' => 'string', 'location' => 'query'),
+      'mediaUpload' => array('type' => 'complex', 'location' => 'query'),
+      'prettyPrint' => array('type' => 'string', 'location' => 'query'),
+  );
+
+  /** @var string $rootUrl */
+  private $rootUrl;
+
+  /** @var Google_Client $client */
+  private $client;
+
+  /** @var string $serviceName */
+  private $serviceName;
+
+  /** @var string $servicePath */
+  private $servicePath;
+
+  /** @var string $resourceName */
+  private $resourceName;
+
+  /** @var array $methods */
+  private $methods;
+
+  public function __construct($service, $serviceName, $resourceName, $resource)
+  {
+    $this->rootUrl = $service->rootUrl;
+    $this->client = $service->getClient();
+    $this->servicePath = $service->servicePath;
+    $this->serviceName = $serviceName;
+    $this->resourceName = $resourceName;
+    $this->methods = is_array($resource) && isset($resource['methods']) ?
+        $resource['methods'] :
+        array($resourceName => $resource);
+  }
+
+  /**
+   * TODO: This function needs simplifying.
+   * @param $name
+   * @param $arguments
+   * @param $expectedClass - optional, the expected class name
+   * @return Google_Http_Request|expectedClass
+   * @throws Google_Exception
+   */
+  public function call($name, $arguments, $expectedClass = null)
+  {
+    if (! isset($this->methods[$name])) {
+      $this->client->getLogger()->error(
+          'Service method unknown',
+          array(
+              'service' => $this->serviceName,
+              'resource' => $this->resourceName,
+              'method' => $name
+          )
+      );
+
+      throw new Google_Exception(
+          "Unknown function: " .
+          "{$this->serviceName}->{$this->resourceName}->{$name}()"
+      );
+    }
+    $method = $this->methods[$name];
+    $parameters = $arguments[0];
+
+    // postBody is a special case since it's not defined in the discovery
+    // document as parameter, but we abuse the param entry for storing it.
+    $postBody = null;
+    if (isset($parameters['postBody'])) {
+      if ($parameters['postBody'] instanceof Google_Model) {
+        // In the cases the post body is an existing object, we want
+        // to use the smart method to create a simple object for
+        // for JSONification.
+        $parameters['postBody'] = $parameters['postBody']->toSimpleObject();
+      } else if (is_object($parameters['postBody'])) {
+        // If the post body is another kind of object, we will try and
+        // wrangle it into a sensible format.
+        $parameters['postBody'] =
+            $this->convertToArrayAndStripNulls($parameters['postBody']);
+      }
+      $postBody = (array) $parameters['postBody'];
+      unset($parameters['postBody']);
+    }
+
+    // TODO: optParams here probably should have been
+    // handled already - this may well be redundant code.
+    if (isset($parameters['optParams'])) {
+      $optParams = $parameters['optParams'];
+      unset($parameters['optParams']);
+      $parameters = array_merge($parameters, $optParams);
+    }
+
+    if (!isset($method['parameters'])) {
+      $method['parameters'] = array();
+    }
+
+    $method['parameters'] = array_merge(
+        $this->stackParameters,
+        $method['parameters']
+    );
+
+    foreach ($parameters as $key => $val) {
+      if ($key != 'postBody' && ! isset($method['parameters'][$key])) {
+        $this->client->getLogger()->error(
+            'Service parameter unknown',
+            array(
+                'service' => $this->serviceName,
+                'resource' => $this->resourceName,
+                'method' => $name,
+                'parameter' => $key
+            )
+        );
+        throw new Google_Exception("($name) unknown parameter: '$key'");
+      }
+    }
+
+    foreach ($method['parameters'] as $paramName => $paramSpec) {
+      if (isset($paramSpec['required']) &&
+          $paramSpec['required'] &&
+          ! isset($parameters[$paramName])
+      ) {
+        $this->client->getLogger()->error(
+            'Service parameter missing',
+            array(
+                'service' => $this->serviceName,
+                'resource' => $this->resourceName,
+                'method' => $name,
+                'parameter' => $paramName
+            )
+        );
+        throw new Google_Exception("($name) missing required param: '$paramName'");
+      }
+      if (isset($parameters[$paramName])) {
+        $value = $parameters[$paramName];
+        $parameters[$paramName] = $paramSpec;
+        $parameters[$paramName]['value'] = $value;
+        unset($parameters[$paramName]['required']);
+      } else {
+        // Ensure we don't pass nulls.
+        unset($parameters[$paramName]);
+      }
+    }
+
+    $this->client->getLogger()->info(
+        'Service Call',
+        array(
+            'service' => $this->serviceName,
+            'resource' => $this->resourceName,
+            'method' => $name,
+            'arguments' => $parameters,
+        )
+    );
+
+    // build the service uri
+    $url = $this->createRequestUri(
+        $method['path'],
+        $parameters
+    );
+
+    // NOTE: because we're creating the request by hand,
+    // and because the service has a rootUrl property
+    // the "base_uri" of the Http Client is not accounted for
+    $request = new Request(
+        $method['httpMethod'],
+        $url,
+        ['content-type' => 'application/json'],
+        $postBody ? json_encode($postBody) : ''
+    );
+
+    // support uploads
+    if (isset($parameters['data'])) {
+      $mimeType = isset($parameters['mimeType'])
+        ? $parameters['mimeType']['value']
+        : 'application/octet-stream';
+      $data = $parameters['data']['value'];
+      $upload = new Google_Http_MediaFileUpload($this->client, $request, $mimeType, $data);
+
+      // pull down the modified request
+      $request = $upload->getRequest();
+    }
+
+    // if this is a media type, we will return the raw response
+    // rather than using an expected class
+    if (isset($parameters['alt']) && $parameters['alt']['value'] == 'media') {
+      $expectedClass = null;
+    }
+
+    // if the client is marked for deferring, rather than
+    // execute the request, return the response
+    if ($this->client->shouldDefer()) {
+      // @TODO find a better way to do this
+      $request = $request
+        ->withHeader('X-Php-Expected-Class', $expectedClass);
+
+      return $request;
+    }
+
+    return $this->client->execute($request, $expectedClass);
+  }
+
+  protected function convertToArrayAndStripNulls($o)
+  {
+    $o = (array) $o;
+    foreach ($o as $k => $v) {
+      if ($v === null) {
+        unset($o[$k]);
+      } elseif (is_object($v) || is_array($v)) {
+        $o[$k] = $this->convertToArrayAndStripNulls($o[$k]);
+      }
+    }
+    return $o;
+  }
+
+  /**
+   * Parse/expand request parameters and create a fully qualified
+   * request uri.
+   * @static
+   * @param string $restPath
+   * @param array $params
+   * @return string $requestUrl
+   */
+  public function createRequestUri($restPath, $params)
+  {
+    // code for leading slash
+    $requestUrl = $this->servicePath . $restPath;
+    if ($this->rootUrl) {
+      if ('/' !== substr($this->rootUrl, -1) && '/' !== substr($requestUrl, 0, 1)) {
+        $requestUrl = '/' . $requestUrl;
+      }
+      $requestUrl = $this->rootUrl . $requestUrl;
+    }
+    $uriTemplateVars = array();
+    $queryVars = array();
+    foreach ($params as $paramName => $paramSpec) {
+      if ($paramSpec['type'] == 'boolean') {
+        $paramSpec['value'] = $paramSpec['value'] ? 'true' : 'false';
+      }
+      if ($paramSpec['location'] == 'path') {
+        $uriTemplateVars[$paramName] = $paramSpec['value'];
+      } else if ($paramSpec['location'] == 'query') {
+        if (isset($paramSpec['repeated']) && is_array($paramSpec['value'])) {
+          foreach ($paramSpec['value'] as $value) {
+            $queryVars[] = $paramName . '=' . rawurlencode(rawurldecode($value));
+          }
+        } else {
+          $queryVars[] = $paramName . '=' . rawurlencode(rawurldecode($paramSpec['value']));
+        }
+      }
+    }
+
+    if (count($uriTemplateVars)) {
+      $uriTemplateParser = new Google_Utils_UriTemplate();
+      $requestUrl = $uriTemplateParser->parse($requestUrl, $uriTemplateVars);
+    }
+
+    if (count($queryVars)) {
+      $requestUrl .= '?' . implode($queryVars, '&');
+    }
+
+    return $requestUrl;
+  }
+}

vendor/google/apiclient/src/Google/Task/Exception.php

@@ -0,0 +1,20 @@
+<?php
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class Google_Task_Exception extends Google_Exception
+{
+}

vendor/google/apiclient/src/Google/Task/Retryable.php

@@ -0,0 +1,24 @@
+<?php
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Interface for checking how many times a given task can be retried following
+ * a failure.
+ */
+interface Google_Task_Retryable
+{
+}

vendor/google/apiclient/src/Google/Task/Runner.php

@@ -0,0 +1,281 @@
+<?php
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * A task runner with exponential backoff support.
+ *
+ * @see https://developers.google.com/drive/web/handle-errors#implementing_exponential_backoff
+ */
+class Google_Task_Runner
+{
+  const TASK_RETRY_NEVER = 0;
+  const TASK_RETRY_ONCE = 1;
+  const TASK_RETRY_ALWAYS = -1;
+
+  /**
+   * @var integer $maxDelay The max time (in seconds) to wait before a retry.
+   */
+  private $maxDelay = 60;
+  /**
+   * @var integer $delay The previous delay from which the next is calculated.
+   */
+  private $delay = 1;
+
+  /**
+   * @var integer $factor The base number for the exponential back off.
+   */
+  private $factor = 2;
+  /**
+   * @var float $jitter A random number between -$jitter and $jitter will be
+   * added to $factor on each iteration to allow for a better distribution of
+   * retries.
+   */
+  private $jitter = 0.5;
+
+  /**
+   * @var integer $attempts The number of attempts that have been tried so far.
+   */
+  private $attempts = 0;
+  /**
+   * @var integer $maxAttempts The max number of attempts allowed.
+   */
+  private $maxAttempts = 1;
+
+  /**
+   * @var callable $action The task to run and possibly retry.
+   */
+  private $action;
+  /**
+   * @var array $arguments The task arguments.
+   */
+  private $arguments;
+
+  /**
+   * @var array $retryMap Map of errors with retry counts.
+   */
+  protected $retryMap = [
+    '500' => self::TASK_RETRY_ALWAYS,
+    '503' => self::TASK_RETRY_ALWAYS,
+    'rateLimitExceeded' => self::TASK_RETRY_ALWAYS,
+    'userRateLimitExceeded' => self::TASK_RETRY_ALWAYS,
+    6  => self::TASK_RETRY_ALWAYS,  // CURLE_COULDNT_RESOLVE_HOST
+    7  => self::TASK_RETRY_ALWAYS,  // CURLE_COULDNT_CONNECT
+    28 => self::TASK_RETRY_ALWAYS,  // CURLE_OPERATION_TIMEOUTED
+    35 => self::TASK_RETRY_ALWAYS,  // CURLE_SSL_CONNECT_ERROR
+    52 => self::TASK_RETRY_ALWAYS   // CURLE_GOT_NOTHING
+  ];
+
+  /**
+   * Creates a new task runner with exponential backoff support.
+   *
+   * @param array $config The task runner config
+   * @param string $name The name of the current task (used for logging)
+   * @param callable $action The task to run and possibly retry
+   * @param array $arguments The task arguments
+   * @throws Google_Task_Exception when misconfigured
+   */
+  public function __construct(
+      $config,
+      $name,
+      $action,
+      array $arguments = array()
+  ) {
+    if (isset($config['initial_delay'])) {
+      if ($config['initial_delay'] < 0) {
+        throw new Google_Task_Exception(
+            'Task configuration `initial_delay` must not be negative.'
+        );
+      }
+
+      $this->delay = $config['initial_delay'];
+    }
+
+    if (isset($config['max_delay'])) {
+      if ($config['max_delay'] <= 0) {
+        throw new Google_Task_Exception(
+            'Task configuration `max_delay` must be greater than 0.'
+        );
+      }
+
+      $this->maxDelay = $config['max_delay'];
+    }
+
+    if (isset($config['factor'])) {
+      if ($config['factor'] <= 0) {
+        throw new Google_Task_Exception(
+            'Task configuration `factor` must be greater than 0.'
+        );
+      }
+
+      $this->factor = $config['factor'];
+    }
+
+    if (isset($config['jitter'])) {
+      if ($config['jitter'] <= 0) {
+        throw new Google_Task_Exception(
+            'Task configuration `jitter` must be greater than 0.'
+        );
+      }
+
+      $this->jitter = $config['jitter'];
+    }
+
+    if (isset($config['retries'])) {
+      if ($config['retries'] < 0) {
+        throw new Google_Task_Exception(
+            'Task configuration `retries` must not be negative.'
+        );
+      }
+      $this->maxAttempts += $config['retries'];
+    }
+
+    if (!is_callable($action)) {
+        throw new Google_Task_Exception(
+            'Task argument `$action` must be a valid callable.'
+        );
+    }
+
+    $this->action = $action;
+    $this->arguments = $arguments;
+  }
+
+  /**
+   * Checks if a retry can be attempted.
+   *
+   * @return boolean
+   */
+  public function canAttempt()
+  {
+    return $this->attempts < $this->maxAttempts;
+  }
+
+  /**
+   * Runs the task and (if applicable) automatically retries when errors occur.
+   *
+   * @return mixed
+   * @throws Google_Task_Retryable on failure when no retries are available.
+   */
+  public function run()
+  {
+    while ($this->attempt()) {
+      try {
+        return call_user_func_array($this->action, $this->arguments);
+      } catch (Google_Service_Exception $exception) {
+        $allowedRetries = $this->allowedRetries(
+            $exception->getCode(),
+            $exception->getErrors()
+        );
+
+        if (!$this->canAttempt() || !$allowedRetries) {
+          throw $exception;
+        }
+
+        if ($allowedRetries > 0) {
+          $this->maxAttempts = min(
+              $this->maxAttempts,
+              $this->attempts + $allowedRetries
+          );
+        }
+      }
+    }
+  }
+
+  /**
+   * Runs a task once, if possible. This is useful for bypassing the `run()`
+   * loop.
+   *
+   * NOTE: If this is not the first attempt, this function will sleep in
+   * accordance to the backoff configurations before running the task.
+   *
+   * @return boolean
+   */
+  public function attempt()
+  {
+    if (!$this->canAttempt()) {
+      return false;
+    }
+
+    if ($this->attempts > 0) {
+      $this->backOff();
+    }
+
+    $this->attempts++;
+    return true;
+  }
+
+  /**
+   * Sleeps in accordance to the backoff configurations.
+   */
+  private function backOff()
+  {
+    $delay = $this->getDelay();
+
+    usleep($delay * 1000000);
+  }
+
+  /**
+   * Gets the delay (in seconds) for the current backoff period.
+   *
+   * @return float
+   */
+  private function getDelay()
+  {
+    $jitter = $this->getJitter();
+    $factor = $this->attempts > 1 ? $this->factor + $jitter : 1 + abs($jitter);
+
+    return $this->delay = min($this->maxDelay, $this->delay * $factor);
+  }
+
+  /**
+   * Gets the current jitter (random number between -$this->jitter and
+   * $this->jitter).
+   *
+   * @return float
+   */
+  private function getJitter()
+  {
+    return $this->jitter * 2 * mt_rand() / mt_getrandmax() - $this->jitter;
+  }
+
+  /**
+   * Gets the number of times the associated task can be retried.
+   *
+   * NOTE: -1 is returned if the task can be retried indefinitely
+   *
+   * @return integer
+   */
+  public function allowedRetries($code, $errors = array())
+  {
+    if (isset($this->retryMap[$code])) {
+      return $this->retryMap[$code];
+    }
+
+    if (
+        !empty($errors) &&
+        isset($errors[0]['reason'], $this->retryMap[$errors[0]['reason']])
+    ) {
+      return $this->retryMap[$errors[0]['reason']];
+    }
+
+    return 0;
+  }
+
+  public function setRetryMap($retryMap)
+  {
+    $this->retryMap = $retryMap;
+  }
+}

vendor/google/apiclient/src/Google/Utils/UriTemplate.php

@@ -0,0 +1,333 @@
+<?php
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Implementation of levels 1-3 of the URI Template spec.
+ * @see http://tools.ietf.org/html/rfc6570
+ */
+class Google_Utils_UriTemplate
+{
+  const TYPE_MAP = "1";
+  const TYPE_LIST = "2";
+  const TYPE_SCALAR = "4";
+
+  /**
+   * @var $operators array
+   * These are valid at the start of a template block to
+   * modify the way in which the variables inside are
+   * processed.
+   */
+  private $operators = array(
+      "+" => "reserved",
+      "/" => "segments",
+      "." => "dotprefix",
+      "#" => "fragment",
+      ";" => "semicolon",
+      "?" => "form",
+      "&" => "continuation"
+  );
+
+  /**
+   * @var reserved array
+   * These are the characters which should not be URL encoded in reserved
+   * strings.
+   */
+  private $reserved = array(
+      "=", ",", "!", "@", "|", ":", "/", "?", "#",
+      "[", "]",'$', "&", "'", "(", ")", "*", "+", ";"
+  );
+  private $reservedEncoded = array(
+    "%3D", "%2C", "%21", "%40", "%7C", "%3A", "%2F", "%3F",
+    "%23", "%5B", "%5D", "%24", "%26", "%27", "%28", "%29",
+    "%2A", "%2B", "%3B"
+  );
+
+  public function parse($string, array $parameters)
+  {
+    return $this->resolveNextSection($string, $parameters);
+  }
+
+  /**
+   * This function finds the first matching {...} block and
+   * executes the replacement. It then calls itself to find
+   * subsequent blocks, if any.
+   */
+  private function resolveNextSection($string, $parameters)
+  {
+    $start = strpos($string, "{");
+    if ($start === false) {
+      return $string;
+    }
+    $end = strpos($string, "}");
+    if ($end === false) {
+      return $string;
+    }
+    $string = $this->replace($string, $start, $end, $parameters);
+    return $this->resolveNextSection($string, $parameters);
+  }
+
+  private function replace($string, $start, $end, $parameters)
+  {
+    // We know a data block will have {} round it, so we can strip that.
+    $data = substr($string, $start + 1, $end - $start - 1);
+
+    // If the first character is one of the reserved operators, it effects
+    // the processing of the stream.
+    if (isset($this->operators[$data[0]])) {
+      $op = $this->operators[$data[0]];
+      $data = substr($data, 1);
+      $prefix = "";
+      $prefix_on_missing = false;
+
+      switch ($op) {
+        case "reserved":
+          // Reserved means certain characters should not be URL encoded
+          $data = $this->replaceVars($data, $parameters, ",", null, true);
+          break;
+        case "fragment":
+          // Comma separated with fragment prefix. Bare values only.
+          $prefix = "#";
+          $prefix_on_missing = true;
+          $data = $this->replaceVars($data, $parameters, ",", null, true);
+          break;
+        case "segments":
+          // Slash separated data. Bare values only.
+          $prefix = "/";
+          $data =$this->replaceVars($data, $parameters, "/");
+          break;
+        case "dotprefix":
+          // Dot separated data. Bare values only.
+          $prefix = ".";
+          $prefix_on_missing = true;
+          $data = $this->replaceVars($data, $parameters, ".");
+          break;
+        case "semicolon":
+          // Semicolon prefixed and separated. Uses the key name
+          $prefix = ";";
+          $data = $this->replaceVars($data, $parameters, ";", "=", false, true, false);
+          break;
+        case "form":
+          // Standard URL format. Uses the key name
+          $prefix = "?";
+          $data = $this->replaceVars($data, $parameters, "&", "=");
+          break;
+        case "continuation":
+          // Standard URL, but with leading ampersand. Uses key name.
+          $prefix = "&";
+          $data = $this->replaceVars($data, $parameters, "&", "=");
+          break;
+      }
+
+      // Add the initial prefix character if data is valid.
+      if ($data || ($data !== false && $prefix_on_missing)) {
+        $data = $prefix . $data;
+      }
+
+    } else {
+      // If no operator we replace with the defaults.
+      $data = $this->replaceVars($data, $parameters);
+    }
+    // This is chops out the {...} and replaces with the new section.
+    return substr($string, 0, $start) . $data . substr($string, $end + 1);
+  }
+
+  private function replaceVars(
+      $section,
+      $parameters,
+      $sep = ",",
+      $combine = null,
+      $reserved = false,
+      $tag_empty = false,
+      $combine_on_empty = true
+  ) {
+    if (strpos($section, ",") === false) {
+      // If we only have a single value, we can immediately process.
+      return $this->combine(
+          $section,
+          $parameters,
+          $sep,
+          $combine,
+          $reserved,
+          $tag_empty,
+          $combine_on_empty
+      );
+    } else {
+      // If we have multiple values, we need to split and loop over them.
+      // Each is treated individually, then glued together with the
+      // separator character.
+      $vars = explode(",", $section);
+      return $this->combineList(
+          $vars,
+          $sep,
+          $parameters,
+          $combine,
+          $reserved,
+          false, // Never emit empty strings in multi-param replacements
+          $combine_on_empty
+      );
+    }
+  }
+
+  public function combine(
+      $key,
+      $parameters,
+      $sep,
+      $combine,
+      $reserved,
+      $tag_empty,
+      $combine_on_empty
+  ) {
+    $length = false;
+    $explode = false;
+    $skip_final_combine = false;
+    $value = false;
+
+    // Check for length restriction.
+    if (strpos($key, ":") !== false) {
+      list($key, $length) = explode(":", $key);
+    }
+
+    // Check for explode parameter.
+    if ($key[strlen($key) - 1] == "*") {
+      $explode = true;
+      $key = substr($key, 0, -1);
+      $skip_final_combine = true;
+    }
+
+    // Define the list separator.
+    $list_sep = $explode ? $sep : ",";
+
+    if (isset($parameters[$key])) {
+      $data_type = $this->getDataType($parameters[$key]);
+      switch ($data_type) {
+        case self::TYPE_SCALAR:
+          $value = $this->getValue($parameters[$key], $length);
+          break;
+        case self::TYPE_LIST:
+          $values = array();
+          foreach ($parameters[$key] as $pkey => $pvalue) {
+            $pvalue = $this->getValue($pvalue, $length);
+            if ($combine && $explode) {
+              $values[$pkey] = $key . $combine . $pvalue;
+            } else {
+              $values[$pkey] = $pvalue;
+            }
+          }
+          $value = implode($list_sep, $values);
+          if ($value == '') {
+            return '';
+          }
+          break;
+        case self::TYPE_MAP:
+          $values = array();
+          foreach ($parameters[$key] as $pkey => $pvalue) {
+            $pvalue = $this->getValue($pvalue, $length);
+            if ($explode) {
+              $pkey = $this->getValue($pkey, $length);
+              $values[] = $pkey . "=" . $pvalue; // Explode triggers = combine.
+            } else {
+              $values[] = $pkey;
+              $values[] = $pvalue;
+            }
+          }
+          $value = implode($list_sep, $values);
+          if ($value == '') {
+            return false;
+          }
+          break;
+      }
+    } else if ($tag_empty) {
+      // If we are just indicating empty values with their key name, return that.
+      return $key;
+    } else {
+      // Otherwise we can skip this variable due to not being defined.
+      return false;
+    }
+
+    if ($reserved) {
+      $value = str_replace($this->reservedEncoded, $this->reserved, $value);
+    }
+
+    // If we do not need to include the key name, we just return the raw
+    // value.
+    if (!$combine || $skip_final_combine) {
+      return $value;
+    }
+
+    // Else we combine the key name: foo=bar, if value is not the empty string.
+    return $key . ($value != '' || $combine_on_empty ? $combine . $value : '');
+  }
+
+  /**
+   * Return the type of a passed in value
+   */
+  private function getDataType($data)
+  {
+    if (is_array($data)) {
+      reset($data);
+      if (key($data) !== 0) {
+        return self::TYPE_MAP;
+      }
+      return self::TYPE_LIST;
+    }
+    return self::TYPE_SCALAR;
+  }
+
+  /**
+   * Utility function that merges multiple combine calls
+   * for multi-key templates.
+   */
+  private function combineList(
+      $vars,
+      $sep,
+      $parameters,
+      $combine,
+      $reserved,
+      $tag_empty,
+      $combine_on_empty
+  ) {
+    $ret = array();
+    foreach ($vars as $var) {
+      $response = $this->combine(
+          $var,
+          $parameters,
+          $sep,
+          $combine,
+          $reserved,
+          $tag_empty,
+          $combine_on_empty
+      );
+      if ($response === false) {
+        continue;
+      }
+      $ret[] = $response;
+    }
+    return implode($sep, $ret);
+  }
+
+  /**
+   * Utility function to encode and trim values
+   */
+  private function getValue($value, $length)
+  {
+    if ($length) {
+      $value = substr($value, 0, $length);
+    }
+    $value = rawurlencode($value);
+    return $value;
+  }
+}

vendor/google/apiclient/src/Google/autoload.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+ * THIS FILE IS FOR BACKWARDS COMPATIBLITY ONLY
+ *
+ * If you were not already including this file in your project, please ignore it
+ */
+
+$file = __DIR__ . '/../../vendor/autoload.php';
+
+if (!file_exists($file)) {
+  $exception = 'This library must be installed via composer or by downloading the full package.';
+  $exception .= ' See the instructions at https://github.com/google/google-api-php-client#installation.';
+  throw new Exception($exception);
+}
+
+$error = 'google-api-php-client\'s autoloader was moved to vendor/autoload.php in 2.0.0. This ';
+$error .= 'redirect will be removed in 2.1. Please adjust your code to use the new location.';
+trigger_error($error, E_USER_DEPRECATED);
+
+require_once $file;