fmalamitsas-aws-s3 0.6.2.1254423625

data/lib/aws/s3/owner.rb

@@ -0,0 +1,46 @@
+module AWS
+  module S3
+    # Entities in S3 have an associated owner (the person who created them). The owner is a canonical representation of an 
+    # entity in the S3 system. It has an <tt>id</tt> and a <tt>display_name</tt>. 
+    # 
+    # These attributes can be used when specifying a ACL::Grantee for an ACL::Grant.
+    #
+    # You can retrieve the owner of the current account by calling Owner.current.
+    class Owner
+      undef_method :id if method_defined?(:id) # Get rid of Object#id
+      include SelectiveAttributeProxy
+      
+      class << self
+        # The owner of the current account.
+        def current
+          response = Service.get('/')
+          # new(response.parsed['owner']) if response.parsed['owner']
+          #TODO: This is a pretty hackish way to get the current account owner.
+          response.parsed['contents'][0]['owner'] if (response.parsed['contents'] && response.parsed['contents'][0])
+        end
+        memoized :current
+      end
+      
+      def initialize(attributes = {}) #:nodoc:
+        @attributes = attributes
+      end
+      
+      def ==(other_owner) #:nodoc:
+        hash == other_owner.hash
+      end
+      
+      def hash #:nodoc
+        [id, display_name].join.hash
+      end
+      
+      private
+        def proxiable_attribute?(name)
+          valid_attributes.include?(name)
+        end
+        
+        def valid_attributes
+          %w(id display_name)
+        end
+    end
+  end
+end

data/lib/aws/s3/parsing.rb

@@ -0,0 +1,99 @@
+#:stopdoc:
+module AWS
+  module S3
+    module Parsing
+      class << self
+        def parser=(parsing_library)
+          XmlParser.parsing_library = parsing_library
+        end
+        
+        def parser
+          XmlParser.parsing_library
+        end
+      end
+      
+      module Typecasting
+        def typecast(object)
+          case object
+          when Hash
+            typecast_hash(object)
+          when Array
+            object.map {|element| typecast(element)}
+          when String
+            CoercibleString.coerce(object)
+          else
+            object
+          end
+        end
+        
+        def typecast_hash(hash)
+          if content = hash['__content__']  
+            typecast(content)
+          else
+            keys   = hash.keys.map {|key| key.underscore}
+            values = hash.values.map {|value| typecast(value)}
+            keys.inject({}) do |new_hash, key|
+              new_hash[key] = values.slice!(0)
+              new_hash
+            end
+          end
+        end
+      end
+      
+      class XmlParser < Hash
+        include Typecasting
+        
+        class << self
+          attr_accessor :parsing_library
+        end
+        
+        attr_reader :body, :xml_in, :root
+        
+        def initialize(body)
+          @body = body
+          unless body.strip.empty?
+            parse
+            set_root
+            typecast_xml_in
+          end
+        end
+      
+        private
+      
+          def parse
+            @xml_in = self.class.parsing_library.xml_in(body, parsing_options)
+          end
+          
+          def parsing_options
+            {
+              # Includes the enclosing tag as the top level key
+              'keeproot'      => true, 
+              # Makes tag value available via the '__content__' key
+              'contentkey'    => '__content__', 
+              # Always parse tags into a hash, even when there are no attributes 
+              # (unless there is also no value, in which case it is nil)
+              'forcecontent'  => true, 
+              # If a tag is empty, makes its content nil
+              'suppressempty' => nil,
+              # Force nested elements to be put into an array, even if there is only one of them
+              'forcearray'    => ['Contents', 'Bucket', 'Grant', 'CommonPrefixes']
+            }
+          end
+          
+          def set_root
+            @root = @xml_in.keys.first.underscore
+          end
+          
+          def typecast_xml_in
+            typecast_xml = {}
+            @xml_in.dup.each do |key, value| # Some typecasting is destructive so we dup
+              typecast_xml[key.underscore] = typecast(value)
+            end
+            # An empty body will try to update with a string so only update if the result is a hash
+            update(typecast_xml[root]) if typecast_xml[root].is_a?(Hash)
+          end
+      end
+    end
+  end
+end
+#:startdoc:

data/lib/aws/s3/response.rb

