dragonfly 0.6.2 → 0.7.0

data/lib/dragonfly/encoder.rb

@@ -0,0 +1,13 @@
+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/r_magick_encoder.rb

@@ -2,10 +2,10 @@ require 'RMagick'
 
 module Dragonfly
   module Encoding
-
-    class RMagickEncoder < Base
+    class RMagickEncoder
 
       include Configurable
+      include RMagickUtils
 
       configurable_attr :supported_formats, [
         :ai,
@@ -42,28 +42,19 @@ module Dragonfly
         :xwd
       ]
 
-      def encode(image, format, encoding={})
+      def encode(temp_object, format, encoding={})
         format = format.to_s.downcase
         throw :unable_to_handle unless supported_formats.include?(format.to_sym)
-        encoded_image = rmagick_image(image)
-        if encoded_image.format.downcase == format
-          image # do nothing
-        else
-          encoded_image.format = format
-          encoded_image.to_blob
+        rmagick_image(temp_object) do |image|
+          if image.format.downcase == format
+            temp_object # do nothing
+          else
+            image.format = format
+            image
+          end
         end
       end
 
-      private
-
-      def rmagick_image(temp_object)
-        Magick::Image.from_blob(temp_object.data).first
-      rescue Magick::ImageMagickError => e
-        log.warn("Unable to handle content in #{self.class} - got:\n#{e}")
-        throw :unable_to_handle
-      end
-
     end
-
   end
 end

data/lib/dragonfly/endpoint.rb

@@ -0,0 +1,43 @@
+module Dragonfly
+  module Endpoint
+
+    class EmptyJob < StandardError; end
+
+    private
+
+    def response_for_job(job, env)
+      if etag_matches?(job, env)
+        [304, cache_headers(job), []]
+      else
+        [200, success_headers(job), job.result] # Successful response
+      end
+    rescue DataStorage::DataNotFound => e
+      [404, {"Content-Type" => 'text/plain'}, [e.message]]
+    end
+
+    def cache_headers(job)
+      {
+        "Cache-Control" => "public, max-age=#{job.app.cache_duration}",
+        "ETag" => %("#{job.unique_signature}")
+      }
+    end
+
+    def etag_matches?(job, env)
+      if_none_match = env['HTTP_IF_NONE_MATCH']
+      if if_none_match
+        if_none_match.tr!('"','')
+        if_none_match.split(',').include?(job.unique_signature) || if_none_match == '*'
+      else
+        false
+      end
+    end
+
+    def success_headers(job)
+      {
+        "Content-Type" => job.app.resolve_mime_type(job.result),
+        "Content-Length" => job.size.to_s,
+      }.merge(cache_headers(job))
+    end
+
+  end
+end

data/lib/dragonfly/function_manager.rb

@@ -0,0 +1,65 @@
+module Dragonfly
+  class FunctionManager
+    
+    # Exceptions
+    class NotDefined < NoMethodError; end
+    class UnableToHandle < NotImplementedError; end
+    
+    include Loggable
+    
+    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)
+      methods_to_add(obj).each do |meth|
+        add meth.to_sym, 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 inspect
+      to_s.sub(/>$/, " with functions: #{functions.keys.map{|k| k.to_s }.sort.join(', ')} >")
+    end
+
+    private
+    
+    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]
+      else
+        obj.public_methods(false)
+      end
+    end
+
+  end
+end

data/lib/dragonfly/{processing/r_magick_text_processor.rb → generation/r_magick_generator.rb}

@@ -1,9 +1,8 @@
 require 'RMagick'
 
 module Dragonfly
-  module Processing
-
-    class RMagickTextProcessor < Base
+  module Generation
+    class RMagickGenerator
       
       FONT_STYLES = {
         'normal' => Magick::NormalStyle,
@@ -56,8 +55,19 @@ module Dragonfly
           )
         end
       end
