dragonfly 0.8.6 → 0.9.0

data/lib/dragonfly/config/heroku.rb

@@ -5,7 +5,7 @@ module Dragonfly
 
       def self.apply_configuration(app, bucket_name)
         app.configure do |c|
-          c.datastore = Dragonfly::DataStorage::S3DataStore.new
+          c.datastore = 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")

data/lib/dragonfly/config/image_magick.rb

@@ -1,41 +1,6 @@
 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
+    puts "WARNING: Dragonfly::Config::ImageMagick is DEPRECATED and will soon be removed. Please use Dragonfly::ImageMagick::Config instead."
+    ImageMagick = Dragonfly::ImageMagick::Config
   end
 end

data/lib/dragonfly/config/rails.rb

@@ -6,8 +6,11 @@ module Dragonfly
       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'
+          if c.datastore.is_a?(DataStorage::FileDataStore)
+            c.datastore.root_path = ::Rails.root.join('public/system/dragonfly', ::Rails.env).to_s
+            c.datastore.server_root = ::Rails.root.join('public').to_s
+          end
+          c.url_format = '/media/:job/:basename.:format'
           c.analyser.register(Analysis::FileCommandAnalyser)
         end
       end

data/lib/dragonfly/configurable.rb

@@ -2,26 +2,20 @@ module Dragonfly
   module Configurable
 
     # Exceptions
-    class BadConfigAttribute < StandardError; end
+    class NotConfigured < RuntimeError; end
+    class BadConfigAttribute < RuntimeError; 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
+        # We should use configured_class rather than self.class
+        # because sometimes this will be the eigenclass of an object
+        # e.g. if we configure a module, etc.
+        define_method :configured_class do
+          klass
         end
-        private :configuration_hash
-
-        define_method :configuration_methods do
-          klass.configuration_methods
-        end
-
       end
     end
 
@@ -42,19 +36,86 @@ module Dragonfly
         self
       end
 
-      def configure_with(configurer, *args, &block)
-        configurer = configurer_for(configurer) if configurer.is_a?(Symbol)
-        configurer.apply_configuration(self, *args)
+      def configure_with(config, *args, &block)
+        config = saved_config_for(config) if config.is_a?(Symbol)
+        config.apply_configuration(self, *args)
         configure(&block) if block
         self
       end
 
+      def has_config_method?(method_name)
+        config_methods.include?(method_name.to_sym)
+      end
+            
+      def config_methods
+        @config_methods ||= configured_class.config_methods.dup
+      end
+      
       def configuration
-        configuration_hash.dup
+        @configuration ||= {}
+      end
+      
+      def default_configuration
+        # Merge the default configuration of all ancestor classes/modules which are configurable
+        @default_configuration ||= [self.class, configured_class, *configured_class.ancestors].reverse.inject({}) do |default_config, klass|
+          default_config.merge!(klass.default_configuration) if klass.respond_to? :default_configuration
+          default_config
+        end
+      end
+
+      def set_config_value(key, value)
+        configuration[key] = value
+        child_configurables.each{|c| c.set_if_unset(key, value) }
+        value
+      end
+      
+      def use_as_fallback_config(other_configurable)
+        other_configurable.add_child_configurable(self)
+        self.fallback_configurable = other_configurable
+      end
+
+      protected
+
+      def add_child_configurable(obj)
+        child_configurables << obj
+        config_methods.push(*obj.config_methods)
+        fallback_configurable.config_methods.push(*obj.config_methods) if fallback_configurable
+      end
+
+      def set_if_unset(key, value)
+        set_config_value(key, value) unless set_locally?(key)
+      end
+
+      private
+      
+      attr_accessor :fallback_configurable
+      
+      def child_configurables
+        @child_configurables ||= []
+      end
+      
+      def set_locally?(key)
+        instance_variable_defined?("@#{key}")
+      end
+      
+      def default_value(key)
+        if default_configuration[key].is_a?(DeferredBlock)
+          default_configuration[key] = default_configuration[key].call
+        end
+        default_configuration[key]
       end
 
-      def has_configuration_method?(method_name)
-        configuration_methods.include?(method_name.to_sym)
+      def saved_configs
+        configured_class.saved_configs
+      end
+
+      def saved_config_for(symbol)
+        config = saved_configs[symbol]
+        if config.nil?
+          raise ArgumentError, "#{symbol.inspect} is not a known configuration - try one of #{saved_configs.keys.join(', ')}"
+        end
+        config = config.call if config.respond_to?(:call)
+        config
       end
 
     end
@@ -65,8 +126,20 @@ module Dragonfly
         @default_configuration ||= {}
       end
 
