google-api-client 0.10.3 → 0.11.0

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

@@ -55,7 +55,7 @@ module Google
           def if_fn(name)
             ivar_name = "@#{name}".to_sym
             lambda do |opts|
-              if opts[:options][:user_options] and opts[:options][:user_options][:skip_undefined]
+              if opts[:user_options] && opts[:user_options][:skip_undefined]
                 if respond_to?(:key?)
                   self.key?(name) || instance_variable_defined?(ivar_name)
                 else
@@ -72,6 +72,10 @@ module Google
               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) }

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

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'hurley'
 
 module Google
   module Apis
@@ -21,108 +20,60 @@ module Google
       #
       # @private
       class JsonPart
-        include Hurley::Multipart::Part
 
-        # @return [Fixnum]
-        #   Length of part
-        attr_reader :length
-
-        # @param [String] boundary
-        #   Multipart boundary
         # @param [String] value
         #   JSON content
-        def initialize(boundary, value, header = {})
-          @part = build_part(boundary, value)
-          @length = @part.bytesize
-          @io = StringIO.new(@part)
+        # @param [Hash] header
+        #   Additional headers
+        def initialize(value, header = {})
+          @value = value
+          @header = header
         end
 
-        private
-
-        # Format the part
-        #
-        # @param [String] boundary
-        #   Multipart boundary
-        # @param [String] value
-        #   JSON content
-        # @return [String]
-        def build_part(boundary, value)
+        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"
+          part << "#{@value}\r\n"
+          StringIO.new(part)
         end
+
       end
 
-      # Part of a multipart request for holding arbitrary content. Modified
-      # from Hurley::Multipart::FilePart to remove Content-Disposition
+      # Part of a multipart request for holding arbitrary content.
       #
       # @private
       class FilePart
-        include Hurley::Multipart::Part
-
-        # @return [Fixnum]
-        #   Length of part
-        attr_reader :length
-
-        # @param [String] boundary
-        #   Multipart boundary
-        # @param [Google::Apis::Core::UploadIO] io
+        # @param [IO] io
         #   IO stream
         # @param [Hash] header
         #   Additional headers
-        def initialize(boundary, io, header = {})
-          file_length = io.respond_to?(:length) ? io.length : File.size(io.local_path)
-
-          @head = build_head(boundary, io.content_type, file_length,
-                             io.respond_to?(:opts) ? io.opts.merge(header) : header)
-
-          @length = @head.bytesize + file_length + FOOT.length
-          @io = Hurley::CompositeReadIO.new(@length, StringIO.new(@head), io, StringIO.new(FOOT))
+        def initialize(io, header = {})
+          @io = io
+          @header = header
+          @length = io.respond_to?(:size) ? io.size : nil
         end
 
-        private
-
-        # Construct the header for the part
-        #
-        # @param [String] boundary
-        #  Multipart boundary
-        # @param [String] type
-        #  Content type for the part
-        # @param [Fixnum] content_len
-        #  Length of the part
-        # @param [Hash] header
-        #  Headers for the part
-        def build_head(boundary, type, content_len, header)
-          content_id = ''
-          if header[:content_id]
-            content_id = sprintf(CID_FORMAT, header[:content_id])
+        def to_io(boundary)
+          head = ''
+          head << "--#{boundary}\r\n"
+          @header.each do |(k, v)|
+            head << "#{k}: #{v}\r\n"
           end
-          sprintf(HEAD_FORMAT,
-                  boundary,
-                  content_len.to_i,
-                  content_id,
-                  header[:content_type] || type,
-                  header[:content_transfer_encoding] || DEFAULT_TR_ENCODING)
+          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
-
-        DEFAULT_TR_ENCODING = 'binary'.freeze
-        FOOT = "\r\n".freeze
-        CID_FORMAT = "Content-ID: %s\r\n"
-        HEAD_FORMAT = <<-END
---%s\r
-Content-Length: %d\r
-%sContent-Type: %s\r
-Content-Transfer-Encoding: %s\r
-\r
-        END
       end
 
       # Helper for building multipart requests
       class Multipart
         MULTIPART_RELATED = 'multipart/related'
