avatar 0.0.5 → 0.2.0

data/tasks/deployment.rake

@@ -1,34 +0,0 @@
-desc 'Release the website and new gem version'
-task :deploy => [:check_version, :website, :release] do
-  puts "Remember to create SVN tag:"
-  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
-    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
-  puts "Suggested comment:"
-  puts "Tagging release #{CHANGES}"
-end
-
-desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
-task :local_deploy => [:website_generate, :install_gem]
-
-task :check_version do
-  unless ENV['VERSION']
-    puts 'Must pass a VERSION=x.y.z release version'
-    exit
-  end
-  unless ENV['VERSION'] == VERS
-    puts "Please update your version.rb to match the release version, currently #{VERS}"
-    exit
-  end
-end
-
-desc 'Install the package as a gem, without generating documentation(ri/rdoc)'
-task :install_gem_no_doc => [:clean, :package] do
-  sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri"
-end
-
-namespace :manifest do
-  desc 'Recreate Manifest.txt to include ALL files'
-  task :refresh do
-    `rake check_manifest | patch -p0 > Manifest.txt`
-  end
-end

data/tasks/environment.rake

@@ -1,7 +0,0 @@
-task :ruby_env do
-  RUBY_APP = if RUBY_PLATFORM =~ /java/
-    "jruby"
-  else
-    "ruby"
-  end unless defined? RUBY_APP
-end

data/tasks/testing.rake

@@ -1,37 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'rake/testtask'
-
-PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-
-LIB_DIRECTORIES = FileList.new do |fl|
-  fl.include "#{PROJECT_ROOT}/lib"
-  fl.include "#{PROJECT_ROOT}/test/lib/file_column/lib"
-end
-
-TEST_FILES = FileList.new do |fl|
-  fl.include "#{PROJECT_ROOT}/test/**/test_*.rb"
-  fl.exclude "#{PROJECT_ROOT}/test/test_helper.rb"
-  fl.exclude "#{PROJECT_ROOT}/test/lib/**/*.rb"
-end
-
-Rake.application.remove_task :test
-
-desc 'Run all tests'
-Rake::TestTask.new(:test) do |t|
-  t.libs = LIB_DIRECTORIES
-  t.test_files = TEST_FILES
-  t.verbose = true
-end
-
-desc "Build a code coverage report"
-task :coverage do
-  files = TEST_FILES.join(" ")
-  sh "rcov -o coverage #{files} --exclude ^/Library/Ruby/,^init.rb --include lib/ --include-file ^lib/.*\\.rb"
-end
-
-namespace :coverage do
-  task :clean do
-    rm_r 'coverage' if File.directory?('coverage')
-  end
-end

data/tasks/website.rake

