dragonfly 0.8.6 → 0.9.0

data/lib/dragonfly/image_magick/analyser.rb

@@ -0,0 +1,51 @@
+module Dragonfly
+  module ImageMagick
+    class Analyser
+
+      include Utils
+      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
+      
+      def image?(temp_object)
+        !!catch(:unable_to_handle){ identify(temp_object) }
+      end
+
+    end
+  end
+end

data/lib/dragonfly/image_magick/config.rb

@@ -0,0 +1,44 @@
+module Dragonfly
+  module ImageMagick
+
+    # ImageMagick Config 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 Config
+
+      def self.apply_configuration(app, opts={})
+        app.configure do |c|
+          c.analyser.register(ImageMagick::Analyser)
+          c.processor.register(ImageMagick::Processor)
+          c.encoder.register(ImageMagick::Encoder)
+          c.generator.register(ImageMagick::Generator)
+
+          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 :strip do
+            process :strip
+          end
+          c.job :convert do |args, format|
+            process :convert, args, format
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/dragonfly/{encoding/r_magick_encoder.rb → image_magick/encoder.rb}

@@ -1,11 +1,9 @@
-require 'RMagick'
-
 module Dragonfly
-  module Encoding
-    class RMagickEncoder
+  module ImageMagick
+    class Encoder
 
       include Configurable
-      include RMagickUtils
+      include Utils
 
       configurable_attr :supported_formats, [
         :ai,
@@ -41,18 +39,16 @@ module Dragonfly
         :xpm,
         :xwd
       ]
-      configurable_attr :use_filesystem, true
 
-      def encode(temp_object, format, encoding={})
+      def encode(temp_object, format, args='')
         format = format.to_s.downcase
         throw :unable_to_handle unless supported_formats.include?(format.to_sym)
-        rmagick_image(temp_object) do |image|
-          if image.format.downcase == format
-            temp_object # do nothing
-          else
-            image.format = format
-            image
-          end
+        details = identify(temp_object)
+
+        if details[:format] == format.to_sym && args.empty?
+          temp_object
+        else
+          convert(temp_object, args, format)
         end
       end
 

data/lib/dragonfly/image_magick/generator.rb

@@ -0,0 +1,145 @@
+module Dragonfly
+  module ImageMagick
+    class Generator
+
+      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 Utils
+      include Configurable
+
+      def plain(width, height, colour, opts={})
+        format = opts[:format] || 'png'
+        [
+          convert(nil, "-size #{width}x#{height} \"xc:#{colour}\"", format),
+          {:format => format.to_sym, :name => "plain.#{format}"}
+        ]
+      end
+
+      def plasma(width, height, format='png')
+        [
+          convert(nil, "-size #{width}x#{height} plasma:fractal", format),
+          {: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 = convert(nil, args.join(' '), format)
+
+        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/image_magick/processor.rb

@@ -0,0 +1,104 @@
+module Dragonfly
+  module ImageMagick
+    class Processor
+
+      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 Utils
+      
+      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[/^[+-]/]
+        repage  = opts[:repage] == false ? '' : '+repage'
+    
+        convert(temp_object, "-crop #{width}x#{height}#{x}#{y}#{" -gravity #{gravity}" if gravity} #{repage}")
+      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 strip(temp_object)
+        convert(temp_object, "-strip")
+      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/image_magick/utils.rb

@@ -0,0 +1,72 @@
+require 'tempfile'
+
+module Dragonfly
+  module ImageMagick
+    module Utils
+
+      # Exceptions
+      class ShellCommandFailed < RuntimeError; end
+
+      include Loggable
+      include Configurable
+      configurable_attr :convert_command, "convert"
+      configurable_attr :identify_command, "identify"
+      configurable_attr :log_commands, false
+    
+      private
+
+      def convert(temp_object=nil, args='', format=nil)
+        tempfile = new_tempfile(format)
+        run "#{convert_command} #{temp_object.path if temp_object} #{args} #{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 run(command)
+        log.debug("Running command: #{command}") if 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
+end