dragonfly 0.1.0

data/lib/dragonfly/extended_temp_object.rb

@@ -0,0 +1,94 @@
+module Dragonfly
+  class ExtendedTempObject < TempObject
+    
+    # Exceptions
+    class NotConfiguredError < RuntimeError; end
+    
+    class << self
+      attr_accessor :app
+    end
+    
+    def process(processing_method, *args)
+      self.class.new(processor.send(processing_method, self, *args))
+    end
+    
+    def process!(processing_method, *args)
+      modify_self!(processor.send(processing_method, self, *args))
+    end
+
+    def encode(*args)
+      self.class.new(encoder.encode(self, *args))
+    end
+    
+    def encode!(*args)
+      modify_self!(encoder.encode(self, *args))
+    end
+    
+    def transform(*args)
+      args.any? ? dup.transform!(*args) : self
+    end
+    
+    def transform!(*args)
+      parameters = parameters_class.from_args(*args)
+      process!(parameters.processing_method, parameters.processing_options) unless parameters.processing_method.nil?
+      encode!(parameters.format, parameters.encoding) unless parameters.format.nil?
+      self
+    end
+    
+    # Modify methods, public_methods and respond_to?, because method_missing
+    # allows methods from the analyser
+    
+    def methods(*args)
+      (super + analyser.analysis_methods).uniq
+    end
+    
+    def public_methods(*args)
+      (super + analyser.analysis_methods).uniq
+    end
+    
+    def respond_to?(method)
+      super || analyser.has_analysis_method?(method)
+    end
+
+    private
+    
+    def method_missing(method, *args, &block)
+      if analyser.has_analysis_method?(method)
+        # Define the method so we don't use method_missing next time
+        instance_var = "@#{method}"
+        self.class.class_eval do
+          define_method method do
+            # Lazy reader, like
+            #   @width ||= analyser.width(self)
+            instance_variable_set(instance_var, instance_variable_get(instance_var) || analyser.send(method, self))
+          end
+        end
+        # Now that it's defined (for next time)
+        send(method)
+      else
+        super
+      end
+    end
+    
+    def app
+      self.class.app ? self.class.app : raise(NotConfiguredError, "#{self.class} has no app set")
+    end
+    
+    def analyser
+      app.analyser
+    end
+    
+    def processor
+      app.processor
+    end
+    
+    def encoder
+      app.encoder
+    end
+    
+    def parameters_class
+      app.parameters_class
+    end
+
+  end
+end

data/lib/dragonfly/middleware.rb

@@ -0,0 +1,27 @@
+module Dragonfly
+
+  class Middleware
+    
+    def initialize(app, dragonfly_app_name)
+      @app = app
+      @dragonfly_app_name = dragonfly_app_name
+    end
+    
+    def call(env)
+      response = dragonfly_app.call(env)
+      if response[0] == 404
+        @app.call(env)
+      else
+        response
+      end
+    end
+    
+    private
+    
+    def dragonfly_app
+      App[@dragonfly_app_name]
+    end
+    
+  end
+
+end

data/lib/dragonfly/parameters.rb

