dragonfly 0.8.6 → 0.9.0

data/lib/dragonfly/data_storage/mongo_data_store.rb

@@ -12,6 +12,8 @@ module Dragonfly
       configurable_attr :database, 'dragonfly'
       configurable_attr :username
       configurable_attr :password
+      configurable_attr :connection
+      configurable_attr :db
 
       # Mongo gem deprecated ObjectID in favour of ObjectId
       OBJECT_ID = defined?(BSON::ObjectId) ? BSON::ObjectId : BSON::ObjectID
@@ -23,12 +25,14 @@ module Dragonfly
         self.database = opts[:database] if opts[:database]
         self.username = opts[:username]
         self.password = opts[:password]
+        self.connection = opts[:connection]
+        self.db = opts[:db]
       end
 
       def store(temp_object, opts={})
         ensure_authenticated!
         temp_object.file do |f|
-          mongo_id = grid.put(f, :metadata => marshal_encode(temp_object.attributes))
+          mongo_id = grid.put(f, :metadata => marshal_encode(opts[:meta] || {}))
           mongo_id.to_s
         end
       end
@@ -36,11 +40,11 @@ module Dragonfly
       def retrieve(uid)
         ensure_authenticated!
         grid_io = grid.get(bson_id(uid))
-        extra = marshal_decode(grid_io.metadata)
-        extra[:meta].merge!(:stored_at => grid_io.upload_date)
+        meta = marshal_decode(grid_io.metadata)
+        meta.merge!(:stored_at => grid_io.upload_date)
         [
           grid_io.read,
-          extra
+          meta
         ]
       rescue Mongo::GridFileNotFound, INVALID_OBJECT_ID => e
         raise DataNotFound, "#{e} - #{uid}"

data/lib/dragonfly/data_storage/s3data_store.rb

@@ -1,4 +1,4 @@
-require 'aws/s3'
+require 'fog'
 
 module Dragonfly
   module DataStorage
@@ -6,88 +6,132 @@ module Dragonfly
     class S3DataStore
 
       include Configurable
-      include AWS::S3
       include Serializer
 
       configurable_attr :bucket_name
       configurable_attr :access_key_id
       configurable_attr :secret_access_key
       configurable_attr :use_filesystem, true
+      configurable_attr :region
+      configurable_attr :storage_headers, {'x-amz-acl' => 'public-read'}
+
+      REGIONS = {
+        'us-east-1'      => 's3.amazonaws.com',  #default
+        'eu-west-1'      => 's3-eu-west-1.amazonaws.com',
+        'ap-southeast-1' => 's3-ap-southeast-1.amazonaws.com',
+        'us-west-1'      => 's3-us-west-1.amazonaws.com'
+      }
 
       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 connect!
-        AWS::S3::Base.establish_connection!(
-          :access_key_id => access_key_id,
-          :secret_access_key => secret_access_key
-        )
-      end
-
-      def create_bucket!
-        Bucket.create(bucket_name) unless bucket_names.include?(bucket_name)
+        self.region = opts[:region]
       end
 
       def store(temp_object, opts={})
-        uid = opts[:path] || generate_uid(temp_object.name || 'file')
-        ensure_initialized
-        extra_data = temp_object.attributes
+        ensure_configured
+        ensure_bucket_initialized
+        
+        meta = opts[:meta] || {}
+        headers = opts[:headers] || {}
+        uid = opts[:path] || generate_uid(meta[:name] || temp_object.original_filename || 'file')
+        
         if use_filesystem
           temp_object.file do |f|
-            S3Object.store(uid, f, bucket_name, s3_metadata_for(extra_data))
+            storage.put_object(bucket_name, uid, f, full_storage_headers(headers, meta))
           end
         else
-          S3Object.store(uid, temp_object.data, bucket_name, s3_metadata_for(extra_data))
+          storage.put_object(bucket_name, uid, temp_object.data, full_storage_headers(headers, meta))
         end
+        
         uid
       end
 
       def retrieve(uid)