-      def configuration_methods
-        @configuration_methods ||= []
+      def config_methods
+        @config_methods ||= []
+      end
+
+      def nested_configurables
+        @nested_configurables ||= []
+      end
+
+      def register_configuration(name, config=nil, &config_in_block) 
+        saved_configs[name] = config_in_block || config
+      end
+
+      def saved_configs
+        @saved_configs ||= {}
       end
 
       private
@@ -76,15 +149,13 @@ module Dragonfly
 
         # 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]
+          configuration.has_key?(attribute) ? configuration[attribute] : default_value(attribute)
         end
 
         # Define the writer
         define_method("#{attribute}=") do |value|
-          configuration_hash[attribute] = value
+          instance_variable_set("@#{attribute}", value)
+          set_config_value(attribute, value)
         end
 
         configuration_method attribute
@@ -92,7 +163,11 @@ module Dragonfly
       end
 
       def configuration_method(*method_names)
-        configuration_methods.push(*method_names.map{|n| n.to_sym })
+        config_methods.push(*method_names.map{|n| n.to_sym }).uniq!
+      end
+      
+      def nested_configurable(*method_names)
+        nested_configurables.push(*method_names)
       end
 
     end
@@ -104,12 +179,17 @@ module Dragonfly
       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)
+        if owner.has_config_method?(method_name)
+          attribute = method_name.to_s.tr('=','').to_sym
+          if method_name.to_s =~ /=$/ && owner.has_config_method?(attribute) # a bit hacky - if it has both getter and setter, assume it's a configurable_attr
+            owner.set_config_value(attribute, args.first)
+          else
+            owner.send(method_name, *args, &block)
+          end
+        elsif nested_configurable?(method_name)
+          owner.send(method_name)
         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(', ')}"
+          raise BadConfigAttribute, "You tried to configure using '#{method_name.inspect}',  but the valid config attributes are #{owner.config_methods.map{|a| %('#{a.inspect}') }.sort.join(', ')}"
         end
       end
 
@@ -117,11 +197,11 @@ module Dragonfly
 
       attr_reader :owner
 
-      def nested_configurable?(method, *args)
-        owner.respond_to?(method) && owner.send(method, *args).is_a?(Configurable)
+      def nested_configurable?(method)
+        owner.configured_class.nested_configurables.include?(method.to_sym)
       end
 
     end
 
   end
-end
+end

data/lib/dragonfly/core_ext/object.rb

@@ -1,6 +1,6 @@
 class Object
   
-  # Will eventually get this by cherry-picking from activesupport
+  # Don't want to depend on activesupport for this
   def blank?
     respond_to?(:empty?) ? empty? : !self
   end

data/lib/dragonfly/core_ext/string.rb

@@ -5,5 +5,5 @@ class String
   def to_method_name
     RUBY_VERSION =~ /^1.8/ ? self : to_sym
   end
-  
+
 end

data/lib/dragonfly/data_storage/couch_data_store.rb

@@ -0,0 +1,84 @@
+require 'couchrest'
+
+module Dragonfly
+  module DataStorage
+    class CouchDataStore
+
+      include Configurable
+      include Serializer
+
+      configurable_attr :host, 'localhost'
+      configurable_attr :port, '5984'
+      configurable_attr :database, 'dragonfly'
+      configurable_attr :username
+      configurable_attr :password
+
+      def initialize(opts={})
+        self.host = opts[:host] if opts[:host]
+        self.port = opts[:port] if opts[:port]
+        self.database = opts[:database] if opts[:database]
+        self.username = opts[:username]
+        self.password = opts[:password]
+      end
+
+      def store(temp_object, opts={})
+        meta = opts[:meta] || {}
+        name = meta[:name] || temp_object.original_filename || 'file'
+        content_type = opts[:content_type] || opts[:mime_type] || 'application/octet-stream'
+        
+        temp_object.file do |f|
+          doc = CouchRest::Document.new(:meta => marshal_encode(meta))
+          response = db.save_doc(doc)
+          doc.put_attachment(name, f, {:content_type => content_type})
+          form_uid(response['id'], name)
+        end
+      rescue RuntimeError => e
+        raise UnableToStore, "#{e} - #{temp_object.inspect}"
+      end
+
+      def retrieve(uid)
+        doc_id, attachment = parse_uid(uid)
+        doc = db.get(doc_id)
+        [doc.fetch_attachment(attachment), marshal_decode(doc['meta'])]
+      rescue RestClient::ResourceNotFound => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def destroy(uid)
+        doc_id, attachment = parse_uid(uid)
+        doc = db.get(doc_id)
+        db.delete_doc(doc)
+      rescue RestClient::ResourceNotFound => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def db
+        @db ||= begin
+          url = "http://#{auth}#{host}:#{port}"
+          CouchRest.new(url).database!(database)
+        end
+      end
+
+      def url_for(uid, opts={})
+        doc_id, attachment = parse_uid(uid)
+        "http://#{host}:#{port}/#{database}/#{doc_id}/#{attachment}"
+      end
+      
+      private
+      
+      def auth
+        username.blank? ? nil : "#{username}:#{password}@"
+      end
+      
+      def form_uid(doc_id, attachment)
+        "#{doc_id}/#{attachment}"
+      end
+      
+      def parse_uid(uid)
+        doc_id, attachment = uid.split('/')
+        [doc_id, (attachment || 'file')]
+      end
+
+    end
+  end
+end

