dragonfly 0.8.6 → 0.9.0

data/lib/dragonfly/image_magick_utils.rb

@@ -1,81 +1,4 @@
-require 'tempfile'
-
 module Dragonfly
-  module ImageMagickUtils
-
-    # Exceptions
-    class ShellCommandFailed < RuntimeError; end
-
-    class << self
-      include Configurable
-      configurable_attr :convert_command, "convert"
-      configurable_attr :identify_command, "identify"
-      configurable_attr :log_commands, false
-    end
-    
-    include Loggable
-    
-    private
-
-    def convert(temp_object, args='', format=nil)
-      tempfile = new_tempfile(format)
-      run "#{convert_command} #{args} #{temp_object.path} #{tempfile.path}"
-      tempfile
-    end
-
-    def identify(temp_object)
-      # example of details string:
-      # myimage.png PNG 200x100 200x100+0+0 8-bit DirectClass 31.2kb
-      details = raw_identify(temp_object)
-      filename, format, geometry, geometry_2, depth, image_class, size = details.split(' ')
-      width, height = geometry.split('x')
-      {
-        :filename => filename,
-        :format => format.downcase.to_sym,
-        :width => width.to_i,
-        :height => height.to_i,
-        :depth => depth.to_i,
-        :image_class => image_class
-      }
-    end
-    
-    def raw_identify(temp_object, args='')
-      run "#{identify_command} #{args} #{temp_object.path}"
-    end
-    
-    def new_tempfile(ext=nil)
-      tempfile = ext ? Tempfile.new(['dragonfly', ".#{ext}"]) : Tempfile.new('dragonfly')
-      tempfile.binmode
-      tempfile.close
-      tempfile
-    end
-    
-    def convert_command
-      ImageMagickUtils.convert_command
-    end
-
-    def identify_command
-      ImageMagickUtils.identify_command
-    end
-
-    def run(command)
-      log.debug("Running command: #{command}") if ImageMagickUtils.log_commands
-      begin
-        result = `#{command}`
-      rescue Errno::ENOENT
-        raise_shell_command_failed(command)
-      end
-      if $?.exitstatus == 1
-        throw :unable_to_handle
-      elsif !$?.success?
-        raise_shell_command_failed(command)
-      end
-      result
-    end
-    
-    def raise_shell_command_failed(command)
-      raise ShellCommandFailed, "Command failed (#{command}) with exit status #{$?.exitstatus}"
-    end
-
-  end
+  puts "WARNING: Dragonfly::ImageMagickUtils is DEPRECATED and will soon be removed. Please use Dragonfly::ImageMagick::Utils instead."
+  ImageMagickUtils = ImageMagick::Utils
 end

data/lib/dragonfly/job.rb

@@ -1,6 +1,8 @@
 require 'forwardable'
 require 'digest/sha1'
 require 'base64'
+require 'open-uri'
+require 'pathname'
 
 module Dragonfly
   class Job
@@ -16,7 +18,9 @@ module Dragonfly
     class IncorrectSHA < StandardError; end
 
     extend Forwardable
-    def_delegators :result, :data, :file, :tempfile, :path, :to_file, :size, :ext, :name, :name=, :basename, :meta, :meta=, :format, :_format
+    def_delegators :result,
+                   :data, :file, :tempfile, :path, :to_file, :size
+    def_delegator :app, :server
 
     class Step
 
@@ -35,30 +39,29 @@ module Dragonfly
         end
       end
 
-      def initialize(*args)
-        @args = args
+      def initialize(job, *args)
+        @job, @args = job, args
+        init
       end
 
-      attr_reader :args
-
-      def update_temp_object(job, content, extra)
-        temp_object = TempObject.new(content, job.temp_object.attributes)
-        temp_object.extract_attributes_from(extra) if extra
-        job.temp_object = temp_object
+      def init # To be overridden
       end
 
+      attr_reader :job, :args
+
       def inspect
         "#{self.class.step_name}(#{args.map{|a| a.inspect }.join(', ')})"
       end
+
     end
 
     class Fetch < Step
       def uid
         args.first
       end
-      def apply(job)
-        content, extra = job.app.datastore.retrieve(uid)
-        job.temp_object = TempObject.new(content, extra)
+      def apply
+        content, meta = job.app.datastore.retrieve(uid)
+        job.update(content, meta)
       end
     end
 
@@ -69,41 +72,64 @@ module Dragonfly
       def arguments
         args[1..-1]
       end
-      def apply(job)
+      def apply
         raise NothingToProcess, "Can't process because temp object has not been initialized. Need to fetch first?" unless job.temp_object
-        content, extra = job.app.processor.process(job.temp_object, name, *arguments)
-        update_temp_object(job, content, extra)
+        content, meta = job.app.processor.process(job.temp_object, name, *arguments)
+        job.update(content, meta)
       end
     end
 
     class Encode < Step
+      def init
+        job.meta[:format] = format
+      end
       def format
         args.first
       end
       def arguments
         args[1..-1]
       end
