rails_imager 0.0.18 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0764ea29875ab7576c668c8e792b8866eca1c1c7
-  data.tar.gz: f9235dcafccd09e9df9f8ba7c7ffc910714c125a
+  metadata.gz: fd9b2fe3759e88819d0db1f9b3af5fba8e6d576a
+  data.tar.gz: 39f8ba07520ec430d733ddfefedf5342707ec07c
 SHA512:
-  metadata.gz: 241f39a3ce37651a208763b4c68cf394c9225f0de676a3b87899ed80347a7fe8b38624262d1d5dbbfba572b75f9078cc686a70cc4c481334173ae34389881d10
-  data.tar.gz: 3abb94d5b7a48a4d6e25264fefd98a6f71a8b198f693de8eb29f629aea976f9488c1158cd3fe757c6f367b7ee54285f10286c693543a609cfd70373dc1d45369
+  metadata.gz: 4f1569d9140d97e751f842f2d74e03088c49d2a07e723238b1264c4a69a4caf390340569998427c1580b7c85a379ce932131a58907c6c22dc2d138ab2578af8c
+  data.tar.gz: 137034cb9d007fe284496e1b3c55e2506b3cff718dd8a707836cf30686e729c23d7cc983c7917cf9d60ec9f8b96b769e2ea51f58792d095f651d6a541ee865e8

data/app/controllers/rails_imager/images_controller.rb

@@ -1,32 +1,193 @@
-# encoding: utf-8
-
-require_dependency "rails_imager/application_controller"
-
 class RailsImager::ImagesController < ApplicationController
+  PARAMS_ARGS = [:width, :height, :smartsize, :maxwidth, :maxheight, :rounded_corners, :border, :border_color, :force]
+  
   def show
-    rimger = RailsImager::ImageHandler.new
-    image_params = params[:image] || {}
+    set_and_validate_parameters
+    set_path
+    @mod_time = File.mtime(@full_path)
+    generate_cache_name
+    generate_cache if should_generate_cache?
+    set_headers
+    
+    if not_modified? && !force?
+      render :nothing => true, :status => "304 Not Modified"
+    else
+      send_file @cache_path, :type => "image/png", :disposition => "inline", :filename => "picture.png"
+    end
+  end
+  
+private
+  
+  def set_path
+    @path = "#{Rails.public_path}/#{params[:id]}"
+    @full_path = File.realpath(@path)
+    validate_path
+  end
+  
+  def set_and_validate_parameters
+    @image_params = params[:image] || {}
+    @image_params.each do |key, val|
+      raise ArgumentError, "Invalid parameter: '#{key}'." unless PARAMS_ARGS.map{ |param| param.to_s }.include?(key)
+    end
+  end
+  
+  def force?
+    if @image_params[:force] && @image_params[:force].to_s == "true"
+      return true
+    else
+      return false
+    end
+  end
+  
+  def not_modified?
+    if request.headers["HTTP_IF_MODIFIED_SINCE"]
+      if_mod_since_time = Datet.in(request.headers["HTTP_IF_MODIFIED_SINCE"]).time
+    else
+      if_mod_since_time = request.if_modified_since
+    end
     
-    # Check for invalid parameters.
-    image_params.each do |key, val|
-      raise ArgumentError, "Invalid parameter: '#{key}'." unless RailsImager::ImageHandler::PARAMS_ARGS.map{ |param| param.to_s }.include?(key)
+    if if_mod_since_time && if_mod_since_time.utc.to_s == @mod_time.utc.to_s
+      return true
     end
     
-    image_path = "#{Rails.public_path}/#{params[:id]}"
-    image_path = File.realpath(image_path)
-    validate_path(image_path)
+    return false
+  end
+  
+  def set_headers
+    response.last_modified = @mod_time
     
-    rimger.handle(
-      :controller => self,
-      :fpath => image_path,
-      :params => image_params
-    )
+    if force?
+      response.headers["Expires"] = Time.now.httpdate
+    else
+      response.headers["Expires"] = 2.hours.from_now.httpdate
+    end
   end
   
