raws 0.0.10 → 0.0.11

data/lib/raws/s3/adapter.rb

@@ -98,10 +98,8 @@ class RAWS::S3::Adapter
         request.header.merge! header
         response = request.send(
           if location
-            "<CreateBucketConfiguration>"
-              "<LocationConstraint>#{
-                location
-              }</LocationConstraint>"
+            "<CreateBucketConfiguration>" <<
+              "<LocationConstraint>#{location}</LocationConstraint>" <<
             "</CreateBucketConfiguration>"
           end
         )
@@ -117,20 +115,20 @@ class RAWS::S3::Adapter
         :query  => {'requestPayment' => nil}
       ) do |request|
         response = request.send\
-          '<RequestPaymentConfiguration'
-            ' xmlns="http://s3.amazonaws.com/doc/2006-03-01/">'
-            "<Payer>#{requester}</Payer>"
+          '<RequestPaymentConfiguration' <<
+            ' xmlns="http://s3.amazonaws.com/doc/2006-03-01/">' <<
+            "<Payer>#{requester}</Payer>" <<
           '</RequestPaymentConfiguration>'
         response.receive
         response
       end
     end
 
-    def get_bucket(bucket_name, params={})
+    def get_bucket(bucket_name, query={})
       connect(
         'GET', 
         :bucket => bucket_name,
-        :query  => params
+        :query  => query
       ) do |request|
         response = request.send
         response.parse :multiple => ['Contents']
@@ -162,40 +160,66 @@ class RAWS::S3::Adapter
       end
     end
 
+    def get_acl(bucket_name, key)
+      connect(
+        'GET', 
+        :bucket => bucket_name,
+        :path   => "/#{key}",
+        :query  => {'acl' => nil}
+      ) do |request|
+        response = request.send
+        response.parse :multiple => ['Grant']
+        response
+      end
+    end
+
+    def put_acl(bucket_name, key, acl)
+      connect(
+        'PUT', 
+        :bucket => bucket_name,
+        :path   => "/#{key}",
+        :query  => {'acl' => nil}
+      ) do |request|
+        response = request.send acl
+        response.parse :multiple => ['Grant']
+        response
+      end
+    end
+
     def delete_bucket(bucket_name)
       connect 'DELETE', :bucket => bucket_name do |request|
         request.send
       end
     end
 
-    def put_object(bucket_name, name, header, &block)
+    def put_object(bucket_name, key, header, &block)
       connect(
         'PUT',
         :bucket => bucket_name,
-        :path   => '/' << name
+        :path   => '/' << key
       ) do |request|
         request.header.merge!(header)
         block.call(request)
       end
     end
 
-    def copy_object(src_bucket, src_name, dest_bucket, dest_name, header={})
+    def copy_object(src_bucket, src_key, dest_bucket, dest_key, header={})
       connect(
         'PUT',
         :bucket => dest_bucket,
-        :path   => '/' << dest_name
+        :path   => '/' << dest_key
       ) do |request|
         request.header.merge! header
-        request.header['x-amz-copy-source'] = "/#{src_bucket}/#{src_name}"
+        request.header['x-amz-copy-source'] = "/#{src_bucket}/#{src_key}"
         request.send
       end
     end
 
-    def get_object(bucket_name, name=nil, header={}, &block)
+    def get_object(bucket_name, key=nil, header={}, &block)
       connect(
         'GET',
         :bucket => bucket_name,
-        :path   => "/#{name}"
+        :path   => "/#{key}"
       ) do |request|
         request.header.merge! header
         if block_given?
@@ -208,11 +232,11 @@ class RAWS::S3::Adapter
       end
     end
 
-    def head_object(bucket_name, name)
+    def head_object(bucket_name, key)
       connect(
         'HEAD',
         :bucket => bucket_name,
-        :path   => '/' << name
+        :path   => '/' << key
       ) do |request|
         response = request.send
         response.receive
@@ -220,11 +244,11 @@ class RAWS::S3::Adapter
       end
     end
 
-    def delete_object(bucket_name, name)
+    def delete_object(bucket_name, key)
       connect(
         'DELETE',
         :bucket => bucket_name,
-        :path   => '/' << name
+        :path   => '/' << key
       ) do |request|
         response = request.send
         response.receive

data/lib/raws/s3/metadata.rb

@@ -1,11 +1,17 @@
 class RAWS::S3::Metadata < Hash
   X_AMZ_META = 'x-amz-meta-'
 
-  def initialize(header={})
+  def initialize(header)
     super()
+    @header = header
     decode(header)
   end
 
+  def reload
+    @header.reload
+    decode(@header)
+  end
+
   def decode(header)
     clear
     header.select do |key, val|
@@ -27,10 +33,10 @@ class RAWS::S3::Metadata < Hash
 
       if val.is_a? Array
         ret[key] = val.map do |v|
-          RAWS.escape(v.strip)
+          RAWS.escape v
         end.join(',')
       else
-        ret[key] = RAWS.escape(val.strip)
+        ret[key] = RAWS.escape val
       end
 
       ret

