dragonfly 0.5.7 → 0.6.0

data/lib/dragonfly/config/r_magick_text.rb

@@ -0,0 +1,25 @@
+module Dragonfly
+  module Config
+
+    module RMagickText
+
+      def self.apply_configuration(app)
+        app.configure do |c|
+          c.datastore = DataStorage::TransparentDataStore.new
+          c.register_analyser(Analysis::FileCommandAnalyser)
+          c.register_processor(Processing::RMagickTextProcessor)
+          c.register_encoder(Encoding::RMagickEncoder)
+          c.parameters.add_shortcut :text, Hash do |_, options|
+            {
+              :processing_method => :text,
+              :processing_options => options,
+              :format => :png
+            }
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/dragonfly/config/rails_defaults.rb

@@ -0,0 +1,18 @@
+module Dragonfly
+  module Config
+    
+    module RailsDefaults
+    
+      def self.apply_configuration(app)
+        app.configure do |c|
+          c.log = ::Rails.logger
+          c.datastore.root_path = "#{::Rails.root}/public/system/dragonfly/#{::Rails.env}"
+          c.url_handler.configure do |u|
+            u.path_prefix = '/media'
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/config/rails_images.rb

@@ -0,0 +1,13 @@
+module Dragonfly
+  module Config
+    
+    module RailsImages
+    
+      def self.apply_configuration(app)
+        app.configure_with(RMagickImages)
+        app.configure_with(RailsDefaults)
+      end
+
+    end
+  end
+end

data/lib/dragonfly/configurable.rb

@@ -27,12 +27,13 @@ module Dragonfly
     
     module InstanceMethods
       
-      def configure(&blk)
+      def configure(&block)
         yield ConfigurationProxy.new(self)
       end
     
-      def configure_with(configurer)
-        configurer.apply_configuration(self)
+      def configure_with(configurer, *args, &block)
+        configurer.apply_configuration(self, *args)
+        configure(&block) if block
       end
     
       def configuration

data/lib/dragonfly/data_storage/base.rb

@@ -2,6 +2,8 @@ module Dragonfly
   module DataStorage
     class Base
 
+      include BelongsToApp
+
       def store(temp_object)
         raise NotImplementedError
       end

data/lib/dragonfly/data_storage/s3data_store.rb

@@ -6,10 +6,12 @@ module Dragonfly
     class S3DataStore < Base
   
       include Configurable
+      include AWS::S3
   
       configurable_attr :bucket_name
       configurable_attr :access_key_id
       configurable_attr :secret_access_key
