TheRakeshPurohit / rtCamp

lib/Google/AuthHandler/AuthHandlerFactory.php

Indentation +12 added lines, -12 removed lines

@@ -20,23 +20,23 @@
 
 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 = [])
-  {
+    /**
+     * 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':
+        case '5':
         return new Google_AuthHandler_Guzzle5AuthHandler($cache, $cacheConfig);
-      case '6':
+        case '6':
         return new Google_AuthHandler_Guzzle6AuthHandler($cache, $cacheConfig);
-      default:
+        default:
         throw new Exception('Version not supported');
     }
-  }
+    }
 }

lib/Google/AuthHandler/Guzzle6AuthHandler.php

Indentation +30 added lines, -30 removed lines

@@ -15,27 +15,27 @@ 
 */
 class Google_AuthHandler_Guzzle6AuthHandler
 {
-  protected $cache;
-  protected $cacheConfig;
+    protected $cache;
+    protected $cacheConfig;
 
-  public function __construct(CacheItemPoolInterface $cache = null, array $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
-  ) {
+    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
-      );
+        $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
@@ -55,12 +55,12 @@ 
     $http = new Client($config);
 
     return $http;
-  }
+    }
 
-  public function attachToken(ClientInterface $http, array $token, array $scopes)
-  {
+    public function attachToken(ClientInterface $http, array $token, array $scopes)
+    {
     $tokenFunc = function ($scopes) use ($token) {
-      return $token['access_token'];
+        return $token['access_token'];
     };
 
     $middleware = new ScopedAccessTokenMiddleware(
@@ -77,10 +77,10 @@ 
     $http = new Client($config);
 
     return $http;
-  }
+    }
 
-  public function attachKey(ClientInterface $http, $key)
-  {
+    public function attachKey(ClientInterface $http, $key)
+    {
     $middleware = new SimpleMiddleware(['key' => $key]);
 
     $config = $http->getConfig();
@@ -90,17 +90,17 @@ 
     $http = new Client($config);
 
     return $http;
-  }
+    }
 
-  private function createAuthHttp(ClientInterface $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'),
+            'base_uri' => $http->getConfig('base_uri'),
+            'exceptions' => true,
+            'verify' => $http->getConfig('verify'),
+            'proxy' => $http->getConfig('proxy'),
         ]
     );
