dragonfly 0.5.7 → 0.6.0

data/lib/dragonfly/processing/r_magick_text_processor.rb

@@ -0,0 +1,155 @@
+require 'RMagick'
+
+module Dragonfly
+  module Processing
+
+    class RMagickTextProcessor < Base
+      
+      FONT_STYLES = {
+        'normal' => Magick::NormalStyle,
+        'italic' => Magick::ItalicStyle,
+        'oblique' => Magick::ObliqueStyle
+      }
+      
+      FONT_STRETCHES = {
+        'normal'          => Magick::NormalStretch,
+        'semi-condensed'  => Magick::SemiCondensedStretch,
+        'condensed'       => Magick::CondensedStretch,
+        'extra-condensed' => Magick::ExtraCondensedStretch,
+        'ultra-condensed' => Magick::UltraCondensedStretch,
+        'semi-expanded'   => Magick::SemiExpandedStretch,
+        'expanded'        => Magick::ExpandedStretch,
+        'extra-expanded'  => Magick::ExtraExpandedStretch,
+        'ultra-expanded'  => Magick::UltraExpandedStretch
+      }
+      
+      FONT_WEIGHTS = {
+        'normal'  => Magick::NormalWeight,
+        'bold'    => Magick::BoldWeight,
+        'bolder'  => Magick::BolderWeight,
+        'lighter' => Magick::LighterWeight,
+        '100'     => 100,
+        '200'     => 200,
+        '300'     => 300,
+        '400'     => 400,
+        '500'     => 500,
+        '600'     => 600,
+        '700'     => 700,
+        '800'     => 800,
+        '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
+            
+      def text(temp_object, opts={})
+        opts = HashWithCssStyleKeys[opts]
+        
+        draw = Magick::Draw.new
+        draw.gravity = Magick::CenterGravity
+        draw.text_antialias = true
+        
+        # Font size
+        font_size = (opts[:font_size] || 12).to_i
+
+        # Scale up the text for better quality -
+        #  it will be reshrunk at the end
+        s = scale_factor_for(font_size)
+
+        # Settings
+        draw.pointsize    = font_size * s
+        draw.font         = opts[:font] if opts[:font]
+        draw.font_family  = opts[:font_family] if opts[:font_family]
+        draw.fill         = opts[:color] if opts[:color]
+        draw.stroke       = opts[:stroke_color] if opts[:stroke_color]
+        draw.font_style   = FONT_STYLES[opts[:font_style]] if opts[:font_style]
+        draw.font_stretch = FONT_STRETCHES[opts[:font_stretch]] if opts[:font_stretch]
+        draw.font_weight  = FONT_WEIGHTS[opts[:font_weight]] if opts[:font_weight]
+
+        # Padding
+        # NB the values are scaled up by the scale factor
+        pt, pr, pb, pl = parse_padding_string(opts[:padding]) if opts[:padding]
+        padding_top    = (opts[:padding_top]    || pt || 0) * s
+        padding_right  = (opts[:padding_right]  || pr || 0) * s
+        padding_bottom = (opts[:padding_bottom] || pb || 0) * s
+        padding_left   = (opts[:padding_left]   || pl || 0) * s
+
+        text = temp_object.data
+
+        # Calculate (scaled up) dimensions
+        metrics = draw.get_type_metrics(text)
+        width, height = metrics.width, metrics.height
+
+        scaled_up_width = padding_left + width + padding_right
+        scaled_up_height = padding_top + height + padding_bottom
+
+        # Draw the background
+        image = Magick::Image.new(scaled_up_width, scaled_up_height){
+          self.background_color = opts[:background_color] || 'transparent'
+        }
+        # Draw the text
+        draw.annotate(image, width, height, padding_left, padding_top, text)
+        
+        # Scale back down again
+        image.scale!(1/s)
+        
+        image.format = 'png'
+
+        # Output image as string
+        image.to_blob
+      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/processor_list.rb

@@ -1,5 +1,9 @@
 module Dragonfly
   class ProcessorList
     include Delegator
+    
+    def initialize(app)
+      @app = app
+    end
   end
 end

data/lib/dragonfly/rails/images.rb

@@ -2,23 +2,11 @@ require 'dragonfly'
 require 'rack/cache'
 
 ### The dragonfly app ###
-
 app = Dragonfly::App[:images]
-app.configure_with(Dragonfly::RMagickConfiguration)
-app.configure do |c|
-  c.log = Rails.logger
-  c.datastore.configure do |d|
-    d.root_path = "#{Rails.root}/public/system/dragonfly/#{Rails.env}"
-  end
-  c.url_handler.configure do |u|
-    u.protect_from_dos_attacks = false
-    u.path_prefix = '/media'
-  end
-end
+app.configure_with(Dragonfly::Config::RailsImages)
 
 ### Extend active record ###
-ActiveRecord::Base.extend Dragonfly::ActiveRecordExtensions
-ActiveRecord::Base.register_dragonfly_app(:image, app)
+Dragonfly.active_record_macro(:image, app)
 
 ### Insert the middleware ###
 # Where the middleware is depends on the version of Rails

data/lib/dragonfly/temp_object.rb

@@ -53,26 +53,34 @@ module Dragonfly
     end
     
     def data
-      @data ||= initialized_data || file.open.read
+      @data ||= initialized_data || file.read
     end
 
     def tempfile
-      if @tempfile
+      @tempfile ||= begin
+        if initialized_tempfile
+          @tempfile = initialized_tempfile
+        elsif initialized_data
+          @tempfile = Tempfile.new('dragonfly')
+          @tempfile.write(initialized_data)
+        elsif initialized_file
+          @tempfile = copy_to_tempfile(initialized_file.path)
+        end
+        @tempfile.close
         @tempfile
-      elsif initialized_tempfile
-        initialized_tempfile.open
-        @tempfile = initialized_tempfile
-      elsif initialized_data
-        tempfile = Tempfile.new('dragonfly')
-        tempfile.write(initialized_data)
-        tempfile.open
-        @tempfile = tempfile
-      elsif initialized_file
-        @tempfile = copy_to_tempfile(initialized_file)
       end
     end
-    
-    alias_method :file, :tempfile
+
+    def file(&block)
+      f = tempfile.open
+      if block_given?
+        ret = yield f
+        f.close
+      else
+        ret = f
+      end
+      ret
+    end
     
     def path
       tempfile.path
@@ -104,17 +112,10 @@ module Dragonfly
     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)
