fog-dragonfly 0.8.1

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/image_magick.rb

@@ -0,0 +1,41 @@
+module Dragonfly
+  module Config
+
+    # ImageMagick is a saved configuration for Dragonfly apps, which does the following:
+    # - registers an imagemagick analyser
+    # - registers an imagemagick processor
+    # - registers an imagemagick encoder
+    # - adds thumb shortcuts like '280x140!', etc.
+    # Look at the source code for apply_configuration to see exactly how it configures the app.
+    module ImageMagick
+
+      def self.apply_configuration(app, opts={})
+        app.configure do |c|
+          c.analyser.register(Analysis::ImageMagickAnalyser)
+          c.processor.register(Processing::ImageMagickProcessor)
+          c.encoder.register(Encoding::ImageMagickEncoder)
+          c.generator.register(Generation::ImageMagickGenerator)
+
+          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
+          c.job :convert do |args, format|
+            process :convert, args, format
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/dragonfly/config/r_magick.rb

@@ -0,0 +1,46 @@
+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, opts={})
+        use_filesystem = opts.has_key?(:use_filesystem) ? opts[:use_filesystem] : true
+        app.configure do |c|
+          c.analyser.register(Analysis::RMagickAnalyser) do |a|
+            a.use_filesystem = use_filesystem
+          end
+          c.processor.register(Processing::RMagickProcessor) do |p|
+            p.use_filesystem = use_filesystem
+          end
+          c.encoder.register(Encoding::RMagickEncoder) do |e|
+            e.use_filesystem = use_filesystem
+          end
+          c.generator.register(Generation::RMagickGenerator) do |g|
+            g.use_filesystem = use_filesystem
+          end
+          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.rb

@@ -0,0 +1,17 @@
+module Dragonfly
+  module Config
+
+    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}" if c.datastore.is_a?(DataStorage::FileDataStore)
+          c.url_path_prefix = '/media'
+          c.analyser.register(Analysis::FileCommandAnalyser)
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/configurable.rb

@@ -0,0 +1,119 @@
+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,
+        # e.g. if we've included it in an eigenclasse
+        define_method :configuration_hash do
+          @configuration_hash ||= klass.default_configuration.dup
+        end
+        private :configuration_hash
+
+        define_method :configuration_methods do
+          klass.configuration_methods
+        end
+
+      end
+    end
+
+    class DeferredBlock < Proc; 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
+
+      def has_configuration_method?(method_name)
+        configuration_methods.include?(method_name.to_sym)
+      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 ? DeferredBlock.new(&blk) : default
+
+        # Define the reader
+        define_method(attribute) do
+          if configuration_hash[attribute].is_a?(DeferredBlock)
+            configuration_hash[attribute] = configuration_hash[attribute].call
+          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)
+        elsif nested_configurable?(method_name, *args)
+          owner.send(method_name, *args)
+        else
+          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

@@ -0,0 +1,8 @@
+class Object
+  
+  # Will eventually get this by cherry-picking from activesupport
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+  
+end

data/lib/dragonfly/core_ext/string.rb

@@ -0,0 +1,9 @@
+class String
+  
+  # Ruby 1.8 reports methods as strings,
+  # whereas 1.9 reports them as symbols
+  def to_method_name
+    RUBY_VERSION =~ /^1.8/ ? self : to_sym
+  end
+  
+end

data/lib/dragonfly/core_ext/symbol.rb

@@ -0,0 +1,9 @@
+class Symbol
+  
+  # Ruby 1.8 reports methods as strings,
+  # whereas 1.9 reports them as symbols
+  def to_method_name
+    RUBY_VERSION =~ /^1.8/ ? to_s : self
+  end
+  
+end

data/lib/dragonfly/data_storage.rb

@@ -0,0 +1,9 @@
+module Dragonfly
+  module DataStorage
+
+    # Exceptions
+    class DataNotFound < StandardError; end
+    class UnableToStore < StandardError; end
+
+  end
+end

data/lib/dragonfly/data_storage/file_data_store.rb

