Moved to Typo!

Note: The RichText blog has moved to www.ricroberts.com

This blog has been moved to www.ricroberts.com, so I could host it on Typo.

This post explains how I imported all my old blogger posts into the new typo installation.

Note that the feed has remained the same: feeds.feedburner.com/richtext.

Read More About Swirrl

Note: The RichText blog has moved to www.ricroberts.com

As I mentioned a while back, my current project is 'Swirrl'.

Swirrl helps you store, share, edit and analyze the information you need to run your business. It's like a wiki, but better.

Recently I've been putting together some more information on what Swirrl does and why you might want to use it. Please take a look at the new Swirrl home page and Read More page.

There's also a registration form where you can leave your e-mail address if you want to be notified when we are ready to accept sign-ups. We’ll also announce it on the Swirrl blog if there's any other news on progress.

Thanks!

Lighting your campfire with fluid

Note: The RichText blog has moved to www.ricroberts.com

Inspired by blog posts from Robby Russell, and thoughtbot, we've recently started using Campfire for
text-chat between our distributed Swirrl team members.

As we all use macs, we were previously using Apple's iChat, with aim/.mac accounts. However, we often had connectivity problems with this, and so I went on the lookout for something new.

Although Campfire doesn't let you display a 'status', we use the idea that if you're in the chat room then you're available for chatting, and if you're not, then you're either away or don't want to be disturbed. This works fine for us. One major benefit of Campfire is that the transcripts of all chats are stored on the server for easy searching.

As is usual for a 37 signals application, The user interface is clean and intuitive. If you're on a mac, the user experience can be further enhanced by using fluid. Fluid lets you create what it calls "Site Specific Browsers". These are bascially uber-bookmarks that you can put in your dock, and let you launch a site in its own little browser as if it was a standalone app.

When using fluid, if you have any unread messages in a chat it handily shows up the dock icon (the image for which can be downloaded here).

If a conversation gets too complicated for text-chat, we still resort to an iChat voice chat, for the reasons described in this old post. iChat also offers the benefit of screen-sharing if you're on Leopard.

Brightbox Rails Hosting

Note: The RichText blog has moved to www.ricroberts.com

I recently wrote about Swirrl's choice of Rails host, Brightbox, on the Swirrl Blog.

You can read what I had to say here.

Rails on Mac OS X Leopard

Note: The RichText blog has moved to www.ricroberts.com

We'll get to the instructions for setting up rails on Leopard in a moment, but first a bit of background...

A few days after it was released, I changed over to using Mac OS X 10.5 (Leopard) as my platform for developing rails apps. When I first installed Leopard it took me a little while to figure out the best way to do things, as Leopard comes with lots of rails development features pre-installed.