-  }
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -56,7 +56,7 @@
 
   public function attachToken(ClientInterface $http, array $token, array $scopes)
   {
-    $tokenFunc = function ($scopes) use ($token) {
+    $tokenFunc = function($scopes) use ($token) {
       return $token['access_token'];
     };
 

lib/Google/autoload.php

Indentation +3 added lines, -3 removed lines

@@ -9,9 +9,9 @@
 $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);
+    $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 ';

lib/Google/Client.php

Indentation +767 added lines, -767 removed lines

@@ -38,153 +38,153 @@ 
  */
 class Google_Client
 {
-  const LIBVER = "2.2.3";
-  const USER_AGENT_SUFFIX = "google-api-php-client/";
-  const OAUTH2_REVOKE_URI = 'https://oauth2.googleapis.com/revoke';
-  const OAUTH2_TOKEN_URI = 'https://oauth2.googleapis.com/token';
-  const OAUTH2_AUTH_URL = 'https://accounts.google.com/o/oauth2/auth';
-  const API_BASE_PATH = 'https://www.googleapis.com';
-
-  /**
-   * @var Google\Auth\OAuth2 $auth
-   */
-  private $auth;
-
-  /**
-   * @var GuzzleHttp\ClientInterface $http
-   */
-  private $http;
-
-  /**
-   * @var Psr\Cache\CacheItemPoolInterface $cache
-   */
-  private $cache;
-
-  /**
-   * @var array access token
-   */
-  private $token;
-
-  /**
-   * @var array $config
-   */
-  private $config;
-
-  /**
-   * @var Psr\Log\LoggerInterface $logger
-   */
-  private $logger;
-
-  /**
-   * @var boolean $deferExecution
-   */
-  private $deferExecution = false;
-
-  /** @var array $scopes */
-  // Scopes requested by the client
-  protected $requestedScopes = [];
-
-  /**
-   * Construct the Google Client.
-   *
-   * @param array $config
-   */
-  public function __construct(array $config = array())
-  {
+    const LIBVER = "2.2.3";
+    const USER_AGENT_SUFFIX = "google-api-php-client/";
+    const OAUTH2_REVOKE_URI = 'https://oauth2.googleapis.com/revoke';
+    const OAUTH2_TOKEN_URI = 'https://oauth2.googleapis.com/token';
+    const OAUTH2_AUTH_URL = 'https://accounts.google.com/o/oauth2/auth';
+    const API_BASE_PATH = 'https://www.googleapis.com';
+
+    /**
+     * @var Google\Auth\OAuth2 $auth
+     */
+    private $auth;
+
+    /**
+     * @var GuzzleHttp\ClientInterface $http
+     */
+    private $http;
+
+    /**
+     * @var Psr\Cache\CacheItemPoolInterface $cache
+     */
+    private $cache;
+
+    /**
+     * @var array access token
+     */
+    private $token;
+
+    /**
+     * @var array $config
+     */
+    private $config;
+
+    /**
+     * @var Psr\Log\LoggerInterface $logger
+     */
+    private $logger;
+
+    /**
+     * @var boolean $deferExecution
+     */
+    private $deferExecution = false;
+
+    /** @var array $scopes */
+    // Scopes requested by the client
+    protected $requestedScopes = [];
+
+    /**
+     * Construct the Google Client.
+     *
+     * @param array $config
+     */
+    public function __construct(array $config = array())
+    {
     $this->config = array_merge(
         [
-          'application_name' => '',
-
-          // Don't change these unless you're working against a special development
-          // or testing environment.
-          'base_path' => self::API_BASE_PATH,
-
-          // https://developers.google.com/console
-          'client_id' => '',
-          'client_secret' => '',
-          'redirect_uri' => null,
-          'state' => null,
-
-          // Simple API access key, also from the API console. Ensure you get
-          // a Server key, and not a Browser key.
-          'developer_key' => '',
-
-          // For use with Google Cloud Platform
-          // fetch the ApplicationDefaultCredentials, if applicable
-          // @see https://developers.google.com/identity/protocols/application-default-credentials
-          'use_application_default_credentials' => false,
-          'signing_key' => null,
-          'signing_algorithm' => null,
-          'subject' => null,
-
-          // Other OAuth2 parameters.
-          'hd' => '',
-          'prompt' => '',
-          'openid.realm' => '',
-          'include_granted_scopes' => null,
-          'login_hint' => '',
-          'request_visible_actions' => '',
-          'access_type' => 'online',
-          'approval_prompt' => 'auto',
-
-          // Task Runner retry configuration
-          // @see Google_Task_Runner
-          'retry' => array(),
-          'retry_map' => null,
-
-          // cache config for downstream auth caching
-          'cache_config' => [],
-
-          // function to be called when an access token is fetched
-          // follows the signature function ($cacheKey, $accessToken)
-          'token_callback' => null,
-
-          // Service class used in Google_Client::verifyIdToken.
-          // Explicitly pass this in to avoid setting JWT::$leeway
-          'jwt' => null,
-
-          // Setting api_format_v2 will return more detailed error messages
-          // from certain APIs.
-          'api_format_v2' => false
+            'application_name' => '',
+
+            // Don't change these unless you're working against a special development
+            // or testing environment.
+            'base_path' => self::API_BASE_PATH,
+
+            // https://developers.google.com/console
+            'client_id' => '',
+            'client_secret' => '',
+            'redirect_uri' => null,
+            'state' => null,
+
+            // Simple API access key, also from the API console. Ensure you get
+            // a Server key, and not a Browser key.
+            'developer_key' => '',
+
+            // For use with Google Cloud Platform
+            // fetch the ApplicationDefaultCredentials, if applicable
+            // @see https://developers.google.com/identity/protocols/application-default-credentials
+            'use_application_default_credentials' => false,
+            'signing_key' => null,
+            'signing_algorithm' => null,
+            'subject' => null,
+
+            // Other OAuth2 parameters.
+            'hd' => '',
+            'prompt' => '',
+            'openid.realm' => '',
+            'include_granted_scopes' => null,
+            'login_hint' => '',
+            'request_visible_actions' => '',
+            'access_type' => 'online',
+            'approval_prompt' => 'auto',
+
+            // Task Runner retry configuration
+            // @see Google_Task_Runner
+            'retry' => array(),
+            'retry_map' => null,
+
+            // cache config for downstream auth caching
+            'cache_config' => [],
+
+            // function to be called when an access token is fetched
+            // follows the signature function ($cacheKey, $accessToken)
+            'token_callback' => null,
+
+            // Service class used in Google_Client::verifyIdToken.
+            // Explicitly pass this in to avoid setting JWT::$leeway
+            'jwt' => null,
+
+            // Setting api_format_v2 will return more detailed error messages
+            // from certain APIs.
+            'api_format_v2' => false
         ],
         $config
     );
-  }
-
-  /**
-   * Get a string containing the version of the library.
-   *
-   * @return string
-   */
-  public function getLibraryVersion()
-  {
+    }
+
+    /**
+     * Get a string containing the version of the library.
+     *
+     * @return string
+     */
+    public function getLibraryVersion()
+    {
     return self::LIBVER;
-  }
-
-  /**
-   * For backwards compatibility
-   * alias for fetchAccessTokenWithAuthCode
-   *
-   * @param $code string code from accounts.google.com
-   * @return array access token
-   * @deprecated
-   */
-  public function authenticate($code)
-  {
+    }
+
+    /**
+     * For backwards compatibility
+     * alias for fetchAccessTokenWithAuthCode
+     *
+     * @param $code string code from accounts.google.com
+     * @return array access token
+     * @deprecated
+     */
+    public function authenticate($code)
+    {
     return $this->fetchAccessTokenWithAuthCode($code);
-  }
-
-  /**
-   * Attempt to exchange a code for an valid authentication token.
-   * Helper wrapped around the OAuth 2.0 implementation.
-   *
-   * @param $code string code from accounts.google.com
-   * @return array access token
-   */
-  public function fetchAccessTokenWithAuthCode($code)
-  {
+    }
+
+    /**
+     * Attempt to exchange a code for an valid authentication token.
+     * Helper wrapped around the OAuth 2.0 implementation.
+     *
+     * @param $code string code from accounts.google.com
+     * @return array access token
+     */
+    public function fetchAccessTokenWithAuthCode($code)
+    {
     if (strlen($code) == 0) {
-      throw new InvalidArgumentException("Invalid code");
+        throw new InvalidArgumentException("Invalid code");
     }
 
     $auth = $this->getOAuth2Service();
@@ -194,40 +194,40 @@ 
     $httpHandler = HttpHandlerFactory::build($this->getHttpClient());
     $creds = $auth->fetchAuthToken($httpHandler);
     if ($creds && isset($creds['access_token'])) {
-      $creds['created'] = time();
-      $this->setAccessToken($creds);
+        $creds['created'] = time();
+        $this->setAccessToken($creds);
     }
 
     return $creds;
-  }
-
-  /**
-   * For backwards compatibility
-   * alias for fetchAccessTokenWithAssertion
-   *
-   * @return array access token
-   * @deprecated
-   */
-  public function refreshTokenWithAssertion()
-  {
+    }
+
+    /**
+     * For backwards compatibility
+     * alias for fetchAccessTokenWithAssertion
+     *
+     * @return array access token
+     * @deprecated
+     */
+    public function refreshTokenWithAssertion()
+    {
     return $this->fetchAccessTokenWithAssertion();
-  }
-
-  /**
-   * Fetches a fresh access token with a given assertion token.
-   * @param ClientInterface $authHttp optional.
-   * @return array access token
-   */
-  public function fetchAccessTokenWithAssertion(ClientInterface $authHttp = null)
-  {
+    }
+
+    /**
+     * Fetches a fresh access token with a given assertion token.
+     * @param ClientInterface $authHttp optional.
+     * @return array access token
+     */
+    public function fetchAccessTokenWithAssertion(ClientInterface $authHttp = null)
+    {
     if (!$this->isUsingApplicationDefaultCredentials()) {
-      throw new DomainException(
-          'set the JSON service account credentials using'
-          . ' Google_Client::setAuthConfig or set the path to your JSON file'
-          . ' with the "GOOGLE_APPLICATION_CREDENTIALS" environment variable'
-          . ' and call Google_Client::useApplicationDefaultCredentials to'
-          . ' refresh a token with assertion.'
-      );
+        throw new DomainException(
+            'set the JSON service account credentials using'
+            . ' Google_Client::setAuthConfig or set the path to your JSON file'
+            . ' with the "GOOGLE_APPLICATION_CREDENTIALS" environment variable'
+            . ' and call Google_Client::useApplicationDefaultCredentials to'
+            . ' refresh a token with assertion.'
+        );
     }
 
     $this->getLogger()->log(
@@ -240,39 +240,39 @@ 
     $httpHandler = HttpHandlerFactory::build($authHttp);
     $creds = $credentials->fetchAuthToken($httpHandler);
     if ($creds && isset($creds['access_token'])) {
-      $creds['created'] = time();
-      $this->setAccessToken($creds);
+        $creds['created'] = time();
+        $this->setAccessToken($creds);
     }
 
     return $creds;
-  }
-
-  /**
-   * For backwards compatibility
-   * alias for fetchAccessTokenWithRefreshToken
-   *
-   * @param string $refreshToken
-   * @return array access token
-   */
-  public function refreshToken($refreshToken)
-  {
+    }
+
+    /**
+     * For backwards compatibility
+     * alias for fetchAccessTokenWithRefreshToken
+     *
+     * @param string $refreshToken
+     * @return array access token
+     */
+    public function refreshToken($refreshToken)
+    {
     return $this->fetchAccessTokenWithRefreshToken($refreshToken);
-  }
-
-  /**
-   * Fetches a fresh OAuth 2.0 access token with the given refresh token.
-   * @param string $refreshToken
-   * @return array access token
-   */
-  public function fetchAccessTokenWithRefreshToken($refreshToken = null)
-  {
+    }
+
+    /**
+     * Fetches a fresh OAuth 2.0 access token with the given refresh token.
+     * @param string $refreshToken
+     * @return array access token
+     */
+    public function fetchAccessTokenWithRefreshToken($refreshToken = null)
+    {
     if (null === $refreshToken) {
-      if (!isset($this->token['refresh_token'])) {
+        if (!isset($this->token['refresh_token'])) {
         throw new LogicException(
             'refresh token must be passed in or set as part of setAccessToken'
         );
-      }
-      $refreshToken = $this->token['refresh_token'];
+        }
+        $refreshToken = $this->token['refresh_token'];
     }
     $this->getLogger()->info('OAuth2 access token refresh');
     $auth = $this->getOAuth2Service();
@@ -281,30 +281,30 @@ 
     $httpHandler = HttpHandlerFactory::build($this->getHttpClient());
     $creds = $auth->fetchAuthToken($httpHandler);
     if ($creds && isset($creds['access_token'])) {
-      $creds['created'] = time();
-      if (!isset($creds['refresh_token'])) {
+        $creds['created'] = time();
+        if (!isset($creds['refresh_token'])) {
         $creds['refresh_token'] = $refreshToken;
-      }
-      $this->setAccessToken($creds);
+        }
+        $this->setAccessToken($creds);
     }
 
     return $creds;
-  }
-
-  /**
-   * Create a URL to obtain user authorization.
-   * The authorization endpoint allows the user to first
-   * authenticate, and then grant/deny the access request.
-   * @param string|array $scope The scope is expressed as an array or list of space-delimited strings.
-   * @return string
-   */
-  public function createAuthUrl($scope = null)
-  {
+    }
+
+    /**
+     * Create a URL to obtain user authorization.
+     * The authorization endpoint allows the user to first
+     * authenticate, and then grant/deny the access request.
+     * @param string|array $scope The scope is expressed as an array or list of space-delimited strings.
+     * @return string
+     */
+    public function createAuthUrl($scope = null)
+    {
     if (empty($scope)) {
-      $scope = $this->prepareScopes();
+        $scope = $this->prepareScopes();
     }
     if (is_array($scope)) {
-      $scope = implode(' ', $scope);
+        $scope = implode(' ', $scope);
     }
 
     // only accept one of prompt or approval_prompt
@@ -319,16 +319,16 @@ 
 
     $params = array_filter(
         [
-          'access_type' => $this->config['access_type'],
-          'approval_prompt' => $approvalPrompt,
-          'hd' => $this->config['hd'],
-          'include_granted_scopes' => $includeGrantedScopes,
-          'login_hint' => $this->config['login_hint'],
-          'openid.realm' => $this->config['openid.realm'],
-          'prompt' => $this->config['prompt'],
-          'response_type' => 'code',
-          'scope' => $scope,
-          'state' => $this->config['state'],
+            'access_type' => $this->config['access_type'],
+            'approval_prompt' => $approvalPrompt,
+            'hd' => $this->config['hd'],
+            'include_granted_scopes' => $includeGrantedScopes,
+            'login_hint' => $this->config['login_hint'],
+            'openid.realm' => $this->config['openid.realm'],
+            'prompt' => $this->config['prompt'],
+            'response_type' => 'code',
+            'scope' => $scope,
+            'state' => $this->config['state'],
         ]
     );
 
@@ -342,22 +342,22 @@ 
     $auth = $this->getOAuth2Service();
 
     return (string) $auth->buildFullAuthorizationUri($params);
-  }
-
-  /**
-   * Adds auth listeners to the HTTP client based on the credentials
-   * set in the Google API Client object
-   *
-   * @param GuzzleHttp\ClientInterface $http the http client object.
-   * @return GuzzleHttp\ClientInterface the http client object
-   */
-  public function authorize(ClientInterface $http = null)
-  {
+    }
+
+    /**
+     * Adds auth listeners to the HTTP client based on the credentials
+     * set in the Google API Client object
+     *
+     * @param GuzzleHttp\ClientInterface $http the http client object.
+     * @return GuzzleHttp\ClientInterface the http client object
+     */
+    public function authorize(ClientInterface $http = null)
+    {
     $credentials = null;
     $token = null;
     $scopes = null;
     if (null === $http) {
-      $http = $this->getHttpClient();
+        $http = $this->getHttpClient();
     }
 
     // These conditionals represent the decision tree for authentication
@@ -366,349 +366,349 @@ 
     //   3a. Check for an Access Token
     //   3b. If access token exists but is expired, try to refresh it
     if ($this->isUsingApplicationDefaultCredentials()) {
-      $credentials = $this->createApplicationDefaultCredentials();
+        $credentials = $this->createApplicationDefaultCredentials();
     } elseif ($token = $this->getAccessToken()) {
-      $scopes = $this->prepareScopes();
-      // add refresh subscriber to request a new token
-      if (isset($token['refresh_token']) && $this->isAccessTokenExpired()) {
+        $scopes = $this->prepareScopes();
+        // add refresh subscriber to request a new token
+        if (isset($token['refresh_token']) && $this->isAccessTokenExpired()) {
         $credentials = $this->createUserRefreshCredentials(
             $scopes,
             $token['refresh_token']
         );
-      }
+        }
     }
 
     $authHandler = $this->getAuthHandler();
 
     if ($credentials) {
-      $callback = $this->config['token_callback'];
-      $http = $authHandler->attachCredentials($http, $credentials, $callback);
+        $callback = $this->config['token_callback'];
+        $http = $authHandler->attachCredentials($http, $credentials, $callback);
     } elseif ($token) {
-      $http = $authHandler->attachToken($http, $token, (array) $scopes);
+        $http = $authHandler->attachToken($http, $token, (array) $scopes);
     } elseif ($key = $this->config['developer_key']) {
-      $http = $authHandler->attachKey($http, $key);
+        $http = $authHandler->attachKey($http, $key);
     }
 
     return $http;
-  }
-
-  /**
-   * Set the configuration to use application default credentials for
-   * authentication
-   *
-   * @see https://developers.google.com/identity/protocols/application-default-credentials
-   * @param boolean $useAppCreds
-   */
-  public function useApplicationDefaultCredentials($useAppCreds = true)
-  {
+    }
+
+    /**
+     * Set the configuration to use application default credentials for
+     * authentication
+     *
+     * @see https://developers.google.com/identity/protocols/application-default-credentials
+     * @param boolean $useAppCreds
+     */
+    public function useApplicationDefaultCredentials($useAppCreds = true)
+    {
     $this->config['use_application_default_credentials'] = $useAppCreds;
-  }
-
-  /**
-   * To prevent useApplicationDefaultCredentials from inappropriately being
-   * called in a conditional
-   *
-   * @see https://developers.google.com/identity/protocols/application-default-credentials
-   */
-  public function isUsingApplicationDefaultCredentials()
-  {
+    }
+
+    /**
+     * To prevent useApplicationDefaultCredentials from inappropriately being
+     * called in a conditional
+     *
+     * @see https://developers.google.com/identity/protocols/application-default-credentials
+     */
+    public function isUsingApplicationDefaultCredentials()
+    {
     return $this->config['use_application_default_credentials'];
-  }
-
-  /**
-   * @param string|array $token
-   * @throws InvalidArgumentException
-   */
-  public function setAccessToken($token)
-  {
+    }
+
+    /**
+     * @param string|array $token
+     * @throws InvalidArgumentException
+     */
+    public function setAccessToken($token)
+    {
     if (is_string($token)) {
-      if ($json = json_decode($token, true)) {
+        if ($json = json_decode($token, true)) {
         $token = $json;
-      } else {
+        } else {
         // assume $token is just the token string
         $token = array(
-          'access_token' => $token,
+            'access_token' => $token,
         );
-      }
+        }
     }
     if ($token == null) {
-      throw new InvalidArgumentException('invalid json token');
+        throw new InvalidArgumentException('invalid json token');
     }
     if (!isset($token['access_token'])) {
-      throw new InvalidArgumentException("Invalid token format");
+        throw new InvalidArgumentException("Invalid token format");
     }
     $this->token = $token;
-  }
+    }
 
-  public function getAccessToken()
-  {
+    public function getAccessToken()
+    {
     return $this->token;
-  }
+    }
 
-  /**
-   * @return string|null
-   */
-  public function getRefreshToken()
-  {
+    /**
+     * @return string|null
+     */
+    public function getRefreshToken()
+    {
     if (isset($this->token['refresh_token'])) {
-      return $this->token['refresh_token'];
+        return $this->token['refresh_token'];
     }
 
     return null;
-  }
-
-  /**
-   * Returns if the access_token is expired.
-   * @return bool Returns True if the access_token is expired.
-   */
-  public function isAccessTokenExpired()
-  {
+    }
+
+    /**
+     * Returns if the access_token is expired.
+     * @return bool Returns True if the access_token is expired.
+     */
+    public function isAccessTokenExpired()
+    {
     if (!$this->token) {
-      return true;
+        return true;
     }
 
     $created = 0;
     if (isset($this->token['created'])) {
-      $created = $this->token['created'];
+        $created = $this->token['created'];
     } elseif (isset($this->token['id_token'])) {
-      // check the ID token for "iat"
-      // signature verification is not required here, as we are just
-      // using this for convenience to save a round trip request
-      // to the Google API server
-      $idToken = $this->token['id_token'];
-      if (substr_count($idToken, '.') == 2) {
+        // check the ID token for "iat"
+        // signature verification is not required here, as we are just
+        // using this for convenience to save a round trip request
+        // to the Google API server
+        $idToken = $this->token['id_token'];
+        if (substr_count($idToken, '.') == 2) {
         $parts = explode('.', $idToken);
         $payload = json_decode(base64_decode($parts[1]), true);
         if ($payload && isset($payload['iat'])) {
-          $created = $payload['iat'];
+            $created = $payload['iat'];
+        }
         }
-      }
     }
 
     // If the token is set to expire in the next 30 seconds.
     return ($created + ($this->token['expires_in'] - 30)) < time();
-  }
+    }
 
-  /**
-   * @deprecated See UPGRADING.md for more information
-   */
-  public function getAuth()
-  {
+    /**
+     * @deprecated See UPGRADING.md for more information
+     */
+    public function getAuth()
+    {
     throw new BadMethodCallException(
         'This function no longer exists. See UPGRADING.md for more information'
     );
-  }
+    }
 
-  /**
-   * @deprecated See UPGRADING.md for more information
-   */
-  public function setAuth($auth)
-  {
+    /**
+     * @deprecated See UPGRADING.md for more information
+     */
+    public function setAuth($auth)
+    {
     throw new BadMethodCallException(
         'This function no longer exists. See UPGRADING.md for more information'
     );
-  }
-
-  /**
-   * Set the OAuth 2.0 Client ID.
-   * @param string $clientId
-   */
-  public function setClientId($clientId)
-  {
+    }
+
+    /**
+     * Set the OAuth 2.0 Client ID.
+     * @param string $clientId
+     */
+    public function setClientId($clientId)
+    {
     $this->config['client_id'] = $clientId;
-  }
+    }
 
-  public function getClientId()
-  {
+    public function getClientId()
+    {
     return $this->config['client_id'];
-  }
-
-  /**
-   * Set the OAuth 2.0 Client Secret.
-   * @param string $clientSecret
-   */
-  public function setClientSecret($clientSecret)
-  {
+    }
+
+    /**
+     * Set the OAuth 2.0 Client Secret.
+     * @param string $clientSecret
+     */
+    public function setClientSecret($clientSecret)
+    {
     $this->config['client_secret'] = $clientSecret;
-  }
+    }
 
-  public function getClientSecret()
-  {
+    public function getClientSecret()
+    {
     return $this->config['client_secret'];
-  }
-
-  /**
-   * Set the OAuth 2.0 Redirect URI.
-   * @param string $redirectUri
-   */
-  public function setRedirectUri($redirectUri)
-  {
+    }
+
+    /**
+     * Set the OAuth 2.0 Redirect URI.
+     * @param string $redirectUri
+     */
+    public function setRedirectUri($redirectUri)
+    {
     $this->config['redirect_uri'] = $redirectUri;
-  }
+    }
 
-  public function getRedirectUri()
-  {
+    public function getRedirectUri()
+    {
     return $this->config['redirect_uri'];
-  }
-
-  /**
-   * Set OAuth 2.0 "state" parameter to achieve per-request customization.
-   * @see http://tools.ietf.org/html/draft-ietf-oauth-v2-22#section-3.1.2.2
-   * @param string $state
-   */
-  public function setState($state)
-  {
+    }
+
+    /**
+     * Set OAuth 2.0 "state" parameter to achieve per-request customization.
+     * @see http://tools.ietf.org/html/draft-ietf-oauth-v2-22#section-3.1.2.2
+     * @param string $state
+     */
+    public function setState($state)
+    {
     $this->config['state'] = $state;
-  }
-
-  /**
-   * @param string $accessType Possible values for access_type include:
-   *  {@code "offline"} to request offline access from the user.
-   *  {@code "online"} to request online access from the user.
-   */
-  public function setAccessType($accessType)
-  {
+    }
+
+    /**
+     * @param string $accessType Possible values for access_type include:
+     *  {@code "offline"} to request offline access from the user.
+     *  {@code "online"} to request online access from the user.
+     */
+    public function setAccessType($accessType)
+    {
     $this->config['access_type'] = $accessType;
-  }
-
-  /**
-   * @param string $approvalPrompt Possible values for approval_prompt include:
-   *  {@code "force"} to force the approval UI to appear.
-   *  {@code "auto"} to request auto-approval when possible. (This is the default value)
-   */
-  public function setApprovalPrompt($approvalPrompt)
-  {
+    }
+
+    /**
+     * @param string $approvalPrompt Possible values for approval_prompt include:
+     *  {@code "force"} to force the approval UI to appear.
+     *  {@code "auto"} to request auto-approval when possible. (This is the default value)
+     */
+    public function setApprovalPrompt($approvalPrompt)
+    {
     $this->config['approval_prompt'] = $approvalPrompt;
-  }
-
-  /**
-   * Set the login hint, email address or sub id.
-   * @param string $loginHint
-   */
-  public function setLoginHint($loginHint)
-  {
+    }
+
+    /**
+     * Set the login hint, email address or sub id.
+     * @param string $loginHint
+     */
+    public function setLoginHint($loginHint)
+    {
     $this->config['login_hint'] = $loginHint;
-  }
-
-  /**
-   * Set the application name, this is included in the User-Agent HTTP header.
-   * @param string $applicationName
-   */
-  public function setApplicationName($applicationName)
-  {
+    }
+
+    /**
+     * Set the application name, this is included in the User-Agent HTTP header.
+     * @param string $applicationName
+     */
+    public function setApplicationName($applicationName)
+    {
     $this->config['application_name'] = $applicationName;
-  }
-
-  /**
-   * If 'plus.login' is included in the list of requested scopes, you can use
-   * this method to define types of app activities that your app will write.
-   * You can find a list of available types here:
-   * @link https://developers.google.com/+/api/moment-types
-   *
-   * @param array $requestVisibleActions Array of app activity types
-   */
-  public function setRequestVisibleActions($requestVisibleActions)
-  {
+    }
+
+    /**
+     * If 'plus.login' is included in the list of requested scopes, you can use
+     * this method to define types of app activities that your app will write.
+     * You can find a list of available types here:
+     * @link https://developers.google.com/+/api/moment-types
+     *
+     * @param array $requestVisibleActions Array of app activity types
+     */
+    public function setRequestVisibleActions($requestVisibleActions)
+    {
     if (is_array($requestVisibleActions)) {
-      $requestVisibleActions = implode(" ", $requestVisibleActions);
+        $requestVisibleActions = implode(" ", $requestVisibleActions);
     }
     $this->config['request_visible_actions'] = $requestVisibleActions;
-  }
-
-  /**
-   * Set the developer key to use, these are obtained through the API Console.
-   * @see http://code.google.com/apis/console-help/#generatingdevkeys
-   * @param string $developerKey
-   */
-  public function setDeveloperKey($developerKey)
-  {
+    }
+
+    /**
+     * Set the developer key to use, these are obtained through the API Console.
+     * @see http://code.google.com/apis/console-help/#generatingdevkeys
+     * @param string $developerKey
+     */
+    public function setDeveloperKey($developerKey)
+    {
     $this->config['developer_key'] = $developerKey;
-  }
-
-  /**
-   * Set the hd (hosted domain) parameter streamlines the login process for
-   * Google Apps hosted accounts. By including the domain of the user, you
-   * restrict sign-in to accounts at that domain.
-   * @param $hd string - the domain to use.
-   */
-  public function setHostedDomain($hd)
-  {
+    }
+
+    /**
+     * Set the hd (hosted domain) parameter streamlines the login process for
+     * Google Apps hosted accounts. By including the domain of the user, you
+     * restrict sign-in to accounts at that domain.
+     * @param $hd string - the domain to use.
+     */
+    public function setHostedDomain($hd)
+    {
     $this->config['hd'] = $hd;
-  }
-
-  /**
-   * Set the prompt hint. Valid values are none, consent and select_account.
-   * If no value is specified and the user has not previously authorized
-   * access, then the user is shown a consent screen.
-   * @param $prompt string
-   *  {@code "none"} Do not display any authentication or consent screens. Must not be specified with other values.
-   *  {@code "consent"} Prompt the user for consent.
-   *  {@code "select_account"} Prompt the user to select an account.
-   */
-  public function setPrompt($prompt)
-  {
+    }
+
+    /**
+     * Set the prompt hint. Valid values are none, consent and select_account.
+     * If no value is specified and the user has not previously authorized
+     * access, then the user is shown a consent screen.
+     * @param $prompt string
+     *  {@code "none"} Do not display any authentication or consent screens. Must not be specified with other values.
+     *  {@code "consent"} Prompt the user for consent.
+     *  {@code "select_account"} Prompt the user to select an account.
+     */
+    public function setPrompt($prompt)
+    {
     $this->config['prompt'] = $prompt;
-  }
-
-  /**
-   * openid.realm is a parameter from the OpenID 2.0 protocol, not from OAuth
-   * 2.0. It is used in OpenID 2.0 requests to signify the URL-space for which
-   * an authentication request is valid.
-   * @param $realm string - the URL-space to use.
-   */
-  public function setOpenidRealm($realm)
-  {
+    }
+
+    /**
+     * openid.realm is a parameter from the OpenID 2.0 protocol, not from OAuth
+     * 2.0. It is used in OpenID 2.0 requests to signify the URL-space for which
+     * an authentication request is valid.
+     * @param $realm string - the URL-space to use.
+     */
+    public function setOpenidRealm($realm)
+    {
     $this->config['openid.realm'] = $realm;
-  }
-
-  /**
-   * If this is provided with the value true, and the authorization request is
-   * granted, the authorization will include any previous authorizations
-   * granted to this user/application combination for other scopes.
-   * @param $include boolean - the URL-space to use.
-   */
-  public function setIncludeGrantedScopes($include)
-  {
+    }
+
+    /**
+     * If this is provided with the value true, and the authorization request is
+     * granted, the authorization will include any previous authorizations
+     * granted to this user/application combination for other scopes.
+     * @param $include boolean - the URL-space to use.
+     */
+    public function setIncludeGrantedScopes($include)
+    {
     $this->config['include_granted_scopes'] = $include;
-  }
-
-  /**
-   * sets function to be called when an access token is fetched
-   * @param callable $tokenCallback - function ($cacheKey, $accessToken)
-   */
-  public function setTokenCallback(callable $tokenCallback)
-  {
+    }
+
+    /**
+     * sets function to be called when an access token is fetched
+     * @param callable $tokenCallback - function ($cacheKey, $accessToken)
+     */
+    public function setTokenCallback(callable $tokenCallback)
+    {
     $this->config['token_callback'] = $tokenCallback;
-  }
-
-  /**
-   * 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|null $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 = null)
-  {
+    }
+
+    /**
+     * 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|null $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 = null)
+    {
     $tokenRevoker = new Google_AccessToken_Revoke(
         $this->getHttpClient()
     );
 
     return $tokenRevoker->revokeToken($token ?: $this->getAccessToken());
-  }
-
-  /**
-   * Verify an id_token. This method will verify the current id_token, if one
-   * isn't provided.
-   *
-   * @throws LogicException If no token was provided and no token was set using `setAccessToken`.
-   * @throws UnexpectedValueException If the token is not a valid JWT.
-   * @param string|null $idToken The token (id_token) that should be verified.
-   * @return array|false Returns the token payload as an array if the verification was
-   * successful, false otherwise.
-   */
-  public function verifyIdToken($idToken = null)
-  {
+    }
+
+    /**
+     * Verify an id_token. This method will verify the current id_token, if one
+     * isn't provided.
+     *
+     * @throws LogicException If no token was provided and no token was set using `setAccessToken`.
+     * @throws UnexpectedValueException If the token is not a valid JWT.
+     * @param string|null $idToken The token (id_token) that should be verified.
+     * @return array|false Returns the token payload as an array if the verification was
+     * successful, false otherwise.
+     */
+    public function verifyIdToken($idToken = null)
+    {
     $tokenVerifier = new Google_AccessToken_Verify(
         $this->getHttpClient(),
         $this->getCache(),
@@ -716,83 +716,83 @@ 
     );
 
     if (null === $idToken) {
-      $token = $this->getAccessToken();
-      if (!isset($token['id_token'])) {
+        $token = $this->getAccessToken();
+        if (!isset($token['id_token'])) {
         throw new LogicException(
             'id_token must be passed in or set as part of setAccessToken'
         );
-      }
-      $idToken = $token['id_token'];
+        }
+        $idToken = $token['id_token'];
     }
 
     return $tokenVerifier->verifyIdToken(
         $idToken,
         $this->getClientId()
     );
-  }
-
-  /**
-   * Set the scopes to be requested. Must be called before createAuthUrl().
-   * Will remove any previously configured scopes.
-   * @param string|array $scope_or_scopes, ie: array('https://www.googleapis.com/auth/plus.login',
-   * 'https://www.googleapis.com/auth/moderator')
-   */
-  public function setScopes($scope_or_scopes)
-  {
+    }
+
+    /**
+     * Set the scopes to be requested. Must be called before createAuthUrl().
+     * Will remove any previously configured scopes.
+     * @param string|array $scope_or_scopes, ie: array('https://www.googleapis.com/auth/plus.login',
+     * 'https://www.googleapis.com/auth/moderator')
+     */
+    public function setScopes($scope_or_scopes)
+    {
     $this->requestedScopes = array();
     $this->addScope($scope_or_scopes);
-  }
-
-  /**
-   * This functions adds a scope to be requested as part of the OAuth2.0 flow.
-   * Will append any scopes not previously requested to the scope parameter.
-   * A single string will be treated as a scope to request. An array of strings
-   * will each be appended.
-   * @param $scope_or_scopes string|array e.g. "profile"
-   */
-  public function addScope($scope_or_scopes)
-  {
+    }
+
+    /**
+     * This functions adds a scope to be requested as part of the OAuth2.0 flow.
+     * Will append any scopes not previously requested to the scope parameter.
+     * A single string will be treated as a scope to request. An array of strings
+     * will each be appended.
+     * @param $scope_or_scopes string|array e.g. "profile"
+     */
+    public function addScope($scope_or_scopes)
+    {
     if (is_string($scope_or_scopes) && !in_array($scope_or_scopes, $this->requestedScopes)) {
-      $this->requestedScopes[] = $scope_or_scopes;
+        $this->requestedScopes[] = $scope_or_scopes;
     } else if (is_array($scope_or_scopes)) {
-      foreach ($scope_or_scopes as $scope) {
+        foreach ($scope_or_scopes as $scope) {
         $this->addScope($scope);
-      }
-    }
-  }
-
-  /**
-   * Returns the list of scopes requested by the client
-   * @return array the list of scopes
-   *
-   */
-  public function getScopes()
-  {
-     return $this->requestedScopes;
-  }
-
-  /**
-   * @return string|null
-   * @visible For Testing
-   */
-  public function prepareScopes()
-  {
+        }
+    }
+    }
+
+    /**
+     * Returns the list of scopes requested by the client
+     * @return array the list of scopes
+     *
+     */
+    public function getScopes()
+    {
+        return $this->requestedScopes;
+    }
+
+    /**
+     * @return string|null
+     * @visible For Testing
+     */
+    public function prepareScopes()
+    {
     if (empty($this->requestedScopes)) {
-      return null;
+        return null;
     }
 
     return implode(' ', $this->requestedScopes);
-  }
-
-  /**
-   * Helper method to execute deferred HTTP requests.
-   *
-   * @param $request Psr\Http\Message\RequestInterface|Google_Http_Batch
-   * @throws Google_Exception
-   * @return object of the type of the expected class or Psr\Http\Message\ResponseInterface.
-   */
-  public function execute(RequestInterface $request, $expectedClass = null)
-  {
+    }
+
+    /**
+     * Helper method to execute deferred HTTP requests.
+     *
+     * @param $request Psr\Http\Message\RequestInterface|Google_Http_Batch
+     * @throws Google_Exception
+     * @return object of the type of the expected class or Psr\Http\Message\ResponseInterface.
+     */
+    public function execute(RequestInterface $request, $expectedClass = null)
+    {
     $request = $request->withHeader(
         'User-Agent',
         $this->config['application_name']
@@ -818,324 +818,324 @@ 
         $this->config['retry'],
         $this->config['retry_map']
     );
-  }
-
-  /**
-   * Declare whether batch calls should be used. This may increase throughput
-   * by making multiple requests in one connection.
-   *
-   * @param boolean $useBatch True if the batch support should
-   * be enabled. Defaults to False.
-   */
-  public function setUseBatch($useBatch)
-  {
+    }
+
+    /**
+     * Declare whether batch calls should be used. This may increase throughput
+     * by making multiple requests in one connection.
+     *
+     * @param boolean $useBatch True if the batch support should
+     * be enabled. Defaults to False.
+     */
+    public function setUseBatch($useBatch)
+    {
     // This is actually an alias for setDefer.
     $this->setDefer($useBatch);
-  }
-
-  /**
-   * Are we running in Google AppEngine?
-   * return bool
-   */
-  public function isAppEngine()
-  {
+    }
+
+    /**
+     * Are we running in Google AppEngine?
+     * return bool
+     */
+    public function isAppEngine()
+    {
     return (isset($_SERVER['SERVER_SOFTWARE']) &&
         strpos($_SERVER['SERVER_SOFTWARE'], 'Google App Engine') !== false);
-  }
+    }
 
-  public function setConfig($name, $value)
-  {
+    public function setConfig($name, $value)
+    {
     $this->config[$name] = $value;
-  }
+    }
 
-  public function getConfig($name, $default = null)
-  {
+    public function getConfig($name, $default = null)
+    {
     return isset($this->config[$name]) ? $this->config[$name] : $default;
-  }
-
-  /**
-   * For backwards compatibility
-   * alias for setAuthConfig
-   *
-   * @param string $file the configuration file
-   * @throws Google_Exception
-   * @deprecated
-   */
-  public function setAuthConfigFile($file)
-  {
+    }
+
+    /**
+     * For backwards compatibility
+     * alias for setAuthConfig
+     *
+     * @param string $file the configuration file
+     * @throws Google_Exception
+     * @deprecated
+     */
+    public function setAuthConfigFile($file)
+    {
     $this->setAuthConfig($file);
-  }
-
-  /**
-   * Set the auth config from new or deprecated JSON config.
-   * This structure should match the file downloaded from
-   * the "Download JSON" button on in the Google Developer
-   * Console.
-   * @param string|array $config the configuration json
-   * @throws Google_Exception
-   */
-  public function setAuthConfig($config)
-  {
+    }
+
+    /**
+     * Set the auth config from new or deprecated JSON config.
+     * This structure should match the file downloaded from
+     * the "Download JSON" button on in the Google Developer
+     * Console.
+     * @param string|array $config the configuration json
+     * @throws Google_Exception
+     */
+    public function setAuthConfig($config)
+    {
     if (is_string($config)) {
-      if (!file_exists($config)) {
+        if (!file_exists($config)) {
         throw new InvalidArgumentException(sprintf('file "%s" does not exist', $config));
-      }
+        }
 
-      $json = file_get_contents($config);
+        $json = file_get_contents($config);
 
-      if (!$config = json_decode($json, true)) {
+        if (!$config = json_decode($json, true)) {
         throw new LogicException('invalid json for auth config');
-      }
+        }
     }
 
     $key = isset($config['installed']) ? 'installed' : 'web';
     if (isset($config['type']) && $config['type'] == 'service_account') {
-      // application default credentials
-      $this->useApplicationDefaultCredentials();
-
-      // set the information from the config
-      $this->setClientId($config['client_id']);
-      $this->config['client_email'] = $config['client_email'];
-      $this->config['signing_key'] = $config['private_key'];
-      $this->config['signing_algorithm'] = 'HS256';
+        // application default credentials
+        $this->useApplicationDefaultCredentials();
+
+        // set the information from the config
+        $this->setClientId($config['client_id']);
+        $this->config['client_email'] = $config['client_email'];
+        $this->config['signing_key'] = $config['private_key'];
+        $this->config['signing_algorithm'] = 'HS256';
     } elseif (isset($config[$key])) {
-      // old-style
-      $this->setClientId($config[$key]['client_id']);
-      $this->setClientSecret($config[$key]['client_secret']);
-      if (isset($config[$key]['redirect_uris'])) {
+        // old-style
+        $this->setClientId($config[$key]['client_id']);
+        $this->setClientSecret($config[$key]['client_secret']);
+        if (isset($config[$key]['redirect_uris'])) {
         $this->setRedirectUri($config[$key]['redirect_uris'][0]);
-      }
+        }
     } else {
-      // new-style
-      $this->setClientId($config['client_id']);
-      $this->setClientSecret($config['client_secret']);
-      if (isset($config['redirect_uris'])) {
+        // new-style
+        $this->setClientId($config['client_id']);
+        $this->setClientSecret($config['client_secret']);
+        if (isset($config['redirect_uris'])) {
         $this->setRedirectUri($config['redirect_uris'][0]);
-      }
+        }
+    }
     }
-  }
 
-  /**
-   * Use when the service account has been delegated domain wide access.
-   *
-   * @param string $subject an email address account to impersonate
-   */
-  public function setSubject($subject)
-  {
+    /**
+     * Use when the service account has been delegated domain wide access.
+     *
+     * @param string $subject an email address account to impersonate
+     */
+    public function setSubject($subject)
+    {
     $this->config['subject'] = $subject;
-  }
-
-  /**
-   * Declare whether making API calls should make the call immediately, or
-   * return a request which can be called with ->execute();
-   *
-   * @param boolean $defer True if calls should not be executed right away.
-   */
-  public function setDefer($defer)
-  {
+    }
+
+    /**
+     * Declare whether making API calls should make the call immediately, or
+     * return a request which can be called with ->execute();
+     *
+     * @param boolean $defer True if calls should not be executed right away.
+     */
+    public function setDefer($defer)
+    {
     $this->deferExecution = $defer;
-  }
-
-  /**
-   * Whether or not to return raw requests
-   * @return boolean
-   */
-  public function shouldDefer()
-  {
+    }
+
+    /**
+     * Whether or not to return raw requests
+     * @return boolean
+     */
+    public function shouldDefer()
+    {
     return $this->deferExecution;
-  }
+    }
 
-  /**
-   * @return Google\Auth\OAuth2 implementation
-   */
-  public function getOAuth2Service()
-  {
+    /**
+     * @return Google\Auth\OAuth2 implementation
+     */
+    public function getOAuth2Service()
+    {
     if (!isset($this->auth)) {
-      $this->auth = $this->createOAuth2Service();
+        $this->auth = $this->createOAuth2Service();
     }
 
     return $this->auth;
-  }
+    }
 
-  /**
-   * create a default google auth object
-   */
-  protected function createOAuth2Service()
-  {
+    /**
+     * create a default google auth object
+     */
+    protected function createOAuth2Service()
+    {
     $auth = new OAuth2(
         [
-          'clientId'          => $this->getClientId(),
-          'clientSecret'      => $this->getClientSecret(),
-          'authorizationUri'   => self::OAUTH2_AUTH_URL,
-          'tokenCredentialUri' => self::OAUTH2_TOKEN_URI,
-          'redirectUri'       => $this->getRedirectUri(),
-          'issuer'            => $this->config['client_id'],
-          'signingKey'        => $this->config['signing_key'],
-          'signingAlgorithm'  => $this->config['signing_algorithm'],
+            'clientId'          => $this->getClientId(),
+            'clientSecret'      => $this->getClientSecret(),
+            'authorizationUri'   => self::OAUTH2_AUTH_URL,
+            'tokenCredentialUri' => self::OAUTH2_TOKEN_URI,
+            'redirectUri'       => $this->getRedirectUri(),
+            'issuer'            => $this->config['client_id'],
+            'signingKey'        => $this->config['signing_key'],
+            'signingAlgorithm'  => $this->config['signing_algorithm'],
         ]
     );
 
     return $auth;
-  }
-
-  /**
-   * Set the Cache object
-   * @param Psr\Cache\CacheItemPoolInterface $cache
-   */
-  public function setCache(CacheItemPoolInterface $cache)
-  {
+    }
+
+    /**
+     * Set the Cache object
+     * @param Psr\Cache\CacheItemPoolInterface $cache
+     */
+    public function setCache(CacheItemPoolInterface $cache)
+    {
     $this->cache = $cache;
-  }
+    }
 
-  /**
-   * @return Psr\Cache\CacheItemPoolInterface Cache implementation
-   */
-  public function getCache()
-  {
+    /**
+     * @return Psr\Cache\CacheItemPoolInterface Cache implementation
+     */
+    public function getCache()
+    {
     if (!$this->cache) {
-      $this->cache = $this->createDefaultCache();
+        $this->cache = $this->createDefaultCache();
     }
 
     return $this->cache;
-  }
+    }
 
-  /**
-   * @param array $cacheConfig
-   */
-  public function setCacheConfig(array $cacheConfig)
-  {
+    /**
+     * @param array $cacheConfig
+     */
+    public function setCacheConfig(array $cacheConfig)
+    {
     $this->config['cache_config'] = $cacheConfig;
-  }
-
-  /**
-   * Set the Logger object
-   * @param Psr\Log\LoggerInterface $logger
-   */
-  public function setLogger(LoggerInterface $logger)
-  {
+    }
+
+    /**
+     * Set the Logger object
+     * @param Psr\Log\LoggerInterface $logger
+     */
+    public function setLogger(LoggerInterface $logger)
+    {
     $this->logger = $logger;
-  }
+    }
 
-  /**
-   * @return Psr\Log\LoggerInterface implementation
-   */
-  public function getLogger()
-  {
+    /**
+     * @return Psr\Log\LoggerInterface implementation
+     */
+    public function getLogger()
+    {
     if (!isset($this->logger)) {
-      $this->logger = $this->createDefaultLogger();
+        $this->logger = $this->createDefaultLogger();
     }
 
     return $this->logger;
-  }
+    }
 
-  protected function createDefaultLogger()
-  {
+    protected function createDefaultLogger()
+    {
     $logger = new Logger('google-api-php-client');
     if ($this->isAppEngine()) {
-      $handler = new MonologSyslogHandler('app', LOG_USER, Logger::NOTICE);
+        $handler = new MonologSyslogHandler('app', LOG_USER, Logger::NOTICE);
     } else {
-      $handler = new MonologStreamHandler('php://stderr', Logger::NOTICE);
+        $handler = new MonologStreamHandler('php://stderr', Logger::NOTICE);
     }
     $logger->pushHandler($handler);
 
     return $logger;
-  }
+    }
 
-  protected function createDefaultCache()
-  {
+    protected function createDefaultCache()
+    {
     return new MemoryCacheItemPool;
-  }
-
-  /**
-   * Set the Http Client object
-   * @param GuzzleHttp\ClientInterface $http
-   */
-  public function setHttpClient(ClientInterface $http)
-  {
+    }
+
+    /**
+     * Set the Http Client object
+     * @param GuzzleHttp\ClientInterface $http
+     */
+    public function setHttpClient(ClientInterface $http)
+    {
     $this->http = $http;
-  }
+    }
 
-  /**
-   * @return GuzzleHttp\ClientInterface implementation
-   */
-  public function getHttpClient()
-  {
+    /**
+     * @return GuzzleHttp\ClientInterface implementation
+     */
+    public function getHttpClient()
+    {
     if (null === $this->http) {
-      $this->http = $this->createDefaultHttpClient();
+        $this->http = $this->createDefaultHttpClient();
     }
 
     return $this->http;
-  }
-
-  /**
-   * Set the API format version.
-   *
-   * `true` will use V2, which may return more useful error messages.
-   *
-   * @param bool $value
-   */
-  public function setApiFormatV2($value)
-  {
+    }
+
+    /**
+     * Set the API format version.
+     *
+     * `true` will use V2, which may return more useful error messages.
+     *
+     * @param bool $value
+     */
+    public function setApiFormatV2($value)
+    {
     $this->config['api_format_v2'] = (bool) $value;
-  }
+    }
 
-  protected function createDefaultHttpClient()
-  {
+    protected function createDefaultHttpClient()
+    {
     $options = ['exceptions' => false];
 
     $version = ClientInterface::VERSION;
     if ('5' === $version[0]) {
-      $options = [
+        $options = [
         'base_url' => $this->config['base_path'],
         'defaults' => $options,
-      ];
-      if ($this->isAppEngine()) {
+        ];
+        if ($this->isAppEngine()) {
         // set StreamHandler on AppEngine by default
         $options['handler']  = new StreamHandler();
         $options['defaults']['verify'] = '/etc/ca-certificates.crt';
-      }
+        }
     } else {
-      // guzzle 6
-      $options['base_uri'] = $this->config['base_path'];
+        // guzzle 6
+        $options['base_uri'] = $this->config['base_path'];
     }
 
     return new Client($options);
-  }
+    }
 
-  private function createApplicationDefaultCredentials()
-  {
+    private function createApplicationDefaultCredentials()
+    {
     $scopes = $this->prepareScopes();
     $sub = $this->config['subject'];
     $signingKey = $this->config['signing_key'];
 
     // create credentials using values supplied in setAuthConfig
     if ($signingKey) {
-      $serviceAccountCredentials = array(
+        $serviceAccountCredentials = array(
         'client_id' => $this->config['client_id'],
         'client_email' => $this->config['client_email'],
         'private_key' => $signingKey,
         'type' => 'service_account',
-      );
-      $credentials = CredentialsLoader::makeCredentials($scopes, $serviceAccountCredentials);
+        );
+        $credentials = CredentialsLoader::makeCredentials($scopes, $serviceAccountCredentials);
     } else {
-      $credentials = ApplicationDefaultCredentials::getCredentials($scopes);
+        $credentials = ApplicationDefaultCredentials::getCredentials($scopes);
     }
 
     // for service account domain-wide authority (impersonating a user)
     // @see https://developers.google.com/identity/protocols/OAuth2ServiceAccount
     if ($sub) {
-      if (!$credentials instanceof ServiceAccountCredentials) {
+        if (!$credentials instanceof ServiceAccountCredentials) {
         throw new DomainException('domain-wide authority requires service account credentials');
-      }
+        }
 
-      $credentials->setSub($sub);
+        $credentials->setSub($sub);
     }
 
     return $credentials;
-  }
+    }
 
-  protected function getAuthHandler()
-  {
+    protected function getAuthHandler()
+    {
     // Be very careful using the cache, as the underlying auth library's cache
     // implementation is naive, and the cache keys do not account for user
     // sessions.
@@ -1145,18 +1145,18 @@ 
         $this->getCache(),
         $this->config['cache_config']
     );
-  }
+    }
 
-  private function createUserRefreshCredentials($scope, $refreshToken)
-  {
+    private function createUserRefreshCredentials($scope, $refreshToken)
+    {
     $creds = array_filter(
         array(
-          'client_id' => $this->getClientId(),
-          'client_secret' => $this->getClientSecret(),
-          'refresh_token' => $refreshToken,
+            'client_id' => $this->getClientId(),
+            'client_secret' => $this->getClientSecret(),
+            'refresh_token' => $refreshToken,
         )
     );
 
     return new UserRefreshCredentials($scope, $creds);
-  }
+    }
 }

