simple_aws 0.0.1d → 1.0.0.pre1

data/.gitignore

@@ -2,3 +2,5 @@ Gemfile.lock
 doc
 pkg
 .bundle
+*.gem
+.yardoc

data/.travis.yml

@@ -2,7 +2,7 @@ rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
-  - rbx
+#  - rbx
   - ruby-head
   - ree
-  - jruby
+#  - jruby

data/Gemfile

@@ -4,6 +4,7 @@ gemspec
 
 group :development do
   gem "rake"
+  gem "yard"
 end
 
 group :test do

data/MIT_LICENCE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Jason Roelofs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.md

@@ -1,4 +1,4 @@
-SimpleAWS
+SimpleAWS [![Travis CI Build Status](https://secure.travis-ci.org/jameskilton/simple_aws.png)](http://travis-ci.org/jameskilton/simple_aws)
 =========
 
 A thin, simple, forward compatible Ruby wrapper around the various Amazon AWS APIs. Unless otherwise mentioned below, this library will wrap every API available service listed on this page: http://aws.amazon.com/documentation/
@@ -8,23 +8,22 @@ What?! Why?
 
 Do we really need another Ruby library to talk to Amazon Web Services? Aren't there enough libraries out there that could just use some more help to make them better? What about [fog](http://fog.io), or [aws-sdk](http://rubygems.org/gems/aws-sdk), or [aws](http://rubygems.org/gems/aws), or [right_aws](http://rubygems.org/gems/right_aws)?
 
-While there are a number of well used libraries, I feel they have all fallen prey to the same two problems, problems that SimpleAWS will not have: complexity and forward incompatibility.
+While there are a number of well used libraries, I feel they have all fallen prey to the same two problems: complexity and forward incompatibility.
 
 ### Complexity
 
-Every Ruby AWS library in use today is simply too complex. Every library I've tried to use has ended up hurting my productivity as I often have to dive into the code to find out what the parameter list is, what object I need to work with, or what hash keys map to the actual AWS API parameters. Every library that tries to build an Object Abstraction wrapper on top of AWS's APIs suffers from leaky abstractions, which results in yet more time lost trying to figure out what needs to be called, with what, and what gets returned. Software is supposed to be simple, it's supposed to make your life easier as a developer. I've yet to find an AWS library that does this.
+Every Ruby AWS library in use today is simply too complex. Every library I've tried to use has ended up hurting my productivity as I often have to dive into the code to find out what the parameter list is, what object I need to work with, or what hash keys map to the actual AWS API parameters. Every library that tries to build an Object Abstraction wrapper on top of AWS's APIs suffers from leaky abstractions, which results in yet more time lost trying to figure out what needs to be called, with what, and what gets returned. Software is supposed to be simple, it's supposed to make your life easier. I've yet to find an AWS library that does this.
 
-The name SimpleAWS isn't a wish or hope, it's the core philosophy. This library focuses on being a very thin communication layer between your Ruby code and Amazon's AWS APIs. Let SimpleAWS handle the messy communication details so your code can do what it needs to do and you can be more productive doing what you need to do. An AWS library should facilitate using AWS, not abstract it.
+### Forward Compatibility
 
-It's the Unix philosophy, SimpleAWS does one thing and does it well and nothing else.
+Ignoring the complexity argument above, what finally drove me to create this library is the complete lack of forward compatibility in all existing Ruby AWS libraries. Any time I wanted to use a new parameter, new action, or new API, I would need to jump into the library itself and implement the missing pieces. In the usual OSS circles this doesn't sound that bad, and is in fact praised, but when you're dealing with an API library, this requirement quickly becomes a frustration.
 
-### Forward Compatibility
+Amazon constantly updates AWS APIs, adding parameters and actions, and at times entire new APIs. An AWS library should work *with* the API in question, not fight against it. The only thing a hard-coded parameter list does is add confusion as you have to keep two things in your mind: what you want to call, and how the library lets you call it. SimpleAWS simply says no, it won't force anything on the user. Use the names of the API methods and parameters and them alone. If a new parameter is added to the API you're using, just use it; SimpleAWS doesn't care, it will just work.
 
-Ignoring the complexity argument above, what finally drove me to create this library is the complete lack of forward compatibility in all existing Ruby AWS libraries. Any time I wanted to use a new parameter, new action, or new API, I would need to jump into the library itself and implement the missing pieces. In general, this doesn't sound that bad, and in many cases expected, but not for an API wrapper library.
+The name SimpleAWS isn't a wish or hope, it's the core philosophy. This library focuses on being a very thin communication layer between your Ruby code and Amazon's AWS APIs. Let SimpleAWS handle the messy communication details so your code can do what it needs to do letting you be more productive.
 
-Amazon constantly updates AWS APIs, adding parameters and actions, and at times entire new APIs. An AWS library should work *with* the API in question not fight against it. The only thing a hard-coded parameter list to a method does is add confusion and more mental disconnects.  SimpleAWS simply says no, it won't force anything on the user. Use the names of the API params and them alone. If a new parameter is added to the API you're using, just use it, SimpleAWS doesn't care, it will just work.
+In short, it's the Unix philosophy, SimpleAWS does one thing and does it well and nothing else.
 
-SimpleAWS is the first and (from what I've found) only Ruby AWS library that is forward compatible with nigh any change Amazon could make to their APIs.
 
 Surely SimpleAWS isn't just `curl`?
 -----------------------------------
@@ -35,7 +34,7 @@ What SimpleAWS does do is add some logic to ensure it follows the Principle of L
 
 ### Calling
 
-First of all, calling actions are implemented as ruby methods, handled through method_missing. You can call the AWS actions by AWSName or by ruby_name, they both work:
+First of all, calling actions are implemented as ruby methods, handled through mainly through `method_missing` (S3 and CloudFront are the two exceptions). You can call the AWS actions by AWSName or by ruby_name, they both work:
 
 ```ruby
 ec2 = AWS::EC2.new key, secret
@@ -95,34 +94,34 @@ ec2.describe_instances({
 
 All requests return an AWS::Response which does a few cleanup tasks on the resulting XML to make it easier to query and to hide some of the worst warts an XML body tends to have.
 
-First of all, whereever AWS returns a list of items, they almost always get wrapped up in an <item> or <member> wrapper tag. Response gets rid of those tags and gives you a flat array to work with.
+First of all, wherever AWS returns a list of items, they almost always get wrapped up in an `<item>` or `<member>` wrapper tag. AWS::Response gets rid of those tags and gives you a flat array to work with.
 
-Second, the resulting XML can have one or two wrapper objects that do nothing but encapsulate the information you're interested in. Response also jumps past these wrapper objects so you have direct access to the data in the response.
+Second, the resulting XML can have one or two wrapper objects that do nothing but encapsulate the information you're interested in. AWS::Response also jumps past these wrapper objects so you have direct access to the data in the response.
 
 All response objects are infinitely deep queryable via methods or Hash access. See the samples, tests, and AWS::Response for more details and examples of usage. At all times you can easily inspect the current Response object for the entire response body, or just the rest of the body at the current depth level.
 
 Implemented APIs
 ----------------
 
-These are the following Amazon APIs that SimpleAWS currently handles:
-
-* S3
-* EC2
-* ELB
-* IAM
-* MapReduce
-* Auto Scaling
-* RDS
-* ElastiCache
-* Elastic Beanstalk
-* CloudFormation
-* SNS
-* CloudWatch
-* Import / Export
-* Mechanical Turk
-* SQS (Simple Queue Service)
-* SES (Simple Email Service)
-* CloudFront
+These are the Amazon APIs that SimpleAWS currently handles:
+
+* {AWS::S3 S3}
+* {AWS::EC2 EC2}
+* {AWS::ELB ELB}
+* {AWS::IAM IAM}
+* {AWS::MapReduce MapReduce}
+* {AWS::AutoScaling Auto Scaling}
+* {AWS::RDS RDS}
+* {AWS::ElastiCache ElastiCache}
+* {AWS::ElasticBeanstalk Elastic Beanstalk}
+* {AWS::CloudFormation CloudFormation}
+* {AWS::SNS SNS}
+* {AWS::CloudWatch CloudWatch}
+* {AWS::ImportExport ImportExport}
+* {AWS::MechanicalTurk MechanicalTurk}
+* {AWS::SQS SQS}
+* {AWS::SES SES}
+* {AWS::CloudFront CloudFront}
 
 Currently Out-Of-Scope
 ----------------------
@@ -136,11 +135,26 @@ The following API endpoints will not currently be handled in SimpleAWS. These li
 Project Info
 ------------
 
-Author: Jason Roelofs (https://github.com/jameskilton)
+### Rubies
+
+SimpleAWS is built to work under all major Ruby versions:
+
+* 1.8.7
+* 1.9.2
+* 1.9.3
+* ree
+* HEAD
+
+The following are waiting on a release of Nokogiri to fix some issues:
+
+* jruby
+* rubinius
+
+### Misc Info
+
+Author: Jason Roelofs - [Github](https://github.com/jameskilton) [@jameskilton](http://twitter.com/jameskilton)
 
 Source: https://github.com/jameskilton/simple_aws
 
 Issues: https://github.com/jameskilton/simple_aws/issues
 
-[![Travis CI Build Status](https://secure.travis-ci.org/jameskilton/simple_aws.png)](http://travis-ci.org/jameskilton/simple_aws)
-

data/lib/aws/auto_scaling.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS. Use the third parameter to
   # #initialize if you need to talk to a region other than us-east-1.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class AutoScaling < API
     endpoint "autoscaling"

data/lib/aws/call_types/action_param.rb

@@ -7,7 +7,14 @@ module AWS
 
     ##
     # Implement call handling to work with the ?Action param, signing the message
-    # according to whatever Signing module is included along side this module
+    # according to whatever Signing module is included along side this module.
+    #
+    # This module hooks up the `method_missing` functionality as described in the
+    # README. To call methods on APIs including this module, simply call a method
+    # with either the Ruby-fied name, or the full CamelCase name, and pass in
+    # options required as the parameters.
+    #
+    # All responses will be wrapped up in an {AWS::Response AWS::Response} object.
     ##
     module ActionParam
       ##

data/lib/aws/cloud_formation.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS. Use the third parameter to
   # #initialize if you need to talk to a region other than us-east-1.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class CloudFormation < API
     endpoint "cloudformation"

data/lib/aws/cloud_watch.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS. Use the third parameter to
   # #initialize if you need to talk to a region other than us-east-1.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class CloudWatch < API
     endpoint "monitoring"

data/lib/aws/core/connection.rb

@@ -1,14 +1,36 @@
 require 'httparty'
-require 'httmultiparty'
 require 'openssl'
 
 require 'aws/core/response'
 
+##
+# Monkey-patch body_stream usage into HTTParty
+##
+module HTTParty
+  class Request
+    private
+
+    def setup_raw_request
+      @raw_request = http_method.new(uri.request_uri)
+      if body
+        if body.respond_to?(:read)
+          @raw_request.body_stream = body
+        else
+          @raw_request.body = body
+        end
+      end
+      @raw_request.initialize_http_header(options[:headers])
+      @raw_request.basic_auth(username, password) if options[:basic_auth]
+      setup_digest_auth if options[:digest_auth]
+    end
+
+  end
+end
+
 module AWS
 
   class HTTP
-    include HTTMultiParty
-    format :xml
+    include HTTParty
   end
 
   ##

data/lib/aws/core/response.rb

@@ -181,7 +181,7 @@ module AWS
       @body = http_response.parsed_response
       @headers = http_response.headers
 
-      if @body
+      if @body.is_a?(Hash)
         inner = @body[@body.keys.first]
         response_root =
           if result_key = inner.keys.find {|k| k =~ /Result$/}
@@ -208,7 +208,11 @@ module AWS
     # Delegate first-level method calls to the root Proxy object
     ##
     def method_missing(name, *args)
-      @request_root.send(name, *args)
+      if @request_root
+        @request_root.send(name, *args)
+      else
+        super
+      end
     end
 
     ##

data/lib/aws/core/util.rb

@@ -1,4 +1,4 @@
-require 'ox'
+require 'nokogiri'
 
 module AWS
   ##
@@ -40,17 +40,18 @@ module AWS
     # The hash body can contain symbols, strings, arrays and hashes
     ##
     def build_xml_from(hash, namespace = nil)
-      doc = Ox::Document.new(:version => 1.0, :standalone => true)
+      doc = Nokogiri::XML::Document.new
+      doc.encoding = "UTF-8"
 
       root_key = hash.keys.first
-      root = Ox::Element.new root_key
-      root[:xmlns] = namespace if namespace
+      root = Nokogiri::XML::Element.new root_key.to_s, doc
+      root["xmlns"] = namespace if namespace
 
       doc << root
 
       build_body root, hash[root_key]
 
-      %|<?xml version="1.0" encoding="UTF-8"?>#{Ox.dump doc}|
+      doc.to_s
     end
 
     extend self
@@ -61,7 +62,7 @@ module AWS
       hash.each do |key, value|
         case value
         when Hash
-          node = build_node(key)
+          node = build_node(parent, key)
           build_body node, value
           parent << node
         when Array
@@ -69,13 +70,13 @@ module AWS
             build_body parent, {key => entry}
           end
         else
-          parent << build_node(key, value)
+          parent << build_node(parent, key, value)
         end
       end
     end
 
-    def build_node(key, value = nil)
-      child = Ox::Element.new key
+    def build_node(parent, key, value = nil)
+      child = Nokogiri::XML::Element.new key.to_s, parent
       child << value.to_s unless value.nil?
       child
     end

data/lib/aws/ec2.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS. Use the third parameter to
   # #initialize if you need to talk to a region other than us-east-1.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class EC2 < API
     endpoint "ec2"

data/lib/aws/elasti_cache.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS. Use the third parameter to
   # #initialize if you need to talk to a region other than us-east-1.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class ElastiCache < API
     endpoint "elasticache"

data/lib/aws/elastic_beanstalk.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS. Use the third parameter to
   # #initialize if you need to talk to a region other than us-east-1.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class ElasticBeanstalk < API
     endpoint "elasticbeanstalk"

data/lib/aws/elb.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS. Use the third parameter to
   # #initialize if you need to talk to a region other than us-east-1.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class ELB < API
     endpoint "elasticloadbalancing"

data/lib/aws/iam.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS. Use the third parameter to
   # #initialize if you need to talk to a region other than us-east-1.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class IAM < API
     endpoint "iam"

data/lib/aws/import_export.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS.
   # This API does not support region specifiers
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class ImportExport < API
     endpoint "importexport"

data/lib/aws/map_reduce.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS. Use the third parameter to
   # #initialize if you need to talk to a region other than us-east-1.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class MapReduce < API
     endpoint "elasticmapreduce"

data/lib/aws/mechanical_turk.rb

@@ -14,6 +14,9 @@ module AWS
   #
   # For a more fleshed out object API for interacting with MechanicalTurk, you should
   # give rturk a try here: https://github.com/mdp/rturk
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class MechanicalTurk < API
     endpoint "mechanicalturk"

data/lib/aws/rds.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS. Use the third parameter to
   # #initialize if you need to talk to a region other than us-east-1.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class RDS < API
     endpoint "rds"

data/lib/aws/s3.rb

@@ -44,16 +44,11 @@ module AWS
   # JSON information, or an object that otherwise response to #read for file
   # uploads. This API does not build XML or JSON for you right now.
   #
-  #   s3.put "/object/name.txt", :bucket => "bucket_name", :body => {:file => File.open()}
-  #
-  # As this is a common use case, if you don't have any more parameters to send
-  # with the file being uploaded, just use :file.
-  #
-  #   s3.put "/object/name.txt", :bucket => "bucket_name", :file => File.open()
+  #   s3.put "/object/name.txt", :bucket => "bucket_name", :body => File.open()
   #
   # This API does ensure that file data is uploaded as efficiently as possible,
-  # streaming file data from disc to AWS without blowing up memory. All files are
-  # uploading using multipart/form-data.
+  # streaming file data from disc to AWS without blowing up memory. If the
+  # Content-Type header is not specified, it will be defaulted to application/octet-stream
   #
   # NOTE: Like the other parts of SimpleAWS, this API does NOT try to make the
   # AWS API better, but simply provides a cleaner, easy to use API for Ruby.
@@ -70,13 +65,52 @@ module AWS
     use_https true
     version "2006-03-01"
 
-    [:get, :post, :put, :delete, :head].each do |method|
+    ##
+    # Build a full URL for the resource at +path+.
+    # If options includes :expires, this url will be a signed url. :expires
+    # needs to be the raw Unix timestamp at which this URL will expire, as
+    # defined in the S3 documentation.
+    #
+    # Otherwise, +options+ can take anything as described above, but it
+    # will not use :headers or anything related to :body.
+    ##
+    def url_for(path, options = {})
+      request = build_request(:get, path, options)
+
+      url = "#{self.uri}#{request.path}"
+      sep = url =~ /\?/ ? "&" : "?"
+
+      if request.params.any?
+        params = request.params.map {|k, v| "#{k}=#{v}"}.join("&")
+        url += "#{sep}#{params}"
+        sep = "&"
+      end
+
+      if expires_at = options[:expires]
+        # Small hack, expires is in the Date section of the
+        # signing string, so we just do that here
+        request.headers["Date"] = expires_at.to_i
+
+        signature = "Signature=#{build_signature_for(request)}"
+        key = "AWSAccessKeyId=#{self.access_key}"
+        expires = "Expires=#{expires_at.to_i}"
+
+        url += "#{sep}#{signature}&#{key}&#{expires}"
+      end
+
+      url
+    end
+
+    [:get, :put, :delete, :head].each do |method|
       define_method(method) do |*args|
-        self.call method, *args
+        request = self.build_request method, *args
+
+        connection = AWS::Connection.new
+        connection.call finish_and_sign_request(request)
       end
     end
 
-    def call(method, path, options = {})
+    def build_request(method, path, options = {})
       if options[:bucket]
         path = path.gsub(/^\//, "/#{options[:bucket]}/")
       end
@@ -92,18 +126,34 @@ module AWS
       end
 
       if options[:file]
-        options[:body] = {:file => options[:file]}
+        options[:body] = options.delete(:file)
+      end
+
+      signing_params = {}
+      request.params.delete_if {|k, v|
+        if k =~ /^response-/i
+          signing_params[k] = v
+          true
+        end
+      }
+
+      if signing_params.length > 0
+        to_add = signing_params.map {|k, v|
+          "#{k}=#{v}"
+        }.join("&")
+
+        request.path = request.path + "?#{to_add}"
       end
 
       request.body = options[:body]
 
-      if request.body.is_a?(Hash) && request.body[:file]
-        request.headers["Content-Type"] =
-          "multipart/form-data; boundary=-----------RubyMultipartPost"
+      if request.body.respond_to?(:read)
+        request.headers["Content-Type"] ||= "application/octet-stream"
+        request.headers["Content-Length"] = File.size(request.body).to_s
+        request.headers["Expect"] = "100-continue"
       end
 
-      connection = AWS::Connection.new
-      connection.call finish_and_sign_request(request)
+      request
     end
 
     ##
@@ -123,16 +173,17 @@ module AWS
 
     ##
     # Build and sign the final request, as per the rules here:
-    # http://s3.amazonaws.com/doc/s3-developer-guide/RESTAuthentication.html
+    # http://docs.amazonwebservices.com/AmazonS3/latest/dev/RESTAuthentication.html
     ##
     def finish_and_sign_request(request)
       request.headers["Date"] = Time.now.utc.httpdate
       request.headers["Authorization"] =
-        "AWS #{self.access_key}:#{Base64.encode64(build_signature_for(request)).chomp}"
+        "AWS #{self.access_key}:#{build_signature_for(request)}"
 
       request
     end
 
+
     def build_signature_for(request)
       amazon_headers = request.headers.select {|k, v|
         k =~ /^x-amz/i
@@ -149,7 +200,9 @@ module AWS
         request.path
       ].flatten.join("\n")
 
-      OpenSSL::HMAC.digest("sha1", self.secret_key, to_sign)
+      Base64.encode64(
+        OpenSSL::HMAC.digest("sha1", self.secret_key, to_sign)
+      ).chomp
     end
 
   end

data/lib/aws/ses.rb

@@ -10,6 +10,9 @@ module AWS
   # http://docs.amazonwebservices.com/ses/latest/APIReference/
   #
   # All requests are POST and always through HTTPS.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class SES < API
     endpoint "email"

data/lib/aws/sns.rb

@@ -11,6 +11,9 @@ module AWS
   #
   # All requests are POST and always through HTTPS. Use the third parameter to
   # #initialize if you need to talk to a region other than us-east-1.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class SNS < API
     endpoint "sns"

data/lib/aws/sqs.rb

@@ -19,6 +19,9 @@ module AWS
   #
   # In accordance with the AWS documentation, SimpleAWS does not try to reconstruct
   # queue urls, use ListQueues or GetQueueUrl to get the correct queue url when needed.
+  #
+  # @see AWS::CallTypes::ActionParam Calling rules
+  # @see AWS::Response Response handling
   ##
   class SQS < API
     endpoint "sqs"

data/samples/s3.rb

@@ -51,6 +51,20 @@ puts "", "Checking that the file now exists...", ""
 
 p s3.head("/#{uploaded_file_name}", :bucket => bucket_name)
 
+puts "", "Getting file again", ""
+
+p s3.get("/#{uploaded_file_name}", :bucket => bucket_name,
+         :params => {
+           "response-content-disposition" => "attachment",
+           "response-content-type" => "text/ruby",
+           "response-expires" => "never" })
+
+puts "", "Signed, expiring URL for this resource: ", ""
+
+puts s3.url_for("/#{uploaded_file_name}", :bucket => bucket_name,
+             :expires => Time.now.to_i + 120,
+             :params => { "response-content-disposition" => "attachment" })
+
 puts "", "Deleting the file from S3", ""
 
 p s3.delete("/#{uploaded_file_name}", :bucket => bucket_name)
@@ -62,3 +76,5 @@ begin
 rescue => ex
   puts "Not found: #{ex.message}"
 end
+
+

data/simple_aws.gemspec

@@ -1,18 +1,17 @@
 Gem::Specification.new do |s|
   s.name     = "simple_aws"
-  s.version  = "0.0.1d"
+  s.version  = "1.0.0.pre1"
   s.platform = Gem::Platform::RUBY
   s.authors  = ["Jason Roelofs"]
   s.email    = ["jameskilton@gmail.com"]
 
-#  s.homepage = ""
+  s.homepage = "http://github.com/jameskilton/simple_aws"
 
   s.summary     = "The simplest and easiest to use and maintain AWS communication library"
-  s.description = "The simplest and easiest to use and maintain AWS communication library"
+  s.description = "SimpleAWS is a clean, simple, and forward compatible library for talking to Amazon's AWS APIs."
 
-  s.add_dependency "ox"
-  s.add_dependency "httparty"
-  s.add_dependency "httmultiparty"
+  s.add_dependency "nokogiri", "~> 1.5.0"
+  s.add_dependency "httparty", "~> 0.8.0"
 
   s.add_dependency "jruby-openssl" if RUBY_PLATFORM == 'java'
 

data/test/aws/core/response_test.rb

@@ -3,14 +3,19 @@ require 'aws/core/response'
 
 describe AWS::Response do
 
+  def response_stub(success = true, code = 200)
+    http_response = stub
+    http_response.stubs(:headers).returns(nil)
+    http_response.stubs(:success?).returns(success)
+    http_response.stubs(:code).returns(code)
+    http_response
+  end
+
   describe "errors" do
 
     before do
       @error_response = {}
-      @http_response = stub
-      @http_response.stubs(:headers).returns(nil)
-      @http_response.stubs(:success?).returns(false)
-      @http_response.stubs(:code).returns(401)
+      @http_response = response_stub false, 401
     end
 
     it "raises if the response is not a success" do
@@ -111,10 +116,7 @@ describe AWS::Response do
         }
       }
 
-      @http_response = stub
-      @http_response.stubs(:headers).returns(nil)
-      @http_response.stubs(:code).returns(200)
-      @http_response.stubs(:success?).returns(true)
+      @http_response = response_stub
       @http_response.stubs(:parsed_response).returns(@response_hash)
 
       @response = AWS::Response.new @http_response
@@ -170,10 +172,7 @@ describe AWS::Response do
         }
       }
 
-      @http_response = stub
-      @http_response.stubs(:headers).returns(nil)
-      @http_response.stubs(:code).returns(202)
-      @http_response.stubs(:success?).returns(true)
+      @http_response = response_stub true, 202
       @http_response.stubs(:parsed_response).returns(@response_hash)
 
       @response = AWS::Response.new @http_response
@@ -232,10 +231,7 @@ describe AWS::Response do
         }
       }
 
-      @http_response = stub
-      @http_response.stubs(:code).returns(202)
-      @http_response.stubs(:headers).returns(nil)
-      @http_response.stubs(:success?).returns(true)
+      @http_response = response_stub true, 202
       @http_response.stubs(:parsed_response).returns(@response_hash)
 
       @response = AWS::Response.new @http_response
@@ -338,12 +334,32 @@ describe AWS::Response do
 
   end
 
+  describe "raw body data" do
+
+    before do
+      @http_response = response_stub true, 200
+      @http_response.stubs(:parsed_response).returns("raw string body")
+
+      @response = AWS::Response.new @http_response
+    end
+
+    it "doesn't try to parse raw body data" do
+      @response.body.must_equal "raw string body"
+    end
+
+    it "gives a clear error message on unknown method calls" do
+      error = lambda {
+        @response.some_value
+      }.must_raise NoMethodError
+
+      error.message.must_match /AWS::Response/
+    end
+
+  end
+
   describe "#request_id" do
     before do
-      @http_response = stub
-      @http_response.stubs(:headers).returns(nil)
-      @http_response.stubs(:code).returns(200)
-      @http_response.stubs(:success?).returns(true)
+      @http_response = response_stub true, 200
     end
 
     it "finds the top level response id" do

data/test/aws/core/util_test.rb

@@ -72,14 +72,9 @@ END
         :RootNode => { :BoolVal => true, :Number => 12, :BadBool => false }
       )
 
-      response.must_equal <<END
-<?xml version="1.0" encoding="UTF-8"?>
-<RootNode>
-  <BoolVal>true</BoolVal>
-  <Number>12</Number>
-  <BadBool>false</BadBool>
-</RootNode>
-END
+      response.must_match(%r{<BoolVal>true</BoolVal>})
+      response.must_match(%r{<Number>12</Number>})
+      response.must_match(%r{<BadBool>false</BadBool>})
     end
   end
 

data/test/aws/s3_test.rb

@@ -20,9 +20,45 @@ describe AWS::S3 do
     @api.version.must_equal "2006-03-01"
   end
 
+  describe "url_for" do
+
+    it "can build an unsigned, regular URL for the requested path" do
+      url = @api.url_for("/object", :bucket => "johnson")
+      url.must_equal "https://s3.amazonaws.com/johnson/object"
+    end
+
+    it "can build a signed, expiring URL" do
+      url = @api.url_for("/object", :bucket => "johnson", :expires => Time.now.to_i + 60)
+      url.must_match %r[https://s3.amazonaws.com/johnson/object\?]
+      url.must_match %r[Expires=#{Time.now.to_i + 60}]
+      url.must_match %r[AWSAccessKeyId=key]
+      url.must_match %r[Signature=]
+    end
+
+    it "adds parameters to the path" do
+      url = @api.url_for("/object", :bucket => "johnson", :params => {"param1" => "14"})
+      url.must_equal "https://s3.amazonaws.com/johnson/object?param1=14"
+    end
+
+    it "properly handles response- parameters" do
+      url = @api.url_for("/object", :bucket => "johnson",
+                         :params => {"response-content-type" => "text/xml"})
+      url.must_equal "https://s3.amazonaws.com/johnson/object?response-content-type=text/xml"
+    end
+
+    it "combines parameters and signing params properly" do
+      url = @api.url_for("/object", :bucket => "johnson",
+                         :params => {"response-content-type" => "text/xml"},
+                         :expires => Time.now.to_i
+                        )
+      url.must_match %r{/johnson/object\?response-content-type=text/xml&Signature=}
+    end
+
+  end
+
   describe "API calls" do
 
-    [:get, :post, :put, :delete, :head].each do |method|
+    [:get, :put, :delete, :head].each do |method|
       it "supports the #{method} HTTP method" do
         AWS::Connection.any_instance.expects(:call).with do |request|
           request.method.must_equal method
@@ -54,6 +90,16 @@ describe AWS::S3 do
       @api.get "/", :params => { "Parameter1" => "Value2" }
     end
 
+    it "handles the special response- parameters" do
+      AWS::Connection.any_instance.expects(:call).with do |request|
+        request.path.must_equal "/?response-content-type=application/xml"
+        request.params["response-content-type"].must_be_nil
+        true
+      end
+
+      @api.get "/", :params => { "response-content-type" => "application/xml" }
+    end
+
     it "takes extra headers" do
       AWS::Connection.any_instance.expects(:call).with do |request|
         request.headers["Header14"].must_equal "Out to Lunch"
@@ -72,28 +118,31 @@ describe AWS::S3 do
       @api.get "/", :body => "This is a body of text"
     end
 
-    it "adds the form-data header if the body has a file in it" do
+    it "adds appropriate headers if the body has a file in it" do
+      file = File.new("Gemfile")
+
       AWS::Connection.any_instance.expects(:call).with do |request|
-        request.body.must_equal :file => "This is a body of text"
-        request.headers["Content-Type"].must_equal(
-          "multipart/form-data; boundary=-----------RubyMultipartPost"
-        )
+        request.body.must_equal file
+
+        request.headers["Content-Length"].must_equal File.size(file).to_s
+        request.headers["Content-Type"].must_equal "application/octet-stream"
+        request.headers["Expect"].must_equal "100-continue"
         true
       end
 
-      @api.get "/", :body => {:file => "This is a body of text"}
+      @api.get "/", :body => file
     end
 
-    it "allows use of :file if :body only contains a file" do
+    it "uses previously set content type if given" do
       AWS::Connection.any_instance.expects(:call).with do |request|
-        request.body.must_equal :file => "This is a body of text"
         request.headers["Content-Type"].must_equal(
-          "multipart/form-data; boundary=-----------RubyMultipartPost"
+          "application/pdf"
         )
         true
       end
 
-      @api.get "/", :file => "This is a body of text"
+      @api.get "/", :body => File.new("Gemfile"),
+        :headers => {"Content-Type" => "application/pdf"}
     end
 
     it "signs the given request according to Version 3 rules" do

metadata

@@ -1,50 +1,40 @@
 --- !ruby/object:Gem::Specification
 name: simple_aws
 version: !ruby/object:Gem::Version
-  version: 0.0.1d
-  prerelease: 5
+  version: 1.0.0.pre1
+  prerelease: 6
 platform: ruby
 authors:
 - Jason Roelofs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-09 00:00:00.000000000 Z
+date: 2012-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ox
-  requirement: &70172190923080 !ruby/object:Gem::Requirement
+  name: nokogiri
+  requirement: &70160933707720 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.5.0
   type: :runtime
   prerelease: false
-  version_requirements: *70172190923080
+  version_requirements: *70160933707720
 - !ruby/object:Gem::Dependency
   name: httparty
-  requirement: &70172190922660 !ruby/object:Gem::Requirement
+  requirement: &70160933701880 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.0
   type: :runtime
   prerelease: false
-  version_requirements: *70172190922660
-- !ruby/object:Gem::Dependency
-  name: httmultiparty
-  requirement: &70172190922220 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: *70172190922220
-description: The simplest and easiest to use and maintain AWS communication library
+  version_requirements: *70160933701880
+description: SimpleAWS is a clean, simple, and forward compatible library for talking
+  to Amazon's AWS APIs.
 email:
 - jameskilton@gmail.com
 executables: []
@@ -54,6 +44,7 @@ files:
 - .gitignore
 - .travis.yml
 - Gemfile
+- MIT_LICENCE
 - README.md
 - Rakefile
 - lib/aws/api.rb
@@ -115,7 +106,7 @@ files:
 - test/aws/sns_test.rb
 - test/aws/sqs.rb
 - test/test_helper.rb
-homepage: 
+homepage: http://github.com/jameskilton/simple_aws
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -166,3 +157,4 @@ test_files:
 - test/aws/sns_test.rb
 - test/aws/sqs.rb
 - test/test_helper.rb
+has_rdoc: