fog-dragonfly 0.8.1

data/lib/dragonfly/active_model_extensions/class_methods.rb

@@ -0,0 +1,45 @@
+module Dragonfly
+  module ActiveModelExtensions
+    module ClassMethods
+
+      include Validations
+
+      def register_dragonfly_app(macro_name, app)
+        (class << self; self; end).class_eval do
+    
+          # Defines e.g. 'image_accessor' for any activerecord class body
+          define_method macro_name do |attribute|
+
+            # Prior to activerecord 3, adding before callbacks more than once does add it more than once
+            before_save :save_attachments unless respond_to?(:before_save_callback_chain) && before_save_callback_chain.find(:save_attachments)
+            before_destroy :destroy_attachments unless respond_to?(:before_destroy_callback_chain) && before_destroy_callback_chain.find(:destroy_attachments)
+      
+            # Register the new attribute
+            dragonfly_apps_for_attributes[attribute] = app
+            
+            # Define the setter for the attribute
+            define_method "#{attribute}=" do |value|
+              attachments[attribute].assign(value)
+            end
+      
+            # Define the getter for the attribute
+            define_method attribute do
+              attachments[attribute].to_value
+            end
+      
+          end
+    
+        end
+        app
+      end
+      
+      def dragonfly_apps_for_attributes
+        @dragonfly_apps_for_attributes ||= begin
+          parent_class = ancestors.select{|a| a.is_a?(Class) }[1]
+          parent_class.respond_to?(:dragonfly_apps_for_attributes) ? parent_class.dragonfly_apps_for_attributes.dup : {}
+        end
+      end
+      
+    end
+  end
+end

data/lib/dragonfly/active_model_extensions/instance_methods.rb

@@ -0,0 +1,28 @@
+module Dragonfly
+  module ActiveModelExtensions
+    module InstanceMethods
+      
+      def attachments
+        @attachments ||= self.class.dragonfly_apps_for_attributes.inject({}) do |hash, (attribute, app)|
+          hash[attribute] = Attachment.new(app, self, attribute)
+          hash
+        end
+      end
+
+      private
+      
+      def save_attachments
+        attachments.each do |attribute, attachment|
+          attachment.save!
+        end
+      end
+      
+      def destroy_attachments
+        attachments.each do |attribute, attachment|
+          attachment.destroy!
+        end
+      end
+      
+    end
+  end
+end

data/lib/dragonfly/active_model_extensions/validations.rb

@@ -0,0 +1,37 @@
+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 |record, attr, attachment|
+          if attachment
+            property = attachment.send(property_name)
+            record.errors.add(attr,
+                              opts[:message] ||
+                                "#{property_name.to_s.humanize.downcase} is incorrect. It needs to be #{expected_values_string(allowed_values)}, but was '#{property}'"
+                              ) unless allowed_values.include?(property)
+          end
+        end
+
+      end
+
+      def 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,59 @@
+module Dragonfly
+  class Analyser < FunctionManager
+    
+    include Configurable
+    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,47 @@
+module Dragonfly
+  module Analysis
+    class ImageMagickAnalyser
+
+      include ImageMagickUtils
+      include Configurable
+
+      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
+
+      def landscape?(temp_object)
+        attrs = identify(temp_object)
+        attrs[:width] >= attrs[:height]
+      end
+
+      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
+
+    end
+  end
+end

data/lib/dragonfly/analysis/r_magick_analyser.rb

