aws-ses 0.1.0

data/lib/aws/ses/exceptions.rb

@@ -0,0 +1,50 @@
+#--
+# AWS ERROR CODES
+# AWS can throw error exceptions that contain a '.' in them.
+# since we can't name an exception class with that '.' I compressed
+# each class name into the non-dot version which allows us to retain
+# the granularity of the exception.
+#++
+
+module AWS
+
+  # All AWS errors are superclassed by Error < RuntimeError
+  class Error < RuntimeError; end
+
+  # CLIENT : A client side argument error
+  class ArgumentError < Error; end
+
+  # Server Error Codes
+  ###
+
+  # Server : Internal Error.
+  class InternalError < Error; end
+
+  # Server : Not enough available addresses to satisfy your minimum request.
+  class InsufficientAddressCapacity < Error; end
+
+  # Server : There are not enough available instances to satisfy your minimum request.
+  class InsufficientInstanceCapacity < Error; end
+
+  # Server : There are not enough available reserved instances to satisfy your minimum request.
+  class InsufficientReservedInstanceCapacity < Error; end
+
+  # Server : The server is overloaded and cannot handle the request.
+  class Unavailable < Error; end
+
+  # API Errors
+  ############################
+
+  # Server : Invalid AWS Account
+  class InvalidClientTokenId < Error; end
+
+  # Server : The provided signature does not match.
+  class SignatureDoesNotMatch < Error; end
+  
+  # SES Errors
+  ############################
+  
+  
+
+end
+

data/lib/aws/ses/extensions.rb