data/lib/dragonfly/data_storage/file_data_store.rb

@@ -7,16 +7,20 @@ module Dragonfly
 
       # Exceptions
       class BadUID < RuntimeError; end
+      class UnableToFormUrl < RuntimeError; end
 
       include Configurable
 
       configurable_attr :root_path, '/var/tmp/dragonfly'
+      configurable_attr :server_root
+      configurable_attr :store_meta, true
 
       def store(temp_object, opts={})
+        meta = opts[:meta] || {}
         relative_path = if opts[:path]
           opts[:path]
         else
-          filename = temp_object.name || 'file'
+          filename = meta[:name] || temp_object.original_filename || 'file'
           relative_path = relative_path_for(filename)
         end
 
@@ -27,7 +31,7 @@ module Dragonfly
           end
           prepare_path(path)
           temp_object.to_file(path).close
-          store_extra_data(path, temp_object)
+          store_meta_data(path, meta) if store_meta
         rescue Errno::EACCES => e
           raise UnableToStore, e.message
         end
@@ -38,26 +42,38 @@ module Dragonfly
       def retrieve(relative_path)
         validate_uid!(relative_path)
         path = absolute(relative_path)
-        file = File.new(path)
-        file.close
+        pathname = Pathname.new(path)
+        raise DataNotFound, "couldn't find file #{path}" unless pathname.exist?
         [
-          file,
-          retrieve_extra_data(path)
+          pathname,
+          (store_meta ? retrieve_meta_data(path) : {})
         ]
-      rescue Errno::ENOENT => e
-        raise DataNotFound, e.message
       end
 
       def destroy(relative_path)
         validate_uid!(relative_path)
         path = absolute(relative_path)
         FileUtils.rm path
-        FileUtils.rm extra_data_path(path)
+        FileUtils.rm_f meta_data_path(path)
+        FileUtils.rm_f deprecated_meta_data_path(path)
         purge_empty_directories(relative_path)
       rescue Errno::ENOENT => e
         raise DataNotFound, e.message
       end
 
+      def url_for(relative_path, opts={})
+        if server_root.nil?
+          raise NotConfigured, "you need to configure server_root for #{self.class.name} in order to form urls"
+        else
+          _, __, path = absolute(relative_path).partition(server_root)
+          if path.empty?
+            raise UnableToFormUrl, "couldn't form url for uid #{relative_path.inspect} with root_path #{root_path.inspect} and server_root #{server_root.inspect}"
+          else
+            path
+          end
+        end
+      end
+
       def disambiguate(path)
         dirname = File.dirname(path)
         basename = File.basename(path, '.*')
@@ -72,14 +88,18 @@ module Dragonfly
       end
 
       def relative(absolute_path)
-        absolute_path[/^#{root_path}\/?(.*)$/, 1]
+        absolute_path[/^#{Regexp.escape root_path}\/?(.*)$/, 1]
       end
 
       def directory_empty?(path)
         Dir.entries(path) == ['.','..']
       end
 
-      def extra_data_path(data_path)
+      def meta_data_path(data_path)
+        "#{data_path}.meta"
+      end
+
+      def deprecated_meta_data_path(data_path)
         "#{data_path}.extra"
       end
 
@@ -89,15 +109,20 @@ module Dragonfly
         "#{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)
+      def store_meta_data(data_path, meta)
+        File.open(meta_data_path(data_path), 'wb') do |f|
+          f.write Marshal.dump(meta)
         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) } : {}
+      def retrieve_meta_data(data_path)
+        path = meta_data_path(data_path)
+        if File.exist?(path)
+          File.open(path,'rb'){|f| Marshal.load(f.read) }
+        else
+          deprecated_path = deprecated_meta_data_path(data_path)
+          File.exist?(deprecated_path) ? File.open(deprecated_path,'rb'){|f| Marshal.load(f.read) } : {}
+        end
       end
 
       def prepare_path(path)
@@ -114,7 +139,7 @@ module Dragonfly
       end
 
       def validate_uid!(uid)
-        raise BadUID, "tried to fetch uid #{uid.inspect} - perhaps due to a malicious user" if uid['../']
+        raise BadUID, "tried to fetch uid #{uid.inspect} - perhaps due to a malicious user" if uid['..']
       end
 
     end