:two_legged_oauth_1:oauth_1:oauth_2String representation of the service's state.
+ #
+ # @return [String] The service's state, as a String.
+ def inspect
+ sprintf(
+ "#<%s:%#0x ID:%s>", self.class.to_s, self.object_id, self.id
+ )
+ end
+
+ ##
+ # Marshalling support - serialize the API to a string (doc base + original
+ # discovery document).
+ def _dump(level)
+ MultiJson.dump([@document_base.to_s, @discovery_document])
+ end
+
+ ##
+ # Marshalling support - Restore an API instance from serialized form
+ def self._load(obj)
+ new(*MultiJson.load(obj))
+ end
+
+ end
+ end
+end
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/media.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/media.rb
new file mode 100644
index 000000000..ffa7e87c3
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/media.rb
@@ -0,0 +1,77 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'addressable/uri'
+require 'addressable/template'
+
+require 'google/api_client/errors'
+
+
+module Google
+ class APIClient
+ ##
+ # Media upload elements for discovered methods
+ class MediaUpload
+
+ ##
+ # Creates a description of a particular method.
+ #
+ # @param [Google::APIClient::API] api
+ # Base discovery document for the API
+ # @param [Addressable::URI] method_base
+ # The base URI for the service.
+ # @param [Hash] discovery_document
+ # The media upload section of the discovery document.
+ #
+ # @return [Google::APIClient::Method] The constructed method object.
+ def initialize(api, method_base, discovery_document)
+ @api = api
+ @method_base = method_base
+ @discovery_document = discovery_document
+ end
+
+ ##
+ # List of acceptable mime types
+ #
+ # @return [Array]
+ # List of acceptable mime types for uploaded content
+ def accepted_types
+ @discovery_document['accept']
+ end
+
+ ##
+ # Maximum size of an uplad
+ # TODO: Parse & convert to numeric value
+ #
+ # @return [String]
+ def max_size
+ @discovery_document['maxSize']
+ end
+
+ ##
+ # Returns the URI template for the method. A parameter list can be
+ # used to expand this into a URI.
+ #
+ # @return [Addressable::Template] The URI template.
+ def uri_template
+ return @uri_template ||= Addressable::Template.new(
+ @api.method_base.join(Addressable::URI.parse(@discovery_document['protocols']['simple']['path']))
+ )
+ end
+
+ end
+
+ end
+end
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/method.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/method.rb
new file mode 100644
index 000000000..79d1468ff
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/method.rb
@@ -0,0 +1,363 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'addressable/uri'
+require 'addressable/template'
+
+require 'google/api_client/errors'
+
+
+module Google
+ class APIClient
+ ##
+ # A method that has been described by a discovery document.
+ class Method
+
+ ##
+ # Creates a description of a particular method.
+ #
+ # @param [Google::APIClient::API] api
+ # The API this method belongs to.
+ # @param [Addressable::URI] method_base
+ # The base URI for the service.
+ # @param [String] method_name
+ # The identifier for the method.
+ # @param [Hash] discovery_document
+ # The section of the discovery document that applies to this method.
+ #
+ # @return [Google::APIClient::Method] The constructed method object.
+ def initialize(api, method_base, method_name, discovery_document)
+ @api = api
+ @method_base = method_base
+ @name = method_name
+ @discovery_document = discovery_document
+ end
+
+ # @return [String] unparsed discovery document for the method
+ attr_reader :discovery_document
+
+ ##
+ # Returns the API this method belongs to.
+ #
+ # @return [Google::APIClient::API] The API this method belongs to.
+ attr_reader :api
+
+ ##
+ # Returns the identifier for the method.
+ #
+ # @return [String] The method identifier.
+ attr_reader :name
+
+ ##
+ # Returns the base URI for the method.
+ #
+ # @return [Addressable::URI]
+ # The base URI that this method will be joined to.
+ attr_reader :method_base
+
+ ##
+ # Updates the method with the new base.
+ #
+ # @param [Addressable::URI, #to_str, String] new_method_base
+ # The new base URI to use for the method.
+ def method_base=(new_method_base)
+ @method_base = Addressable::URI.parse(new_method_base)
+ @uri_template = nil
+ end
+
+ ##
+ # Returns a human-readable description of the method.
+ #
+ # @return [Hash] The API description.
+ def description
+ return @discovery_document['description']
+ end
+
+ ##
+ # Returns the method ID.
+ #
+ # @return [String] The method identifier.
+ def id
+ return @discovery_document['id']
+ end
+
+ ##
+ # Returns the HTTP method or 'GET' if none is specified.
+ #
+ # @return [String] The HTTP method that will be used in the request.
+ def http_method
+ return @discovery_document['httpMethod'] || 'GET'
+ end
+
+ ##
+ # Returns the URI template for the method. A parameter list can be
+ # used to expand this into a URI.
+ #
+ # @return [Addressable::Template] The URI template.
+ def uri_template
+ return @uri_template ||= Addressable::Template.new(
+ self.method_base.join(Addressable::URI.parse(@discovery_document['path']))
+ )
+ end
+
+ ##
+ # Returns media upload information for this method, if supported
+ #
+ # @return [Google::APIClient::MediaUpload] Description of upload endpoints
+ def media_upload
+ if @discovery_document['mediaUpload']
+ return @media_upload ||= Google::APIClient::MediaUpload.new(self, self.method_base, @discovery_document['mediaUpload'])
+ else
+ return nil
+ end
+ end
+
+ ##
+ # Returns the Schema object for the method's request, if any.
+ #
+ # @return [Google::APIClient::Schema] The request schema.
+ def request_schema
+ if @discovery_document['request']
+ schema_name = @discovery_document['request']['$ref']
+ return @api.schemas[schema_name]
+ else
+ return nil
+ end
+ end
+
+ ##
+ # Returns the Schema object for the method's response, if any.
+ #
+ # @return [Google::APIClient::Schema] The response schema.
+ def response_schema
+ if @discovery_document['response']
+ schema_name = @discovery_document['response']['$ref']
+ return @api.schemas[schema_name]
+ else
+ return nil
+ end
+ end
+
+ ##
+ # Normalizes parameters, converting to the appropriate types.
+ #
+ # @param [Hash, Array] parameters
+ # The parameters to normalize.
+ #
+ # @return [Hash] The normalized parameters.
+ def normalize_parameters(parameters={})
+ # Convert keys to Strings when appropriate
+ if parameters.kind_of?(Hash) || parameters.kind_of?(Array)
+ # Returning an array since parameters can be repeated (ie, Adsense Management API)
+ parameters = parameters.inject([]) do |accu, (k, v)|
+ k = k.to_s if k.kind_of?(Symbol)
+ k = k.to_str if k.respond_to?(:to_str)
+ unless k.kind_of?(String)
+ raise TypeError, "Expected String, got #{k.class}."
+ end
+ accu << [k, v]
+ accu
+ end
+ else
+ raise TypeError,
+ "Expected Hash or Array, got #{parameters.class}."
+ end
+ return parameters
+ end
+
+ ##
+ # Expands the method's URI template using a parameter list.
+ #
+ # @api private
+ # @param [Hash, Array] parameters
+ # The parameter list to use.
+ #
+ # @return [Addressable::URI] The URI after expansion.
+ def generate_uri(parameters={})
+ parameters = self.normalize_parameters(parameters)
+
+ self.validate_parameters(parameters)
+ template_variables = self.uri_template.variables
+ upload_type = parameters.assoc('uploadType') || parameters.assoc('upload_type')
+ if upload_type
+ unless self.media_upload
+ raise ArgumentException, "Media upload not supported for this method"
+ end
+ case upload_type.last
+ when 'media', 'multipart', 'resumable'
+ uri = self.media_upload.uri_template.expand(parameters)
+ else
+ raise ArgumentException, "Invalid uploadType '#{upload_type}'"
+ end
+ else
+ uri = self.uri_template.expand(parameters)
+ end
+ query_parameters = parameters.reject do |k, v|
+ template_variables.include?(k)
+ end
+ # encode all non-template parameters
+ params = ""
+ unless query_parameters.empty?
+ params = "?" + Addressable::URI.form_encode(query_parameters.sort)
+ end
+ # Normalization is necessary because of undesirable percent-escaping
+ # during URI template expansion
+ return uri.normalize + params
+ end
+
+ ##
+ # Generates an HTTP request for this method.
+ #
+ # @api private
+ # @param [Hash, Array] parameters
+ # The parameters to send.
+ # @param [String, StringIO] body The body for the HTTP request.
+ # @param [Hash, Array] headers The HTTP headers for the request.
+ # @option options [Faraday::Connection] :connection
+ # The HTTP connection to use.
+ #
+ # @return [Array] The generated HTTP request.
+ def generate_request(parameters={}, body='', headers={}, options={})
+ if !headers.kind_of?(Array) && !headers.kind_of?(Hash)
+ raise TypeError, "Expected Hash or Array, got #{headers.class}."
+ end
+ method = self.http_method.to_s.downcase.to_sym
+ uri = self.generate_uri(parameters)
+ headers = Faraday::Utils::Headers.new(headers)
+ return [method, uri, headers, body]
+ end
+
+
+ ##
+ # Returns a Hash of the parameter descriptions for
+ # this method.
+ #
+ # @return [Hash] The parameter descriptions.
+ def parameter_descriptions
+ @parameter_descriptions ||= (
+ @discovery_document['parameters'] || {}
+ ).inject({}) { |h,(k,v)| h[k]=v; h }
+ end
+
+ ##
+ # Returns an Array of the parameters for this method.
+ #
+ # @return [Array] The parameters.
+ def parameters
+ @parameters ||= ((
+ @discovery_document['parameters'] || {}
+ ).inject({}) { |h,(k,v)| h[k]=v; h }).keys
+ end
+
+ ##
+ # Returns an Array of the required parameters for this
+ # method.
+ #
+ # @return [Array] The required parameters.
+ #
+ # @example
+ # # A list of all required parameters.
+ # method.required_parameters
+ def required_parameters
+ @required_parameters ||= ((self.parameter_descriptions.select do |k, v|
+ v['required']
+ end).inject({}) { |h,(k,v)| h[k]=v; h }).keys
+ end
+
+ ##
+ # Returns an Array of the optional parameters for this
+ # method.
+ #
+ # @return [Array] The optional parameters.
+ #
+ # @example
+ # # A list of all optional parameters.
+ # method.optional_parameters
+ def optional_parameters
+ @optional_parameters ||= ((self.parameter_descriptions.reject do |k, v|
+ v['required']
+ end).inject({}) { |h,(k,v)| h[k]=v; h }).keys
+ end
+
+ ##
+ # Verifies that the parameters are valid for this method. Raises an
+ # exception if validation fails.
+ #
+ # @api private
+ # @param [Hash, Array] parameters
+ # The parameters to verify.
+ #
+ # @return [NilClass] nil if validation passes.
+ def validate_parameters(parameters={})
+ parameters = self.normalize_parameters(parameters)
+ required_variables = ((self.parameter_descriptions.select do |k, v|
+ v['required']
+ end).inject({}) { |h,(k,v)| h[k]=v; h }).keys
+ missing_variables = required_variables - parameters.map { |(k, _)| k }
+ if missing_variables.size > 0
+ raise ArgumentError,
+ "Missing required parameters: #{missing_variables.join(', ')}."
+ end
+ parameters.each do |k, v|
+ # Handle repeated parameters.
+ if self.parameter_descriptions[k] &&
+ self.parameter_descriptions[k]['repeated'] &&
+ v.kind_of?(Array)
+ # If this is a repeated parameter and we've got an array as a
+ # value, just provide the whole array to the loop below.
+ items = v
+ else
+ # If this is not a repeated parameter, or if it is but we're
+ # being given a single value, wrap the value in an array, so that
+ # the loop below still works for the single element.
+ items = [v]
+ end
+
+ items.each do |item|
+ if self.parameter_descriptions[k]
+ enum = self.parameter_descriptions[k]['enum']
+ if enum && !enum.include?(item)
+ raise ArgumentError,
+ "Parameter '#{k}' has an invalid value: #{item}. " +
+ "Must be one of #{enum.inspect}."
+ end
+ pattern = self.parameter_descriptions[k]['pattern']
+ if pattern
+ regexp = Regexp.new("^#{pattern}$")
+ if item !~ regexp
+ raise ArgumentError,
+ "Parameter '#{k}' has an invalid value: #{item}. " +
+ "Must match: /^#{pattern}$/."
+ end
+ end
+ end
+ end
+ end
+ return nil
+ end
+
+ ##
+ # Returns a String representation of the method's state.
+ #
+ # @return [String] The method's state, as a String.
+ def inspect
+ sprintf(
+ "#<%s:%#0x ID:%s>",
+ self.class.to_s, self.object_id, self.id
+ )
+ end
+ end
+ end
+end
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/resource.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/resource.rb
new file mode 100644
index 000000000..f6493ff40
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/resource.rb
@@ -0,0 +1,156 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'addressable/uri'
+
+require 'google/inflection'
+require 'google/api_client/discovery/method'
+
+
+module Google
+ class APIClient
+ ##
+ # A resource that has been described by a discovery document.
+ class Resource
+
+ ##
+ # Creates a description of a particular version of a resource.
+ #
+ # @param [Google::APIClient::API] api
+ # The API this resource belongs to.
+ # @param [Addressable::URI] method_base
+ # The base URI for the service.
+ # @param [String] resource_name
+ # The identifier for the resource.
+ # @param [Hash] discovery_document
+ # The section of the discovery document that applies to this resource.
+ #
+ # @return [Google::APIClient::Resource] The constructed resource object.
+ def initialize(api, method_base, resource_name, discovery_document)
+ @api = api
+ @method_base = method_base
+ @name = resource_name
+ @discovery_document = discovery_document
+ metaclass = (class <String.
+ def inspect
+ sprintf(
+ "#<%s:%#0x NAME:%s>", self.class.to_s, self.object_id, self.name
+ )
+ end
+ end
+ end
+end
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/schema.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/schema.rb
new file mode 100644
index 000000000..34755190f
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/discovery/schema.rb
@@ -0,0 +1,121 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'time'
+require 'multi_json'
+require 'compat/multi_json'
+require 'base64'
+require 'autoparse'
+require 'addressable/uri'
+require 'addressable/template'
+
+require 'google/inflection'
+require 'google/api_client/errors'
+
+
+module Google
+ class APIClient
+ ##
+ # @api private
+ module Schema
+ def self.parse(api, schema_data)
+ # This method is super-long, but hard to break up due to the
+ # unavoidable dependence on closures and execution context.
+ schema_name = schema_data['id']
+
+ # Due to an oversight, schema IDs may not be URI references.
+ # TODO(bobaman): Remove this code once this has been resolved.
+ schema_uri = (
+ api.document_base +
+ (schema_name[0..0] != '#' ? '#' + schema_name : schema_name)
+ )
+ # puts schema_uri
+
+ # Due to an oversight, schema IDs may not be URI references.
+ # TODO(bobaman): Remove this whole lambda once this has been resolved.
+ reformat_references = lambda do |data|
+ # This code is not particularly efficient due to recursive traversal
+ # and excess object creation, but this hopefully shouldn't be an
+ # issue since it should only be called only once per schema per
+ # process.
+ if data.kind_of?(Hash) &&
+ data['$ref'] && !data['$ref'].kind_of?(Hash)
+ if data['$ref'].respond_to?(:to_str)
+ reference = data['$ref'].to_str
+ else
+ raise TypeError, "Expected String, got #{data['$ref'].class}"
+ end
+ reference = '#' + reference if reference[0..0] != '#'
+ data.merge({
+ '$ref' => reference
+ })
+ elsif data.kind_of?(Hash)
+ data.inject({}) do |accu, (key, value)|
+ if value.kind_of?(Hash)
+ accu[key] = reformat_references.call(value)
+ else
+ accu[key] = value
+ end
+ accu
+ end
+ else
+ data
+ end
+ end
+ schema_data = reformat_references.call(schema_data)
+ # puts schema_data.inspect
+
+ if schema_name
+ api_name_string =
+ Google::INFLECTOR.camelize(api.name)
+ api_version_string =
+ Google::INFLECTOR.camelize(api.version).gsub('.', '_')
+ # This is for compatibility with Ruby 1.8.7.
+ # TODO(bobaman) Remove this when we eventually stop supporting 1.8.7.
+ args = []
+ args << false if Class.method(:const_defined?).arity != 1
+ if Google::APIClient::Schema.const_defined?(api_name_string, *args)
+ api_name = Google::APIClient::Schema.const_get(
+ api_name_string, *args
+ )
+ else
+ api_name = Google::APIClient::Schema.const_set(
+ api_name_string, Module.new
+ )
+ end
+ if api_name.const_defined?(api_version_string, *args)
+ api_version = api_name.const_get(api_version_string, *args)
+ else
+ api_version = api_name.const_set(api_version_string, Module.new)
+ end
+ if api_version.const_defined?(schema_name, *args)
+ schema_class = api_version.const_get(schema_name, *args)
+ end
+ end
+
+ # It's possible the schema has already been defined. If so, don't
+ # redefine it. This means that reloading a schema which has already
+ # been loaded into memory is not possible.
+ unless schema_class
+ schema_class = AutoParse.generate(schema_data, :uri => schema_uri)
+ if schema_name
+ api_version.const_set(schema_name, schema_class)
+ end
+ end
+ return schema_class
+ end
+ end
+ end
+end
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/environment.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/environment.rb
new file mode 100644
index 000000000..50c84fe5c
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/environment.rb
@@ -0,0 +1,42 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+ class APIClient
+ module ENV
+ OS_VERSION = begin
+ if RUBY_PLATFORM =~ /mswin|win32|mingw|bccwin|cygwin/
+ # TODO(bobaman)
+ # Confirm that all of these Windows environments actually have access
+ # to the `ver` command.
+ `ver`.sub(/\s*\[Version\s*/, '/').sub(']', '').strip
+ elsif RUBY_PLATFORM =~ /darwin/i
+ "Mac OS X/#{`sw_vers -productVersion`}"
+ elsif RUBY_PLATFORM == 'java'
+ # Get the information from java system properties to avoid spawning a
+ # sub-process, which is not friendly in some contexts (web servers).
+ require 'java'
+ name = java.lang.System.getProperty('os.name')
+ version = java.lang.System.getProperty('os.version')
+ "#{name}/#{version}"
+ else
+ `uname -sr`.sub(' ', '/')
+ end
+ rescue Exception
+ RUBY_PLATFORM
+ end
+ end
+ end
+end
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/errors.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/errors.rb
new file mode 100644
index 000000000..f12ad6daa
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/errors.rb
@@ -0,0 +1,60 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+ class APIClient
+ ##
+ # An error which is raised when there is an unexpected response or other
+ # transport error that prevents an operation from succeeding.
+ class TransmissionError < StandardError
+ attr_reader :result
+ def initialize(message = nil, result = nil)
+ super(message)
+ @result = result
+ end
+ end
+
+ ##
+ # An exception that is raised if a redirect is required
+ #
+ class RedirectError < TransmissionError
+ end
+
+ ##
+ # An exception that is raised if a method is called with missing or
+ # invalid parameter values.
+ class ValidationError < StandardError
+ end
+
+ ##
+ # A 4xx class HTTP error occurred.
+ class ClientError < TransmissionError
+ end
+
+ ##
+ # A 5xx class HTTP error occurred.
+ class ServerError < TransmissionError
+ end
+
+ ##
+ # An exception that is raised if an ID token could not be validated.
+ class InvalidIDTokenError < StandardError
+ end
+
+ # Error class for problems in batch requests.
+ class BatchError < StandardError
+ end
+ end
+end
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/gzip.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/gzip.rb
new file mode 100644
index 000000000..42fabbbdb
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/gzip.rb
@@ -0,0 +1,28 @@
+require 'faraday'
+require 'zlib'
+
+module Google
+ class APIClient
+ class Gzip < Faraday::Response::Middleware
+ include Google::APIClient::Logging
+
+ def on_complete(env)
+ encoding = env[:response_headers]['content-encoding'].to_s.downcase
+ case encoding
+ when 'gzip'
+ logger.debug { "Decompressing gzip encoded response (#{env[:body].length} bytes)" }
+ env[:body] = Zlib::GzipReader.new(StringIO.new(env[:body])).read
+ env[:response_headers].delete('content-encoding')
+ logger.debug { "Decompressed (#{env[:body].length} bytes)" }
+ when 'deflate'
+ logger.debug{ "Decompressing deflate encoded response (#{env[:body].length} bytes)" }
+ env[:body] = Zlib::Inflate.inflate(env[:body])
+ env[:response_headers].delete('content-encoding')
+ logger.debug { "Decompressed (#{env[:body].length} bytes)" }
+ end
+ end
+ end
+ end
+end
+
+Faraday::Response.register_middleware :gzip => Google::APIClient::Gzip
\ No newline at end of file
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/logging.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/logging.rb
new file mode 100644
index 000000000..09a075b5c
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/logging.rb
@@ -0,0 +1,32 @@
+require 'logger'
+
+module Google
+ class APIClient
+
+ class << self
+ ##
+ # Logger for the API client
+ #
+ # @return [Logger] logger instance.
+ attr_accessor :logger
+ end
+
+ self.logger = Logger.new(STDOUT)
+ self.logger.level = Logger::WARN
+
+ ##
+ # Module to make accessing the logger simpler
+ module Logging
+ ##
+ # Logger for the API client
+ #
+ # @return [Logger] logger instance.
+ def logger
+ Google::APIClient.logger
+ end
+ end
+
+ end
+
+
+end
\ No newline at end of file
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/media.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/media.rb
new file mode 100644
index 000000000..5066bcebd
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/media.rb
@@ -0,0 +1,259 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require 'google/api_client/reference'
+
+module Google
+ class APIClient
+ ##
+ # Uploadable media support. Holds an IO stream & content type.
+ #
+ # @see Faraday::UploadIO
+ # @example
+ # media = Google::APIClient::UploadIO.new('mymovie.m4v', 'video/mp4')
+ class UploadIO < Faraday::UploadIO
+
+ # @return [Fixnum] Size of chunks to upload. Default is nil, meaning upload the entire file in a single request
+ attr_accessor :chunk_size
+
+ ##
+ # Get the length of the stream
+ #
+ # @return [Fixnum]
+ # Length of stream, in bytes
+ def length
+ io.respond_to?(:length) ? io.length : File.size(local_path)
+ end
+ end
+
+ ##
+ # Wraps an input stream and limits data to a given range
+ #
+ # @example
+ # chunk = Google::APIClient::RangedIO.new(io, 0, 1000)
+ class RangedIO
+ ##
+ # Bind an input stream to a specific range.
+ #
+ # @param [IO] io
+ # Source input stream
+ # @param [Fixnum] offset
+ # Starting offset of the range
+ # @param [Fixnum] length
+ # Length of range
+ def initialize(io, offset, length)
+ @io = io
+ @offset = offset
+ @length = length
+ self.rewind
+ end
+
+ ##
+ # @see IO#read
+ def read(amount = nil, buf = nil)
+ buffer = buf || ''
+ if amount.nil?
+ size = @length - @pos
+ done = ''
+ elsif amount == 0
+ size = 0
+ done = ''
+ else
+ size = [@length - @pos, amount].min
+ done = nil
+ end
+
+ if size > 0
+ result = @io.read(size)
+ result.force_encoding("BINARY") if result.respond_to?(:force_encoding)
+ buffer << result if result
+ @pos = @pos + size
+ end
+
+ if buffer.length > 0
+ buffer
+ else
+ done
+ end
+ end
+
+ ##
+ # @see IO#rewind
+ def rewind
+ self.pos = 0
+ end
+
+ ##
+ # @see IO#pos
+ def pos
+ @pos
+ end
+
+ ##
+ # @see IO#pos=
+ def pos=(pos)
+ @pos = pos
+ @io.pos = @offset + pos
+ end
+ end
+
+ ##
+ # Resumable uploader.
+ #
+ class ResumableUpload < Request
+ # @return [Fixnum] Max bytes to send in a single request
+ attr_accessor :chunk_size
+
+ ##
+ # Creates a new uploader.
+ #
+ # @param [Hash] options
+ # Request options
+ def initialize(options={})
+ super options
+ self.uri = options[:uri]
+ self.http_method = :put
+ @offset = options[:offset] || 0
+ @complete = false
+ @expired = false
+ end
+
+ ##
+ # Sends all remaining chunks to the server
+ #
+ # @deprecated Pass the instance to {Google::APIClient#execute} instead
+ #
+ # @param [Google::APIClient] api_client
+ # API Client instance to use for sending
+ def send_all(api_client)
+ result = nil
+ until complete?
+ result = send_chunk(api_client)
+ break unless result.status == 308
+ end
+ return result
+ end
+
+
+ ##
+ # Sends the next chunk to the server
+ #
+ # @deprecated Pass the instance to {Google::APIClient#execute} instead
+ #
+ # @param [Google::APIClient] api_client
+ # API Client instance to use for sending
+ def send_chunk(api_client)
+ return api_client.execute(self)
+ end
+
+ ##
+ # Check if upload is complete
+ #
+ # @return [TrueClass, FalseClass]
+ # Whether or not the upload complete successfully
+ def complete?
+ return @complete
+ end
+
+ ##
+ # Check if the upload URL expired (upload not completed in alotted time.)
+ # Expired uploads must be restarted from the beginning
+ #
+ # @return [TrueClass, FalseClass]
+ # Whether or not the upload has expired and can not be resumed
+ def expired?
+ return @expired
+ end
+
+ ##
+ # Check if upload is resumable. That is, neither complete nor expired
+ #
+ # @return [TrueClass, FalseClass] True if upload can be resumed
+ def resumable?
+ return !(self.complete? or self.expired?)
+ end
+
+ ##
+ # Convert to an HTTP request. Returns components in order of method, URI,
+ # request headers, and body
+ #
+ # @api private
+ #
+ # @return [Array<(Symbol, Addressable::URI, Hash, [#read,#to_str])>]
+ def to_http_request
+ if @complete
+ raise Google::APIClient::ClientError, "Upload already complete"
+ elsif @offset.nil?
+ self.headers.update({
+ 'Content-Length' => "0",
+ 'Content-Range' => "bytes */#{media.length}" })
+ else
+ start_offset = @offset
+ remaining = self.media.length - start_offset
+ chunk_size = self.media.chunk_size || self.chunk_size || self.media.length
+ content_length = [remaining, chunk_size].min
+ chunk = RangedIO.new(self.media.io, start_offset, content_length)
+ end_offset = start_offset + content_length - 1
+ self.headers.update({
+ 'Content-Length' => "#{content_length}",
+ 'Content-Type' => self.media.content_type,
+ 'Content-Range' => "bytes #{start_offset}-#{end_offset}/#{media.length}" })
+ self.body = chunk
+ end
+ super
+ end
+
+ ##
+ # Check the result from the server, updating the offset and/or location
+ # if available.
+ #
+ # @api private
+ #
+ # @param [Faraday::Response] response
+ # HTTP response
+ #
+ # @return [Google::APIClient::Result]
+ # Processed API response
+ def process_http_response(response)
+ case response.status
+ when 200...299
+ @complete = true
+ when 308
+ range = response.headers['range']
+ if range
+ @offset = range.scan(/\d+/).collect{|x| Integer(x)}.last + 1
+ end
+ if response.headers['location']
+ self.uri = response.headers['location']
+ end
+ when 400...499
+ @expired = true
+ when 500...599
+ # Invalidate the offset to mark it needs to be queried on the
+ # next request
+ @offset = nil
+ end
+ return Google::APIClient::Result.new(self, response)
+ end
+
+ ##
+ # Hashified verison of the API request
+ #
+ # @return [Hash]
+ def to_hash
+ super.merge(:offset => @offset)
+ end
+
+ end
+ end
+end
\ No newline at end of file
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/railtie.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/railtie.rb
new file mode 100644
index 000000000..703921b7e
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/railtie.rb
@@ -0,0 +1,16 @@
+require 'google/api_client/logging'
+
+module Google
+ class APIClient
+
+ ##
+ # Optional support class for Rails. Currently replaces the built-in logger
+ # with Rails' application log.
+ #
+ class Railtie < Rails::Railtie
+ initializer 'google-api-client' do |app|
+ Google::APIClient.logger = Rails.logger
+ end
+ end
+ end
+end
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/reference.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/reference.rb
new file mode 100644
index 000000000..15b34250d
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/reference.rb
@@ -0,0 +1,27 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'google/api_client/request'
+
+module Google
+ class APIClient
+ ##
+ # Subclass of Request for backwards compatibility with pre-0.5.0 versions of the library
+ #
+ # @deprecated
+ # use {Google::APIClient::Request} instead
+ class Reference < Request
+ end
+ end
+end
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/request.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/request.rb
new file mode 100644
index 000000000..a8a83c4a4
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/request.rb
@@ -0,0 +1,351 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'faraday'
+require 'faraday/request/multipart'
+require 'multi_json'
+require 'compat/multi_json'
+require 'addressable/uri'
+require 'stringio'
+require 'google/api_client/discovery'
+require 'google/api_client/logging'
+
+module Google
+ class APIClient
+
+ ##
+ # Represents an API request.
+ class Request
+ include Google::APIClient::Logging
+
+ MULTIPART_BOUNDARY = "-----------RubyApiMultipartPost".freeze
+
+ # @return [Hash] Request parameters
+ attr_reader :parameters
+ # @return [Hash] Additional HTTP headers
+ attr_reader :headers
+ # @return [Google::APIClient::Method] API method to invoke
+ attr_reader :api_method
+ # @return [Google::APIClient::UploadIO] File to upload
+ attr_accessor :media
+ # @return [#generated_authenticated_request] User credentials
+ attr_accessor :authorization
+ # @return [TrueClass,FalseClass] True if request should include credentials
+ attr_accessor :authenticated
+ # @return [#read, #to_str] Request body
+ attr_accessor :body
+
+ ##
+ # Build a request
+ #
+ # @param [Hash] options
+ # @option options [Hash, Array] :parameters
+ # Request parameters for the API method.
+ # @option options [Google::APIClient::Method] :api_method
+ # API method to invoke. Either :api_method or :uri must be specified
+ # @option options [TrueClass, FalseClass] :authenticated
+ # True if request should include credentials. Implicitly true if
+ # unspecified and :authorization present
+ # @option options [#generate_signed_request] :authorization
+ # OAuth credentials
+ # @option options [Google::APIClient::UploadIO] :media
+ # File to upload, if media upload request
+ # @option options [#to_json, #to_hash] :body_object
+ # Main body of the API request. Typically hash or object that can
+ # be serialized to JSON
+ # @option options [#read, #to_str] :body
+ # Raw body to send in POST/PUT requests
+ # @option options [String, Addressable::URI] :uri
+ # URI to request. Either :api_method or :uri must be specified
+ # @option options [String, Symbol] :http_method
+ # HTTP method when requesting a URI
+ def initialize(options={})
+ @parameters = Faraday::Utils::ParamsHash.new
+ @headers = Faraday::Utils::Headers.new
+
+ self.parameters.merge!(options[:parameters]) unless options[:parameters].nil?
+ self.headers.merge!(options[:headers]) unless options[:headers].nil?
+ self.api_method = options[:api_method]
+ self.authenticated = options[:authenticated]
+ self.authorization = options[:authorization]
+
+ # These parameters are handled differently because they're not
+ # parameters to the API method, but rather to the API system.
+ self.parameters['key'] ||= options[:key] if options[:key]
+ self.parameters['userIp'] ||= options[:user_ip] if options[:user_ip]
+
+ if options[:media]
+ self.initialize_media_upload(options)
+ elsif options[:body]
+ self.body = options[:body]
+ elsif options[:body_object]
+ self.headers['Content-Type'] ||= 'application/json'
+ self.body = serialize_body(options[:body_object])
+ else
+ self.body = ''
+ end
+
+ unless self.api_method
+ self.http_method = options[:http_method] || 'GET'
+ self.uri = options[:uri]
+ end
+ end
+
+ # @!attribute [r] upload_type
+ # @return [String] protocol used for upload
+ def upload_type
+ return self.parameters['uploadType'] || self.parameters['upload_type']
+ end
+
+ # @!attribute http_method
+ # @return [Symbol] HTTP method if invoking a URI
+ def http_method
+ return @http_method ||= self.api_method.http_method.to_s.downcase.to_sym
+ end
+
+ def http_method=(new_http_method)
+ if new_http_method.kind_of?(Symbol)
+ @http_method = new_http_method.to_s.downcase.to_sym
+ elsif new_http_method.respond_to?(:to_str)
+ @http_method = new_http_method.to_s.downcase.to_sym
+ else
+ raise TypeError,
+ "Expected String or Symbol, got #{new_http_method.class}."
+ end
+ end
+
+ def api_method=(new_api_method)
+ if new_api_method.nil? || new_api_method.kind_of?(Google::APIClient::Method)
+ @api_method = new_api_method
+ else
+ raise TypeError,
+ "Expected Google::APIClient::Method, got #{new_api_method.class}."
+ end
+ end
+
+ # @!attribute uri
+ # @return [Addressable::URI] URI to send request
+ def uri
+ return @uri ||= self.api_method.generate_uri(self.parameters)
+ end
+
+ def uri=(new_uri)
+ @uri = Addressable::URI.parse(new_uri)
+ @parameters.update(@uri.query_values) unless @uri.query_values.nil?
+ end
+
+
+ # Transmits the request with the given connection
+ #
+ # @api private
+ #
+ # @param [Faraday::Connection] connection
+ # the connection to transmit with
+ # @param [TrueValue,FalseValue] is_retry
+ # True if request has been previous sent
+ #
+ # @return [Google::APIClient::Result]
+ # result of API request
+ def send(connection, is_retry = false)
+ self.body.rewind if is_retry && self.body.respond_to?(:rewind)
+ env = self.to_env(connection)
+ logger.debug { "#{self.class} Sending API request #{env[:method]} #{env[:url].to_s} #{env[:request_headers]}" }
+ http_response = connection.app.call(env)
+ result = self.process_http_response(http_response)
+
+ logger.debug { "#{self.class} Result: #{result.status} #{result.headers}" }
+
+ # Resumamble slightly different than other upload protocols in that it requires at least
+ # 2 requests.
+ if result.status == 200 && self.upload_type == 'resumable'
+ upload = result.resumable_upload
+ unless upload.complete?
+ logger.debug { "#{self.class} Sending upload body" }
+ result = upload.send(connection)
+ end
+ end
+ return result
+ end
+
+ # Convert to an HTTP request. Returns components in order of method, URI,
+ # request headers, and body
+ #
+ # @api private
+ #
+ # @return [Array<(Symbol, Addressable::URI, Hash, [#read,#to_str])>]
+ def to_http_request
+ request = (
+ if self.api_method
+ self.api_method.generate_request(self.parameters, self.body, self.headers)
+ elsif self.uri
+ unless self.parameters.empty?
+ self.uri.query = Addressable::URI.form_encode(self.parameters)
+ end
+ [self.http_method, self.uri.to_s, self.headers, self.body]
+ end)
+ return request
+ end
+
+ ##
+ # Hashified verison of the API request
+ #
+ # @return [Hash]
+ def to_hash
+ options = {}
+ if self.api_method
+ options[:api_method] = self.api_method
+ options[:parameters] = self.parameters
+ else
+ options[:http_method] = self.http_method
+ options[:uri] = self.uri
+ end
+ options[:headers] = self.headers
+ options[:body] = self.body
+ options[:media] = self.media
+ unless self.authorization.nil?
+ options[:authorization] = self.authorization
+ end
+ return options
+ end
+
+ ##
+ # Prepares the request for execution, building a hash of parts
+ # suitable for sending to Faraday::Connection.
+ #
+ # @api private
+ #
+ # @param [Faraday::Connection] connection
+ # Connection for building the request
+ #
+ # @return [Hash]
+ # Encoded request
+ def to_env(connection)
+ method, uri, headers, body = self.to_http_request
+ http_request = connection.build_request(method) do |req|
+ req.url(uri.to_s)
+ req.headers.update(headers)
+ req.body = body
+ end
+
+ if self.authorization.respond_to?(:generate_authenticated_request)
+ http_request = self.authorization.generate_authenticated_request(
+ :request => http_request,
+ :connection => connection
+ )
+ end
+
+ request_env = http_request.to_env(connection)
+ end
+
+ ##
+ # Convert HTTP response to an API Result
+ #
+ # @api private
+ #
+ # @param [Faraday::Response] response
+ # HTTP response
+ #
+ # @return [Google::APIClient::Result]
+ # Processed API response
+ def process_http_response(response)
+ Result.new(self, response)
+ end
+
+ protected
+
+ ##
+ # Adjust headers & body for media uploads
+ #
+ # @api private
+ #
+ # @param [Hash] options
+ # @option options [Hash, Array] :parameters
+ # Request parameters for the API method.
+ # @option options [Google::APIClient::UploadIO] :media
+ # File to upload, if media upload request
+ # @option options [#to_json, #to_hash] :body_object
+ # Main body of the API request. Typically hash or object that can
+ # be serialized to JSON
+ # @option options [#read, #to_str] :body
+ # Raw body to send in POST/PUT requests
+ def initialize_media_upload(options)
+ self.media = options[:media]
+ case self.upload_type
+ when "media"
+ if options[:body] || options[:body_object]
+ raise ArgumentError, "Can not specify body & body object for simple uploads"
+ end
+ self.headers['Content-Type'] ||= self.media.content_type
+ self.headers['Content-Length'] ||= self.media.length.to_s
+ self.body = self.media
+ when "multipart"
+ unless options[:body_object]
+ raise ArgumentError, "Multipart requested but no body object"
+ end
+ metadata = StringIO.new(serialize_body(options[:body_object]))
+ build_multipart([Faraday::UploadIO.new(metadata, 'application/json', 'file.json'), self.media])
+ when "resumable"
+ file_length = self.media.length
+ self.headers['X-Upload-Content-Type'] = self.media.content_type
+ self.headers['X-Upload-Content-Length'] = file_length.to_s
+ if options[:body_object]
+ self.headers['Content-Type'] ||= 'application/json'
+ self.body = serialize_body(options[:body_object])
+ else
+ self.body = ''
+ end
+ end
+ end
+
+ ##
+ # Assemble a multipart message from a set of parts
+ #
+ # @api private
+ #
+ # @param [Array<[#read,#to_str]>] parts
+ # Array of parts to encode.
+ # @param [String] mime_type
+ # MIME type of the message
+ # @param [String] boundary
+ # Boundary for separating each part of the message
+ def build_multipart(parts, mime_type = 'multipart/related', boundary = MULTIPART_BOUNDARY)
+ env = Faraday::Env.new
+ env.request = Faraday::RequestOptions.new
+ env.request.boundary = boundary
+ env.request_headers = {'Content-Type' => "#{mime_type};boundary=#{boundary}"}
+ multipart = Faraday::Request::Multipart.new
+ self.body = multipart.create_multipart(env, parts.map {|part| [nil, part]})
+ self.headers.update(env[:request_headers])
+ end
+
+ ##
+ # Serialize body object to JSON
+ #
+ # @api private
+ #
+ # @param [#to_json,#to_hash] body
+ # object to serialize
+ #
+ # @return [String]
+ # JSON
+ def serialize_body(body)
+ return body.to_json if body.respond_to?(:to_json)
+ return MultiJson.dump(body.to_hash) if body.respond_to?(:to_hash)
+ raise TypeError, 'Could not convert body object to JSON.' +
+ 'Must respond to :to_json or :to_hash.'
+ end
+
+ end
+ end
+end
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/result.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/result.rb
new file mode 100644
index 000000000..38d08594e
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/result.rb
@@ -0,0 +1,253 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+ class APIClient
+ ##
+ # This class wraps a result returned by an API call.
+ class Result
+ extend Forwardable
+
+ ##
+ # Init the result
+ #
+ # @param [Google::APIClient::Request] request
+ # The original request
+ # @param [Faraday::Response] response
+ # Raw HTTP Response
+ def initialize(request, response)
+ @request = request
+ @response = response
+ @media_upload = reference if reference.kind_of?(ResumableUpload)
+ end
+
+ # @return [Google::APIClient::Request] Original request object
+ attr_reader :request
+ # @return [Faraday::Response] HTTP response
+ attr_reader :response
+ # @!attribute [r] reference
+ # @return [Google::APIClient::Request] Original request object
+ # @deprecated See {#request}
+ alias_method :reference, :request # For compatibility with pre-beta clients
+
+ # @!attribute [r] status
+ # @return [Fixnum] HTTP status code
+ # @!attribute [r] headers
+ # @return [Hash] HTTP response headers
+ # @!attribute [r] body
+ # @return [String] HTTP response body
+ def_delegators :@response, :status, :headers, :body
+
+ # @!attribute [r] resumable_upload
+ # @return [Google::APIClient::ResumableUpload] For resuming media uploads
+ def resumable_upload
+ @media_upload ||= (
+ options = self.reference.to_hash.merge(
+ :uri => self.headers['location'],
+ :media => self.reference.media
+ )
+ Google::APIClient::ResumableUpload.new(options)
+ )
+ end
+
+ ##
+ # Get the content type of the response
+ # @!attribute [r] media_type
+ # @return [String]
+ # Value of content-type header
+ def media_type
+ _, content_type = self.headers.detect do |h, v|
+ h.downcase == 'Content-Type'.downcase
+ end
+ if content_type
+ return content_type[/^([^;]*);?.*$/, 1].strip.downcase
+ else
+ return nil
+ end
+ end
+
+ ##
+ # Check if request failed
+ #
+ # @!attribute [r] error?
+ # @return [TrueClass, FalseClass]
+ # true if result of operation is an error
+ def error?
+ return self.response.status >= 400
+ end
+
+ ##
+ # Check if request was successful
+ #
+ # @!attribute [r] success?
+ # @return [TrueClass, FalseClass]
+ # true if result of operation was successful
+ def success?
+ return !self.error?
+ end
+
+ ##
+ # Extracts error messages from the response body
+ #
+ # @!attribute [r] error_message
+ # @return [String]
+ # error message, if available
+ def error_message
+ if self.data?
+ if self.data.respond_to?(:error) &&
+ self.data.error.respond_to?(:message)
+ # You're going to get a terrible error message if the response isn't
+ # parsed successfully as an error.
+ return self.data.error.message
+ elsif self.data['error'] && self.data['error']['message']
+ return self.data['error']['message']
+ end
+ end
+ return self.body
+ end
+
+ ##
+ # Check for parsable data in response
+ #
+ # @!attribute [r] data?
+ # @return [TrueClass, FalseClass]
+ # true if body can be parsed
+ def data?
+ !(self.body.nil? || self.body.empty? || self.media_type != 'application/json')
+ end
+
+ ##
+ # Return parsed version of the response body.
+ #
+ # @!attribute [r] data
+ # @return [Object, Hash, String]
+ # Object if body parsable from API schema, Hash if JSON, raw body if unable to parse
+ def data
+ return @data ||= (begin
+ if self.data?
+ media_type = self.media_type
+ data = self.body
+ case media_type
+ when 'application/json'
+ data = MultiJson.load(data)
+ # Strip data wrapper, if present
+ data = data['data'] if data.has_key?('data')
+ else
+ raise ArgumentError,
+ "Content-Type not supported for parsing: #{media_type}"
+ end
+ if @request.api_method && @request.api_method.response_schema
+ # Automatically parse using the schema designated for the
+ # response of this API method.
+ data = @request.api_method.response_schema.new(data)
+ data
+ else
+ # Otherwise, return the raw unparsed value.
+ # This value must be indexable like a Hash.
+ data
+ end
+ end
+ end)
+ end
+
+ ##
+ # Get the token used for requesting the next page of data
+ #
+ # @!attribute [r] next_page_token
+ # @return [String]
+ # next page token
+ def next_page_token
+ if self.data.respond_to?(:next_page_token)
+ return self.data.next_page_token
+ elsif self.data.respond_to?(:[])
+ return self.data["nextPageToken"]
+ else
+ raise TypeError, "Data object did not respond to #next_page_token."
+ end
+ end
+
+ ##
+ # Build a request for fetching the next page of data
+ #
+ # @return [Google::APIClient::Request]
+ # API request for retrieving next page
+ def next_page
+ merged_parameters = Hash[self.reference.parameters].merge({
+ self.page_token_param => self.next_page_token
+ })
+ # Because Requests can be coerced to Hashes, we can merge them,
+ # preserving all context except the API method parameters that we're
+ # using for pagination.
+ return Google::APIClient::Request.new(
+ Hash[self.reference].merge(:parameters => merged_parameters)
+ )
+ end
+
+ ##
+ # Get the token used for requesting the previous page of data
+ #
+ # @!attribute [r] prev_page_token
+ # @return [String]
+ # previous page token
+ def prev_page_token
+ if self.data.respond_to?(:prev_page_token)
+ return self.data.prev_page_token
+ elsif self.data.respond_to?(:[])
+ return self.data["prevPageToken"]
+ else
+ raise TypeError, "Data object did not respond to #next_page_token."
+ end
+ end
+
+ ##
+ # Build a request for fetching the previous page of data
+ #
+ # @return [Google::APIClient::Request]
+ # API request for retrieving previous page
+ def prev_page
+ merged_parameters = Hash[self.reference.parameters].merge({
+ self.page_token_param => self.prev_page_token
+ })
+ # Because Requests can be coerced to Hashes, we can merge them,
+ # preserving all context except the API method parameters that we're
+ # using for pagination.
+ return Google::APIClient::Request.new(
+ Hash[self.reference].merge(:parameters => merged_parameters)
+ )
+ end
+
+ ##
+ # Pagination scheme used by this request/response
+ #
+ # @!attribute [r] pagination_type
+ # @return [Symbol]
+ # currently always :token
+ def pagination_type
+ return :token
+ end
+
+ ##
+ # Name of the field that contains the pagination token
+ #
+ # @!attribute [r] page_token_param
+ # @return [String]
+ # currently always 'pageToken'
+ def page_token_param
+ return "pageToken"
+ end
+
+ end
+ end
+end
diff --git a/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/service.rb b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/service.rb
new file mode 100755
index 000000000..451266fe5
--- /dev/null
+++ b/gems/rails6.1/google-api-client-0.7.1/lib/google/api_client/service.rb
@@ -0,0 +1,233 @@
+# Copyright 2013 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'google/api_client'
+require 'google/api_client/service/stub_generator'
+require 'google/api_client/service/resource'
+require 'google/api_client/service/request'
+require 'google/api_client/service/result'
+require 'google/api_client/service/batch'
+require 'google/api_client/service/simple_file_store'
+
+module Google
+ class APIClient
+
+ ##
+ # Experimental new programming interface at the API level.
+ # Hides Google::APIClient. Designed to be easier to use, with less code.
+ #
+ # @example
+ # calendar = Google::APIClient::Service.new('calendar', 'v3')
+ # result = calendar.events.list('calendarId' => 'primary').execute()
+ class Service
+ include Google::APIClient::Service::StubGenerator
+ extend Forwardable
+
+ DEFAULT_CACHE_FILE = 'discovery.cache'
+
+ # Cache for discovered APIs.
+ @@discovered = {}
+
+ ##
+ # Creates a new Service.
+ #
+ # @param [String, Symbol] api_name
+ # The name of the API this service will access.
+ # @param [String, Symbol] api_version
+ # The version of the API this service will access.
+ # @param [Hash] options
+ # The configuration parameters for the service.
+ # @option options [Symbol, #generate_authenticated_request] :authorization
+ # (:oauth_1)
+ # The authorization mechanism used by the client. The following
+ # mechanisms are supported out-of-the-box:
+ # :two_legged_oauth_1:oauth_1:oauth_2