dragonfly 0.9.15 → 1.0

data/lib/dragonfly/core_ext/object.rb

@@ -1,12 +1,7 @@
 class Object
-  
-  # Don't want to depend on activesupport for this
-  def blank?
-    respond_to?(:empty?) ? empty? : !self
-  end
 
   def to_dragonfly_unique_s
     to_s
   end
-  
+
 end

data/lib/dragonfly/file_data_store.rb

@@ -0,0 +1,197 @@
+require 'pathname'
+require 'yaml'
+require 'fileutils'
+require 'dragonfly/utils'
+
+module Dragonfly
+  class FileDataStore
+
+    # Exceptions
+    class BadUID < RuntimeError; end
+    class UnableToFormUrl < RuntimeError; end
+
+    class MetaStore
+      def write(data_path, meta)
+        File.open(meta_path(data_path), 'wb') do |f|
+          f.write dump(meta)
+        end
+      end
+
+      def read(data_path)
+        path = meta_path(data_path)
+        File.open(path,'rb'){|f| load(f.read) } if File.exist?(path)
+      end
+
+      def destroy(path)
+        FileUtils.rm_f meta_path(path)
+      end
+
+      private
+
+      def meta_path(data_path)
+        raise NotImplementedError
+      end
+
+      def dump(meta)
+        raise NotImplementedError
+      end
+
+      def load(string)
+        raise NotImplementedError
+      end
+    end
+
+    class YAMLMetaStore < MetaStore
+      def meta_path(data_path)
+        "#{data_path}.meta.yml"
+      end
+
+      def dump(meta)
+        YAML.dump(meta)
+      end
+
+      def load(string)
+        YAML.load(string)
+      end
+    end
+
+    class MarshalMetaStore < MetaStore
+      def meta_path(data_path)
+        "#{data_path}.meta"
+      end
+
+      def dump(meta)
+        Marshal.dump(meta)
+      end
+
+      def load(string)
+        Utils.stringify_keys Marshal.load(string)
+      end
+    end
+
+    def initialize(opts={})
+      self.root_path = opts[:root_path] || 'dragonfly'
+      self.server_root = opts[:server_root]
+      self.store_meta = opts[:store_meta]
+      @meta_store = YAMLMetaStore.new
+      @deprecated_meta_store = MarshalMetaStore.new
+    end
+
+    attr_writer :store_meta
+    attr_reader :root_path, :server_root
+
+    def root_path=(path)
+      @root_path = path ? path.to_s : nil
+    end
+
+    def server_root=(path)
+      @server_root = path ? path.to_s : nil
+    end
+
+    def store_meta?
+      @store_meta != false # Default to true if not set
+    end
+
+    def write(content, opts={})
+      relative_path = if opts[:path]
+        opts[:path]
+      else
+        filename = content.name || 'file'
+        relative_path = relative_path_for(filename)
+      end
+
+      path = absolute(relative_path)
+      until !File.exist?(path)
+        path = disambiguate(path)
+      end
+      content.to_file(path).close
+      meta_store.write(path, content.meta) if store_meta?
+
+      relative(path)
+    end
+
+    def read(relative_path)
+      validate_path!(relative_path)
+      path = absolute(relative_path)
+      pathname = Pathname.new(path)
+      return nil unless pathname.exist?
+      [
+        pathname,
+        (
+          if store_meta?
+            meta_store.read(path) || deprecated_meta_store.read(path) || {}
+          end
+        )
+      ]
+    end
+
+    def destroy(relative_path)
+      validate_path!(relative_path)
+      path = absolute(relative_path)
+      FileUtils.rm path
+      meta_store.destroy(path)
+      purge_empty_directories(relative_path)
+    rescue Errno::ENOENT => e
+      Dragonfly.warn("#{self.class.name} destroy error: #{e}")
+    end
+
+    def url_for(relative_path, opts={})
+      if server_root.nil?
+        raise UnableToFormUrl, "you need to configure server_root for #{self.class.name} in order to form urls"
+      else
+        _, __, path = absolute(relative_path).partition(server_root)
+        if path.empty?
+          raise UnableToFormUrl, "couldn't form url for uid #{relative_path.inspect} with root_path #{root_path.inspect} and server_root #{server_root.inspect}"
+        else
+          path
+        end
+      end
+    end
+
+    def disambiguate(path)
+      dirname = File.dirname(path)
+      basename = File.basename(path, '.*')
+      extname = File.extname(path)
+      "#{dirname}/#{basename}_#{(Time.now.usec*10 + rand(100)).to_s(32)}#{extname}"
+    end
+
+    private
+
+    attr_reader :meta_store, :deprecated_meta_store
+
+    def absolute(relative_path)
+      relative_path.to_s == '.' ? root_path : File.join(root_path, relative_path)
+    end
+
+    def relative(absolute_path)
+      absolute_path[/^#{Regexp.escape root_path}\/?(.*)$/, 1]
+    end
+
+    def directory_empty?(path)
+      Dir.entries(path) == ['.','..']
+    end
+
+    def root_path?(dir)
+      root_path == dir
+    end
+
+    def relative_path_for(filename)
+      time = Time.now
+      "#{time.strftime '%Y/%m/%d/%H_%M_%S'}_#{time.usec.to_s(36)}_#{filename.gsub(/[^\w.]+/,'_')}"
+    end
+
+    def purge_empty_directories(path)
+      containing_directory = Pathname.new(path).dirname
+      containing_directory.ascend do |relative_dir|
+        dir = absolute(relative_dir)
+        FileUtils.rmdir dir if directory_empty?(dir) && !root_path?(dir)
+      end
+    end
+
+    def validate_path!(uid)
+      raise BadUID, uid if Utils.blank?(uid) || uid['../']
+    end
+
+  end
+
+end

data/lib/dragonfly/image_magick/analysers/image_properties.rb

@@ -0,0 +1,23 @@
+module Dragonfly
+  module ImageMagick
+    module Analysers
+      class ImageProperties
+
+        def call(content)
+          identify_command = content.env[:identify_command] || 'identify'
+          details = content.shell_eval do |path|
+            "#{identify_command} -ping -format '%m %w %h' #{path}"
+          end
+          format, width, height = details.split
+          {
+            'format' => format.downcase,
+            'width' => width.to_i,
+            'height' => height.to_i
+          }
+        end
+
+      end
+    end
+  end
+end
+

data/lib/dragonfly/image_magick/generators/convert.rb

@@ -0,0 +1,19 @@
+module Dragonfly
+  module ImageMagick
+    module Generators
+      class Convert
+
+        def call(content, args, format)
+          format = format.to_s
+          convert_command = content.env[:convert_command] || 'convert'
+          content.shell_generate :ext => format do |path|
+            "#{convert_command} #{args} #{path}"
+          end
+          content.add_meta('format' => format)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/dragonfly/image_magick/generators/plain.rb

@@ -0,0 +1,26 @@
+module Dragonfly
+  module ImageMagick
+    module Generators
+      class Plain
+
+        def call(content, width, height, opts={})
+          format = extract_format(opts)
+          colour = opts['colour'] || opts['color'] || 'white'
+          content.generate!(:convert, "-size #{width}x#{height} xc:#{colour}", format)
+          content.add_meta('format' => format, 'name' => "plain.#{format}")
+        end
+
+        def update_url(url_attributes, width, height, opts={})
+          url_attributes.name = "plain.#{extract_format(opts)}"
+        end
+
+        private
+
+        def extract_format(opts)
+          opts['format'] || 'png'
+        end
+
+      end
+    end
+  end
+end

data/lib/dragonfly/image_magick/generators/plasma.rb

@@ -0,0 +1,25 @@
+module Dragonfly
+  module ImageMagick
+    module Generators
+      class Plasma
+
+        def call(content, width, height, opts={})
+          format = extract_format(opts)
+          content.generate!(:convert, "-size #{width}x#{height} plasma:fractal", format)
+          content.add_meta('format' => format, 'name' => "plasma.#{format}")
+        end
+
+        def update_url(url_attributes, width, height, opts={})
+          url_attributes.name = "plasma.#{extract_format(opts)}"
+        end
+
+        private
+
+        def extract_format(opts)
+          opts['format'] || 'png'
+        end
+
+      end
+    end
+  end
+end

data/lib/dragonfly/image_magick/generators/text.rb

@@ -0,0 +1,127 @@
+require 'dragonfly/hash_with_css_style_keys'
+
+module Dragonfly
+  module ImageMagick
+    module Generators
+      class Text
+
+        FONT_STYLES = {
+          'normal'  => 'normal',
+          'italic'  => 'italic',
+          'oblique' => 'oblique'
+        }
+
+        FONT_STRETCHES = {
+          'normal'          => 'normal',
+          'semi-condensed'  => 'semi-condensed',
+          'condensed'       => 'condensed',
+          'extra-condensed' => 'extra-condensed',
+          'ultra-condensed' => 'ultra-condensed',
+          'semi-expanded'   => 'semi-expanded',
+          'expanded'        => 'expanded',
+          'extra-expanded'  => 'extra-expanded',
+          'ultra-expanded'  => 'ultra-expanded'
+        }
+
+        FONT_WEIGHTS = {
+          'normal'  => 'normal',
+          'bold'    => 'bold',
+          'bolder'  => 'bolder',
+          'lighter' => 'lighter',
+          '100'     => 100,
+          '200'     => 200,
+          '300'     => 300,
+          '400'     => 400,
+          '500'     => 500,
+          '600'     => 600,
+          '700'     => 700,
+          '800'     => 800,
+          '900'     => 900
+        }
+
+        def update_url(url_attributes, string, opts={})
+          url_attributes.name = "text.#{extract_format(opts)}"
+        end
+
+        def call(content, string, opts={})
+          opts = HashWithCssStyleKeys[opts]
+          args = []
+          format = extract_format(opts)
+          background = opts['background_color'] || 'none'
+          font_size = (opts['font_size'] || 12).to_i
+          escaped_string = "\"#{string.gsub(/"/, '\"')}\""
+
+          # Settings
+          args.push("-gravity NorthWest")
+          args.push("-antialias")
+          args.push("-pointsize #{font_size}")
+          args.push("-font \"#{opts['font']}\"") if opts['font']
+          args.push("-family '#{opts['font_family']}'") if opts['font_family']
+          args.push("-fill #{opts['color']}") if opts['color']
+          args.push("-stroke #{opts['stroke_color']}") if opts['stroke_color']
+          args.push("-style #{FONT_STYLES[opts['font_style']]}") if opts['font_style']
+          args.push("-stretch #{FONT_STRETCHES[opts['font_stretch']]}") if opts['font_stretch']
+          args.push("-weight #{FONT_WEIGHTS[opts['font_weight']]}") if opts['font_weight']
+          args.push("-background #{background}")
+          args.push("label:#{escaped_string}")
+
+          # Padding
+          pt, pr, pb, pl = parse_padding_string(opts['padding']) if opts['padding']
+          padding_top    = (opts['padding_top']    || pt || 0)
+          padding_right  = (opts['padding_right']  || pr || 0)
+          padding_bottom = (opts['padding_bottom'] || pb || 0)
+          padding_left   = (opts['padding_left']   || pl || 0)
+
+          content.generate!(:convert, args.join(' '), format)
+
+          if (padding_top || padding_right || padding_bottom || padding_left)
+            dimensions = content.analyse(:image_properties)
+            text_width  = dimensions['width']
+            text_height = dimensions['height']
+            width  = padding_left + text_width  + padding_right
+            height = padding_top  + text_height + padding_bottom
+
+            args = args.slice(0, args.length - 2)
+            args.push("-size #{width}x#{height}")
+            args.push("xc:#{background}")
+            args.push("-annotate 0x0+#{padding_left}+#{padding_top} #{escaped_string}")
+            content.generate!(:convert, args.join(' '), format)
+          end
+
+          content.add_meta('format' => format, 'name' => "text.#{format}")
+        end
+
+        private
+
+        def extract_format(opts)
+          opts['format'] || 'png'
+        end
+
+        # 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
+      end
+
+    end
+  end
+end
+