-private
+  def validate_path
+    raise "No such file: '#{@full_path}'." unless File.exists?(@full_path)
+    raise "Image wasn't in the public folder: '#{@full_path}'." unless @full_path.start_with?(File.realpath(Rails.public_path.to_s))
+  end
   
-  def validate_path(image_path)
-    raise "No such file: '#{image_path}'." unless File.exists?(image_path)
-    raise "Image wasn't in the public folder: '#{image_path}'." unless image_path.start_with?(Rails.public_path.to_s)
+  def generate_cache_name
+    @cache_name = ::Knj::Strings.sanitize_filename(@path)
+    @cache_name << "__ARGS_"
+    
+    PARAMS_ARGS.each do |val|
+      next if val.to_s == "force"
+      @cache_name << "_#{val}-#{@image_params[val]}"
+    end
+    
+    @cache_path = "#{cache_directory}/#{@cache_name}"
+  end
+  
+  def cache_directory
+    require "tmpdir"
+    cache_path = "#{Dir.tmpdir}/rails-imager-cache"
+    Dir.mkdir(cache_path) unless Dir.exists?(cache_path)
+    return cache_path
+  end
+  
+  def should_generate_cache?
+    return true if force?
+    
+    if File.exists?(@cache_path)
+      if File.mtime(@cache_path) < File.mtime(@full_path)
+        return true
+      else
+        return false
+      end
+    else
+      return true
+    end
+  end
+  
+  def generate_cache
+    @image = ::Magick::Image.read(@full_path).first
+    @image.format = "png"
+    apply_image_changes
+    @image.write(@cache_path)
+  end
+  
+  #Create a new image-object based on the given image-object and the parameters.
+  def apply_image_changes
+    @image_width = @image.columns
+    @image_height = @image.rows
+    
+    if @image_params[:width].to_i > 0
+      @width = @image_params[:width].to_i
+    else
+      @width = @image_width
+    end
+    
+    if @image_params[:height].to_i > 0
+      @height = @image_params[:height].to_i
+    else
+      @height = @image_height
+    end
+    
+    calcuate_sizes
+    @image = @image.resize(@width, @height) if @width != @image_width || @height != @image_height
+    apply_rounded_corners if @image_params[:rounded_corners]
+  end
+  
+  def calcuate_sizes
+    validate_and_set_smartsize if @image_params[:smartsize]
+    validate_and_set_max_width
+    validate_and_set_max_height
+    calculate_missing_width if @image_params[:height] && !@image_params[:width]
+    calculate_missing_height if @image_params[:width] && !@image_params[:height]
+  end
+  
+  def calculate_missing_height
+    @height = (@image_height.to_f / (@image_width.to_f / @width.to_f)).to_i
+  end
+  
+  def calculate_missing_width
+    @width = (@image_width.to_f / (@image_height.to_f / @height.to_f)).to_i
+  end
+  
+  def validate_and_set_smartsize
+    if @image_width > @image_height
+      @width = @image_params[:smartsize].to_i
+      calculate_missing_height
+    else
+      @height = @image_params[:smartsize].to_i
+      calculate_missing_width
+    end
+  end
+  
+  def validate_and_set_max_width
+    if @image_params[:maxwidth]
+      maxwidth = @image_params[:maxwidth].to_i
+      
+      if @width > maxwidth
+        @width = maxwidth
+        calculate_missing_height
+      end
+    end
+  end
+  
+  def validate_and_set_max_height
+    if @image_params[:maxheight]
+      maxheight = @image_params[:maxheight].to_i
+      
+      if @height > maxheight
+        @height = maxheight
+        calculate_missing_width
+      end
+    end
+  end
+  
+  def apply_rounded_corners
+    @image = @image.clone
+    @image.format = "png" # Needs PNG format for transparency.
+    args = {:img => @image, :radius => @image_params[:rounded_corners].to_i}
+    
+    if @image_params[:border] && @image_params[:border_color]
+      args[:border] = @image_params[:border].to_i
+      args[:border_color] = @image_params[:border_color]
+    end
+    
+    ::Knj::Image.rounded_corners(args)
   end
 end

data/app/helpers/rails_imager/images_helper.rb

@@ -2,63 +2,85 @@ require "uri"
 
 module RailsImager::ImagesHelper
   def rails_imager_p(path, args = {})
