fog-dragonfly 0.8.1

data/lib/dragonfly/job_builder.rb

@@ -0,0 +1,39 @@
+module Dragonfly
+  class JobBuilder
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def build(job, *args)
+      evaluate_block(job, false, *args)
+    end
+
+    def build!(job, *args)
+      evaluate_block(job, true, *args)
+    end
+
+    Job.step_names.each do |step|
+      
+      # fetch, process, etc.
+      define_method step do |*args|
+        if @perform_with_bangs
+          @job.send("#{step}!", *args)
+        else
+          @job = @job.send(step, *args)
+        end
+      end
+      
+    end
+    
+    private
+    
+    def evaluate_block(job, perform_with_bangs, *args)
+      @job = job
+      @perform_with_bangs = perform_with_bangs
+      instance_exec(*args, &@block)
+      @job
+    end
+
+  end
+end

data/lib/dragonfly/job_definitions.rb

@@ -0,0 +1,26 @@
+module Dragonfly
+  class JobDefinitions < Module
+
+    def initialize
+      @job_definitions = {}
+    end
+
+    def add(name, &definition_proc)
+      job_definitions[name] = JobBuilder.new(&definition_proc)
+      jd = job_definitions # Needed because we're about to change 'self'
+      
+      define_method name do |*args|
+        jd[name].build(self, *args)
+      end
+      
+      define_method "#{name}!" do |*args|
+        jd[name].build!(self, *args)
+      end
+    end
+
+    private
+
+    attr_reader :job_definitions
+
+  end
+end

data/lib/dragonfly/job_endpoint.rb

@@ -0,0 +1,15 @@
+module Dragonfly
+  class JobEndpoint
+
+    def initialize(job)
+      @job = job
+    end
+
+    def call(env={})
+      Response.new(job, env).to_response
+    end
+
+    attr_reader :job
+
+  end
+end

data/lib/dragonfly/loggable.rb

@@ -0,0 +1,28 @@
+require 'logger'
+
+module Dragonfly
+  module Loggable
+
+    def log
+      case @log_object
+      when nil
+        @log_object = Logger.new($stdout)
+      when Proc
+        @log_object[]
+      when Logger
+        @log_object
+      end
+    end
+
+    def log=(object)
+      @log_object = object
+    end
+    
+    attr_reader :log_object
+
+    def use_same_log_as(object)
+      self.log = proc{ object.log }
+    end
+
+  end
+end

data/lib/dragonfly/middleware.rb

@@ -0,0 +1,34 @@
+module Dragonfly
+  class Middleware
+
+    def initialize(app, dragonfly_app_name, path_prefix)
+      @app = app
+      @endpoint = Rack::Builder.new {
+        map path_prefix do
+          run Dragonfly[dragonfly_app_name]
+        end
+      }.to_app
+    end
+
+    def call(env)
+      response = @endpoint.call(env)
+      if route_not_found?(response)
+        @app.call(env)
+      else
+        response
+      end
+    end
+
+    private
+
+    def route_not_found?(response)
+      response[1]['X-Cascade'] == 'pass' ||
+        (rack_version_doesnt_support_x_cascade? && response[0] == 404)
+    end
+
+    def rack_version_doesnt_support_x_cascade?
+      Rack.version < '1.1'
+    end
+
+  end
+end

data/lib/dragonfly/processing/image_magick_processor.rb

