fog 0.0.5 → 0.0.6

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/fog.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{fog}
-  s.version = "0.0.5"
+  s.version = "0.0.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Wesley Beary"]
-  s.date = %q{2009-09-08}
+  s.date = %q{2009-09-09}
   s.description = %q{brings clouds to you}
   s.email = %q{me@geemus.com}
   s.extra_rdoc_files = [

data/lib/fog/aws/requests/s3/get_bucket.rb

@@ -34,6 +34,9 @@ unless Fog.mocking?
         #       * 'Size'<~Integer> - Size of object
         #       * 'StorageClass'<~String> - Storage class of object
         def get_bucket(bucket_name, options = {})
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
+          end
           query = ''
           for key, value in options
             query << "#{key}=#{value};"
@@ -61,6 +64,9 @@ else
 
         # FIXME: implement delimiter
         def get_bucket(bucket_name, options = {})
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
+          end
           response = Fog::Response.new
           if bucket = Fog::AWS::S3.data[:buckets][bucket_name]
             response.status = 200

data/lib/fog/aws/requests/s3/get_object.rb

@@ -23,7 +23,13 @@ unless Fog.mocking?
         #     * 'Content-Type'<~String> - MIME type of object
         #     * 'ETag'<~String> - Etag of object
         #     * 'Last-Modified'<~String> - Last modified timestamp for object
-        def get_object(bucket_name, object_name, options = {})
+        def get_object(bucket_name, object_name, options = {}, &block)
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
+          end
+          unless object_name
+            raise ArgumentError.new('object_name is required')
+          end
           headers = {}
           headers['If-Modified-Since'] = options['If-Modified-Since'].utc.strftime("%a, %d %b %Y %H:%M:%S +0000") if options['If-Modified-Since']
           headers['If-Unmodified-Since'] = options['If-Unmodified-Since'].utc.strftime("%a, %d %b %Y %H:%M:%S +0000") if options['If-Modified-Since']
@@ -33,7 +39,8 @@ unless Fog.mocking?
             :headers  => headers,
             :host     => "#{bucket_name}.#{@host}",
             :method   => 'GET',
-            :path     => object_name
+            :path     => object_name,
+            :block    => block
           })
         end
 
@@ -48,6 +55,12 @@ else
       class S3
 
         def get_object(bucket_name, object_name, options = {})
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
+          end
+          unless object_name
+            raise ArgumentError.new('object_name is required')
+          end
           response = Fog::Response.new
           if (bucket = Fog::AWS::S3.data[:buckets][bucket_name]) && (object = bucket[:objects][object_name])
             if options['If-Match'] && options['If-Match'] != object['ETag']

data/lib/fog/aws/requests/s3/put_object.rb

@@ -9,7 +9,7 @@ unless Fog.mocking?
         # ==== Parameters
         # * bucket_name<~String> - Name of bucket to create object in
         # * object_name<~String> - Name of object to create
-        # * object<~String> - File to create object from
+        # * data<~File> - File or String to create object from
         # * options<~Hash>:
         #   * 'Cache-Control'<~String> - Caching behaviour
         #   * 'Content-Disposition'<~String> - Presentational information for the object
@@ -24,11 +24,11 @@ unless Fog.mocking?
         # * response<~Fog::AWS::Response>:
         #   * headers<~Hash>:
         #     * 'ETag'<~String> - etag of new object