-            
-      def text(temp_object, opts={})
+      
+      def plasma(width, height, format='png')
+        image = Magick::Image.read("plasma:fractal"){self.size = "#{width}x#{height}"}.first
+        image.format = format.to_s
+        data = image.to_blob
+        image.destroy!
+        [
+          data,
+          {:format => format.to_sym, :name => "plasma.#{format}"}
+        ]
+      end
+      
+      def text(text_string, opts={})
         opts = HashWithCssStyleKeys[opts]
         
         draw = Magick::Draw.new
@@ -89,10 +99,8 @@ module Dragonfly
         padding_bottom = (opts[:padding_bottom] || pb || 0) * s
         padding_left   = (opts[:padding_left]   || pl || 0) * s
 
-        text = temp_object.data
-
         # Calculate (scaled up) dimensions
-        metrics = draw.get_type_metrics(text)
+        metrics = draw.get_type_metrics(text_string)
         width, height = metrics.width, metrics.height
 
         scaled_up_width = padding_left + width + padding_right
@@ -103,15 +111,21 @@ module Dragonfly
           self.background_color = opts[:background_color] || 'transparent'
         }
         # Draw the text
-        draw.annotate(image, width, height, padding_left, padding_top, text)
+        draw.annotate(image, width, height, padding_left, padding_top, text_string)
         
         # Scale back down again
         image.scale!(1/s)
         
-        image.format = 'png'
+        format = opts[:format] || :png
+        image.format = format.to_s
 
         # Output image as string
-        image.to_blob
+        data = image.to_blob
+        image.destroy!
+        [
+          data,
+          {:format => format, :name => "text.#{format}"}
+        ]
       end
       
       private

data/lib/dragonfly/generator.rb

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

data/lib/dragonfly/job.rb