-    if path.class.name == "Paperclip::Attachment"
-      raise "Paperclip path does not start with public path: #{path.path}" unless path.path.to_s.start_with?(Rails.public_path.to_s)
-      path_without_public = path.path.to_s.gsub("#{Rails.public_path}/", "")
-      raise "Path didn't change '#{path.path}' - '#{path_without_public}'." if path.path.to_s == path_without_public
-      path = path_without_public
+    path = path_from_arg(path)
+    
+    if args.delete(:url)
+      newpath = "#{request.protocol}#{request.host_with_port}"
+    elsif args.delete(:mailer)
+      newpath = mailer_pre_path
+    else
+      newpath = ""
     end
     
-    newpath = ""
+    check_arguments(args)
     
-    if args[:url]
-      args.delete(:url)
-      newpath << "#{request.protocol}#{request.host_with_port}"
-    elsif args[:mailer]
-      args.delete(:mailer)
-      
-      if ActionMailer::Base.default_url_options[:protocol]
-        newpath << ActionMailer::Base.default_url_options[:protocol]
-      else
-        newpath << "http://"
-      end
-      
-      newpath << ActionMailer::Base.default_url_options[:host]
-      
-      if ActionMailer::Base.default_url_options[:port]
-        newpath << ":#{ActionMailer::Base.default_url_options[:port]}"
-      end
+    newpath << "/rails_imager/images/"
+    newpath << path
+    
+    if args && args.any?
+      newpath << "?"
+      newpath << url_encoded_arguments(args)
     end
     
-    # Check for invalid parameters.
-    args.each do |key, val|
-      raise ArgumentError, "Invalid parameter: '#{key}'." unless RailsImager::ImageHandler::PARAMS_ARGS.include?(key)
+    return newpath
+  end
+  
+private
+  
+  def mailer_pre_path
+    if ActionMailer::Base.default_url_options[:protocol]
+      pre_path = ActionMailer::Base.default_url_options[:protocol]
+    else
+      pre_path = "http://"
     end
     
+    pre_path << ActionMailer::Base.default_url_options[:host]
     
+    if ActionMailer::Base.default_url_options[:port]
+      pre_path << ":#{ActionMailer::Base.default_url_options[:port]}"
+    end
     
-    newpath << "/rails_imager/images/"
-    newpath << path
+    return pre_path
+  end
+  
+  def url_encoded_arguments(args)
+    path = ""
     
-    if args && args.any?
-      newpath << "?"
-      
-      first = true
-      args.each do |key, val|
-        if first
-          first = false
-        else
-          newpath << "&"
-        end
-        
-        realkey = "image[#{key}]"
-        
-        newpath << URI.encode(realkey.to_s)
-        newpath << "="
-        newpath << URI.encode(val.to_s)
+    first = true
+    args.each do |key, val|
+      if first
+        first = false
+      else
+        path << "&"
       end
+      
+      realkey = "image[#{key}]"
+      
+      path << URI.encode(realkey)
+      path << "="
+      path << URI.encode(val.to_s)
     end
     
-    return newpath
+    return path
+  end
+  
+  def check_arguments(args)
+    # Check for invalid parameters.
+    args.each do |key, val|
+      raise ArgumentError, "Invalid parameter: '#{key}'." unless RailsImager::ImagesController::PARAMS_ARGS.include?(key)
+    end
+  end
+  
+  def path_from_arg(path)
+    if path.class.name == "Paperclip::Attachment"
+      raise "Paperclip path does not start with public path: #{path.path}" unless path.path.to_s.start_with?(Rails.public_path.to_s)
+      path_without_public = path.path.to_s.gsub("#{Rails.public_path}/", "")
+      raise "Path didn't change '#{path.path}' - '#{path_without_public}'." if path.path.to_s == path_without_public
+      return path_without_public
+    elsif path.is_a?(String)
+      return path
+    else
+      raise "Unknown argument: #{path_from_arg}"
+    end
   end
 end

data/lib/rails_imager/version.rb

@@ -1,3 +1,3 @@
 module RailsImager
-  VERSION = "0.0.18"
+  VERSION = "0.0.19"
 end

data/lib/rails_imager.rb

