dragonfly 0.1.6 → 0.2.1

data/lib/dragonfly/analysis/base.rb

@@ -1,10 +1,13 @@
 module Dragonfly
   module Analysis
     class Base
-      
-      def mime_type(temp_object)
+
+      include Delegatable
+
+      def mime_type(*args)
+        throw :unable_to_handle
       end
-      
+
     end
   end
 end

data/lib/dragonfly/analysis/r_magick_analyser.rb

@@ -1,5 +1,4 @@
 require 'rmagick'
-require 'mime/types'
 
 module Dragonfly
   module Analysis
@@ -14,11 +13,6 @@ module Dragonfly
         rmagick_image(image).rows
       end
       
-      def mime_type(image)
-        MIME::Types.type_for(rmagick_image(image).format).first.to_s
-      rescue Magick::ImageMagickError
-      end
-      
       def depth(image)
         rmagick_image(image).depth
       end

data/lib/dragonfly/app.rb

@@ -19,10 +19,12 @@ module Dragonfly
   # @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.encoder = Encoding::RMagickEncoder.new   # See Encoding::Base for how to create a custom encoder
-  #   c.log = Logger.new('/tmp/my.log')          
-  #   c.cache_duration = 3000                    # seconds
+  #   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
@@ -32,12 +34,6 @@ module Dragonfly
   #   c.datastore.configure do |d|    # configuration depends on which data store you use
   #     # ...
   #   end
-  #   c.analyser.configure do |a|     # see Analysis::Analyser
-  #     # ...
-  #   end
-  #   c.processor.configure do |p|    # see Processing::Processor
-  #     # ...
-  #   end
   #   c.parameters.configure do |p|   # see Parameters (class methods)
   #     # ...
   #   end
@@ -70,40 +66,41 @@ module Dragonfly
       def apps
         @apps ||= {}
       end
-            
+    
     end
     
     def initialize
-      @analyser = Analysis::Analyser.new
-      @processor = Processing::Processor.new
+      @analysers, @processors, @encoders = Delegator.new, Delegator.new, Delegator.new
       @parameters_class = Class.new(Parameters)
       @url_handler = UrlHandler.new(@parameters_class)
       initialize_temp_object_class
     end
     
-    # @see Analysis::Analyser
-    attr_reader :analyser
-    # @see Processing::Processor
-    attr_reader :processor
-    # @see Encoding::Base
-    attr_reader :encoder
+    # @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
+    # @see TempObject, and ExtendedTempObject
+    attr_reader :temp_object_class
 
     alias parameters parameters_class
     
     extend Forwardable
     def_delegator :url_handler, :url_for
+    def_delegator :datastore, :destroy
     
     include Configurable
     
     configurable_attr :datastore do DataStorage::FileDataStore.new end
-    configurable_attr :encoder do Encoding::TransparentEncoder.new end
     configurable_attr :log do Logger.new('/var/tmp/dragonfly.log') end
-    configurable_attr :cache_duration, 3600*24*365 # Defaults to 1 year
-    configurable_attr :fallback_mime_type, 'application/octet-stream'
+    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.
     #
@@ -127,16 +124,17 @@ module Dragonfly
         "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
 
-    # 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))
+    # 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)
+      temp_object_class.new(initialization_object)
     end
 
     # Fetch an object from the database and optionally transform
@@ -156,22 +154,42 @@ module Dragonfly
       temp_object.transform(*args)
     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)
-      temp_object_class.new(initialization_object)
+    def generate(*args)
+      create_object(processors.generate(*args))
+    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
+
     private
     
-    # @private
-    attr_reader :temp_object_class
-    
     def initialize_temp_object_class
       @temp_object_class = Class.new(ExtendedTempObject)
       @temp_object_class.app = self
     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}"
+    end
+
   end
 end

data/lib/dragonfly/configurable.rb

@@ -93,7 +93,7 @@ module Dragonfly
         if owner.has_configuration_method?(method_name)
           owner.send(method_name, *args, &block)
         elsif nested_configurable?(method_name, *args)
-          owner.send(method_name, *args).configure(&block)
+          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

data/lib/dragonfly/data_storage/file_data_store.rb

@@ -1,3 +1,5 @@
+require 'pathname'
+
 module Dragonfly
   module DataStorage
 
@@ -12,7 +14,7 @@ module Dragonfly
         suffix = if temp_object.name.blank?
           'file'
         else
-          temp_object.name
+          temp_object.name.sub(/\.[^.]*?$/, '')
         end
         relative_path = relative_storage_path(suffix)
 
@@ -20,20 +22,18 @@ module Dragonfly
           while File.exist?(storage_path = absolute_storage_path(relative_path))
             relative_path = increment_path(relative_path)
           end
-          FileUtils.mkdir_p File.dirname(storage_path) unless File.exist?(storage_path)
+          storage_dir = File.dirname(storage_path)
+          FileUtils.mkdir_p(storage_dir) unless File.exist?(storage_dir)
           FileUtils.cp temp_object.path, storage_path
         rescue Errno::EACCES => e
           raise UnableToStore, e.message
         end
       
-        relative_path.sub(/\.[^.]*?$/, '')
+        relative_path
       end
 
-      def retrieve(uid)
-        pattern = "#{absolute_storage_path(uid)}*"
-        entries = Dir[pattern]
-        raise DataNotFound, "Couldn't find any files matching #{pattern}" if entries.empty?
-        File.new(entries.first)
+      def retrieve(relative_path)
+        File.new(absolute_storage_path(relative_path))
       rescue Errno::ENOENT => e
         raise DataNotFound, e.message
       end

data/lib/dragonfly/delegatable.rb

@@ -0,0 +1,14 @@
+module Dragonfly
+  module Delegatable
+
+    def delegatable_methods
+      if @delegatable_methods
+        @delegatable_methods
+      else
+        ancestors = self.class.ancestors
+        @delegatable_methods = ancestors[0...ancestors.index(Delegatable)].map{|i| i.instance_methods(false) }.flatten
+      end
+    end
+
+  end
+end

data/lib/dragonfly/delegator.rb

@@ -0,0 +1,50 @@
+module Dragonfly
+  class Delegator
+    
+    # This gets raised if no delegated objects are able to handle
+    # the method call, even though they respond to that method.
+    class UnableToHandle < StandardError; end
+    
+    def register(klass, *args, &block)
+      object = klass.new(*args)
+      object.configure(&block) if block
+      registered_objects << object
+    end
+    
+    def unregister(klass)
+      registered_objects.delete_if{|obj| obj.is_a?(klass) }
+    end
+    
+    def unregister_all
+      self.registered_objects = []
+    end
+    
+    def registered_objects
+      @registered_objects ||= []
+    end
+    
+    def callable_methods
+      registered_objects.map{|a| a.delegatable_methods }.flatten.uniq
+    end
+    
+    def has_callable_method?(method)
+      callable_methods.include?(method.to_s)
+    end
+    
+    private
+    
+    attr_writer :registered_objects
+    
+    def method_missing(meth, *args)
+      registered_objects.reverse.each do |object|
+        catch :unable_to_handle do
+          return object.send(meth, *args) if object.respond_to?(meth)
+        end
+      end
+      raise UnableToHandle, "None of the registered objects for #{self} were able to deal with the method call " +
+        "#{meth}(#{args.map{|a| a.inspect[0..100]}.join(',')}), even though the method is implemented" if self.has_callable_method?(meth)
+      super
+    end
+    
+  end
+end

data/lib/dragonfly/encoding/base.rb

@@ -1,13 +1,13 @@
 module Dragonfly
-  module Encoding
-    
+  module Encoding    
     class Base
-      
-      def encode(temp_object, format, options={})
-        raise NotImplementedError
+
+      include Delegatable
+
+      def encode(*args)
+        throw :unable_to_handle
       end
-      
+
     end
-    
   end
 end

data/lib/dragonfly/encoding/r_magick_encoder.rb

@@ -5,7 +5,10 @@ module Dragonfly
     
     class RMagickEncoder < Base
       
+      SUPPORTED_FORMATS = Magick.formats.select{|k,v| v =~ /.*rw./ }.map{|f| f.first.downcase }
+      
       def encode(image, format, encoding={})
