class AWS::S3::Client

def self.bucket_method(method_name, verb, *args, &block)
  method_options = (args.pop if args.last.kind_of?(Hash)) || {}
  xml_grammar = (args.pop if args.last.respond_to?(:rules))
  verb = verb.to_s.upcase
  subresource = args.first
  add_client_request_method(method_name) do
    configure_request do |req, options|
      require_bucket_name!(options[:bucket_name])
      req.http_method = verb
      req.bucket = options[:bucket_name]
      req.add_param(subresource) if subresource
      if header_options = method_options[:header_options]
        header_options.each do |(opt, header)|
          if value = options[opt]
            # for backwards compatability we translate canned acls
            # header values from symbols to strings (e.g. 
            # :public_read translates to 'public-read')
            value = (opt == :acl ? value.to_s.tr('_', '-') : value)
            req.headers[header] = value
          end
        end
      end
    end
    instance_eval(&block) if block
    if xml_grammar
      parser = Core::XML::Parser.new(xml_grammar.rules)
      process_response do |resp|
        resp.data = parser.parse(resp.http_response.body)
        super(resp)
      end
      simulate_response do |resp|
        resp.data = parser.simulate
        super(resp)
      end
    end
  end
end

def self.object_method(method_name, verb, *args, &block)
  bucket_method(method_name, verb, *args) do
    configure_request do |req, options|
      validate_key!(options[:key])
      super(req, options)
      req.key = options[:key]
    end
    instance_eval(&block) if block
  end
end

def add_sse_to_response response
  if sse = response.http_response.header('x-amz-server-side-encryption')
    sse = sse.downcase.to_sym
  end
  response.data[:server_side_encryption] = sse
end

def extract_error_details response
  if 
    (response.http_response.status >= 300 ||
      response.request_type == :complete_multipart_upload) and
    body = response.http_response.body and
    error = Core::XML::Parser.parse(body) and
    error[:code]
  then
    [error[:code], error[:message]]
  end
end

def is_xml? possible_xml
  begin
    REXML::Document.new(possible_xml).has_elements?
  rescue
    false
  end
end

def move_access_control_policy options
  if acl = options[:acl]
    if acl.is_a?(String) and is_xml?(acl)
      options[:access_control_policy] = options.delete(:acl)
    elsif acl.respond_to?(:to_xml)
      options[:access_control_policy] = options.delete(:acl).to_xml
    end
  end
end

def new_request
  S3::Request.new
end

def populate_error resp
  code = resp.http_response.status
  if EMPTY_BODY_ERRORS.include?(code) and resp.http_response.body.nil?
    error_class = EMPTY_BODY_ERRORS[code]
    resp.error = error_class.new(resp.http_request, resp.http_response)
  else
    super
  end
end

def set_request_data request, options, block
  request.body_stream = data_stream_from(options, &block)
  request.headers['Content-Length'] = content_length_from(options)
end

def should_retry? response
  super or
    response.request_type == :complete_multipart_upload &&
    extract_error_details(response)
    # complete multipart upload can return an error inside a 
    # 200 level response -- this forces us to parse the
    # response for errors every time
end