data/lib/raws/s3/model.rb

@@ -1,32 +1,53 @@
+require 'forwardable'
+
 module RAWS::S3::Model
   module ClassMethods
+    include Enumerable
+    extend Forwardable
+    def_delegators :bucket,
+      :create_bucket,
+      :delete_bucket,
+      :owner,
+      :location,
+      :acl,
+      :put_object,
+      :put,
+      :copy_object,
+      :copy,
+      :get_object,
+      :get,
+      :delete_object,
+      :delete
+
     attr_accessor :bucket_name
 
-    def create_bucket
-      RAWS::S3.create_bucket(self.bucket_name)
+    def head_object(key)
+      begin
+        bucket.head_object(key).header
+      rescue => e
+        if e.response.code == 404
+          {}
+        else
+          raise e
+        end
+      end
     end
+    alias :head :head_object
 
-    def delete_bucket(force=nil)
-      RAWS::S3.delete_bucket(self.bucket_name, force)
+    def bucket
+      RAWS::S3[bucket_name]
     end
 
     def filter(query={})
-      RAWS::S3.filter(self.bucket_name, query).map do |val|
-        self.new(val['Key'])
+      bucket.filter(query).map do |contents|
+        self.new(contents['Key'])
       end
     end
     alias :all :filter
+    alias :each :filter
 
-    def find(key, header={})
-      begin
-        self.new(key, RAWS::S3.head(self.bucket_name, key).header)
-      rescue RAWS::HTTP::Error => e
-        if e.response.code == 404
-          nil
-        else
-          raise e
-        end
-      end
+    def find(key)
+      self.new key, head(key)
     end
   end
 
@@ -34,59 +55,64 @@ module RAWS::S3::Model
     attr_reader :key
 
     def initialize(key, header=nil)
-      @key, @header = key, header
-      @metadata = RAWS::S3::Metadata.new(header || {})
+      @key, @header, @metadata = key, header, nil
       after_initialize
     end
 
     def header
-      begin
-        @header = RAWS::S3.head(self.class.bucket_name, @key).header
-      rescue RAWS::HTTP::Error => e
-        if e.response.code == 404
-          {}
-        else
-          raise e
-        end
-      end
+      @header ||= self.class.head(@key)
     end
 
     def metadata
-      @header ? @metadata : @metadata.decode(header)
+      @metadata ||= RAWS::S3::Metadata.new header
     end
 
-    def receive(header={}, &block)
-      RAWS::S3.get(
-        self.class.bucket_name,
-        @key,
-        header
-      ) do |request|
-        response = request.send
-        response.receive(&block)
-        @metadata.decode(response.header)
-        response
-      end
+    def acl
+      self.class.acl @key
+    end
+
+    def delete
+      before_delete
+      response = self.class.delete_object @key
+      after_delete response
     end
 
     def send(header={}, &block)
