dragonfly 0.6.2 → 0.7.0

data/lib/dragonfly/{active_record_extensions → active_model_extensions}/class_methods.rb

@@ -1,16 +1,15 @@
 module Dragonfly
-  module ActiveRecordExtensions
+  module ActiveModelExtensions
     module ClassMethods
 
       include Validations
 
-      def register_dragonfly_app(accessor_prefix, app)
-        eigenclass = respond_to?(:metaclass) ? metaclass : singleton_class # Because rails changed the name from metaclass -> singleton_class
-        eigenclass.class_eval do
+      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 "#{accessor_prefix}_accessor" do |attribute|
-      
+          define_method macro_name do |attribute|
+
             # Prior to activerecord 3, adding before callbacks more than once does add it more than once
             before_save :save_attachments unless respond_to?(:before_save_callback_chain) && before_save_callback_chain.find(:save_attachments)
             before_destroy :destroy_attachments unless respond_to?(:before_destroy_callback_chain) && before_destroy_callback_chain.find(:destroy_attachments)

data/lib/dragonfly/{active_record_extensions → active_model_extensions}/instance_methods.rb

@@ -1,5 +1,5 @@
 module Dragonfly
-  module ActiveRecordExtensions
+  module ActiveModelExtensions
     module InstanceMethods
       
       def attachments

data/lib/dragonfly/{active_record_extensions → active_model_extensions}/validations.rb

@@ -1,16 +1,16 @@
 module Dragonfly
-  module ActiveRecordExtensions
+  module ActiveModelExtensions
     module Validations
-      
+
       private
-      
+
       def validates_property(property_name, opts)
         attrs = opts[:of] or raise ArgumentError, "you need to provide the attribute which has the property, using :of => <attribute_name>"
         attrs = [attrs].flatten #(make sure it's an array)
 
         raise ArgumentError, "you must provide either :in => [<value1>, <value2>..] or :as => <value>" unless opts[:in] || opts[:as]
         allowed_values = opts[:in] || [opts[:as]]
-        
+
         args = attrs + [opts]
         validates_each(*args) do |record, attr, attachment|
           if attachment
@@ -23,11 +23,7 @@ module Dragonfly
         end
 
       end
-      
-      def validates_mime_type_of(attribute, opts)
-        validates_property :mime_type, opts.merge(:of => attribute)
-      end
-      
+
       def expected_values_string(allowed_values)
         if allowed_values.is_a?(Range)
           "between #{allowed_values.first} and #{allowed_values.last}"

data/lib/dragonfly/analyser.rb