@@ -0,0 +1,290 @@
+require 'forwardable'
+require 'digest/sha1'
+
+module Dragonfly
+  class Job
+
+    # Exceptions
+    class AppDoesNotMatch < StandardError; end
+    class JobAlreadyApplied < StandardError; end
+    class NothingToProcess < StandardError; end
+    class NothingToEncode < StandardError; end
+    class NothingToAnalyse < StandardError; end
+    class InvalidArray < StandardError; end
+    class NoSHAGiven < StandardError; end
+    class IncorrectSHA < StandardError; end
+
+    extend Forwardable
+    def_delegators :result, :data, :file, :tempfile, :path, :to_file, :size, :ext, :name, :meta, :format, :_format
+
+    class Step
+
+      class << self
+        # Dragonfly::Job::Fetch -> 'Fetch'
+        def basename
+          @basename ||= name.split('::').last
+        end
+        # Dragonfly::Job::Fetch -> :fetch
+        def step_name
+          @step_name ||= basename.gsub(/[A-Z]/){ "_#{$&.downcase}" }.sub('_','').to_sym
+        end
+        # Dragonfly::Job::Fetch -> :f
+        def abbreviation
+          @abbreviation ||= basename.scan(/[A-Z]/).join.downcase.to_sym
+        end
+      end
+
+      def initialize(*args)
+        @args = args
+      end
+      attr_reader :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 || {}))
+      end
+    end
+
+    class Process < Step
+      def name
+        args.first
+      end
+      def arguments
+        args[1..-1]
+      end
+      def apply(job)
+        raise NothingToProcess, "Can't process because temp object has not been initialized. Need to fetch first?" unless job.temp_object
+        old = job.temp_object
+        job.temp_object = TempObject.new(
+          job.app.processor.process(old, name, *arguments),
+          old.attributes
+        )
+      end
+    end
+
+    class Encode < Step
+      def format
+        args.first
+      end
+      def arguments
+        args[1..-1]
+      end
+      def apply(job)
+        raise NothingToEncode, "Can't encode because temp object has not been initialized. Need to fetch first?" unless job.temp_object
+        old = job.temp_object
+        job.temp_object = TempObject.new(
+          job.app.encoder.encode(old, format, *arguments),
+          old.attributes.merge(:format => format)
+        )
+      end
+    end
+
+    class Generate < Step
+      def apply(job)
+        content, extra = job.app.generator.generate(*args)
+        job.temp_object = TempObject.new(content, (extra || {}))
+      end
+    end
+
+    class FetchFile < Step
+      def path
+        File.expand_path(args.first)
+      end
+      def apply(job)
+        job.temp_object = TempObject.new(File.new(path))
+      end
+    end
+
+    STEPS = [
+      Fetch,
+      Process,
+      Encode,
+      Generate,
+      FetchFile
+    ]
+
+    # Class methods
+    class << self
+
+      def from_a(steps_array, app)
+        unless steps_array.is_a?(Array) &&
+               steps_array.all?{|s| s.is_a?(Array) && step_abbreviations[s.first] }
+          raise InvalidArray, "can't define a job from #{steps_array.inspect}"
+        end
+        job = app.new_job
+        steps_array.each do |step_array|
+          step_class = step_abbreviations[step_array.shift]
+          job.steps << step_class.new(*step_array)
+        end
+        job
+      end
+
+      def from_path(path, app)
+        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
+
+      def step_abbreviations
+        @step_abbreviations ||= STEPS.inject({}){|hash, step_class| hash[step_class.abbreviation] = step_class; hash }
+      end
+
+      def step_names
+        @step_names ||= STEPS.map{|step_class| step_class.step_name }
+      end
+
+    end
+
+    # Instance methods
+
+    def initialize(app, temp_object=nil)
+      @app = app
+      self.extend app.analyser.analysis_methods
+      self.extend app.job_definitions
+      @steps = []
+      @next_step_index = 0
+      @temp_object = temp_object
+    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
+    end
+
+    attr_accessor :temp_object
+    attr_reader :app, :steps
+
+    # define fetch(), fetch!(), process(), etc.
+    STEPS.each do |step_class|
+      class_eval %(
+        def #{step_class.step_name}(*args)
+          new_job = self.dup
+          new_job.steps << #{step_class}.new(*args)
+          new_job
+        end
+
+        def #{step_class.step_name}!(*args)
+          steps << #{step_class}.new(*args)
+          self
+        end
+      )
+    end
+
+    def analyse(method, *args)
+      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
+    end
+
+    def apply
+      pending_steps.each{|step| step.apply(self) }
+      self.next_step_index = steps.length
+      self
+    end
+
+    def result
+      apply
+      temp_object
+    end
+
+    def applied_steps
+      steps[0...next_step_index]
+    end
+
+    def pending_steps
+      steps[next_step_index..-1]
+    end
+
+    def to_a
+      steps.map{|step|
+        [step.class.abbreviation, *step.args]
+      }
+    end
+
+    def serialize
+      Serializer.marshal_encode(to_a)
+    end
+    alias unique_signature serialize
+
+    def sha
+      Digest::SHA1.hexdigest("#{serialize}#{app.secret}")[0...8]
+    end
+
+    def validate_sha!(sha)
+      case sha
+      when nil
+        raise NoSHAGiven
+      when self.sha
+        self
+      else
+        raise IncorrectSHA, sha
+      end
+    end
+
+    def to_app
+      JobEndpoint.new(self)
+    end
+
+    def to_response
+      to_app.call
+    end
+
+    def url(*args)
+      app.url_for(self, *args) unless steps.empty?
+    end
+
+    def to_fetched_job(uid)
+      new_job = self.class.new(app, temp_object)
+      new_job.fetch!(uid)
+      new_job.next_step_index = 1
+      new_job
+    end
+
+    def to_path
+      "/#{serialize}"
+    end
+
+    def inspect
+      to_s.sub(/>$/, " app=#{app}, steps=#{steps.inspect}, temp_object=#{temp_object.inspect}, steps applied:#{applied_steps.length}/#{steps.length} >")
+    end
+
+    protected
+
+    attr_writer :steps
+    attr_accessor :next_step_index
+
+  end
+end