Spacing +4 added lines, -4 removed lines

@@ -341,7 +341,7 @@ 
 
     $auth = $this->getOAuth2Service();
 
-    return (string) $auth->buildFullAuthorizationUri($params);
+    return (string)$auth->buildFullAuthorizationUri($params);
   }
 
   /**
@@ -384,7 +384,7 @@ 
       $callback = $this->config['token_callback'];
       $http = $authHandler->attachCredentials($http, $credentials, $callback);
     } elseif ($token) {
-      $http = $authHandler->attachToken($http, $token, (array) $scopes);
+      $http = $authHandler->attachToken($http, $token, (array)$scopes);
     } elseif ($key = $this->config['developer_key']) {
       $http = $authHandler->attachKey($http, $key);
     }
@@ -1076,7 +1076,7 @@ 
    */
   public function setApiFormatV2($value)
   {
-    $this->config['api_format_v2'] = (bool) $value;
+    $this->config['api_format_v2'] = (bool)$value;
   }
 
   protected function createDefaultHttpClient()
@@ -1091,7 +1091,7 @@ 
       ];
       if ($this->isAppEngine()) {
         // set StreamHandler on AppEngine by default
-        $options['handler']  = new StreamHandler();
+        $options['handler'] = new StreamHandler();
         $options['defaults']['verify'] = '/etc/ca-certificates.crt';
       }
     } else {

lib/Google/Model.php

Indentation +176 added lines, -176 removed lines

@@ -23,295 +23,295 @@
  */
 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();
+    /**
+     * 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()
-  {
+    /**
+     * 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);
+        // 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)
-  {
+    /**
+     * 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)
+    {
     $keyType = $this->keyType($key);
     $keyDataType = $this->dataType($key);
     if ($keyType && !isset($this->processed[$key])) {
-      if (isset($this->modelData[$key])) {
+        if (isset($this->modelData[$key])) {
         $val = $this->modelData[$key];
-      } elseif ($keyDataType == 'array' || $keyDataType == 'map') {
+        } elseif ($keyDataType == 'array' || $keyDataType == 'map') {
         $val = array();
-      } else {
+        } else {
         $val = null;
-      }
+        }
 
-      if ($this->isAssociativeArray($val)) {
+        if ($this->isAssociativeArray($val)) {
         if ($keyDataType && 'map' == $keyDataType) {
-          foreach ($val as $arrayKey => $arrayItem) {
-              $this->modelData[$key][$arrayKey] =
+            foreach ($val as $arrayKey => $arrayItem) {
+                $this->modelData[$key][$arrayKey] =
                 new $keyType($arrayItem);
-          }
+            }
         } else {
-          $this->modelData[$key] = new $keyType($val);
+            $this->modelData[$key] = new $keyType($val);
         }
-      } else if (is_array($val)) {
+        } else if (is_array($val)) {
         $arrayObject = array();
         foreach ($val as $arrayIndex => $arrayItem) {
-          $arrayObject[$arrayIndex] = new $keyType($arrayItem);
+            $arrayObject[$arrayIndex] = new $keyType($arrayItem);
         }
         $this->modelData[$key] = $arrayObject;
-      }
-      $this->processed[$key] = true;
+        }
+        $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)
-  {
+    /**
+     * 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 ($keyType = $this->keyType($key)) {
+        if ($keyType = $this->keyType($key)) {
         $dataType = $this->dataType($key);
         if ($dataType == 'array' || $dataType == 'map') {
-          $this->$key = array();
-          foreach ($val as $itemKey => $itemVal) {
+            $this->$key = array();
+            foreach ($val as $itemKey => $itemVal) {
             if ($itemVal instanceof $keyType) {
-              $this->{$key}[$itemKey] = $itemVal;
+                $this->{$key}[$itemKey] = $itemVal;
             } else {
-              $this->{$key}[$itemKey] = new $keyType($itemVal);
+                $this->{$key}[$itemKey] = new $keyType($itemVal);
+            }
             }
-          }
         } elseif ($val instanceof $keyType) {
-          $this->$key = $val;
+            $this->$key = $val;
         } else {
-          $this->$key = new $keyType($val);
+            $this->$key = new $keyType($val);
         }
         unset($array[$key]);
-      } elseif (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;
-      }
+        } elseif (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()
-  {
+    /**
+     * 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()
-  {
+    /**
+     * 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) {
+        $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 = $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)
-  {
+    /**
+     * 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();
+        return $value->toSimpleObject();
     } else if (is_array($value)) {
-      $return = array();
-      foreach ($value as $key => $a_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);
+            $key = $this->getMappedName($key);
+            $return[$key] = $this->nullPlaceholderCheck($a_value);
+        }
         }
-      }
-      return $return;
+        return $return;
     }
     return $value;
-  }
+    }
 
-  /**
-   * Check whether the value is the null placeholder and return true null.
-   */
-  private function nullPlaceholderCheck($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 null;
     }
     return $value;
-  }
+    }
 