data/lib/dragonfly/image_magick/plugin.rb

@@ -0,0 +1,83 @@
+require 'dragonfly/image_magick/analysers/image_properties'
+require 'dragonfly/image_magick/generators/convert'
+require 'dragonfly/image_magick/generators/plain'
+require 'dragonfly/image_magick/generators/plasma'
+require 'dragonfly/image_magick/generators/text'
+require 'dragonfly/image_magick/processors/convert'
+require 'dragonfly/image_magick/processors/encode'
+require 'dragonfly/image_magick/processors/thumb'
+
+module Dragonfly
+  module ImageMagick
+
+    # The ImageMagick Plugin registers an app with generators, analysers and processors.
+    # Look at the source code for #call to see exactly how it configures the app.
+    class Plugin
+
+      def call(app, opts={})
+        # ENV
+        app.env[:convert_command] = opts[:convert_command] || 'convert'
+        app.env[:identify_command] = opts[:identify_command] || 'identify'
+
+        # Analysers
+        app.add_analyser :image_properties, ImageMagick::Analysers::ImageProperties.new
+        app.add_analyser :width do |content|
+          content.analyse(:image_properties)['width']
+        end
+        app.add_analyser :height do |content|
+          content.analyse(:image_properties)['height']
+        end
+        app.add_analyser :format do |content|
+          content.analyse(:image_properties)['format']
+        end
+        app.add_analyser :aspect_ratio do |content|
+          attrs = content.analyse(:image_properties)
+          attrs['width'].to_f / attrs['height']
+        end
+        app.add_analyser :portrait do |content|
+          attrs = content.analyse(:image_properties)
+          attrs['width'] <= attrs['height']
+        end
+        app.add_analyser :landscape do |content|
+          !content.analyse(:portrait)
+        end
+        app.add_analyser :image do |content|
+          begin
+            content.analyse(:image_properties)['format'] != 'pdf'
+          rescue Shell::CommandFailed
+            false
+          end
+        end
+
+        # Aliases
+        app.define(:portrait?) { portrait }
+        app.define(:landscape?) { landscape }
+        app.define(:image?) { image }
+
+        # Generators
+        app.add_generator :convert, ImageMagick::Generators::Convert.new
+        app.add_generator :plain, ImageMagick::Generators::Plain.new
+        app.add_generator :plasma, ImageMagick::Generators::Plasma.new
+        app.add_generator :text, ImageMagick::Generators::Text.new
+
+        # Processors
+        app.add_processor :convert, Processors::Convert.new
+        app.add_processor :encode, Processors::Encode.new
+        app.add_processor :thumb, Processors::Thumb.new
+        app.add_processor :rotate do |content, amount|
+          content.process!(:convert, "-rotate #{amount}")
+        end
+
+        # Extra methods
+        app.define :identify do |args=""|
+          shell_eval do |path|
+            "#{app.env[:identify_command]} #{args} #{path}"
+          end
+        end
+
+      end
+
+    end
+  end
+end
+