dragonfly 0.9.15 → 1.0

data/lib/dragonfly/data_storage/mongo_data_store.rb

@@ -1,96 +0,0 @@
-require 'mongo'
-
-module Dragonfly
-  module DataStorage
-    class MongoDataStore
-
-      include Configurable
-      include Serializer
-
-      configurable_attr :host
-      configurable_attr :hosts
-      configurable_attr :connection_opts, {}
-      configurable_attr :port
-      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
-      INVALID_OBJECT_ID = defined?(BSON::InvalidObjectId) ? BSON::InvalidObjectId : BSON::InvalidObjectID
-
-      def initialize(opts={})
-        self.host = opts[:host]
-        self.hosts = opts[:hosts]
-        self.connection_opts = opts[:connection_opts] if opts[:connection_opts]
-        self.port = opts[:port]
-        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!
-        content_type = opts[:content_type] || opts[:mime_type] || 'application/octet-stream'
-        temp_object.file do |f|
-          mongo_id = grid.put(f, :content_type => content_type,
-                                 :metadata => marshal_encode(temp_object.meta))
-          mongo_id.to_s
-        end
-      end
-
-      def retrieve(uid)
-        ensure_authenticated!
-        grid_io = grid.get(bson_id(uid))
-        meta = marshal_decode(grid_io.metadata)
-        meta.merge!(:stored_at => grid_io.upload_date)
-        [
-          grid_io.read,
-          meta
-        ]
-      rescue Mongo::GridFileNotFound, INVALID_OBJECT_ID => e
-        raise DataNotFound, "#{e} - #{uid}"
-      end
-
-      def destroy(uid)
-        ensure_authenticated!
-        grid.delete(bson_id(uid))
-      rescue Mongo::GridFileNotFound, INVALID_OBJECT_ID => e
-        raise DataNotFound, "#{e} - #{uid}"
-      end
-
-      def connection
-        @connection ||= if hosts
-          Mongo::ReplSetConnection.new(hosts, connection_opts)
-        else
-          Mongo::Connection.new(host, port, connection_opts)
-        end
-      end
-
-      def db
-        @db ||= connection.db(database)
-      end
-
-      def grid
-        @grid ||= Mongo::Grid.new(db)
-      end
-
-      private
-
-      def ensure_authenticated!
-        if username
-          @authenticated ||= db.authenticate(username, password)
-        end
-      end
-
-      def bson_id(uid)
-        OBJECT_ID.from_string(uid)
-      end
-
-    end
-  end
-end

data/lib/dragonfly/data_storage/s3data_store.rb