@@ -1,19 +1,25 @@
 require "rails/engine"
 require "rails_imager/engine"
 require "string-cases"
+require "datet"
+require "knjrbfw"
+require "RMagick" unless ::Kernel.const_defined?(:RMagick)
 
 module RailsImager
   def self.const_missing(name)
     if name.to_s.end_with?("Controller")
-      path = "#{File.dirname(__FILE__)}/../app/controllers/rails_imager/#{::StringCases.camel_to_snake(name)}"
+      path = "#{File.dirname(__FILE__)}/../app/controllers/rails_imager/#{::StringCases.camel_to_snake(name)}.rb"
     elsif name.to_s.end_with?("Helper")
-      path = "#{File.dirname(__FILE__)}/../app/helpers/rails_imager/#{::StringCases.camel_to_snake(name)}"
+      path = "#{File.dirname(__FILE__)}/../app/helpers/rails_imager/#{::StringCases.camel_to_snake(name)}.rb"
     else
-      path = "#{File.dirname(__FILE__)}/rails_imager/#{::StringCases.camel_to_snake(name)}"
+      path = "#{File.dirname(__FILE__)}/rails_imager/#{::StringCases.camel_to_snake(name)}.rb"
     end
     
-    require path
-    raise LoadError, "Not autoloaded: #{name}" unless const_defined?(name)
-    return const_get(name)
+    if File.exists?(path)
+      require path
+      return const_get(name) if const_defined?(name)
+    end
+    
+    super
   end
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rails_imager
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.0.19
 platform: ruby
 authors:
 - kaspernj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-14 00:00:00.000000000 Z
+date: 2014-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 4.0.4
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 4.0.4
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: knjrbfw
   requirement: !ruby/object:Gem::Requirement
@@ -143,21 +143,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- app/helpers/rails_imager/application_helper.rb
-- app/helpers/rails_imager/images_helper.rb
-- app/assets/javascripts/rails_imager/images.js
-- app/assets/javascripts/rails_imager/application.js
 - app/assets/stylesheets/rails_imager/application.css
 - app/assets/stylesheets/rails_imager/images.css
+- app/assets/javascripts/rails_imager/images.js
+- app/assets/javascripts/rails_imager/application.js
+- app/helpers/rails_imager/images_helper.rb
 - app/controllers/rails_imager/images_controller.rb
-- app/controllers/rails_imager/application_controller.rb
 - app/views/layouts/rails_imager/application.html.erb
 - config/routes.rb
+- lib/rails_imager.rb
+- lib/tasks/rails_imager_tasks.rake
 - lib/rails_imager/engine.rb
 - lib/rails_imager/version.rb
-- lib/rails_imager/image_handler.rb
-- lib/tasks/rails_imager_tasks.rake
-- lib/rails_imager.rb
 - MIT-LICENSE
 - Rakefile
 homepage: http://www.github.com/kaspernj/rails_imager
@@ -179,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.7
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Automatic resizing, bordering and more of images.

data/app/controllers/rails_imager/application_controller.rb

@@ -1,4 +0,0 @@
-module RailsImager
-  class ApplicationController < ActionController::Base
-  end
-end

data/app/helpers/rails_imager/application_helper.rb

@@ -1,4 +0,0 @@
-module RailsImager
-  module ApplicationHelper
-  end
-end

data/lib/rails_imager/image_handler.rb

