fog-dragonfly 0.8.1

data/lib/dragonfly/generation/r_magick_generator.rb

@@ -0,0 +1,155 @@
+require 'RMagick'
+
+module Dragonfly
+  module Generation
+    class RMagickGenerator
+
+      FONT_STYLES = {
+        'normal' => Magick::NormalStyle,
+        'italic' => Magick::ItalicStyle,
+        'oblique' => Magick::ObliqueStyle
+      }
+
+      FONT_STRETCHES = {
+        'normal'          => Magick::NormalStretch,
+        'semi-condensed'  => Magick::SemiCondensedStretch,
+        'condensed'       => Magick::CondensedStretch,
+        'extra-condensed' => Magick::ExtraCondensedStretch,
+        'ultra-condensed' => Magick::UltraCondensedStretch,
+        'semi-expanded'   => Magick::SemiExpandedStretch,
+        'expanded'        => Magick::ExpandedStretch,
+        'extra-expanded'  => Magick::ExtraExpandedStretch,
+        'ultra-expanded'  => Magick::UltraExpandedStretch
+      }
+
+      FONT_WEIGHTS = {
+        'normal'  => Magick::NormalWeight,
+        'bold'    => Magick::BoldWeight,
+        'bolder'  => Magick::BolderWeight,
+        'lighter' => Magick::LighterWeight,
+        '100'     => 100,
+        '200'     => 200,
+        '300'     => 300,
+        '400'     => 400,
+        '500'     => 500,
+        '600'     => 600,
+        '700'     => 700,
+        '800'     => 800,
+        '900'     => 900
+      }
+
+      include RMagickUtils
+      include Configurable
+      configurable_attr :use_filesystem, true
+
+      def plasma(width, height, format='png')
+        image = Magick::Image.read("plasma:fractal"){self.size = "#{width}x#{height}"}.first
+        image.format = format.to_s
+        content = use_filesystem ? write_to_tempfile(image) : image.to_blob
+        image.destroy!
+        [
+          content,
+          {:format => format.to_sym, :name => "plasma.#{format}"}
+        ]
+      end
+
+      def text(text_string, opts={})
+        opts = HashWithCssStyleKeys[opts]
+
+        draw = Magick::Draw.new
+        draw.gravity = Magick::CenterGravity
+        draw.text_antialias = true
+
+        # Font size
+        font_size = (opts[:font_size] || 12).to_i
+
+        # Scale up the text for better quality -
+        #  it will be reshrunk at the end
+        s = scale_factor_for(font_size)
+
+        # Settings
+        draw.pointsize    = font_size * s
+        draw.font         = opts[:font] if opts[:font]
+        draw.font_family  = opts[:font_family] if opts[:font_family]
+        draw.fill         = opts[:color] if opts[:color]
+        draw.stroke       = opts[:stroke_color] if opts[:stroke_color]
+        draw.font_style   = FONT_STYLES[opts[:font_style]] if opts[:font_style]
+        draw.font_stretch = FONT_STRETCHES[opts[:font_stretch]] if opts[:font_stretch]
+        draw.font_weight  = FONT_WEIGHTS[opts[:font_weight]] if opts[:font_weight]
+
+        # Padding
+        # NB the values are scaled up by the scale factor
+        pt, pr, pb, pl = parse_padding_string(opts[:padding]) if opts[:padding]
+        padding_top    = (opts[:padding_top]    || pt || 0) * s
+        padding_right  = (opts[:padding_right]  || pr || 0) * s
+        padding_bottom = (opts[:padding_bottom] || pb || 0) * s
+        padding_left   = (opts[:padding_left]   || pl || 0) * s
+
+        # Calculate (scaled up) dimensions
+        metrics = draw.get_type_metrics(text_string)
+        width, height = metrics.width, metrics.height
+
+        scaled_up_width = padding_left + width + padding_right
+        scaled_up_height = padding_top + height + padding_bottom
+
+        # Draw the background
+        image = Magick::Image.new(scaled_up_width, scaled_up_height){
+          self.background_color = opts[:background_color] || 'transparent'
+        }
+        # Draw the text
+        draw.annotate(image, width, height, padding_left, padding_top, text_string)
+
+        # Scale back down again
+        image.scale!(1/s)
+
+        format = opts[:format] || :png
+        image.format = format.to_s
+
+        # Output image either as a string or a tempfile
+        content = use_filesystem ? write_to_tempfile(image) : image.to_blob
+        image.destroy!
+        [
+          content,
+          {:format => format, :name => "text.#{format}"}
+        ]
+      end
+
+      private
+
+      # Use css-style padding declaration, i.e.
+      # 10        (all sides)
+      # 10 5      (top/bottom, left/right)
+      # 10 5 10   (top, left/right, bottom)
+      # 10 5 10 5 (top, right, bottom, left)
+      def parse_padding_string(str)
+        padding_parts = str.gsub('px','').split(/\s+/).map{|px| px.to_i}
+        case padding_parts.size
+        when 1
+          p = padding_parts.first
+          [p,p,p,p]
+        when 2
+          p,q = padding_parts
+          [p,q,p,q]
+        when 3
+          p,q,r = padding_parts
+          [p,q,r,q]
+        when 4
+          padding_parts
+        else raise ArgumentError, "Couldn't parse padding string '#{str}' - should be a css-style string"
+        end
+      end
+
+      def scale_factor_for(font_size)
+        # Scale approximately to 64 if below
+        min_size = 64
+        if font_size < min_size
+          (min_size.to_f / font_size).ceil
+        else
+          1
+        end.to_f
+      end
+
+    end
+
+  end
+end

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/image_magick_utils.rb

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

data/lib/dragonfly/job.rb

@@ -0,0 +1,371 @@
+require 'forwardable'
+require 'digest/sha1'
+require 'base64'
+
+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, :name=, :basename, :meta, :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 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
+      end
+
+      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
+        content, extra = job.app.processor.process(job.temp_object, name, *arguments)
+        update_temp_object(job, content, extra)
+      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
+        content, extra = job.app.encoder.encode(job.temp_object, format, *arguments)
+        update_temp_object(job, content, extra)
+        job.temp_object.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 = 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
+
+      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
+
+    # Applying, etc.
+
+    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
+
+    # Serializing, etc.
+
+    def serialize
+      Serializer.marshal_encode(to_a)
+    end
+
+    def unique_signature
+      Digest::SHA1.hexdigest(serialize)
+    end
+
+    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
+
+    # URLs, etc.
+
+    def url(*args)
+      app.url_for(self, *args) unless steps.empty?
+    end
+
+    def b64_data
+      "data:#{resolve_mime_type};base64,#{Base64.encode64(data)}"
+    end
+
+    # to_stuff...
+
+    def to_app
+      JobEndpoint.new(self)
+    end
+
+    def to_response(env={})
+      to_app.call(env)
+    end
+
+    def to_path
+      "/#{serialize}"
+    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
+
+    # 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
+    end
+
+    def generate_step
+      last_step_of_type(Generate)
+    end
+
+    def fetch_file_step
+      last_step_of_type(FetchFile)
+    end
+
+    def process_steps
+      steps.select{|s| s.is_a?(Process) }
+    end
+
+    def encode_step
+      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
+    end
+
+    # Misc
+
+    def store(opts={})
+      app.store(result, opts)
+    end
+
+    def resolve_mime_type
+      app.resolve_mime_type(result)
+    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
+
+    private
+
+    def last_step_of_type(type)
+      steps.select{|s| s.is_a?(type) }.last
+    end
+
+  end
+end