scashin133-s3 0.3.8

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in s3.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    scashin133-s3 (0.3.8)
+      proxies
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    mocha (0.9.8)
+      rake
+    proxies (0.2.1)
+    rake (0.8.7)
+    test-unit (2.1.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  mocha
+  proxies
+  scashin133-s3!
+  test-unit (>= 2.0)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jakub Kuźma, Mirosław Boruta
+
+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.

data/README.rdoc

@@ -0,0 +1,22 @@
+= S3
+
+S3 library provides access to {Amazon's Simple Storage Service}[http://aws.amazon.com/s3/].
+It supports both: European and US buckets through {REST API}[http://docs.amazonwebservices.com/AmazonS3/latest/RESTAPI.html].
+
+* homepage[http://jah.pl/projects/s3.html]
+* gemcutter[http://gemcutter.org/gems/s3]
+* repository[http://github.com/qoobaa/s3]
+* {issue tracker}[http://github.com/qoobaa/s3/issues]
+* rdoc[http://qoobaa.github.com/s3]
+
+== Installation
+
+  gem install s3
+
+== Usage
+
+See homepage[http://jah.pl/projects/s3.html] for details.
+
+== Copyright
+
+Copyright (c) 2009 Jakub Kuźma, Mirosław Boruta. See LICENSE[http://github.com/qoobaa/s3/raw/master/LICENSE] for details.

data/Rakefile

@@ -0,0 +1,21 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+Bundler.setup
+
+require "rake/testtask"
+require "rake/rdoctask"
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << "lib" << "test"
+  test.pattern = "test/**/*_test.rb"
+  test.verbose = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "s3 #{S3::VERSION}"
+  rdoc.rdoc_files.include("README.rdoc")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+task :default => :test

data/extra/s3_attachment_fu.rb

@@ -0,0 +1,159 @@
+require "singleton"
+require "s3"
+
+# S3 Backend for attachment-fu plugin. After installing attachment-fu
+# plugin, copy the file to:
+# +vendor/plugins/attachment-fu/lib/technoweenie/attachment_fu/backends+
+#
+# To configure S3Backend create initializer file in your Rails
+# application, e.g. +config/initializers/s3_backend.rb+.
+#
+#   Technoweenie::AttachmentFu::Backends::S3Backend.configuration do |config|
+#     config.access_key_id = "..." # your access key id
+#     config.secret_access_key = "..." # your secret access key
+#     config.bucket_name = "..." # default bucket name to store attachments
+#     config.use_ssl = false # pass true if you want to communicate via SSL
+#   end
+
+module Technoweenie
+  module AttachmentFu
+    module Backends
+      module S3Backend
+
+        # S3Backend configuration class
+        class Configuration
+          include Singleton
+
+          ATTRIBUTES = [:access_key_id, :secret_access_key, :use_ssl, :bucket_name]
+
+          attr_accessor *ATTRIBUTES
+        end
+
+        # Method used to configure S3Backend, see the example above
+        def self.configuration
+          if block_given?
+            yield Configuration.instance
+          end
+          Configuration.instance
+        end
+
+        # :nodoc:
+        def self.included(base)
+          include S3
+
+          service = Service.new(:access_key_id => configuration.access_key_id,
+                                :secret_access_key => configuration.secret_access_key,
+                                :use_ssl => configuration.use_ssl)
+
+          bucket_name = base.attachment_options[:bucket_name] || configuration.bucket_name
+
+          base.cattr_accessor :bucket
+          base.bucket = service.buckets.build(bucket_name) # don't connect
+
+          base.before_update :rename_file
+        end
+
+        # The attachment ID used in the full path of a file
+        def attachment_path_id
+          ((respond_to?(:parent_id) && parent_id) || id).to_s
+        end
+
+        # The pseudo hierarchy containing the file relative to the bucket name
+        # Example: <tt>:table_name/:id</tt>
+        def base_path
+          [attachment_options[:path_prefix], attachment_path_id].join("/")
+        end
+
+        # The full path to the file relative to the bucket name
+        # Example: <tt>:table_name/:id/:filename</tt>
+        def full_filename(thumbnail = nil)
+          [base_path, thumbnail_name_for(thumbnail)].join("/")
+        end
+
+        # All public objects are accessible via a GET request to the S3 servers. You can generate a
+        # url for an object using the s3_url method.
+        #
+        #   @photo.s3_url
+        #
+        # The resulting url is in the form: <tt>http(s)://:server/:bucket_name/:table_name/:id/:file</tt> where
+        # the <tt>:server</tt> variable defaults to <tt>AWS::S3 URL::DEFAULT_HOST</tt> (s3.amazonaws.com) and can be
+        # set using the configuration parameters in <tt>RAILS_ROOT/config/amazon_s3.yml</tt>.
+        #
+        # The optional thumbnail argument will output the thumbnail's filename (if any).
+        def s3_url(thumbnail = nil)
+          if attachment_options[:cname]
+            ["#{s3_protocol}#{bucket.name}", full_filename(thumbnail)].join("/")
+          else
+            ["#{s3_protocol}#{s3_hostname}#{bucket.path_prefix}", full_filename(thumbnail)].join("/")
+          end
+        end
+        alias :public_url :s3_url
+        alias :public_filename :s3_url
+
+        # Name of the bucket used to store attachments
+        def bucket_name
+          self.class.bucket.name
+        end
+
+        # :nodoc:
+        def create_temp_file
+          write_to_temp_file current_data
+        end
+
+        # :nodoc:
+        def current_data
+          # Object.value full_filename, bucket_name
+          object = self.class.bucket.objects.find(full_filename)
+          object.content
+        end
+
+        # Returns http:// or https:// depending on use_ssl setting
+        def s3_protocol
+          attachment_options[:use_ssl] ?  "https://" : "http://"
+        end
+
+        # Returns hostname of the bucket
+        # e.g. +bucketname.com.s3.amazonaws.com+. Additionally you can
+        # pass :cname => true option in has_attachment method to
+        # return CNAME only, e.g. +bucketname.com+
+        def s3_hostname
+          attachment_options[:cname] ? self.class.bucket.name : self.class.bucket.host
+        end
+
+        protected
+
+        # Frees the space in S3 bucket, used by after_destroy callback
+        def destroy_file
+          object = self.class.bucket.objects.find(full_filename)
+          object.destroy
+        end
+
+        # Renames file if filename has been changed - copy the file to
+        # new key and delete old one
+        def rename_file
+          return unless filename_changed?
+
+          old_full_filename = [base_path, filename_was].join("/")
+
+          object = self.class.bucket.objects.find(old_full_filename)
+          new_object = object.copy(:key => full_filename, :acl => attachment_options[:acl])
+          object.destroy
+          true
+        end
+
+        # Saves the file to storage
+        def save_to_storage
+          if save_attachment?
+            object = self.class.bucket.objects.build(full_filename)
+
+            object.content_type = content_type
+            object.acl = attachment_options[:acl]
+            object.content = temp_path ? File.open(temp_path) : temp_data
+            object.save
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/extra/s3_paperclip.rb

@@ -0,0 +1,157 @@
+# S3 backend for paperclip plugin. Copy the file to:
+# +config/initializers/+ directory
+#
+# Example configuration for CNAME bucket:
+#
+#   has_attached_file :image,
+#                     :s3_host_alias => "bucket.domain.tld",
+#                     :url => ":s3_alias_url",
+#                     :styles => {
+#                       :medium => "300x300>",
+#                       :thumb => "100x100>"
+#                     },
+#                     :storage => :s3,
+#                     :s3_credentials => {
+#                       :access_key_id => "...",
+#                       :secret_access_key => "..."
+#                     },
+#                     :bucket => "bucket.domain.tld",
+#                     :path => ":attachment/:id/:style.:extension"
+module Paperclip
+  module Storage
+    module S3
+      def self.extended base
+        begin
+          require "s3"
+        rescue LoadError => e
+          e.message << " (You may need to install the s3 gem)"
+          raise e
+        end
+
+        base.instance_eval do
+          @s3_credentials   = parse_credentials(@options[:s3_credentials])
+          @bucket_name      = @options[:bucket]           || @s3_credentials[:bucket]
+          @bucket_name      = @bucket_name.call(self) if @bucket_name.is_a?(Proc)
+          @s3_options       = @options[:s3_options]       || {}
+          @s3_permissions   = @options[:s3_permissions]   || :public_read
+          @s3_storage_class = @options[:s3_storage_class] || :standard
+          @s3_protocol      = @options[:s3_protocol]      || (@s3_permissions == :public_read ? "http" : "https")
+          @s3_headers       = @options[:s3_headers]       || {}
+          @s3_host_alias    = @options[:s3_host_alias]
+          @url              = ":s3_path_url" unless @url.to_s.match(/^:s3.*url$/)
+          @service = ::S3::Service.new(@s3_options.merge(
+            :access_key_id => @s3_credentials[:access_key_id],
+            :secret_access_key => @s3_credentials[:secret_access_key],
+            :use_ssl => @s3_protocol == "https"
+          ))
+          @bucket = @service.buckets.build(@bucket_name)
+        end
+        Paperclip.interpolates(:s3_alias_url) do |attachment, style|
+          "#{attachment.s3_protocol}://#{attachment.s3_host_alias}/#{attachment.path(style).gsub(%r{^/}, "")}"
+        end
+        Paperclip.interpolates(:s3_path_url) do |attachment, style|
+          "#{attachment.s3_protocol}://s3.amazonaws.com/#{attachment.bucket_name}/#{attachment.path(style).gsub(%r{^/}, "")}"
+        end
+        Paperclip.interpolates(:s3_domain_url) do |attachment, style|
+          "#{attachment.s3_protocol}://#{attachment.bucket_name}.s3.amazonaws.com/#{attachment.path(style).gsub(%r{^/}, "")}"
+        end
+      end
+
+      def expiring_url(style_name = default_style, time = 3600)
+        bucket.objects.build(path(style_name)).temporary_url(Time.now + time)
+      end
+
+      def bucket_name
+        @bucket_name
+      end
+
+      def bucket
+        @bucket
+      end
+
+      def s3_host_alias
+        @s3_host_alias
+      end
+
+      def parse_credentials creds
+        creds = find_credentials(creds).stringify_keys
+        (creds[RAILS_ENV] || creds).symbolize_keys
+      end
+
+      def exists?(style = default_style)
+        if original_filename
+          bucket.objects.build(path(style)).exists?
+        else
+          false
+        end
+      end
+
+      def s3_protocol
+        @s3_protocol
+      end
+
+      # Returns representation of the data of the file assigned to the given
+      # style, in the format most representative of the current storage.
+      def to_file style = default_style
+        return @queued_for_write[style] if @queued_for_write[style]
+        begin
+          file = Tempfile.new(path(style))
+          file.binmode if file.respond_to?(:binmode)
+          file.write(bucket.objects.find(path(style)).content)
+          file.rewind
+        rescue ::S3::Error::NoSuchKey
+          file.close if file.respond_to?(:close)
+          file = nil
+        end
+        file
+      end
+
+      def flush_writes #:nodoc:
+        @queued_for_write.each do |style, file|
+          begin
+            log("saving #{path(style)}")
+            object = bucket.objects.build(path(style))
+            file.rewind
+            object.content = file.read
+            object.acl = @s3_permissions
+            object.storage_class = @s3_storage_class
+            object.content_type = instance_read(:content_type)
+            object.content_disposition = @s3_headers[:content_disposition]
+            object.content_encoding = @s3_headers[:content_encoding]
+            object.save
+          rescue ::S3::Error::ResponseError => e
+            raise
+          end
+        end
+        @queued_for_write = {}
+      end
+
+      def flush_deletes #:nodoc:
+        @queued_for_delete.each do |path|
+          begin
+            log("deleting #{path}")
+            bucket.objects.find(path).destroy
+          rescue ::S3::Error::ResponseError
+            # Ignore this.
+          end
+        end
+        @queued_for_delete = []
+      end
+
+      def find_credentials creds
+        case creds
+        when File
+          YAML::load(ERB.new(File.read(creds.path)).result)
+        when String
+          YAML::load(ERB.new(File.read(creds)).result)
+        when Hash
+          creds
+        else
+          raise ArgumentError, "Credentials are not a path, file, or hash."
+        end
+      end
+      private :find_credentials
+
+    end
+  end
+end

data/lib/s3/bucket.rb

@@ -0,0 +1,172 @@
+module S3
+  class Bucket
+    include Parser
+    include Proxies
+    extend Forwardable
+
+    attr_reader :name, :service
+
+    def_instance_delegators :service, :service_request
+    private_class_method :new
+
+    # Retrieves the bucket information from the server. Raises an
+    # S3::Error exception if the bucket doesn't exist or you don't
+    # have access to it, etc.
+    def retrieve
+      bucket_headers
+      self
+    end
+
+    # Returns location of the bucket, e.g. "EU"
+    def location(reload = false)
+      if reload or @location.nil?
+        @location = location_constraint
+      else
+        @location
+      end
+    end
+
+    # Compares the bucket with other bucket. Returns true if the names
+    # of the buckets are the same, and both have the same services
+    # (see Service equality)
+    def ==(other)
+      self.name == other.name and self.service == other.service
+    end
+
+    # Similar to retrieve, but catches S3::Error::NoSuchBucket
+    # exceptions and returns false instead.
+    def exists?
+      retrieve
+      true
+    rescue Error::NoSuchBucket
+      false
+    end
+
+    # Destroys given bucket. Raises an S3::Error::BucketNotEmpty
+    # exception if the bucket is not empty. You can destroy non-empty
+    # bucket passing true (to force destroy)
+    def destroy(force = false)
+      delete_bucket
+      true
+    rescue Error::BucketNotEmpty
+      if force
+        objects.destroy_all
+        retry
+      else
+        raise
+      end
+    end
+
+    # Saves the newly built bucket.
+    #
+    # ==== Options
+    # * <tt>:location</tt> - location of the bucket
+    #   (<tt>:eu</tt> or <tt>us</tt>)
+    # * Any other options are passed through to
+    #   Connection#request
+    def save(options = {})
+      options = {:location => options} unless options.is_a?(Hash)
+      create_bucket_configuration(options)
+      true
+    end
+
+    # Returns true if the name of the bucket can be used like +VHOST+
+    # name. If the bucket contains characters like underscore it can't
+    # be used as +VHOST+ (e.g. <tt>bucket_name.s3.amazonaws.com</tt>)
+    def vhost?
+      self.class.vhost?(@name)
+    end
+
+    # Returns host name of the bucket according (see #vhost? method)
+    def host
+      vhost? ? "#@name.#{HOST}" : "#{HOST}"
+    end
+
+    # Returns path prefix for non +VHOST+ bucket. Path prefix is used
+    # instead of +VHOST+ name, e.g. "bucket_name/"
+    def path_prefix
+      vhost? ? "" : "#@name/"
+    end
+
+    # Returns the objects in the bucket and caches the result (see
+    # #reload method).
+    def objects
+      Proxy.new(lambda { list_bucket }, :owner => self, :extend => ObjectsExtension)
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class}:#{name}>"
+    end
+    
+    def self.vhost?(name)
+      "#{name}.#{HOST}" =~ /\A#{URI::REGEXP::PATTERN::HOSTNAME}\Z/
+    end
+
+    private
+
+    attr_writer :service
+
+    def location_constraint
+      response = bucket_request(:get, :params => {:location => nil})
+      parse_location_constraint(response.body)
+    end
+
+    def list_bucket(options = {})
+      response = bucket_request(:get, :params => options)
+      objects_attributes = parse_list_bucket_result(response.body)
+
+      # If there are more than 1000 objects S3 truncates listing
+      # and we need to request another listing for the remaining objects.
+      while parse_is_truncated(response.body)
+        marker = objects_attributes.last[:key]
+        response = bucket_request(:get, :params => options.merge(:marker => marker))
+        objects_attributes += parse_list_bucket_result(response.body)
+      end
+
+      objects_attributes.map { |object_attributes| Object.send(:new, self, object_attributes) }
+    end
+
+    def bucket_headers(options = {})
+      response = bucket_request(:head, :params => options)
+    rescue Error::ResponseError => e
+      if e.response.code.to_i == 404
+        raise Error::ResponseError.exception("NoSuchBucket").new("The specified bucket does not exist.", nil)
+      else
+        raise e
+      end
+    end
+
+    def create_bucket_configuration(options = {})
+      location = options[:location].to_s.upcase if options[:location]
+      options[:headers] ||= {}
+      if location and location != "US"
+        options[:body] = "<CreateBucketConfiguration><LocationConstraint>#{location}</LocationConstraint></CreateBucketConfiguration>"
+        options[:headers][:content_type] = "application/xml"
+      end
+      bucket_request(:put, options)
+    end
+
+    def delete_bucket
+      bucket_request(:delete)
+    end
+
+    def initialize(service, name) #:nodoc:
+      self.service = service
+      self.name = name
+    end
+
+    def name=(name)
+      raise ArgumentError.new("Invalid bucket name: #{name}") unless name_valid?(name)
+      @name = name
+    end
+
+    def bucket_request(method, options = {})
+      path = "#{path_prefix}#{options[:path]}"
+      service_request(method, options.merge(:host => host, :path => path))
+    end
+
+    def name_valid?(name)
+      name =~ /\A[a-z0-9][a-z0-9\._-]{2,254}\Z/i and name !~ /\A#{URI::REGEXP::PATTERN::IPV4ADDR}\Z/
+    end
+  end
+end

data/lib/s3/buckets_extension.rb

@@ -0,0 +1,27 @@
+module S3
+  module BucketsExtension
+    # Builds new bucket with given name
+    def build(name)
+      Bucket.send(:new, proxy_owner, name)
+    end
+
+    # Finds the bucket with given name
+    def find_first(name)
+      bucket = build(name)
+      bucket.retrieve
+    end
+    alias :find :find_first
+
+    # Find all buckets in the service
+    def find_all
+      proxy_target
+    end
+
+    # Destroy all buckets in the service. Doesn't destroy non-empty
+    # buckets by default, pass true to force destroy (USE WITH
+    # CARE!).
+    def destroy_all(force = false)
+      proxy_target.each { |bucket| bucket.destroy(force) }
+    end
+  end
+end