google-api-client 0.52.0 → 0.53.0

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

@@ -1,153 +0,0 @@
-# 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 'representable/json'
-require 'representable/json/hash'
-require 'base64'
-require 'date'
-
-module Google
-  module Apis
-    module Core
-      # Support for serializing hashes + property value/nil/unset tracking
-      # To be included in representers as a feature.
-      # @private
-      module JsonRepresentationSupport
-        def self.included(base)
-          base.extend(JsonSupport)
-        end
-
-        # @private
-        module JsonSupport
-          # Returns a customized getter function for Representable. Allows
-          # indifferent hash/attribute access.
-          #
-          # @param [String] name Property name
-          # @return [Proc]
-          def getter_fn(name)
-            ivar_name = "@#{name}".to_sym
-            lambda do |_|
-              if respond_to?(:fetch)
-                fetch(name, instance_variable_get(ivar_name))
-              else
-                instance_variable_get(ivar_name)
-              end
-            end
-          end
-
-          # Returns a customized function for Representable that checks whether or not
-          # an attribute should be serialized. Allows proper patch semantics by distinguishing
-          # between nil & unset values
-          #
-          # @param [String] name Property name
-          # @return [Proc]
-          def if_fn(name)
-            ivar_name = "@#{name}".to_sym
-            lambda do |opts|
-              if opts[:user_options] && opts[:user_options][:skip_undefined]
-                if respond_to?(:key?)
-                  self.key?(name) || instance_variable_defined?(ivar_name)
-                else
-                  instance_variable_defined?(ivar_name)
-                end
-              else
-                true
-              end
-            end
-          end
-
-          def set_default_options(name, options)
-            if options[:base64]
-              options[:render_filter] = ->(value, _doc, *_args) { value.nil? ? nil : Base64.urlsafe_encode64(value) }
-              options[:parse_filter] = ->(fragment, _doc, *_args) { Base64.urlsafe_decode64(fragment) }
-            end
-            if options[:numeric_string]
-              options[:render_filter] = ->(value, _doc, *_args) { value.nil? ? nil : value.to_s}
-              options[:parse_filter] = ->(fragment, _doc, *_args) { fragment.to_i }
-            end
-            if options[:type] == DateTime
-              options[:render_filter] = ->(value, _doc, *_args) { value.nil? ? nil : value.is_a?(DateTime) ? value.rfc3339(3) : value.to_s }
-              options[:parse_filter] = ->(fragment, _doc, *_args) { DateTime.parse(fragment) }
-            end
-            if options[:type] == Date
-              options[:render_filter] = ->(value, _doc, *_args) { value.nil? ? nil : value.to_s}
-              options[:parse_filter] = ->(fragment, _doc, *_args) { Date.parse(fragment) }
-            end
-
-            options[:render_nil] = true
-            options[:getter] = getter_fn(name)
-            options[:if] = if_fn(name)
-          end
-
-          # Define a single value property
-          #
-          # @param [String] name
-          #  Property name
-          # @param [Hash] options
-          def property(name, options = {})
-            set_default_options(name, options)
-            super(name, options)
-          end
-
-          # Define a collection property
-          #
-          # @param [String] name
-          #  Property name
-          # @param [Hash] options
-          def collection(name, options = {})
-            set_default_options(name, options)
-            super(name, options)
-          end
-
-          # Define a hash property
-          #
-          # @param [String] name
-          #  Property name
-          # @param [Hash] options
-          def hash(name = nil, options = nil)
-            return super() unless name # Allow Object.hash
-            set_default_options(name, options)
-            super(name, options)
-          end
-        end
-      end
-
-      # Base decorator for JSON representers
-      #
-      # @see https://github.com/apotonick/representable
-      class JsonRepresentation < Representable::Decorator
-        include Representable::JSON
-        feature JsonRepresentationSupport
-      end
-
-      module JsonObjectSupport
-        def self.included(base)
-          base.extend(ClassMethods)
-        end
-
-        module ClassMethods
-          def from_json(json)
-            representation = self.const_get(:Representation)
-            representation.new(self.new).from_json(json, unwrap: self)
-          end
-        end
-
-        def to_json(*a)
-          representation = self.class.const_get(:Representation)
-          representation.new(self).to_hash(user_options: { skip_undefined: true }).to_json(*a)
-        end
-      end
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-# 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.
-
-
-module Google
-  module Apis
-    module Core
-      # Part of a multipart request for holding JSON data
-      #
-      # @private
-      class JsonPart
-
-        # @param [String] value
-        #   JSON content
-        # @param [Hash] header
-        #   Additional headers
-        def initialize(value, header = {})
-          @value = value
-          @header = header
-        end
-
-        def to_io(boundary)
-          part = ''
-          part << "--#{boundary}\r\n"
-          part << "Content-Type: application/json\r\n"
-          @header.each do |(k, v)|
-            part << "#{k}: #{v}\r\n"
-          end
-          part << "\r\n"
-          part << "#{@value}\r\n"
-          StringIO.new(part)
-        end
-
-      end
-
-      # Part of a multipart request for holding arbitrary content.
-      #
-      # @private
-      class FilePart
-        # @param [IO] io
-        #   IO stream
-        # @param [Hash] header
-        #   Additional headers
-        def initialize(io, header = {})
-          @io = io
-          @header = header
-          @length = io.respond_to?(:size) ? io.size : nil
-        end
-
-        def to_io(boundary)
-          head = ''
-          head << "--#{boundary}\r\n"
-          @header.each do |(k, v)|
-            head << "#{k}: #{v}\r\n"
-          end
-          head << "Content-Length: #{@length}\r\n" unless @length.nil?
-          head << "Content-Transfer-Encoding: binary\r\n"
-          head << "\r\n"
-          Google::Apis::Core::CompositeIO.new(StringIO.new(head), @io, StringIO.new("\r\n"))
-        end
-      end
-
-      # Helper for building multipart requests
-      class Multipart
-        MULTIPART_RELATED = 'multipart/related'
-
-        # @return [String]
-        #  Content type header
-        attr_reader :content_type
-
-        # @param [String] content_type
-        #  Content type for the multipart request
-        # @param [String] boundary
-        #  Part delimiter
-
-        def initialize(content_type: MULTIPART_RELATED, boundary: nil)
-          @parts = []
-          @boundary = boundary || Digest::SHA1.hexdigest(SecureRandom.random_bytes(8))
-          @content_type = "#{content_type}; boundary=#{@boundary}"
-        end
-
-        # Append JSON data part
-        #
-        # @param [String] body
-        #   JSON text
-        # @param [String] content_id
-        #   Optional unique ID of this part
-        # @return [self]
-        def add_json(body, content_id: nil)
-          header = {}
-          header['Content-ID'] = content_id unless content_id.nil?
-          @parts << Google::Apis::Core::JsonPart.new(body, header).to_io(@boundary)
-          self
-        end
-
-        # Append arbitrary data as a part
-        #
-        # @param [IO] upload_io
-        #   IO stream
-        # @param [String] content_id
-        #   Optional unique ID of this part
-        # @return [self]
-        def add_upload(upload_io, content_type: nil, content_id: nil)
-          header = {
-              'Content-Type' => content_type || 'application/octet-stream'
-          }
-          header['Content-Id'] = content_id unless content_id.nil?
-          @parts << Google::Apis::Core::FilePart.new(upload_io,
-                                                     header).to_io(@boundary)
-          self
-        end
-
-        # Assemble the multipart requests
-        #
-        # @return [IO]
-        #  IO stream
-        def assemble
-          @parts <<  StringIO.new("--#{@boundary}--\r\n\r\n")
-          Google::Apis::Core::CompositeIO.new(*@parts)
-        end
-      end
-    end
-  end
-end

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