@@ -0,0 +1,152 @@
+require 'rack'
+
+module Dragonfly
+  class Parameters
+    
+    # Exceptions
+    class InvalidParameters < RuntimeError; end
+    class InvalidShortcut < RuntimeError; end
+
+    # Class methods
+    class << self
+      
+      include Configurable
+      
+      configurable_attr :default_processing_method
+      configurable_attr :default_processing_options, {}
+      configurable_attr :default_format
+      configurable_attr :default_encoding, {}
+      
+      def add_shortcut(*args, &block)
+        if block
+          block_shortcuts_of_length(args.length) << [args, block]
+        else
+          shortcut_name, attributes = args
+          simple_shortcuts[shortcut_name] = attributes
+        end
+      end
+      configuration_method :add_shortcut
+      
+      def from_shortcut(*args)
+        if attributes = matching_simple_shortcut(args)
+          new(attributes)
+        elsif attributes = matching_block_shortcut(args)
+          new(attributes)
+        else
+          raise InvalidShortcut, "No shortcut was found matching (#{args.map{|a| a.inspect }.join(', ')})"
+        end
+      end
+      
+      def from_args(*args)
+        if args.empty? then new
+        elsif args.length == 1 && args.first.is_a?(Hash) then new(args.first)
+        elsif args.length == 1 && args.first.is_a?(Parameters) then args.first.dup
+        else from_shortcut(*args)
+        end
+      end
+      
+      private
+      
+      def simple_shortcuts
+        @simple_shortcuts ||= {}
+      end
+      
+      # block_shortcuts is actually a hash (keyed on the number of
+      # arguments) of arrays (of argument lists)
+      def block_shortcuts
+        @block_shortcuts ||= {}
+      end
+      
+      def block_shortcuts_of_length(arg_length)
+        block_shortcuts[arg_length] ||= []
+      end
+      
+      def matching_simple_shortcut(args)
+        if args.length == 1 && args.first.is_a?(Symbol)
+          simple_shortcuts[args.first]
+        end
+      end
+      
+      def matching_block_shortcut(args)
+        block_shortcuts_of_length(args.length).each do |(args_to_match, block)|
+          if all_args_match?(args, args_to_match)
+            # If the block shortcut arg is a single regexp, then also yield the match data
+            if args_to_match.length == 1 && args_to_match.first.is_a?(Regexp)
+              match_data = args_to_match.first.match(args.first)
+              return block.call(args.first, match_data)
+            # ...otherwise just yield the args
+            else
+              return block.call(*args)
+            end
+          end
+        end
+        nil
+      end
+      
+      def all_args_match?(args, args_to_match)
+        (0...args.length).inject(true){|current_result, i| current_result &&= args_to_match[i] === args[i] }
+      end
+
+    end
+
+    # 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)
+      raise ArgumentError, "Parameters doesn't recognise the following parameters: #{attributes.keys.join(', ')}" if attributes.any?
+    end
+
+    def [](attribute)
+      send(attribute)
+    end
+    
+    def []=(attribute, value)
+      send("#{attribute}=", value)
+    end
+    
+    def ==(other_parameters)
+      self.to_hash == other_parameters.to_hash
+    end
+    
+    def generate_sha(salt, sha_length)
+      Digest::SHA1.hexdigest("#{to_sorted_array}#{salt}")[0...sha_length]
+    end
+    
+    def unique_signature
+      generate_sha('I like cheese', 10)
+    end
+
+    def to_hash
+      {
+        :uid => uid,
+        :processing_method => processing_method,
+        :processing_options => processing_options,
+        :format => format,
+        :encoding => encoding
+      }
+    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
+      [
+        uid,
+        format,
+        processing_method,
+        processing_options.sort{|a,b| a[1].to_s <=> b[1].to_s },
+        encoding.sort{|a,b| a[1].to_s <=> b[1].to_s }
+      ]
+    end
+
+  end
+end

data/lib/dragonfly/processing/processor.rb

@@ -0,0 +1,14 @@
+module Dragonfly
+  module Processing
+    class Processor
+
+      include Configurable
+
+      def register(mod)
+        self.extend(mod)
+      end
+      configuration_method :register
+
+    end
+  end
+end

data/lib/dragonfly/processing/r_magick_processor.rb

