dragonfly 0.7.7 → 0.8.0

data/fixtures/{rails_3.0.0 → rails_3.0.3}/template.rb

@@ -1,5 +1,4 @@
 gem 'rack-cache', :require => 'rack/cache'
-gem 'rmagick', '2.12.2', :require => 'RMagick'
 
 gem 'capybara'
 gem 'cucumber-rails'

data/irbrc.rb

@@ -1,7 +1,7 @@
 require "rubygems"
 require "bundler/setup"
 require File.dirname(__FILE__) + '/lib/dragonfly'
-APP = Dragonfly[:images].configure_with(:rmagick)
+APP = Dragonfly[:images].configure_with(:imagemagick)
 
 # available_uids = `find #{APP.datastore.root_path} ! -type d`.split("\n").map do |file|
 #   file.sub("#{APP.datastore.root_path}/", '')

data/lib/dragonfly/analysis/image_magick_analyser.rb

@@ -0,0 +1,47 @@
+module Dragonfly
+  module Analysis
+    class ImageMagickAnalyser
+
+      include ImageMagickUtils
+      include Configurable
+
+      def width(temp_object)
+        identify(temp_object)[:width]
+      end
+
+      def height(temp_object)
+        identify(temp_object)[:height]
+      end
+
+      def aspect_ratio(temp_object)
+        attrs = identify(temp_object)
+        attrs[:width].to_f / attrs[:height]
+      end
+
+      def portrait?(temp_object)
+        attrs = identify(temp_object)
+        attrs[:width] <= attrs[:height]
+      end
+
+      def landscape?(temp_object)
+        attrs = identify(temp_object)
+        attrs[:width] >= attrs[:height]
+      end
+
+      def depth(temp_object)
+        identify(temp_object)[:depth]
+      end
+
+      def number_of_colours(temp_object)
+        details = raw_identify(temp_object, '-verbose -unique')
+        details[/Colors: (\d+)/, 1].to_i
+      end
+      alias number_of_colors number_of_colours
+
+      def format(temp_object)
+        identify(temp_object)[:format]
+      end
+
+    end
+  end
+end

data/lib/dragonfly/app.rb