@@ -0,0 +1,114 @@
+require 'pathname'
+
+module Dragonfly
+  module DataStorage
+
+    class FileDataStore
+
+      include Configurable
+
+      configurable_attr :root_path, '/var/tmp/dragonfly'
+
+      def store(temp_object, opts={})
+        relative_path = if opts[:path]
+          opts[:path]
+        else
+          filename = temp_object.name || 'file'
+          relative_path = relative_path_for(filename)
+        end
+
+        begin
+          path = absolute(relative_path)
+          until !File.exist?(path)
+            path = disambiguate(path)
+          end
+          prepare_path(path)
+          temp_object.to_file(path).close
+          store_extra_data(path, temp_object)
+        rescue Errno::EACCES => e
+          raise UnableToStore, e.message
+        end
+
+        relative(path)
+      end
+
+      def retrieve(relative_path)
+        path = absolute(relative_path)
+        file = File.new(path)
+        file.close
+        [
+          file,
+          retrieve_extra_data(path)
+        ]
+      rescue Errno::ENOENT => e
+        raise DataNotFound, e.message
+      end
+
+      def destroy(relative_path)
+        path = absolute(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
+
+      def disambiguate(path)
+        dirname = File.dirname(path)
+        basename = File.basename(path, '.*')
+        extname = File.extname(path)
+        "#{dirname}/#{basename}_#{Time.now.usec.to_s(32)}#{extname}"
+      end
+
+      private
+
+      def absolute(relative_path)
+        File.join(root_path, relative_path)
+      end
+
+      def relative(absolute_path)
+        absolute_path[/^#{root_path}\/?(.*)$/, 1]
+      end
+
+      def directory_empty?(path)
+        Dir.entries(path) == ['.','..']
+      end
+
+      def extra_data_path(data_path)
+        "#{data_path}.extra"
+      end
+
+      def relative_path_for(filename)
+        time = Time.now
+        msec = time.usec / 1000
+        "#{time.strftime '%Y/%m/%d/%H_%M_%S'}_#{msec}_#{filename.gsub(/[^\w.]+/,'_')}"
+      end
+
+      def store_extra_data(data_path, temp_object)
+        File.open(extra_data_path(data_path), 'wb') 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) ?  File.open(path,'rb'){|f| Marshal.load(f.read) } : {}
+      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(relative_dir)
+          FileUtils.rmdir dir if directory_empty?(dir)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/dragonfly/data_storage/mongo_data_store.rb

@@ -0,0 +1,82 @@
+require 'mongo'
+
+module Dragonfly
+  module DataStorage
+    class MongoDataStore
+
+      include Configurable
+      include Serializer
+
+      configurable_attr :host
+      configurable_attr :port
+      configurable_attr :database, 'dragonfly'
+      configurable_attr :username
+      configurable_attr :password
+
+      # Mongo gem deprecated ObjectID in favour of ObjectId
+      OBJECT_ID = defined?(BSON::ObjectId) ? BSON::ObjectId : BSON::ObjectID
+      INVALID_OBJECT_ID = defined?(BSON::InvalidObjectId) ? BSON::InvalidObjectId : BSON::InvalidObjectID
+
+      def initialize(opts={})
+        self.host = opts[:host]
+        self.port = opts[:port]
+        self.database = opts[:database] if opts[:database]
+        self.username = opts[:username]
+        self.password = opts[:password]
+      end
+
+      def store(temp_object, opts={})
+        ensure_authenticated!
+        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)
+        ensure_authenticated!
+        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, INVALID_OBJECT_ID => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def destroy(uid)
+        ensure_authenticated!
+        grid.delete(bson_id(uid))
+      rescue Mongo::GridFileNotFound, INVALID_OBJECT_ID => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def connection
+        @connection ||= Mongo::Connection.new(host, port)
+      end
+
+      def db
+        @db ||= connection.db(database)
+      end
+
+      def grid
+        @grid ||= Mongo::Grid.new(db)
+      end
+
+      private
+
+      def ensure_authenticated!
+        if username
+          @authenticated ||= db.authenticate(username, password)
+        end
+      end
+      
+      def bson_id(uid)
+        OBJECT_ID.from_string(uid)
+      end
+
+    end
+  end
+end