@@ -1,273 +0,0 @@
-# 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/core/multipart'
-require 'google/apis/core/http_command'
-require 'google/apis/core/api_command'
-require 'google/apis/errors'
-require 'addressable/uri'
-require 'tempfile'
-require 'mini_mime'
-
-module Google
-  module Apis
-    module Core
-      # Base upload command. Not intended to be used directly
-      # @private
-      class BaseUploadCommand < ApiCommand
-        UPLOAD_PROTOCOL_HEADER = 'X-Goog-Upload-Protocol'
-        UPLOAD_CONTENT_TYPE_HEADER = 'X-Goog-Upload-Header-Content-Type'
-        UPLOAD_CONTENT_LENGTH = 'X-Goog-Upload-Header-Content-Length'
-        CONTENT_TYPE_HEADER = 'Content-Type'
-
-        # File name or IO containing the content to upload
-        # @return [String, File, #read]
-        attr_accessor :upload_source
-
-        # Content type of the upload material
-        # @return [String]
-        attr_accessor :upload_content_type
-
-        # Content, as UploadIO
-        # @return [Google::Apis::Core::UploadIO]
-        attr_accessor :upload_io
-
-        # Ensure the content is readable and wrapped in an IO instance.
-        #
-        # @return [void]
-        # @raise [Google::Apis::ClientError] if upload source is invalid
-        def prepare!
-          super
-          if streamable?(upload_source)
-            self.upload_io = upload_source
-            @close_io_on_finish = false
-          elsif self.upload_source.is_a?(String)
-            self.upload_io = File.new(upload_source, 'r')
-            if self.upload_content_type.nil?
-              type = MiniMime.lookup_by_filename(upload_source)
-              self.upload_content_type = type && type.content_type
-            end
-            @close_io_on_finish = true
-          else
-            fail Google::Apis::ClientError, 'Invalid upload source'
-          end
-          if self.upload_content_type.nil? || self.upload_content_type.empty?
-            self.upload_content_type = 'application/octet-stream'
-          end
-        end
-
-        # Close IO stream when command done. Only closes the stream if it was opened by the command.
-        def release!
-          upload_io.close if @close_io_on_finish
-        end
-
-        private
-
-        def streamable?(upload_source)
-          upload_source.is_a?(IO) || upload_source.is_a?(StringIO) || upload_source.is_a?(Tempfile)
-        end
-      end
-
-      # Implementation of the raw upload protocol
-      class RawUploadCommand < BaseUploadCommand
-        RAW_PROTOCOL = 'raw'
-
-        # Ensure the content is readable and wrapped in an {{Google::Apis::Core::UploadIO}} instance.
-        #
-        # @return [void]
-        # @raise [Google::Apis::ClientError] if upload source is invalid
-        def prepare!
-          super
-          self.body = upload_io
-          header[UPLOAD_PROTOCOL_HEADER] = RAW_PROTOCOL
-          header[UPLOAD_CONTENT_TYPE_HEADER] = upload_content_type
-        end
-      end
-
-      # Implementation of the multipart upload protocol
-      class MultipartUploadCommand < BaseUploadCommand
-        MULTIPART_PROTOCOL = 'multipart'
-        MULTIPART_RELATED = 'multipart/related'
-
-        # Encode the multipart request
-        #
-        # @return [void]
-        # @raise [Google::Apis::ClientError] if upload source is invalid
-        def prepare!
-          super
-          multipart = Multipart.new
-          multipart.add_json(body)
-          multipart.add_upload(upload_io, content_type: upload_content_type)
-          self.body = multipart.assemble
-          header['Content-Type'] = multipart.content_type
-          header[UPLOAD_PROTOCOL_HEADER] = MULTIPART_PROTOCOL
-        end
-      end
-
-      # Implementation of the resumable upload protocol
-      class ResumableUploadCommand < BaseUploadCommand
-        UPLOAD_COMMAND_HEADER = 'X-Goog-Upload-Command'
-        UPLOAD_OFFSET_HEADER = 'X-Goog-Upload-Offset'
-        BYTES_RECEIVED_HEADER = 'X-Goog-Upload-Size-Received'
-        UPLOAD_URL_HEADER = 'X-Goog-Upload-URL'
-        UPLOAD_STATUS_HEADER = 'X-Goog-Upload-Status'
-        STATUS_ACTIVE = 'active'
-        STATUS_FINAL = 'final'
-        STATUS_CANCELLED = 'cancelled'
-        RESUMABLE = 'resumable'
-        START_COMMAND = 'start'
-        QUERY_COMMAND = 'query'
-        UPLOAD_COMMAND = 'upload, finalize'
-
-        # Reset upload to initial state.
-        #
-        # @return [void]
-        # @raise [Google::Apis::ClientError] if upload source is invalid
-        def prepare!
-          @state = :start
-          @upload_url = nil
-          @offset = 0
-          # Prevent the command from populating the body with form encoding, by
-          # asserting that it already has a body. Form encoding is never used
-          # by upload requests.
-          self.body = '' unless self.body
-          super
-        end
-
-        # Check the to see if the upload is complete or needs to be resumed.
-        #
-        # @param [Fixnum] status
-        #   HTTP status code of response
-        # @param [HTTP::Message::Headers] header
-        #   Response headers
-        # @param [String, #read] body
-        #  Response body
-        # @return [Object]
-        #   Response object
-        # @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 process_response(status, header, body)
-          @offset = Integer(header[BYTES_RECEIVED_HEADER].first) unless header[BYTES_RECEIVED_HEADER].empty?
-          @upload_url = header[UPLOAD_URL_HEADER].first unless header[UPLOAD_URL_HEADER].empty?
-          upload_status = header[UPLOAD_STATUS_HEADER].first
-          logger.debug { sprintf('Upload status %s', upload_status) }
-          if upload_status == STATUS_ACTIVE
-            @state = :active
-          elsif upload_status == STATUS_FINAL
-            @state = :final
-          elsif upload_status == STATUS_CANCELLED
-            @state = :cancelled
-            fail Google::Apis::ClientError, body
-          end
-          super(status, header, body)
-        end
-
-        def send_start_command(client)
-          logger.debug { sprintf('Sending upload start command to %s', url) }
-
-          request_header = header.dup
-          apply_request_options(request_header)
-          request_header[UPLOAD_PROTOCOL_HEADER] = RESUMABLE
-          request_header[UPLOAD_COMMAND_HEADER] = START_COMMAND
-          request_header[UPLOAD_CONTENT_LENGTH] = upload_io.size.to_s
-          request_header[UPLOAD_CONTENT_TYPE_HEADER] = upload_content_type
-
-          client.request(method.to_s.upcase,
-                         url.to_s, query: nil,
-                         body: body,
-                         header: request_header,
-                         follow_redirect: true)
-        rescue => e
-          raise Google::Apis::ServerError, e.message
-        end
-
-        # Query for the status of an incomplete upload
-        #
-        # @param [HTTPClient] client
-        #   HTTP client
-        # @return [HTTP::Message]
-        # @raise [Google::Apis::ServerError] Unable to send the request
-        def send_query_command(client)
-          logger.debug { sprintf('Sending upload query command to %s', @upload_url) }
-
-          request_header = header.dup
-          apply_request_options(request_header)
-          request_header[UPLOAD_COMMAND_HEADER] = QUERY_COMMAND
-
-          client.post(@upload_url, body: '', header: request_header, follow_redirect: true)
-        end
-
-
-        # Send the actual content
-        #
-        # @param [HTTPClient] client
-        #   HTTP client
-        # @return [HTTP::Message]
-        # @raise [Google::Apis::ServerError] Unable to send the request
-        def send_upload_command(client)
-          logger.debug { sprintf('Sending upload command to %s', @upload_url) }
-
-          content = upload_io
-          content.pos = @offset
-
-          request_header = header.dup
-          apply_request_options(request_header)
-          request_header[UPLOAD_COMMAND_HEADER] = QUERY_COMMAND
-          request_header[UPLOAD_COMMAND_HEADER] = UPLOAD_COMMAND
-          request_header[UPLOAD_OFFSET_HEADER] = @offset.to_s
-          request_header[CONTENT_TYPE_HEADER] = upload_content_type
-
-          client.post(@upload_url, body: content, header: request_header, follow_redirect: true)
-        end
-
-        # Execute the upload request once. This will typically perform two HTTP requests -- one to initiate or query
-        # for the status of the upload, the second to send the (remaining) content.
-        #
-        # @private
-        # @param [HTTPClient] client
-        #   HTTP client
-        # @yield [result, err] Result or error if block supplied
-        # @return [Object]
-        # @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_once(client, &block)
-          case @state
-          when :start
-            response = send_start_command(client)
-            result = process_response(response.status_code, response.header, response.body)
-          when :active
-            response = send_query_command(client)
-            result = process_response(response.status_code, response.header, response.body)
-          when :cancelled, :final
-            error(@last_error, rethrow: true, &block)
-          end
-          if @state == :active
-            response = send_upload_command(client)
-            result = process_response(response.status_code, response.header, response.body)
-          end
-
-          success(result, &block) if @state == :final
-        rescue => e
-          # Some APIs like Youtube generate non-retriable 401 errors and mark
-          # the upload as finalized. Save the error just in case we get
-          # retried.
-          @last_error = e
-          error(e, rethrow: true, &block)
-        end
-      end
-    end
-  end
-end