+      configurable_attr :use_filesystem, true
 
       def connect!
         AWS::S3::Base.establish_connection!(
@@ -19,32 +21,37 @@ module Dragonfly
       end
 
       def create_bucket!
-        AWS::S3::Bucket.create(bucket_name)
+        Bucket.create(bucket_name) unless bucket_names.include?(bucket_name)
       end
 
       def store(temp_object)
         uid = generate_uid(temp_object.basename || 'file')
         ensure_initialized
-        AWS::S3::S3Object.store(uid, temp_object.file, bucket_name)
+        object = use_filesystem ? temp_object.file : temp_object.data
+        S3Object.store(uid, object, bucket_name)
         uid
       end
 
       def retrieve(uid)
         ensure_initialized
-        AWS::S3::S3Object.value(uid, bucket_name)
+        S3Object.value(uid, bucket_name)
       rescue AWS::S3::NoSuchKey => e
         raise DataNotFound, "#{e} - #{uid}"
       end
   
       def destroy(uid)
         ensure_initialized
-        AWS::S3::S3Object.delete(uid, bucket_name)
+        S3Object.delete(uid, bucket_name)
       rescue AWS::S3::NoSuchKey => e
         raise DataNotFound, "#{e} - #{uid}"
       end
 
       private
 
+      def bucket_names
+        Service.buckets.map{|bucket| bucket.name }
+      end
+
       def ensure_initialized
         unless @initialized
           connect!

data/lib/dragonfly/delegator.rb

@@ -1,6 +1,8 @@
 module Dragonfly
   module Delegator
     
+    include BelongsToApp
+    
     # This gets raised if no delegated objects are able to handle
     # the method call, even though they respond to that method.
     class UnableToHandle < StandardError; end
@@ -8,7 +10,9 @@ module Dragonfly
     def register(klass, *args, &block)
       object = klass.new(*args)
       object.configure(&block) if block
+      object.app = self.app if app_set? && object.is_a?(BelongsToApp)
       registered_objects << object
+      object
     end
     
     def unregister(klass)
@@ -23,12 +27,23 @@ module Dragonfly
       @registered_objects ||= []
     end
     
-    def callable_methods
+    def delegate(meth, *args)
+      registered_objects.reverse.each do |object|
+        catch :unable_to_handle do
+          return object.send(meth, *args) if object.respond_to?(meth)
+        end
+      end
+      # If the code gets here, then none of the registered objects were able to handle the method call
+      raise UnableToHandle, "None of the objects registered with #{self} were able to deal with the method call " +
+        "#{meth}(#{args.map{|a| a.inspect[0..100]}.join(',')}). You need to register one that can."
+    end
+    
+    def delegatable_methods
       registered_objects.map{|a| a.delegatable_methods }.flatten.uniq
     end
     
-    def has_callable_method?(method)
-      callable_methods.include?(method.to_method_name)
+    def has_delegatable_method?(method)
+      delegatable_methods.include?(method.to_method_name)
     end
     
     private
@@ -36,14 +51,11 @@ module Dragonfly
     attr_writer :registered_objects
     
     def method_missing(meth, *args)
-      registered_objects.reverse.each do |object|
-        catch :unable_to_handle do
-          return object.send(meth, *args) if object.respond_to?(meth)
-        end
+      if has_delegatable_method?(meth)
+        delegate(meth, *args)
+      else
+        super
       end
-      raise UnableToHandle, "None of the registered objects for #{self} were able to deal with the method call " +
-        "#{meth}(#{args.map{|a| a.inspect[0..100]}.join(',')}), even though the method is implemented" if self.has_callable_method?(meth)
-      super
     end
     
   end

data/lib/dragonfly/encoder_list.rb

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

data/lib/dragonfly/encoding/base.rb

@@ -2,6 +2,7 @@ module Dragonfly
   module Encoding    
     class Base
 
+      include BelongsToApp
       include Delegatable
 
       def encode(*args)

data/lib/dragonfly/encoding/r_magick_encoder.rb

@@ -2,15 +2,50 @@ require 'RMagick'
 
 module Dragonfly
   module Encoding
-    
+
     class RMagickEncoder < Base
-      
-      SUPPORTED_FORMATS = Magick.formats.select{|k,v| v =~ /.*rw./ }.map{|f| f.first.downcase }
-      
+
+      include Configurable
+
+      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(image, format, encoding={})
         format = format.to_s.downcase
-        throw :unable_to_handle unless SUPPORTED_FORMATS.include?(format)
-        encoded_image = Magick::Image.from_blob(image.data).first
+        throw :unable_to_handle unless supported_formats.include?(format.to_sym)
+        encoded_image = rmagick_image(image)
         if encoded_image.format.downcase == format
           image # do nothing
         else
@@ -18,8 +53,17 @@ module Dragonfly
           encoded_image.to_blob
         end
       end
-      
+
+      private
+
+      def rmagick_image(temp_object)
+        Magick::Image.from_blob(temp_object.data).first
+      rescue Magick::ImageMagickError => e
+        log.warn("Unable to handle content in #{self.class} - got:\n#{e}")
+        throw :unable_to_handle
+      end
+
     end
-    
+
   end
 end

data/lib/dragonfly/extended_temp_object.rb

@@ -22,15 +22,16 @@ module Dragonfly
   #   temp_object.transform!('300x200', :gif)      # ===> operate on self
   class ExtendedTempObject < TempObject
     
-    # Exceptions
-    class NotConfiguredError < RuntimeError; end
+    include BelongsToApp
     
-    class << self
-      attr_accessor :app
+    def initialize(obj, app)
+      super(obj)
+      self.app = app
+      @cache = {}
     end
     
     def process(processing_method, *args)
-      self.class.new(processor.send(processing_method, self, *args))
+      self.class.new(processor.send(processing_method, self, *args), app)
     end
     
     def process!(processing_method, *args)
@@ -38,7 +39,7 @@ module Dragonfly
     end
 
     def encode(*args)
-      self.class.new(encoder.encode(self, *args))
+      self.class.new(encoder.encode(self, *args), app)
     end
     
     def encode!(*args)
@@ -56,38 +57,40 @@ module Dragonfly
       self
     end
     
-    # As we create customly configured subclasses of this class, the console
-    # gives a confusing output when inspecting, so modify here
-    def inspect
-      super.sub('Class:','Custom Dragonfly::ExtendedTempObject:')
-    end
-    
     # Modify methods, public_methods and respond_to?, because method_missing
     # allows methods from the analyser
     
     def methods(*args)
-      (super + analyser.callable_methods).uniq
+      (super + analyser.delegatable_methods).uniq
     end
     
     def public_methods(*args)
-      (super + analyser.callable_methods).uniq
+      (super + analyser.delegatable_methods).uniq
     end
     
     def respond_to?(method)
-      super || analyser.has_callable_method?(method)
+      super || analyser.has_delegatable_method?(method)
     end
 
     private
+
+    attr_reader :cache
     
+    def flush_cache!
+      @cache = {}
+    end
+
+    def reset!
+      super
+      flush_cache!
+    end
+
     def method_missing(method, *args, &block)
-      if analyser.has_callable_method?(method)
-        # Define the method so we don't use method_missing next time
-        instance_var = "@#{method}"
-        self.class.class_eval do
+      if analyser.has_delegatable_method?(method)
+        # Define the method on the instance so we don't use method_missing next time
+        class << self; self; end.class_eval do
           define_method method do
-            # Lazy reader, like
-            #   @width ||= analyser.width(self)
-            instance_variable_set(instance_var, instance_variable_get(instance_var) || analyser.send(method, self))
+            cache[method] ||= analyser.delegate(method, self)
           end
         end
         # Now that it's defined (for next time)
@@ -97,10 +100,6 @@ module Dragonfly
       end
     end
     
-    def app
-      self.class.app ? self.class.app : raise(NotConfiguredError, "#{self.class} has no app set")
-    end
-    
     def analyser
       app.analysers
     end
@@ -116,6 +115,6 @@ module Dragonfly
     def parameters_class
       app.parameters_class
     end
-
+    
   end
 end

data/lib/dragonfly/processing/base.rb

@@ -2,6 +2,7 @@ module Dragonfly
   module Processing
     class Base
 
+      include BelongsToApp
       include Delegatable
 
     end

data/lib/dragonfly/processing/r_magick_processor.rb

@@ -2,7 +2,6 @@ require 'RMagick'
 
 module Dragonfly
   module Processing
-
     class RMagickProcessor < Base
       
       GRAVITIES = {
@@ -16,60 +15,13 @@ module Dragonfly
         's'  => Magick::SouthGravity,
         'se' => Magick::SouthEastGravity
       }
-      
-      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
+
+      def generate(width, height, format='png')
+        image = Magick::Image.read("plasma:fractal"){self.size = "#{width}x#{height}"}.first
+        image.format = format.to_s
+        image.to_blob
       end
       
-      
       # Processing methods
       
       def crop(temp_object, opts={})
@@ -89,11 +41,11 @@ module Dragonfly
         image.crop(gravity, x, y, width, height).to_blob
       end
       
-      def generate(width, height, format='png')
-        image = Magick::Image.read("plasma:fractal"){self.size = "#{width}x#{height}"}.first
-        image.format = format.to_s
-        image.to_blob
+      def greyscale(temp_object, opts={})
+        depth = opts[:depth] || 256
+        rmagick_image(temp_object).quantize(depth, Magick::GRAYColorspace).to_blob
       end
+      alias grayscale greyscale
       
       def resize(temp_object, opts={})
         rmagick_image(temp_object).change_geometry!(opts[:geometry]) do |cols, rows, img|
@@ -124,52 +76,6 @@ module Dragonfly
           temp_object
         end
       end
-      
-      def text(temp_object, opts={})
-        opts = HashWithCssStyleKeys[opts]
-        
-        draw = Magick::Draw.new
-        draw.gravity = Magick::CenterGravity
-        draw.text_antialias = true
-        
-        # Settings
-        draw.font         = opts[:font] if opts[:font]
-        draw.font_family  = opts[:font_family] if opts[:font_family]
-        draw.pointsize    = opts[:font_size].to_f if opts[:font_size]
-        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]
-
-        text = temp_object.data
-
-        # Calculate dimensions
-        metrics = draw.get_type_metrics(text)
-        width, height = metrics.width, metrics.height
-
-        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
-
-        # Hack - for small font sizes, the width seems to be affected by rounding errors
-        padding_right += 2
-
-        total_width = padding_left + width + padding_right
-        total_height = padding_top + height + padding_bottom
-
-        # Draw the background
-        image = Magick::Image.new(total_width, total_height){
-          self.background_color = opts[:background_color] || 'transparent'
-        }
-        # Draw the text
-        draw.annotate(image, width, height, padding_left, padding_top, text)
-        # Output image as string
-        image.format = 'png'
-        image.to_blob
-      end
 
       def vignette(temp_object, opts={})
         x      = opts[:x].to_f      || temp_object.width  * 0.1
@@ -184,32 +90,11 @@ module Dragonfly
       
       def rmagick_image(temp_object)
         Magick::Image.from_blob(temp_object.data).first
-      end
-
-      # 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
+      rescue Magick::ImageMagickError => e
+        log.warn("Unable to handle content in #{self.class} - got:\n#{e}")
+        throw :unable_to_handle
       end
 
     end
-
   end
 end