dragonfly 0.8.6 → 0.9.0

data/lib/dragonfly/active_model_extensions/attachment_class_methods.rb

@@ -0,0 +1,144 @@
+module Dragonfly
+  module ActiveModelExtensions
+    class Attachment
+      class << self
+    
+        class ConfigProxy
+      
+          def initialize(spec, block)
+            @spec = spec
+            instance_eval(&block)
+          end
+      
+          private
+      
+          attr_reader :spec
+      
+          def after_assign(*callbacks, &block)
+            add_callbacks(:after_assign, *callbacks, &block)
+          end
+      
+          def after_unassign(*callbacks, &block)
+            add_callbacks(:after_unassign, *callbacks, &block)
+          end
+      
+          def copy_to(accessor, &block)
+            after_assign do |a|
+              self.send "#{accessor}=", (block_given? ? instance_exec(a, &block) : a)
+            end
+            after_unassign{|a| self.send("#{accessor}=", nil) }
+          end
+      
+          def storage_opts(opts=nil, &block)
+            spec.storage_opts_specs << (opts || block)
+          end
+
+          def storage_opt(key, value, &block)
+            if value.is_a? Symbol
+              storage_opts{|a| {key => send(value)} }
+            elsif block_given?
+              storage_opts{|a| {key => instance_exec(a, &block)} }
+            else
+              storage_opts{|a| {key => value} }
+            end
+          end
+      
+          def add_callbacks(name, *callbacks, &block)
+            if block_given?
+              spec.callbacks[name] << block
+            else
+              spec.callbacks[name].push(*callbacks)
+            end
+          end
+      
+          def method_missing(meth, *args, &block)
+            if meth.to_s =~ /^storage_(.*)$/
+              storage_opt($1.to_sym, args.first, &block)
+            else
+              super
+            end
+          end
+      
+        end
+    
+        def init(model_class, attribute, app, config_block)
+          @model_class, @attribute, @app, @config_block = model_class, attribute, app, config_block
+          include app.analyser.analysis_methods
+          include app.job_definitions
+          define_method :format do
+            job.format
+          end
+          define_method :mime_type do
+            job.mime_type
+          end
+          ConfigProxy.new(self, config_block) if config_block
+          self
+        end
+
+        attr_reader :model_class, :attribute, :app, :config_block
+
+        # Callbacks
+        def callbacks
+          @callbacks ||= Hash.new{|h,k| h[k] = [] }
+        end
+    
+        def run_callbacks(name, model, attachment)
+          attachment.should_run_callbacks = false
+          callbacks[name].each do |callback|
+            case callback
+            when Symbol then model.send(callback)
+            when Proc then model.instance_exec(attachment, &callback)
+            end
+          end
+          attachment.should_run_callbacks = true
+        end
+
+        # Magic attributes
+        def allowed_magic_attributes
+          app.analyser.analysis_method_names + [:size, :basename, :name, :ext, :meta]
+        end
+
+        def magic_attributes
+          @magic_attributes ||= begin
+            prefix = attribute.to_s + '_'
+            model_class.public_instance_methods.inject([]) do |attrs, name|
+              _, __, suffix  = name.to_s.partition(prefix)
+              if !suffix.empty? && allowed_magic_attributes.include?(suffix.to_sym)
+                attrs << suffix.to_sym
+              end
+              attrs
+            end
+          end
+        end
+
+        def ensure_uses_cached_magic_attributes
+          return if @uses_cached_magic_attributes
+          magic_attributes.each do |attr|
+            define_method attr do
+              magic_attribute_for(attr)
+            end
+          end
+          @uses_cached_magic_attributes = true
+        end
+
+        # Storage options
+        def storage_opts_specs
+          @storage_opts_specs ||= []
+        end
+    
+        def evaluate_storage_opts(model, attachment)
+          storage_opts_specs.inject({}) do |opts, spec|
+            options = case spec
+            when Proc then model.instance_exec(attachment, &spec)
+            when Symbol then model.send(spec)
+            else spec
+            end
+            opts.merge!(options)
+            opts
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/dragonfly/active_model_extensions/class_methods.rb

@@ -7,15 +7,15 @@ module Dragonfly
       def register_dragonfly_app(macro_name, app)
         (class << self; self; end).class_eval do
     
-          # Defines e.g. 'image_accessor' for any activerecord class body
-          define_method macro_name do |attribute|
+          # Defines e.g. 'image_accessor' for any activemodel class body
+          define_method macro_name do |attribute, &config_block|
 
