oahu-dragonfly 0.8.2

data/lib/dragonfly/active_model_extensions/instance_methods.rb

@@ -0,0 +1,28 @@
+module Dragonfly
+  module ActiveModelExtensions
+    module InstanceMethods
+      
+      def dragonfly_attachments
+        @dragonfly_attachments ||= self.class.dragonfly_attachment_classes.inject({}) do |hash, klass|
+          hash[klass.attribute] = klass.new(self)
+          hash
+        end
+      end
+
+      private
+      
+      def save_dragonfly_attachments
+        dragonfly_attachments.each do |attribute, attachment|
+          attachment.save!
+        end
+      end
+      
+      def destroy_dragonfly_attachments
+        dragonfly_attachments.each do |attribute, attachment|
+          attachment.destroy!
+        end
+      end
+      
+    end
+  end
+end

data/lib/dragonfly/active_model_extensions/validations.rb

@@ -0,0 +1,41 @@
+module Dragonfly
+  module ActiveModelExtensions
+    module Validations
+
+      private
+
+      def validates_property(property_name, opts)
+        attrs = opts[:of] or raise ArgumentError, "you need to provide the attribute which has the property, using :of => <attribute_name>"
+        attrs = [attrs].flatten #(make sure it's an array)
+
+        raise ArgumentError, "you must provide either :in => [<value1>, <value2>..] or :as => <value>" unless opts[:in] || opts[:as]
+        allowed_values = opts[:in] || [opts[:as]]
+
+        args = attrs + [opts]
+        validates_each(*args) do |model, attr, attachment|
+          if attachment
+            property = attachment.send(property_name)
+            unless allowed_values.include?(property)
+              message = opts[:message] ||
+                "#{property_name.to_s.humanize.downcase} is incorrect. "+
+                "It needs to be #{Validations.expected_values_string(allowed_values)}"+
+                (property ? ", but was '#{property}'" : "")
+              message = message.call(property, model) if message.respond_to?(:call)
+              model.errors.add(attr, message)
+            end
+          end
+        end
+
+      end
+
+      def self.expected_values_string(allowed_values)
+        if allowed_values.is_a?(Range)
+          "between #{allowed_values.first} and #{allowed_values.last}"
+        else
+          allowed_values.length > 1 ? "one of '#{allowed_values.join('\', \'')}'" : "'#{allowed_values.first.to_s}'"
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/analyser.rb

