aws-s3-akhtaboot 0.6.2.1288082910

data/lib/aws/s3/owner.rb

@@ -0,0 +1,44 @@
+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']
+        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']
+            }
+          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/support/faster-xml-simple/lib/faster_xml_simple.rb

@@ -0,0 +1,187 @@
+# 
+# Copyright (c) 2006 Michael Koziarski
+# 
+# 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.
+
+require 'rubygems'
+require 'xml/libxml'
+
+class FasterXmlSimple
+  Version = '0.5.0'
+  class << self
+    # Take an string containing XML, and returns a hash representing that 
+    # XML document.  For example:
+    # 
+    #   FasterXmlSimple.xml_in("<root><something>1</something></root>")
+    #   {"root"=>{"something"=>{"__content__"=>"1"}}}
+    #
+    # Faster XML Simple is designed to be a drop in replacement for the xml_in
+    # functionality of http://xml-simple.rubyforge.org
+    #
+    # The following options are supported:
+    # 
+    # * <tt>contentkey</tt>: The key to use for the content of text elements,
+    #   defaults to '\_\_content__'
+    # * <tt>forcearray</tt>: The list of elements which should always be returned
+    #   as arrays.  Under normal circumstances single element arrays are inlined.
+    # * <tt>suppressempty</tt>: The value to return for empty elements, pass +true+
+    #   to remove empty elements entirely.
+    # * <tt>keeproot</tt>:  By default the hash returned has a single key with the
+    #   name of the root element.  If the name of the root element isn't 
+    #   interesting to you, pass +false+. 
+    # * <tt>forcecontent</tt>:  By default a text element with no attributes, will 
+    #   be collapsed to just a string instead of a hash with a single key.  
+    #   Pass +true+ to prevent this.
+    #
+    #
+    def xml_in(string, options={})
+      new(string, options).out
+    end
+  end
+  
+  def initialize(string, options) #:nodoc:
+    @doc     = parse(string)
+    @options = default_options.merge options
+  end
+  
+  def out #:nodoc:
+    if @options['keeproot']
+      {@doc.root.name => collapse(@doc.root)}
+    else
+      collapse(@doc.root)
+    end
+  end
+  
+  private
+    def default_options
+      {'contentkey' => '__content__', 'forcearray' => [], 'keeproot'=>true}
+    end
+  
+    def collapse(element)
+      result = hash_of_attributes(element) 
+      if text_node? element
+        text = collapse_text(element)
+        result[content_key] = text if text =~ /\S/
+      elsif element.children?
+        element.inject(result) do |hash, child|
+          unless child.text?
+            child_result = collapse(child) 
+            (hash[child.name] ||= []) << child_result
+          end
+          hash
+        end
+      end
+      if result.empty?
+        return empty_element
+      end
+      # Compact them to ensure it complies with the user's requests
+      inline_single_element_arrays(result) 
+      remove_empty_elements(result) if suppress_empty?
+      if content_only?(result) && !force_content?
+        result[content_key]
+      else
+        result
+      end
+    end
+    
+    def content_only?(result)
+      result.keys == [content_key]
+    end
+  
+    def content_key
+      @options['contentkey']
+    end
+  
+    def force_array?(key_name)
+      Array(@options['forcearray']).include?(key_name)
+    end
+  
+    def inline_single_element_arrays(result)
+      result.each do |key, value|
+        if value.size == 1 && value.is_a?(Array) && !force_array?(key)
+          result[key] = value.first
+        end
+      end    
+    end
+  
+    def remove_empty_elements(result)
+      result.each do |key, value|
+        if value == empty_element
+          result.delete key
+        end
+      end
+    end
+    
+    def suppress_empty?
+      @options['suppressempty'] == true
+    end
+     
+    def empty_element
+      if !@options.has_key? 'suppressempty'
+        {}
+      else
+        @options['suppressempty']
+      end
+    end
+
+    # removes the content if it's nothing but blanks,  prevents
+    # the hash being polluted with lots of content like "\n\t\t\t" 
+    def suppress_empty_content(result)
+      result.delete content_key if result[content_key] !~ /\S/ 
+    end
+  
+    def force_content?
+      @options['forcecontent']
+    end
+  
+    # a text node is one with 1 or more child nodes which are
+    # text nodes, and no non-text children, there's no sensible
+    # way to support nodes which are text and markup like:
+    # <p>Something <b>Bold</b> </p>
+    def text_node?(element)
+      !element.text? && element.all? {|c| c.text?}
+    end
+  
+    # takes a text node, and collapses it into a string
+    def collapse_text(element)
+      element.map {|c| c.content } * ''
+    end
+  
+    def hash_of_attributes(element)
+      result = {}
+      element.each_attr do |attribute| 
+        name = attribute.name
+        name = [attribute.ns, attribute.name].join(':') if attribute.ns?
+        result[name] = attribute.value 
+      end
+      result
+    end
+  
+    def parse(string)
+      if string == ''
+        string = ' '
+      end
+      XML::Parser.string(string).parse
+    end
+end
+
+class XmlSimple # :nodoc:
+  def self.xml_in(*args)
+    FasterXmlSimple.xml_in *args
+  end
+end