-            # Prior to activerecord 3, adding before callbacks more than once does add it more than once
-            before_save :save_dragonfly_attachments unless respond_to?(:before_save_callback_chain) && before_save_callback_chain.find(:save_dragonfly_attachments)
-            before_destroy :destroy_dragonfly_attachments unless respond_to?(:before_destroy_callback_chain) && before_destroy_callback_chain.find(:destroy_dragonfly_attachments)
+            # Add callbacks
+            before_save :save_dragonfly_attachments
+            before_destroy :destroy_dragonfly_attachments
       
             # Register the new attribute
-            dragonfly_apps_for_attributes[attribute] = app
+            dragonfly_attachment_classes << new_dragonfly_attachment_class(attribute, app, config_block)
             
             # Define the setter for the attribute
             define_method "#{attribute}=" do |value|
@@ -27,19 +27,72 @@ module Dragonfly
               dragonfly_attachments[attribute].to_value
             end
       
+            # Define the URL setter
+            define_method "#{attribute}_url=" do |url|
+              unless url.blank?
+                dragonfly_attachments[attribute].assign(app.fetch_url(url))
+              end
+            end
+      
+            # Define the URL getter
+            define_method "#{attribute}_url" do
+              nil
+            end
+
+            # Define the remove setter
+            define_method "remove_#{attribute}=" do |value|
+              unless [0, "0", false, "false", "", nil].include?(value)
+                dragonfly_attachments[attribute].assign(nil)
+                instance_variable_set("@remove_#{attribute}", true)
+              end
+            end
+
+            # Define the remove getter
+            attr_reader "remove_#{attribute}"
+
+            # Define the retained setter
+            define_method "retained_#{attribute}=" do |string|
+              unless string.blank?
+                begin
+                  dragonfly_attachments[attribute].retained_attrs = Serializer.marshal_decode(string)
+                rescue Serializer::BadString => e
+                  app.log.warn("*** WARNING ***: couldn't update attachment with serialized retained_#{attribute} string #{string.inspect}")              
+                end
+              end
+              dragonfly_attachments[attribute].should_retain = true
+              dragonfly_attachments[attribute].retain!
+              string
+            end
+            
+            # Define the retained getter
+            define_method "retained_#{attribute}" do
+              attrs = dragonfly_attachments[attribute].retained_attrs
+              Serializer.marshal_encode(attrs) if attrs
+            end
+            
           end
     
         end
         app
       end
       
-      def dragonfly_apps_for_attributes
-        @dragonfly_apps_for_attributes ||= begin
+      def dragonfly_attachment_classes
+        @dragonfly_attachment_classes ||= begin
           parent_class = ancestors.select{|a| a.is_a?(Class) }[1]
-          parent_class.respond_to?(:dragonfly_apps_for_attributes) ? parent_class.dragonfly_apps_for_attributes.dup : {}
+          if parent_class.respond_to?(:dragonfly_attachment_classes)
+            parent_class.dragonfly_attachment_classes.map do |klass|
+              new_dragonfly_attachment_class(klass.attribute, klass.app, klass.config_block)
+            end
+          else
+            []
+          end
         end
       end
       
+      def new_dragonfly_attachment_class(attribute, app, config_block)
+        Class.new(Attachment).init(self, attribute, app, config_block)
+      end
+      
     end
   end
 end

data/lib/dragonfly/active_model_extensions/instance_methods.rb

@@ -3,8 +3,8 @@ module Dragonfly
     module InstanceMethods
       
       def dragonfly_attachments
-        @dragonfly_attachments ||= self.class.dragonfly_apps_for_attributes.inject({}) do |hash, (attribute, app)|
-          hash[attribute] = Attachment.new(app, self, attribute)
+        @dragonfly_attachments ||= self.class.dragonfly_attachment_classes.inject({}) do |hash, klass|
+          hash[klass.attribute] = klass.new(self)
           hash
         end
       end

data/lib/dragonfly/active_model_extensions/validations.rb

@@ -12,19 +12,23 @@ module Dragonfly
         allowed_values = opts[:in] || [opts[:as]]
 
         args = attrs + [opts]
-        validates_each(*args) do |record, attr, attachment|
+        validates_each(*args) do |model, attr, attachment|
           if attachment
             property = attachment.send(property_name)
-            record.errors.add(attr,
-                              opts[:message] ||
-                                "#{property_name.to_s.humanize.downcase} is incorrect. It needs to be #{expected_values_string(allowed_values)}, but was '#{property}'"
-                              ) unless allowed_values.include?(property)
+            unless allowed_values.include?(property)
+              message = opts[:message] ||
+                "#{property_name.to_s.humanize.downcase} is incorrect. "+
+                "It needs to be #{Validations.expected_values_string(allowed_values)}"+
+                (property ? ", but was '#{property}'" : "")
+              message = message.call(property, model) if message.respond_to?(:call)
+              model.errors.add(attr, message)
+            end
           end
         end
 
       end
 