@@ -0,0 +1,59 @@
+module Dragonfly
+  class Analyser < FunctionManager
+    
+    include Configurable
+    configurable_attr :enable_cache, true
+    configurable_attr :cache_size, 100
+    
+    def initialize
+      super
+      analyser = self
+      @analysis_methods = Module.new do
+
+        define_method :analyser do
+          analyser
+        end
+        
+      end
+      @analysis_method_names = []
+    end
+    
+    attr_reader :analysis_methods, :analysis_method_names
+    
+    def analyse(temp_object, method, *args)
+      if enable_cache
+        key = [temp_object.object_id, method, *args]
+        cache[key] ||= call_last(method, temp_object, *args)
+      else
+        call_last(method, temp_object, *args)
+      end
+    rescue NotDefined, UnableToHandle => e
+      log.warn(e.message)
+      nil
+    end
+    
+    # Each time a function is registered with the analyser,
+    # add a method to the analysis_methods module.
+    # Expects the object that is extended to define 'analyse(method, *args)'
+    def add(name, *args, &block)
+      analysis_methods.module_eval %(
+        def #{name}(*args)
+          analyse(:#{name}, *args)
+        end
+      )
+      analysis_method_names << name.to_sym
+      super
+    end
+    
+    def clear_cache!
+      @cache = nil
+    end
+    
+    private
+    
+    def cache
+      @cache ||= SimpleCache.new(cache_size)
+    end
+    
+  end
+end

data/lib/dragonfly/analysis/file_command_analyser.rb

@@ -1,7 +1,7 @@
 module Dragonfly
   module Analysis
     
-    class FileCommandAnalyser < Base
+    class FileCommandAnalyser
       
       include Configurable
       

data/lib/dragonfly/analysis/r_magick_analyser.rb

@@ -2,45 +2,60 @@ require 'RMagick'
 
 module Dragonfly
   module Analysis
-    
-    class RMagickAnalyser < Base
-      
-      def width(image)
-        rmagick_image(image).columns
+    class RMagickAnalyser
+
+      include Loggable
+      include RMagickUtils
+
+      def width(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.columns
+        end
+      end
+
+      def height(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.rows
+        end
+      end
+
+      def aspect_ratio(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.columns.to_f / image.rows
+        end
       end
-      
-      def height(image)
-        rmagick_image(image).rows
+
+      def portrait?(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.columns <= image.rows
+        end
       end
-      
-      def aspect_ratio(image)
-        rmagick_data = rmagick_image(image)
-        rmagick_data.columns.to_f / rmagick_data.rows
+
+      def landscape?(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.columns >= image.rows
+        end
       end
-      
-      def depth(image)
-        rmagick_image(image).depth
+
+      def depth(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.depth
+        end
       end
-      
-      def number_of_colours(image)
-        rmagick_image(image).number_colors
+
+      def number_of_colours(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.number_colors
+        end
       end
       alias number_of_colors number_of_colours
 
-      def format(image)
-        rmagick_image(image).format.downcase.to_sym
-      end
-      
-      private
-      
-      def rmagick_image(image)
-        Magick::Image.from_blob(image.data).first
-      rescue Magick::ImageMagickError => e
-        log.warn("Unable to handle content in #{self.class} - got:\n#{e}")
-        throw :unable_to_handle
+      def format(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.format.downcase.to_sym
+        end
       end
-      
+
     end
-    
   end
 end

data/lib/dragonfly/app.rb

@@ -1,193 +1,101 @@
 require 'logger'
 require 'forwardable'
+require 'rack'
 
 module Dragonfly
-
-  # A Dragonfly App is the rack app which holds everything together.
-  # You can have as many app instances as you want, and they all have
-  # completely separate configuration.
-  # Each App has a name.
-  # @example
-  # Dragonfly::App[:images]   # => creates a new app named :images
-  # Dragonfly::App[:images]   # => returns the :images app
-  # Dragonfly::App[:ocr]      # => creates a new app named :ocr
-  #
-  # # The two apps can be differently configured
-  # Dragonfly::App[:images].parameters.default_format = :jpg
-  # Dragonfly::App[:ocr].parameters.default_format = :tif
-  #
-  # @example Example configuration options:
-  #
-  # Dragonfly::App[:images].configure do |c|
-  #   c.datastore = MyEC2DataStore.new                     # See DataStorage::Base for how to create a custom data store
-  #   c.register_analyser(Analysis::RMagickAnalyser)       # See Analysis::Base for how to create a custom analyser
-  #   c.register_processor(Processing::RMagickProcessor)   # See Processing::Base for how to create a custom analyser
-  #   c.register_encoder(Encoding::RMagickEncoder)         # See Encoding::Base for how to create a custom encoder
-  #   c.log = Logger.new('/tmp/my.log')
-  #   c.cache_duration = 3000                              # seconds
-  # end
-  #
-  # @example Configuration including nested items
-  #
-  # Dragonfly::App[:images].configure do |c|
-  #   # ...
-  #   c.datastore.configure do |d|    # configuration depends on which data store you use
-  #     # ...
-  #   end
-  #   c.parameters.configure do |p|   # see Parameters (class methods)
-  #     # ...
-  #   end
-  #   c.url_handler.configure do |u|   # see UrlHandler
-  #     # ...
-  #   end
-  # end
-  #
   class App
-    
-    
+
     class << self
-      
+
       private :new # Hide 'new' - need to use 'instance'
-      
-      # Get / create a Dragonfly App.
-      #
-      # Rather than using 'new', use this method to create / refer to each app.
-      #
-      # @param [Symbol] name the name of the App
-      # @return [App] either the named App or a new one with that name
+
       def instance(name)
         apps[name] ||= new
       end
-      
+
       alias [] instance
-      
+
       private
-      
+
       def apps
         @apps ||= {}
       end
-    
+
     end
-    
+
     def initialize
-      @analysers, @processors, @encoders = AnalyserList.new(self), ProcessorList.new(self), EncoderList.new(self)
-      @parameters_class = Class.new(Parameters)
-      @url_handler = UrlHandler.new(@parameters_class)
-    end
-    
-    # @see Analysis::AnalyserList
-    attr_reader :analysers
-    # @see Processing::ProcessorList
-    attr_reader :processors
-    # @see Encoding::EncoderList
-    attr_reader :encoders
-    # @see UrlHandler
-    attr_reader :url_handler
-    # @see Parameters
-    attr_reader :parameters_class
-
-    alias parameters parameters_class
-    
+      @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)
+      @job_definitions = JobDefinitions.new
+      @server = Dragonfly::SimpleEndpoint.new(self)
+    end
+
+    include Configurable
+
     extend Forwardable
-    def_delegator :url_handler, :url_for
     def_delegator :datastore, :destroy
-    
-    include Configurable
-    
+    def_delegators :new_job, :fetch, :generate, :fetch_file
+    def_delegator :server, :call
+
     configurable_attr :datastore do DataStorage::FileDataStore.new end
-    configurable_attr :log do Logger.new('/var/tmp/dragonfly.log') end
     configurable_attr :cache_duration, 3600*24*365 # (1 year)
-    configurable_attr :fallback_mime_type, 'application/octet-stream'    
-    
-    # The call method required by Rack to run.
-    #
-    # @param env the Rack env hash
-    # @return [Array] a Rack response:
-    #
-    #   - 200 status if all ok
-    #
-    #   - 400 if url recognised but parameters incorrect
-    #
-    #   - 404 if url not recognised / data not found.
-    #
-    # See the Rack documentation for more details
-    def call(env)
-      parameters = url_handler.url_to_parameters(env['PATH_INFO'], env['QUERY_STRING'])
-      temp_object = fetch(parameters.uid, parameters)
-      [200, {
-        "Content-Type" => mime_type_for(parameters.format, temp_object),
-        "Content-Length" => temp_object.size.to_s,
-        "ETag" => parameters.unique_signature,
-        "Cache-Control" => "public, max-age=#{cache_duration}"
-        }, temp_object]
-    rescue UrlHandler::IncorrectSHA, UrlHandler::SHANotGiven => e
-      warn_with_info(e.message, env)
-      [400, {"Content-Type" => "text/plain"}, [e.message]]
-    rescue UrlHandler::UnknownUrl, DataStorage::DataNotFound => e
-      [404, {"Content-Type" => 'text/plain'}, [e.message]]
-    end
-
-    # Create a temp_object from the object passed in
-    # @param [String, File, Tempfile, TempObject] initialization_object the object holding the data
-    # @return [ExtendedTempObject] a temp_object holding the data
-    def create_object(initialization_object)
-      ExtendedTempObject.new(initialization_object, self)
-    end
-
-    # Fetch an object from the database and optionally transform
-    #
-    # Note that the arguments passed in to transform are as defined by the
-    # parameter shortcuts (see Parameter class methods)
-    # @param [String] uid the string uid corresponding to the stored data object
-    # @param [*args [optional]] shortcut_args the shortcut args for transforming the object 
-    # @return [ExtendedTempObject] a temp_object holding the data
-    # @example 
-    # app = Dragonfly::App[:images]
-    # app.fetch('abcd1234')             # returns a temp_object with exactly the data that was originally stored
-    # app.fetch('abcd1234', '20x20!')   # returns a transformed temp_object, in this case with image data resized to 20x20
-    # @see Parameters
-    def fetch(uid, *args)
-      temp_object = ExtendedTempObject.new(datastore.retrieve(uid), self)
-      temp_object.transform(*args)
-    end
-
-    def generate(*args)
-      create_object(processors.generate(*args))
-    end
-
-    # Return the mime type for a given extension, from the registered list
-    # By default uses the list provided by Rack (see Rack::Mime::MIME_TYPES)
-    # If not found there, it falls back to the registered analysers (if temp_object provided).
-    # If not found there, it falls back to the configured 'fallback_mime_type'
-    # @param [Symbol, String] format the format (file-extension)
-    # @param [TempObject] temp_object (optional)
-    # @return [String] the mime-type
-    # @see register_mime_type
-    def mime_type_for(format, temp_object=nil)
-      registered_mime_types[file_ext_string(format)] || (temp_object.mime_type if temp_object.respond_to?(:mime_type)) || fallback_mime_type
-    end
-
-    # Store an object, using the configured datastore
-    # @param [String, File, Tempfile, TempObject] object the object holding the data
-    # @return [String] the uid assigned to it
-    def store(object)
-      datastore.store(create_object(object))
-    end
-
-    def register_analyser(*args, &block)
-      analysers.register(*args, &block)
-    end
-    configuration_method :register_analyser
-
-    def register_processor(*args, &block)
-      processors.register(*args, &block)
-    end
-    configuration_method :register_processor
-
-    def register_encoder(*args, &block)
-      encoders.register(*args, &block)
-    end
-    configuration_method :register_encoder
+    configurable_attr :fallback_mime_type, 'application/octet-stream'
+    configurable_attr :url_path_prefix
+    configurable_attr :url_host
+    configurable_attr :protect_from_dos_attacks, false
+    configurable_attr :secret
+    configurable_attr :log do Logger.new('/var/tmp/dragonfly.log') end
+    configurable_attr :infer_mime_type_from_file_ext, true
+
+    attr_reader :analyser
+    attr_reader :processor
+    attr_reader :encoder
+    attr_reader :generator
+    attr_reader :server
+
+    configuration_method :analyser
+    configuration_method :processor
+    configuration_method :encoder
+    configuration_method :generator
+
+    attr_accessor :job_definitions
+
+    SAVED_CONFIGS = {
+      :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)
+    end
+
+    def endpoint(job=nil, &block)
+      block ? RoutedEndpoint.new(self, &block) : JobEndpoint.new(job)
+    end
+
+    def job(name, &block)
+      job_definitions.add(name, &block)
+    end
+    configuration_method :job
+
+    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
 
     def register_mime_type(format, mime_type)
       registered_mime_types[file_ext_string(format)] = mime_type
@@ -198,15 +106,72 @@ module Dragonfly
       @registered_mime_types ||= Rack::Mime::MIME_TYPES.dup
     end
 
-    private
+    def mime_type_for(format)
+      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
+    end
+
+    def mount_path
+      url_path_prefix.blank? ? '/' : url_path_prefix
+    end
 
-    def warn_with_info(message, env)
-      log.warn "Got error: #{message}\nPath was #{env['PATH_INFO'].inspect} and query was #{env['QUERY_STRING'].inspect}"
+    def url_for(job, *args)
+      if (args.length == 1 && args.first.kind_of?(Hash)) || args.empty?
+        opts = args.first || {}
+        host = opts[:host] || url_host
+        path_prefix = opts[:path_prefix] || url_path_prefix
+        path = "#{host}#{path_prefix}#{job.to_path}"
+        path << "?#{dos_protection_query_string(job)}" if protect_from_dos_attacks
+        path
+      else
+        # Deprecation stuff - will be removed!!!
+        case args[0]
+        when /^(\d+)?x(\d+)?/
+          log.warn("DEPRECATED USE OF url_for and will be removed in the future - please use thumb(#{args.map{|a|a.inspect}.join(', ')}).url")
+          args[1] ? job.thumb(args[0], args[1]).url : job.thumb(args[0]).url
+        when :gif, :png, :jpg, :jpeg
+          log.warn("DEPRECATED USE OF url_for and will be removed in the future - please use encode(#{args.first.inspect}).url")
+          job.encode(args[0]).url
+        else
+          raise "DEPRECATED USE OF url_for - will be removed in future versions - please consult the docs"
+        end
+      end
+    end
+
+    def define_macro(mod, macro_name)
+      already_extended = (class << mod; self; end).included_modules.include?(ActiveModelExtensions)
+      mod.extend(ActiveModelExtensions) unless already_extended
+      mod.register_dragonfly_app(macro_name, self)
+    end
+
+    def define_macro_on_include(mod, macro_name)
+      app = self
+      (class << mod; self; end).class_eval do
+        alias included_without_dragonfly included
+        define_method :included_with_dragonfly do |mod|
+          included_without_dragonfly(mod)
+          app.define_macro(mod, macro_name)
+        end
+        alias included included_with_dragonfly
+      end
     end
-    
+
+    private
+
     def file_ext_string(format)
       '.' + format.to_s.downcase.sub(/^.*\./,'')
     end
 
+    def dos_protection_query_string(job)
+      server.required_params_for(job).map{|k,v| "#{k}=#{v}" }.join('&')
+    end
+
   end
 end