google-api-client 0.8.6 → 0.9

data/google-api-client.gemspec

@@ -1,43 +1,31 @@
-# -*- encoding: utf-8 -*-
-require File.join(File.dirname(__FILE__), 'lib/google/api_client', 'version')
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'google/apis/version'
 
-Gem::Specification.new do |s|
-  s.name = "google-api-client"
-  s.version = Google::APIClient::VERSION::STRING
+Gem::Specification.new do |spec|
+  spec.name          = 'google-api-client'
+  spec.version       = Google::Apis::VERSION
+  spec.authors       = ['Steven Bazyl', 'Tim Emiola', 'Sergio Gomes', 'Bob Aman']
+  spec.email         = ['sbazyl@google.com']
+  spec.summary       = %q{Client for accessing Google APIs}
+  spec.homepage      = 'https://github.com/google/google-api-ruby-client'
+  spec.license       = 'Apache 2.0'
 
-  s.required_rubygems_version = ">= 1.3.5"
-  s.require_paths = ["lib"]
-  s.authors = ["Bob Aman", "Steven Bazyl"]
-  s.license = "Apache-2.0"
-  s.description = "The Google API Ruby Client makes it trivial to discover and access supported APIs."
-  s.email = "sbazyl@google.com"
-  s.extra_rdoc_files = ["README.md"]
-  s.files = %w(google-api-client.gemspec Rakefile LICENSE CHANGELOG.md README.md Gemfile)
-  s.files += Dir.glob("lib/**/*.rb")
-  s.files += Dir.glob("lib/cacerts.pem")
-  s.files += Dir.glob("spec/**/*.{rb,opts}")
-  s.files += Dir.glob("vendor/**/*.rb")
-  s.files += Dir.glob("tasks/**/*")
-  s.files += Dir.glob("website/**/*")
-  s.homepage = "https://github.com/google/google-api-ruby-client/"
-  s.rdoc_options = ["--main", "README.md"]
-  s.summary = "The Google API Ruby Client makes it trivial to discover and access Google's REST APIs."
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib', 'generated', 'third_party']
 
-  s.add_runtime_dependency 'addressable', '~> 2.3'
-  s.add_runtime_dependency 'signet', '~> 0.6'
-  s.add_runtime_dependency 'faraday', '~> 0.9'
-  s.add_runtime_dependency 'googleauth', '~> 0.3'
-  s.add_runtime_dependency 'multi_json', '~> 1.10'
-  s.add_runtime_dependency 'autoparse', '~> 0.3'
-  s.add_runtime_dependency 'extlib', '~> 0.9'
-  s.add_runtime_dependency 'launchy', '~> 2.4'
-  s.add_runtime_dependency 'retriable', '~> 1.4'
-  s.add_runtime_dependency 'activesupport', '>= 3.2'
-
-  s.add_development_dependency 'rake', '~> 10.0'
-  s.add_development_dependency 'yard', '~> 0.8'
-  s.add_development_dependency 'rspec', '~> 3.1'
-  s.add_development_dependency 'kramdown', '~> 1.5'
-  s.add_development_dependency 'simplecov', '~> 0.9.2'
-  s.add_development_dependency 'coveralls', '~> 0.7.11'
+  spec.add_runtime_dependency 'representable', '~> 2.3.0'
+  spec.add_runtime_dependency 'multi_json', '~> 1.11'
+  spec.add_runtime_dependency 'retriable', '~> 2.0'
+  spec.add_runtime_dependency 'activesupport', '>= 3.2'
+  spec.add_runtime_dependency 'addressable', '~> 2.3'
+  spec.add_runtime_dependency 'mime-types', '>= 1.6'
+  spec.add_runtime_dependency 'hurley', '~> 0.1'
+  spec.add_runtime_dependency 'googleauth', '~> 0.5'
+  spec.add_runtime_dependency 'thor', '~> 0.19'
+  spec.add_runtime_dependency 'httpclient', '~> 2.7'
+  spec.add_runtime_dependency 'memoist', '~> 0.11'
 end

