Here is what I am trying to do.  I am sure I am not the only one out there trying to do the same thing.  In our organization we use Exchange.  This is the keeper of my office calendar which syncs perfectly with my iPhone via ActiveSync.  My wife and I also use our My Dog Boris Google Apps account for our family calendaring and personal email.  She also uses Outlook/Exchange at her office.  We both use the Google Calendar Sync plug in for Outlook to synchronize our office calendars with dedicated calendars set up in Google Apps.  On Google Apps, we can view each others office calendar (read only) as well as make entries to a 3rd calendar that we’ve set up for our Family events.  All that is working perfectly with few glitches.  Google Calendar Sync works in the background and rarely causes any problems (thanks Google).

Of course, most of you know that I am a Mac-guy and I do as much as I can (including all my development work) on the Macbook that usually sits next to my office PC.  When Snow Leopard came out last year, Active Sync was included in the operating system.  It allowed me to synchronize my mail, contacts, and calendars with Exchange.  Of course, Mac OS X has had support for syncing contacts and calendars with Google for some time.  I thought my prayers had been answered.  Well, hold your horses.  You see, while there is support for multiple calendars in iCal and multiple account in Address Book, they remain completely isolated from each other.   You cannot sync your Exchange Contact file with your “On My Mac” address book account that syncs with Gmail.  Hmmm.

The reason this isn’t an issue for calendaring is because of the Google Calendar Sync plug in for Outlook.  When this runs in the background in Windows, it is actually mapping from one domain (Exchange) to another (Gmail).  The Google Sync tool doesn’t (yet) support contact syncing.  There are other plug ins available that have support for syncing contacts between Outlook and Gmail but I have found them to be more trouble than they are worth.  I have tried both OggSync and gSyncit but I ended up scrapping them as they just seemed buggy to me.  Plus, they weren’t free (not a good combination, IMHO).

Enter Soocial.  So while it is a little more intrusive than I would like (a third party having access to my contacts plus another point of failure), it seemed really simple and wasn’t trying to get me to join another social networking cult.  After setting up the free account (is there any other type on Soocial?), I added connectors to my Gmail account and downloaded the plug-in for Outlook.  Note there are a bunch of warnings about this being in beta but I went for it anyway.  I will confirm that there are some issues that I hope will be worked out (read on).  I also didn’t need to add a connector to my Macbook Address Book since I was already successfully syncing with Gmail as above.  Gmail would already act as that conduit for me.  After a little bit of trouble with the Outlook plug-in I was able to get everything working… well almost.

After an initial sync with Outlook I was getting duplicates in my Outlook contacts and on my iPhone.  However, my contacts on the Soocial website appeared to be very clean (no dupes).  So what I decided to do was make a backup .vcf file from the tools available on the Soocial site (just to be safe).  Then I deleted all my Outlook contacts (whereby removing them from Exchange and my iPhone).  I also deleted all my Gmail contacts (after making another backup from the Gmail site).  Next I initiated a manual sync with Gmail and after that appeared to successfully re-populate my Google contacts from my Soocial “master file”, I initiated a sync from the Soocial plug-in inside Outlook.  After a lengthy process (mine took almost 30 minutes), my contacts re-appeared in Outlook with no duplicates!  Now when I make a change to my contacts in either (1) the Soocial website, (2) Gmail, (3) Outlook, (4) iPhone, or (5) the Address Book on my Mac THEY WILL ALL BE SYNCHRONIZED.  Of course, there is some latency depending on the client you are using to update.  Exchange only gets notification of contact updates from Gmail or Soocial if Outlook is running and the plug in is syncing every so often (and visa versa).  I think I can live with that.

All is good now in contact synchronization land (at least until Soocial crashes or runs out of money).  Now if I can only get visibility to my Family and wife’s calendar (through Google Apps) in Outlook and on my iPhone.  I recall having that visibility when I was using gSyncit (it supports multiple calendar syncing between Google and Outlook).  However, I just couldn’t live with the hassle and bugs in the application.  Plus, I like the comfort of knowing that Google wrote the application that is trying to sync my calendars in Google.

Let’s say I have a form with an id of ‘my_form’ and I have a number of input fields, including select lists, text, and textarea tags. By simply assigning a class of ‘editable’ (you can use whatever you want), I can detect when a form has changed and enable the save (submit) button accordingly. The magic happens in standard JQuery document ready function. Here is the entire javascript listing:

