Rich-Text Textarea Editor in Rails Using Widg

Often your users might need to enter rich-text in your program: whether it be for updating their profile or leaving comments on your blog, it's common functionality. Using WidgEditor will help you make this easy. There are plugins for various other editors, but so far I've found this simple method the most stable.

1. Download widgEditor (latest version)
2. Edit the widgEditor.js file as shown below if using AJAX
3. Copy the widgEditor.js file into your public/javascripts folder
4. Copy the widgEditor.css file into your applications public/stylesheets folder.
5. Copy all the images from the widgEditor folder to your public/images folder.
6. Include the javascript and css files in your layout file.
7. Give any text field you want to be an editor field a class of “widgEditor”.
Example:
%= stylesheet_link_tag 'widgEditor' %>
%= javascript_include_tag "widgEditor" %>
%= text_area 'profile', 'about', :cols => "50", :rows=>"4", :class=>"widgEditor" %>

Using AJAX and WidgEditor

You'll need to modify widgEditor.js for AJAX. WidgEditor modifies your form submit function to ensure that a clean HTML copy of your input gets submitted. You need to change this so that it handles our AJAX/Javascript forms. In the widgEditor.prototype.modifyFormSubmit function, change the line that reads:
from: oldOnsubmit = theForm.onsubmit;
to: theForm.oldOnsubmit = theForm.onsubmit;

Then just a few lines below in the new onSubmit function, change the oldOnsubmit() function call to
from: return oldOnsubmit();
to: return theForm.oldOnsubmit()

Rails Guides

The Ruby on Rails team and many Rails enthuisiasts have been working hard on a new site for guides for Rails. They range from guides for getting started, to guides covering more of the specifics. The getting started guide covers a lot, but it can look a little length to the newcomer - perhaps it should be broken into sections. It does, though, cover each of the pieces and paradigms used in Rails, making learning the language fully rather easy. For example, it covers the Model View Controller paradigm used in Rails. Models are representations of the data we used, Views are displays of that data, and the Controller interacts with the user. Then it goes on to talk about all the pieces of rails, ranging from Active Record (for Models) through Active Support (for all the little things).

Rails Dynamic Links

Since I've been working on a program for Mindbridge for a while, (and you can see how busy I am), I try occasionally to post useful things I remember here. One is about Rails dynamic linking abilities. I recently forgot, then remembered again, about how easy it is to link to an object.

(%= link_to "View", @object %) instead of (%= link_to "View", object_path(@object) %)

You can use a handy REST cheat sheet to keep it all handy. It helps me remember that I have to explicitly declare the delete method, for example, in my links.

Rails Captcha

I just finished a lot of improvement on the custom Captcha implementation I use on all my websites. Right now the captcha protects comment forms and user profiles to prevent abuse by spammers, and it's very effective. Spammers obviously can't post spam without actually reading and interpreting my images as letters, or without having access to my MySQL database.

How It Works
The design for my custom captcha for rails is simple enough. Whenever the user request a page displaying a captcha-protected form, a captcha object is created in the database, which has a randomly generated private key, and I use it's id number as the public key. If the inputter does not submit the correct private key along with the public key (which is stored in a hidden value on the form), then they are given an error message. The user can see the private key, if they are a human, through a gif image which includes the letters A-L as part of the 5-digit key. The letters are blurred a little using a few RMagick functions and a few calls to random, and then the resulting image is given through rails in response to a .gif format request.

My improvements recently were rather simple. I first realized I had way too much code in the controller, and I moved most of it to methods in the Captcha.rb model method. Then I used a collect function and some loops to simplify things that were repeated, trying to follow along with DRY principals. Now I'm pretty sure that the program runs a little smoother and bugs will be easier to iron out.

Rails Development and Hosting

Here are some great posts about rails development, hosting, hiring, etc:



Ruby on Rails Hosting
An overview of some Ruby on Rails development and hosting companies.
View more »



11 Tips on Hiring a Rails Developer
Tips include looking for people who have contributed to the community, and more.View more »



Hosting Rails
A very cheap hosting company that offers mongrel for as little as $10 per month.View more »

Custom 404 Pages - Rails 404 Status

Sometimes your application hits it where it doesn't know what to render. Perhaps your user tried to access so URL from memory and spelled it wrong. Maybe they tried /user/john instead of /users/john. Whatever happens, they'll be getting some sort of error. Fortunately for you, you can control this error without much work. Add this to the bottom of your routes.rb file.

map.connect '*path', :controller => 'application', :action => 'rescue_404' unless ::ActionController::Base.consider_all_requests_local

Then add to your application.rb

def rescue_404
    rescue_action_in_public CustomNotFoundError.new
  end

  def rescue_action_in_public(exception)
    case exception
      when CustomNotFoundError, ::ActionController::UnknownAction then
        #render_with_layout "shared/error404", 404, "standard"
        render :template => "shared/error404", :layout => "standard", :status => "404"
      else
        @message = exception
        render :template => "shared/error", :layout => "standard", :status => "500"
    end
  end

  def local_request?
    return false
  end

Sometimes you may want to throw a 404 yourself. For example if they go to /wiki/doesnotexist you can render your own page. Use something as simple as:

render :action => "something", :status => 404

or as simple as

render :file => "#{RAILS_ROOT}/public/404.html", :status => 404 and return

Scaffold versus Scaffold Resource

Scaffolding has always been the standard way to start a Ruby on Rails piece/component/controller, generating the standard files and paths based on the specified model name. More recently, though, scaffold now creates a RESTful version of these rails conventions. At one time it simply generated regular CRUD, and then scaffold_resource came along to create a REST-based controller, model, and views. Now scaffold does that, by creating the correct views, actions, and allowing Rails to respond to different types of requests (XML, HTML, etc), which make it more restful.