-      def apply(job)
+      def apply
         raise NothingToEncode, "Can't encode because temp object has not been initialized. Need to fetch first?" unless job.temp_object
-        content, extra = job.app.encoder.encode(job.temp_object, format, *arguments)
-        update_temp_object(job, content, extra)
-        job.temp_object.format = format
+        content, meta = job.app.encoder.encode(job.temp_object, format, *arguments)
+        job.update(content, meta)
+        job.meta[:format] = format
       end
     end
 
     class Generate < Step
-      def apply(job)
-        content, extra = job.app.generator.generate(*args)
-        job.temp_object = TempObject.new(content, extra)
+      def apply
+        content, meta = job.app.generator.generate(*args)
+        job.update(content, meta)
       end
     end
 
     class FetchFile < Step
+      def init
+        job.name = File.basename(path)
+      end
       def path
         File.expand_path(args.first)
       end
-      def apply(job)
-        job.temp_object = TempObject.new(File.new(path))
+      def apply
+        job.temp_object = TempObject.new(Pathname.new(path))
+      end
+    end
+
+    class FetchUrl < Step
+      def init
+        job.name = File.basename(path) if path[/[^\/]$/]
+      end
+      def url
+        @url ||= (args.first[%r<^\w+://>] ? args.first : "http://#{args.first}")
+      end
+      def path
+        @path ||= URI.parse(url).path
+      end
+      def apply
+        open(url) do |f|
+          job.temp_object = TempObject.new(f.read)
+        end
       end
     end
 
@@ -112,7 +138,8 @@ module Dragonfly
       Process,
       Encode,
       Generate,
-      FetchFile
+      FetchFile,
+      FetchUrl
     ]
 
     # Class methods
@@ -126,18 +153,11 @@ module Dragonfly
         job = app.new_job
         steps_array.each do |step_array|
           step_class = step_abbreviations[step_array.shift]
-          job.steps << step_class.new(*step_array)
+          job.steps << step_class.new(job, *step_array)
         end
         job
       end
 
-      def from_path(path, app)
-        path = path.dup
-        path.sub!(app.url_path_prefix, '') if app.url_path_prefix
-        path.sub!('/', '')
-        deserialize(path, app)
-      end
-
       def deserialize(string, app)
         from_a(Serializer.marshal_decode(string), app)
       end
@@ -152,22 +172,43 @@ module Dragonfly
 
     end
 
-    # Instance methods
+    ####### Instance methods #######
 
-    def initialize(app, temp_object=nil)
+    # This is needed because we need a way of overriding
+    # the methods added to Job objects by the analyser and by
+    # the job shortcuts like 'thumb', etc.
+    # If we had traits/classboxes in ruby maybe this wouldn't be needed
+    # Think of it as like a normal instance method but with a css-like !important after it
+    module OverrideInstanceMethods
+      
+      def format
+        apply
+        format_from_meta || analyse(:format)
+      end
+      
+      def mime_type
+        app.mime_type_for(format) || analyse(:mime_type) || app.fallback_mime_type
+      end
+      
+      def to_s
+        super.sub(/#<Class:\w+>/, 'Extended Dragonfly::Job')
+      end
+      
+    end
+
+    def initialize(app, content=nil, meta={})
       @app = app
-      self.extend app.analyser.analysis_methods
-      self.extend app.job_definitions
       @steps = []
       @next_step_index = 0
-      @temp_object = temp_object
+      @meta = {}
+      update(content, meta)
     end
 
     # Used by 'dup' and 'clone'
     def initialize_copy(other)
-      self.steps = other.steps.dup
-      self.extend app.analyser.analysis_methods
-      self.extend app.job_definitions
+      self.steps = other.steps.map do |step|
+        step.class.new(self, *step.args)
+      end
     end
 
     attr_accessor :temp_object
@@ -178,12 +219,12 @@ module Dragonfly
       class_eval %(
         def #{step_class.step_name}(*args)
           new_job = self.dup
-          new_job.steps << #{step_class}.new(*args)
+          new_job.steps << #{step_class}.new(new_job, *args)
           new_job
         end
 
         def #{step_class.step_name}!(*args)
-          steps << #{step_class}.new(*args)
+          steps << #{step_class}.new(self, *args)
           self
         end
       )
@@ -193,35 +234,21 @@ module Dragonfly
       unless result
         raise NothingToAnalyse, "Can't analyse because temp object has not been initialized. Need to fetch first?"
       end
-      # Hacky - wish there was a nicer way to do this without extending with yet another module
-      if method == :format
-        _format || analyser.analyse(result, method, *args)
-      else
-        analyser.analyse(result, method, *args)
-      end
-    end
-
-    def +(other_job)
-      unless app == other_job.app
-        raise AppDoesNotMatch, "Cannot add jobs belonging to different apps (#{app} is not #{other_job.app})"
-      end
-      unless other_job.applied_steps.empty?
-        raise JobAlreadyApplied, "Cannot add jobs when the second one has already been applied (#{other_job})"
-      end
-      new_job = self.class.new(app, temp_object)
-      new_job.steps = steps + other_job.steps
-      new_job.next_step_index = next_step_index
-      new_job
+      analyser.analyse(result, method, *args)
     end
 
     # Applying, etc.
 
     def apply
-      pending_steps.each{|step| step.apply(self) }
+      pending_steps.each{|step| step.apply }
       self.next_step_index = steps.length
       self
     end
 
+    def applied?
+      next_step_index == steps.length
+    end
+
     def result
       apply
       temp_object
@@ -273,11 +300,11 @@ module Dragonfly
     # URLs, etc.
 
     def url(opts={})
-      app.url_for(self, opts) unless steps.empty?
+      app.url_for(self, attributes_for_url.merge(opts)) unless steps.empty?
     end
 
     def b64_data
-      "data:#{resolve_mime_type};base64,#{Base64.encode64(data)}"
+      "data:#{mime_type};base64,#{Base64.encode64(data)}"
     end
 
     # to_stuff...
@@ -286,7 +313,7 @@ module Dragonfly
       JobEndpoint.new(self)
     end
 
-    def to_response(env={})
+    def to_response(env={"REQUEST_METHOD" => "GET"})
       to_app.call(env)
     end
 
@@ -295,7 +322,7 @@ module Dragonfly
     end
 
     def to_fetched_job(uid)
-      new_job = self.class.new(app, temp_object)
+      new_job = self.class.new(app, temp_object, meta)
       new_job.fetch!(uid)
       new_job.next_step_index = 1
       new_job
@@ -303,21 +330,13 @@ module Dragonfly
 
     # Step inspection
 
-    def fetch_step
-      last_step_of_type(Fetch)
-    end
-
     def uid
       step = fetch_step
       step.uid if step
     end
 
-    def uid_basename
-      File.basename(uid, '.*') if uid
-    end
-
-    def uid_extname
-      File.extname(uid) if uid
+    def fetch_step
+      last_step_of_type(Fetch)
     end
 
     def generate_step
@@ -328,6 +347,10 @@ module Dragonfly
       last_step_of_type(FetchFile)
     end
 
+    def fetch_url_step
+      last_step_of_type(FetchUrl)
+    end
+
     def process_steps
       steps.select{|s| s.is_a?(Process) }
     end
@@ -336,30 +359,65 @@ module Dragonfly
       last_step_of_type(Encode)
     end
 
-    def encoded_format
-      step = encode_step
-      step.format if step
-    end
-
-    def encoded_extname
-      format = encoded_format
-      ".#{format}" if format
+    def step_types
+      steps.map{|s| s.class.step_name }
     end
 
     # Misc
 
     def store(opts={})
-      app.store(result, opts)
-    end
-
-    def resolve_mime_type
-      app.resolve_mime_type(result)
+      app.store(result, opts.merge(:meta => meta))
     end
 
     def inspect
       to_s.sub(/>$/, " app=#{app}, steps=#{steps.inspect}, temp_object=#{temp_object.inspect}, steps applied:#{applied_steps.length}/#{steps.length} >")
     end
 
+    # Name and stuff
+        
+    attr_reader :meta
+
+    def meta=(hash)
+      raise ArgumentError, "meta must be a hash, you tried setting it as #{hash.inspect}" unless hash.is_a?(Hash)
+      @meta = hash
+    end
+
+    def name
+      meta[:name]
+    end
+
+    def name=(name)
+      meta[:name] = name
+    end
+    
+    def basename
+      meta[:basename] || (File.basename(name, '.*') if name)
+    end
+
+    def ext
+      meta[:ext] || (File.extname(name)[/\.(.*)/, 1] if name)
+    end
+    
+    def attributes_for_url
+      attrs = meta.reject{|k, v| !server.params_in_url.include?(k.to_s) }
+      attrs[:basename] ||= basename if server.params_in_url.include?('basename')
+      attrs[:ext] ||= ext if server.params_in_url.include?('ext')
+      attrs[:format] = (attrs[:format] || format_from_meta).to_s if server.params_in_url.include?('format')
+      attrs.delete_if{|k, v| v.blank? }
+      attrs
+    end
+    
+    def update(content, meta)
+      if meta
+        meta.merge!(meta.delete(:meta)) if meta[:meta] # legacy data etc. may have nested meta hash - deprecate gracefully here
+        self.meta.merge!(meta)
+      end
+      if content
+        self.temp_object = TempObject.new(content)
+        self.name = temp_object.original_filename if name.nil? && temp_object.original_filename
+      end
+    end
+    
     protected
 
     attr_writer :steps
@@ -367,6 +425,10 @@ module Dragonfly
 
     private
 
+    def format_from_meta
+      meta[:format] || (ext.to_sym if ext && app.trust_file_extensions)
+    end
+
     def last_step_of_type(type)
       steps.select{|s| s.is_a?(type) }.last
     end