@@ -0,0 +1,58 @@
+module Dragonfly
+  class Analyser < FunctionManager
+    
+    configurable_attr :enable_cache, true
+    configurable_attr :cache_size, 100
+    
+    def initialize
+      super
+      analyser = self
+      @analysis_methods = Module.new do
+
+        define_method :analyser do
+          analyser
+        end
+        
+      end
+      @analysis_method_names = []
+    end
+    
+    attr_reader :analysis_methods, :analysis_method_names
+    
+    def analyse(temp_object, method, *args)
+      if enable_cache
+        key = [temp_object.object_id, method, *args]
+        cache[key] ||= call_last(method, temp_object, *args)
+      else
+        call_last(method, temp_object, *args)
+      end
+    rescue NotDefined, UnableToHandle => e
+      log.warn(e.message)
+      nil
+    end
+    
+    # Each time a function is registered with the analyser,
+    # add a method to the analysis_methods module.
+    # Expects the object that is extended to define 'analyse(method, *args)'
+    def add(name, *args, &block)
+      analysis_methods.module_eval %(
+        def #{name}(*args)
+          analyse(:#{name}, *args)
+        end
+      )
+      analysis_method_names << name.to_sym
+      super
+    end
+    
+    def clear_cache!
+      @cache = nil
+    end
+    
+    private
+    
+    def cache
+      @cache ||= SimpleCache.new(cache_size)
+    end
+    
+  end
+end

data/lib/dragonfly/analysis/file_command_analyser.rb

@@ -0,0 +1,32 @@
+module Dragonfly
+  module Analysis
+    
+    class FileCommandAnalyser
+      
+      include Configurable
+      
+      configurable_attr :file_command, "file"
+      configurable_attr :use_filesystem, false
+      configurable_attr :num_bytes_to_check, 255
+      
+      def mime_type(temp_object)
+        content_type = if use_filesystem
+          `#{file_command} -b --mime '#{temp_object.path}'`
+        else
+          IO.popen("#{file_command} -b --mime -", 'r+') do |io|
+            if num_bytes_to_check
+              io.write temp_object.data[0, num_bytes_to_check]
+            else
+              io.write temp_object.data 
+            end
+            io.close_write
+            io.read
+          end
+        end.split(';').first
+        content_type.strip if content_type
+      end
+      
+    end
+    
+  end
+end

data/lib/dragonfly/analysis/image_magick_analyser.rb

@@ -0,0 +1,6 @@
+module Dragonfly
+  module Analysis
+    puts "WARNING: Dragonfly::Analysis::ImageMagickAnalyser is DEPRECATED and will soon be removed. Please use Dragonfly::ImageMagick::Analyser instead."
+    ImageMagickAnalyser = ImageMagick::Analyser
+  end
+end

data/lib/dragonfly/app.rb

@@ -0,0 +1,172 @@
+require 'logger'
+require 'forwardable'
+require 'rack'
+
+module Dragonfly
+  class App
+
+    class << self
+
+      private :new # Hide 'new' - need to use 'instance'
+
+      def instance(name)
+        apps[name] ||= new
+      end
+
+      alias [] instance
+
+      private
+
+      def apps
+        @apps ||= {}
+      end
+
+    end
+
+    def initialize
+      @analyser, @processor, @encoder, @generator = Analyser.new, Processor.new, Encoder.new, Generator.new
+      [@analyser, @processor, @encoder, @generator].each do |obj|
+        obj.use_same_log_as(self)
+        obj.use_as_fallback_config(self)
+      end
+      @server = Server.new(self)
+      @job_definitions = JobDefinitions.new
+    end
+
+    include Configurable
+
+    extend Forwardable
+    def_delegator :datastore, :destroy
+    def_delegators :new_job, :fetch, :generate, :fetch_file, :fetch_url
+    def_delegators :server, :call
+
+    configurable_attr :datastore do DataStorage::FileDataStore.new end
+    configurable_attr :cache_duration, 3600*24*365 # (1 year)
+    configurable_attr :fallback_mime_type, 'application/octet-stream'
+    configurable_attr :secret, 'secret yo'
+    configurable_attr :log do Logger.new('/var/tmp/dragonfly.log') end
+    configurable_attr :trust_file_extensions, true
+    configurable_attr :content_disposition
+    configurable_attr :content_filename, Response::DEFAULT_FILENAME
+
+    attr_reader :analyser
+    attr_reader :processor
+    attr_reader :encoder
+    attr_reader :generator
+    attr_reader :server
+
+    nested_configurable :server, :analyser, :processor, :encoder, :generator
+
+    attr_accessor :job_definitions
+
+    def new_job(content=nil, meta={})
+      job_class.new(self, content, meta)
+    end
+    alias create new_job
+
+    def endpoint(job=nil, &block)
+      block ? RoutedEndpoint.new(self, &block) : JobEndpoint.new(job)
+    end
+
+    def job(name, &block)
+      job_definitions.add(name, &block)
+    end
+    configuration_method :job
+
+    def job_class
+      @job_class ||= begin
+        app = self
+        Class.new(Job).class_eval do
+          include app.analyser.analysis_methods
+          include app.job_definitions
+          include Job::OverrideInstanceMethods
+          self
+        end
+      end
+    end
+
+    def store(object, opts={})
+      temp_object = object.is_a?(TempObject) ? object : TempObject.new(object)
+      datastore.store(temp_object, opts)
+    end
+
+    def register_mime_type(format, mime_type)
+      registered_mime_types[file_ext_string(format)] = mime_type
+    end
+    configuration_method :register_mime_type
+
+    def registered_mime_types
+      @registered_mime_types ||= Rack::Mime::MIME_TYPES.dup
+    end
+
+    def mime_type_for(format)
+      registered_mime_types[file_ext_string(format)]
+    end
+
+    def define_url(&block)
+      @url_proc = block
+    end
+    configuration_method :define_url
+
+    def url_for(job, opts={})
+      if @url_proc
+        @url_proc.call(self, job, opts)
+      else
+        server.url_for(job, opts)
+      end
+    end
+
+    def remote_url_for(uid, opts={})
+      datastore.url_for(uid, opts)
+    rescue NoMethodError => e
+      raise NotImplementedError, "The datastore doesn't support serving content directly - #{datastore.inspect}"
+    end
+
+    def define_macro(mod, macro_name)
+      already_extended = (class << mod; self; end).included_modules.include?(ActiveModelExtensions)
+      mod.extend(ActiveModelExtensions) unless already_extended
+      mod.register_dragonfly_app(macro_name, self)
+    end
+
+    def define_macro_on_include(mod, macro_name)
+      app = self
+      (class << mod; self; end).class_eval do
+        alias included_without_dragonfly included
+        define_method :included_with_dragonfly do |mod|
+          included_without_dragonfly(mod)
+          app.define_macro(mod, macro_name)
+        end
+        alias included included_with_dragonfly
+      end
+    end
+    
+    # Deprecated methods
+    def url_path_prefix=(thing)
+      raise NoMethodError, "url_path_prefix is deprecated - please use url_format, e.g. url_format = '/media/:job/:basename.:format' - see docs for more details"
+    end
+    configuration_method :url_path_prefix=
+
+    def url_suffix=(thing)
+      raise NoMethodError, "url_suffix is deprecated - please use url_format, e.g. url_format = '/media/:job/:basename.:format' - see docs for more details"
+    end
+    configuration_method :url_suffix=
+
+    def infer_mime_type_from_file_ext=(bool)
+      raise NoMethodError, "infer_mime_type_from_file_ext is deprecated - please use trust_file_extensions = #{bool.inspect} instead"
+    end
+    configuration_method :infer_mime_type_from_file_ext=
+
+    private
+
+    attr_accessor :get_remote_url
+
+    def saved_configs
+      self.class.saved_configs
+    end
+
+    def file_ext_string(format)
+      '.' + format.to_s.downcase.sub(/^.*\./,'')
+    end
+
+  end
+end

data/lib/dragonfly/config/heroku.rb

@@ -0,0 +1,19 @@
+module Dragonfly
+  module Config
+
+    module Heroku
+
+      def self.apply_configuration(app, bucket_name)
+        app.configure do |c|
+          c.datastore = DataStorage::S3DataStore.new
+          c.datastore.configure do |d|
+            d.bucket_name = bucket_name
+            d.access_key_id = ENV['S3_KEY'] || raise("ENV variable 'S3_KEY' needs to be set - use\n\theroku config:add S3_KEY=XXXXXXXXX")
+            d.secret_access_key = ENV['S3_SECRET'] || raise("ENV variable 'S3_SECRET' needs to be set - use\n\theroku config:add S3_SECRET=XXXXXXXXX")
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/config/image_magick.rb

@@ -0,0 +1,6 @@
+module Dragonfly
+  module Config
+    puts "WARNING: Dragonfly::Config::ImageMagick is DEPRECATED and will soon be removed. Please use Dragonfly::ImageMagick::Config instead."
+    ImageMagick = Dragonfly::ImageMagick::Config
+  end
+end

data/lib/dragonfly/config/rails.rb

@@ -0,0 +1,20 @@
+module Dragonfly
+  module Config
+
+    module Rails
+
+      def self.apply_configuration(app)
+        app.configure do |c|
+          c.log = ::Rails.logger
+          if c.datastore.is_a?(DataStorage::FileDataStore)
+            c.datastore.root_path = ::Rails.root.join('public/system/dragonfly', ::Rails.env).to_s
+            c.datastore.server_root = ::Rails.root.join('public').to_s
+          end
+          c.url_format = '/media/:job/:basename.:format'
+          c.analyser.register(Analysis::FileCommandAnalyser)
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/configurable.rb

@@ -0,0 +1,207 @@
+module Dragonfly
+  module Configurable
+
+    # Exceptions
+    class NotConfigured < RuntimeError; end
+    class BadConfigAttribute < RuntimeError; end
+
+    def self.included(klass)
+      klass.class_eval do
+        include Configurable::InstanceMethods
+        extend Configurable::ClassMethods
+
+        # We should use configured_class rather than self.class
+        # because sometimes this will be the eigenclass of an object
+        # e.g. if we configure a module, etc.
+        define_method :configured_class do
+          klass
+        end
+      end
+    end
+
+    class DeferredBlock # Inheriting from Proc causes errors in some versions of Ruby
+      def initialize(blk)
+        @blk = blk
+      end
+
+      def call
+        @blk.call
+      end
+    end
+
+    module InstanceMethods
+
+      def configure(&block)
+        yield ConfigurationProxy.new(self)
+        self
+      end
+
+      def configure_with(config, *args, &block)
+        config = saved_config_for(config) if config.is_a?(Symbol)
+        config.apply_configuration(self, *args)
+        configure(&block) if block
+        self
+      end
+
+      def has_config_method?(method_name)
+        config_methods.include?(method_name.to_sym)
+      end
+            
+      def config_methods
+        @config_methods ||= configured_class.config_methods.dup
+      end
+      
+      def configuration
+        @configuration ||= {}
+      end
+      
+      def default_configuration
+        # Merge the default configuration of all ancestor classes/modules which are configurable
+        @default_configuration ||= [self.class, configured_class, *configured_class.ancestors].reverse.inject({}) do |default_config, klass|
+          default_config.merge!(klass.default_configuration) if klass.respond_to? :default_configuration
+          default_config
+        end
+      end
+
+      def set_config_value(key, value)
+        configuration[key] = value
+        child_configurables.each{|c| c.set_if_unset(key, value) }
+        value
+      end
+      
+      def use_as_fallback_config(other_configurable)
+        other_configurable.add_child_configurable(self)
+        self.fallback_configurable = other_configurable
+      end
+
+      protected
+
+      def add_child_configurable(obj)
+        child_configurables << obj
+        config_methods.push(*obj.config_methods)
+        fallback_configurable.config_methods.push(*obj.config_methods) if fallback_configurable
+      end
+
+      def set_if_unset(key, value)
+        set_config_value(key, value) unless set_locally?(key)
+      end
+
+      private
+      
+      attr_accessor :fallback_configurable
+      
+      def child_configurables
+        @child_configurables ||= []
+      end
+      
+      def set_locally?(key)
+        instance_variable_defined?("@#{key}")
+      end
+      
+      def default_value(key)
+        if default_configuration[key].is_a?(DeferredBlock)
+          default_configuration[key] = default_configuration[key].call
+        end
+        default_configuration[key]
+      end
+
+      def saved_configs
+        configured_class.saved_configs
+      end
+
+      def saved_config_for(symbol)
+        config = saved_configs[symbol]
+        if config.nil?
+          raise ArgumentError, "#{symbol.inspect} is not a known configuration - try one of #{saved_configs.keys.join(', ')}"
+        end
+        config = config.call if config.respond_to?(:call)
+        config
+      end
+
+    end
+
+    module ClassMethods
+
+      def default_configuration
+        @default_configuration ||= {}
+      end
+
+      def config_methods
+        @config_methods ||= []
+      end
+
+      def nested_configurables
+        @nested_configurables ||= []
+      end
+
+      def register_configuration(name, config=nil, &config_in_block) 
+        saved_configs[name] = config_in_block || config
+      end
+
+      def saved_configs
+        @saved_configs ||= {}
+      end
+
+      private
+
+      def configurable_attr attribute, default=nil, &blk
+        default_configuration[attribute] = blk ? DeferredBlock.new(blk) : default
+
+        # Define the reader
+        define_method(attribute) do
+          configuration.has_key?(attribute) ? configuration[attribute] : default_value(attribute)
+        end
+
+        # Define the writer
+        define_method("#{attribute}=") do |value|
+          instance_variable_set("@#{attribute}", value)
+          set_config_value(attribute, value)
+        end
+
+        configuration_method attribute
+        configuration_method "#{attribute}="
+      end
+
+      def configuration_method(*method_names)
+        config_methods.push(*method_names.map{|n| n.to_sym }).uniq!
+      end
+      
+      def nested_configurable(*method_names)
+        nested_configurables.push(*method_names)
+      end
+
+    end
+
+    class ConfigurationProxy
+
+      def initialize(owner)
+        @owner = owner
+      end
+
+      def method_missing(method_name, *args, &block)
+        if owner.has_config_method?(method_name)
+          attribute = method_name.to_s.tr('=','').to_sym
+          if method_name.to_s =~ /=$/ && owner.has_config_method?(attribute) # a bit hacky - if it has both getter and setter, assume it's a configurable_attr
+            owner.set_config_value(attribute, args.first)
+          else
+            owner.send(method_name, *args, &block)
+          end
+        elsif nested_configurable?(method_name)
+          owner.send(method_name)
+        else
+          raise BadConfigAttribute, "You tried to configure using '#{method_name.inspect}',  but the valid config attributes are #{owner.config_methods.map{|a| %('#{a.inspect}') }.sort.join(', ')}"
+        end
+      end
+
+      private
+
+      attr_reader :owner
+
+      def nested_configurable?(method)
+        owner.configured_class.nested_configurables.include?(method.to_sym)
+      end
+
+    end
+
+  end
+end