-  /**
-   * If there is an internal name mapping, use that.
-   */
-  private function getMappedName($key)
-  {
+    /**
+     * 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];
+        $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)
-  {
+    /**
+     * 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;
+        return false;
     }
     $keys = array_keys($array);
     foreach ($keys as $key) {
-      if (is_string($key)) {
+        if (is_string($key)) {
         return true;
-      }
+        }
     }
     return false;
-  }
+    }
 
-  /**
-   * 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)
-  {
+    /**
+     * 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."
-      );
+        throw new Google_Exception(
+            "Incorrect parameter type passed to $method(). Expected an array."
+        );
+    }
     }
-  }
 
-  public function offsetExists($offset)
-  {
+    public function offsetExists($offset)
+    {
     return isset($this->$offset) || isset($this->modelData[$offset]);
-  }
+    }
 
-  public function offsetGet($offset)
-  {
+    public function offsetGet($offset)
+    {
     return isset($this->$offset) ?
         $this->$offset :
         $this->__get($offset);
-  }
+    }
 
-  public function offsetSet($offset, $value)
-  {
+    public function offsetSet($offset, $value)
+    {
     if (property_exists($this, $offset)) {
-      $this->$offset = $value;
+        $this->$offset = $value;
     } else {
-      $this->modelData[$offset] = $value;
-      $this->processed[$offset] = true;
+        $this->modelData[$offset] = $value;
+        $this->processed[$offset] = true;
+    }
     }
-  }
 
-  public function offsetUnset($offset)
-  {
+    public function offsetUnset($offset)
+    {
     unset($this->modelData[$offset]);
-  }
+    }
 
-  protected function keyType($key)
-  {
+    protected function keyType($key)
+    {
     $keyType = $key . "Type";
 
     // ensure keyType is a valid class
     if (property_exists($this, $keyType) && class_exists($this->$keyType)) {
-      return $this->$keyType;
+        return $this->$keyType;
+    }
     }
-  }
 
-  protected function dataType($key)
-  {
+    protected function dataType($key)
+    {
     $dataType = $key . "DataType";
 
     if (property_exists($this, $dataType)) {
-      return $this->$dataType;
+        return $this->$dataType;
+    }
     }
-  }
 
-  public function __isset($key)
-  {
+    public function __isset($key)
+    {
     return isset($this->modelData[$key]);
-  }
+    }
 
-  public function __unset($key)
-  {
+    public function __unset($key)
+    {
     unset($this->modelData[$key]);
-  }
+    }
 
-  /**
-   * Convert a string to camelCase
-   * @param  string $value
-   * @return string
-   */
-  private function camelCase($value)
-  {
+    /**
+     * 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;
-  }
+    }
 }

Spacing +1 added lines, -2 removed lines

@@ -254,8 +254,7 @@
   public function offsetGet($offset)
   {
     return isset($this->$offset) ?
-        $this->$offset :
-        $this->__get($offset);
+        $this->$offset : $this->__get($offset);
   }
 
   public function offsetSet($offset, $value)

lib/Google/AccessToken/Revoke.php

Indentation +26 added lines, -26 removed lines

@@ -27,35 +27,35 @@ 
  */
 class Google_AccessToken_Revoke
 {
-  /**
-   * @var GuzzleHttp\ClientInterface The http client
-   */
-  private $http;
+    /**
+     * @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)
-  {
+    /**
+     * 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)
-  {
+    /**
+     * 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'])) {
+        if (isset($token['refresh_token'])) {
         $token = $token['refresh_token'];
-      } else {
+        } else {
         $token = $token['access_token'];
-      }
+        }
     }
 
     $body = Psr7\stream_for(http_build_query(array('token' => $token)));
@@ -63,8 +63,8 @@ 
         'POST',
         Google_Client::OAUTH2_REVOKE_URI,
         [
-          'Cache-Control' => 'no-store',
-          'Content-Type'  => 'application/x-www-form-urlencoded',
+            'Cache-Control' => 'no-store',
+            'Content-Type'  => 'application/x-www-form-urlencoded',
         ],
         $body
     );
@@ -74,5 +74,5 @@ 
     $response = $httpHandler($request);
 
     return $response->getStatusCode() == 200;
-  }
+    }
 }

lib/Google/AccessToken/Verify.php

Indentation +125 added lines, -125 removed lines

@@ -31,55 +31,55 @@ 
  */
 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
-  ) {
+    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();
+        $http = new Client();
     }
 
     if (null === $cache) {
-      $cache = new MemoryCacheItemPool;
+        $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)
-  {
+    }
+
+    /**
+     * 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');
+        throw new LogicException('id_token cannot be null');
     }
 
     // set phpseclib constants if applicable
@@ -88,15 +88,15 @@ 
     // 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);
+        $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));
+        $rsa = new $rsaClass();
+        $rsa->loadKey(array('n' => $modulus, 'e' => $exponent));
 
-      try {
+        try {
         $payload = $this->jwt->decode(
             $idToken,
             $rsa->getPublicKey(),
@@ -104,63 +104,63 @@ 
         );
 
         if (property_exists($payload, 'aud')) {
-          if ($audience && $payload->aud != $audience) {
+            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 false;
         }
 
         return (array) $payload;
-      } catch (ExpiredException $e) {
+        } catch (ExpiredException $e) {
         return false;
-      } catch (ExpiredExceptionV3 $e) {
+        } catch (ExpiredExceptionV3 $e) {
         return false;
-      } catch (SignatureInvalidException $e) {
+        } catch (SignatureInvalidException $e) {
         // continue
-      } catch (DomainException $e) {
+        } catch (DomainException $e) {
         // continue
-      }
+        }
     }
 
     return false;
-  }
+    }
 
-  private function getCache()
-  {
+    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)
-  {
+    }
+
+    /**
+     * 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)) {
+        if (!$file = file_get_contents($url)) {
         throw new Google_Exception(
             "Failed to retrieve verification certificates: '" .
             $url . "'."
         );
-      }
+        }
 
-      return json_decode($file, true);
+        return json_decode($file, true);
     }
 
     $response = $this->http->get($url);
 
     if ($response->getStatusCode() == 200) {
-      return json_decode((string) $response->getBody(), true);
+        return json_decode((string) $response->getBody(), true);
     }
     throw new Google_Exception(
         sprintf(
@@ -169,105 +169,105 @@ 
         ),
         $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()
-  {
+    // 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');
-      $certs = $cacheItem->get();
+        $cacheItem = $cache->getItem('federated_signon_certs_v3');
+        $certs = $cacheItem->get();
     }
 
 
     if (!$certs) {
-      $certs = $this->retrieveCertsFromLocation(
-          self::FEDERATED_SIGNON_CERT_URL
-      );
+        $certs = $this->retrieveCertsFromLocation(
+            self::FEDERATED_SIGNON_CERT_URL
+        );
 
-      if ($cache) {
+        if ($cache) {
         $cacheItem->expiresAt(new DateTime('+1 hour'));
         $cacheItem->set($certs);
         $cache->save($cacheItem);
-      }
+        }
     }
 
     if (!isset($certs['keys'])) {
-      throw new InvalidArgumentException(
-          'federated sign-on certs expects "keys" to be set'
-      );
+        throw new InvalidArgumentException(
+            'federated sign-on certs expects "keys" to be set'
+        );
     }
 
     return $certs['keys'];
-  }
+    }
 
-  private function getJwtService()
-  {
+    private function getJwtService()
+    {
     $jwtClass = 'JWT';
     if (class_exists('\Firebase\JWT\JWT')) {
-      $jwtClass = 'Firebase\JWT\JWT';
+        $jwtClass = 'Firebase\JWT\JWT';
     }
 
     if (property_exists($jwtClass, 'leeway') && $jwtClass::$leeway < 1) {
-      // Ensures JWT leeway is at least 1
-      // @see https://github.com/google/google-api-php-client/issues/827
-      $jwtClass::$leeway = 1;
+        // Ensures JWT leeway is at least 1
+        // @see https://github.com/google/google-api-php-client/issues/827
+        $jwtClass::$leeway = 1;
     }
 
     return new $jwtClass;
-  }
+    }
 
-  private function getRsaClass()
-  {
+    private function getRsaClass()
+    {
     if (class_exists('phpseclib\Crypt\RSA')) {
-      return 'phpseclib\Crypt\RSA';
+        return 'phpseclib\Crypt\RSA';
     }
 
     return 'Crypt_RSA';
-  }
+    }
 
-  private function getBigIntClass()
-  {
+    private function getBigIntClass()
+    {
     if (class_exists('phpseclib\Math\BigInteger')) {
-      return 'phpseclib\Math\BigInteger';
+        return 'phpseclib\Math\BigInteger';
     }
 
     return 'Math_BigInteger';
-  }
+    }
 
-  private function getOpenSslConstant()
-  {
+    private function getOpenSslConstant()
+    {
     if (class_exists('phpseclib\Crypt\RSA')) {
-      return 'phpseclib\Crypt\RSA::MODE_OPENSSL';
+        return 'phpseclib\Crypt\RSA::MODE_OPENSSL';
     }
 
     if (class_exists('Crypt_RSA')) {
-      return 'CRYPT_RSA_MODE_OPENSSL';
+        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()
-  {
+    }
+
+    /**
+     * 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')) {
+        if (!defined('MATH_BIGINTEGER_OPENSSL_ENABLED')) {
         define('MATH_BIGINTEGER_OPENSSL_ENABLED', true);
-      }
-      if (!defined('CRYPT_RSA_MODE')) {
+        }
+        if (!defined('CRYPT_RSA_MODE')) {
         define('CRYPT_RSA_MODE', constant($this->getOpenSslConstant()));
-      }
+        }
+    }
     }
-  }
 }

Spacing +2 added lines, -2 removed lines

@@ -116,7 +116,7 @@ 
           return false;
         }
 
-        return (array) $payload;
+        return (array)$payload;
       } catch (ExpiredException $e) {
         return false;
       } catch (ExpiredExceptionV3 $e) {
@@ -160,7 +160,7 @@ 
     $response = $this->http->get($url);
 
     if ($response->getStatusCode() == 200) {
-      return json_decode((string) $response->getBody(), true);
+      return json_decode((string)$response->getBody(), true);
     }
     throw new Google_Exception(
         sprintf(

lib/Google/Http/Batch.php

Indentation +106 added lines, -106 removed lines

@@ -30,49 +30,49 @@ 
  */
 class Google_Http_Batch
 {
-  const BATCH_PATH = 'batch';
+    const BATCH_PATH = 'batch';
 
-  private static $CONNECTION_ESTABLISHED_HEADERS = array(
+    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 string Multipart Boundary. */
+    private $boundary;
 
-  /** @var array service requests to be executed. */
-  private $requests = array();
+    /** @var array service requests to be executed. */
+    private $requests = array();
 
-  /** @var Google_Client */
-  private $client;
+    /** @var Google_Client */
+    private $client;
 
-  private $rootUrl;
+    private $rootUrl;
 
-  private $batchPath;
+    private $batchPath;
 
-  public function __construct(
-      Google_Client $client,
-      $boundary = false,
-      $rootUrl = null,
-      $batchPath = null
-  ) {
+    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)
-  {
+    public function add(RequestInterface $request, $key = false)
+    {
     if (false == $key) {
-      $key = mt_rand();
+        $key = mt_rand();
     }
 
     $this->requests[$key] = $request;
-  }
+    }
 
-  public function execute()
-  {
+    public function execute()
+    {
     $body = '';
     $classes = array();
     $batchHttpTemplate = <<<EOF
@@ -90,38 +90,38 @@ 
 
     /** @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');
+        $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),
+        'Content-Type' => sprintf('multipart/mixed; boundary=%s', $this->boundary),
+        'Content-Length' => strlen($body),
     );
 
     $request = new Request(
@@ -134,95 +134,95 @@ 
     $response = $this->client->execute($request);
 
     return $this->parseResponse($response, $classes);
-  }
+    }
 
-  public function parseResponse(ResponseInterface $response, $classes = array())
-  {
+    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])) {
+        $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);
+        $body = str_replace("--$boundary--", "--$boundary", $body);
+        $parts = explode("--$boundary", $body);
+        $responses = array();
+        $requests = array_values($this->requests);
 
-      foreach ($parts as $i => $part) {
+        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);
+            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];
+            $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)
-          );
+            list($partHeaders, $partBody) = $this->parseHttpResponse($part, false);
+            $response = new Response(
+                $status,
+                $partHeaders,
+                Psr7\stream_for($partBody)
+            );
 
-          // Need content id.
-          $key = $headers['content-id'];
+            // Need content id.
+            $key = $headers['content-id'];
 
-          try {
+            try {
             $response = Google_Http_REST::decodeHttpResponse($response, $requests[$i-1]);
-          } catch (Google_Service_Exception $e) {
+            } catch (Google_Service_Exception $e) {
             // Store the exception as the response, so successful responses
             // can be processed.
             $response = $e;
-          }
+            }
 
-          $responses[$key] = $response;
+            $responses[$key] = $response;
+        }
         }
-      }
 
-      return $responses;
+        return $responses;
     }
 
     return null;
-  }
+    }
 
-  private function parseRawHeaders($rawHeaders)
-  {
+    private function parseRawHeaders($rawHeaders)
+    {
     $headers = array();
     $responseHeaderLines = explode("\r\n", $rawHeaders);
     foreach ($responseHeaderLines as $headerLine) {
-      if ($headerLine && strpos($headerLine, ':') !== false) {
+        if ($headerLine && strpos($headerLine, ':') !== false) {
         list($header, $value) = explode(': ', $headerLine, 2);
         $header = strtolower($header);
         if (isset($headers[$header])) {
-          $headers[$header] .= "\n" . $value;
+            $headers[$header] .= "\n" . $value;
         } else {
-          $headers[$header] = $value;
+            $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)
-  {
+    }
+
+    /**
+     * 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) {
+        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
@@ -233,21 +233,21 @@ 
         //   $headerSize -= strlen($established_header);
         // }
         break;
-      }
+        }
     }
 
     if ($headerSize) {
-      $responseBody = substr($respData, $headerSize);
-      $responseHeaders = substr($respData, 0, $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] :
+        $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);
-  }
+    }
 }

Spacing +5 added lines, -6 removed lines

@@ -97,7 +97,7 @@ 
           $request->getProtocolVersion()
       );
 
-      $content = (string) $request->getBody();
+      $content = (string)$request->getBody();
 
       $headers = '';
       foreach ($request->getHeaders() as $name => $values) {
@@ -110,7 +110,7 @@ 
           $key,
           $firstLine,
           $headers,
-          $content ? "\n".$content : ''
+          $content ? "\n" . $content : ''
       );
 
       $classes['response-' . $key] = $request->getHeaderLine('X-Php-Expected-Class');
@@ -148,7 +148,7 @@ 
       }
     }
 
-    $body = (string) $response->getBody();
+    $body = (string)$response->getBody();
     if (!empty($body)) {
       $body = str_replace("--$boundary--", "--$boundary", $body);
       $parts = explode("--$boundary", $body);
@@ -176,7 +176,7 @@ 
           $key = $headers['content-id'];
 
           try {
-            $response = Google_Http_REST::decodeHttpResponse($response, $requests[$i-1]);
+            $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.
@@ -242,8 +242,7 @@ 
     } else {
       $responseSegments = explode("\r\n\r\n", $respData, 2);
       $responseHeaders = $responseSegments[0];
-      $responseBody = isset($responseSegments[1]) ? $responseSegments[1] :
-                                                    null;
+      $responseBody = isset($responseSegments[1]) ? $responseSegments[1] : null;
     }
 
     $responseHeaders = $this->parseRawHeaders($responseHeaders);

lib/Google/Http/REST.php

Indentation +82 added lines, -82 removed lines

@@ -27,23 +27,23 @@ 
  */
 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
-  ) {
+    /**
+     * 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()),
@@ -52,35 +52,35 @@ 
     );
 
     if (null !== $retryMap) {
-      $runner->setRetryMap($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)
-  {
+    }
+
+    /**
+     * 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);
+        $httpHandler = HttpHandlerFactory::build($client);
+        $response = $httpHandler($request);
     } catch (RequestException $e) {
-      // if Guzzle throws an exception, catch it and handle the response
-      if (!$e->hasResponse()) {
+        // 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 = $e->getResponse();
+        // specific checking for Guzzle 5: convert to PSR7 response
+        if ($response instanceof \GuzzleHttp\Message\ResponseInterface) {
         $response = new Response(
             $response->getStatusCode(),
             $response->getHeaders() ?: [],
@@ -88,34 +88,34 @@ 
             $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
-  ) {
+    }
+
+    /**
+     * 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();
+        // 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));
+        // 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
@@ -123,60 +123,60 @@ 
     $body = self::decodeBody($response, $request);
 
     if ($expectedClass = self::determineExpectedClass($expectedClass, $request)) {
-      $json = json_decode($body, true);
+        $json = json_decode($body, true);
 
-      return new $expectedClass($json);
+        return new $expectedClass($json);
     }
 
     return $response;
-  }
+    }
 
-  private static function decodeBody(ResponseInterface $response, RequestInterface $request = null)
-  {
+    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 '';
+        // 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)
-  {
+    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;
+        return null;
     }
 
     // if we don't have a request, we just use what's passed in
     if (null === $request) {
-      return $expectedClass;
+        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)
-  {
+    private static function getResponseErrors($body)
+    {
     $json = json_decode($body, true);
 
     if (isset($json['error']['errors'])) {
-      return $json['error']['errors'];
+        return $json['error']['errors'];
     }
 
     return null;
-  }
+    }
 
-  private static function isAltMedia(RequestInterface $request = 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') {
+        parse_str($qs, $query);
+        if (isset($query['alt']) && $query['alt'] == 'media') {
         return true;
-      }
+        }
     }
 
     return false;
-  }
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -46,7 +46,7 @@ 
   ) {
     $runner = new Google_Task_Runner(
         $config,
-        sprintf('%s %s', $request->getMethod(), (string) $request->getUri()),
+        sprintf('%s %s', $request->getMethod(), (string)$request->getUri()),
         array(get_class(), 'doExecute'),
         array($client, $request, $expectedClass)
     );
@@ -112,7 +112,7 @@ 
     // retry strategy
     if (intVal($code) >= 400) {
       // if we errored out, it should be safe to grab the response body
-      $body = (string) $response->getBody();
+      $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));
@@ -138,7 +138,7 @@ 
       return '';
     }
 
-    return (string) $response->getBody();
+    return (string)$response->getBody();
   }
 
   private static function determineExpectedClass($expectedClass, RequestInterface $request = null)