-      RAWS::S3.put(
-        self.class.bucket_name,
+      before_send
+      if @header
+        @header.merge! header
+      else
+        @header = header
+      end
+      response = self.class.put_object(
         @key,
-        @metadata.encode.merge!(header)
+        @header.merge(metadata.encode)
       ) do |request|
-        request.send(&block)
+        request.send &block
+      end
+      after_send response
+    end
+
+    def receive(header={}, &block)
+      before_receive
+      ret = self.class.get_object(@key, header) do |request|
+        response = request.send
+        @header  = response.header
+        metadata.decode @header
+        response.receive &block
+        response
       end
+      after_send ret
+      ret
     end
 
     def after_initialize; end
     def before_delete; end
-    def after_delete; end
-    def before_save; end
-    def after_save; end
-    def before_update; end
-    def after_update; end
-    def before_insert; end
-    def after_insert; end
+    def after_delete(response); end
+    def before_receive; end
+    def after_receive(response); end
+    def before_send; end
+    def after_send(response); end
   end
 
   def self.included(mod)

data/lib/raws/s3/owner.rb

@@ -0,0 +1,8 @@
+class RAWS::S3::Owner
+  attr_reader :id, :display_name
+  alias :name :display_name
+
+  def initialize(owner)
+    @id, @display_name = owner['ID'], owner['DisplayName']
+  end
+end

data/lib/raws/sdb.rb

@@ -12,81 +12,87 @@ class RAWS::SDB
       @http ||= RAWS.http
     end
 
+    # Creates a new domain and returns the instance of RAWS:SDB.
     def create_domain(domain_name)
       Adapter.create_domain(domain_name)
+      self[domain_name]
     end
 
+    # Deletes the domain.
     def delete_domain(domain_name)
       Adapter.delete_domain(domain_name)
     end
 
-    def metadata(domain_name)
-      doc = Adapter.domain_metadata(domain_name)
-      doc['DomainMetadataResponse']['DomainMetadataResult']
+    # Returns the domain metadata.
+    def domain_metadata(domain_name)
+      Adapter.domain_metadata(domain_name)\
+        ['DomainMetadataResponse']['DomainMetadataResult']
     end
 
-    def list(next_token=nil, max_num=nil)
-      doc = Adapter.list_domains(next_token, max_num)
-      doc['ListDomainsResponse']['ListDomainsResult']
-    end
+    def list_domains(params={})
+      doc = Adapter.list_domains(params)\
+        ['ListDomainsResponse']['ListDomainsResult']
 
-    def domains(next_token=nil, max_num=nil)
-      data = list(next_token, max_num)
       {
-        'Domains' => (data['DomainName'] || []).map do |val|
-          self.new(val)
-        end,
-        'NextToken' => data['NextToken']
+        'Domains' => (doc ? doc['DomainName'] : []).map do |v| self.new(v) end,
+        'NextToken' => doc && doc['NextToken']
       }
     end
 
-    def each(&block)
+    def each(params={}, &block)
       next_token = nil
       begin
-        data = domains(next_token)
+        data = list_domains(params.merge('NextToken' => next_token))
         data['Domains'].each(&block)
       end while next_token = data['NextToken']
     end
 
+    def domains(&block)
+      if block_given?
+        each(&block)
+      else
+        map
+      end
+    end
+
+    # Returns the instance of RAWS::SDB.
     def [](domain_name)
-      @cache ||= {}
-      @cache[domain_name] ||= self.new(domain_name)
+      self.new domain_name
     end
 
-    def select(expr, params=[], next_token=nil, &block)
+    def select(expr, params=[], &block)
+      next_token = nil
       begin
-        data = Adapter.select(
-          expr,
-          params,
-          next_token
-        )['SelectResponse']['SelectResult']
-
-        data['Item'].each do |val|
-          block.call([val['Name'], val['Attribute']])
-        end if data.key? 'Item'
-      end while next_token = data['NextToken']
+        ret = Adapter.select(expr, params, next_token)\
+          ['SelectResponse']['SelectResult']
+        ret['Item'].each do |val|
+          block.call [val['Name'], val['Attribute']]
+        end if ret
+      end while ret && next_token = ret['NextToken']
     end
     alias :all :select
 
-    def get(domain_name, item_name, *attrs)
-      Adapter.get_attributes(
-        domain_name,
-        item_name,
-        *attrs
-      )['GetAttributesResponse']['GetAttributesResult']['Attribute']
+    def get_attributes(domain_name, item_name, *attrs)
+      doc = Adapter.get_attributes(domain_name, item_name, *attrs)\
+        ['GetAttributesResponse']['GetAttributesResult']
+      doc && doc['Attribute']
     end
+    alias :get :get_attributes
 
-    def put(domain_name, item_name, attrs={}, *replaces)
-      Adapter.put_attributes(domain_name, item_name, attrs, *replaces)
+    def put_attributes(domain_name, item_name, attrs={}, *replaces)
+      Adapter.put_attributes domain_name, item_name, attrs, *replaces
     end
+    alias :put :put_attributes
 
-    def batch_put(domain_name, items={}, replaces={})
-      Adapter.batch_put_attributes(domain_name, items, replaces)
+    def batch_put_attributes(domain_name, items={}, replaces={})
+      Adapter.batch_put_attributes domain_name, items, replaces
     end
+    alias :batch_put :batch_put_attributes
 
-    def delete(domain_name, item_name, attrs={})
-      Adapter.delete_attributes(domain_name, item_name, attrs)
+    def delete_attributes(domain_name, item_name, attrs={})
+      Adapter.delete_attributes domain_name, item_name, attrs
     end
+    alias :delete :delete_attributes
   end
 
   attr_reader :domain_name
@@ -103,30 +109,35 @@ class RAWS::SDB
     self.class.delete_domain(domain_name)
   end
 
-  def metadata
-    self.class.metadata(domain_name)
+  def domain_metadata
+    self.class.domain_metadata(domain_name)
   end
+  alias :metadata :domain_metadata
 
   def select(output_list='*', &block)
     Select.new.columns(output_list).from(domain_name, &block)
   end
   alias :all :select
 
-  def get(item_name, *attrs)
-    self.class.get(domain_name, item_name, *attrs)
+  def get_attributes(item_name, *attrs)
+    self.class.get_attributes domain_name, item_name, *attrs
   end
+  alias :get :get_attributes
 
-  def put(item_name, attrs={}, *replaces)
-    self.class.put(domain_name, item_name, attrs, *replaces)
+  def put_attributes(item_name, attrs, *replaces)
+    self.class.put_attributes domain_name, item_name, attrs, *replaces
   end
+  alias :put :put_attributes
 
-  def batch_put(items={}, replaces={})
-    self.class.batch_put(domain_name, items, replaces)
+  def batch_put_attributes(items, replaces={})
+    self.class.batch_put_attributes domain_name, items, replaces
   end
+  alias :batch_put :batch_put_attributes
 
-  def delete(item_name, attrs={})
-    self.class.delete(domain_name, item_name, attrs)
+  def delete_attributes(item_name, attrs={})
+    self.class.delete_attributes domain_name, item_name, attrs
   end
+  alias :delete :delete_attributes
 
   def <=>(a)
     domain_name <=> a.domain_name