dragonfly 0.6.2 → 0.7.0

data/lib/dragonfly/config/heroku.rb

@@ -0,0 +1,19 @@
+module Dragonfly
+  module Config
+
+    module Heroku
+
+      def self.apply_configuration(app, bucket_name)
+        app.configure do |c|
+          c.datastore = Dragonfly::DataStorage::S3DataStore.new
+          c.datastore.configure do |d|
+            d.bucket_name = bucket_name
+            d.access_key_id = ENV['S3_KEY'] || raise("ENV variable 'S3_KEY' needs to be set - use\n\theroku config:add S3_KEY=XXXXXXXXX")
+            d.secret_access_key = ENV['S3_SECRET'] || raise("ENV variable 'S3_SECRET' needs to be set - use\n\theroku config:add S3_SECRET=XXXXXXXXX")
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/config/r_magick.rb

@@ -0,0 +1,37 @@
+module Dragonfly
+  module Config
+
+    # RMagick is a saved configuration for Dragonfly apps, which does the following:
+    # - registers an rmagick analyser
+    # - registers an rmagick processor
+    # - registers an rmagick encoder
+    # - adds thumb shortcuts like '280x140!', etc.
+    # Look at the source code for apply_configuration to see exactly how it configures the app.
+    module RMagick
+
+      def self.apply_configuration(app)
+        app.configure do |c|
+          c.analyser.register(Analysis::RMagickAnalyser)
+          c.processor.register(Processing::RMagickProcessor)
+          c.encoder.register(Encoding::RMagickEncoder)
+          c.generator.register(Generation::RMagickGenerator)
+          c.job :thumb do |geometry, format|
+            process :thumb, geometry
+            encode format if format
+          end
+          c.job :gif do
+            encode :gif
+          end
+          c.job :jpg do
+            encode :jpg
+          end
+          c.job :png do
+            encode :png
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/dragonfly/config/{rails_defaults.rb → rails.rb}

@@ -1,15 +1,14 @@
 module Dragonfly
   module Config
-    
-    module RailsDefaults
-    
+
+    module Rails
+
       def self.apply_configuration(app)
         app.configure do |c|
           c.log = ::Rails.logger
-          c.datastore.root_path = "#{::Rails.root}/public/system/dragonfly/#{::Rails.env}"
-          c.url_handler.configure do |u|
-            u.path_prefix = '/media'
-          end
+          c.datastore.root_path = "#{::Rails.root}/public/system/dragonfly/#{::Rails.env}" if c.datastore.is_a?(DataStorage::FileDataStore)
+          c.url_path_prefix = '/media'
+          c.analyser.register(Analysis::FileCommandAnalyser)
         end
       end
 

data/lib/dragonfly/configurable.rb

@@ -1,14 +1,14 @@
 module Dragonfly
   module Configurable
-    
+
     # Exceptions
     class BadConfigAttribute < StandardError; end
-    
+
     def self.included(klass)
       klass.class_eval do
         include Configurable::InstanceMethods
         extend Configurable::ClassMethods
-        
+
         # These aren't included in InstanceMethods because we need access to 'klass'
         # We can't just put them into InstanceMethods and use 'self.class' because
         # this won't always point to the class in which we've included Configurable,
@@ -17,25 +17,28 @@ module Dragonfly
           @configuration_hash ||= klass.default_configuration.dup
         end
         private :configuration_hash
-        
+
         define_method :configuration_methods do
           klass.configuration_methods
         end
-        
+
       end
     end
-    
+
     module InstanceMethods
-      
+
       def configure(&block)
         yield ConfigurationProxy.new(self)
+        self
       end
-    
+
       def configure_with(configurer, *args, &block)
+        configurer = configurer_for(configurer) if configurer.is_a?(Symbol)
         configurer.apply_configuration(self, *args)
         configure(&block) if block
+        self
       end
-    
+
       def configuration
         configuration_hash.dup
       end
@@ -45,22 +48,22 @@ module Dragonfly
       end
 
     end
-    
+
     module ClassMethods
-      
+
       def default_configuration
         @default_configuration ||= {}
       end
-      
+
       def configuration_methods
         @configuration_methods ||= []
       end
-      
+
       private
-      
+
       def configurable_attr attribute, default=nil, &blk
         default_configuration[attribute] = blk || default
-        
+
         # Define the reader
         define_method(attribute) do
           if configuration_hash[attribute].respond_to? :call
@@ -68,28 +71,28 @@ module Dragonfly
           end
           configuration_hash[attribute]
         end
-        
+
         # Define the writer
         define_method("#{attribute}=") do |value|
           configuration_hash[attribute] = value
         end
-        
+
         configuration_method attribute
         configuration_method "#{attribute}="
       end