@@ -0,0 +1,71 @@
+require 'rmagick'
+
+module Dragonfly
+  module Processing
+
+    module RMagickProcessor
+      
+      GRAVITY_MAPPINGS = {
+        'nw' => Magick::NorthWestGravity,
+        'n'  => Magick::NorthGravity,
+        'ne' => Magick::NorthEastGravity,
+        'w'  => Magick::WestGravity,
+        'c'  => Magick::CenterGravity,
+        'e'  => Magick::EastGravity,
+        'sw' => Magick::SouthWestGravity,
+        's'  => Magick::SouthGravity,
+        'se' => Magick::SouthEastGravity
+      }
+      
+      def crop(temp_object, opts={})
+        x       = opts[:x].to_i
+        y       = opts[:y].to_i
+        gravity = GRAVITY_MAPPINGS[opts[:gravity]] || Magick::ForgetGravity
+        width   = opts[:width].to_i
+        height  = opts[:height].to_i
+
+        image = rmagick_image(temp_object)
+
+        # RMagick throws an error if the cropping area is bigger than the image,
+        # when the gravity is something other than nw
+        width  = image.columns - x if x + width  > image.columns
+        height = image.rows    - y if y + height > image.rows
+
+        image.crop(gravity, x, y, width, height).to_blob
+      end
+      
+      def resize(temp_object, opts={})
+        rmagick_image(temp_object).change_geometry!(opts[:geometry]) do |cols, rows, img|
+         img.resize!(cols, rows)
+        end.to_blob
+      end
+
+      def resize_and_crop(temp_object, opts={})
+        image = rmagick_image(temp_object)
+        
+        width   = opts[:width] ? opts[:width].to_i : image.columns
+        height  = opts[:height] ? opts[:height].to_i : image.rows
+        gravity = GRAVITY_MAPPINGS[opts[:gravity]] || Magick::CenterGravity
+
+        image.resize_to_fill(width, height, gravity).to_blob
+      end
+
+      def vignette(temp_object, opts={})
+        x      = opts[:x].to_f      || temp_object.width  * 0.1
+        y      = opts[:y].to_f      || temp_object.height * 0.1
+        radius = opts[:radius].to_f ||  0.0
+        sigma  = opts[:sigma].to_f  || 10.0
+
+        rmagick_image(temp_object).vignette(x, y, radius, sigma).to_blob
+      end
+      
+      private
+      
+      def rmagick_image(temp_object)
+        Magick::Image.from_blob(temp_object.data).first
+      end
+
+    end
+
+  end
+end

data/lib/dragonfly/r_magick_configuration.rb