@@ -0,0 +1,99 @@
+module Dragonfly
+  module Processing
+    class ImageMagickProcessor
+
+      GRAVITIES = {
+        'nw' => 'NorthWest',
+        'n'  => 'North',
+        'ne' => 'NorthEast',
+        'w'  => 'West',
+        'c'  => 'Center',
+        'e'  => 'East',
+        'sw' => 'SouthWest',
+        's'  => 'South',
+        'se' => 'SouthEast'
+      }
+      
+      # Geometry string patterns
+      RESIZE_GEOMETRY         = /^\d*x\d*[><%^!]?$|^\d+@$/ # e.g. '300x200!'
+      CROPPED_RESIZE_GEOMETRY = /^(\d+)x(\d+)#(\w{1,2})?$/ # e.g. '20x50#ne'
+      CROP_GEOMETRY           = /^(\d+)x(\d+)([+-]\d+)?([+-]\d+)?(\w{1,2})?$/ # e.g. '30x30+10+10'
+      THUMB_GEOMETRY = Regexp.union RESIZE_GEOMETRY, CROPPED_RESIZE_GEOMETRY, CROP_GEOMETRY
+      
+      include ImageMagickUtils
+      
+      def resize(temp_object, geometry)
+        convert(temp_object, "-resize '#{geometry}'")
+      end
+      
+      def crop(temp_object, opts={})
+        width   = opts[:width]
+        height  = opts[:height]
+        gravity = GRAVITIES[opts[:gravity]]
+        x       = "#{opts[:x] || 0}"
+        x = '+' + x unless x[/^[+-]/]
+        y       = "#{opts[:y] || 0}"
+        y = '+' + y unless y[/^[+-]/]
+      
+        convert(temp_object, "-crop #{width}x#{height}#{x}#{y}#{" -gravity #{gravity}" if gravity}")
+      end
+      
+      def flip(temp_object)
+        convert(temp_object, "-flip")
+      end
+      
+      def flop(temp_object)
+        convert(temp_object, "-flop")
+      end
+      
+      def greyscale(temp_object)
+        convert(temp_object, "-colorspace Gray")
+      end
+      alias grayscale greyscale
+      
+      def resize_and_crop(temp_object, opts={})
+        attrs          = identify(temp_object)
+        current_width  = attrs[:width].to_i
+        current_height = attrs[:height].to_i
+        
+        width   = opts[:width]  ? opts[:width].to_i  : current_width
+        height  = opts[:height] ? opts[:height].to_i : current_height
+        gravity = opts[:gravity] || 'c'
+
+        if width != current_width || height != current_height
+          scale = [width.to_f / current_width, height.to_f / current_height].max
+          temp_object = TempObject.new(resize(temp_object, "#{(scale * current_width).ceil}x#{(scale * current_height).ceil}"))
+        end
+
+        crop(temp_object, :width => width, :height => height, :gravity => gravity)
+      end
+      
+      def rotate(temp_object, amount, opts={})
+        convert(temp_object, "-rotate '#{amount}#{opts[:qualifier]}'")
+      end
+      
+      def thumb(temp_object, geometry)
+        case geometry
+        when RESIZE_GEOMETRY
+          resize(temp_object, geometry)
+        when CROPPED_RESIZE_GEOMETRY
+          resize_and_crop(temp_object, :width => $1, :height => $2, :gravity => $3)
+        when CROP_GEOMETRY
+          crop(temp_object,
+            :width => $1,
+            :height => $2,
+            :x => $3,
+            :y => $4,
+            :gravity => $5
+          )
+        else raise ArgumentError, "Didn't recognise the geometry string #{geometry}"
+        end
+      end
+      
+      def convert(temp_object, args='', format=nil)
+        format ? [super, {:format => format.to_sym}] : super
+      end
+      
+    end
+  end
+end

data/lib/dragonfly/processing/r_magick_processor.rb

@@ -0,0 +1,126 @@
+require 'RMagick'
+
+module Dragonfly
+  module Processing
+    class RMagickProcessor
+
+      GRAVITIES = {
+        '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
+      }
+
+      # Geometry string patterns
+      RESIZE_GEOMETRY         = /^\d*x\d*[><%^!]?$|^\d+@$/ # e.g. '300x200!'
+      CROPPED_RESIZE_GEOMETRY = /^(\d+)x(\d+)#(\w{1,2})?$/ # e.g. '20x50#ne'
+      CROP_GEOMETRY           = /^(\d+)x(\d+)([+-]\d+)?([+-]\d+)?(\w{1,2})?$/ # e.g. '30x30+10+10'
+      THUMB_GEOMETRY = Regexp.union RESIZE_GEOMETRY, CROPPED_RESIZE_GEOMETRY, CROP_GEOMETRY
+
+      include RMagickUtils
+      include Configurable
+      
+      configurable_attr :use_filesystem, true
+
+      def crop(temp_object, opts={})
+        x       = opts[:x].to_i
+        y       = opts[:y].to_i
+        gravity = GRAVITIES[opts[:gravity]] || Magick::ForgetGravity
+        width   = opts[:width].to_i
+        height  = opts[:height].to_i
+
+        rmagick_image(temp_object) do |image|
+          # 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)
+        end
+      end
+
+      def flip(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.flip!
+        end
+      end
+
+      def flop(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.flop!
+        end
+      end
+
+      def greyscale(temp_object, opts={})
+        depth = opts[:depth] || 256
+        rmagick_image(temp_object) do |image|
+          image.quantize(depth, Magick::GRAYColorspace)
+        end
+      end
+      alias grayscale greyscale
+
+      def resize(temp_object, geometry)
+        rmagick_image(temp_object) do |image|
+          image.change_geometry!(geometry) do |cols, rows, img|
+           img.resize!(cols, rows)
+          end
+        end
+      end
+
+      def resize_and_crop(temp_object, opts={})
+        rmagick_image(temp_object) do |image|
+
+          width   = opts[:width] ? opts[:width].to_i : image.columns
+          height  = opts[:height] ? opts[:height].to_i : image.rows
+          gravity = GRAVITIES[opts[:gravity]] || Magick::CenterGravity
+
+          image.crop_resized(width, height, gravity)
+        end
+      end
+
+      def rotate(temp_object, amount, opts={})
+        args = [amount.to_f]
+        args << opts[:qualifier] if opts[:qualifier]
+        rmagick_image(temp_object) do |image|
+          image.background_color = opts[:background_colour] if opts[:background_colour]
+          image.background_color = opts[:background_color] if opts[:background_color]
+          image.rotate(*args) || temp_object
+        end
+      end
+
+      def thumb(temp_object, geometry)
+        case geometry
+        when RESIZE_GEOMETRY
+          resize(temp_object, geometry)
+        when CROPPED_RESIZE_GEOMETRY
+          resize_and_crop(temp_object, :width => $1, :height => $2, :gravity => $3)
+        when CROP_GEOMETRY
+          crop(temp_object,
+            :width => $1,
+            :height => $2,
+            :x => $3,
+            :y => $4,
+            :gravity => $5
+          )
+        else raise ArgumentError, "Didn't recognise the geometry string #{geometry}"
+        end
+      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) do |image|
+          image.vignette(x, y, radius, sigma)
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/processor.rb

@@ -0,0 +1,9 @@
+module Dragonfly
+  class Processor < FunctionManager
+
+    def process(temp_object, method, *args)
+      call_last(method, temp_object, *args)
+    end
+
+  end
+end

data/lib/dragonfly/r_magick_utils.rb

@@ -0,0 +1,48 @@
+require 'tempfile'
+
+module Dragonfly
+  module RMagickUtils
+
+    include Loggable
+
+    private
+
+    # Requires the extended object to respond to 'use_filesystem'
+    def rmagick_image(temp_object, &block)
+      imagelist = use_filesystem ? Magick::Image.read(temp_object.path) : Magick::Image.from_blob(temp_object.data)
+      image = imagelist.first
+      result = block.call(image)
+      case result
+      when Magick::Image, Magick::ImageList
+        content = use_filesystem ? write_to_tempfile(result) : result.to_blob
+        result.destroy!
+      else
+        content = result
+      end
+      image.destroy!
+      content
+    rescue Magick::ImageMagickError => e
+      log.warn("Unable to handle content in #{self.class} - got:\n#{e}")
+      throw :unable_to_handle
+    end
+
+    def ping_rmagick_image(temp_object, &block)
+      imagelist = use_filesystem ? Magick::Image.ping(temp_object.path) : Magick::Image.from_blob(temp_object.data)
+      image = imagelist.first
+      result = block.call(image)
+      image.destroy!
+      result
+    rescue Magick::ImageMagickError => e
+      log.warn("Unable to handle content in #{self.class} - got:\n#{e}")
+      throw :unable_to_handle
+    end
+
+    def write_to_tempfile(rmagick_image)
+      tempfile = Tempfile.new('dragonfly')
+      tempfile.close
+      rmagick_image.write(tempfile.path)
+      tempfile
+    end
+
+  end
+end

data/lib/dragonfly/rails/images.rb

@@ -0,0 +1,22 @@
+require 'dragonfly'
+require 'rack/cache'
+require 'uri'
+
+### The dragonfly app ###
+app = Dragonfly[:images]
+app.configure_with(:rails)
+app.configure_with(:imagemagick)
+
+### Extend active record ###
+app.define_macro(ActiveRecord::Base, :image_accessor)
+
+### Insert the middleware ###
+# Where the middleware is depends on the version of Rails
+middleware = Rails.respond_to?(:application) ? Rails.application.middleware : ActionController::Dispatcher.middleware
+
+middleware.insert_after 'Rack::Lock', 'Dragonfly::Middleware', :images, app.url_path_prefix
+middleware.insert_before 'Dragonfly::Middleware', 'Rack::Cache', {
+  :verbose     => true,
+  :metastore   => URI.encode("file:#{Rails.root}/tmp/dragonfly/cache/meta"), # URI encoded because Windows
+  :entitystore => URI.encode("file:#{Rails.root}/tmp/dragonfly/cache/body")  # has problems with spaces
+}