-      
+
       def configuration_method(*method_names)
         configuration_methods.push(*method_names.map{|n| n.to_sym })
       end
-      
+
     end
-    
+
     class ConfigurationProxy
-      
+
       def initialize(owner)
         @owner = owner
       end
-      
+
       def method_missing(method_name, *args, &block)
         if owner.has_configuration_method?(method_name)
           owner.send(method_name, *args, &block)
@@ -99,16 +102,16 @@ module Dragonfly
           raise BadConfigAttribute, "You tried to configure using '#{method_name.inspect}',  but the valid config attributes are #{owner.configuration_methods.map{|a| %('#{a.inspect}') }.sort.join(', ')}"
         end
       end
-      
+
       private
-      
+
       attr_reader :owner
-      
+
       def nested_configurable?(method, *args)
         owner.respond_to?(method) && owner.send(method, *args).is_a?(Configurable)
       end
-      
+
     end
-    
+
   end
 end

data/lib/dragonfly/core_ext/object.rb

@@ -5,4 +5,4 @@ class Object
     respond_to?(:empty?) ? empty? : !self
   end
   
-end
+end

data/lib/dragonfly/data_storage/file_data_store.rb

@@ -3,23 +3,24 @@ require 'pathname'
 module Dragonfly
   module DataStorage
 
-    class FileDataStore < Base
+    class FileDataStore
 
       include Configurable
-    
-      configurable_attr :root_path, '/var/tmp/dragonfly'
 
-      def store(temp_object)
+      configurable_attr :root_path, '/var/tmp/dragonfly'
 
-        relative_path = relative_storage_path(temp_object.basename || 'file')
+      def store(temp_object, opts={})
+        filename = temp_object.name || 'file'
 
+        relative_path = relative_path_for(filename)
         begin
-          while File.exist?(storage_path = absolute_storage_path(relative_path))
-            relative_path = increment_path(relative_path)
+          while File.exist?(path = absolute_path(relative_path))
+            filename = disambiguate(filename)
+            relative_path = relative_path_for(filename)
           end
-          storage_dir = File.dirname(storage_path)
-          FileUtils.mkdir_p(storage_dir) unless File.exist?(storage_dir)
-          FileUtils.cp temp_object.path, storage_path
+          prepare_path(path)
+          temp_object.to_file(path).close
+          store_extra_data(path, temp_object)
         rescue Errno::EACCES => e
           raise UnableToStore, e.message
         end
@@ -28,33 +29,33 @@ module Dragonfly
       end
 
       def retrieve(relative_path)
-        File.new(absolute_storage_path(relative_path))
+        path = absolute_path(relative_path)
+        [
+          File.new(path),
+          retrieve_extra_data(path)
+        ]
       rescue Errno::ENOENT => e
         raise DataNotFound, e.message
       end
 
       def destroy(relative_path)
-        FileUtils.rm absolute_storage_path(relative_path)
-        containing_directory = Pathname.new(relative_path).dirname
-        containing_directory.ascend do |relative_dir|
-          dir = absolute_storage_path(relative_dir)
-          FileUtils.rmdir dir if directory_empty?(dir)
-        end
+        path = absolute_path(relative_path)
+        FileUtils.rm path
+        FileUtils.rm extra_data_path(path)
+        purge_empty_directories(relative_path)
       rescue Errno::ENOENT => e
         raise DataNotFound, e.message
       end
 
-      private
-    
-      def increment_path(path)
-        path.sub(/(_(\d+))?$/){ $1 ? "_#{$2.to_i+1}" : '_2' }
+      def disambiguate(filename)
+        basename = File.basename(filename, '.*')
+        extname = File.extname(filename)
+        "#{basename}_#{Time.now.usec.to_s(32)}#{extname}"
       end
 
-      def relative_storage_path(suffix)
-        "#{Time.now.strftime '%Y/%m/%d/%H%M%S'}_#{suffix}"
-      end
-      
-      def absolute_storage_path(relative_path)
+      private
+
+      def absolute_path(relative_path)
         File.join(root_path, relative_path)
       end
 
@@ -62,6 +63,38 @@ module Dragonfly
         Dir.entries(path) == ['.','..']
       end
 
+      def extra_data_path(data_path)
+        "#{data_path}.extra"
+      end
+
+      def relative_path_for(filename)
+        "#{Time.now.strftime '%Y/%m/%d'}/#{filename.gsub(/[^\w.]+/,'_')}"
+      end
+      
+      def store_extra_data(data_path, temp_object)
+        File.open(extra_data_path(data_path), 'w') do |f|
+          f.write Marshal.dump(temp_object.attributes)
+        end
+      end
+      
+      def retrieve_extra_data(data_path)
+        path = extra_data_path(data_path)
+        File.exist?(path) ? Marshal.load(File.read(path)) : {}
+      end
+      
+      def prepare_path(path)
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      end
+      
+      def purge_empty_directories(path)
+        containing_directory = Pathname.new(path).dirname
+        containing_directory.ascend do |relative_dir|
+          dir = absolute_path(relative_dir)
+          FileUtils.rmdir dir if directory_empty?(dir)
+        end
+      end
+      
     end
 
   end