+      to_io do |io|
+        while part = io.read(block_size)
           yield part
         end
-        tempfile.close
       end
     end
     
@@ -127,6 +128,14 @@ module Dragonfly
       File.new(path)
     end
     
+    def to_io(&block)
+      if initialized_data
+        StringIO.open(initialized_data, &block)
+      else
+        file(&block)
+      end
+    end
+
     protected
     
     attr_accessor :initialized_data, :initialized_tempfile, :initialized_file
@@ -134,16 +143,14 @@ module Dragonfly
     private
     
     def reset!
-      instance_variables.each do |var|
-        instance_variable_set(var, nil)
-      end
+      @data = @tempfile = @initialized_data = @initialized_file = @initialized_tempfile = nil
     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_tempfile = copy_to_tempfile(obj.initialized_tempfile.path) if obj.initialized_tempfile
         @initialized_file = obj.initialized_file
       when String
         @initialized_data = obj
@@ -153,20 +160,20 @@ module Dragonfly
         @initialized_file = obj
         self.name = File.basename(obj.path)
       else
-        raise ArgumentError, "#{self.class.name} must be initialized with a String, a File or a Tempfile"
+        raise ArgumentError, "#{self.class.name} must be initialized with a String, a File, a Tempfile, or another TempObject"
       end
       self.name = obj.original_filename if obj.respond_to?(:original_filename)
     end
     
-    def copy_to_tempfile(file)
-      tempfile = Tempfile.new('dragonfly')
-      FileUtils.cp File.expand_path(file.path), tempfile.path
-      tempfile
-    end
-    
     def block_size
       self.class.block_size
     end
     
+    def copy_to_tempfile(path)
+      tempfile = Tempfile.new('dragonfly')
+      FileUtils.cp File.expand_path(path), tempfile.path
+      tempfile
+    end
+    
   end
 end

data/spec/dragonfly/active_record_extensions/migration.rb

@@ -1,3 +1,10 @@
+# Seems to blow up on Rails 3 without this
+begin
+  require 'active_support/all'
+rescue LoadError => e
+  puts "Couldn't load activesupport: #{e}"
+end
+
 class MigrationForTest < ActiveRecord::Migration
   
   def self.up

data/spec/dragonfly/active_record_extensions/model_spec.rb

@@ -6,18 +6,17 @@ describe Item do
 
   describe "registering dragonfly apps" do
 