-        def put_object(bucket_name, object_name, object, options = {})
-          file = parse_file(object)
-          headers = file[:headers].merge!(options)
+        def put_object(bucket_name, object_name, data, options = {})
+          data = parse_data(data)
+          headers = data[:headers].merge!(options)
           request({
-            :body     => file[:body],
+            :body     => data[:body],
             :expects  => 200,
             :headers  => headers,
             :host     => "#{bucket_name}.#{@host}",
@@ -47,21 +47,21 @@ else
     module AWS
       class S3
 
-        def put_object(bucket_name, object_name, object, options = {})
-          file = parse_file(object)
+        def put_object(bucket_name, object_name, data, options = {})
+          data = parse_data(data)
           response = Fog::Response.new
           if (bucket = Fog::AWS::S3.data[:buckets][bucket_name])
             response.status = 200
             bucket[:objects][object_name] = {
-              :body           => file[:body],
-              'Content-Type'  => file[:headers]['Content-Type'],
+              :body           => data[:body],
               'ETag'          => Fog::AWS::Mock.etag,
               'Key'           => object_name,
               'LastModified'  => Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S +0000"),
               'Owner'         => { 'DisplayName' => 'owner', 'ID' => 'some_id'},
-              'Size'          => file[:headers]['Content-Length'],
+              'Size'          => data[:headers]['Content-Length'],
               'StorageClass'  => 'STANDARD'
             }
+            bucket[:objects][object_name]['Content-Type'] = data[:headers]['Content-Type']
           else
             response.status = 404
             raise(Fog::Errors.status_error(200, 404, response))

data/lib/fog/aws/requests/simpledb/batch_put_attributes.rb

@@ -41,14 +41,15 @@ else
         def batch_put_attributes(domain_name, items, replace_attributes = Hash.new([]))
           response = Fog::Response.new
           if Fog::AWS::SimpleDB.data[:domains][domain_name]
-            for key, value in items do
-              for item in value do
-                if replace_attributes[key] && replace_attributes[key].include?(value)
-                  Fog::AWS::SimpleDB.data[:domains][domain_name][key] = []
+            for item_name, attributes in items do
+              for key, value in attributes do
+                Fog::AWS::SimpleDB.data[:domains][domain_name][item_name] ||= {}
+                if replace_attributes[item_name] && replace_attributes[item_name].include?(key)
+                  Fog::AWS::SimpleDB.data[:domains][domain_name][item_name][key.to_s] = []
                 else
-                  Fog::AWS::SimpleDB.data[:domains][domain_name][key] ||= []
+                  Fog::AWS::SimpleDB.data[:domains][domain_name][item_name][key.to_s] ||= []
                 end
-                Fog::AWS::SimpleDB.data[:domains][domain_name][key] << value.to_s
+                Fog::AWS::SimpleDB.data[:domains][domain_name][item_name][key.to_s] << value.to_s
               end
             end
             response.status = 200

data/lib/fog/aws/requests/simpledb/create_domain.rb

@@ -34,7 +34,7 @@ else
 
         def create_domain(domain_name)
           response = Fog::Response.new
-          Fog::AWS::SimpleDB.data[:domains][domain_name] = { :attributes => {} }
+          Fog::AWS::SimpleDB.data[:domains][domain_name] = {}
           response.status = 200
           response.body = {
             'BoxUsage'  => Fog::AWS::Mock.box_usage,

data/lib/fog/aws/requests/simpledb/delete_attributes.rb

@@ -1,34 +1,72 @@
-module Fog
-  module AWS
-    class SimpleDB
-
-      # List metadata for SimpleDB domain
-      #
-      # ==== Parameters
-      # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
-      #   following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
-      # * item_name<~String> - Name of the item.  May use any UTF-8 characters valid
-      #   in xml.  Control characters and sequences not allowed in xml are not
-      #   valid.  Can be up to 1024 bytes long.
-      # * attributes<~Hash> - Name/value pairs to remove from the item.  Defaults to
-      #   nil, which will delete the entire item. Attribute names and values may
-      #   use any UTF-8 characters valid in xml. Control characters and sequences
-      #   not allowed in xml are not valid.  Each name and value can be up to 1024
-      #   bytes long.
-      #
-      # ==== Returns
-      # * response<~Fog::AWS::Response>:
-      #   * body<~Hash>:
-      #     * 'BoxUsage'
-      #     * 'RequestId'
-      def delete_attributes(domain_name, item_name, attributes = nil)
-        request({
-          'Action' => 'DeleteAttributes',
-          'DomainName' => domain_name,
-          'ItemName' => item_name
-        }.merge!(encode_attributes(attributes)), Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string))
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        # List metadata for SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
+        #   following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # * item_name<~String> - Name of the item.  May use any UTF-8 characters valid
+        #   in xml.  Control characters and sequences not allowed in xml are not
+        #   valid.  Can be up to 1024 bytes long.
+        # * attributes<~Hash> - Name/value pairs to remove from the item.  Defaults to
+        #   nil, which will delete the entire item. Attribute names and values may
+        #   use any UTF-8 characters valid in xml. Control characters and sequences
+        #   not allowed in xml are not valid.  Each name and value can be up to 1024
+        #   bytes long.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def delete_attributes(domain_name, item_name, attributes = nil)
+          request({
+            'Action' => 'DeleteAttributes',
+            'DomainName' => domain_name,
+            'ItemName' => item_name
+          }.merge!(encode_attributes(attributes)), Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string))
+        end
+
       end
+    end
+  end
 
+else
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        def delete_attributes(domain_name, item_name, attributes = nil)
+          response = Fog::Response.new
+          if Fog::AWS::SimpleDB.data[:domains][domain_name]
+            if attributes
+              for key, value in attributes
+                if Fog::AWS::SimpleDB.data[:domains][domain_name][key]
+                  Fog::AWS::SimpleDB.data[:domains][domain_name][key].delete('value')
+                end
+              end
+            else
+              Fog::AWS::SimpleDB.data[:domains].delete(domain_name)
+            end
+            response.status = 200
+            response.body = {
+              'BoxUsage'  => Fog::AWS::Mock.box_usage,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
     end
   end
-end
+
+end

data/lib/fog/aws/requests/simpledb/domain_metadata.rb

@@ -1,30 +1,80 @@
-module Fog
-  module AWS
-    class SimpleDB
-
-      # List metadata for SimpleDB domain
-      #
-      # ==== Parameters
-      # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
-      # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
-      #
-      # ==== Returns
-      # * response<~Fog::AWS::Response>:
-      #   * body<~Hash>:
-      #     * 'AttributeNameCount' - number of unique attribute names in domain
-      #     * 'AttributeNamesSizeBytes' - total size of unique attribute names, in bytes
-      #     * 'AttributeValueCount' - number of all name/value pairs in domain
-      #     * 'AttributeValuesSizeBytes' - total size of attributes, in bytes
-      #     * 'ItemCount' - number of items in domain
-      #     * 'ItemNameSizeBytes' - total size of item names in domain, in bytes
-      #     * 'Timestamp' - last update time for metadata.
-      def domain_metadata(domain_name)
-        request({
-          'Action' => 'DomainMetadata',
-          'DomainName' => domain_name
-        }, Fog::Parsers::AWS::SimpleDB::DomainMetadata.new(@nil_string))
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        # List metadata for SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
+        # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'AttributeNameCount' - number of unique attribute names in domain
+        #     * 'AttributeNamesSizeBytes' - total size of unique attribute names, in bytes
+        #     * 'AttributeValueCount' - number of all name/value pairs in domain
+        #     * 'AttributeValuesSizeBytes' - total size of attributes, in bytes
+        #     * 'BoxUsage'
+        #     * 'ItemCount' - number of items in domain
+        #     * 'ItemNameSizeBytes' - total size of item names in domain, in bytes
+        #     * 'RequestId'
+        #     * 'Timestamp' - last update time for metadata.
+        def domain_metadata(domain_name)
+          request({
+            'Action' => 'DomainMetadata',
+            'DomainName' => domain_name
+          }, Fog::Parsers::AWS::SimpleDB::DomainMetadata.new(@nil_string))
+        end
+
       end
+    end
+  end
 
+else
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        def domain_metadata(domain_name)
+          response = Fog::Response.new
+          if domain = Fog::AWS::SimpleDB.data[:domains][domain_name]
+            response.status = 200
+            
+            attribute_names = []
+            attribute_values = []
+            for item in domain.values
+              for key, values in item
+                attribute_names << key
+                for value in values
+                  attribute_values << value
+                end
+              end
+            end
+            
+            response.body = {
+              'AttributeNameCount'        => attribute_names.length,
+              'AttributeNamesSizeBytes'   => attribute_names.join('').length,
+              'AttributeValueCount'       => attribute_values.length,
+              'AttributeValuesSizeBytes'  => attribute_values.join('').length,
+              'BoxUsage'                  => Fog::AWS::Mock.box_usage,
+              'ItemCount'                 => domain.keys.length,
+              'ItemNamesSizeBytes'        => domain.keys.join('').length,
+              'RequestId'                 => Fog::AWS::Mock.request_id,
+              'Timestamp'                 => Time.now
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
     end
   end
+
 end

data/lib/fog/aws/requests/simpledb/get_attributes.rb

@@ -1,35 +1,75 @@
-module Fog
-  module AWS
-    class SimpleDB
-
-      # List metadata for SimpleDB domain
-      #
-      # ==== Parameters
-      # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
-      #   following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
-      # * item_name<~String> - Name of the item.  May use any UTF-8 characters valid
-      #   in xml.  Control characters and sequences not allowed in xml are not
-      #   valid.  Can be up to 1024 bytes long.
-      # * attributes<~Hash> - Name/value pairs to return from the item.  Defaults to
-      #   nil, which will return all attributes. Attribute names and values may use
-      #   any UTF-8 characters valid in xml. Control characters and sequences not 
-      #   allowed in xml are not valid.  Each name and value can be up to 1024
-      #   bytes long.
-      #
-      # ==== Returns
-      # * response<~Fog::AWS::Response>:
-      #   * body<~Hash>:
-      #     * 'Attributes' - list of attribute name/values for the item
-      #     * 'BoxUsage'
-      #     * 'RequestId'
-      def get_attributes(domain_name, item_name, attributes = nil)
-        request({
-          'Action' => 'GetAttributes',
-          'DomainName' => domain_name,
-          'ItemName' => item_name,
-        }.merge!(encode_attribute_names(attributes)), Fog::Parsers::AWS::SimpleDB::GetAttributes.new(@nil_string))
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        # List metadata for SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
+        #   following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # * item_name<~String> - Name of the item.  May use any UTF-8 characters valid
+        #   in xml.  Control characters and sequences not allowed in xml are not
+        #   valid.  Can be up to 1024 bytes long.
+        # * attributes<~Array> - Attributes to return from the item.  Defaults to
+        #   nil, which will return all attributes. Attribute names and values may use
+        #   any UTF-8 characters valid in xml. Control characters and sequences not 
+        #   allowed in xml are not valid.  Each name and value can be up to 1024
+        #   bytes long.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'Attributes' - list of attribute name/values for the item
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def get_attributes(domain_name, item_name, attributes = nil)
+          request({
+            'Action' => 'GetAttributes',
+            'DomainName' => domain_name,
+            'ItemName' => item_name,
+          }.merge!(encode_attribute_names(attributes)), Fog::Parsers::AWS::SimpleDB::GetAttributes.new(@nil_string))
+        end
+
       end
+    end
+  end
 
+else
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        def get_attributes(domain_name, item_name, attributes = nil)
+          response = Fog::Response.new
+          if Fog::AWS::SimpleDB.data[:domains][domain_name]
+            object = {}
+            if attributes
+              for attribute in attributes
+                if Fog::AWS::SimpleDB.data[:domains][domain_name][item_name] && Fog::AWS::SimpleDB.data[:domains][domain_name][item_name]
+                  object[attribute] = Fog::AWS::SimpleDB.data[:domains][domain_name][item_name][attribute]
+                end
+              end
+            elsif Fog::AWS::SimpleDB.data[:domains][domain_name][item_name]
+              object = Fog::AWS::SimpleDB.data[:domains][domain_name][item_name]
+            end
+            response.status = 200
+            response.body = {
+              'Attributes'  => object,
+              'BoxUsage'    => Fog::AWS::Mock.box_usage,
+              'RequestId'   => Fog::AWS::Mock.request_id
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
     end
   end
+
 end

data/lib/fog/aws/requests/simpledb/put_attributes.rb

@@ -1,29 +1,47 @@
-module Fog
-  module AWS
-    class SimpleDB
-
-      # Put item attributes into a SimpleDB domain
-      #
-      # ==== Parameters
-      # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
-      # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
-      # * item_name<~String> - Name of the item.  May use any UTF-8 characters valid
-      #   in xml.  Control characters and sequences not allowed in xml are not
-      #   valid.  Can be up to 1024 bytes long.
-      # * attributes<~Hash> - Name/value pairs to add to the item.  Attribute names
-      #   and values may use any UTF-8 characters valid in xml. Control characters
-      #   and sequences not allowed in xml are not valid.  Each name and value can
-      #   be up to 1024 bytes long.
-      #
-      # ==== Returns
-      # * response<~Fog::AWS::Response>:
-      #   * body<~Hash>:
-      #     * 'BoxUsage'
-      #     * 'RequestId'
-      def put_attributes(domain_name, item_name, attributes, replace_attributes = [])
-        batch_put_attributes(domain_name, { item_name => attributes }, { item_name => replace_attributes })
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        # Put item attributes into a SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
+        # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # * item_name<~String> - Name of the item.  May use any UTF-8 characters valid
+        #   in xml.  Control characters and sequences not allowed in xml are not
+        #   valid.  Can be up to 1024 bytes long.
+        # * attributes<~Hash> - Name/value pairs to add to the item.  Attribute names
+        #   and values may use any UTF-8 characters valid in xml. Control characters
+        #   and sequences not allowed in xml are not valid.  Each name and value can
+        #   be up to 1024 bytes long.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def put_attributes(domain_name, item_name, attributes, replace_attributes = [])
+          batch_put_attributes(domain_name, { item_name => attributes }, { item_name => replace_attributes })
+        end
+
       end
+    end
+  end
 
+else
+
+  module Fog
+    module AWS
+      class SimpleDb
+
+        def put_attributes(domain_name, item_name, attributes, replace_attributes = [])
+          batch_put_attributes(domain_name, { item_name => attributes }, { item_name => replace_attributes })
+        end
+
+      end
     end
   end
+
 end

data/lib/fog/aws/s3.rb

@@ -81,20 +81,24 @@ module Fog
 
       private
 
-      def parse_file(file)
+      def parse_data(data)
         metadata = {
           :body => nil,
           :headers => {}
         }
 
-        filename = File.basename(file.path)
-        unless (mime_types = MIME::Types.of(filename)).empty?
-          metadata[:headers]['Content-Type'] = mime_types.first.content_type
+        if data.is_a?(String)
+          metadata[:body] = data
+          metadata[:headers]['Content-Length'] = metadata[:body].size.to_s
+        else
+          filename = File.basename(data.path)
+          unless (mime_types = MIME::Types.of(filename)).empty?
+            metadata[:headers]['Content-Type'] = mime_types.first.content_type
+          end
+          metadata[:body] = data.read
+          metadata[:headers]['Content-Length'] = File.size(data.path)
         end
-
-        metadata[:body] = file.read
-        metadata[:headers]['Content-Length'] = metadata[:body].size.to_s
-        metadata[:headers]['Content-MD5'] = Base64.encode64(Digest::MD5.digest(metadata[:body])).strip
+        # metadata[:headers]['Content-MD5'] = Base64.encode64(Digest::MD5.digest(metadata[:body])).strip
         metadata
       end
 
@@ -137,6 +141,7 @@ DATA
         params[:headers]['Authorization'] = "AWS #{@aws_access_key_id}:#{signature}"
 
         response = @connection.request({
+          :block    => params[:block],
           :body     => params[:body],
           :expects  => params[:expects],
           :headers  => params[:headers],

data/lib/fog/connection.rb

@@ -34,15 +34,26 @@ unless Fog.mocking?
         request = "#{params[:method]} #{params[:path]} HTTP/1.1\r\n"
         params[:headers] ||= {}
         params[:headers]['Host'] = params[:host]
-        if params[:body]
+        if params[:body] && !params[:headers]['Content-Length']
           params[:headers]['Content-Length'] = params[:body].length
         end
         for key, value in params[:headers]
           request << "#{key}: #{value}\r\n"
         end
-        request << "\r\n#{params[:body]}"
+        request << "\r\n"
         @connection.write(request)
 
+        if params[:body]
+          if params[:body].is_a?(String)
+            body = StringIO.new(params[:body])
+          else
+            body = params[:body]
+          end
+          while chunk = body.read(1048576) # 1 megabyte
+            @connection.write(chunk)
+          end
+        end
+
         response = Fog::Response.new
         response.request = params
         response.status = @connection.readline[9..11].to_i
@@ -65,19 +76,30 @@ unless Fog.mocking?
             parser = params[:parser]
           end
           body = Nokogiri::XML::SAX::PushParser.new(parser)
+        elsif params[:block]
+          body = nil
         else
           body = ''
         end
 
         unless params[:method] == 'HEAD'
           if response.headers['Content-Length']
-            body << @connection.read(response.headers['Content-Length'].to_i)
+            content = @connection.read(response.headers['Content-Length'].to_i)
+            unless params[:block]
+              body << content
+            else
+              params[:block].call(content)
+            end
           elsif response.headers['Transfer-Encoding'] == 'chunked'
             while true
               # 2 == "/r/n".length
               chunk_size = @connection.readline.chomp!.to_i(16) + 2
-              chunk = @connection.read(chunk_size)
-              body << chunk[0...-2]
+              chunk = @connection.read(chunk_size)[0...-2]
+              unless params[:block]
+                body << chunk
+              else
+                params[:block].call(chunk)
+              end
               if chunk_size == 2
                 break
               end

data/spec/aws/requests/s3/get_object_spec.rb

@@ -26,6 +26,15 @@ describe 'S3.get_object' do
       actual.headers['Last-Modified'].should be_a(String)
     end
 
+    it 'should return chunks with optional block' do
+      file = File.open(File.dirname(__FILE__) + '/../../../lorem.txt', 'r')
+      data = ''
+      s3.get_object('foggetobject', 'fog_get_object') do |chunk|
+        data << chunk
+      end
+      data.should == file.read
+    end
+
   end
   describe 'failure' do
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fog
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Wesley Beary
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-08 00:00:00 -07:00
+date: 2009-09-09 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency