dragonfly 0.1.0

data/lib/dragonfly/active_record_extensions/attachment.rb

@@ -0,0 +1,117 @@
+module Dragonfly
+  module ActiveRecordExtensions
+    
+    class PendingUID; def to_s; 'PENDING'; end; end
+    
+    class Attachment
+      
+      def initialize(app, parent_model, attribute_name)
+        @app, @parent_model, @attribute_name = app, parent_model, attribute_name
+      end
+      
+      def assign(value)
+        if value.nil?
+          self.uid = nil
+          reset_magic_attributes
+        else
+          self.temp_object = app.create_object(value)
+          self.uid = PendingUID.new
+          set_magic_attributes
+        end
+        value
+      end
+
+      def destroy!
+        app.datastore.destroy(previous_uid) if previous_uid
+      rescue DataStorage::DataNotFound => e
+        app.log.warn("*** WARNING ***: tried to destroy data with uid #{previous_uid}, but got error: #{e}")
+      end
+      
+      def fetch(*args)
+        app.fetch(uid, *args)
+      end
+      
+      def save!
+        if changed?
+          destroy!
+          self.uid = app.datastore.store(temp_object)
+        end
+      end
+      
+      def size
+        temp_object.size
+      end
+      
+      def temp_object
+        if @temp_object
+          @temp_object
+        elsif been_persisted?
+          @temp_object = fetch
+        end
+      end
+      
+      def to_value
+        self if been_assigned?
+      end
+      
+      def url(*args)
+        unless uid.nil? || uid.is_a?(PendingUID)
+          app.url_for(uid, *args)
+        end
+      end
+      
+      private
+      
+      def been_assigned?
+        uid
+      end
+      
+      def been_persisted?
+        uid && !uid.is_a?(PendingUID)
+      end
+      
+      def changed?
+        parent_model.send("#{attribute_name}_uid_changed?")
+      end
+      
+      def uid=(uid)
+        parent_model.send("#{attribute_name}_uid=", uid)
+      end
+      
+      def uid
+        parent_model.send("#{attribute_name}_uid")
+      end
+      
+      def previous_uid
+        parent_model.send("#{attribute_name}_uid_was")
+      end
+      
+      attr_reader :app, :parent_model, :attribute_name
+      
+      attr_writer :temp_object
+      
+      def analyser
+        app.analyser
+      end
+      
+      def magic_attributes
+        parent_model.class.column_names.select { |name|
+          name =~ /^#{attribute_name}_(.+)$/ &&
+            analyser.has_analysis_method?($1) || $1 == 'size'
+        }
+      end
+      
+      def set_magic_attributes
+        magic_attributes.each do |attribute|
+          method = attribute.sub("#{attribute_name}_", '')
+          parent_model.send("#{attribute}=", temp_object.send(method))
+        end
+      end
+      
+      def reset_magic_attributes
+        magic_attributes.each{|attribute| parent_model.send("#{attribute}=", nil) }
+      end
+      
+    end
+  end
+end

data/lib/dragonfly/active_record_extensions/class_methods.rb

@@ -0,0 +1,41 @@
+module Dragonfly
+  module ActiveRecordExtensions
+    module ClassMethods
+
+      include Validations
+
+      def register_dragonfly_app(accessor_prefix, app)
+        metaclass.class_eval do
+    
+          # Defines e.g. 'image_accessor' for any activerecord class body
+          define_method "#{accessor_prefix}_accessor" do |attribute|
+      
+            before_save :save_attached_files unless before_save_callback_chain.find(:save_attached_files)
+            before_destroy :destroy_attached_files unless before_destroy_callback_chain.find(:destroy_attached_files)
+      
+            # Register the new attribute
+            dragonfly_apps_for_attributes[attribute] = app
+            
+            # Define the setter for the attribute
+            define_method "#{attribute}=" do |value|
+              attachments[attribute].assign(value)
+            end
+      
+            # Define the getter for the attribute
+            define_method attribute do
+              attachments[attribute].to_value
+            end
+      
+          end
+    
+        end
+        app
+      end
+      
+      def dragonfly_apps_for_attributes
+        @dragonfly_apps_for_attributes ||= {}
+      end
+
+    end
+  end
+end

data/lib/dragonfly/active_record_extensions/instance_methods.rb

@@ -0,0 +1,28 @@
+module Dragonfly
+  module ActiveRecordExtensions
+    module InstanceMethods
+      
+      def attachments
+        @attachments ||= self.class.dragonfly_apps_for_attributes.inject({}) do |hash, (attribute, app)|
+          hash[attribute] = Attachment.new(app, self, attribute)
+          hash
+        end
+      end
+
+      private
+      
+      def save_attached_files
+        attachments.each do |attribute, attachment|
+          attachment.save!
+        end
+      end
+      
+      def destroy_attached_files
+        attachments.each do |attribute, attachment|
+          attachment.destroy!
+        end
+      end
+      
+    end
+  end
+end

data/lib/dragonfly/active_record_extensions/validations.rb

@@ -0,0 +1,19 @@
+module Dragonfly
+  module ActiveRecordExtensions
+    module Validations
+      
+      def validates_mime_type_of(*args)
+        opts = args.last
+        raise ArgumentError, "you must provide either :in => [(mime-types)] or :as => '(mime-type)' to validates_mime_type_of" unless opts.is_a?(::Hash) &&
+          (allowed_mime_types = opts[:in] || [opts[:as]])
+        validates_each(*args) do |record, attr, attachment|
+          if attachment
+            mime_type = attachment.temp_object.mime_type
+            record.errors.add attr, "doesn't have the correct MIME-type. It needs to be #{'one of ' if allowed_mime_types.length > 1}'#{allowed_mime_types.join('\', \'')}', but was '#{mime_type || 'unknown'}'" unless allowed_mime_types.include?(mime_type)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/active_record_extensions.rb

@@ -0,0 +1,12 @@
+module Dragonfly
+  module ActiveRecordExtensions
+
+    def self.extended(klass)
+      unless klass.include?(InstanceMethods)
+        klass.extend(ClassMethods)
+        klass.class_eval{ include InstanceMethods }
+      end
+    end
+
+  end
+end

data/lib/dragonfly/analysis/analyser.rb

@@ -0,0 +1,45 @@
+module Dragonfly
+  module Analysis
+    class Analyser
+      
+      def initialize
+        @analysers = []
+      end
+      
+      include Configurable
+
+      def register(analyser)
+        analysers.unshift(analyser)
+      end
+      configuration_method :register
+
+      def mime_type(temp_object)
+        analysers.each do |analyser|
+          mime_type = analyser.mime_type(temp_object)
+          return mime_type if mime_type
+        end
+        nil
+      end
+      
+      def analysis_methods
+        analysers.map{|a| a.public_methods(false) }.flatten.uniq
+      end
+      
+      def has_analysis_method?(method)
+        analysis_methods.include?(method.to_s)
+      end
+      
+      private
+      
+      attr_reader :analysers
+
+      def method_missing(meth, *args)
+        analysers.each do |analyser|
+          return analyser.send(meth, *args) if analyser.respond_to?(meth)
+        end
+        super
+      end
+      
+    end
+  end
+end

data/lib/dragonfly/analysis/base.rb

@@ -0,0 +1,10 @@
+module Dragonfly
+  module Analysis
+    class Base
+      
+      def mime_type(temp_object)
+      end
+      
+    end
+  end
+end

data/lib/dragonfly/analysis/r_magick_analyser.rb

@@ -0,0 +1,40 @@
+require 'rmagick'
+require 'mime/types'
+
+module Dragonfly
+  module Analysis
+    
+    class RMagickAnalyser < Base
+      
+      def width(image)
+        rmagick_image(image).columns
+      end
+      
+      def height(image)
+        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
+      
+      def number_of_colours(image)
+        rmagick_image(image).number_colors
+      end
+      alias number_of_colors number_of_colours
+      
+      private
+      
+      def rmagick_image(image)
+        Magick::Image.from_blob(image.data).first
+      end
+      
+    end
+    
+  end
+end

data/lib/dragonfly/app.rb