data/lib/google/api_client/auth/installed_app.rb

@@ -23,14 +23,17 @@ module Google
     #
     # @example
     #
-    #    client = Google::APIClient.new
     #    flow = Google::APIClient::InstalledAppFlow.new(
     #      :client_id => '691380668085.apps.googleusercontent.com',
     #      :client_secret => '...',
     #      :scope => 'https://www.googleapis.com/auth/drive'
     #    )
-    #    client.authorization = flow.authorize
+    #    authorization = flow.authorize
+    #    Drive = Google::Apis::DriveV2
+    #    drive = Drive::DriveService.new
+    #    drive.authorization = authorization
     #
+    # @deprecated Use google-auth-library-ruby instead
     class InstalledAppFlow
 
       RESPONSE_BODY = <<-HTML
@@ -83,7 +86,7 @@ module Google
       #
       # @return [Signet::OAuth2::Client]
       #  Authorization instance, nil if user cancelled.
-      def authorize(storage=nil)
+      def authorize(storage=nil, options={})
         auth = @authorization
 
         server = WEBrick::HTTPServer.new(
@@ -105,7 +108,7 @@ module Google
             server.stop
           end
 
-          Launchy.open(auth.authorization_uri.to_s)
+          Launchy.open(auth.authorization_uri(options).to_s)
           server.start
         ensure
           server.shutdown
@@ -123,4 +126,3 @@ module Google
 
   end
 end
-

data/lib/google/api_client/auth/key_utils.rb

@@ -18,6 +18,7 @@ module Google
     # Helper for loading keys from the PKCS12 files downloaded when
     # setting up service accounts at the APIs Console.
     #
+    # @deprecated Use google-auth-library-ruby instead
     module KeyUtils
       ##
       # Loads a key from PKCS12 file, assuming a single private key

data/lib/google/api_client/auth/storage.rb

@@ -21,6 +21,7 @@ module Google
     # JSON serialized file. Meant to resemble the serialized format
     # http://google-api-python-client.googlecode.com/hg/docs/epy/oauth2client.file.Storage-class.html
     #
+    # @deprecated Use google-auth-library-ruby instead
     class Storage
 
       AUTHORIZATION_URI = 'https://accounts.google.com/o/oauth2/auth'
@@ -35,7 +36,8 @@ module Google
       ##
       # Initializes the Storage object.
       #
-      # @params [Object] Storage object
+      # @param [Object] store
+      #  Storage object
       def initialize(store)
         @store= store
         @authorization = nil
@@ -44,7 +46,7 @@ module Google
       ##
       # Write the credentials to the specified store.
       #
-      # @params [Signet::OAuth2::Client] authorization
+      # @param [Signet::OAuth2::Client] authorization
       #    Optional authorization instance. If not provided, the authorization
       #    already associated with this instance will be written.
       def write_credentials(authorization=nil)

data/lib/google/api_client/auth/storages/file_store.rb

@@ -21,6 +21,7 @@ module Google
     # JSON serialized file. Meant to resemble the serialized format
     # http://google-api-python-client.googlecode.com/hg/docs/epy/oauth2client.file.Storage-class.html
     #
+    # @deprecated Use google-auth-library-ruby instead
     class FileStore
 
       attr_accessor :path
@@ -45,9 +46,7 @@ module Google
       ##
       # Write the credentials to the specified file.
       #
-      # @param [Signet::OAuth2::Client] authorization
-      #    Optional authorization instance. If not provided, the authorization
-      #    already associated with this instance will be written.
+      # @param [Hash] credentials_hash
       def write_credentials(credentials_hash)
         open(self.path, 'w+') do |f|
           f.write(credentials_hash.to_json)

data/lib/google/api_client/auth/storages/redis_store.rb

@@ -16,6 +16,7 @@ require 'json'
 
 module Google
   class APIClient
+    # @deprecated Use google-auth-library-ruby instead
     class RedisStore
 
       DEFAULT_REDIS_CREDENTIALS_KEY = "google_api_credentials"
@@ -25,7 +26,10 @@ module Google
       ##
       # Initializes the RedisStore object.
       #
-      # @params [Object] Redis instance
+      # @param [Object] redis
+      #  Redis instance
+      # @param [Object] key
+      #  Optional key to store credentials under. Defaults to 'google_api_credentials'
       def initialize(redis, key = nil)
         @redis= redis
         @redis_credentials_key = key
@@ -33,6 +37,7 @@ module Google
 
       ##
       # Attempt to read in credentials from redis.
+      # @return [Hash]
       def load_credentials
         credentials = redis.get redis_credentials_key
         JSON.parse(credentials) if credentials
@@ -45,7 +50,7 @@ module Google
       ##
       # Write the credentials to redis.
       #
-      # @params [Hash] credentials
+      # @param [Hash] credentials_hash
       def write_credentials(credentials_hash)
         redis.set(redis_credentials_key, credentials_hash.to_json)
       end

data/lib/google/api_client/client_secrets.rb

@@ -23,7 +23,7 @@ module Google
     # inspired by the Google API Python client.
     #
     # @see https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
-    #
+    # @deprecated Use google-auth-library-ruby instead
     # @example
     #   {
     #     "web": {
@@ -46,7 +46,6 @@ module Google
     #     }
     #   }
     class ClientSecrets
-      
       ##
       # Reads client configuration from a file
       #
@@ -77,7 +76,7 @@ module Google
       end
 
       ##
-      # Intialize OAuth client settings.
+      # Initialize OAuth client settings.
       #
       # @param [Hash] options
       #   Parsed client secrets files
@@ -122,7 +121,7 @@ module Google
       def to_json
         return MultiJson.dump(to_hash)
       end
-      
+
       def to_hash
         {
           self.flow => ({
@@ -147,7 +146,7 @@ module Google
           end
         }
       end
-      
+
       def to_authorization
         gem 'signet', '>= 0.4.0'
         require 'signet/oauth_2/client'

data/lib/google/apis.rb

@@ -0,0 +1,48 @@
+# Copyright 2015 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'google/apis/version'
+require 'logger'
+
+module Google
+  module Apis
+    ROOT = File.expand_path('..', File.dirname(__dir__))
+
+    # @!attribute [rw] logger
+    # @return [Logger] The logger.
+    def self.logger
+      @logger ||= rails_logger || default_logger
+    end
+
+    class << self
+      attr_writer :logger
+    end
+
+    private
+
+    # Create and configure a logger
+    # @return [Logger]
+    def self.default_logger
+      logger = Logger.new($stdout)
+      logger.level = Logger::WARN
+      logger
+    end
+
+    # Check to see if client is being used in a Rails environment and ge the logger if present
+    # @return [Logger]
+    def self.rails_logger
+      ::Rails.logger if defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+    end
+  end
+end

data/lib/google/apis/core/api_command.rb

@@ -0,0 +1,135 @@
+# Copyright 2015 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'active_support/inflector'
+require 'addressable/uri'
+require 'addressable/template'
+require 'google/apis/core/http_command'
+require 'google/apis/errors'
+require 'multi_json'
+require 'retriable'
+
+module Google
+  module Apis
+    module Core
+      # Command for executing most basic API request with JSON requests/responses
+      class ApiCommand < HttpCommand
+        JSON_CONTENT_TYPE = 'application/json'
+        FIELDS_PARAM = 'fields'
+        RATE_LIMIT_ERRORS = %w(rateLimitExceeded userRateLimitExceeded)
+
+        # JSON serializer for request objects
+        # @return [Google::Apis::Core::JsonRepresentation]
+        attr_accessor :request_representation
+
+        # Request body to serialize
+        # @return [Object]
+        attr_accessor :request_object
+
+        # JSON serializer for response objects
+        # @return [Google::Apis::Core::JsonRepresentation]
+        attr_accessor :response_representation
+
+        # Class to instantiate when de-serializing responses
+        # @return [Object]
+        attr_accessor :response_class
+
+        # Serialize the request body
+        #
+        # @return [void]
+        def prepare!
+          query[FIELDS_PARAM] = normalize_fields_param(query[FIELDS_PARAM]) if query.key?(FIELDS_PARAM)
+          if request_representation && request_object
+            header[:content_type] ||= JSON_CONTENT_TYPE
+            self.body = request_representation.new(request_object).to_json(skip_undefined: true)
+          end
+          super
+        end
+
+        # Deserialize the response body if present
+        #
+        # @param [String] content_type
+        #  Content type of body
+        # @param [String, #read] body
+        #  Response body
+        # @return [Object]
+        #   Response object
+        # noinspection RubyUnusedLocalVariable
+        def decode_response_body(content_type, body)
+          return super unless response_representation
+          return super if content_type.nil?
+          return nil unless content_type.start_with?(JSON_CONTENT_TYPE)
+          instance = response_class.new
+          response_representation.new(instance).from_json(body, unwrap: response_class)
+          instance
+        end
+
+        # Check the response and raise error if needed
+        #
+        # @param [Fixnum] status
+        #   HTTP status code of response
+        # @param [Hurley::Header] header
+        #   HTTP response headers
+        # @param [String] body
+        #   HTTP response body
+        # @param [String] message
+        #   Error message text
+        # @return [void]
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def check_status(status, header = nil, body = nil, message = nil)
+          case status
+          when 400, 402...500
+            error = parse_error(body)
+            if error
+              message = sprintf('%s: %s', error['reason'], error['message'])
+              raise Google::Apis::RateLimitError.new(message,
+                                                     status_code: status,
+                                                     header: header,
+                                                     body: body) if RATE_LIMIT_ERRORS.include?(error['reason'])
+            end
+            super(status, header, body, message)
+          else
+            super(status, header, body, message)
+          end
+        end
+
+        private
+
+        # Attempt to parse a JSON error message, returning the first found error
+        # @param [String] body
+        #  HTTP response body
+        # @return [Hash]
+        def parse_error(body)
+          hash = MultiJson.load(body)
+          hash['error']['errors'].first
+        rescue
+          nil
+        end
+
+        # Convert field names from ruby conventions to original names in JSON
+        #
+        # @param [String] fields
+        #   Value of 'fields' param
+        # @return [String]
+        #   Updated header value
+        def normalize_fields_param(fields)
+          # TODO: Generate map of parameter names during code gen. Small possibility that camelization fails
+          fields.gsub(/:/, '').gsub(/[\w_]+/) { |str| ActiveSupport::Inflector.camelize(str, false) }
+        end
+      end
+    end
+  end
+end

data/lib/google/apis/core/base_service.rb

@@ -0,0 +1,317 @@
+# Copyright 2015 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'addressable/uri'
+require 'addressable/template'
+require 'google/apis/version'
+require 'google/apis/core/api_command'
+require 'google/apis/core/batch'
+require 'google/apis/core/upload'
+require 'google/apis/core/download'
+require 'google/apis/core/http_client_adapter'
+require 'google/apis/options'
+require 'googleauth'
+require 'hurley'
+require 'hurley/addressable'
+
+module Google
+  module Apis
+    module Core
+      # Base service for all APIs. Not to be used directly.
+      #
+      class BaseService
+        # Root URL (host/port) for the API
+        # @return [Addressable::URI]
+        attr_accessor :root_url
+
+        # Additional path prefix for all API methods
+        # @return [Addressable::URI]
+        attr_accessor :base_path
+
+        # Alternate path prefix for media uploads
+        # @return [Addressable::URI]
+        attr_accessor :upload_path
+
+        # Alternate path prefix for all batch methods
+        # @return [Addressable::URI]
+        attr_accessor :batch_path
+
+        # HTTP client
+        # @return [Hurley::Client]
+        attr_accessor :client
+
+        # General settings
+        # @return [Google::Apis::ClientOptions]
+        attr_accessor :client_options
+
+        # Default options for all requests
+        # @return [Google::Apis::RequestOptions]
+        attr_accessor :request_options
+
+        # @param [String,Addressable::URI] root_url
+        #   Root URL for the API
+        # @param [String,Addressable::URI] base_path
+        #   Additional path prefix for all API methods
+        # @api private
+        def initialize(root_url, base_path)
+          self.root_url = root_url
+          self.base_path = base_path
+          self.upload_path = "upload/#{base_path}"
+          self.batch_path = 'batch'
+          self.client_options = Google::Apis::ClientOptions.default.dup
+          self.request_options = Google::Apis::RequestOptions.default.dup
+        end
+
+        # @!attribute [rw] authorization
+        # @return [Signet::OAuth2::Client]
+        #  OAuth2 credentials
+        def authorization=(authorization)
+          request_options.authorization = authorization
+        end
+
+        def authorization
+          request_options.authorization
+        end
+
+        # TODO: with(options) method
+
+        # Perform a batch request. Calls made within the block are sent in a single network
+        # request to the server.
+        #
+        # @example
+        #   service.batch do |service|
+        #     service.get_item(id1) do |res, err|
+        #       # process response for 1st call
+        #     end
+        #     # ...
+        #     service.get_item(idN) do |res, err|
+        #       # process response for Nth call
+        #     end
+        #   end
+        #
+        # @param [Hash, Google::Apis::RequestOptions] options
+        #  Request-specific options
+        # @yield [self]
+        # @return [void]
+        def batch(options = nil)
+          batch_command = BatchCommand.new(:post, Addressable::URI.parse(root_url + batch_path))
+          batch_command.options = request_options.merge(options)
+          apply_command_defaults(batch_command)
+          begin
+            Thread.current[:google_api_batch] = batch_command
+            yield self
+          ensure
+            Thread.current[:google_api_batch] = nil
+          end
+          batch_command.execute(client)
+        end
+
+        # Perform a batch upload request. Calls made within the block are sent in a single network
+        # request to the server. Batch uploads are useful for uploading multiple small files. For larger
+        # files, use single requests which use a resumable upload protocol.
+        #
+        # @example
+        #   service.batch do |service|
+        #     service.insert_item(upload_source: 'file1.txt') do |res, err|
+        #       # process response for 1st call
+        #     end
+        #     # ...
+        #     service.insert_item(upload_source: 'fileN.txt') do |res, err|
+        #       # process response for Nth call
+        #     end
+        #   end
+        #
+        # @param [Hash, Google::Apis::RequestOptions] options
+        #  Request-specific options
+        # @yield [self]
+        # @return [void]
+        def batch_upload(options = nil)
+          batch_command = BatchUploadCommand.new(:put, Addressable::URI.parse(root_url + upload_path))
+          batch_command.options = request_options.merge(options)
+          apply_command_defaults(batch_command)
+          begin
+            Thread.current[:google_api_batch] = batch_command
+            yield self
+          ensure
+            Thread.current[:google_api_batch] = nil
+          end
+          batch_command.execute(client)
+        end
+
+        # Get the current HTTP client
+        # @return [Hurley::Client]
+        def client
+          @client ||= new_client
+        end
+
+
+        # Simple escape hatch for making API requests directly to a given
+        # URL. This is not intended to be used as a generic HTTP client
+        # and should be used only in cases where no service method exists
+        # (e.g. fetching an export link for a Google Drive file.)
+        #
+        # @param [Symbol] method
+        #   HTTP method as symbol (e.g. :get, :post, :put, ...)
+        # @param [String] url
+        #   URL to call
+        # @param [Hash<String,String>] params
+        #   Optional hash of query parameters
+        # @param [#read] body
+        #   Optional body for POST/PUT
+        # @param [IO, String] download_dest
+        #   IO stream or filename to receive content download
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [String] HTTP response body
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [String] HTTP response body
+        def http(method, url, params: nil, body: nil, download_dest: nil, options: nil, &block)
+          if download_dest
+            command = DownloadCommand.new(method, url, body: body)
+          else
+            command = HttpCommand.new(method, url, body: body)
+          end
+          command.options = request_options.merge(options)
+          apply_command_defaults(command)
+          command.query.merge(Hash(params))
+          execute_or_queue_command(command, &block)
+        end
+
+        protected
+
+        # Create a new upload command.
+        #
+        # @param [symbol] method
+        #   HTTP method for uploading (typically :put or :post)
+        # @param [String] path
+        #  Additional path to upload endpoint, appended to API base path
+        # @param [Hash, Google::Apis::RequestOptions] options
+        #  Request-specific options
+        # @return [Google::Apis::Core::UploadCommand]
+        def make_upload_command(method, path, options)
+          template = Addressable::Template.new(root_url + upload_path + path)
+          if batch?
+            command = MultipartUploadCommand.new(method, template)
+          else
+            command = ResumableUploadCommand.new(method, template)
+          end
+          command.options = request_options.merge(options)
+          apply_command_defaults(command)
+          command
+        end
+
+        # Create a new download command.
+        #
+        # @param [symbol] method
+        #   HTTP method for uploading (typically :get)
+        # @param [String] path
+        #  Additional path to download endpoint, appended to API base path
+        # @param [Hash, Google::Apis::RequestOptions] options
+        #  Request-specific options
+        # @return [Google::Apis::Core::DownloadCommand]
+        def make_download_command(method, path, options)
+          template = Addressable::Template.new(root_url + base_path + path)
+          command = DownloadCommand.new(method, template)
+          command.options = request_options.merge(options)
+          command.query['alt'] = 'media'
+          apply_command_defaults(command)
+          command
+        end
+
+        # Create a new command.
+        #
+        # @param [symbol] method
+        #   HTTP method (:get, :post, :delete, etc...)
+        # @param [String] path
+        #  Additional path, appended to API base path
+        # @param [Hash, Google::Apis::RequestOptions] options
+        #  Request-specific options
+        # @return [Google::Apis::Core::DownloadCommand]
+        def make_simple_command(method, path, options)
+          template = Addressable::Template.new(root_url + base_path + path)
+          command = ApiCommand.new(method, template)
+          command.options = request_options.merge(options)
+          apply_command_defaults(command)
+          command
+        end
+
+        # Execute the request. If a batch is in progress, the request is added to the batch instead.
+        #
+        # @param [Google::Apis::Core::HttpCommand] command
+        #   Command to execute
+        # @return [Object] response object if command executed and no callback supplied
+        # @yield [result, err] Result & error if block supplied
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def execute_or_queue_command(command, &callback)
+          batch_command = current_batch
+          if batch_command
+            batch_command.add(command, &callback)
+            nil
+          else
+            command.execute(client, &callback)
+          end
+        end
+
+        # Update commands with service-specific options. To be implemented by subclasses
+        # @param [Google::Apis::Core::HttpCommand] _command
+        def apply_command_defaults(_command)
+        end
+
+        private
+
+        # Get the current batch context
+        #
+        # @return [Google:Apis::Core::BatchRequest]
+        def current_batch
+          Thread.current[:google_api_batch]
+        end
+
+        # Check if a batch is in progress
+        # @return [Boolean]
+        def batch?
+          !current_batch.nil?
+        end
+
+        # Create a new HTTP client
+        # @return [Hurley::Client]
+        def new_client
+          client = Hurley::Client.new
+          client.connection = Google::Apis::Core::HttpClientAdapter.new unless client_options.use_net_http
+          client.request_options.timeout = request_options.timeout_sec
+          client.request_options.open_timeout = request_options.open_timeout_sec
+          client.request_options.proxy = client_options.proxy_url
+          client.request_options.query_class = Hurley::Query::Flat
+          client.ssl_options.ca_file = File.join(Google::Apis::ROOT, 'lib', 'cacerts.pem')
+          client.header[:user_agent] = user_agent
+          client
+        end
+
+        # Build the user agent header
+        # @return [String]
+        def user_agent
+          sprintf('%s/%s google-api-ruby-client/%s %s (gzip)',
+                  client_options.application_name,
+                  client_options.application_version,
+                  Google::Apis::VERSION,
+                  Google::Apis::OS_VERSION)
+        end
+      end
+    end
+  end
+end