@@ -0,0 +1,313 @@
+#:stopdoc:
+
+class Hash
+  def to_query_string(include_question_mark = true)
+    query_string = ''
+    unless empty?
+      query_string << '?' if include_question_mark
+      query_string << inject([]) do |params, (key, value)| 
+        params << "#{key}=#{value}" 
+      end.join('&')
+    end
+    query_string
+  end
+  
+  def to_normalized_options
+    # Convert all option names to downcased strings, and replace underscores with hyphens
+    inject({}) do |normalized_options, (name, value)|
+      normalized_options[name.to_header] = value.to_s
+      normalized_options
+    end
+  end
+  
+  def to_normalized_options!
+    replace(to_normalized_options)
+  end
+end
+
+class String
+  if RUBY_VERSION <= '1.9'
+    def previous!
+      self[-1] -= 1
+      self
+    end
+  else
+    def previous!
+      self[-1] = (self[-1].ord - 1).chr
+      self
+    end
+  end
+  
+  def previous
+    dup.previous!
+  end
+  
+  def to_header
+    downcase.tr('_', '-')
+  end
+  
+  # ActiveSupport adds an underscore method to String so let's just use that one if
+  # we find that the method is already defined
+  def underscore
+    gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").downcase
+  end unless public_method_defined? :underscore
+
+  if RUBY_VERSION >= '1.9'
+    def valid_utf8?
+      dup.force_encoding('UTF-8').valid_encoding?
+    end
+  else
+    def valid_utf8?
+      scan(Regexp.new('[^\x00-\xa0]', nil, 'u')) { |s| s.unpack('U') }
+      true
+    rescue ArgumentError
+      false
+    end
+  end
+  
+  # All paths in in S3 have to be valid unicode so this takes care of 
+  # cleaning up any strings that aren't valid utf-8 according to String#valid_utf8?
+  if RUBY_VERSION >= '1.9'
+    def remove_extended!
+      sanitized_string = ''
+      each_byte do |byte|
+        character = byte.chr
+        sanitized_string << character if character.ascii_only?
+      end
+      sanitized_string
+    end
+  else
+    def remove_extended!
+      gsub!(/[\x80-\xFF]/) { "%02X" % $&[0] }
+    end
+  end
+  
+  def remove_extended
+    dup.remove_extended!
+  end
+end
+
+class CoercibleString < String
+  class << self
+    def coerce(string)
+      new(string).coerce
+    end
+  end
+  
+  def coerce
+    case self
+    when 'true';         true
+    when 'false';         false
+    # Don't coerce numbers that start with zero
+    when  /^[1-9]+\d*$/;   Integer(self)
+    when datetime_format; Time.parse(self)
+    else
+      self
+    end
+  end
+  
+  private
+    # Lame hack since Date._parse is so accepting. S3 dates are of the form: '2006-10-29T23:14:47.000Z'
+    # so unless the string looks like that, don't even try, otherwise it might convert an object's
+    # key from something like '03 1-2-3-Apple-Tree.mp3' to Sat Feb 03 00:00:00 CST 2001.
+    def datetime_format
+      /^\d{4}-\d{2}-\d{2}\w\d{2}:\d{2}:\d{2}/
+    end
+end
+
+class Symbol
+  def to_header
+    to_s.to_header
+  end
+end
+
+module Kernel
+  def __method__(depth = 0)
+    caller[depth][/`([^']+)'/, 1]
+  end if RUBY_VERSION <= '1.8.7'
+  
+  def __called_from__
+    caller[1][/`([^']+)'/, 1]
+  end if RUBY_VERSION > '1.8.7'
+  
+  def expirable_memoize(reload = false, storage = nil)
+    current_method = RUBY_VERSION > '1.8.7' ? __called_from__ : __method__(1)
+    storage = "@#{storage || current_method}"
+    if reload 
+      instance_variable_set(storage, nil)
+    else
+      if cache = instance_variable_get(storage)
+        return cache
+      end
+    end
+    instance_variable_set(storage, yield)
+  end
+
+  def require_library_or_gem(library, gem_name = nil)
+    if RUBY_VERSION >= '1.9'
+      gem(gem_name || library, '>=0') 
+    end
+    require library
+  rescue LoadError => library_not_installed
+    begin
+      require 'rubygems'
+      require library
+    rescue LoadError
+      raise library_not_installed
+    end
+  end
+end
+
+class Object
+  def returning(value)
+    yield(value)
+    value
+  end
+end
+
+class Module
+  def memoized(method_name)
+    original_method = "unmemoized_#{method_name}_#{Time.now.to_i}"
+    alias_method original_method, method_name
+    module_eval(<<-EVAL, __FILE__, __LINE__)
+      def #{method_name}(reload = false, *args, &block)
+        expirable_memoize(reload) do
+          send(:#{original_method}, *args, &block)
+        end
+      end
+    EVAL
+  end
+  
+  def constant(name, value)
+    unless const_defined?(name)
+      const_set(name, value) 
+      module_eval(<<-EVAL, __FILE__, __LINE__)
+        def self.#{name.to_s.downcase}
+          #{name.to_s}
+        end
+      EVAL
+    end
+  end
+  
+  # Transforms MarcelBucket into
+  #
+  #   class MarcelBucket < AWS::S3::Bucket
+  #     set_current_bucket_to 'marcel'
+  #   end
+  def const_missing_from_s3_library(sym)
+    if sym.to_s =~ /^(\w+)(Bucket|S3Object)$/
+      const = const_set(sym, Class.new(AWS::S3.const_get($2)))
+      const.current_bucket = $1.underscore
+      const
+    else
+      const_missing_not_from_s3_library(sym)
+    end
+  end
+  alias_method :const_missing_not_from_s3_library, :const_missing
+  alias_method :const_missing, :const_missing_from_s3_library
+end
+
+
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end if Class.instance_methods(false).grep(/^cattr_(?:reader|writer|accessor)$/).empty?
+
+module SelectiveAttributeProxy
+  def self.included(klass)
+    klass.extend(ClassMethods)
+    klass.class_eval(<<-EVAL, __FILE__, __LINE__)
+      cattr_accessor :attribute_proxy
+      cattr_accessor :attribute_proxy_options
+      
+      # Default name for attribute storage
+      self.attribute_proxy         = :attributes
+      self.attribute_proxy_options = {:exclusively => true}
+      
+      private
+        # By default proxy all attributes
+        def proxiable_attribute?(name)
+          return true unless self.class.attribute_proxy_options[:exclusively]
+          send(self.class.attribute_proxy).has_key?(name)
+        end
+        
+        def method_missing(method, *args, &block)
+          # Autovivify attribute storage
+          if method == self.class.attribute_proxy
+            ivar = "@\#{method}"
+            instance_variable_set(ivar, {}) unless instance_variable_get(ivar).is_a?(Hash)
+            instance_variable_get(ivar)
+          # Delegate to attribute storage
+          elsif method.to_s =~ /^(\\w+)(=?)$/ && proxiable_attribute?($1)
+            attributes_hash_name = self.class.attribute_proxy
+            $2.empty? ? send(attributes_hash_name)[$1] : send(attributes_hash_name)[$1] = args.first
+          else
+            super
+          end
+        end
+    EVAL
+  end
+  
+  module ClassMethods
+    def proxy_to(attribute_name, options = {})
+      if attribute_name.is_a?(Hash)
+        options = attribute_name
+      else
+        self.attribute_proxy = attribute_name
+      end
+      self.attribute_proxy_options = options
+    end
+  end
+end
+
+
+class XmlGenerator < String #:nodoc:
+  attr_reader :xml
+  def initialize
+    @xml = Builder::XmlMarkup.new(:indent => 2, :target => self)
+    super()
+    build
+  end
+end
+#:startdoc:

data/lib/aws/ses/response.rb

@@ -0,0 +1,97 @@
+module AWS
+  module SES
+    class Response < String  
+      attr_reader :response, :body, :parsed, :action
+      
+      def initialize(action, response)
+        @action   = action
+        @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
+        parse_options = { 'forcearray' => ['item', 'member'], 'suppressempty' => nil, 'keeproot' => false }
+#        parse_options = { 'suppressempty' => nil, 'keeproot' => false }
+
+        xml = XmlSimple.xml_in(body, parse_options)
+        xml["#{@action}Result"]
+      end
+      memoized :parsed
+      
+      # It's expected that each subclass of Response will override this method with what part of response is relevant
+      def result
+        parsed
+      end
+
+      def inspect
+        "#<%s:0x%s %s %s>" % [self.class, object_id, response.code, response.message]
+      end
+    end  # class Response
+    
+    # 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 < 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 #module SES
+end  # module AWS
+