-      def expected_values_string(allowed_values)
+      def self.expected_values_string(allowed_values)
         if allowed_values.is_a?(Range)
           "between #{allowed_values.first} and #{allowed_values.last}"
         else

data/lib/dragonfly/analyser.rb

@@ -1,7 +1,6 @@
 module Dragonfly
   class Analyser < FunctionManager
     
-    include Configurable
     configurable_attr :enable_cache, true
     configurable_attr :cache_size, 100
     

data/lib/dragonfly/analysis/file_command_analyser.rb

@@ -6,7 +6,7 @@ module Dragonfly
       include Configurable
       
       configurable_attr :file_command, "file"
-      configurable_attr :use_filesystem, false
+      configurable_attr :use_filesystem, true
       configurable_attr :num_bytes_to_check, 255
       
       def mime_type(temp_object)

data/lib/dragonfly/analysis/image_magick_analyser.rb

@@ -1,47 +1,6 @@
 module Dragonfly
   module Analysis
-    class ImageMagickAnalyser
-
-      include ImageMagickUtils
-      include Configurable
-
-      def width(temp_object)
-        identify(temp_object)[:width]
-      end
-
-      def height(temp_object)
-        identify(temp_object)[:height]
-      end
-
-      def aspect_ratio(temp_object)
-        attrs = identify(temp_object)
-        attrs[:width].to_f / attrs[:height]
-      end
-
-      def portrait?(temp_object)
-        attrs = identify(temp_object)
-        attrs[:width] <= attrs[:height]
-      end
-
-      def landscape?(temp_object)
-        attrs = identify(temp_object)
-        attrs[:width] >= attrs[:height]
-      end
-
-      def depth(temp_object)
-        identify(temp_object)[:depth]
-      end
-
-      def number_of_colours(temp_object)
-        details = raw_identify(temp_object, '-verbose -unique')
-        details[/Colors: (\d+)/, 1].to_i
-      end
-      alias number_of_colors number_of_colours
-
-      def format(temp_object)
-        identify(temp_object)[:format]
-      end
-
-    end
+    puts "WARNING: Dragonfly::Analysis::ImageMagickAnalyser is DEPRECATED and will soon be removed. Please use Dragonfly::ImageMagick::Analyser instead."
+    ImageMagickAnalyser = ImageMagick::Analyser
   end
 end

data/lib/dragonfly/app.rb

@@ -25,33 +25,29 @@ module Dragonfly
 
     def initialize
       @analyser, @processor, @encoder, @generator = Analyser.new, Processor.new, Encoder.new, Generator.new
-      @analyser.use_same_log_as(self)
-      @processor.use_same_log_as(self)
-      @encoder.use_same_log_as(self)
-      @generator.use_same_log_as(self)
+      [@analyser, @processor, @encoder, @generator].each do |obj|
+        obj.use_same_log_as(self)
+        obj.use_as_fallback_config(self)
+      end
+      @server = Server.new(self)
       @job_definitions = JobDefinitions.new
-      @server = Dragonfly::SimpleEndpoint.new(self)
     end
 
     include Configurable
 
     extend Forwardable
     def_delegator :datastore, :destroy
-    def_delegators :new_job, :fetch, :generate, :fetch_file
-    def_delegator :server, :call
+    def_delegators :new_job, :fetch, :generate, :fetch_file, :fetch_url
+    def_delegators :server, :call
 
     configurable_attr :datastore do DataStorage::FileDataStore.new end
     configurable_attr :cache_duration, 3600*24*365 # (1 year)
     configurable_attr :fallback_mime_type, 'application/octet-stream'
-    configurable_attr :url_path_prefix
-    configurable_attr :url_host
-    configurable_attr :url_suffix
-    configurable_attr :protect_from_dos_attacks, false
     configurable_attr :secret, 'secret yo'
     configurable_attr :log do Logger.new('/var/tmp/dragonfly.log') end
-    configurable_attr :infer_mime_type_from_file_ext, true
+    configurable_attr :trust_file_extensions, true
     configurable_attr :content_disposition
-    configurable_attr :content_filename, Response::DEFAULT_FILENAME
+    configurable_attr :content_filename, Dragonfly::Response::DEFAULT_FILENAME
 
     attr_reader :analyser
     attr_reader :processor
@@ -59,33 +55,14 @@ module Dragonfly
     attr_reader :generator
     attr_reader :server
 