data/lib/dragonfly/data_storage/mongo_data_store.rb

@@ -0,0 +1,65 @@
+require 'mongo'
+
+module Dragonfly
+  module DataStorage
+    class MongoDataStore
+
+      include Configurable
+      include Serializer
+
+      configurable_attr :host
+      configurable_attr :port
+      configurable_attr :database, 'dragonfly'
+
+      def initialize(opts={})
+        self.host = opts[:host]
+        self.port = opts[:port]
+        self.database = opts[:database] if opts[:database]
+      end
+
+      def store(temp_object, opts={})
+        temp_object.file do |f|
+          mongo_id = grid.put(f, :metadata => marshal_encode(temp_object.attributes))
+          mongo_id.to_s
+        end
+      end
+
+      def retrieve(uid)
+        grid_io = grid.get(bson_id(uid))
+        extra = marshal_decode(grid_io.metadata)
+        extra[:meta].merge!(:stored_at => grid_io.upload_date)
+        [
+          grid_io.read,
+          extra
+        ]
+      rescue Mongo::GridFileNotFound, BSON::InvalidObjectID => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def destroy(uid)
+        grid.delete(bson_id(uid))
+      rescue Mongo::GridFileNotFound, BSON::InvalidObjectID => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      private
+
+      def connection
+        @connection ||= Mongo::Connection.new(host, port)
+      end
+
+      def db
+        @db ||= connection.db(database)
+      end
+
+      def grid
+        @grid ||= Mongo::Grid.new(db)
+      end
+
+      def bson_id(uid)
+        BSON::ObjectID.from_string(uid)
+      end
+
+    end
+  end
+end

data/lib/dragonfly/data_storage/s3data_store.rb

@@ -3,16 +3,23 @@ require 'aws/s3'
 module Dragonfly
   module DataStorage
 
-    class S3DataStore < Base
-  
+    class S3DataStore
+
       include Configurable
       include AWS::S3
-  
+      include Serializer
+
       configurable_attr :bucket_name
       configurable_attr :access_key_id
       configurable_attr :secret_access_key
       configurable_attr :use_filesystem, true
 
+      def initialize(opts={})
+        self.bucket_name = opts[:bucket_name]
+        self.access_key_id = opts[:access_key_id]
+        self.secret_access_key = opts[:secret_access_key]
+      end
+
       def connect!
         AWS::S3::Base.establish_connection!(
           :access_key_id => access_key_id,
@@ -24,22 +31,27 @@ module Dragonfly
         Bucket.create(bucket_name) unless bucket_names.include?(bucket_name)
       end
 
-      def store(temp_object)
-        uid = generate_uid(temp_object.basename || 'file')
+      def store(temp_object, opts={})
+        uid = generate_uid(temp_object.name || 'file')
         ensure_initialized
         object = use_filesystem ? temp_object.file : temp_object.data
-        S3Object.store(uid, object, bucket_name)
+        extra_data = temp_object.attributes
+        S3Object.store(uid, object, bucket_name, s3_metadata_for(extra_data))
         object.close if use_filesystem
         uid
       end
 
       def retrieve(uid)
         ensure_initialized
-        S3Object.value(uid, bucket_name)
+        s3_object = S3Object.find(uid, bucket_name)
+        [
+          s3_object.value,
+          parse_s3_metadata(s3_object.metadata)
+        ]
       rescue AWS::S3::NoSuchKey => e
         raise DataNotFound, "#{e} - #{uid}"
       end
-  
+
       def destroy(uid)
         ensure_initialized
         S3Object.delete(uid, bucket_name)
@@ -61,12 +73,19 @@ module Dragonfly
         end
       end
 
-      def generate_uid(suffix)
-        time = Time.now
-        "#{time.strftime '%Y/%m/%d/%H/%M/%S'}/#{rand(1000)}/#{suffix}"
+      def generate_uid(name)
+        "#{Time.now.strftime '%Y/%m/%d/%H/%M/%S'}/#{rand(1000)}/#{name.gsub(/[^\w.]+/, '_')}"
+      end
+
+      def s3_metadata_for(extra_data)
+        {'x-amz-meta-extra' => marshal_encode(extra_data)}
+      end
+
+      def parse_s3_metadata(metadata)
+        marshal_decode(metadata['x-amz-meta-extra'])
       end
 
     end
-    
+
   end
 end