@@ -0,0 +1,180 @@
+#:stopdoc:
+module AWS
+  module S3
+    class Base
+      class Response < String  
+        attr_reader :response, :body, :parsed
+        def initialize(response)
+          @response = response
+          @body     = response.body.to_s
+          super(body)
+        end
+    
+        def headers
+          headers = {}
+          response.each do |header, value|
+            headers[header] = value
+          end
+          headers
+        end
+        memoized :headers
+    
+        def [](header)
+          headers[header]
+        end
+    
+        def each(&block)
+          headers.each(&block)
+        end
+    
+        def code
+          response.code.to_i
+        end
+    
+        {:success      => 200..299, :redirect     => 300..399,
+         :client_error => 400..499, :server_error => 500..599}.each do |result, code_range|
+          class_eval(<<-EVAL, __FILE__, __LINE__)
+            def #{result}? 
+              return false unless response
+              (#{code_range}).include? code
+            end
+          EVAL
+        end
+    
+        def error?
+          !success? && response['content-type'] == 'application/xml' && parsed.root == 'error'
+        end
+    
+        def error
+          Error.new(parsed, self)
+        end
+        memoized :error
+    
+        def parsed()
+          # XmlSimple is picky about what kind of object it parses, so we pass in body rather than self
+          Parsing::XmlParser.new(body)
+        end
+        memoized :parsed
+    
+        def inspect
+          "#<%s:0x%s %s %s>" % [self.class, object_id, response.code, response.message]
+        end
+      end
+    end
+    
+    class Bucket  
+      class Response < Base::Response
+        def bucket
+          parsed
+        end
+      end
+    end
+  
+    class S3Object
+      class Response < Base::Response
+        def etag
+          headers['etag'][1...-1]
+        end
+      end
+    end
+
+    class Service
+      class Response < Base::Response
+        def empty?
+          parsed['buckets'].nil?
+        end
+  
+        def buckets
+          parsed['buckets']['bucket'] || []
+        end
+      end
+    end
+    
+    module ACL
+      class Policy
+        class Response < Base::Response
+          alias_method :policy, :parsed
+        end
+      end
+    end
+    
+    # Requests whose response code is between 300 and 599 and contain an <Error></Error> in their body
+    # are wrapped in an Error::Response. This Error::Response contains an Error object which raises an exception
+    # that corresponds to the error in the response body. The exception object contains the ErrorResponse, so
+    # in all cases where a request happens, you can rescue ResponseError and have access to the ErrorResponse and
+    # its Error object which contains information about the ResponseError.
+    #
+    #   begin
+    #     Bucket.create(..)
+    #   rescue ResponseError => exception
+    #    exception.response
+    #    # => <Error::Response>
+    #    exception.response.error
+    #    # => <Error>
+    #   end
+    class Error
+      class Response < Base::Response
+        def error? 
+          true
+        end
+      
+        def inspect
+          "#<%s:0x%s %s %s: '%s'>" % [self.class.name, object_id, response.code, error.code, error.message]
+        end
+      end
+    end
+
+    # Guess response class name from current class name. If the guessed response class doesn't exist
+    # do the same thing to the current class's parent class, up the inheritance heirarchy until either
+    # a response class is found or until we get to the top of the heirarchy in which case we just use 
+    # the the Base response class.
+    #
+    # Important: This implemantation assumes that the Base class has a corresponding Base::Response.
+    class FindResponseClass #:nodoc:
+      class << self
+        def for(start)
+          new(start).find
+        end
+      end
+  
+      def initialize(start)
+        @container     = AWS::S3
+        @current_class = start
+      end
+  
+      def find
+        self.current_class = current_class.superclass until response_class_found?            
+        target.const_get(class_to_find)
+      end
+  
+      private
+        attr_reader :container
+        attr_accessor :current_class
+        
+        def target
+          container.const_get(current_name)
+        end
+        
+        def target?
+          container.const_defined?(current_name)
+        end
+        
+        def response_class_found?
+          target? && target.const_defined?(class_to_find)
+        end
+        
+        def class_to_find
+          :Response
+        end
+        
+        def current_name
+          truncate(current_class)
+        end
+        
+        def truncate(klass)
+          klass.name[/[^:]+$/]
+        end
+      end
+  end
+end
+#:startdoc:

data/lib/aws/s3/service.rb

@@ -0,0 +1,51 @@
+module AWS
+  module S3
+    # The service lets you find out general information about your account, like what buckets you have. 
+    # 
+    #   Service.buckets
+    #   # => []
+    class Service < Base
+      @@response = nil #:nodoc:
+      
+      class << self
+        # List all your buckets.
+        #
+        #   Service.buckets
+        #   # => []
+        #
+        # For performance reasons, the bucket list will be cached. If you want avoid all caching, pass the <tt>:reload</tt> 
+        # as an argument:
+        #
+        #   Service.buckets(:reload)
+        def buckets
+          response = get('/')
+          if response.empty?
+            []
+          else
+            response.buckets.map {|attributes| Bucket.new(attributes)}
+          end
+        end
+        memoized :buckets
+        
+        # Sometimes methods that make requests to the S3 servers return some object, like a Bucket or an S3Object. 
+        # Othertimes they return just <tt>true</tt>. Other times they raise an exception that you may want to rescue. Despite all these 
+        # possible outcomes, every method that makes a request stores its response object for you in Service.response. You can always 
+        # get to the last request's response via Service.response.
+        # 
+        #   objects = Bucket.objects('jukebox')
+        #   Service.response.success?
+        #   # => true
+        #
+        # This is also useful when an error exception is raised in the console which you weren't expecting. You can 
+        # root around in the response to get more details of what might have gone wrong.
+        def response
+          @@response
+        end
+        
+        def response=(response) #:nodoc:
+          @@response = response
+        end
+      end
+    end
+  end
+end

data/lib/aws/s3/version.rb

@@ -0,0 +1,12 @@
+module AWS
+  module S3
+    module VERSION #:nodoc:
+      MAJOR    = '0'
+      MINOR    = '6'
+      TINY     = '2' 
+      BETA     = Time.now.to_i.to_s
+    end
+    
+    Version = [VERSION::MAJOR, VERSION::MINOR, VERSION::TINY, VERSION::BETA].compact * '.'
+  end
+end

data/site/index.erb

@@ -0,0 +1,41 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+
+<head>
+  <meta http-equiv="content-type" content="text/html;charset=iso-8859-1" />
+  <title>AWS::S3 - Ruby Library for Amazon Simple Storage Service (S3)</title>
+  <link rel="Stylesheet" href="screen.css" type="text/css" media="screen" />
+  <link rel="Stylesheet" href="ruby.css" type="text/css" media="screen" />
+  <link rel="shortcut icon" href="images/favicon.ico" type="image/x-icon" />
+</head>
+
+<body>
+  <div class="page_area">
+    <div class="left_column">
+      <img id="logo" src="images/box-and-gem.gif" />
+    </div>
+    <div class="column">
+      <div class="header">
+        <h2>AWS::S3</h2>
+        <h3>A Ruby Library for Amazon's Simple<br />Storage Service's (S3) REST API.</h3>
+      <p class="links">
+      <a href="http://github.com/marcel/aws-s3/tree/master">Browse code</a> |
+      <a href="http://amazon.rubyforge.org/doc/">Docs</a> |
+      <a href="http://rubyforge.org/frs/?group_id=2409">Downloads</a> |
+      <a href="http://rubyforge.org/tracker/?group_id=2409">Bugs &amp; Patches</a> |
+      <a href="http://rubyforge.org/mailman/listinfo/amazon-s3-dev">Mailing list</a></p>
+        <h4>Download with RubyGems</h4>
+        <pre>sudo gem i aws-s3</pre>
+        <h4>Clone from the master git repository</h4>
+        <pre>git clone git://github.com/marcel/aws-s3.git</pre>
+      </div>
+
+      <div class="readme">
+
+<h2>Readme</h2>
+<h4 class="first">Getting started</h4>
+<%= erb_data[:readme] %>
+</body>
+</html>

data/site/public/ruby.css

@@ -0,0 +1,18 @@
+.ruby {border: 1px solid #333; }
+.ruby .normal    {}
+.ruby .comment   { color: #666; background-color: #eee; font-style: italic; }
+.ruby .keyword   { color: #c96; font-weight: bold; }
+.ruby .method    { color: #333; }
+.ruby .class     { color: #333; }
+.ruby .module    { color: #333; }
+.ruby .punct     { color: #333; font-weight: bold; }
+.ruby .symbol    { color: #333; }
+.ruby .string    { color: #996; }
+.ruby .char      { color: #999; }
+.ruby .ident     { color: #333; }
+.ruby .constant  { color: #69c; font-weight: bold;}
+.ruby .regex     { color: #333; }
+.ruby .number    { color: #333; }
+.ruby .attribute { color: #333; }
+.ruby .global    { color: #333; }
+.ruby .expr      { color: #333; }