Recently, after reinstalling my OS, I had to figure some of it out again as I hadn't made enough notes. So this time, I thought I'd document it properly and share it on my blog for the benefit of others (and so I don't forget too!).

As you might remember from this post last year, I'm a fan of using Netbeans for my rails IDE. Since that post, it has come out of beta and is now a fully fledged release (currrently at v6.0.1).

However, I couldn't get its step-through debugger to work with Leopard's installation of rails. I think is is because Netbeans assumes certain relative paths between the ruby interpreter and your gems, which differ in the Leopard standard install.

After being inspired by this post by Robby Russell, I decided to use Macports as my solution. Macports gives you a self contained environment for installing stuff. Everything installed under Macports lives in /opt/local, so if you mess up your Macports environment, you can easily just trash this folder and start again.

Installation Procedure

Here goes... The following instructions walk you through how to set up a development environment with Ruby, Rails, MySQL, Netbeans and Subversion on OS X 10.5 "Leopard".

Xcode
Before doing anything else, we need to install the Xcode tools from the Leopard DVD. Just double click on the installer and away it goes.

Macports
Download the installer from the Macports site, and run it.
(I used the dmg for v1.5.0 for OS X 10.5, but I think v1.6.0 is out now so you might want to try that one).

MySQL
Now, for MySQL, I just downloaded the package from the MySQL site, and installed it.

The problem I've found with this using this package is that the preference pane and automatic startup item don't work quite right, but there are workarounds for this. In particular, this worked for me:


"[...] the working MySQL.prefPane is here

and to get the StartupItem to work (see bug#25008), copy the (if existent)
/usr/local/MySQLCOM directory to /Library/StartupItems/MySQLCOM "


There are also some great free GUI tools available on the MySQL site too. At the time of writing, there isn't a dedicated package for these available for OS X 10.5 -only 10.4, but it works fine.

Set paths
This step is important! Dont skip it.

edit ~/.bash_profile, for example using TextMate:

mate ~/.bash_profile

and add the following line:

export PATH="/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/local/sbin:/usr/local/mysql/bin:$PATH"

(As I mentioned before, anything installed in Macports is installed under opt/local)

Save the file, and restart your terminal session to pick up the changes.

Install ruby and rubygems in Macports

sudo port install ruby
sudo port install rb-rubygems

Install all your required gems

For example:

sudo gem install rake
sudo gem install rails
sudo gem install capistrano
sudo gem install termios
sudo gem install mongrel
sudo gem install mongrel_cluster
sudo gem install ruby-debug
sudo gem install ruby-debug-ide

(The ruby-debug and ruby-debug-ide gems above are required if you want step-through debugging to work in Netbeans).

Subversion
I just use the subversion installation that comes with Leopard, as this works fine.

Netbeans
Download Netbeans from here, and run the installer. (For developing rails apps, you just need the 'ruby' bundle).

Debgging in Netbeans
In Netbeans, under Preferences->Ruby, set the ruby interpreter to /opt/local/bin/ruby
The fast debugger radio button should become available - select it.

That's pretty much it. You should now have a fully functioning setup for developing on rails.

Note: I use svn over ssh to access my subversion code repository. Below are some instructions for getting this to work with Netbeans. You can safely ignore all that follows if this doesn't apply to you - Netbeans works fine 'out of the box' with svn over http...

svn+ssh in Netbeans
In order to get the svn+ssh protocol to work with Netbeans, you need to set up a ssh key, and set your mac up to remember it. Here's how to do this

1. Create a pair of keys on your local machine.
From your home directory on your mac, run the following command:

ssh-keygen -t dsa

This will prompt you for a secret passphrase - make sure to use a good passphrase. When this is done you will get two files called id_dsa and id_dsa.pub in your ~/.ssh dir.

2. On your server, ensure that the .ssh directory exists for the user
Log in to your server via ssh

ssh myuser@myserver.net

make a .ssh hidden directory

mkdir ~/.ssh

3. Place your public key on your server
On your mac, run

ssh myuser@myserver.net 'cat >>.ssh/authorized_keys' <~/.ssh/id_dsa.pub

4. Try to log in to the server

ssh myuser@myserver.net

You will be asked for the passphrase

In OS X Leopard, there is a user interface for ssh-agent which will ask you if you want to remember the passphrase, and will store it in your keychain. From then on, you wont need to enter a password or a passphrase for this user.

5. Edit the subversion config
This step is required because, although when you check out from an svn repository in Netbeans, the dialog asks you for a tunnel command, it forgets that when you restart the IDE.

On your mac, edit the ~/.subversion/config file (note: this file wont exist unless you've previously run Netbeans)

mate ~/.subversion/config

Add an entry under the [tunnels] section like this:

ssh = $SVN_SSH ssh -l my_ssh_username

Save the file.

Now, Netbeans will be able to access your svn repository over ssh without needing a password from you.

6. Checkout from your repository
In Netbeans, If you go to the Versioning->Checkout dialog, you will see that the tunnel command is pre-populated for you. Just enter your repository location eg:

svn+ssh://myserver.net/repository

and everything should work fine.

The curse of the spreadsheet!

Note: The RichText blog has moved to www.ricroberts.com

I recently wrote about the misuse of spreadsheets on the Swirrl blog.

Spreadsheets are great for some tasks. People love the informality, the flexibility and the instant results: in skilled hands, they can be very powerful. But “when all you have is a hammer, everything looks like a nail”... Read the full article.

Swirrl on Rails

Note: The RichText blog has moved to www.ricroberts.com

Just a quick announcement about the current rails project I'm working on:

It's called swirrl and you can read about it here.

Handling Errors in Ajax & Rails

Note: The RichText blog has moved to www.ricroberts.com

A while ago, I was wondering how I should deal with errors that are encountered in rails controllers, while processing an Ajax request. I played around with some alternatives and eventually came up with one that has been working great for a few months, so I thought I'd share it.

You've probably all heard of overriding 'rescue_action_in_public' in your ApplicationController to deal with errors. (See simple example below).

def rescue_action_in_public(exception)
  # render the error page.
  render :file => "public/error.html"
end

This works great in regular methods, but what if something happens in an ajax request?

If you take no action, then the controller will fail 'silently' (well, some stuff appears in the log, but the user is unaware).

The way I got around this was to add a method to the ApplicationController, similar to that below (irrelevant code stripped out, so apologies if this code has a typo!).

  def perform_ajax_action
    
    if block_given?
      begin
        if (request.xhr?)
          yield
        else
          raise RuntimeError.new('Not in an ajax request!')
        end
      rescue Exception => error
        logger.error("#{Time.now}: Error performing ajax action: #{error.inspect}")
        logger.error(error.backtrace.join("\n"))
        ajax_aware_redirect_to "/error.html"
      end      
    else
      logger.error("perform_ajax_action called with no block!");
      ajax_aware_redirect_to "/error.html"
    end
    
  end

(You were probably wondering what this 'ajax_aware_redirect_to' business is all about. It's just another method in the ApplicationController which helps with redirecting during ajax processing. It looks a bit like this: Again, irrelevant stuff removed.)

  def ajax_aware_redirect_to(options = {}, *parameters_for_method_reference)
    if request.xhr?
      render :update do |page| 
        page.redirect_to( options, *parameters_for_method_reference) 
      end
    else
      redirect_to( options, *parameters_for_method_reference)
    end
  end

Now, in order to get this to catch your errors, you need to add an :around_filter to your controller. e.g.

class MyController < ApplicationController
  
  around_filter :my_around_filter, :only => [:my_action]
  
  # controller code here....

  def my_around_filter
    perform_ajax_action do
      # do other useful stuff here if you like.
      # in an 'around filter' yield calls the method wrapped in the filter
      yield
    end
  end
end

MySQL Temporary Tables and Rails

Note: The RichText blog has moved to www.ricroberts.com

According to the Rails documentation, all active record classes by default use the same database connection.

As the Agile Web Development With Rails book rightly says, Ruby on rails is not thread safe (2nd Edtn p 649). A Mongrel server uses one thread per request (i.e. multithreaded), but is synchronised around the calls to Dispatcher.dispatch. This means that everything is threaded right before and right after Rails runs. While Rails is running there is only one controller in operation at a time. This is why people typically have to run a small set of Mongrel processes (a “Pack of Mongrels”) to get good concurrency (from Mongrel FAQs).

MySQL temporary tables are only visible inside the connection from which they are created, and they are automatically dropped when the connection is dropped (see the MySQL docs). Along with the above, this means that any rails active record class will be able to see temporary tables created by other active record classes (within the same server process).

However, since only one controller operation is running at a time within each server process (and therefore only one for each connection), I think you can safely do the following in a rails active record model class if you want to use temporary tables:

begin
  connection.execute("DROP TEMPORARY TABLE IF EXISTS my_temp_table")
  connection.execute("CREATE TEMPORARY TABLE my_temp_table")
  # do stuff with temp table here
ensure
  # this drop is here to help keep the size of the data base down 
  # between calls to this method
  connection.execute("DROP TEMPORARY TABLE IF EXISTS my_temp_table")
end

NetBeans Intervenes

Note: The RichText blog has moved to www.ricroberts.com

Regular readers of this blog will know that I'm not averse to trying new IDEs for my rails development.

I recently came across this post by George Cook about an app I hadn't considered.... NetBeans.

George does a great job of explaining NetBeans's virtues, so I won't repeat them all here, but to sum up, it does everything I need a rails IDE to do plus a little bit extra. The most impressive feature for me is the in-IDE fast debugging (more on how to set this up below).

NetBeans does have it's down points. With its default settings it doesn't look as slick as TextMate, but after some fiddling around with the preferences you can rectify this. It does use more memory than TextMate but even on my MacBook with 1GB RAM and lots of other applications open, I still have a little bit free. Besides, compared with something like Microsoft Visual Studio 2005 (which eats RAM for breakfast) NetBeans is a veritable size zero.

There is a ruby-only build of NetBeans available which helps to keep the memory footprint down. The exact version I installed was build 3533, which seems to work fine.

UPDATE (26 Sep 07): Netbeans 6 Beta 1 is now out! Get it from the Sun web-site.

Getting started with NetBeans

Here are few quick pointers to get you going.

To begin, all you have to do is do:
-> File -> New Project
.. and then choose "Ruby on Rails Application with Existing Sources"
and browse for your rails folder.

You need the ruby-debug-ide gem installed (sudo gem install ruby-
debug-ide) to do fast debugging.

Before trying to debug, you need to go to:
-> Preferences -> Ruby -> Platform
... then choose the location of your ruby interpreter (e.g. /usr/local/bin/ruby)
You should then be able to select the Fast Debugger radio button for the
Debugger engine. (If you can't, try restarting NetBeans - this worked for me).

RedBox Rules!

Note: The RichText blog has moved to www.ricroberts.com

As you might have noticed from previous posts in this blog, I'm somewhat interested in modal dialogs in Ruby On Rails.

Up until now, I've been happily using the Prototype Window Class. However, it's quite a lot of js (a lot of which I don't use), and I've recently found a few small bugs in it. I'm not denying it's an impressive piece of work - it's just that there were a few niggles (Check out the forums).

Anyway, I've been investigating a few other options (namely: SubModal, ThickBox, LivePipe's Control.Modal, LightBox Gone Wild, StickyWin) and then I eventually found RedBox.

Most of the options I considered are variations on the LightBox theme, but RedBox stood out for me because of it's simplicity and ease of use with RoR. It doesn't do anything particularly fancy, but it ticked all my boxes (i.e. easily customisable, works well with Rails, small size of javascript, no obvious bugs).

It really couldn't be simpler to use RedBox with Rails.

To install the RedBox plugin, in Terminal just run:

script/plugin install svn://rubyforge.org/var/svn/ambroseplugins/redbox

...from your Rails project folder. This will stick stuff in your vendor folder. Then, from the vendor/plugins/redbox folder, you can run:

rake update_scripts

...to copy the files to the relevant places in your project. (i.e. the public/javascripts, stylesheets folders etc.).

Now all that's left is to stick the javascript and stylesheet links into your layout:

<%= stylesheet_link_tag 'redbox' %>
<%# we need to include prototype, etc... %>
<%= javascript_include_tag :defaults %>
<%= javascript_include_tag 'redbox' %> 

To create a link to a RedBox, you can use the helpers that the author provides, the most useful of which I found to be the 'link_to_remote_redbox' helper. This allows you to launch a RedBox with some content from another page. For example:

<%= link_to_remote_redbox("redbox",
  :url => {:controller=>'my_controller', :action=>'my_action',
    :id=>'my_id'}) %>

Then, in the resulting RedBox dialog, you need some way of closing the it. To just close is very simple...

<%= link_to_close_redbox "Cancel" %>

It's also pretty easy to get it to do stuff after closing. For example, you could call a rails action, via an ajax call...

<%= link_to_close_redbox "OK", {:onclick => remote_function(
   :url => {:controller=>'my_controller', :action=>'my_action',
     :id=>'my_id'},
   :complete => "$('spinner').hide();",
   :before => "$('spinner').show();")
   } %>

If you want, the rails action could do some rjs to update some of the main page.
(Of course, you could use a similar technique to submit a form on the dialog too).

One of my additional requirements was to be able to guide the users through a two-step process, within the constrains of the modal dialog (something I found fiddly with other modal dialog solutions). Here's how I did this with RedBox...

<%# to link to another page inside RedBox %>
<%= link_to_remote( 'hello',
  :url => url_for(
    :controller => "my_controller", 
    :action => "my_action", 
    :id => "my_id"),
  :update => 'modal_content', # the div used by default for the dialog
  :complete => 'RedBox.setWindowPosition();'#make sure it's centered
  ) %>

Notice how I call the RedBox's setWindowPosition() function once the update is complete. This is because the new page being shown might be a different size to the first one, and although the dialog automatically resizes to fit the content (which is nice), it doesn't automatically recenter itself. (Without this step, the dialog's top-left corner just stays in the same position).

A new look

Note: The RichText blog has moved to www.ricroberts.com

I've decided to give my blog a new look, as I've been neglecting it recently.

I've got a few tasty computing morsels up my sleeve, so watch this space! ;)

More on modal dialogs in rails

Note: The RichText blog has moved to www.ricroberts.com

Almost a year ago (blimey!), I posted about modal dialogs. For various reasons, the part of the application about which I wrote ended up being done a bit differently to how I described. I've recently had a lot more time to work on rails and the other day, I came across a different reason to use modal windows.

The Xilinus Prototype Window Library is now at version 1.3, and has some nice additions since I last used it. There is also a link to a rails helper for launching windows and dialogs, which although doesn't fully support all of the options, is a good point to build from.

Now, to finally answer Michael Kovacs's question from that original post, I found it handy to make use of the callbacks (onOK & onCancel for dialogs and closeCallback for windows) when dealing with ajax.

For example, suppose you want the user to impart some information in one of your modal dialogs. And then you would like to save this information and cause an update to a portion of the page from which you launched the dialog, as a result of what the user did...

One solution is, in the callback function, to interrogate the contents of the dialog for what the user entered (using prototype, say) and then call a remote_function to save the info to a database. This remote_function could then use rjs to update the original page.

The erb in your view to launch the dialog might look a bit like this...

<%=
url = (url_for :controller => 'my_controller', :action => 'dialog_action')
link_to_prototype_dialog(
"link text here", 
{
  #content
  :url=>url,
  :options=>{:method=>'get'}
}, 
'confirm', #dialog-kind
{ 
  # dialog options
  :className=>"alphacube",
  :width=>680,
  :height=>220,
  :onOk="function(win)
  {
    val1 = $F('val1');
    val2 = $F('val2');" +
    remote_function(
      :url => {:controller=>'my_controller', :action=>'do_something'},
      :with => "'val1=' + val1 + '&val2=' + val2",
      :complete => "$('spinner').hide();",
      :before => "$('spinner').show();") + 
    ";
    return true;  // remember to return true to allow the dialog to close
  }"
}
%>

Note that in order to get this to work properly I had to tweak the rails helper to slightly to correctly format the generated javascript, but you get the general idea.

UPDATE: you might also want to try RedBox modal dialogs.

diagrams for your rails apps

Note: The RichText blog has moved to www.ricroberts.com

RailRoad lets you generate diagrams of your rails app.

Documentation often gets left to get out of date. With a tool such as this, you can just keep changing the code, automatically generating diagrams along the way.

The link above tells you how to set up a rake task to do just this, meaning that you'll never have to look at a redundant diagram again (or manually update one either)!

Aptana with fast debugging

Note: The RichText blog has moved to www.ricroberts.com

I blogged a while back that Radrails was taken over by Aptana. Recently, someone entered a comment on this old post saying that Aptana now supports fast debugging. So I thought I'd give it a whirl.

To get it to work, you need to install the "ruby-debug" gem, the "ruby-debug-ide" gem, and follow these instructions.

This is a very useful feature, although having used TextMate for a while I prefer its clean look over Aptana's rather cluttered feel.

Skype vs iChat

Note: The RichText blog has moved to www.ricroberts.com

Until recently, I'd been using Skype quite a lot for my VOIP phone calls.

However, unless both people in the conversation used headphones or some kind of headset, then I could hear a slightly delayed echo of my own voice. Although this didn't actually stop anything working it was very disconcerting. Also, if either party had the volume turned up beyond a whisper, then I got quite an annoying feedback whistle.

So, I decided to try the iChat application that came with my mac, with another of my mac-owner buddies. To use iChat, you need a .mac or aim name. (I found out by reading the .mac faq that if you sign up for the free .mac trial, then you can still use your .mac name for iChat after the trial expires.)

iChat suffers from neither of the problems that plague Skype. Even when using quite a high volume we experienced no feedback or echo, and both members of the conversation were just using the MacBook's built in iSight webcam, integrated mic and laptop speakers (i.e. with no headsets)

Visibility in ruby

Note: The RichText blog has moved to www.ricroberts.com

Back in January, I made this post about ruby instance variables in derived classes.

I recently came across this post by Jamis Buck (one of the core Rails guys) with some more info about method visibility in ruby. Basically, he explains that private and protected methods are visible by all derived classes.

This seems a bit free and easy, coming from a C-sharp view point. In rails, this means, for example, that the controllers can't call the models' private methods and vice-versa. But all controllers can access all of the application controller's methods, so it's hard to hide it's inner workings from the other controllers if you want to.

Radrails and Aptana

Note: The RichText blog has moved to www.ricroberts.com

Earlier this month, I wrote about the demise of Radrails.

Well, Aptana have stepped in to save the day. It's not clear exactly what will become of Radrails in its current form, but anything's got to be better than all of that great work just petering out into obscurity.

Here's what the Radrails site had to say about it all.

NAS drive for Mac and PC

Note: The RichText blog has moved to www.ricroberts.com

Not so long ago, I went on the lookout for a Network Attached Storage (NAS) drive that I could use with my Mac and my PC.

This proved a little bit more awkward than I expected because many NAS drives only supported Macs by allowing you to format the disk in FAT32. This is all very well until you want to put files larger than 4GB on there, such as disk images.

I eventually settled on the LaCie Ethernet Disk Mini. This product uses the XFS file system, which has a maximum file size of 8 exabytes (should be enough!). It supports connections from Windows, Apple, HTTP and FTP. It lets you define shares and users, and even allows you to connect another USB disk for backups or extra storage.

Works a treat with both my PC and my Mac. Definitely recommended.

TextMate for rails

Note: The RichText blog has moved to www.ricroberts.com

With the seemingly indefinite postponement of Radrails 0.8, I decided to go on the hunt for another Ruby on Rails IDE.

After scouring the web, I found that many people seem to favour TextMate, and according to this page the core Rails team use it for development, so I thought I'd give it a whirl.

I must say I am impressed. It features Subversion integration, and some built in support for developing Ruby on Rails applications. The only thing it doesn't have is a step-through ruby debugger, but there is a TextMate ruby-debug bundle which allows you to set breakpoints from within TextMate. (My previous blog post explains more about ruby-debug.)

Note that in order to get the Subversion integration to work, you need a Subversion client installed. There are now new instructions on Hivelogic.com for setting up rails on OS X which now feature how to install one.

TextMate is not free, but it is cheap at only 39 Euros.