You are currently browsing the monthly archive for November, 2008.

If you develop Rails applications, you’re probably used to seeing this sort of thing in your log files:

terminalthumb

Really, the only important thing there (as far as helping me find the source of the error) is the very first line of the backtrace: ActiveRecord::StatementInvalid (SQLite3::SQLException: no such table: posts: SELECT * FROM "posts" ):. But Rails throws in another 55 lines of backtrace information, just in case I have exposed a bug somewhere in Active Record or Action Pack or the dispatcher or Mongrel or Rack or even the initial script/server command. In most cases, that’s just noise.

Rails 2.3 (inspired by Thoughtbot’s Quiet Backtrace plugin) is smart enough to just shut up about the parts I don’t care. Here’s the default Rails 2.3 log in the same situation:


Processing PostsController#index (for 127.0.0.1 at 2008-11-29 08:12:31) [GET]
  Post Load (0.0ms)   SQLite3::SQLException: no such table: posts: SELECT * FROM "posts" 

ActiveRecord::StatementInvalid (SQLite3::SQLException: no such table: posts: SELECT * FROM "posts" ):
  /app/controllers/posts_controller.rb:5:in `index'

Rendered /Users/mike/scratch/blog23/vendor/rails/actionpack/lib/action_controller/templates/rescues/_trace (18.0ms)
Rendered /Users/mike/scratch/blog23/vendor/rails/actionpack/lib/action_controller/templates/rescues/_request_and_response (0.6ms)
Rendering /Users/mike/scratch/blog23/vendor/rails/actionpack/lib/action_controller/templates/rescues/layout.erb (internal_server_error)
Completed in 34ms (DB: 0) | 500 Internal Server Error [http://localhost/posts]

Much nicer. Rails uses a combination of silencers (which just throw away lines matching a particular pattern) and filters (which make regex-based substitutions) to clean up the backtrace.

The guts of the backtrace cleaner are in ActiveSupport::BacktraceCleaner, letting you set up your own cleaners. Most of us, though, will be using the default backtrace cleaner that Rails spins up during initialization, Rails::BacktraceCleaner. Rails adds a variety of filters and silencers “out of the box”:


ERB_METHOD_SIG = /:in `_run_erb_.*/

VENDOR_DIRS  = %w( vendor/plugins vendor/gems vendor/rails )
SERVER_DIRS  = %w( lib/mongrel bin/mongrel lib/rack )
RAILS_NOISE  = %w( script/server )
RUBY_NOISE   = %w( rubygems/custom_require benchmark.rb )

ALL_NOISE    = VENDOR_DIRS + SERVER_DIRS + RAILS_NOISE + RUBY_NOISE

def initialize
  super
  add_filter   { |line| line.sub(RAILS_ROOT, '') }
  add_filter   { |line| line.sub(ERB_METHOD_SIG, '') }
  add_filter   { |line| line.sub('./', '/') } # for tests
  add_silencer { |line| ALL_NOISE.any? { |dir| line.include?(dir) } }
end

So, by default, Rails will throw away all the messages from the vendor folders and the servers, among other things. Naturally, you can change these defaults. Rails 2.3 adds a config/initializers/backtrace_silencers.rb file to your application. You can add your own silencers or filters in this file:


Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }

You can also tell Rails to remove the default silencers if you’re worried that you have uncovered a deeper bug:


Rails.backtrace_cleaner.remove_silencers!

Because the silencer is set up during the initialization process, you need to restart the server if you make any changes to it.

Currently in edge, the in-browser backtrace pages that you get in development mode show the full backtrace, not the silenced one.