@@ -0,0 +1,63 @@
+require 'RMagick'
+
+module Dragonfly
+  module Analysis
+    class RMagickAnalyser
+
+      include RMagickUtils
+      include Configurable
+
+      configurable_attr :use_filesystem, true
+
+      def width(temp_object)
+        ping_rmagick_image(temp_object) do |image|
+          image.columns
+        end
+      end
+
+      def height(temp_object)
+        ping_rmagick_image(temp_object) do |image|
+          image.rows
+        end
+      end
+
+      def aspect_ratio(temp_object)
+        ping_rmagick_image(temp_object) do |image|
+          image.columns.to_f / image.rows
+        end
+      end
+
+      def portrait?(temp_object)
+        ping_rmagick_image(temp_object) do |image|
+          image.columns <= image.rows
+        end
+      end
+
+      def landscape?(temp_object)
+        ping_rmagick_image(temp_object) do |image|
+          image.columns >= image.rows
+        end
+      end
+
+      def depth(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.depth
+        end
+      end
+
+      def number_of_colours(temp_object)
+        rmagick_image(temp_object) do |image|
+          image.number_colors
+        end
+      end
+      alias number_of_colors number_of_colours
+
+      def format(temp_object)
+        ping_rmagick_image(temp_object) do |image|
+          image.format.downcase.to_sym
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/app.rb

@@ -0,0 +1,182 @@
+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.use_same_log_as(self)
+      @processor.use_same_log_as(self)
+      @encoder.use_same_log_as(self)
+      @generator.use_same_log_as(self)
+      @job_definitions = JobDefinitions.new
+      @server = Dragonfly::SimpleEndpoint.new(self)
+    end
+
+    include Configurable
+
+    extend Forwardable
+    def_delegator :datastore, :destroy
+    def_delegators :new_job, :fetch, :generate, :fetch_file
+    def_delegator :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 :url_path_prefix
+    configurable_attr :url_host
+    configurable_attr :url_suffix
+    configurable_attr :protect_from_dos_attacks, false
+    configurable_attr :secret, 'secret yo'
+    configurable_attr :log do Logger.new('/var/tmp/dragonfly.log') end
+    configurable_attr :infer_mime_type_from_file_ext, 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
+
+    configuration_method :analyser
+    configuration_method :processor
+    configuration_method :encoder
+    configuration_method :generator
+
+    attr_accessor :job_definitions
+
+    SAVED_CONFIGS = {
+      :imagemagick => 'ImageMagick',
+      :image_magick => 'ImageMagick',
+      :rmagick => 'RMagick',
+      :r_magick => 'RMagick',
+      :rails => 'Rails',
+      :heroku => 'Heroku'
+    }
+
+    def configurer_for(symbol)
+      class_name = SAVED_CONFIGS[symbol]
+      if class_name.nil?
+        raise ArgumentError, "#{symbol.inspect} is not a known configuration - try one of #{SAVED_CONFIGS.keys.join(', ')}"
+      end
+      Config.const_get(class_name)
+    end
+
+    def new_job(content=nil, opts={})
+      content ? Job.new(self, TempObject.new(content, opts)) : Job.new(self)
+    end
+
+    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 store(object, opts={})
+      temp_object = object.is_a?(TempObject) ? object : TempObject.new(object)
+      temp_object.extract_attributes_from(opts)
+      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 resolve_mime_type(temp_object)
+      mime_type_for(temp_object.format)                                   ||
+        (mime_type_for(temp_object.ext) if infer_mime_type_from_file_ext) ||
+        analyser.analyse(temp_object, :mime_type)                         ||
+        mime_type_for(analyser.analyse(temp_object, :format))             ||
+        fallback_mime_type
+    end
+
+    def mount_path
+      url_path_prefix.blank? ? '/' : url_path_prefix
+    end
+
+    def url_for(job, *args)
+      if (args.length == 1 && args.first.kind_of?(Hash)) || args.empty?
+        opts = args.first ? args.first.dup : {}
+        host = opts.delete(:host) || url_host
+        suffix = opts.delete(:suffix) || url_suffix
+        suffix = suffix.call(job) if suffix.respond_to?(:call)
+        path_prefix = opts.delete(:path_prefix) || url_path_prefix
+        path = "#{host}#{path_prefix}#{job.to_path}#{suffix}"
+        query = opts
+        query.merge!(server.required_params_for(job)) if protect_from_dos_attacks
+        path << "?#{Rack::Utils.build_query(query)}" if query.any?
+        path
+      else
+        # Deprecation stuff - will be removed!!!
+        case args[0]
+        when /^(\d+)?x(\d+)?/
+          log.warn("DEPRECATED USE OF url_for and will be removed in the future - please use thumb(#{args.map{|a|a.inspect}.join(', ')}).url")
+          args[1] ? job.thumb(args[0], args[1]).url : job.thumb(args[0]).url
+        when :gif, :png, :jpg, :jpeg
+          log.warn("DEPRECATED USE OF url_for and will be removed in the future - please use encode(#{args.first.inspect}).url")
+          job.encode(args[0]).url
+        else
+          raise "DEPRECATED USE OF url_for - will be removed in future versions - please consult the docs"
+        end
+      end
+    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
+
+    private
+
+    def file_ext_string(format)
+      '.' + format.to_s.downcase.sub(/^.*\./,'')
+    end
+
+  end
+end