-        ensure_initialized
-        s3_object = S3Object.find(uid, bucket_name)
+        ensure_configured
+        response = storage.get_object(bucket_name, uid)
         [
-          s3_object.value,
-          parse_s3_metadata(s3_object.metadata)
+          response.body,
+          parse_s3_metadata(response.headers)
         ]
-      rescue AWS::S3::NoSuchKey => e
+      rescue Excon::Errors::NotFound => e
         raise DataNotFound, "#{e} - #{uid}"
       end
 
       def destroy(uid)
-        ensure_initialized
-        S3Object.delete(uid, bucket_name)
-      rescue AWS::S3::NoSuchKey => e
+        storage.delete_object(bucket_name, uid)
+      rescue Excon::Errors::NotFound => e
         raise DataNotFound, "#{e} - #{uid}"
       end
 
+      def url_for(uid, opts={})
+        if opts && opts[:expires]
+          storage.get_object_url(bucket_name, uid, opts[:expires])
+        else
+          "http://#{bucket_name}.s3.amazonaws.com/#{uid}"
+        end
+      end
+
+      def domain
+        REGIONS[get_region]
+      end
+
+      def storage
+        @storage ||= Fog::Storage.new(
+          :provider => 'AWS',
+          :aws_access_key_id => access_key_id,
+          :aws_secret_access_key => secret_access_key,
+          :region => region
+        )
+      end
+
+      def bucket_exists?
+        storage.get_bucket_location(bucket_name)
+        true
+      rescue Excon::Errors::NotFound => e
+        false
+      end
+
       private
 
-      def bucket_names
-        Service.buckets.map{|bucket| bucket.name }
+      def ensure_configured
+        unless @configured
+          [:bucket_name, :access_key_id, :secret_access_key].each do |attr|
+            raise NotConfigured, "You need to configure #{self.class.name} with #{attr}" if send(attr).nil?
+          end
+          @configured = true
+        end
       end
 
-      def ensure_initialized
-        unless @initialized
-          connect!
-          create_bucket!
-          @initialized = true
+      def ensure_bucket_initialized
+        unless @bucket_initialized
+          storage.put_bucket(bucket_name, 'LocationConstraint' => region) unless bucket_exists?
+          @bucket_initialized = true
         end
       end
 
+      def get_region
+        reg = region || 'us-east-1'
+        raise "Invalid region #{reg} - should be one of #{valid_regions.join(', ')}" unless valid_regions.include?(reg)
+        reg
+      end
+
       def generate_uid(name)
         "#{Time.now.strftime '%Y/%m/%d/%H/%M/%S'}/#{rand(1000)}/#{name.gsub(/[^\w.]+/, '_')}"
       end
 
-      def s3_metadata_for(extra_data)
-        {'x-amz-meta-extra' => marshal_encode(extra_data)}
+      def full_storage_headers(headers, meta)
+        {'x-amz-meta-extra' => marshal_encode(meta)}.merge(storage_headers).merge(headers)
+      end
+
+      def parse_s3_metadata(headers)
+        encoded_meta = headers['x-amz-meta-extra']
+        (marshal_decode(encoded_meta) if encoded_meta) || {}
       end
 
-      def parse_s3_metadata(metadata)
-        extra_data = metadata['x-amz-meta-extra']
-        marshal_decode(extra_data) if extra_data
+      def valid_regions
+        REGIONS.keys
       end
 
     end

data/lib/dragonfly/encoding/image_magick_encoder.rb

@@ -1,57 +1,6 @@
 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
+    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

@@ -6,6 +6,7 @@ module Dragonfly
     class UnableToHandle < NotImplementedError; end
 
     include Loggable
+    include Configurable
 
     def initialize
       @functions = {}
@@ -23,6 +24,7 @@ module Dragonfly
       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
@@ -58,8 +60,8 @@ module Dragonfly
     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]
+          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

data/lib/dragonfly/generation/image_magick_generator.rb

@@ -1,140 +1,6 @@
 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
+    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/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