class S3

# Used by S3#S3Object and S3::Client to accept options with

# data that should be uploaded (streamed).

# @api private

module DataOptions

protected

# @return [Hash] Returns a hash of options with a :data option that

# responds to #read and #eof?.

def compute_write_options *args, &block

options = convert_args_to_options_hash(*args)

validate_data!(options, &block)

rename_file_to_data(options)

convert_data_to_io_obj(options, &block)

try_to_determine_content_length(options)

options

end

# Converts an argument list into a single hash of options. Treats

# non-hash arguments in the first position as a data option.

def convert_args_to_options_hash *args

case args.count

when 0 then {}

when 1 then args[0].is_a?(Hash) ? args[0] : { :data => args[0] }

when 2 then args[1].merge(:data => args[0])

else

msg = "expected 0, 1 or 2 arguments, got #{args.count}"

raise ArgumentError, msg

end

end

# Moves options[:file] to options[:data]. If this option is a string

# then it is treated as a file path and is converted to an open file.

def rename_file_to_data options

if file = options.delete(:file)

options[:data] = file.is_a?(String) ? open_file(file) : file

end

end

# Converts the :data option to an IO-like object. This allows us

# to always perform streaming uploads.

def convert_data_to_io_obj options, &block

data = options.delete(:data)

if block_given?

options[:data] = IOProxy.new(block)

elsif data.is_a?(String)

data = data.dup if data.frozen?

data.force_encoding("BINARY") if data.respond_to?(:force_encoding)

options[:data] = StringIO.new(data)

elsif data.is_a?(Pathname)

options[:data] = open_file(data.to_s)

elsif io_like?(data)

options[:data] = data

else

msg = "invalid :data option, expected a String, Pathname or "

msg << "an object that responds to #read and #eof?"

raise ArgumentError, msg

end

end

# Attempts to determine the content length of the :data option.

# This is only done when a content length is not already provided.

def try_to_determine_content_length options

unless options[:content_length]

data = options[:data]

length = case

when data.respond_to?(:path) && data.path then File.size(data.path)

when data.respond_to?(:bytesize) then data.bytesize

when data.respond_to?(:size) then data.size

when data.respond_to?(:length) then data.length

else nil

end

options[:content_length] = length if length

end

end

def validate_data! options, &block

data = options[:data]

file = options[:file]

raise ArgumentError, 'Object data passed multiple ways.' if

[data, file, block].compact.count > 1

data = file if file

return if block_given?

return if data.kind_of?(String)

return if data.kind_of?(Pathname)

return if io_like?(data)

msg = ":data must be provided as a String, Pathname, File, or "

msg << "an object that responds to #read and #eof?"

raise ArgumentError, msg

end

# @return [Boolean] Returns `true` if the object responds to

# `#read` and `#eof?`.

def io_like? io

io.respond_to?(:read) and io.respond_to?(:eof?)

end

# @param [String] path Path to a file on disk.

# @return [File] Given a path string, returns an open File.

def open_file path

Core::ManagedFile.open(path)

end

# A utility class that turns a block (with 2 args) into an

# IO object that responds to #read and #eof.

# @api private

class IOProxy

def initialize write_block

unless write_block.arity == 2

msg = "a write block must accept 2 yield params: a buffer and "

msg << "a number of bytes to write"

raise ArgumentError, msg

end

@write_block = write_block

@eof = false

end

def read bytes = nil, output_buffer = nil

data = if bytes

(@eof) ? nil : read_chunk(bytes)

else

(@eof) ? "" : read_all

end

output_buffer ? output_buffer.replace(data || '') : data

end

def eof?

@eof

end

protected

def read_chunk bytes

buffer = StringIO.new

@write_block.call(buffer, bytes)

buffer.rewind

@eof = true if buffer.size < bytes

buffer.read

end

def read_all

buffer = StringIO.new

buffer << read_chunk(1024 * 1024 * 5) until @eof

buffer.rewind

buffer.read

end

end

end

end