var formChanged = false;

$(document).ready(function() {
     $('#my_form input[type=text].editable, #my_form textarea.editable').each(function (i) {
          $(this).data('initial_value', $(this).val());
     });

     $('#my_form input[type=text].editable, #my_form textarea.editable').keyup(function() {
          if ($(this).val() != $(this).data('initial_value')) {
               handleFormChanged();
          }
     });

     $('#my_form .editable').bind('change paste', function() {
          handleFormChanged();
     });

     $('.navigation_link').bind("click", function () {
          return confirmNavigation();
     });
});

function handleFormChanged() {
     $('#save_or_update').attr("disabled", false);
     formChanged = true;
}

function confirmNavigation() {
     if (formChanged) {
          return confirm('Are you sure? Your changes will be lost!');
     } else {
          return true;
     }
}

What is going on here? First, a standard variable ‘formChanged’ is set to false when the page is loaded. In the JQuery document load function each text and textarea form element with a class of ‘editable’ is collected and the JQuery ‘data’ property (keyed with ‘initial_value’) is set to the values that were populated upon form load (likely using your favorite server side framework).  This is a HUGE feature that JQuery added.  It allows a ton of flexibility as we will see.

Next, I bind the keyup function to examine the contents of the text or textarea input and compare it against its respective ‘initial_value’.  If it is different, I call a simple ‘handleFormChanged()’ function to enable the submit button (id = ‘save_or_update’).  Binding the keyup event in this way allows me to not wait until the onblur event to check for changes.  The onblur event is what triggers the normal ‘change’ event in JQuery.  However, I also want to bind the ‘change’ and ‘paste’ events to any editable events as the user may use the cut and paste features to change the text or textarea values (here I simply assume a paste is always changing the value and don’t feel a need to check).  The change also picks up any change to a select list or a checkbox.  Of course, you should confirm that all your UI widgets are adequately covered by the various event handlers in JQuery.

The next JQuery bind is to any clickable component that is classed with ‘navigation_link’ (again, my arbitrary terminology).  I added this class to the submit button, as well as all my links in the navigation.  You could also simply use a ‘a’ selector to catch everything but I wanted precise control over which links triggered the action.  The ‘confirmNavigation()’ method simply examines the value of the formChanged variable to know whether to confirm that the user wishes to navigate away from the form page.

The users really love the way this helps prevent losing changes by accident.  What is even nicer is that this code could exist in a javascript include and provide this functionality through your application.  Perhaps you could just simply assign a class attribute to the form such as ‘checked_form’ and adjust your JQuery selectors accordingly, even keeping you from having to assign an ‘editable’ class to each of the input elements.  Then, just make sure you mark your navigation links and/or buttons with a class attribute such as ‘navigation_link’, or if you want everything checked, just adjust your selectors to pick up every anchor tag and every button.

JQuery is really a huge time saver.

Capistrano is a build automation tool, similar to Ant.  However, while Ant doesn’t make many assumptions about what (or how) your building and deploying, Capistrano makes a lot of assumptions (sound familiar?).  As a result, Capistrano can quickly become the centerpiece of your deployment process.  Capistrano leverages SSH to execute remote shell commands on one or more of your deployment servers, checking out code from your SCM (usually SVN or git), managing a directory structure of releases and creating symbolic links to your current release.  It will even help you remotely start and stop your app and erect a maintenance page! All of this is accomplished via Capistrano Tasks and Recipes that are scoped by a namespace to avoid conflicts.  Of course, you can easily create your own Recipes, but I didn’t have the need in my particular situation. The out of the box deploy script generated by Capistrano for me was more than adequate, although I did make some tweaks (see below) based on the fact that I was using Passenger (i.e. mod_rails) in my Apache configuration on the deployment server.    Here is what I had to do to get my new application up and running with Capistrano:

Installation

Installation was a snap.  Capistrano is ONLY installed on your development machine.  It is a simple gem install:


$ sudo gem install capistrano
...(output omitted)...
Successfully installed capistrano-2.5.5


Setting up my project

Next I navigated to my rails project root and executed the following command:

$ capify .
[add] writing './Capfile'
[add] writing './config/deploy.rb'
[done] capified!

I’ve been capified! Well that wasn’t too painful.