-        DEFAULT_BOUNDARY = 'RubyApiClientMultiPart'
 
         # @return [String]
         #  Content type header
@@ -135,8 +86,8 @@ Content-Transfer-Encoding: %s\r
 
         def initialize(content_type: MULTIPART_RELATED, boundary: nil)
           @parts = []
-          @boundary = boundary || DEFAULT_BOUNDARY
-          @content_type = "#{content_type}; boundary=#{boundary}"
+          @boundary = boundary || Digest::SHA1.hexdigest(SecureRandom.random_bytes(8))
+          @content_type = "#{content_type}; boundary=#{@boundary}"
         end
 
         # Append JSON data part
@@ -147,23 +98,26 @@ Content-Transfer-Encoding: %s\r
         #   Optional unique ID of this part
         # @return [self]
         def add_json(body, content_id: nil)
-          header = { :content_id => content_id }
-          @parts << Google::Apis::Core::JsonPart.new(@boundary, body, header)
+          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 [Google::Apis::Core::UploadIO] upload_io
+        # @param [IO] upload_io
         #   IO stream
         # @param [String] content_id
         #   Optional unique ID of this part
         # @return [self]
-        def add_upload(upload_io, content_id: nil)
-          header = { :content_id => content_id }
-          @parts << Google::Apis::Core::FilePart.new(@boundary,
-                                                     upload_io,
-                                                     header)
+        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
 
@@ -172,16 +126,10 @@ Content-Transfer-Encoding: %s\r
         # @return [IO]
         #  IO stream
         def assemble
-          @parts << Hurley::Multipart::EpiloguePart.new(@boundary)
-          ios = []
-          len = 0
-          @parts.each do |part|
-            len += part.length
-            ios << part.to_io
-          end
-          Hurley::CompositeReadIO.new(len, *ios)
+          @parts <<  StringIO.new("--#{@boundary}--\r\n\r\n")
+          Google::Apis::Core::CompositeIO.new(*@parts)
         end
       end
     end
   end
-end
+end

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

@@ -18,58 +18,18 @@ require 'google/apis/core/api_command'
 require 'google/apis/errors'
 require 'addressable/uri'
 require 'tempfile'
-begin
-  require 'mime/types/columnar'
-rescue LoadError
-  # Temporary until next major bump when we can tighten
-  # dependency to mime-types >-=3.0
-  require 'mime-types'
-end
+require 'mime-types'
 
 module Google
   module Apis
     module Core
-      # Extension of Hurley's UploadIO to add length accessor
-      class UploadIO < Hurley::UploadIO
-        OCTET_STREAM_CONTENT_TYPE = 'application/octet-stream'
-
-        # Get the length of the stream
-        # @return [Fixnum]
-        def length
-          io.respond_to?(:length) ? io.length : File.size(local_path)
-        end
-
-        # Create a new instance given a file path
-        # @param [String, File] file_name
-        #  Path to file
-        # @param [String] content_type
-        #  Optional content type. If nil, will attempt to auto-detect
-        # @return [Google::Apis::Core::UploadIO]
-        def self.from_file(file_name, content_type: nil)
-          if content_type.nil?
-            type = MIME::Types.of(file_name)
-            content_type = type.first.content_type unless type.nil? || type.empty?
-          end
-          new(file_name, content_type || OCTET_STREAM_CONTENT_TYPE)
-        end
-
-        # Wraps an IO stream in UploadIO
-        # @param [#read] io
-        #  IO to wrap
-        # @param [String] content_type
-        #  Optional content type.
-        # @return [Google::Apis::Core::UploadIO]
-        def self.from_io(io, content_type: OCTET_STREAM_CONTENT_TYPE)
-          new(io, content_type)
-        end
-      end
-
       # 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]
@@ -83,21 +43,29 @@ module Google
         # @return [Google::Apis::Core::UploadIO]
         attr_accessor :upload_io
 
-        # Ensure the content is readable and wrapped in an {{Google::Apis::Core::UploadIO}} instance.
+        # 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 = UploadIO.from_io(upload_source, content_type: upload_content_type)
+            self.upload_io = upload_source
             @close_io_on_finish = false
