hash collections seem like a better domain mapping

lib/fog/aws/models/s3/bucket.rb

@@ -17,6 +17,10 @@ module Fog
           super
         end
 
+        def buckets
+          @buckets
+        end
+
         def delete
           connection.delete_bucket(name)
           true
@@ -50,15 +54,12 @@ module Fog
             options['LocationConstraint'] = @location
           end
           connection.put_bucket(name, options)
+          buckets[name] = self
           true
         end
 
         private
 
-        def buckets
-          @buckets
-        end
-
         def buckets=(new_buckets)
           @buckets = new_buckets
         end

lib/fog/aws/models/s3/buckets.rb

@@ -8,13 +8,19 @@ module Fog
 
       class Buckets < Fog::Collection
 
+        def [](name)
+          self[name] ||= begin
+            get(name)
+          end
+        end
+
         def all
           data = connection.get_service.body
           owner = Fog::AWS::S3::Owner.new(data.delete('Owner').merge!(:connection => connection))
           buckets = Fog::AWS::S3::Buckets.new
           data['Buckets'].each do |bucket|
             buckets << Fog::AWS::S3::Bucket.new({
-              :buckets    => self
+              :buckets    => buckets,
               :connection => connection,
               :owner      => owner
             }.merge!(bucket))
@@ -28,6 +34,40 @@ module Fog
           bucket
         end
 
+        def get(name, options = {})
+          remap_attributes(options, {
+            :is_truncated => 'IsTruncated',
+            :marker       => 'Marker',
+            :max_keys     => 'MaxKeys',
+            :prefix       => 'Prefix'
+          })
+          data = connection.get_bucket(name, options).body
+          bucket = Fog::AWS::S3::Bucket.new({
+            :connection => connection,
+            :name       => data['Name']
+          })
+          objects_data = {}
+          for key, value in data
+            if ['IsTruncated', 'Marker', 'MaxKeys', 'Prefix'].include?(key)
+              objects_data[key] = value
+            end
+          end
+          objects = Fog::AWS::S3::Objects.new({
+            :bucket       => bucket,
+            :connection   => connection
+          }.merge!(objects_data))
+          data['Contents'].each do |object|
+            owner = Fog::AWS::S3::Owner.new(object.delete('Owner').merge!(:connection => connection))
+            objects << Fog::AWS::S3::Object.new({
+              :bucket     => bucket,
+              :connection => connection,
+              :objects    => self,
+              :owner      => owner
+            }.merge!(object))
+          end
+          bucket
+        end
+
         def new(attributes = {})
           Fog::AWS::S3::Bucket.new(
             attributes.merge!(

lib/fog/aws/models/s3/object.rb

@@ -52,6 +52,7 @@ module Fog
         def save(options = {})
           data = connection.put_object(bucket.name, key, body, options)
           @etag = data.headers['ETag']
+          objects[key] = self
           true
         end
 

lib/fog/aws/models/s3/objects.rb

@@ -19,34 +19,14 @@ module Fog
           super
         end
 
+        def [](key)
+          self[key] ||= begin
+            get(key)
+          end
+        end
+
         def all(options = {})
-          remap_attributes(options, {
+          bucket.buckets.get(bucket.name, options).objects
-            :is_truncated => 'IsTruncated',
-            :marker       => 'Marker',
-            :max_keys     => 'MaxKeys',
-            :prefix       => 'Prefix'
-          })
-          data = connection.get_bucket(bucket.name, options).body
-          objects_data = {}
-          for key, value in data
-            if ['IsTruncated', 'Marker', 'MaxKeys', 'Prefix'].include?(key)
-              objects_data[key] = value
-            end
-          end
-          objects = Fog::AWS::S3::Objects.new({
-            :bucket       => bucket,
-            :connection   => connection
-          }.merge!(objects_data))
-          data['Contents'].each do |object|
-            owner = Fog::AWS::S3::Owner.new(object.delete('Owner').merge!(:connection => connection))
-            objects << Fog::AWS::S3::Object.new({
-              :bucket     => bucket,
-              :connection => connection,
-              :objects    => self,
-              :owner      => owner
-            }.merge!(object))
-          end
-          objects
         end
 
         def bucket
@@ -59,7 +39,7 @@ module Fog
           object
         end
 
-        def get
+        def get(key, options = {})
           data = connection.get_object(bucket.name, key, options)
           object_data = { :body => data.body}
           for key, value in data.headers
@@ -74,7 +54,7 @@ module Fog
           }.merge!(object_data))
         end
 
-        def head
+        def head(key, options = {})
           data = connection.head_object(bucket.name, key, options)
           object_data = {}
           for key, value in data.headers

lib/fog/collection.rb

@@ -1,5 +1,5 @@
 module Fog
-  class Collection < Array
+  class Collection < Hash
 
     def initialize(attributes = {})
       update_attributes(attributes)
@@ -11,8 +11,8 @@ module Fog
         data << " #{attribute}=#{send(attribute[1..-1].to_sym).inspect}"
       end
       data << " ["
-      for item in self
+      for key, value in self
-        data << "#{item.inspect},"
+        data << "#{value.inspect},"
       end
       data.chomp!
       data << "]>"