+        throw :unable_to_handle unless SUPPORTED_FORMATS.include?(format.to_s)
         encoded_image = Magick::Image.from_blob(image.data).first
         encoded_image.format = format.to_s
         encoded_image.to_blob

data/lib/dragonfly/encoding/transparent_encoder.rb

@@ -5,7 +5,7 @@ module Dragonfly
       
       # Does nothing
       def encode(temp_object, format, encoding={})
-        temp_object.file
+        temp_object
       end
       
     end

data/lib/dragonfly/extended_temp_object.rb

@@ -35,25 +35,31 @@ module Dragonfly
       self
     end
     
+    # As we create customly configured subclasses of this class, the console
+    # gives a confusing output when inspecting, so modify here
+    def inspect
+      super.sub('Class:','Custom Dragonfly::ExtendedTempObject:')
+    end
+    
     # Modify methods, public_methods and respond_to?, because method_missing
     # allows methods from the analyser
     
     def methods(*args)
-      (super + analyser.analysis_methods).uniq
+      (super + analyser.callable_methods).uniq
     end
     
     def public_methods(*args)
-      (super + analyser.analysis_methods).uniq
+      (super + analyser.callable_methods).uniq
     end
     
     def respond_to?(method)
-      super || analyser.has_analysis_method?(method)
+      super || analyser.has_callable_method?(method)
     end
 
     private
     
     def method_missing(method, *args, &block)
-      if analyser.has_analysis_method?(method)
+      if analyser.has_callable_method?(method)
         # Define the method so we don't use method_missing next time
         instance_var = "@#{method}"
         self.class.class_eval do
@@ -75,15 +81,15 @@ module Dragonfly
     end
     
     def analyser
-      app.analyser
+      app.analysers
     end
     
     def processor
-      app.processor
+      app.processors
     end
     
     def encoder
-      app.encoder
+      app.encoders
     end
     
     def parameters_class

data/lib/dragonfly/parameters.rb

@@ -17,6 +17,15 @@ module Dragonfly
       configurable_attr :default_format
       configurable_attr :default_encoding, {}
       
+      def new_with_defaults(attributes={})
+        new({
+          :processing_method => default_processing_method,
+          :processing_options => default_processing_options,
+          :format => default_format,
+          :encoding => default_encoding
+        }.merge(attributes))
+      end
+      
       def add_shortcut(*args, &block)
         if block
           block_shortcuts_of_length(args.length).unshift([args, block])
@@ -39,7 +48,7 @@ module Dragonfly
       configuration_method :hash_from_shortcut
       
       def from_shortcut(*args)
-        new(hash_from_shortcut(*args))
+        new_with_defaults(hash_from_shortcut(*args))
       end
       
       def from_args(*args)
@@ -96,17 +105,18 @@ module Dragonfly
 
     # Instance methods
 
-    attr_accessor :uid, :processing_method, :processing_options, :format, :encoding
-
     def initialize(attributes={})
       attributes = attributes.dup
-      %w(processing_method processing_options format encoding).each do |attribute|
-        instance_variable_set "@#{attribute}", (attributes.delete(attribute.to_sym) || self.class.send("default_#{attribute}"))
-      end
-      @uid = attributes.delete(:uid)
+      self.uid                = attributes.delete(:uid)
+      self.processing_method  = attributes.delete(:processing_method)
+      self.processing_options = attributes.delete(:processing_options) || {}
+      self.format             = attributes.delete(:format)
+      self.encoding           = attributes.delete(:encoding) || {}
       raise ArgumentError, "Parameters doesn't recognise the following parameters: #{attributes.keys.join(', ')}" if attributes.any?
     end
 
+    attr_accessor :uid, :processing_method, :processing_options, :format, :encoding
+    
     def [](attribute)
       send(attribute)
     end
@@ -137,10 +147,6 @@ module Dragonfly
       }
     end
 
-    def validate!
-      raise InvalidParameters, "Parameters requires that at least the uid and the format are set" if uid.nil? || format.nil?
-    end
-
     private
     
     def to_sorted_array