@@ -0,0 +1,47 @@
+module Dragonfly
+  
+  RMagickConfiguration = AppConfiguration.new
+  
+  def RMagickConfiguration.apply_configuration(app)
+    app.configure do |c|
+      c.analyser do |a|
+        a.register(Analysis::RMagickAnalyser.new)
+      end
+      c.processor do |p|
+        p.register(Processing::RMagickProcessor)
+      end
+      c.encoder = Encoding::RMagickEncoder.new
+      c.parameters do |p|
+        p.default_format = :jpg
+        # Standard resizing like '30x40!', etc.
+        p.add_shortcut(/^\d*x\d*[><%^!]?$|^\d+@$/) do |geometry, match_data|
+          {
+            :processing_method => :resize,
+            :processing_options => {:geometry => geometry}
+          }
+        end
+        # Cropped resizing like '20x50#ne'
+        p.add_shortcut(/^(\d+)x(\d+)#(\w{1,2})?/) do |geometry, match_data|
+          {
+            :processing_method => :resize_and_crop,
+            :processing_options => {:width => match_data[1], :height => match_data[2], :gravity => match_data[3]}
+          }
+        end
+        # Cropping like '30x30+10+10ne'
+        p.add_shortcut(/^(\d+)x(\d+)([+-]\d+)([+-]\d+)(\w{1,2})?/) do |geometry, match_data|
+          {
+            :processing_method => :crop,
+            :processing_options => {
+              :width => match_data[1],
+              :height => match_data[2],
+              :x => match_data[3],
+              :y => match_data[4],
+              :gravity => match_data[5]
+            }
+          }
+        end
+      end
+    end
+  end
+  
+end

data/lib/dragonfly/rails/images.rb

@@ -0,0 +1,20 @@
+require 'dragonfly'
+
+### The dragonfly app ###
+
+app = Dragonfly::App[:images]
+app.configure_with(Dragonfly::RMagickConfiguration)
+app.configure do |c|
+  c.log = RAILS_DEFAULT_LOGGER
+  c.datastore.configure do |d|
+    d.root_path = "#{Rails.root}/public/system/dragonfly/#{Rails.env}"
+  end
+  c.url_handler do |u|
+    u.protect_from_dos_attacks = false
+    u.path_prefix = '/images'
+  end
+end
+
+### Extend active record ###
+ActiveRecord::Base.extend Dragonfly::ActiveRecordExtensions
+ActiveRecord::Base.register_dragonfly_app(:image, app)

data/lib/dragonfly/temp_object.rb

@@ -0,0 +1,118 @@
+require 'tempfile'
+
+module Dragonfly
+  class TempObject
+  
+    # Class configuration
+    class << self
+      
+      include Configurable
+      configurable_attr :block_size, 8192
+      
+    end
+  
+    # Instance Methods
+    
+    def initialize(obj)
+      initialize_from_object!(obj)
+    end
+    
+    attr_accessor :name
+    
+    def modify_self!(obj)
+      reset!
+      initialize_from_object!(obj)
+      self
+    end
+    
+    def data
+      @data ||= initialized_data || file.open.read
+    end
+
+    def tempfile
+      if @tempfile
+        @tempfile
+      elsif initialized_tempfile
+        @tempfile = initialized_tempfile
+      elsif initialized_data
+        tempfile = Tempfile.new('dragonfly')
+        tempfile.write(initialized_data)
+        tempfile.close
+        @tempfile = tempfile
+      elsif initialized_file
+        @tempfile = copy_to_tempfile(initialized_file)
+      end
+    end
+    
+    alias_method :file, :tempfile
+    
+    def path
+      tempfile.path
+    end
+    
+    def size
+      if initialized_data
+        initialized_data.size
+      else
+        File.size(path)
+      end
+    end
+    
+    def each(&block)
+      if initialized_data
+        string_io = StringIO.new(initialized_data)
+        while part = string_io.read(block_size)
+          yield part
+        end
+      else
+        tempfile.open
+        while part = tempfile.read(block_size)
+          yield part
+        end
+        tempfile.close
+      end
+    end
+    
+    protected
+    
+    attr_accessor :initialized_data, :initialized_tempfile, :initialized_file
+    
+    private
+    
+    def reset!
+      instance_variables.each do |var|
+        instance_variable_set(var, nil)
+      end
+    end
+    
+    def initialize_from_object!(obj)
+      case obj
+      when TempObject
+        @initialized_data = obj.initialized_data
+        @initialized_tempfile = copy_to_tempfile(obj.initialized_tempfile) if obj.initialized_tempfile
+        @initialized_file = obj.initialized_file
+      when String
+        @initialized_data = obj
+      when Tempfile
+        @initialized_tempfile = obj
+      when File
+        @initialized_file = obj
+      else
+        raise ArgumentError, "#{self.class.name} must be initialized with a String, a File or a Tempfile"
+      end
+      self.name = obj.original_filename if obj.respond_to?(:original_filename)
+    end
+    
+    def copy_to_tempfile(file)
+      tempfile = Tempfile.new('dragonfly')
+      tempfile.close
+      FileUtils.cp File.expand_path(file.path), tempfile.path
+      tempfile
+    end
+    
+    def block_size
+      self.class.block_size
+    end
+    
+  end
+end

data/lib/dragonfly/url_handler.rb

@@ -0,0 +1,148 @@
+require 'digest/sha1'
+require 'rack'
+
+module Dragonfly
+  class UrlHandler
+    
+    # Exceptions
+    class IncorrectSHA < RuntimeError; end
+    class SHANotGiven < RuntimeError; end
+    class UnknownUrl < RuntimeError; end
+    
+    include Rack::Utils
+    include Configurable
+
+    MAPPINGS = {
+      :processing_method => 'm',
+      :processing_options => 'o',
+      :encoding => 'e',
+      :sha => 's'
+    }
+ 
+    configurable_attr :protect_from_dos_attacks, true
+    configurable_attr :secret, 'This is a secret!'
+    configurable_attr :sha_length, 16
+    configurable_attr :path_prefix, ''
+
+    def initialize(parameters_class = Parameters)
+      @parameters_class = parameters_class
+    end
+
+    def url_for(uid, *args)
+      parameters = parameters_class.from_args(*args)
+      parameters.uid = uid
+      parameters_to_url(parameters)
+    end
+
+    def url_to_parameters(path, query_string)
+      validate_format!(path)
+      path = remove_path_prefix(path)
+      query = parse_nested_query(query_string)
+      attributes = {
+        :uid => extract_uid(path, query),
+        :processing_method => extract_processing_method(path, query),
+        :processing_options => extract_processing_options(path, query),
+        :format => extract_format(path, query),
+        :encoding => extract_encoding(path, query)
+      }.reject{|k,v| v.nil? }
+      parameters = parameters_class.new(attributes)
+      validate_parameters(parameters, query)
+      parameters
+    end
+
+    def parameters_to_url(parameters)
+      parameters.validate!
+      query_string = [:processing_method, :processing_options, :encoding].map do |attribute|
+        build_query(MAPPINGS[attribute] => parameters[attribute]) unless parameters[attribute].blank?
+      end.compact.join('&')
+      sha_string = "&#{MAPPINGS[:sha]}=#{sha_from_parameters(parameters)}" if protect_from_dos_attacks?
+      url = "#{path_prefix}/#{escape_except_for_slashes(parameters.uid)}.#{parameters.format}?#{query_string}#{sha_string}"
+      url.sub!(/\?$/,'')
+      url
+    end
+
+    private
+
+    def remove_path_prefix(path)
+      path.sub(path_prefix, '')
+    end
+
+    def extract_uid(path, query)
+      path.sub(/^\//,'').sub(/\.[^.]+$/, '')
+    end
+  
+    def extract_processing_method(path, query)
+      query[MAPPINGS[:processing_method]]
+    end
+  
+    def extract_processing_options(path, query)
+      processing_options = query[MAPPINGS[:processing_options]]
+      symbolize_keys(processing_options) if processing_options
+    end
+  
+    def extract_format(path, query)
+      path.sub(/^\//,'').split('.').last
+    end
+  
+    def extract_encoding(path, query)
+      encoding = query[MAPPINGS[:encoding]]
+      symbolize_keys(encoding) if encoding
+    end
+
+    attr_reader :parameters_class
+
+    def symbolize_keys(hash)
+      hash = hash.dup
+      hash.each do |key, value|
+        hash[key.to_sym] = hash.delete(key)
+      end
+      hash
+    end
+
+    def validate_parameters(parameters, query)
+      if protect_from_dos_attacks?
+        sha = query[MAPPINGS[:sha]]
+        raise SHANotGiven, "You need to give a SHA" if sha.nil?
+        raise IncorrectSHA, "The SHA parameter you gave is incorrect" if sha_from_parameters(parameters) != sha
+      end
+    end
+    
+    def protect_from_dos_attacks?
+      protect_from_dos_attacks
+    end
+    
+    def sha_from_parameters(parameters)
+      parameters.generate_sha(secret, sha_length)
+    end
+    
+    
+    # Annoyingly, the 'build_query' in Rack::Utils doesn't seem to work
+    # properly for nested parameters/arrays
+    # Taken from http://github.com/sinatra/sinatra/commit/52658061d1205753a8afd2801845a910a6c01ffd
+    def build_query(value, prefix = nil)
+      case value
+      when Array
+        value.map { |v|
+          build_query(v, "#{prefix}[]")
+        } * "&"
+      when Hash
+        value.map { |k, v|
+          build_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+        } * "&"
+      else
+        "#{prefix}=#{escape(value)}"
+      end
+    end
+    
+    def escape_except_for_slashes(string)
+      string.split('/').map{|s| escape(s) }.join('/')
+    end
+    
+    def validate_format!(path)
+      if path !~ /^#{path_prefix}/ || path !~ /^.*[^\/].*\..*[^\/].*$/
+        raise UnknownUrl, "path '#{path}' not found" 
+      end
+    end
+    
+  end
+end