Tweaking for environment

After capification (?) I updated the ./config/deploy.rb file generated by Capistrano. Mine looked similar to this (some values changed to protect the innocent). Note that I also put some nice comment dividers to help organize the information. They are not required:

#############################################################
#	Application
#############################################################

set :application, "myrailsapp"
set :deploy_to, "/var/www/#{application}"
set :rails_env, "production"

#############################################################
#	Settings
#############################################################

default_run_options[:pty] = true
set :use_sudo, true

#############################################################
#	Servers
#############################################################

set :user, "some_user_name"
set :domain, "yourdomain.com"
server domain, :app, :web
role :db, domain, :primary => true

#############################################################
#	Subversion
#############################################################

set :repository,  "svn+ssh://www.yourdomain.com/repos/myrailsapp/trunk"
set :svn_username, "svn_user_name"
set :svn_password, "svn_password"
set :checkout, "export"

#############################################################
# Passenger
#############################################################

namespace :deploy do
  task :start, :roles => :app do
    run "touch #{current_release}/tmp/restart.txt"
  end

  task :stop, :roles => :app do
    # Do nothing.
  end

  desc "Restart Application"
  task :restart, :roles => :app do
    run "touch #{current_release}/tmp/restart.txt"
  end
end

Everything is pretty self explanatory. However, at the risk of pointing out the obvious… In the Application related properties, set the name of the rails app. This name can be anything but it will be used in the path to the deployment location in the next line so you may want to put some thought into this. I set the rails environment to ‘production’. I didn’t mess with the Settings related properties as I knew I would need to execute commands on the remote server as sudo. The server related properties include the user name that will attempt the SSH session. Domain could be something that resolves via DNS or an IP address, of course. I also needed to update the SVN properties with the path to my repository and my username/password.

For the most part, everything up to this point was out-of-the-box. All I needed to do was adjust some user names, passwords, and server paths. The last section (Recipe?) I added to accommodate the fact that I was using Passenger (i.e. mod_rails) on my Apache-based server as the glue between Apache and Ruby/Rails. This is really simple. The namespace used by Capistrano is ‘deploy’. All I am doing is overriding the default implementation of the :start, :stop, and :restart tasks. In the case of Passenger, all that is necessary is to “touch” a special file in the {RAILS_ROOT}/tmp directory called restart.txt. Passenger monitors this file and will reload when it sees that it has been modified.

That’s just about it. Well, almost. You’ll want to perform the task ‘cap deploy:setup’ from your RAILS_ROOT directory (again, on your development machine) first. This will set up a small directory structure under your target deployment location (adding directories ‘releases’, and ‘shared’). I had a small problem with permissions on the server so I had to manually SSH to update the file permissions in my target directory (i.e. ‘/var/www/myrailsapp’ directory to allow for writing. That was the only glitch for me and it only had to be done once.

Deployment

Next, I executed the following commands:

$ cap deploy:cold
...(output ommitted) [be prepared to respond to the SSH password and sudo password prompt]...

This launched a remote SSH session, checked out the latest version from SVN, built a new timestamp directory under the ‘releases’ subdirectory and created a symbolic link called ‘current’ to the current release. This way, my Document Root setting in my Apache configuration could simply refer to the ‘/var/www/myrailsapp/current/public’ directory (don’t forget that you need to include the public directory in the Apache config). Future releases could be done with:

$ cap deploy

…from the RAILS_ROOT directory of the development machine and voila. It’s automation bliss. There are loads of out of the box tasks (execute ‘cap –tasks’ to see the full list) to help you in the deployment and management process. A couple that I have been using a lot are ‘cap deploy:web:disable’ and ‘cap deploy:web:enable’. This will have Capistrano put up a maintenance page when you ‘disable’ your website for maintenance and remove it when it is back online ‘enabled’. However, be sure to update your Apache mod_rewrite rules to enable this. Here is what I added to my Apache virtual host configuration:

RewriteCond %{REQUEST_URI} !\.(css|jpg|png)$
RewriteCond %{DOCUMENT_ROOT}/system/maintenance.html -f
RewriteCond %{SCRIPT_FILENAME} !maintenance.html
RewriteRule ^.*$ /system/maintenance.html [L]


My experience was very positive with Capistrano thanks to the power of opinionated software. Your mileage may vary.