@@ -67,6 +67,8 @@ module Dragonfly
     attr_accessor :job_definitions
 
     SAVED_CONFIGS = {
+      :imagemagick => 'ImageMagick',
+      :image_magick => 'ImageMagick',
       :rmagick => 'RMagick',
       :r_magick => 'RMagick',
       :rails => 'Rails',

data/lib/dragonfly/config/image_magick.rb

@@ -0,0 +1,41 @@
+module Dragonfly
+  module Config
+
+    # ImageMagick is a saved configuration for Dragonfly apps, which does the following:
+    # - registers an imagemagick analyser
+    # - registers an imagemagick processor
+    # - registers an imagemagick encoder
+    # - adds thumb shortcuts like '280x140!', etc.
+    # Look at the source code for apply_configuration to see exactly how it configures the app.
+    module ImageMagick
+
+      def self.apply_configuration(app, opts={})
+        app.configure do |c|
+          c.analyser.register(Analysis::ImageMagickAnalyser)
+          c.processor.register(Processing::ImageMagickProcessor)
+          c.encoder.register(Encoding::ImageMagickEncoder)
+          c.generator.register(Generation::ImageMagickGenerator)
+
+          c.job :thumb do |geometry, format|
+            process :thumb, geometry
+            encode format if format
+          end
+          c.job :gif do
+            encode :gif
+          end
+          c.job :jpg do
+            encode :jpg
+          end
+          c.job :png do
+            encode :png
+          end
+          c.job :convert do |args, format|
+            process :convert, args, format
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/dragonfly/data_storage/file_data_store.rb

@@ -67,7 +67,7 @@ module Dragonfly
       end
 
       def relative(absolute_path)
-        absolute_path[/^#{root_path}\/(.*)$/, 1]
+        absolute_path[/^#{root_path}\/?(.*)$/, 1]
       end
 
       def directory_empty?(path)
@@ -79,7 +79,9 @@ module Dragonfly
       end
 
       def relative_path_for(filename)
-        "#{Time.now.strftime '%Y/%m/%d'}/#{filename.gsub(/[^\w.]+/,'_')}"
+        time = Time.now
+        msec = time.usec / 1000
+        "#{time.strftime '%Y/%m/%d/%H_%M_%S'}_#{msec}_#{filename.gsub(/[^\w.]+/,'_')}"
       end
 
       def store_extra_data(data_path, temp_object)

data/lib/dragonfly/data_storage/s3data_store.rb

@@ -34,10 +34,14 @@ module Dragonfly
       def store(temp_object, opts={})
         uid = opts[:path] || generate_uid(temp_object.name || 'file')
         ensure_initialized
-        object = use_filesystem ? temp_object.file : temp_object.data
         extra_data = temp_object.attributes
-        S3Object.store(uid, object, bucket_name, s3_metadata_for(extra_data))
-        object.close if use_filesystem
+        if use_filesystem
+          temp_object.file do |f|
+            S3Object.store(uid, f, bucket_name, s3_metadata_for(extra_data))
+          end
+        else
+          S3Object.store(uid, temp_object.data, bucket_name, s3_metadata_for(extra_data))
+        end
         uid
       end
 

data/lib/dragonfly/encoding/image_magick_encoder.rb

@@ -0,0 +1,57 @@
+module Dragonfly
+  module Encoding
+    class ImageMagickEncoder
+
+      include Configurable
+      include ImageMagickUtils
+
+      configurable_attr :supported_formats, [
+        :ai,
+        :bmp,
+        :eps,
+        :gif,
+        :gif87,
+        :ico,
+        :j2c,
+        :jp2,
+        :jpeg,
+        :jpg,
+        :pbm,
+        :pcd,
+        :pct,
+        :pcx,
+        :pdf,
+        :pict,
+        :pjpeg,
+        :png,
+        :png24,
+        :png32,
+        :png8,
+        :pnm,
+        :ppm,
+        :ps,
+        :psd,
+        :ras,
+        :tga,
+        :tiff,
+        :wbmp,
+        :xbm,
+        :xpm,
+        :xwd
+      ]
+
+      def encode(temp_object, format, args='')
+        format = format.to_s.downcase
+        throw :unable_to_handle unless supported_formats.include?(format.to_sym)
+        details = identify(temp_object)
+
+        if details[:format] == format.to_sym && args.empty?
+          temp_object
+        else
+          convert(temp_object, args, format)
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/generation/hash_with_css_style_keys.rb

@@ -0,0 +1,23 @@
+module Dragonfly
+  module Generation
+    
+    # HashWithCssStyleKeys is solely for being able to access a hash
+    # which has css-style keys (e.g. 'font-size') with the underscore
+    # symbol version
+    # @example
+    #   opts = {'font-size' => '23px', :color => 'white'}
+    #   opts = HashWithCssStyleKeys[opts]
+    #   opts[:font_size]   # ===> '23px'
+    #   opts[:color]       # ===> 'white'
+    class HashWithCssStyleKeys < Hash
+      def [](key)
+        super || (
+          str_key = key.to_s
+          css_key = str_key.gsub('_','-')
+          super(str_key) || super(css_key) || super(css_key.to_sym)
+        )
+      end
+    end
+
+  end
+end

data/lib/dragonfly/generation/image_magick_generator.rb

@@ -0,0 +1,140 @@
+module Dragonfly
+  module Generation
+    class ImageMagickGenerator
+
+      FONT_STYLES = {
+        'normal'  => 'normal',
+        'italic'  => 'italic',
+        'oblique' => 'oblique'
+      }
+
+      FONT_STRETCHES = {
+        'normal'          => 'normal',
+        'semi-condensed'  => 'semi-condensed',
+        'condensed'       => 'condensed',
+        'extra-condensed' => 'extra-condensed',
+        'ultra-condensed' => 'ultra-condensed',
+        'semi-expanded'   => 'semi-expanded',
+        'expanded'        => 'expanded',
+        'extra-expanded'  => 'extra-expanded',
+        'ultra-expanded'  => 'ultra-expanded'
+      }
+
+      FONT_WEIGHTS = {
+        'normal'  => 'normal',
+        'bold'    => 'bold',
+        'bolder'  => 'bolder',
+        'lighter' => 'lighter',
+        '100'     => 100,
+        '200'     => 200,
+        '300'     => 300,
+        '400'     => 400,
+        '500'     => 500,
+        '600'     => 600,
+        '700'     => 700,
+        '800'     => 800,
+        '900'     => 900
+      }
+
+      include ImageMagickUtils
+      include Configurable
+
+      def plasma(width, height, format='png')
+        tempfile = new_tempfile(format)
+        run "#{convert_command} -size #{width}x#{height} plasma:fractal #{tempfile.path}"
+        [
+          tempfile,
+          {:format => format.to_sym, :name => "plasma.#{format}"}
+        ]
+      end
+
+      def text(string, opts={})
+        opts = HashWithCssStyleKeys[opts]
+        args = []
+        format = (opts[:format] || :png)
+        background = opts[:background_color] || 'none'
+        font_size = (opts[:font_size] || 12).to_i
+        escaped_string = "\"#{string.gsub(/"/, '\"')}\""
+
+        # Settings
+        args.push("-gravity NorthWest")
+        args.push("-antialias")
+        args.push("-pointsize #{font_size}")
+        args.push("-font '#{opts[:font]}'") if opts[:font]
+        args.push("-family '#{opts[:font_family]}'") if opts[:font_family]
+        args.push("-fill #{opts[:color]}") if opts[:color]
+        args.push("-stroke #{opts[:stroke_color]}") if opts[:stroke_color]
+        args.push("-style #{FONT_STYLES[opts[:font_style]]}") if opts[:font_style]
+        args.push("-stretch #{FONT_STRETCHES[opts[:font_stretch]]}") if opts[:font_stretch]
+        args.push("-weight #{FONT_WEIGHTS[opts[:font_weight]]}") if opts[:font_weight]
+        args.push("-background #{background}")
+        args.push("label:#{escaped_string}")
+
+        # Padding
+        pt, pr, pb, pl = parse_padding_string(opts[:padding]) if opts[:padding]
+        padding_top    = (opts[:padding_top]    || pt || 0)
+        padding_right  = (opts[:padding_right]  || pr || 0)
+        padding_bottom = (opts[:padding_bottom] || pb || 0)
+        padding_left   = (opts[:padding_left]   || pl || 0)
+
+        tempfile = new_tempfile(format)
+        run "#{convert_command} #{args.join(' ')} #{tempfile.path}"
+
+        if (padding_top || padding_right || padding_bottom || padding_left)
+          attrs  = identify(tempfile)
+          text_width  = attrs[:width].to_i
+          text_height = attrs[:height].to_i
+          width  = padding_left + text_width  + padding_right
+          height = padding_top  + text_height + padding_bottom
+
+          args = args.slice(0, args.length - 2)
+          args.push("-size #{width}x#{height}")
+          args.push("xc:#{background}")
+          args.push("-annotate 0x0+#{padding_left}+#{padding_top} #{escaped_string}")
+          run "#{convert_command} #{args.join(' ')} #{tempfile.path}"
+        end
+
+        [
+          tempfile,
+          {:format => format, :name => "text.#{format}"}
+        ]
+      end
+
+      private
+
+      # Use css-style padding declaration, i.e.
+      # 10        (all sides)
+      # 10 5      (top/bottom, left/right)
+      # 10 5 10   (top, left/right, bottom)
+      # 10 5 10 5 (top, right, bottom, left)
+      def parse_padding_string(str)
+        padding_parts = str.gsub('px','').split(/\s+/).map{|px| px.to_i}
+        case padding_parts.size
+        when 1
+          p = padding_parts.first
+          [p,p,p,p]
+        when 2
+          p,q = padding_parts
+          [p,q,p,q]
+        when 3
+          p,q,r = padding_parts
+          [p,q,r,q]
+        when 4
+          padding_parts
+        else raise ArgumentError, "Couldn't parse padding string '#{str}' - should be a css-style string"
+        end
+      end
+
+      def scale_factor_for(font_size)
+        # Scale approximately to 64 if below
+        min_size = 64
+        if font_size < min_size
+          (min_size.to_f / font_size).ceil
+        else
+          1
+        end.to_f
+      end
+
+    end
+  end
+end

data/lib/dragonfly/generation/r_magick_generator.rb

@@ -38,24 +38,6 @@ module Dragonfly
         '900'     => 900
       }
 