-          elsif upload_source.is_a?(String)
-            self.upload_io = UploadIO.from_file(upload_source, content_type: upload_content_type)
+          elsif self.upload_source.is_a?(String)
+            self.upload_io = File.new(upload_source, 'r')
+            if self.upload_content_type.nil?
+              type = MIME::Types.of(upload_source)
+              self.upload_content_type = type.first.content_type unless type.nil? || type.empty?
+            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
+          puts self.upload_content_type.inspect
         end
 
         # Close IO stream when command done. Only closes the stream if it was opened by the command.
@@ -124,13 +92,12 @@ module Google
           super
           self.body = upload_io
           header[UPLOAD_PROTOCOL_HEADER] = RAW_PROTOCOL
-          header[UPLOAD_CONTENT_TYPE_HEADER] = upload_io.content_type
+          header[UPLOAD_CONTENT_TYPE_HEADER] = upload_content_type
         end
       end
 
       # Implementation of the multipart upload protocol
       class MultipartUploadCommand < BaseUploadCommand
-        UPLOAD_BOUNDARY = 'RubyApiClientUpload'
         MULTIPART_PROTOCOL = 'multipart'
         MULTIPART_RELATED = 'multipart/related'
 
@@ -140,11 +107,11 @@ module Google
         # @raise [Google::Apis::ClientError] if upload source is invalid
         def prepare!
           super
-          @multipart = Multipart.new(boundary: UPLOAD_BOUNDARY, content_type: MULTIPART_RELATED)
-          @multipart.add_json(body)
-          @multipart.add_upload(upload_io)
-          self.body = @multipart.assemble
-          header[:content_type] = @multipart.content_type
+          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
@@ -179,7 +146,7 @@ module Google
         #
         # @param [Fixnum] status
         #   HTTP status code of response
-        # @param [Hurley::Header] header
+        # @param [HTTP::Message::Headers] header
         #   Response headers
         # @param [String, #read] body
         #  Response body
@@ -189,9 +156,9 @@ module Google
         # @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]) if header.key?(BYTES_RECEIVED_HEADER)
-          @upload_url = header[UPLOAD_URL_HEADER] if header.key?(UPLOAD_URL_HEADER)
-          upload_status = header[UPLOAD_STATUS_HEADER]
+          @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
@@ -204,61 +171,69 @@ module Google
           super(status, header, body)
         end
 
-        # Send the start command to initiate the upload
-        #
-        # @param [Hurley::Client] client
-        #   HTTP client
-        # @return [Hurley::Response]
-        # @raise [Google::Apis::ServerError] Unable to send the request
         def send_start_command(client)
           logger.debug { sprintf('Sending upload start command to %s', url) }
-          client.send(method, url, body) do |req|
-            apply_request_options(req)
-            req.header[UPLOAD_PROTOCOL_HEADER] = RESUMABLE
-            req.header[UPLOAD_COMMAND_HEADER] = START_COMMAND
-            req.header[UPLOAD_CONTENT_LENGTH] = upload_io.length.to_s
-            req.header[UPLOAD_CONTENT_TYPE_HEADER] = upload_io.content_type
-          end
+
+          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 [Hurley::Client] client
+        # @param [HTTPClient] client
         #   HTTP client
-        # @return [Hurley::Response]
+        # @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) }
-          client.post(@upload_url, nil) do |req|
-            apply_request_options(req)
-            req.header[UPLOAD_COMMAND_HEADER] = QUERY_COMMAND
-          end
+
+          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 [Hurley::Client] client
+        # @param [HTTPClient] client
         #   HTTP client
-        # @return [Hurley::Response]
+        # @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
-          client.post(@upload_url, content) do |req|
-            apply_request_options(req)
-            req.header[UPLOAD_COMMAND_HEADER] = UPLOAD_COMMAND
-            req.header[UPLOAD_OFFSET_HEADER] = @offset.to_s
-          end
+
+          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 [Hurley::Client] client
+        # @param [HTTPClient] client
         #   HTTP client
         # @yield [result, err] Result or error if block supplied
         # @return [Object]