@@ -0,0 +1,85 @@
+require 'logger'
+require 'forwardable'
+
+module Dragonfly
+  class App
+    
+    class << self
+      
+      private :new # Hide 'new' - need to use 'instance'
+      
+      def instance(name)
+        apps[name] ||= new
+      end
+      
+      alias [] instance
+      
+      private
+      
+      def apps
+        @apps ||= {}
+      end
+            
+    end
+    
+    def initialize
+      @analyser = Analysis::Analyser.new
+      @processor = Processing::Processor.new
+      @parameters_class = Class.new(Parameters)
+      @url_handler = UrlHandler.new(@parameters_class)
+      initialize_temp_object_class
+    end
+    
+    attr_reader :analyser,
+                :processor,
+                :encoder,
+                :url_handler,
+                :parameters_class,
+                :temp_object_class
+
+    alias parameters parameters_class
+    
+    # Just for convenience so the user doesn't have to use url_handler
+    extend Forwardable
+    def_delegator :url_handler, :url_for
+    
+    include Configurable
+    
+    configurable_attr :datastore do DataStorage::FileDataStore.new end
+    configurable_attr :encoder do Encoding::Base.new end
+    configurable_attr :log do Logger.new('/var/tmp/dragonfly.log') end
+    configurable_attr :cache_duration, 3000
+    
+    def call(env)
+      parameters = url_handler.url_to_parameters(env['PATH_INFO'], env['QUERY_STRING'])
+      temp_object = fetch(parameters.uid, parameters)
+      [200, {
+        "Content-Type" => temp_object.mime_type,
+        "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
+      [400, {"Content-Type" => "text/plain"}, [e.message]]
+    rescue UrlHandler::UnknownUrl, DataStorage::DataNotFound => e
+      [404, {"Content-Type" => 'text/plain'}, [e.message]]
+    end
+
+    def fetch(uid, *args)
+      temp_object = temp_object_class.new(datastore.retrieve(uid))
+      temp_object.transform(*args)
+    end
+
+    def create_object(initialization_object)
+      temp_object_class.new(initialization_object)
+    end
+
+    private
+    
+    def initialize_temp_object_class
+      @temp_object_class = Class.new(ExtendedTempObject)
+      @temp_object_class.app = self
+    end
+
+  end
+end

data/lib/dragonfly/app_configuration.rb

@@ -0,0 +1,9 @@
+module Dragonfly
+  class AppConfiguration
+    
+    def apply_configuration(app)
+      raise NotImplementedError
+    end
+    
+  end
+end

data/lib/dragonfly/configurable.rb

@@ -0,0 +1,113 @@
+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
+    
+    module InstanceMethods
+      
+      def configure(&blk)
+        yield ConfigurationProxy.new(self)
+      end
+    
+      def configure_with(configurer)
+        configurer.apply_configuration(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 || default
+        
+        # Define the reader
+        define_method(attribute) do
+          if configuration_hash[attribute].respond_to? :call
+            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).configure(&block)
+        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/data_storage/base.rb

@@ -0,0 +1,19 @@
+module Dragonfly
+  module DataStorage
+    class Base
+
+      def store(temp_object)
+        raise NotImplementedError
+      end
+
+      def retrieve(uid)
+        raise NotImplementedError
+      end
+      
+      def destroy(uid)
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/dragonfly/data_storage/file_data_store.rb

@@ -0,0 +1,72 @@
+module Dragonfly
+  module DataStorage
+
+    class FileDataStore < Base
+
+      include Configurable
+    
+      configurable_attr :root_path, '/var/tmp/dragonfly'
+
+      def store(temp_object)
+
+        suffix = if temp_object.name.blank?
+          'file'
+        else
+          temp_object.name.sub(/\.[^.]*?$/, '')
+        end
+        relative_path = relative_storage_path(suffix)
+
+        begin
+          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)
+          FileUtils.cp temp_object.path, storage_path
+        rescue Errno::EACCES => e
+          raise UnableToStore, e.message
+        end
+      
+        relative_path
+      end
+
+      def retrieve(relative_path)
+        begin
+          File.new(absolute_storage_path(relative_path))
+        rescue Errno::ENOENT => e
+          raise DataNotFound, e.message
+        end
+      end
+
+      def destroy(relative_path)
+        FileUtils.rm absolute_storage_path(relative_path)
+        containing_directory = Pathname.new(relative_path).dirname
+        containing_directory.ascend do |relative_dir|
+          dir = absolute_storage_path(relative_dir)
+          FileUtils.rmdir dir if directory_empty?(dir)
+        end
+      rescue Errno::ENOENT => e
+        raise DataNotFound, e.message
+      end
+
+      private
+    
+      def increment_path(path)
+        path.sub(/(_(\d+))?$/){ $1 ? "_#{$2.to_i+1}" : '_2' }
+      end
+
+      def relative_storage_path(suffix)
+        "#{Time.now.strftime '%Y/%m/%d/%H%M%S'}_#{suffix}"
+      end
+      
+      def absolute_storage_path(relative_path)
+        File.join(root_path, relative_path)
+      end
+
+      def directory_empty?(path)
+        Dir.entries(path) == ['.','..']
+      end
+
+    end
+
+  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/encoding/base.rb

@@ -0,0 +1,13 @@
+module Dragonfly
+  module Encoding
+    
+    class Base
+      
+      def encode(temp_object, format, options={})
+        raise NotImplementedError
+      end
+      
+    end
+    
+  end
+end

data/lib/dragonfly/encoding/r_magick_encoder.rb

@@ -0,0 +1,17 @@
+require 'rmagick'
+
+module Dragonfly
+  module Encoding
+    
+    class RMagickEncoder < Base
+      
+      def encode(image, format, encoding={})
+        encoded_image = Magick::Image.from_blob(image.data).first
+        encoded_image.format = format.to_s
+        encoded_image.to_blob
+      end
+      
+    end
+    
+  end
+end