@@ -1,256 +0,0 @@
-require "RMagick"
-require "knjrbfw"
-require "tmpdir"
-require "datet"
-
-class RailsImager::ImageHandler
-  PARAMS_ARGS = [:width, :height, :smartsize, :maxwidth, :maxheight, :rounded_corners, :border, :border_color, :force]
-  
-  #This is the default cache which is plased in the temp-directory, so it will be cleared on every restart. It should always exist.
-  DEFAULT_CACHE_DIR = "#{Dir.tmpdir}/rails-imager-cache"
-  Dir.mkdir(DEFAULT_CACHE_DIR) unless Dir.exists?(DEFAULT_CACHE_DIR)
-  
-  #Default arguments unless something else is given in constructor.
-  DEFAULT_ARGS = {
-    :cache_dir => DEFAULT_CACHE_DIR
-  }
-  
-  INITIALIZE_ALLOWED_ARGS = [:cache_dir]
-  #Initializes the RailsImager.
-  def initialize(args = {})
-    args.each do |key, val|
-      raise "Invalid argument: '#{key}'." unless INITIALIZE_ALLOWED_ARGS.include?(key)
-    end
-    
-    @args = DEFAULT_ARGS.merge(args)
-  end
-  
-  IMG_FROM_PARAMS_ALLOWED_ARGS = [:image, :params]
-  #Create a new image-object based on the given image-object and the parameters.
-  def img_from_params(args)
-    args.each do |key, val|
-      raise "Invalid argument: '#{key}'." unless IMG_FROM_PARAMS_ALLOWED_ARGS.include?(key)
-    end
-    
-    #Set up vars.
-    img = args[:image]
-    raise "No image given." unless img
-    raise "Wrong image-object given: '#{img.class.name}'." unless img.is_a?(Magick::Image)
-    
-    params = args[:params]
-    raise "No params given." unless params
-    
-    img_width = img.columns
-    img_height = img.rows
-    
-    width = img_width
-    height = img_height
-    
-    width = params[:width].to_i if params[:width].to_i > 0
-    height = params[:height].to_i if params[:height].to_i > 0
-    
-    #Check arguments and manipulate image.
-    if params[:smartsize]
-      if img_width > img_height
-        width = params[:smartsize].to_i
-        height = (img_height.to_f / (img_width.to_f / width.to_f)).to_i
-      else
-        height = params[:smartsize].to_i
-        width = (img_width.to_f / (img_height.to_f / height.to_f)).to_i
-      end
-    end
-    
-    if params[:maxwidth]
-      maxwidth = params[:maxwidth].to_i
-      
-      if width > maxwidth
-        height = (img_height.to_f / (img_width.to_f / maxwidth.to_f)).to_i
-        width = maxwidth
-      end
-    end
-    
-    if params[:maxheight]
-      maxheight = params[:maxheight].to_i
-      
-      if height > maxheight
-        width = (img_width.to_f / (img_height.to_f / maxheight.to_f)).to_i
-        height = maxheight
-      end
-    end
-    
-    if params[:width] && !params[:height]
-      height = (img_height.to_f / (img_width.to_f / width.to_f)).to_i
-    elsif params[:height] && !params[:width]
-      width = (img_width.to_f / (img_height.to_f / height.to_f)).to_i
-    elsif params[:width] && params[:height]
-      width = params[:width].to_i
-      height = params[:height].to_i
-    end
-    
-    if width != img_width || height != img_height
-      img = img.resize(width, height)
-    end
-    
-    if params[:rounded_corners]
-      img = img.clone
-      img.format = "png" # Needs PNG format for transparency.
-      args = {:img => img, :radius => params[:rounded_corners].to_i}
-      
-      if params[:border] && params[:border_color]
-        args[:border] = params[:border].to_i
-        args[:border_color] = params[:border_color]
-      end
-      
-      Knj::Image.rounded_corners(args)
-    end
-    
-    return img
-  end
-  
-  CACHENAME_FROM_PARAMS_ALLOWED_ARGS = [:params, :image, :fpath]
-  #Returns the path to a cached object based on the given filepath, image and request-parameters.
-  def cachename_from_params(args)
-    args.each do |key, val|
-      raise "Invalid argument: '#{key}'." unless CACHENAME_FROM_PARAMS_ALLOWED_ARGS.include?(key)
-    end
-    
-    params = args[:params]
-    raise "No params was given." unless params
-    
-    if args[:image] && !args[:image].filename.to_s.strip.empty?
-      name = Knj::Strings.sanitize_filename(args[:image].filename)
-    elsif args[:fpath]
-      name = Knj::Strings.sanitize_filename(args[:fpath])
-    else
-      raise "No image or fpath was given."
-    end
-    
-    name << "__ARGS__"
-    
-    PARAMS_ARGS.each do |val|
-      name += "_" unless name.empty?
-      name += "#{val}-#{params[val]}"
-    end
-    
-    return name
-  end
-  
-  FORCE_CACHE_FROM_PARAMS_ALLOWED_ARGS = [:fpath, :image, :request, :params]
-  # Checks if a cache-file is created for the given filepath or image. If not then it will be created. If the cache-object is too old, then it will updated. Then returns the path to the cache-object in the end.
-  def force_cache_from_request(args)
-    args.each do |key, val|
-      raise "Invalid argument: '#{key}'." if !FORCE_CACHE_FROM_PARAMS_ALLOWED_ARGS.include?(key)
-    end
-    
-    img = nil
-    
-    if args[:fpath] && !args[:fpath].to_s.strip.empty?
-      fpath = args[:fpath]
-    elsif args[:image] && !args[:image].filename.to_s.strip.empty?
-      fpath = args[:image].filename
-      img = args[:image]
-    else
-      raise "No image or filename was given."
-    end
-    
-    request = args[:request]
-    raise "Invalid request: '#{request.class.name}'." if !request
-    params = args[:params]
-    raise "No parameters on that request: '#{params.class.name}'." if !params
-    
-    mod_time = File.mtime(fpath)
-    cachename = self.cachename_from_params(:fpath => fpath, :params => params)
-    cachepath = "#{@args[:cache_dir]}/#{cachename}"
-    not_modified = false
-    headers = request.headers
-    
-    if !File.exists?(cachepath) || File.mtime(cachepath) < File.mtime(fpath)
-      should_generate = true
-    else
-      should_generate = false
-    end
-    
-    if should_generate
-      img = ::Magick::Image.read(fpath).first unless img
-      img.format = "png"
-      img = self.img_from_params(:image => img, :params => params)
-      img.write(cachepath)
-    else
-      if_mod_since_time = nil
-      if headers["HTTP_IF_MODIFIED_SINCE"]
-        if_mod_since_time = Datet.in(headers["HTTP_IF_MODIFIED_SINCE"]).time
-      else
-        if_mod_since_time = request.if_modified_since
-      end
-      
-      not_modified = true if if_mod_since_time && if_mod_since_time.utc.to_s == mod_time.utc.to_s
-    end
-    
-    return {
-      :cachepath => cachepath,
-      :generated => should_generate,
-      :not_modified => not_modified,
-      :mod_time => mod_time,
-    }
-  end
-  
-  HANDLE_ALLOWED_ARGS = [:fpath, :image, :controller, :params]
-  #Automatically handles the image with generation, cache control and more.
-  def handle(args)
-    args.each do |key, val|
-      raise "Invalid argument: '#{key}'." unless HANDLE_ALLOWED_ARGS.include?(key)
-    end
-    
-    controller = args[:controller]
-    raise "No controller was given." unless controller
-    request = controller.request
-    params = args[:params]
-    raise "No params was given." unless params
-    
-    if args[:image]
-      fpath = args[:image].filename
-    elsif args[:fpath]
-      fpath = args[:fpath]
-    end
-    
-    raise "No filepath was given." if !fpath
-    res = self.force_cache_from_request(:fpath => fpath, :request => request, :params => params)
-    
-    if params[:force] && params[:force] != "0"
-      force = true
-    else
-      force = false
-    end
-    
-    controller.response.headers["Last-Modified"] = res[:mod_time].httpdate
-    
-    if force
-      controller.response.headers["Expires"] = Time.now.httpdate
-    else
-      controller.response.headers["Expires"] = 2.hours.from_now.httpdate
-    end
-    
-    if res[:not_modified] && !force
-      controller.render :nothing => true, :status => "304 Not Modified"
-    else
-      controller.send_file res[:cachepath], :type => "image/png", :disposition => "inline", :filename => "picture.png"
-    end
-  end
-  
-  #Yields every cache-file to the block. If the block returns true, then the cache-file will be deleted. If no block is given all the cache will be deleted.
-  def clear_cache(&blk)
-    Dir.foreach(@args[:cache_dir]) do |file|
-      next if file == "." || file == ".."
-      fn = "#{@args[:cache_dir]}/#{file}"
-      next unless File.file?(fn)
-      
-      if blk == nil
-        res = true
-      else
-        res = yield(fn)
-      end
-      
-      File.unlink(fn) if res == true
-    end
-  end
-end