-    before(:each) do
-      @app1, @app2 = Dragonfly::App[:images], Dragonfly::App[:videos]
-      ActiveRecord::Base.register_dragonfly_app(:image, @app1)
-      ActiveRecord::Base.register_dragonfly_app(:video, @app2)
-    end
-
+    let(:app1){ Dragonfly::App[:images] }
+    let(:app2){ Dragonfly::App[:videos] }
+    
     it "should return the mapping of apps to attributes" do
+      Dragonfly.active_record_macro(:image, app1)
+      Dragonfly.active_record_macro(:video, app2)
       Item.class_eval do
         image_accessor :preview_image
         video_accessor :trailer_video
       end
-      Item.dragonfly_apps_for_attributes.should == {:preview_image => @app1, :trailer_video => @app2}
+      Item.dragonfly_apps_for_attributes.should == {:preview_image => app1, :trailer_video => app2}
     end
 
   end
@@ -36,7 +35,7 @@ describe Item do
     
       before(:each) do
         @app = Dragonfly::App[:images]
-        ActiveRecord::Base.register_dragonfly_app(:image, @app)
+        Dragonfly.active_record_macro(:image, @app)
         Item.class_eval do
           image_accessor :preview_image
         end
@@ -259,7 +258,7 @@ describe Item do
 
     before(:all) do
       @app = Dragonfly::App[:images]
-      ActiveRecord::Base.register_dragonfly_app(:image, @app)
+      Dragonfly.active_record_macro(:image, @app)
     end
     
     describe "validates_presence_of" do
@@ -417,7 +416,7 @@ describe Item do
         def number_of_As(temp_object); temp_object.data.count('A'); end
       end
       @app.register_analyser(custom_analyser)
-      ActiveRecord::Base.register_dragonfly_app(:image, @app)
+      Dragonfly.active_record_macro(:image, @app)
       Item.class_eval do
         image_accessor :preview_image
       end
@@ -549,7 +548,7 @@ describe Item do
   describe "inheritance" do
     before(:all) do
       @app = Dragonfly::App[:images]
-      ActiveRecord::Base.register_dragonfly_app(:image, @app)
+      Dragonfly.active_record_macro(:image, @app)
       Car.class_eval do
         image_accessor :image
       end

data/spec/dragonfly/active_record_extensions/spec_helper.rb

@@ -5,7 +5,7 @@ require 'active_record'
 
 DB_FILE = File.expand_path(File.dirname(__FILE__)+'/db.sqlite3')
 
-%w{migration initializer models}.each do |file|
+%w{migration models}.each do |file|
   require "#{File.dirname(__FILE__)}/#{file}"
 end 
 

data/spec/dragonfly/analysis/r_magick_analyser_spec.rb

@@ -28,4 +28,17 @@ describe Dragonfly::Analysis::RMagickAnalyser do
     @analyser.depth(@beach).should == 8
   end
   
-end
+  it "should return the format" do
+    @analyser.format(@beach).should == :png
+  end
+  
+  %w(width height aspect_ratio number_of_colours depth format).each do |meth|
+    it "should throw unable_to_handle in #{meth.inspect} if it's not an image file" do
+      temp_object = Dragonfly::TempObject.new('blah')
+      lambda{
+        @analyser.send(meth, temp_object)
+      }.should throw_symbol(:unable_to_handle)
+    end
+  end
+  
+end

data/spec/dragonfly/belongs_to_app_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class Testoast
+  include Dragonfly::BelongsToApp
+end
+
+describe Dragonfly::BelongsToApp do
+  
+  before(:each) do
+    @object = Testoast.new
+  end
+
+  describe "when the app is not set" do
+    it "should raise an error if the app is accessed" do
+      lambda{
+        @object.app
+      }.should raise_error(Dragonfly::BelongsToApp::NotConfigured)
+    end
+    it "should say it's not set" do
+      @object.app_set?.should be_false
+    end
+    it "should still return a log" do
+      @object.log.should be_a(Logger)
+    end
+    it "should cache the log" do
+      @object.log.should == @object.log
+    end
+    it "should return the app's log if it's subsequently set" do
+      @object.log.should be_a(Logger)
+      @object.app = (app = mock('app', :log => mock))
+      @object.log.should == app.log
+    end
+  end
+
+  describe "when the app is set" do
+    before(:each) do
+      @app = mock('app', :log => mock)
+      @object.app = @app
+    end
+    
+    it "should return the app" do
+      @object.app.should == @app
+    end
+    
+    it "should return the app's log" do
+      @object.log.should == @app.log
+    end
+    
+    it "should say it's set" do
+      @object.app_set?.should be_true
+    end
+
+  end
+  
+end