-      # HashWithCssStyleKeys is solely for being able to access a hash
-      # which has css-style keys (e.g. 'font-size') with the underscore
-      # symbol version
-      # @example
-      #   opts = {'font-size' => '23px', :color => 'white'}
-      #   opts = HashWithCssStyleKeys[opts]
-      #   opts[:font_size]   # ===> '23px'
-      #   opts[:color]       # ===> 'white'
-      class HashWithCssStyleKeys < Hash
-        def [](key)
-          super || (
-            str_key = key.to_s
-            css_key = str_key.gsub('_','-')
-            super(str_key) || super(css_key) || super(css_key.to_sym)
-          )
-        end
-      end
-
       include RMagickUtils
       include Configurable
       configurable_attr :use_filesystem, true

data/lib/dragonfly/image_magick_utils.rb

@@ -0,0 +1,81 @@
+require 'tempfile'
+
+module Dragonfly
+  module ImageMagickUtils
+
+    # Exceptions
+    class ShellCommandFailed < RuntimeError; end
+
+    class << self
+      include Configurable
+      configurable_attr :convert_command, "convert"
+      configurable_attr :identify_command, "identify"
+      configurable_attr :log_commands, false
+    end
+    
+    include Loggable
+    
+    private
+
+    def convert(temp_object, args='', format=nil)
+      tempfile = new_tempfile(format)
+      run "#{convert_command} #{args} #{temp_object.path} #{tempfile.path}"
+      tempfile
+    end
+
+    def identify(temp_object)
+      # example of details string:
+      # myimage.png PNG 200x100 200x100+0+0 8-bit DirectClass 31.2kb
+      details = raw_identify(temp_object)
+      filename, format, geometry, geometry_2, depth, image_class, size = details.split(' ')
+      width, height = geometry.split('x')
+      {
+        :filename => filename,
+        :format => format.downcase.to_sym,
+        :width => width.to_i,
+        :height => height.to_i,
+        :depth => depth.to_i,
+        :image_class => image_class
+      }
+    end
+    
+    def raw_identify(temp_object, args='')
+      run "#{identify_command} #{args} #{temp_object.path}"
+    end
+    
+    def new_tempfile(ext=nil)
+      tempfile = ext ? Tempfile.new(['dragonfly', ".#{ext}"]) : Tempfile.new('dragonfly')
+      tempfile.binmode
+      tempfile.close
+      tempfile
+    end
+    
+    def convert_command
+      ImageMagickUtils.convert_command
+    end
+
+    def identify_command
+      ImageMagickUtils.identify_command
+    end
+
+    def run(command)
+      log.debug("Running command: #{command}") if ImageMagickUtils.log_commands
+      begin
+        result = `#{command}`
+      rescue Errno::ENOENT
+        raise_shell_command_failed(command)
+      end
+      if $?.exitstatus == 1
+        throw :unable_to_handle
+      elsif !$?.success?
+        raise_shell_command_failed(command)
+      end
+      result
+    end
+    
+    def raise_shell_command_failed(command)
+      raise ShellCommandFailed, "Command failed (#{command}) with exit status #{$?.exitstatus}"
+    end
+
+  end
+end