Customers used to the Java & Oracle worlds are often scared by the Ruby on Rails switch. They want to be sure that this new tool will do at least as much as the old one. This is a perfectly understandable reaction.
To do so, they regularly ask for a POC (Proof of Concept) development to confirm that a given functionality can be easily implemented using Ruby on Rails.

During one on my last meetings, the following reflexion came to my ears : "Are you sure that it will be possible to upload files in our Oracle database? I tried myself another scripting language (PHP) and I encountered many issues with BLOB!".

So here is my POC responding to this question.
I specified Oracle in the title of this article but the following Ruby code has nothing specific to this database.

First of all, we need a table and a model to store data related to our file. You'll aslo need a controller and views.
You can use the scaffold script provided by Rails to generate this structure :



Here is my migration file :

class CreateFileUploads < ActiveRecord::Migration

  def self.up

    create_table :file_uploads do |t|

      t.string :name

      t.string :content_type

      t.integer :content_size

      t.binary :content

      t.timestamps

    end

  end



  def self.down

    drop_table :file_uploads

  end

end

Note the type of the content column : binary. This will generate a BLOB field in your database during the migration :



Nothing special about the model :

class FileUpload < ActiveRecord::Base

end

You can then modify the creation form (new.html.erb) :



The form has been defined has a multipart and the content field is now a file_field.
You can then work on the create method of your controller :

def create

  @file_upload = FileUpload.new(params[:file_upload])

  if @file_upload.valid?

    @file_upload.name = params[:file_upload][:content].original_filename

    @file_upload.content = params[:file_upload][:content].read

    @file_upload.content_type = params[:file_upload][:content].content_type

    @file_upload.content_size = params[:file_upload][:content].size

    @file_upload.save

    flash[:notice] = 'FileUpload was successfully created.'

    redirect_to @file_upload

  else

    render :action => "new"

  end

end

Nothing complicated here, the params[:file_upload][:content] holds an instance of ActionController::UploadedStringIO on which you can perform various operations as reading data, get content type and size, ... All this information is then stored in the database.

In the show.html.erb page, replace the content by a download link :




Finally, insert the download method in your controller and you're done!

def download

  file = FileUpload.find(params[:id])

  if file

    send_data(file.content, :type => file.content_type , :filename => file.name)

  else

    flash[:error] = "Invalid file ID!"

    redirect_to :action => "index"

  end

end

One more time, it's very simple! The FileUpload record is extracted from the database using his ID. The associated file is then returned thanks to send_data method.

You can now save any kind of file in your Oracle database!

I have various methods providing default behaviors in the application_helper.rb file of my current project.
These methods are commons to all my controllers but some of them may decide to override this default behavior if necessary.
To do so, they can redefine the methods in their own helper.

Let's say that I have the say_hi method in application_helper.rb :

def say_hi

"Hi from ApplicationController"

end"

If I call it in the views related to my controllers 'Controller1' and 'Controller2', the text "Hi from ApplicationController" will be correctly displayed.
Now, I want to change this greeting message in the pages of Controller1. I can redefine the method say_hi in controller1_helper.rb :

def say_hi

"Hi from Controller1"

end"

Everything works fine.
But now, if I apply the same solution in controller2_helper.rb :

def say_hi

"Hi from Controller2"

end"

The message displayed in the pages of Controller2 will be correct. But on the other hand, pages of Controller1 will display "Hi from Controller2" instead of "Hi from Controller1".
This is a strange behavior, I was not excepting a such result.

This issue is caused by this sentence in your ApplicationController :

helper :all

The goal of this method is to include all custom helpers in all views.
All methods of all helpers will then be included in the current view.
Controller2 is the last one in the list (alphabetical order) so it is the last included and his 'say_hi' method will be used.

You can open the file actionpack/lib/action_controller/helpers.rb to see how it works :

def helper(*args, &block)

  args.flatten.each do |arg|

  case arg 

    when Module

      add_template_helper(arg)

    when :all

      helper(all_application_helpers)

    when String, Symbol

      file_name  = arg.to_s.underscore + '_helper'

      class_name = file_name.camelize

      

      begin

        require_dependency(file_name)

      rescue LoadError => load_error

        requiree = / -- (.*?)(.rb)?$/.match(load_error.message).to_a[1]

        if requiree == file_name

          msg = "Missing helper file helpers/#{file_name}.rb"

          raise LoadError.new(msg).copy_blame!(load_error)

        else

          raise

        end

      end

      add_template_helper(class_name.constantize)

  else

     raise ArgumentError, "helper expects String, Symbol, or Module argument (was: #{args.inspect})"

  end

end

def all_application_helpers

  extract = /^#{Regexp.quote(helpers_dir)}\/?(.*)_helper.rb$/

  Dir["#{helpers_dir}/**/*_helper.rb"].map { |file| file.sub extract, '\1' }

end

When the helper method is called with the :all parameter, it will re-invoke itself with the result of all_application_helpers as a parameter.
This method will return an array containing the names of all helpers defined in the app/helpers folder (in my case, 'application', 'controller1' and 'controller2').
The new call to the helper method will then browse each name and include the corresponding helper.

So I removed the helper :all line in my ApplicationController and everything worked fine.

But I'm wondering on the interest of this method.
Why would the methods associated to Controller2 be available in Controller1?
I have no problem against the existence of this method but it's for me a mistake to include it by default in a fresh new Rails application.

For one of my latest projects, I had to implement a "generic" controller allowing management of various types of ActiveRecord objects.
An administrator should for example be able to validate comments & links suggestions before they appear on the website.
This validation should be done through a common interface (a common controller /activations) to avoid code duplication.

Thanks to Ruby dynamic nature it was of course very easy to implement.

But the following tips helped me to achieve my goals :

The following code allows you to work with a class when his name is only known at runtime :

klass_name = "Article"

klass = Kernel.const_get(klass_name)

klass.find(:all, :order => 'created_at DESC')

It's sometimes also very useful to create/get instance variables dynamically :

var_name = "article"

instance_variable_set("@#{var_name}", klass.find(params[:id]))

instance_variable_get("@#{var_name}")

Talking about instance variables... Do you know how it is possible to access instance variables you defined in your controllers into your views?
In most frameworks, you have to specify explicitly which data you want to make available for your views.
For example, using Java and Spring, you have to create a Map object with all your data and then use this map as a parameter for the render method.
With Ruby on Rails it's done automatically and it's a good news! But how does it work?

It's very simple.
The following method is defined in the ActionView::Base class (actionpack/lib/action_view/base.rb) :

def copy_ivars_from_controller

  if @controller

    variables = @controller.instance_variable_names

    variables -= @controller.protected_instance_variables if @controller.respond_to?(:protected_instance_variables)

    variables.each { |name| instance_variable_set(name, @controller.instance_variable_get(name)) }

  end

end

... and this method will be called from the render method of your view.
What it does is simply get all the instance variables of the current controller (subtracting protected vars) and then recreate each of them in the current view using instance_variable_set.