-    configuration_method :analyser
-    configuration_method :processor
-    configuration_method :encoder
-    configuration_method :generator
+    nested_configurable :server, :analyser, :processor, :encoder, :generator
 
     attr_accessor :job_definitions
 
-    SAVED_CONFIGS = {
-      :imagemagick => 'ImageMagick',
-      :image_magick => 'ImageMagick',
-      :rmagick => 'RMagick',
-      :r_magick => 'RMagick',
-      :rails => 'Rails',
-      :heroku => 'Heroku'
-    }
-
-    def configurer_for(symbol)
-      class_name = SAVED_CONFIGS[symbol]
-      if class_name.nil?
-        raise ArgumentError, "#{symbol.inspect} is not a known configuration - try one of #{SAVED_CONFIGS.keys.join(', ')}"
-      end
-      Config.const_get(class_name)
-    end
-
-    def new_job(content=nil, opts={})
-      content ? Job.new(self, TempObject.new(content, opts)) : Job.new(self)
+    def new_job(content=nil, meta={})
+      job_class.new(self, content, meta)
     end
+    alias create new_job
 
     def endpoint(job=nil, &block)
       block ? RoutedEndpoint.new(self, &block) : JobEndpoint.new(job)
@@ -96,9 +73,20 @@ module Dragonfly
     end
     configuration_method :job
 
+    def job_class
+      @job_class ||= begin
+        app = self
+        Class.new(Job).class_eval do
+          include app.analyser.analysis_methods
+          include app.job_definitions
+          include Job::OverrideInstanceMethods
+          self
+        end
+      end
+    end
+
     def store(object, opts={})
       temp_object = object.is_a?(TempObject) ? object : TempObject.new(object)
-      temp_object.extract_attributes_from(opts)
       datastore.store(temp_object, opts)
     end
 
@@ -115,29 +103,28 @@ module Dragonfly
       registered_mime_types[file_ext_string(format)]
     end
 
-    def resolve_mime_type(temp_object)
-      mime_type_for(temp_object.format)                                   ||
-        (mime_type_for(temp_object.ext) if infer_mime_type_from_file_ext) ||
-        analyser.analyse(temp_object, :mime_type)                         ||
-        mime_type_for(analyser.analyse(temp_object, :format))             ||
-        fallback_mime_type
+    def response_headers
+      @response_headers ||= {}
     end
+    configuration_method :response_headers
 
-    def mount_path
-      url_path_prefix.blank? ? '/' : url_path_prefix
+    def define_url(&block)
+      @url_proc = block
     end
+    configuration_method :define_url
 
     def url_for(job, opts={})
-      opts = opts.dup
-      host = opts.delete(:host) || url_host
-      suffix = opts.delete(:suffix) || url_suffix
-      suffix = suffix.call(job) if suffix.respond_to?(:call)
-      path_prefix = opts.delete(:path_prefix) || url_path_prefix
-      path = "#{host}#{path_prefix}#{job.to_path}#{suffix}"
-      query = opts
-      query.merge!(server.required_params_for(job)) if protect_from_dos_attacks
-      path << "?#{Rack::Utils.build_query(query)}" if query.any?
-      path
+      if @url_proc
+        @url_proc.call(self, job, opts)
+      else
+        server.url_for(job, opts)
+      end
+    end
+
+    def remote_url_for(uid, opts={})
+      datastore.url_for(uid, opts)
+    rescue NoMethodError => e
+      raise NotImplementedError, "The datastore doesn't support serving content directly - #{datastore.inspect}"
     end
 
     def define_macro(mod, macro_name)
@@ -157,9 +144,31 @@ module Dragonfly
         alias included included_with_dragonfly
       end
     end
+    
+    # Deprecated methods
+    def url_path_prefix=(thing)
+      raise NoMethodError, "url_path_prefix is deprecated - please use url_format, e.g. url_format = '/media/:job/:basename.:format' - see docs for more details"
+    end
+    configuration_method :url_path_prefix=
+
+    def url_suffix=(thing)
+      raise NoMethodError, "url_suffix is deprecated - please use url_format, e.g. url_format = '/media/:job/:basename.:format' - see docs for more details"
+    end
+    configuration_method :url_suffix=
+
+    def infer_mime_type_from_file_ext=(bool)
+      raise NoMethodError, "infer_mime_type_from_file_ext is deprecated - please use trust_file_extensions = #{bool.inspect} instead"
+    end
+    configuration_method :infer_mime_type_from_file_ext=
 
     private
 
+    attr_accessor :get_remote_url
+
+    def saved_configs
+      self.class.saved_configs
+    end
+
     def file_ext_string(format)
       '.' + format.to_s.downcase.sub(/^.*\./,'')
     end