Hopefully I will shake off the post-turkey stupor and write some code today.

  • RubyConf08 Videos - Confreaks has got most of them processed and posted now, with more formats to come.
  • A Byte of Vim - Free eBook on using the Vim editor.
  • dj.god - The delayed_job god configuration used by github. This was a great help to me in setting up my own.
  • Gettin’ less icky with the chronic - A way to make run all date attributes through chronic. I should take a closer look at this.
  • Looks like I’m going to roll out at least one and possibly two Rails applications that use delayed_job for asynchronous background job processing. What I haven’t figured out is a good server-side deployment strategy. If you have, I’d love to talk to you.

    I’d forgotten how fun trying to pull all the pieces together on a last-minute high-pressure project could be.

  • Rubinius for the Layman, Part 3 - Try Rubinius in 20 minutes - Rubinius took a blow this week when Engine Yard let some folks go, but things are mature enough that you can see the current state of the project easily if you want.
  • If you use Mocha and RSpec then read this - Jake Scruggs points out a useful plugin if you’re in this boat.
  • Calendar Date Select - Rails plugin for popup calendars. I used this in an app this week and so far it’s working out nicely.
  • I recently hit a situation where I needed to sort an array of ActiveRecord objects on a particular attribute. The catch was that in this case the array started out with the results of a find operation - but then it had a bunch more transient objects added to it that weren’t part of the database. Fortunately the Array#sort method makes short work of this. Given an array a of objects with an entry_date attribute:

    
    a.sort! {|x,y| x.entry_date <=> y.entry_date}
    

    Because this was the only sort I needed on this particular model, I decided to push the operation right down into the model:

    
    class Receipt < ActiveRecord::Base
      def <=> (other)
        entry_date <=> other.entry_date
      end
    end
    

    Then the sort is much simpler:

    
    a.sort!
    

    Note that this technique only makes sense if your array isn’t coming straight from the database. If you are retrieving records from the database, you’re better off including an :order clause in your finder to let the database do the sorting.

    Too busy to do more than post a couple of links, alas.

  • Moving to Rails 2.2 Headaches - Vol 1 - Looks like mostly issues with various libraries not being ready yet.
  • jrails_in_place_editing - Now that it’s been moved out of core Rails, there are a boatload of in-place edit plugins out there. This one seems to work OK in a project where we’re using jQuery.
  • This month is definitely ending with a bang.

  • environment.rb and requiring dependencies - Why thread safety may require you to rearrange how you’re handling initialization.
  • Rails 2.2: i18n, HTTP validators, thread safety, JRuby/1.9 compatibility, docs - The official release announcement.
  • Free Ruby eBook - The Book Of Ruby, new chapter: YAML - From the SapphireSteel folks.
  • This Week in Edge Rails - My latest contribution to the main Ruby on Rails weblog.
  • Rails 2.2 For Me And For You - Even if you’ve read the release notes you’ll probably learn about more new features here.
  • There are times when I’m glad I’m not a big wheel in the Ruby community. Saves me all sorts of angst, apparently.

  • 960 Grid System - Another CSS scaffolding system. Nice looking home page, at the very least.
  • The Art & Science of CSS - And speaking of CSS, here’s a free book download from SitePoint. I’ve actually got this one in paper; it’s not bad.
  • GitX 0.5 - This git GUI for OS X is developing nicely.
  • Base - Commercial (£10.00) GUI for SQLite. I should take a look at this one.
  • Skim - Fancy PDF reader and note manager for OS X.
  • The Opposite of Momentum or “Sophie’s Choice” for Rubyists - Another rubyist expresses general malaise about the state of the language.
  • There has been an astounding amount of invective and discussion over a recent addition to Rails. Briefly, if you have an array in Rails, you can now use ordinal numbers to get at the first ten members through aliases such as Array#second, Array#third, and so on. Some people are concerned about code bloat, some are concerned about lack of elegance, and DHH’s judgment in writing this bit of code has been seriously challenged.

    Well, I’m not happy either - because the changes don’t go far enough. Let’s add one more method to Array and be done with it:

    
    Class Array
      def by_ordinal(pos)
        self[pos.to_i - 1]
      end
    end
    

    With this simple addition, you can refer to Array.by_ordinal("3rd"), Array.by_ordinal("21st"), or even Array.by_ordinal("407th"). As a bonus, the naming of the individual members is consistent with Rails’ Inflector#ordinalize method. Please join me in pushing for this to be included in Rails core.

    Some days I am amazed that any software at all ever works.

  • Mike T’s SQLite Database Administrator Tool - The icon is butt-ugly, but the tool is reasonably functional.
  • Ruby Isn’t Fun Anymore - Apparently some people are not feeling the upstart excitement. I’m not one of them.
  • Gist Support for TextMate - Some people are clearly trying to turn TextMate into an operating system.
  • Live from Pro Rubyconf ‘08 / SMACKDOWN - Informal A/B testing at Pro RubyConf.
  • Rails TakeFive - Five Questions with Jay Fields - Another interesting interview from FiveRuns.
  • Vocito - OS X Desktop UI for Grand Central. Mildly interesting if only because it’s the first sign of life from GC in months.
  • It’s hard to work real effectively when your head is ready to explode. But self-employment doesn’t come with paid sick days.

  • What’s New in Edge Rails: Default Scoping - Ryan Daigle covers some of the latest changes.
  • SQL Injection Cheat Sheet - Read it as things to guard against rather than a cookbook, please.
  • Shoulda for RSpec is Remarkable - Another addition to the growing stable of testing tools.
  • Installing ruby 1.9preview1 on OS X Leopard - How to do it.
  • QBWC-Mini - Experimental Sinatra server for easier QuickBooks integration.
  • « Distribute Your Content With Amazon CloudFront - Amazon’s new CDN. I expect we’ll see Rails integration shortly.
  • Ruby on Rack #2 - The Builder - Pratik is still writing about Rack and how to use it.
  • Tutorial: Reset Passwords with Authlogic - Just what the title says.
  • Things are hopping a bit around here these days, thanks to some short-term work helping out other devs. It’s always fun to come up to speed on a new project.

  • Smart Asset Management for Rails Plugins - An automated way for plugins to manage things like images and CSS in their hosting Rails project.
  • jQuery Selectors - Useful interactive page for figuring out how they work.
  • MiMo Displays - Serious gadget lust. I probably shouldn’t save this bookmark.
  • Ruby on Rack #1 - Hello Rack! - If you’ve been wondering what all this Rack stuff is about, Pratik Naik has a good introduction.
  • Pushr - Automatic Rails application deployment via Capistrano and a Git repo hook.
  • Things Caches Do- A nice explanation, with pictures.
  • Here’s a commit message that showed up in the main Rails repository earlier today:

    
    BACKWARDS INCOMPATIBLE: Renamed application.rb to
    application_controller.rb and removed all the special casing that was in
    place to support the former. You must do this rename in your own
    application when you upgrade to this version [DHH]
    

    Well, getting rid of special casing is great, and this commit does indeed simplify some of the Rails internals a bit. But I can hear some of my readers cursing: this seems like an arbitrary change just when Rails 2.2 is about to come out.

    Fortunately, if you’re moving to Rails 2.2, this won’t affect you (yet). We’re close enough to 2.2 final that the main repository has been branched: there’s now a 2.2 stable branch (which is currently accepting very few bug fixes) and a master branch that’s targeted at Rails 2.3, or perhaps Rails 3.0. This change - and some other big changes that have been committed over the past few days - is on the master branch.

    So, for Rails 2.2, don’t panic. On the other hand, if you’re tracking edge Rails closely, the next few weeks are likely to be a time of vast change (and instability) as some pent-up major changes hit the repository. Be sure you know what you’re cloning before you set up a new Rails application.

    Lots of links piled up over the weekend. I’ll try to get something more substantive posted later.

  • The Rails Myths - The list continues to grow, though it’s also generating some responding posts and general snark elsewhere.
  • Beginner’s Guide to Installing Merb - Updated for Merb 1.0. Still some hoops to jump through.
  • Speeding Up Rails Development - Some suggestions from Jim Neath.
  • new plugin: acts_as_git - Connect a text or string field directly to a git repo for easy versioning.
  • 3 Ways To Build Fake Demo Data For Your Rails App - My latest for Rails Inside.
  • Rails 2.2 RC2: Last stop before final - Rails 2.2 is coming together.
  • WebKit Nightly Builds - The developer stuff in the latest WebKit builds is pretty spiffy - right-click and “inspect element”.
  • A test server for Rails applications - Intended to be the Rails equivalent of RSpec’s spec server.
  • Profiling Your Rails Application - Take Two - There are big advances in this area. Some day I may even understand them.
  • First, foremost and [0] - The difference between post.comments.first and post.comments[0] in Rails is subtle and surprising.
  • Been having great fun coming up to speed with shoulda the last few days. I think it’s finally starting to make sense to me, though surely there are best practices I’m still missing.

  • Spandex MemCache Store - An enhanced version of the default Rails memcache bits.
  • RubyGems 1.3.1 - New minor release. So far it hasn’t caused any new issues for my major applications.
  • Concurrency is a Myth in Ruby - Well, yes, although JRuby does present a different situation.
  • Shoulda Testing Cheat Sheet - A useful thing to have around when you’re learning.
  • ActiveRitalin - A Rails plugin built on the premise that “Rails find_by_sql is the devil.”
  • The Rails Myths - DHH tries to set the record straight. Good luck with that.
  • With my latest project past its initial design spike and settling down into more routine stuff, I’m still looking for more to take on, especially into December and beyond.

  • Getting Started with Cappuccino and Ruby on Rails - That’s the Objective-J framework for desktop-like web applications.
  • forgery - Another approach to generating fake data in your applications.
  • Sometimes a tool isn’t just a tool - Pat Maddox takes up the banner of Rails testing tools.
  • The Fast, Good and Cheap Pricing Method - Every consultant should know this stuff. A surprising number don’t.
  • Gobby - Cross-platform collaborative text editor.
  • Even though Rails 2.2 is officially in “release candidate” status, new features are still making their way into the source code tree. While we could debate the suitability of this from a release engineering point of view, some of the new features are certainly sweet. The latest is the addition of the :only and :except options to RESTful routes.

    Normally, using map.resources creates routes for all seven of the default actions (index, show, new, create, edit, update, and destroy) for the resource. But in Rails 2.2 (or in the current edge builds), you can fine-tune this behavior. The :only option specifies that only certain routes should be generated:

    
    map.resources :customers, :only => [:index, :show, :destroy]
    

    As with most places in Rails, you can use :except as the opposite of :only:

    
    map.resources :customers, :except => :index
    

    That declaration would give you six of the seven default routes, omitting only a route for the index action.

    In addition to an action or an array of actions, you can also supply the special symbols :all or :none to the :only and :except options.

    Why do this? In addition to making your code easier to follow, the smaller you can make the routing table, the less memory it will take up - and the less processing time route recognition and generation will take. It can also lower the attack surface of your application by removing unused routes, which is a security win.

  • SWFUpload, Paperclip and Ruby on Rails - I find myself needing to implement SWFUpload again. This is a good wrapup post on the issues in Rails, though I think I’m going to need to tweak it a bit to work with Authlogic.
  • File Type Detection (RSpec & Rails) - Notes on sorting filetype detection out in TextMate.
  • Uploading to multiple S3 buckets with Paperclip and Rails - A very useful technique to increase the speed of showing multiple images on a single page.
  • Paperclip Extended - Some useful extra functions for Paperclip.
  • Rails Meets Sinatra - Serving two frameworks through one application.
  • If by some chance you missed it, I’m now doing the edge Rails updates for the Riding Rails weblog. Oh, and I’m writing for Ruby Inside and Rails Inside now too. So, you know, I have more outlets for your important news :)

  • A critical look at the current state of Ruby testing - Something of a rant from Dan Croak. It’s liable to provoke heated discussion.
  • Hoshi 0.1.0 Released…Soon - This looks like an interesting way to attack the generation and recognition of HTML from pure Ruby code. (via RubyFlow)
  • The RSpec Book: Behaviour Driven Development with Ruby - Looks like this one is on the way for April. No pre-order link yet though.
  • Live Textile JS Preview - A useful tool if you need to proofread Textile-marked up text.
  • SimplySearchable plugin - A new take on automatically building some useful named scopes.
  • A major milestone for DB2 on Rails - Those who think Rails has no place in the enterprise should note that IBM is officially supporting it with a brand-new DB2 adapter, including transactional migration support. (via Riding Rails)
  • Do you know when your code runs? - If you don’t, you can get into trouble moving from development to production.
  • Legos, Play-Doh, and Programming - Coding philosophy from Jamis Buck.
  • 7 Stages of Scaling Web Applications - Overview slides from Rackspace.
  • Rail’s Dev Mode Performance Plugin - Josh Goebel wants to speed up your Rails in development mode.
  • Merb 1.0 - It’s out. You can also get a ton of links from Ruby Inside.
  • wee_lightbox rails plugin - This actually seems to work rather well to get Lightbox integrated with Rails.
  • Well, I still have hours to sell, but a couple of little projects appear to be coming together, so hopefully I won’t be on the bench for too long.

  • Scaling Ruby - The latest EnvyCast. I heard some good things about this material being presented at RubyConf.
  • Rubular - Ruby regular expression editor online.
  • Bort Update to Rails 2.2 - This prepackaged Rails solution, including various bells and whistles, is in active development.
  • A few reasons braid is better than 40 lines of Rake. - After wrestling with a rake-based git subtrees solution for a while, I’m getting inclined to agree that there must be a better way.
  • You probably already know (well, if you’re a Rails developer) that you can use to_xml or to_json to quickly get XML or JSON representations of Active Record model instances. But did you know that these methods are configurable? By default they simply dump all of the attributes of the model along with their values, but if you want to do something different, you can - and usually without overriding the base methods.

    To start, you can specify exactly which attributes to export with the :only or :except options:

    
    @user.to_xml :only => [ :name, :phone ]
    @user.to_xml :except => :password
    @user.to_json :only => [ :name, :phone ]
    @user.to_json :except => :password 
    

    You can include associated records, nesting as needed, with the :include option:

    
    @user.to_xml :include => {:orders =>
      { :include => [:shipments, :backorders] }}
     @user.to_json {:orders =>
      { :include => [:shipments, :backorders] }}
    

    :only and :except also work on includes:

    
    @user.to_xml :include => {:orders =>
      { :include => [:shipments, :backorders] },
      :only => :order_date }
    @user.to_json {:orders =>
      { :include => [:shipments, :backorders] },
      :only => :order_date }
    

    You can create XML or JSON attributes from model methods by using the :methods option:

    
    @user.to_xml :methods => :permalink
    @user.to_json :methods => :permalink 
    

    Additionally, there are some options that apply only to to_xml. :skip_instruct suppresses the XML processing instruction. :skip_types suppresses the output of types to the XML. :dasherize => false turns off dasherization of column names.

    I’ve shut down and reformatted my Windows desktop for good (I hadn’t turned it on for six months or so, it just took me this long to get around to reformatting the drives). If anyone wants a deal on a Dell PowerEdge 1800 server before I EBay it, holler.

  • We’ve stopped using rSpec … - And ignited a bunch of debate in comments. Caboose has bailed out; the comment chain is interesting for a glimpse of what testing solutions the community is using.
  • Google Analytics plugin - Finally got around to making some doc and feature improvements to my fork of this project.
  • giternal - An alternative for managing git externals in your Rails project. Or any other project, for that matter.
  • If you take a look at the Rails source code, you’ll find numerous useful comments like this one from ActionController::Base:

    
    # All requests are considered local by default, so everyone
    # will be exposed to detailed debugging screens on errors.
    # When the application is ready to go public, this should be set to
    # false, and the protected method <tt>local_request?</tt>
    # should instead be implemented in the controller to determine
    # when debugging screens should be shown.
    @@consider_all_requests_local = true
    cattr_accessor :consider_all_requests_local
    

    But if you check your favorite Rails API site for documentation of consider_all_requests_local, you’ll come up blank. What’s up?

    I spent some time chasing this, and it turns out to be a conflict between the way that Rails is commented and the way that rdoc thinks things should be done. There’s actually a ticket in the old Rails Trac with a proposed resolution for this. As it happens, that ticket isn’t quite right, but it provoked rdoc into changing things. The secret lies in the rdoc 2.x support for documenting metaprogrammed methods.

    To properly document cattr_accessor (and similar) declarations in your own Rails code, you need to do two things. First, upgrade from your musty old rdoc 1.0.1 to a more recent version - 2.2.1 is current. If you look at their downloads you will find there is a gem version, but just installing this may not be enough: putting the gem on my system gave me rdoc 2 from the command line but rdoc 1 from rake tasks. That’s because (at least on my Mac), rdoc is also out there in the ruby/1.8 standard tree, and so I had to replace the 1.0.1 there with the new bits.

    Second, you need to change your markup comments to tell rdoc that this is a metaprogrammed method. Here’s the revision for that method from ActiveController::Base:

    
    @@consider_all_requests_local = true
    ##
    # :singleton-method:
    # All requests are considered local by default, so everyone
    # will be exposed to detailed debugging screens on errors.
    # When the application is ready to go public, this should be set to
    # false, and the protected method <tt>local_request?</tt>
    # should instead be implemented in the controller to determine
    # when debugging screens should be shown.
    cattr_accessor :consider_all_requests_local
    

    The ## indicator tells rdoc that this is a metaprogrammed method, which means it will ignore the first token on the declaration and pick up the second one as the method name. The # :singleton-method# indicator tells rdoc to document this as a class method rather than as an instance method.

    The Rails Documentation team is exploring how we’ll fix up the core Rails source to use the new markers. Meanwhile, you should start using this anywhere that you have the cattr methods in your own code or plugins - and upgrade your rdoc bits in anticipation.

    Yesterday saw my first posting to the official Rails weblog. A nice step on the way to world domination, I guess.

  • Gerrit and Repo, the Android Source Management Tools - Google has built some tools to make git work better for large-scale projects, including workflow and code-review bits.
  • RubyMine Public Preview - JetBrains is getting into the Rails IDE business. I may take a look, though honestly, two years after closing the IDE I don’t miss it.
  • GitHub Code Search - A bit of poking around here reveals that Ruby coders pretty much have a lock on the chunky bacon market.
  • Life on the Edge with Merb, DataMapper, and RSpec - Work-in-progress aimed for folks who might be thinking of switching from Rails.
  • ActiveSupport::Rescuable - Pratik Naik shows how to mix this into your own code with Rails 2.2.
  • 40 Beautiful Free Icon Sets - Some nice stuff out there; be sure to check the fine print before using.
  • In Rails 2.2, if you include a belongs_to or references column in a call to the model generator, it will automatically add the belongs_to declaration to the model, as well as creating the foreign key column in the migration.

    For example, run this from the command line:

    script/generate model order order_date:datetime customer:belongs_to

    And you’ll find that the generated Order model looks like this:

    
    class Order < ActiveRecord::Base
      belongs_to :customer
    end
    

    Nothing earthshaking, but it will save you a few keystrokes.

    Personally, I think we ought to explore the possibilities of making the model generator much more full-featured. I don’t see any reason why it couldn’t build validations, associations, and accessibility declarations at generation time. As a first step on this road, I’ve submitted a Rails patch. If you like the idea (and you’ve got a copy of edge hanging around), go give it a try and let me know what you think.

    I tossed out a few more bits of open source code over the weekend: a fork of suprails (though actually I hope the original project just merges my one tiny change), and a proposed change for Rails core (which you’re welcome to go test and, hopefully, +1).

  • When autotest fails - Apparently RSpec has a built-in server to speed up running tests. Unfortunately, I’ve not been able to get it working in my own projects.
  • The Sorry State of Blogging Software - Adam bemoans the Rails blogging infrastructure, among other choices.
  • Drag and Drop Sorting with JQuery and Rails - Ben Curtis shows how to do it.
  • Turn-Key: SaaS Rails Find Home in Morph AppSpace - Morph now offers one-click deployment for Beast, El Dorado, Substruct, and Tracks.
  • rboard - Rails-based forums that I need to look at the next time I have need of such a thing.
  • Maybe it’s just me and the amount of support and writing I’m doing these days, but I find myself fairly frequently looking at a bit of core Rails code and wondering “what that in release X”? To help figure that out, here’s a list of Rails version release dates (starting with 1.0) pulled together from the svn and git repos:

    12/13/05 1.0.0
    
     3/22/06 1.1.0 RC1
     3/28/06 1.1.0
     4/06/06 1.1.1
     4/09/06 1.1.2
     6/28/06 1.1.3
     6/30/06 1.1.4
     8/09/06 1.1.5
     8/10/06 1.1.6
    
    11/23/06 1.2.0 RC1
     1/05/07 1.2.0 RC2
     1/18/07 1.2.0
     1/18/07 1.2.1
     2/06/07 1.2.2
     3/14/07 1.2.3
    10/05/07 1.2.4
    10/12/07 1.2.5
    11/24/07 1.2.6
    
     9/30/07 2.0.0 PR (Preview Release)
    11/09/07 2.0.0 RC1
    11/29/07 2.0.0 RC2
    12/07/07 2.0.0
    12/07/07 2.0.1 (2.0 final)
    12/16/07 2.0.2
     5/11/08 2.0.3
     9/04/08 2.0.4
    10/19/08 2.0.5
    
     5/11/08 2.1.0 RC1
     5/31/08 2.1.0
     9/04/08 2.1.1
    10/23/08 2.1.2
    
    10/24/08 2.2.0 (2.2 RC1)
    11/14/08 2.2.1 (2.2 RC2)