p{border: solid 1px silver; padding: 5px;}. See also the Rails cookbook: "Sending and receiving files":http://manuals.rubyonrails.com/read/chapter/56 The form part of the "new" template:


  
    Name:

    <%= text_field "person", "name" %>
  

  
    Picture:

The controller:

class AddressbookController < ApplicationController
  def new
    # not really needed since the template doesn't rely on any data
  end

  def create
    post = Post.save(@params["person"])
    redirect_to :action => "show", :id => post.id
  end
end

The model:

class Post < ActiveRecord::Base
  def self.save(person)
    File.open("pictures/#{person['name']}/picture.jpg", "w") { |f| f.write(person['picture'].read) }
  end
end

To get the original name of the uploaded file, use person['picture'].original_filename. There is also a person['picture'].content_type method. (These are buried somewhere in the depths of cgi.rb) *Note for Windows:* to avoid corrupting binary files, you must call File.open in binary mode. Change the "w" flag to "wb", like this:

File.open("pictures/#{person['name']}/picture.jpg", "wb") { |f| f.write(person['picture'].read) }

*truncated files?* If you have trouble with zero-length files written by this code, try calling

person['picture'].rewind

before writing the file. *Files uploaded from Internet Explorer* Internet Explorer prepends the original path of a file to the filename sent, so the original_filename routine will return something like C:\Documents and Files\user_name\Pictures\My File.jpg instead of just My File.jpg. To deal with this, make sure you write a sanitize method, perhaps called via :before_save, to remove the path and any illegal characters from the filename. An example sanitize method (this is not perfect!):

private
    def sanitize_filename(value)
        # get only the filename, not the whole path
        just_filename = File.basename(value.gsub('\\\\', '/')) 
        # replace all none alphanumeric, underscore or periods with underscore
        @filename = just_filename.gsub(/[^\w\.\-]/,'_') 
    end

h2. CGI class documentation h3. From the "CGI class documentation":http://www.ruby-doc.org/stdlib/libdoc/cgi/rdoc/classes/CGI.html

Multipart requests
If a request’s method is POST and its content type is multipart/form-data, then it may contain uploaded files. These are stored by the \QueryExtension module in the parameters of the request. The parameter name is the name attribute of the file input field, as usual. However, the value is not a string, but an IO object, either an IOString for small files, or a Tempfile for larger ones. This object also has the additional singleton methods:

local_path():
the path of the uploaded file on the local filesystem

original_filename():
the name of the file on the client computer

content_type():
the content type of the file

h2. How to upload files directly into the database *The view* is almost the same as above, but I changed the field's name to @tmp_file@ since it's not going to be stored anywhere permanently. *The model* for me is just the plain model without any specific methods at the moment. Oh and the field 'picture' in the DB should be a binary field (for example BLOB in \MySQL) *The controller*:

def create
  @params['person']['filename'] = @params['person']['tmp_file'].original_filename.gsub(/[^a-zA-Z0-9.]/, '_') # This makes sure filenames are sane
  @params['person']['picture'] = @params['person']['tmp_file'].read
  @params['person'].delete('tmp_file') # let's remove the field from the hash, because there's no such field in the DB anyway.
  @person = Person.new(@params['person'])
  # then the basic if @person.save ... like in TutorialFramingOut

%{color:blue}In the above, the file contents gets inserted into the hash as a string - ie. it's read to memory. Is that the best we can do? Can we not pass a file-reference or similar and via that get the file contents streamed from the filesystem to the DB?% h2. How to download files from the database Here's a piece of code that'll help you download the picture from the DB directly (modified from HowtoSendFiles rev=1)

  @entry = Person.find(@params['id'])
  @response.headers['Pragma'] = ' '
  @response.headers['Cache-Control'] = ' '
  @response.headers['Content-type'] = 'application/octet-stream'
  @response.headers['Content-Disposition'] = "attachment; filename=#{@person.filename}" 
  @response.headers['Accept-Ranges'] = 'bytes'
  @response.headers['Content-Length'] = @person.picture.length
  @response.headers['Content-Transfer-Encoding'] = 'binary'
  @response.headers['Content-Description'] = 'File Transfer'
  render_text @person.picture

Alternately, you can do the much simpler:

  @person = Person.find(@params['id'])
  send_data @person.picture, :filename => @person.filename, :type => "image/jpeg"

If you want to display the image inline (ie, in a page), use this send_data instead:

  send_data @person.picture, :filename => @person.filename, :type => "image/jpeg", :disposition => "inline"

Here's the api documentation for "send_file":http://rails.rubyonrails.com/classes/ActionController/Base.html#M000089 and "send_data":http://rails.rubyonrails.com/classes/ActionController/Base.html#M000090 [This stuff won't work in lighttpd due to a bug in lighttpd and file uploads. That was many versions ago, however. It may work now. --[[what-a-day|what-a-day]]] h2. File save variation The uploaded file will be a "TempFile":http://www.ruby-doc.org/core/classes/Tempfile.html -like object (if over 10kb in size). These can be copied by the filesystem instead of being read and processed through Ruby.

  def picture=(picture)
    FileUtils.copy picture.local_path, "pictures/#{name}/picture.jpg"
  end

h2. Using caching to reduce database load and bandwidth usage See HowtoUseHTTPCaching h2. Checking that the user provided a file: This can be done via picture.size == 0 h2. Uploading files to a SQLite database You can't store things with null bytes into BLOBs yet. Until the "new adapter":http://www.jamisbuck.org/jamis/blog.cgi/programming/ruby is out, use Base64 or some similar binary->ascii coding system to make it not contain null bytes. h2. Testing a file upload In order to test a file being uploaded you have to mirror what cgi.rb is doing with a multipart post. Unfortunately what it does is quite long and complex, this code takes a file on your system, and turns it into what normally comes out of cgi.rb. Obviously ymmv with the methods


  def uploaded_file(path, content_type, filename)
    t = Tempfile.new(filename);
    FileUtils.copy_file(path, t.path)
    (class << t; self; end).class_eval do
      alias local_path path
      define_method(:original_filename) {filename}
      define_method(:content_type) {content_type}
    end
    return t
  end

Usage:

 
uploaded_file("#{File.expand_path(RAILS_ROOT)}/test/mocks/testing/stock.jpg", 'image/jpeg', 'stock.jpg')

h2. Another approach There is another example at http://www.albert.bagasie.com/RailsTips h2. Mime-types No mention of mime-types here. You could try the "MIME::Types":http://www.halostatue.ca/ruby/MIME__Types.html library for Ruby category:Howto