@@ -1,17 +0,0 @@
-desc 'Generate website files'
-task :website_generate => :ruby_env do
-  (Dir['website/**/*.txt'] - Dir['website/version*.txt']).each do |txt|
-    sh %{ #{RUBY_APP} script/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
-  end
-end
-
-desc 'Upload website files to rubyforge'
-task :website_upload do
-  host = "#{rubyforge_username}@rubyforge.org"
-  remote_dir = "/var/www/gforge-projects/#{PATH}/"
-  local_dir = 'website'
-  sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
-end
-
-desc 'Generate and upload website files'
-task :website => [:website_generate, :website_upload, :publish_docs]

data/test/.gitignore

@@ -1,3 +0,0 @@
-# ignore the tmp and public directories used for file_column images storage:
-/public
-/tmp

data/test/lib/database.rb

@@ -1,2 +0,0 @@
-ActiveRecord::Base.configurations = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
-ActiveRecord::Base.establish_connection(ENV['DB'] || 'sqlite3')

data/test/lib/database.yml

@@ -1,10 +0,0 @@
-mysql:
-    :adapter: mysql
-    :host: localhost
-    :username: rails
-    :password:
-    :database: rails_plugin_test
-
-sqlite3:
-    :adapter: sqlite3
-    :database: ':memory:'

data/test/lib/file_column/CHANGELOG

@@ -1,69 +0,0 @@
-*svn*
-    * allow for directories in file_column dirs as well
-    * use subdirs for versions instead of fiddling with filename
-    * url_for_image_column_helper for dynamic resizing of images from views
-    * new "crop" feature [Sean Treadway]
-    * url_for_file_column helper: do not require model objects to be stored in
-      instance variables
-    * allow more fined-grained control over :store_dir via callback
-      methods [Gerret Apelt]
-    * allow assignment of regular file objects
-    * validation of file format and file size [Kyle Maxwell]
-    * validation of image dimensions [Lee O'Mara]
-    * file permissions can be set via :permissions option
-    * fixed bug that prevents deleting of file via assigning nil if
-      column is declared as NON NULL on some databases
-    * don't expand absolute paths. This is necessary for file_column to work
-      when your rails app is deployed into a sub-directory via a symbolic link
-    * url_for_*_column will no longer return absolute URLs! Instead, although the
-      generated URL starts with a slash, it will be relative to your application's
-      root URL. This is so, because rails' image_tag helper will automatically
-      convert it to an absolute URL. If you need an absolute URL (e.g., to pass
-      it to link_to) use url_for_file_column's :absolute => true option.
-    * added support for file_column enabled unit tests [Manuel Holtgrewe]
-    * support for custom transformation of images [Frederik Fix]
-    * allow setting of image attributes (e.g., quality) [Frederik Fix]
-    * :magick columns can optionally ignore non-images (i.e., do not try to
-       resize them)
-
-0.3.1
-    * make object with file_columns serializable
-    * use normal require for RMagick, so that it works with gem
-      and custom install as well
-
-0.3
-    * fixed bug where empty file uploads were not recognized with some browsers
-    * fixed bug on windows when "file" utility is not present
-    * added option to disable automatic file extension correction
-    * Only allow one attribute per call to file_column, so that options only
-      apply to one argument
-    * try to detect when people forget to set the form encoding to
-      'multipart/form-data'
-    * converted to rails plugin
-    * easy integration with RMagick
-
-0.2
-    * complete rewrite using state pattern
-    * fixed sanitize filename [Michael Raidel]
-    * fixed bug when no file was uploaded [Michael Raidel]
-    * try to fix filename extensions [Michael Raidel]
-    * Feed absolute paths through File.expand_path to make them as simple as possible
-    * Make file_column_field helper work with auto-ids (e.g., "event[]")
-
-0.1.3
-    * test cases with more than 1 file_column
-    * fixed bug when file_column was called with several arguments
-    * treat empty ("") file_columns as nil
-    * support for binary files on windows
-
-0.1.2
-    * better rails integration, so that you do not have to include the modules yourself. You
-      just have to "require 'rails_file_column'" in your "config/environment.rb"
-    * Rakefile for testing and packaging
-
-0.1.1 (2005-08-11)
-    * fixed nasty bug in url_for_file_column that made it unusable on Apache
-    * prepared for public release
-    
-0.1 (2005-08-10)
-    * initial release

data/test/lib/file_column/README

@@ -1,54 +0,0 @@
-FEATURES
-========
-
-Let's assume an model class named Entry, where we want to define the "image" column
-as a "file_upload" column.
-
-class Entry < ActiveRecord::Base
-  file_column :image
-end
-
-* every entry can have one uploaded file, the filename will be stored in the "image" column
-
-* files will be stored in "public/entry/image/<entry.id>/filename.ext"
-
-* Newly uploaded files will be stored in "public/entry/tmp/<random>/filename.ext" so that
-  they can be reused in form redisplays (due to validation etc.)
-
-* in a view, "<%= file_column_field 'entry', 'image' %> will create a file upload field as well
-  as a hidden field to recover files uploaded before in a case of a form redisplay
-
-* in a view, "<%= url_for_file_column 'entry', 'image' %> will create an URL to access the
-  uploaded file. Note that you need an Entry object in the instance variable @entry for this
-  to work.
-
-* easy integration with RMagick to resize images and/or create thumb-nails.
-
-USAGE
-=====
-
-Just drop the whole directory into your application's "vendor/plugins" directory. Starting
-with version 1.0rc of rails, it will be automatically picked for you by rails plugin
-mechanism.
-
-DOCUMENTATION
-=============
-
-Please look at the rdoc-generated documentation in the "doc" directory.
-
-RUNNING UNITTESTS
-=================
-
-There are extensive unittests in the "test" directory. Currently, only MySQL is supported, but
-you should be able to easily fix this by looking at "connection.rb". You have to create a
-database for the tests and put the connection information into "connection.rb". The schema
-for MySQL can be found in "test/fixtures/mysql.sql".
-
-You can run the tests by starting the "*_test.rb" in the directory "test"
-
-BUGS & FEEDBACK
-===============
-
-Bug reports (as well as patches) and feedback are very welcome. Please send it to
-sebastian.kanthak@muehlheim.de
-

data/test/lib/file_column/Rakefile

@@ -1,36 +0,0 @@
-task :default => [:test]
-
-PKG_NAME = "file-column"
-PKG_VERSION = "0.3.1"
-
-PKG_DIR = "release/#{PKG_NAME}-#{PKG_VERSION}"
-
-task :clean do
-  rm_rf "release"
-end
-
-task :setup_directories do
-  mkpath "release"
-end
-
-
-task :checkout_release => :setup_directories do
-  rm_rf PKG_DIR
-  revision = ENV["REVISION"] || "HEAD"
-  sh "svn export -r #{revision} . #{PKG_DIR}"
-end
-
-task :release_docs => :checkout_release do
-  sh "cd #{PKG_DIR}; rdoc lib"
-end
-
-task :package => [:checkout_release, :release_docs] do
-  sh "cd release; tar czf #{PKG_NAME}-#{PKG_VERSION}.tar.gz #{PKG_NAME}-#{PKG_VERSION}"
-end
-
-task :test do
-  sh "cd test; ruby file_column_test.rb"
-  sh "cd test; ruby file_column_helper_test.rb"
-  sh "cd test; ruby magick_test.rb"
-  sh "cd test; ruby magick_view_only_test.rb"
-end

data/test/lib/file_column/TODO

@@ -1,6 +0,0 @@
-* document configuration options better
-* support setting of permissions
-* validation methods for file format/size
-* delete stale files from tmp directories
-
-* ensure valid URLs are created even when deployed at sub-path (compute_public_url?)

data/test/lib/file_column/init.rb

@@ -1,13 +0,0 @@
-# plugin init file for rails
-# this file will be picked up by rails automatically and
-# add the file_column extensions to rails
-
-require 'file_column'
-require 'file_compat'
-require 'file_column_helper'
-require 'validations'
-#require 'test_case' if RAILS_ENV == 'test'
-
-ActiveRecord::Base.send(:include, FileColumn)
-ActionView::Base.send(:include, FileColumnHelper)
-ActiveRecord::Base.send(:include, FileColumn::Validations)

data/test/lib/file_column/lib/file_column.rb

@@ -1,720 +0,0 @@
-require 'fileutils'
-require 'tempfile'
-require 'magick_file_column'
-
-module FileColumn # :nodoc:
-  def self.append_features(base)
-    super
-    base.extend(ClassMethods)
-  end
-
-  def self.create_state(instance,attr)
-    filename = instance[attr]
-    if filename.nil? or filename.empty?
-      NoUploadedFile.new(instance,attr)
-    else
-      PermanentUploadedFile.new(instance,attr)
-    end
-  end
-
-  def self.init_options(defaults, model, attr)
-    options = defaults.dup
-    options[:store_dir] ||= File.join(options[:root_path], model, attr)
-    unless options[:store_dir].is_a?(Symbol)
-      options[:tmp_base_dir] ||= File.join(options[:store_dir], "tmp")
-    end
-    options[:base_url] ||= options[:web_root] + File.join(model, attr)
-
-    [:store_dir, :tmp_base_dir].each do |dir_sym|
-      if options[dir_sym].is_a?(String) and !File.exists?(options[dir_sym])
-        FileUtils.mkpath(options[dir_sym])
-      end
-    end
-
-    options
-  end
-
-  class BaseUploadedFile # :nodoc:
-
-    def initialize(instance,attr)
-      @instance, @attr = instance, attr
-      @options_method = "#{attr}_options".to_sym
-    end
-
-
-    def assign(file)
-      if file.is_a? File
-        # this did not come in via a CGI request. However,
-        # assigning files directly may be useful, so we
-        # make just this file object similar enough to an uploaded
-        # file that we can handle it. 
-        file.extend FileColumn::FileCompat
-      end
-
-      if file.nil?
-        delete
-      else
-        if file.size == 0
-          # user did not submit a file, so we
-          # can simply ignore this
-          self
-        else
-          if file.is_a?(String)
-            # if file is a non-empty string it is most probably
-            # the filename and the user forgot to set the encoding
-            # to multipart/form-data. Since we would raise an exception
-            # because of the missing "original_filename" method anyways,
-            # we raise a more meaningful exception rightaway.
-            raise TypeError.new("Do not know how to handle a string with value '#{file}' that was passed to a file_column. Check if the form's encoding has been set to 'multipart/form-data'.")
-          end
-          upload(file)
-        end
-      end
-    end
-
-    def just_uploaded?
-      @just_uploaded
-    end
-
-    def on_save(&blk)
-      @on_save ||= []
-      @on_save << Proc.new
-    end
-    
-    # the following methods are overriden by sub-classes if needed
-
-    def temp_path
-      nil
-    end
-
-    def absolute_dir
-      if absolute_path then File.dirname(absolute_path) else nil end
-    end
-
-    def relative_dir
-      if relative_path then File.dirname(relative_path) else nil end
-    end
-
-    def after_save
-      @on_save.each { |blk| blk.call } if @on_save
-      self
-    end
-
-    def after_destroy
-    end
-
-    def options
-      @instance.send(@options_method)
-    end
-
-    private
-    
-    def store_dir
-      if options[:store_dir].is_a? Symbol
-        raise ArgumentError.new("'#{options[:store_dir]}' is not an instance method of class #{@instance.class.name}") unless @instance.respond_to?(options[:store_dir])
-
-        dir = File.join(options[:root_path], @instance.send(options[:store_dir]))
-        FileUtils.mkpath(dir) unless File.exists?(dir)
-        dir
-      else 
-        options[:store_dir]
-      end
-    end
-
-    def tmp_base_dir
-      if options[:tmp_base_dir]
-        options[:tmp_base_dir] 
-      else
-        dir = File.join(store_dir, "tmp")
-        FileUtils.mkpath(dir) unless File.exists?(dir)
-        dir
-      end
-    end
-
-    def clone_as(klass)
-      klass.new(@instance, @attr)
-    end
-
-  end
-    
-
-  class NoUploadedFile < BaseUploadedFile # :nodoc:
-    def delete
-      # we do not have a file so deleting is easy
-      self
-    end
-
-    def upload(file)
-      # replace ourselves with a TempUploadedFile
-      temp = clone_as TempUploadedFile
-      temp.store_upload(file)
-      temp
-    end
-
-    def absolute_path(subdir=nil)
-      nil
-    end
-
-
-    def relative_path(subdir=nil)
-      nil
-    end
-
-    def assign_temp(temp_path)
-      return self if temp_path.nil? or temp_path.empty?
-      temp = clone_as TempUploadedFile
-      temp.parse_temp_path temp_path
-      temp
-    end
-  end
-
-  class RealUploadedFile < BaseUploadedFile # :nodoc:
-    def absolute_path(subdir=nil)
-      if subdir
-        File.join(@dir, subdir, @filename)
-      else
-        File.join(@dir, @filename)
-      end
-    end
-
-    def relative_path(subdir=nil)
-      if subdir
-        File.join(relative_path_prefix, subdir, @filename)
-      else
-        File.join(relative_path_prefix, @filename)
-      end
-    end
-
-    private
-
-    # regular expressions to try for identifying extensions
-    EXT_REGEXPS = [ 
-      /^(.+)\.([^.]+\.[^.]+)$/, # matches "something.tar.gz"
-      /^(.+)\.([^.]+)$/ # matches "something.jpg"
-    ]
-
-    def split_extension(filename,fallback=nil)
-      EXT_REGEXPS.each do |regexp|
-        if filename =~ regexp
-          base,ext = $1, $2
-          return [base, ext] if options[:extensions].include?(ext.downcase)
-        end
-      end
-      if fallback and filename =~ EXT_REGEXPS.last
-        return [$1, $2]
-      end
-      [filename, ""]
-    end
-    
-  end
-
-  class TempUploadedFile < RealUploadedFile # :nodoc:
-
-    def store_upload(file)
-      @tmp_dir = FileColumn.generate_temp_name
-      @dir = File.join(tmp_base_dir, @tmp_dir)      
-      FileUtils.mkdir(@dir)
-      
-      @filename = FileColumn::sanitize_filename(file.original_filename)
-      local_file_path = File.join(tmp_base_dir,@tmp_dir,@filename)
-      
-      # stored uploaded file into local_file_path
-      # If it was a Tempfile object, the temporary file will be
-      # cleaned up automatically, so we do not have to care for this
-      if file.respond_to?(:local_path) and file.local_path and File.exists?(file.local_path)
-        FileUtils.copy_file(file.local_path, local_file_path)
-      elsif file.respond_to?(:read)
-        File.open(local_file_path, "wb") { |f| f.write(file.read) }
-      else
-        raise ArgumentError.new("Do not know how to handle #{file.inspect}")
-      end
-      File.chmod(options[:permissions], local_file_path)
-      
-      if options[:fix_file_extensions]
-        # try to determine correct file extension and fix
-        # if necessary
-        content_type = get_content_type((file.content_type.chomp if file.content_type))
-        if content_type and options[:mime_extensions][content_type]
-          @filename = correct_extension(@filename,options[:mime_extensions][content_type])
-        end
-
-        new_local_file_path = File.join(tmp_base_dir,@tmp_dir,@filename)
-        File.rename(local_file_path, new_local_file_path) unless new_local_file_path == local_file_path
-        local_file_path = new_local_file_path
-      end
-      
-      @instance[@attr] = @filename
-      @just_uploaded = true
-    end
-
-
-    # tries to identify and strip the extension of filename
-    # if an regular expresion from EXT_REGEXPS matches and the
-    # downcased extension is a known extension (in options[:extensions])
-    # we'll strip this extension
-    def strip_extension(filename)
-      split_extension(filename).first
-    end
-
-    def correct_extension(filename, ext)
-      strip_extension(filename) << ".#{ext}"
-    end
-    
-    def parse_temp_path(temp_path, instance_options=nil)
-      raise ArgumentError.new("invalid format of '#{temp_path}'") unless temp_path =~ %r{^((\d+\.)+\d+)/([^/].+)$}
-      @tmp_dir, @filename = $1, FileColumn.sanitize_filename($3)
-      @dir = File.join(tmp_base_dir, @tmp_dir)
-
-      @instance[@attr] = @filename unless instance_options == :ignore_instance
-    end
-    
-    def upload(file)
-      # store new file
-      temp = clone_as TempUploadedFile
-      temp.store_upload(file)
-      
-      # delete old copy
-      delete_files
-
-      # and return new TempUploadedFile object
-      temp
-    end
-
-    def delete
-      delete_files
-      @instance[@attr] = ""
-      clone_as NoUploadedFile
-    end
-
-    def assign_temp(temp_path)
-      return self if temp_path.nil? or temp_path.empty?
-      # we can ignore this since we've already received a newly uploaded file
-
-      # however, we delete the old temporary files
-      temp = clone_as TempUploadedFile
-      temp.parse_temp_path(temp_path, :ignore_instance)
-      temp.delete_files
-
-      self
-    end
-
-    def temp_path
-      File.join(@tmp_dir, @filename)
-    end
-
-    def after_save
-      super
-
-      # we have a newly uploaded image, move it to the correct location
-      file = clone_as PermanentUploadedFile
-      file.move_from(File.join(tmp_base_dir, @tmp_dir), @just_uploaded)
-
-      # delete temporary files
-      delete_files
-
-      # replace with the new PermanentUploadedFile object
-      file
-    end
-
-    def delete_files
-      FileUtils.rm_rf(File.join(tmp_base_dir, @tmp_dir))
-    end
-
-    def get_content_type(fallback=nil)
-      if options[:file_exec]
-        begin
-          content_type = `#{options[:file_exec]} -bi "#{File.join(@dir,@filename)}"`.chomp
-          content_type = fallback unless $?.success?
-          content_type.gsub!(/;.+$/,"") if content_type
-          content_type
-        rescue
-          fallback
-        end
-      else
-        fallback
-      end
-    end
-
-    private
-
-    def relative_path_prefix
-      File.join("tmp", @tmp_dir)
-    end
-  end
-
-  
-  class PermanentUploadedFile < RealUploadedFile # :nodoc:
-    def initialize(*args)
-      super *args
-      @dir = File.join(store_dir, relative_path_prefix)
-      @filename = @instance[@attr]
-      @filename = nil if @filename.empty?
-    end
-
-    def move_from(local_dir, just_uploaded)
-      # remove old permament dir first
-      # this creates a short moment, where neither the old nor
-      # the new files exist but we can't do much about this as
-      # filesystems aren't transactional.
-      FileUtils.rm_rf @dir
-
-      FileUtils.mv local_dir, @dir
-
-      @just_uploaded = just_uploaded
-    end
-
-    def upload(file)
-      temp = clone_as TempUploadedFile
-      temp.store_upload(file)
-      temp
-    end
-
-    def delete
-      file = clone_as NoUploadedFile
-      @instance[@attr] = ""
-      file.on_save { delete_files }
-      file
-    end
-
-    def assign_temp(temp_path)
-      return nil if temp_path.nil? or temp_path.empty?
-
-      temp = clone_as TempUploadedFile
-      temp.parse_temp_path(temp_path)
-      temp
-    end
-
-    def after_destroy
-      delete_files
-    end
-
-    def delete_files
-      FileUtils.rm_rf @dir
-    end
-
-    private
-    
-    def relative_path_prefix
-      raise RuntimeError.new("Trying to access file_column, but primary key got lost.") if @instance.id.to_s.empty?
-      @instance.id.to_s
-    end
-  end
-    
-  # The FileColumn module allows you to easily handle file uploads. You can designate
-  # one or more columns of your model's table as "file columns" like this:
-  #
-  #   class Entry < ActiveRecord::Base
-  #
-  #     file_column :image
-  #   end
-  #
-  # Now, by default, an uploaded file "test.png" for an entry object with primary key 42 will
-  # be stored in in "public/entry/image/42/test.png". The filename "test.png" will be stored
-  # in the record's "image" column. The "entries" table should have a +VARCHAR+ column
-  # named "image".
-  #
-  # The methods of this module are automatically included into <tt>ActiveRecord::Base</tt>
-  # as class methods, so that you can use them in your models.
-  #
-  # == Generated Methods
-  #
-  # After calling "<tt>file_column :image</tt>" as in the example above, a number of instance methods
-  # will automatically be generated, all prefixed by "image":
-  #
-  # * <tt>Entry#image=(uploaded_file)</tt>: this will handle a newly uploaded file
-  #   (see below). Note that
-  #   you can simply call your upload field "entry[image]" in your view (or use the
-  #   helper).
-  # * <tt>Entry#image(subdir=nil)</tt>: This will return an absolute path (as a
-  #   string) to the currently uploaded file
-  #   or nil if no file has been uploaded
-  # * <tt>Entry#image_relative_path(subdir=nil)</tt>: This will return a path relative to
-  #   this file column's base directory
-  #   as a string or nil if no file has been uploaded. This would be "42/test.png" in the example.
-  # * <tt>Entry#image_just_uploaded?</tt>: Returns true if a new file has been uploaded to this instance.
-  #   You can use this in your code to perform certain actions (e. g., validation,
-  #   custom post-processing) only on newly uploaded files.
-  #
-  # You can access the raw value of the "image" column (which will contain the filename) via the
-  # <tt>ActiveRecord::Base#attributes</tt> or <tt>ActiveRecord::Base#[]</tt> methods like this:
-  #
-  #   entry['image']    # e.g."test.png"
-  #
-  # == Storage of uploaded files
-  #
-  # For a model class +Entry+ and a column +image+, all files will be stored under
-  # "public/entry/image". A sub-directory named after the primary key of the object will
-  # be created, so that files can be stored using their real filename. For example, a file
-  # "test.png" stored in an Entry object with id 42 will be stored in
-  #
-  #   public/entry/image/42/test.png
-  #
-  # Files will be moved to this location in an +after_save+ callback. They will be stored in
-  # a temporary location previously as explained in the next section.
-  #
-  # By default, files will be created with unix permissions of <tt>0644</tt> (i. e., owner has
-  # read/write access, group and others only have read access). You can customize
-  # this by passing the desired mode as a <tt>:permissions</tt> options. The value
-  # you give here is passed directly to <tt>File::chmod</tt>, so on Unix you should
-  # give some octal value like 0644, for example.
-  #
-  # == Handling of form redisplay
-  #
-  # Suppose you have a form for creating a new object where the user can upload an image. The form may
-  # have to be re-displayed because of validation errors. The uploaded file has to be stored somewhere so
-  # that the user does not have to upload it again. FileColumn will store these in a temporary directory
-  # (called "tmp" and located under the column's base directory by default) so that it can be moved to
-  # the final location if the object is successfully created. If the form is never completed, though, you
-  # can easily remove all the images in this "tmp" directory once per day or so.
-  #
-  # So in the example above, the image "test.png" would first be stored in 
-  # "public/entry/image/tmp/<some_random_key>/test.png" and be moved to
-  # "public/entry/image/<primary_key>/test.png".
-  #
-  # This temporary location of newly uploaded files has another advantage when updating objects. If the
-  # update fails for some reasons (e.g. due to validations), the existing image will not be overwritten, so
-  # it has a kind of "transactional behaviour".
-  #
-  # == Additional Files and Directories
-  #
-  # FileColumn allows you to keep more than one file in a directory and will move/delete
-  # all the files and directories it finds in a model object's directory when necessary.
-  #
-  # As a convenience you can access files stored in sub-directories via the +subdir+
-  # parameter if they have the same filename.
-  #
-  # Suppose your uploaded file is named "vancouver.jpg" and you want to create a
-  # thumb-nail and store it in the "thumb" directory. If you call
-  # <tt>image("thumb")</tt>, you
-  # will receive an absolute path for the file "thumb/vancouver.jpg" in the same
-  # directory "vancouver.jpg" is stored. Look at the documentation of FileColumn::Magick
-  # for more examples and how to create these thumb-nails automatically.
-  #
-  # == File Extensions
-  #
-  # FileColumn will try to fix the file extension of uploaded files, so that
-  # the files are served with the correct mime-type by your web-server. Most
-  # web-servers are setting the mime-type based on the file's extension. You
-  # can disable this behaviour by passing the <tt>:fix_file_extensions</tt> option
-  # with a value of +nil+ to +file_column+.
-  #
-  # In order to set the correct extension, FileColumn tries to determine
-  # the files mime-type first. It then uses the +MIME_EXTENSIONS+ hash to
-  # choose the corresponding file extension. You can override this hash
-  # by passing in a <tt>:mime_extensions</tt> option to +file_column+.
-  #
-  # The mime-type of the uploaded file is determined with the following steps:
-  #
-  # 1. Run the external "file" utility. You can specify the full path to
-  #    the executable in the <tt>:file_exec</tt> option or set this option
-  #    to +nil+ to disable this step
-  #
-  # 2. If the file utility couldn't determine the mime-type or the utility was not
-  #    present, the content-type provided by the user's browser is used
-  #    as a fallback.
-  #
-  # == Custom Storage Directories
-  #
-  # FileColumn's storage location is determined in the following way. All
-  # files are saved below the so-called "root_path" directory, which defaults to
-  # "RAILS_ROOT/public". For every file_column, you can set a separte "store_dir"
-  # option. It defaults to "model_name/attribute_name".
-  # 
-  # Files will always be stored in sub-directories of the store_dir path. The
-  # subdirectory is named after the instance's +id+ attribute for a saved model,
-  # or "tmp/<randomkey>" for unsaved models.
-  #
-  # You can specify a custom root_path by setting the <tt>:root_path</tt> option.
-  # 
-  # You can specify a custom storage_dir by setting the <tt>:storage_dir</tt> option.
-  #
-  # For setting a static storage_dir that doesn't change with respect to a particular
-  # instance, you assign <tt>:storage_dir</tt> a String representing a directory
-  # as an absolute path.
-  #
-  # If you need more fine-grained control over the storage directory, you
-  # can use the name of a callback-method as a symbol for the
-  # <tt>:store_dir</tt> option. This method has to be defined as an
-  # instance method in your model. It will be called without any arguments
-  # whenever the storage directory for an uploaded file is needed. It should return
-  # a String representing a directory relativeo to root_path.
-  #
-  # Uploaded files for unsaved models objects will be stored in a temporary
-  # directory. By default this directory will be a "tmp" directory in
-  # your <tt>:store_dir</tt>. You can override this via the
-  # <tt>:tmp_base_dir</tt> option.
-  module ClassMethods
-
-    # default mapping of mime-types to file extensions. FileColumn will try to
-    # rename a file to the correct extension if it detects a known mime-type
-    MIME_EXTENSIONS = {
-      "image/gif" => "gif",
-      "image/jpeg" => "jpg",
-      "image/pjpeg" => "jpg",
-      "image/x-png" => "png",
-      "image/jpg" => "jpg",
-      "image/png" => "png",
-      "application/x-shockwave-flash" => "swf",
-      "application/pdf" => "pdf",
-      "application/pgp-signature" => "sig",
-      "application/futuresplash" => "spl",
-      "application/msword" => "doc",
-      "application/postscript" => "ps",
-      "application/x-bittorrent" => "torrent",
-      "application/x-dvi" => "dvi",
-      "application/x-gzip" => "gz",
-      "application/x-ns-proxy-autoconfig" => "pac",
-      "application/x-shockwave-flash" => "swf",
-      "application/x-tgz" => "tar.gz",
-      "application/x-tar" => "tar",
-      "application/zip" => "zip",
-      "audio/mpeg" => "mp3",
-      "audio/x-mpegurl" => "m3u",
-      "audio/x-ms-wma" => "wma",
-      "audio/x-ms-wax" => "wax",
-      "audio/x-wav" => "wav",
-      "image/x-xbitmap" => "xbm",             
-      "image/x-xpixmap" => "xpm",             
-      "image/x-xwindowdump" => "xwd",             
-      "text/css" => "css",             
-      "text/html" => "html",                          
-      "text/javascript" => "js",
-      "text/plain" => "txt",
-      "text/xml" => "xml",
-      "video/mpeg" => "mpeg",
-      "video/quicktime" => "mov",
-      "video/x-msvideo" => "avi",
-      "video/x-ms-asf" => "asf",
-      "video/x-ms-wmv" => "wmv"
-    }
-
-    EXTENSIONS = Set.new MIME_EXTENSIONS.values
-    EXTENSIONS.merge %w(jpeg)
-
-    # default options. You can override these with +file_column+'s +options+ parameter
-    DEFAULT_OPTIONS = {
-      :root_path => File.join(RAILS_ROOT, "public"),
-      :web_root => "",
-      :mime_extensions => MIME_EXTENSIONS,
-      :extensions => EXTENSIONS,
-      :fix_file_extensions => true,
-      :permissions => 0644,
-
-      # path to the unix "file" executbale for
-      # guessing the content-type of files
-      :file_exec => "file" 
-    }
-    
-    # handle the +attr+ attribute as a "file-upload" column, generating additional methods as explained
-    # above. You should pass the attribute's name as a symbol, like this:
-    #
-    #   file_column :image
-    #
-    # You can pass in an options hash that overrides the options
-    # in +DEFAULT_OPTIONS+.
-    def file_column(attr, options={})
-      options = DEFAULT_OPTIONS.merge(options) if options
-      
-      my_options = FileColumn::init_options(options, 
-                                            Inflector.underscore(self.name).to_s,
-                                            attr.to_s)
-      
-      state_attr = "@#{attr}_state".to_sym
-      state_method = "#{attr}_state".to_sym
-      
-      define_method state_method do
-        result = instance_variable_get state_attr
-        if result.nil?
-          result = FileColumn::create_state(self, attr.to_s)
-          instance_variable_set state_attr, result
-        end
-        result
-      end
-      
-      private state_method
-      
-      define_method attr do |*args|
-        send(state_method).absolute_path *args
-      end
-      
-      define_method "#{attr}_relative_path" do |*args|
-        send(state_method).relative_path *args
-      end
-
-      define_method "#{attr}_dir" do
-        send(state_method).absolute_dir
-      end
-
-      define_method "#{attr}_relative_dir" do
-        send(state_method).relative_dir
-      end
-
-      define_method "#{attr}=" do |file|
-        state = send(state_method).assign(file)
-        instance_variable_set state_attr, state
-        if state.options[:after_upload] and state.just_uploaded?
-          state.options[:after_upload].each do |sym|
-            self.send sym
-          end
-        end
-      end
-      
-      define_method "#{attr}_temp" do
-        send(state_method).temp_path
-      end
-      
-      define_method "#{attr}_temp=" do |temp_path|
-        instance_variable_set state_attr, send(state_method).assign_temp(temp_path)
-      end
-      
-      after_save_method = "#{attr}_after_save".to_sym
-      
-      define_method after_save_method do
-        instance_variable_set state_attr, send(state_method).after_save
-      end
-      
-      after_save after_save_method
-      
-      after_destroy_method = "#{attr}_after_destroy".to_sym
-      
-      define_method after_destroy_method do
-        send(state_method).after_destroy
-      end
-      after_destroy after_destroy_method
-      
-      define_method "#{attr}_just_uploaded?" do
-        send(state_method).just_uploaded?
-      end
-
-      # this creates a closure keeping a reference to my_options
-      # right now that's the only way we store the options. We
-      # might use a class attribute as well
-      define_method "#{attr}_options" do
-        my_options
-      end
-
-      private after_save_method, after_destroy_method
-
-      FileColumn::MagickExtension::file_column(self, attr, my_options) if options[:magick]
-    end
-    
-  end
-  
-  private
-  
-  def self.generate_temp_name
-    now = Time.now
-    "#{now.to_i}.#{now.usec}.#{Process.pid}"
-  end
-  
-  def self.sanitize_filename(filename)
-    filename = File.basename(filename.gsub("\\", "/")) # work-around for IE
-    filename.gsub!(/[^a-zA-Z0-9\.\-\+_]/,"_")
-    filename = "_#{filename}" if filename =~ /^\.+$/
-    filename = "unnamed" if filename.size == 0
-    filename
-  end
-  
-end
-
-