@@ -1,168 +0,0 @@
-require 'fog'
-
-module Dragonfly
-  module DataStorage
-
-    class S3DataStore
-
-      include Configurable
-      include Serializer
-
-      configurable_attr :bucket_name
-      configurable_attr :access_key_id
-      configurable_attr :secret_access_key
-      configurable_attr :region
-      configurable_attr :use_filesystem, true
-      configurable_attr :storage_headers, {'x-amz-acl' => 'public-read'}
-      configurable_attr :url_scheme, 'http'
-      configurable_attr :url_host
-
-      REGIONS = {
-        'us-east-1' => 's3.amazonaws.com',  #default
-        'us-west-1' => 's3-us-west-1.amazonaws.com',
-        'us-west-2' => 's3-us-west-2.amazonaws.com',
-        'ap-northeast-1' => 's3-ap-northeast-1.amazonaws.com',
-        'ap-southeast-1' => 's3-ap-southeast-1.amazonaws.com',
-        'eu-west-1' => 's3-eu-west-1.amazonaws.com',
-        'sa-east-1' => 's3-sa-east-1.amazonaws.com',
-        'sa-east-1' => 's3-sa-east-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]
-        self.region = opts[:region]
-      end
-
-      def store(temp_object, opts={})
-        ensure_configured
-        ensure_bucket_initialized
-        
-        headers = opts[:headers] || {}
-        mime_type = opts[:mime_type] || opts[:content_type]
-        headers['Content-Type'] = mime_type if mime_type
-        uid = opts[:path] || generate_uid(temp_object.name || 'file')
-        
-        rescuing_socket_errors do
-          if use_filesystem
-            temp_object.file do |f|
-              storage.put_object(bucket_name, uid, f, full_storage_headers(headers, temp_object.meta))
-            end
-          else
-            storage.put_object(bucket_name, uid, temp_object.data, full_storage_headers(headers, temp_object.meta))
-          end
-        end
-        
-        uid
-      end
-
-      def retrieve(uid)
-        ensure_configured
-        response = rescuing_socket_errors{ storage.get_object(bucket_name, uid) }
-        [
-          response.body,
-          parse_s3_metadata(response.headers)
-        ]
-      rescue Excon::Errors::NotFound => e
-        raise DataNotFound, "#{e} - #{uid}"
-      end
-
-      def destroy(uid)
-        rescuing_socket_errors{ storage.delete_object(bucket_name, uid) }
-      rescue Excon::Errors::NotFound => e
-        raise DataNotFound, "#{e} - #{uid}"
-      rescue Excon::Errors::Conflict => e
-        raise DestroyError, "#{e} - #{uid}"
-      end
-
-      def url_for(uid, opts={})
-        if opts && opts[:expires]
-          if storage.respond_to?(:get_object_https_url) # fog's get_object_url is deprecated (aug 2011)
-            storage.get_object_https_url(bucket_name, uid, opts[:expires])
-          else
-            storage.get_object_url(bucket_name, uid, opts[:expires])
-          end
-        else
-          scheme = opts[:scheme] || url_scheme
-          host   = opts[:host]   || url_host || "#{bucket_name}.s3.amazonaws.com"
-          "#{scheme}://#{host}/#{uid}"
-        end
-      end
-
-      def domain
-        REGIONS[get_region]
-      end
-
-      def storage
-        @storage ||= begin
-          storage = Fog::Storage.new(
-            :provider => 'AWS',
-            :aws_access_key_id => access_key_id,
-            :aws_secret_access_key => secret_access_key,
-            :region => region
-          )
-          storage.sync_clock
-          storage
-        end
-      end
-
-      def bucket_exists?
-        rescuing_socket_errors{ storage.get_bucket(bucket_name) }
-        true
-      rescue Excon::Errors::NotFound => e
-        false
-      end
-
-      private
-
-      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_bucket_initialized
-        unless @bucket_initialized
-          rescuing_socket_errors{ 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 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 valid_regions
-        REGIONS.keys
-      end
-
-      def rescuing_socket_errors(&block)
-        yield
-      rescue Excon::Errors::SocketError => e
-        storage.reload
-        yield
-      end
-
-    end
-
-  end
-end

data/lib/dragonfly/encoder.rb

@@ -1,13 +0,0 @@
-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

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

@@ -1,67 +0,0 @@
-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, 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
-      "<#{self.class.name} with functions: #{functions.keys.map{|k| k.to_s }.sort.join(', ')} >"
-    end
-
-    private
-
-    def methods_to_add(obj)
-      methods = obj.public_methods(false).map{|m| m.to_sym }
-      methods -= obj.config_methods if obj.is_a?(Configurable)
-      methods
-    end
-
-  end
-end

data/lib/dragonfly/generation/image_magick_generator.rb

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

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

data/lib/dragonfly/image_magick/analyser.rb

@@ -1,53 +0,0 @@
-module Dragonfly
-  module ImageMagick
-    class Analyser
-
-      include Configurable
-      include Utils
-
-      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
-      alias portrait portrait?
-
-      def landscape?(temp_object)
-        attrs = identify(temp_object)
-        attrs[:width] >= attrs[:height]
-      end
-      alias landscape landscape?
-
-      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

@@ -1,44 +0,0 @@
-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 :strip do
-            process :strip
-          end
-          c.job :convert do |args, format|
-            process :convert, args, format
-          end
-        end
-
-      end
-
-    end
-  end
-end