fog-dragonfly 0.8.1

data/lib/dragonfly/data_storage/s3data_store.rb

@@ -0,0 +1,115 @@
+require 'fog'
+
+module Dragonfly
+  module DataStorage
+
+    class S3DataStore
+
+      include Configurable
+      include Serializer
+
+      # Available options are defined in Fog Storage[http://github.com/geemus/fog/blob/master/lib/fog/aws/storage.rb]
+      #
+      #     'eu-west-1' => 's3-eu-west-1.amazonaws.com'
+      #     'us-east-1' => 's3.amazonaws.com'
+      #     'ap-southeast-1' => 's3-ap-southeast-1.amazonaws.com'
+      #     'us-west-1' => 's3-us-west-1.amazonaws.com'
+
+      configurable_attr :bucket_name
+      configurable_attr :access_key_id
+      configurable_attr :secret_access_key
+      configurable_attr :region
+      configurable_attr :specific_uid
+      configurable_attr :use_filesystem, true
+      configurable_attr :autocreate_bucket, false
+
+      def initialize(opts={})
+        self.bucket_name = opts[:bucket_name]
+        self.access_key_id = opts[:access_key_id]
+        self.secret_access_key = opts[:secret_access_key]
+      end
+
+      def connection
+        @connection ||= Fog::AWS::Storage.new(
+          :aws_access_key_id => access_key_id,
+          :aws_secret_access_key => secret_access_key,
+          :region => region
+        )
+      end
+
+      def create_bucket!
+        connection.put_bucket(bucket_name) unless bucket_names.include?(bucket_name)
+      end
+
+      def store(temp_object, opts={})
+        uid = opts[:path] || generate_uid(temp_object.name || 'file')
+        ensure_initialized
+        extra_data = temp_object.attributes
+        if use_filesystem
+          temp_object.file do |f|
+            connection.put_object(bucket_name,
+                                  uid,
+                                  f.read,
+                                  s3_metadata_for(extra_data))
+          end
+        else
+          connection.put_object(bucket_name,
+                                uid,
+                                temp_object.data,
+                                s3_metadata_for(extra_data))
+        end
+        uid
+      end
+
+      def retrieve(uid)
+        ensure_initialized
+        s3_object = connection.get_object(bucket_name, uid)
+        [
+          s3_object.body,
+          parse_s3_metadata(s3_object.headers)
+        ]
+      rescue Excon::Errors::NotFound => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def destroy(uid)
+        ensure_initialized
+        connection.delete_object(bucket_name, uid)
+      rescue Excon::Errors::NotFound => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      private
+
+      def bucket_names
+        connection.get_service.body['Buckets'].map{|bucket| bucket['Name'] }
+      end
+
+      def ensure_initialized
+        unless @initialized
+          create_bucket! if autocreate_bucket
+          @initialized = true
+        end
+      end
+
+      def generate_uid(name)
+        if self.specific_uid.is_a?(Proc)
+          self.specific_uid.call(name)
+        else
+          "#{Time.now.strftime '%Y/%m/%d/%H/%M/%S'}/#{rand(1000)}/#{name.gsub(/[^\w.]+/, '_')}"
+        end
+      end
+
+      def s3_metadata_for(extra_data)
+        {'x-amz-meta-extra' => marshal_encode(extra_data)}
+      end
+
+      def parse_s3_metadata(metadata)
+        extra_data = metadata['x-amz-meta-extra']
+        marshal_decode(extra_data) if extra_data
+      end
+
+    end
+
+  end
+end

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,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/encoding/r_magick_encoder.rb

@@ -0,0 +1,61 @@
+require 'RMagick'
+
+module Dragonfly
+  module Encoding
+    class RMagickEncoder
+
+      include Configurable
+      include RMagickUtils
+
+      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
+      ]
+      configurable_attr :use_filesystem, true
+
+      def encode(temp_object, format, encoding={})
+        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
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/function_manager.rb

@@ -0,0 +1,69 @@
+module Dragonfly
+  class FunctionManager
+
+    # Exceptions
+    class NotDefined < NoMethodError; end
+    class UnableToHandle < NotImplementedError; end
+
+    include Loggable
+
+    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)
+      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.configuration_methods.map{|meth| meth.to_method_name} -
+          [:configuration_methods.to_method_name]
+      else
+        obj.public_methods(false)
+      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