**'' code. -If you absolutely need to use ''**javascript_tags(remote_function())**'', be careful not to retrieve content that contains the code ''****'', or your remote_function call will never properly finish... -''**remote_function**'' does seem to work properly using the :with option. So do use it to encode a selectbox or checkbox option. Here's an example of a checkbox that submits its "content" immediately to a remote method:


<%= check_box(
              "game", 
              "active", 
              :id => 'game_active_'+ @game.uid.to_s,
              :onchange => remote_function(
                :update => "test",
                :url => { :action => :activate_game },
                :with => "'id=#{@game.uid.to_s}&active='+ (
		                                 (this.checked) ? '1' : '0')"
              )) %>

The :with option allows you to use javascript to create (url query) strings. Be careful with your javascript here. Use brackets to define the scope. In the example above, if you leave out the highlighted brackets, the //active// parameter will not be submitted, and there will be no javascript warning! Here's another example, this one using a ''**condition**'' parameter for the ''**observe_field**'' method invocation. The condition should contain javascript code, but really only the condition part.


<%= observe_field(:user_license_id,
                  :update => 'dates',                  
                  :with => "id", 
                  :condition => "!($(user_protect_startenddates).checked)",               
                  :url => {:action => :refresh_dates},
                  :on => "click" ) %>

This code updates a DOM node called 'dates', but only if the checkbox 'user_protect_startenddates' has not been checked. ==== Watch where you update to: container troubles ==== Ruby on Rails uses prototype.js for ajax. Prototype updates your DOM using ''**innerHTML**''. This is usually cool, but not everywhere and always, especially not in MS IE (versions 6 and 7 that I know of). Consider this example: (Do not use the following code)


    
      
            
          Student
          
            Project:
            <%= select("result", "projects", Project.find(:all, :conditions => ['deleted = 0 AND hidden = 0']).collect {|p| [ p.label, p.uid ] }, { :prompt => " [Student's current project] ", :order => :label }) %>                
          
          Score    
        
            
      
        
          Generic content

Student	Project: <%= select("result", "projects", Project.find(:all, :conditions => ['deleted = 0 AND hidden = 0']).collect {\|p\| [ p.label, p.uid ] }, { :prompt => " [Student's current project] ", :order => :label }) %>	Score
Generic content

(Do not use the above code) The idea here was to generate the content for ''**results_container**'' on the server and then send it back using Rails/Ajax. All went well on our trusted browser Firefox, but MS IE 6 and 7 fail miserably here. Apparently MS IE does not allow you to expand the content of a ''**tbody**'' element using innerHTML. ==== How Do I Display the Contents of flash[:notice] through Ajax? ==== The lazy answer is of course: by outputting it in the partial that you retrieve through ajax. But what if your flash box is not within reach of the partial? Let's say your default place for outputting the flash messages is a shiny box which is part of your default application view. The smart answer is to have the partial update the flash box. Example of a default view:


  <%= flash[:notice] %>

                    
    <%= render :partial => 'admin/account/ajax_list', :locals => {:person_id => @person.id} %>

Now, in your controller which handles updates for the partial, use the flash[:notice] array to store messages. In your partial, use javascript to update the contents of the flash box:

A more elaborate approach can be found here: [[http://www.bigsmoke.us/ajax-validation-on-rails/|AJAX validation on Rails]]. And the [[http://www.simplisticcomplexity.com/2007/11/05/display-validation-errors-for-your-ajaxified-form/|Simplistic Complexity]] blog has yet another way of displaying error messages through Ajax. ==== form_remote_tag submit by Javascript ==== The title for this section was stolen from [[http://www.suite75.net/blog/dev/form_remote_tag-submit-by-javascript.html|suite75.net]]. Here's the question: How do I submit a "remote form" using javascript?

==== Loading a Partial Through Ajax ==== Sometimes you need access to a completely separate controller to render a partial. Use ajax:



<%= javascript_tag(remote_function(:update => "comments",
                                   :url => {:controller => "comments", 
                                            :action => "list" })) %>

And in your controller:


  def list
    render :partial => "list"    
  end

=====File uploads with FileColumn plugin===== Use the plugin FileColumn to upload files, e.g. images: [[http://www.kanthak.net/opensource/file_column/index.html|http://www.kanthak.net/opensource/file_column/index.html]] (Warning: it seems as though the latest version is only available through subversion) For all the image related operations, file_column relies on rmagick. See e.g. [[http://www.simplesystems.org/RMagick/doc/imusage.html#geometry|geometry string]] configuration options. This plugin is pretty well documented (see also the rdoc files inside the vendor plugin directory), but it's difficult to find out how to configure file storage locations. Here is how. ====File upload directory==== In your model class, you identify an attribute which should be used to store urls as follows:


class Match < ActiveRecord::Base
   file_column :item_image
end

In this example, the attribute "item_image" will used to store urls. If you use FileColumn to upload files, the file is saved in a location, by default under 'public'. FileColumn takes care of this all, but if you want to change the defaults, you should know this: - If you change the storage location, you must separately change ''**web_root**'':


file_column :item_image, 
            :root_path => File.join(RAILS_ROOT, 'public/images/uploads'), 
            :web_root => 'images/uploads/'

====Delete an Uploaded File==== If you need to get rid of the uploaded file, you can always delete the entire record that stores the whereabouts of the file. The FileColumn plugin will take care of everything. But of course, you do not always want to chop off your head when you've got a headache. So, here's how to just delete the uploaded file from your file system, and then delete the reference to the file from the record.


  def delete_uploaded_file
    if (@quest_text = QuestText.find(params[:id]))
      if File.delete(@quest_text.reward_image)
        # following is crude method to prevent SQL injection
        uid = params[:id].to_i                
        QuestText.connection.update("UPDATE quests_texts SET reward_image = '' WHERE uid = " + uid.to_s)       
        flash[:notice] = 'The file was deleted.'
      else
        flash[:error] = 'The file could not be deleted.'        
      end 
      redirect_to :action => 'edit', :id => params[:id], 'text_id' =>  @quest_text.text, 'quest_id' => @quest_text.quest                     
    end 
  end

Someone pointed out that you can also set the file_column field for the model object to nil, and then save the object. The associated file will be deleted automatically. ====Copy The Image when Cloning a Model Object ==== There is a solution posted on [[http://blog.craigambrose.com/past/2006/11/28/copyin-files-between-models-with-file_column/|Craig Ambrose's log]], but it requires an additional hack to the ''vendor/plugins/file_column/lib/file_column.rb'' file, which is documented on a blog called [[http://blog.skrdla.net/2007/09/rails-and-filecolumn-plugin-copy.html|blog.skrdla.net]]. My own solution does not require any hacks to the file_column plugin. It relies on copying the image to the right directory. Here's an example:


      @destination_meaning = @meaning.clone
      @destination_meaning.word_id = @destination_word.id
      @destination_meaning.save

      
      if @meaning.user_image and @meaning.user_image != ''
        File.makedirs(File.join(RAILS_ROOT, "public/images/uploads/meaning/user_image/#{@destination_meaning.id}") )
        if not File.copy(@meaning.user_image,@destination_meaning.user_image)
          flash[:notice] = "Something went wrong while copying the image."
          redirect_to :controller => 'school_wordpad',:action => 'show_word', :id => params[:word_id]   
          return                  
        end
      end

Update: Craig's solution does work with the file_column version as derived from subversion (as opposed to the 0.3.1 tar ball posted on the file_column website). Here's a small improvement of Craig's clone method:


  alias :original_clone :clone # Ruby allows us to 'rename' the clone method (here: to original_clone)     
  def clone    
    result = self.original_clone         
    result['image'] = nil # we can't use result.image, we have to access the 'raw' value of this attribute 
    unless image.nil?
      result.image = File.open(image)
      FileUtils.cp(image, result.image)
    end
    result
  end

=====Tool tip (or title attribute) and other html options===== The API talks about "html options" all the time, without specifying anywhere what they are. Turns out you can just use the appropriate html attributes, coded as Ruby "symbols". E.g.:


<%= link_to “Edit”, {:controller => 'complete_text', :action => 'edit', :id => @complete_text.uid, :quest_id => @quest_id, :selected_paragraph => @paragraph.uid}, :title => "Edit this record" %>

This code outputs a link with a title attribute: ''**title="Edit this record"**''. =====Sum or add up array elements===== Place this code in your Rails application's ''**/config directory**'':


class Array
  def sum
    if block_given?
      inject(0) { |m, v| m + yield(v) }
    else
      inject(0) { |m, v| m + v }
    end
  end
end

This code does not redefine the ''**Array**'' class, as it may seem to the Ruby novice, but it rather adds a ''**sum**'' method to it. Here is how you use it, given an array of models ''**SmallTransaction**'' ('transaction' seems to be a reserved keyword in Rails), which contains the attribute ''**credit**'':


@credit_total = ( (not @small_transactions.nil?) 
   and (not @small_transactions.empty?) ) ? @small_transactions.sum(&:credit) : 0 ;

=====Join model or association class using has_many and :through ===== True, you can use ''**has_and_belongs_to_many**'' to define a relationship between two associated tables. But, as excellently explained here: [[http://blog.hasmanythrough.com/articles/2006/04/20/many-to-many-dance-off|http://blog.hasmanythrough.com/articles/2006/04/20/many-to-many-dance-off]], you won't get a primary key with your join table. Which means that you cannot properly base a join model on this table. Instead, use ''**has_many**'' and ''**:through**''. Here's an example:


CREATE TABLE `transactions` (
  `id` int(11) NOT NULL auto_increment,
  `entry_id` int(11) NOT NULL default '0',
  `book_id` int(11) NOT NULL default '0',
  `user_id` int(11) NOT NULL default '0',
  `debit` double NOT NULL default '0',
  `credit` double NOT NULL default '0',
  PRIMARY KEY  (`id`),
  KEY `entry_id` (`entry_id`),
  KEY `book_id` (`book_id`),
  KEY `user_id` (`user_id`)
)


class Book < ActiveRecord::Base 
  has_many(
    :entries,
    :through => :small_transactions,
    :conditions => ['transactions.hidden = 0'])
  has_many :small_transactions     
end

class Entry < ActiveRecord::Base  
  has_many(
    :books,
    :through => :small_transactions,
    :conditions => ['transactions.hidden = 0'])
  has_many :small_transactions  
end

class SmallTransaction < ActiveRecord::Base
  #Apparently, Transaction is a reserved word within Rails
  set_table_name "transactions"  
  belongs_to :entry
  belongs_to :book   
end

Any conditions on retrieving records from the join table should be specified in the //joined// classes, not in the join class itself. Do not forget to prefix the columns with the join table name, when specifying the conditions. =====Submit a serialized form using Ajax===== There are various standard methods for submitting a serialized form using Ajax, such as submit_to_remote. These methods are bound to standard controls, however, such as a submit button. If you ever need to submit a form using a non-standard control, for instance a select box, use the Prototype javascript library ([[http://script.aculo.us/|http://script.aculo.us/]]) to serialize the form. Here is an example of a select box which submits the form where it resides.


<%= select 'entry', 'action_id', @actions.collect{ |list|  [ list.label, list.id]  },
   { :include_blank => true},
   { :class => "formfield",
     :onchange => "alert('combine with more Javascript');" + remote_function(
       :update => 'test',
       :url => url_for(:action =>  'test'),
       :with => 'Form.serialize(this.form)'
     )
   }
%>

=====Testing with Functional and Unit Tests===== To see what instruments are available, see this website: [[http://ar.rubyonrails.org/classes/Fixtures.html|http://ar.rubyonrails.org/classes/Fixtures.html]]. The book //Agile Webdevelopment with Rails// describes how to use these testing instruments. This book describes the use of instantiated fixtures. As an example, let's say we've got this fixture:


wordsweb:
  id: 1
  date: "2006-01-01 00:00:00"
  description: "Lot of Words"

Then we can state this in our unit test:


assert_equal @wordsweb.id, @entries["wordsweb"]["id"]

However, by default instantiated fixtures are turned off. Turn them on in ''**/test/test_helper.rb**'':


self.use_instantiated_fixtures  = true

=====Testing with Irb or Console===== Of course, you can also do some informal testing with irb (the one-line ruby interpreter) or the Rails console. In the main directory of your web application, use the command ''**script/console**'' to start the console. Now you have access to e.g. all your ActiveRecord models.


script/console
Loading development environment.
p = Person.find(:first)
=> #nil, "subdepartment_id"=>nil, "nationality_id"=>nil, "middlenames"=>nil, "title"=>nil, "jobdescription"=>nil, "birthdate"=>nil, "phonework"=>nil, "nickname"=>nil, "lock_version"=>"0", "country_id"=>nil, "initials"=>nil, "prepart"=>nil, "streetnumber"=>nil, "gender"=>nil, "id"=>"1", "mobile"=>nil, "phonehome"=>nil, "postalcode"=>nil, "organization_id"=>"2", "fax"=>nil, "street"=>nil, "department_id"=>nil, "first_name"=>"_", "last_name"=>"Demogebruiker", "profession"=>nil, "email"=>nil}>
>> puts p.last_name
Demogebruiker
=> nil
>>

=====Default Values For Your Model===== In Ruby, it's quite easy to set up an object with default values. Here's a basic example, taken from [[http://www.rubycentral.com/book/tut_classes.html|Programming Ruby]]:


class Song
  def initialize(name, artist, duration)
    @name     = name
    @artist   = artist
    @duration = duration
  end
end

But for an active record model class, this won't work -- you'd have to completely [[http://m.onkey.org/2007/7/24/how-to-set-default-values-in-your-model|rewrite the initialize method]], and then add your own stuff to it. There is an easier way, however: just use the ''**after_initialize**'' callback method. Here is an example taken from [[http://blog.teksol.info/articles/2005/12/14/setting-default-values-in-models|A Single Programmer's Blog]]:


class Site < ActiveRecord::Base
  def after_initialize
    self.attribute = default_value unless self.attribute
  end
end

===== Access Denied: Filter Based Authorization ===== It is quite common to use a ''**before_filter**'' to secure controllers. E.g.:


before_filter :authorize, :except => :login

The ''**:except**'' option excludes the login action from being filtered by the before_filter. Using multiple filters can be tricky, however. Consider the following example:


  before_filter :authorize, :check_usergroup, :except => :login

  def authorize
    unless session[:user_id]
      flash[:notice] = "Please log in"
      redirect_to(:controller => "login", :action => "authorize")      
    end
  end

  def check_usergroup
    # groups_allowed is an array of usergroup ids    
    unless self.groups_allowed.include?(session[:usergroup_id])
      flash[:notice] = "You don't have access to the page you wanted to visit."
      request.env["HTTP_REFERER"] ? (redirect_to :back) : (redirect_to HOME_URL)      
    end  
  end

Even if the first filter applies, i.e. you are redirected to the you to ''**login/authorize**'', the filter chain is still processed. In other words, the **second** filter is also applied, which has a redirect as well! This will result in a ActionController::DoubleRenderError error. So, you need to stop the before_filter chain if something goes wrong in the first filter. You do this by simply returning false:


  def authorize
    unless session[:user_id]
      flash[:notice] = "Please log in"
      redirect_to(:controller => "login", :action => "authorize")      
      return false
    end
  end