oahu-dragonfly 0.8.2

data/lib/dragonfly/encoder.rb

@@ -0,0 +1,13 @@
+module Dragonfly
+  class Encoder < FunctionManager
+    
+    def add(name=:encode, callable_obj=nil, &block)
+      super(name, callable_obj, &block)
+    end
+    
+    def encode(temp_object, *args)
+      call_last(:encode, temp_object, *args)
+    end
+
+  end
+end

data/lib/dragonfly/encoding/image_magick_encoder.rb

@@ -0,0 +1,6 @@
+module Dragonfly
+  module Encoding
+    puts "WARNING: Dragonfly::Encoding::ImageMagickEncoder is DEPRECATED and will soon be removed. Please use Dragonfly::ImageMagick::Encoder instead."
+    ImageMagickEncoder = ImageMagick::Encoder
+  end
+end

data/lib/dragonfly/function_manager.rb

@@ -0,0 +1,71 @@
+module Dragonfly
+  class FunctionManager
+
+    # Exceptions
+    class NotDefined < NoMethodError; end
+    class UnableToHandle < NotImplementedError; end
+
+    include Loggable
+    include Configurable
+
+    def initialize
+      @functions = {}
+      @objects = []
+    end
+
+    def add(name, callable_obj=nil, &block)
+      functions[name] ||= []
+      functions[name] << (callable_obj || block)
+    end
+
+    attr_reader :functions, :objects
+
+    def register(klass, *args, &block)
+      obj = klass.new(*args)
+      obj.configure(&block) if block
+      obj.use_same_log_as(self) if obj.is_a?(Loggable)
+      obj.use_as_fallback_config(self) if obj.is_a?(Configurable)
+      methods_to_add(obj).each do |meth|
+        add meth.to_sym, obj.method(meth)
+      end
+      objects << obj
+      obj
+    end
+
+    def call_last(meth, *args)
+      if functions[meth.to_sym]
+        functions[meth.to_sym].reverse.each do |function|
+          catch :unable_to_handle do
+            return function.call(*args)
+          end
+        end
+        # If the code gets here, then none of the registered functions were able to handle the method call
+        raise UnableToHandle, "None of the functions registered with #{self} were able to deal with the method call " +
+          "#{meth}(#{args.map{|a| a.inspect[0..100]}.join(',')}). You may need to register one that can."
+      else
+        raise NotDefined, "function #{meth} not registered with #{self}"
+      end
+    end
+
+    def get_registered(klass)
+      objects.reverse.detect{|o| o.instance_of?(klass) }
+    end
+
+    def inspect
+      to_s.sub(/>$/, " with functions: #{functions.keys.map{|k| k.to_s }.sort.join(', ')} >")
+    end
+
+    private
+
+    def methods_to_add(obj)
+      if obj.is_a?(Configurable)
+        obj.public_methods(false) -
+          obj.config_methods.map{|meth| meth.to_method_name} -
+          [:configured_class.to_method_name] # Hacky - there must be a better way...
+      else
+        obj.public_methods(false)
+      end
+    end
+
+  end
+end

data/lib/dragonfly/generation/image_magick_generator.rb

@@ -0,0 +1,6 @@
+module Dragonfly
+  module Generation
+    puts "WARNING: Dragonfly::Generation::ImageMagickGenerator is DEPRECATED and will soon be removed. Please use Dragonfly::ImageMagick::Generator instead."
+    ImageMagickGenerator = ImageMagick::Generator
+  end
+end

data/lib/dragonfly/generator.rb

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

data/lib/dragonfly/hash_with_css_style_keys.rb

@@ -0,0 +1,21 @@
+module Dragonfly
+  
+  # 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

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,41 @@
+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 :convert do |args, format|
+            process :convert, args, format
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/dragonfly/image_magick/encoder.rb

@@ -0,0 +1,57 @@
+module Dragonfly
+  module ImageMagick
+    class Encoder
+
+      include Configurable
+      include Utils
+
+      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/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,99 @@
+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[/^[+-]/]
+      
+        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