In my opinion, this debate is like having a debate about cars vs. pickup trucks. There are valid pros/cons to buying cars and valid pros/cons to buying pickup trucks. In fact, it’s totally valid for one person to own both a car and a pickup truck! Gasp! I know, it’s mind-blowing!

I’ll add that, as a proponent of MongoDB, I definitely think the right NoSQL database is a better solution in many ways for much of the web-app databasing that was previously handled by relational DBs. But my saying that in no way indicates that I think SQL is dead, relational is dead, or anything of that sort. This is a classic ‘right tools for the job’ discussion.

If there’s any debate at all, maybe it’s around what, specifically, the best use cases are for each type of database, but I’d prefer that we stop referring to that as a debate and instead just see it as an ongoing evolution and discussion. Creating conflict where there doesn’t need to be any solves nothing and makes us all look bad.

Take it for what it is: a point of discussion.

Of course, the skeleton of any Rails app will vary from project to project, depending on needs.  Agile approach is to only add it to your framework if you actually need it right now, though some stuff tends to be easier to use (like authentication systems and databases) if you build it in up-front.  That tends to be my approach for green-fielding Rails apps.

If you’ve got some favorites that you use, feel free to post in the comments about it! I’m always interested in hearing about new stuff that makes my life easier/more fun.

FOR MY ACTIVERECORD-BASED APPS

• inherited_resources
  • for building clean, simple resource-oriented controllers.  the Rails 3.0 guys recommend you start using this with Rails 2.3.5 apps because Rails 3.0′s new controller syntax is basically derived from inherited_resources (and jose valim is on the rails core team now)
• authlogic
  • the reigning champ (in my opinion) for a while in terms of a really simple, basic user authentication solution.  i’ve also tried clearance, lockdown, ye olde restful_authentication, and others.  I still like authlogic alot, but the new Devise system seems to be really solid and might be good enough to get me to switch for new apps
• searchlogic
  • really handy extra methods for activerecord queries
• haml / sass
  • blah blah blah http://blog.digimonkey.com/2010/02/why-use-haml-and-sass-i-already-know-html/
• formtastic — http://github.com/justinfrench/formtastic
  • if you intend to produce semantically-correct, standards-compliant xhtml, your biggest enemy is trying to get forms to both look right and be semantic xhtml.  formtastic takes you a long way towards that goal, while also cleaning up your views significantly. and if you need to do something weird for a form that doesn’t quite work with formtastic, it doesn’t get in your way.
• compass + blueprint
  • blueprint is just a CSS framework for laying out 950px wide fixed layouts in a clean way; particularly great for multi-column layouts, which can be notoriously tricky to get right and cross-browser
  • compass adds a layer on top of blueprint + Sass to make html/css design really easy and slick; saves you a TON of time and makes it easier to get the cross-browser stuff working (or 99% working) on the first try, instead of spending a whole day fighting IE 7
• hoptoad
  • exception notification to a third-party service that integrates with lighthouse, github, et al
• acts_as_state_machine
  • self-explanatory
• acts_as_taggable_on_steroids
• acts_as_rateable_with_weights (mine) – http://github.com/mepatterson/acts_as_rateable_with_weights
  • forked my own version of acts_as_rateable to add weighted ratings and bayesian averages
• will_paginate
  • makes it much easier to handle pagination on any enumerable object collection (ActiveRecord objects or not)
• ssl_requirement
  • allows you to lock down controller methods so they won’t work unless the requestor is hitting them through SSL
• statistics – http://github.com/acatighera/statistics
  • have used this exactly once.  liked it, but didn’t use a ton of its features.  seems pretty robust though.
• jrails plugin (+ nuke the prototype stuff and replace with jquery)
  • self-explanatory; prototype is dead. long live jquery.
• xapian or thinking_sphinx
  • i’ve gone through so many different search engines for so many projects.  I think I’m the only one using Xapian.  It actually works pretty well, but is lacking in a lot of ways.  Thinking sphinx is similar; easier Rails integration, but missing some stuff, though it’s highlighting and excerpting work nicely.
• paperclip
  • super-simple file attachments on ActiveRecord models
• carmen — http://github.com/jim/carmen
  • “helpful collection of geographic names and abbreviations for Rails apps (includes replacements for country_select and state_select)”
• stringex — http://github.com/rsl/stringex
  • helpful assortment of extra string methods
• admin-data — http://github.com/neerajdotname/admin_data
  • every app ends up needing some sort of admin backend to rifle through the data layer, at the very least in development mode; pretty useful
• bullet — http://github.com/flyerhzm/bullet
  • stupid-simple plugin that helps you find N+1 queries and other query performance problems
• factory_girl, shoulda, faker
  • i liked factory_girl a lot until my company started using machinist, so now I think I like that better.  shoulda is great.  faker is indispensable, imho.
• db-populate – http://github.com/ffmike/db-populate
  • i’ve been using this in my older AR-backed apps.  probably won’t need it in 2.3.5 or 3.0 apps, though i do like how ffmike did db-populate.  i think it might still be more robust than the db:seed thing built-in to Rails

FOR MY MONGO_MAPPER APPS

• mongo
  • [GEM] the base MongoDB ruby driver
• mongo_ext
  • [GEM] C-extensions for the above to make it perform better
• mongo_mapper
  • [GEM] John Nunemaker’s thin ORM layer for Mongo.  fairly young and poorly documented, but it’s such a thin wrapper that it hasn’t been a problem for me.  just gives you some basic ActiveRecord-ish relationships and conveniences for using Mongo Documents and EmbeddedDocuments with standard Ruby models.
  • http://railstips.org/blog/archives/2009/06/27/mongomapper-the-rad-mongo-wrapper/
  • http://railstips.org/blog/archives/2009/12/18/why-i-think-mongo-is-to-databases-what-rails-was-to-frameworks/
  • http://rdoc.info/projects/jnunemaker/mongomapper
• sunspot[GEM] + sunspot_rails[GEM] (with custom config for mongo support) – http://github.com/outoftime/sunspot
  • found that sunspot integrates the solr search engine more easily with mongo than anything else out there.  has a lot of nice features, and it does automatic indexing on the fly, rather than requiring some sort of nasty cron job or handrolled delta-indexing solution
• handrolled auth system derived in part from authlogic
  • so, i probably should start using Devise, since it apparently has native mongo_mapper support.  but for the two mongo apps I’ve built thus far, i just handrolled a simple authentication system by adapting the core code from authlogic and removing all the ActiveRecord-specific bits.  works fine, easy to add on custom stuff.  but Devise is probably better for the future.
• machinist, shoulda, faker
  • see above
• acts_as_mongo_rateable (mine) — http://github.com/mepatterson/acts_as_mongo_rateable
  • I wrote this from scratch, inspired by the basic architecture of the acts_as_rateable plugin for ActiveRecord
• acts_as_mongo_taggable (mine) – http://github.com/mepatterson/acts_as_mongo_taggable
  • I wrote this from scratch, inspired by the basic architecture of the acts_as_taggable_on_steroids plugin for ActiveRecord
• will_paginate
  • works fine with any enumerable object, so works with Mongo
• compass + blueprint
  • see above
• haml / sass
  • see above
• jrails plugin (+ jquery instead of prototype)
  • see above
• inherited_resources
  • this works largely the same with Mongo, since your resource-based controller shouldn’t really have any direct dependence on your database ORM
• hoptoad
  • see above

STUFF I’D LIKE TO USE/WANT TO INVESTIGATE FURTHER

• devise – http://github.com/plataformatec/devise
  • has mongo support baked in!  looks really cool and has a lot of robust functionality.
  • example using with mongomapper – http://github.com/theshortcut/devise_mongomapper_example
• easy ESI — http://github.com/grosser/easy_esi
  • haven’t looked at it much; seems like an interesting approach
• aegis – http://github.com/makandra/aegis
  • seems like a really nice way to do complicated roles and permissions.  haven’t used it though.  dunno if it will work with any of the good auth systems like devise, clearance, authlogic, etc.  in most cases, might just be easier to write your own simple roles system (which is what i’ve done in ALL cases)

Given: a Users collection where the users’ names are stored in an Array key called name. i.e. :name => ["Patterson", "Matt"]. It can be any length, so if they want middle names or titles or whatever, it just gets stuck in there as an element on the array.

Problem: Need to create a really quick lookup to do autocomplete when someone is looking for a particular person in the database.

Solution:

So when the user types “m” into the autocomplete field, it will quickly populate the suggestions with ["Patterson", "Matt"] and ["Magdalene", "Mary"] and ["Munchausen", "Baron"] and ["Mr.", "John", "Arbuckle"]. But it won’t pickup people with ‘m’ in the middle of any of their name components, like ["Hammer", "Captain"].

How simple is that?

UPDATE: 11 Apr 2010
As it turns out, you can make the above even faster:

without the ‘.*’ bit, apparently mongo’s regex implementation gets a huge speed boost since it’s not having to parse the rest of the string once it hits a match.

So, I had to fool around a bit to get the so-called “Mongosphinx” gem working with my app architecture. Thought it might be helpful to others to demonstrate how I did it. I’ll boil it down to a generic sort of implementation. Hit the jump to see the whole bloody mess…

app/models/document.rb

I’ll illuminate some of that for you.

If you’ve been using MongoMapper, most of the key stuff should be obvious already. The ‘sphinx_tags’ is a special trick I cooked up to make this work well with my acts_as_mongo_taggable plugin. Basically, whenever a Document is saved/updated, I jam a single string into the sphinx_tags field in Mongo. This lets sphinx index those tags easily.

The search just takes advantage of Mongosphinx’s normal by_fulltext_index method.

The reindex thing, while probably a hacky solution, works well enough for now that I don’t have a need to do anything fancier. This lets us have the app be reasonably quick to include newly-created documents in the index to be available for search. And I take advantage of GridFS (built into Mongo) to store my last_run value so I don’t even need a cron job for this. If my app starts getting significant document-creation traffic, I might want to do something more sophisticated like delta indexing or whatnot, but for now this is fine for me.

lib/tasks/sphinx.rake

Okay, moving on to the aforementioned rake tasks… Here are the contents of my lib/tasks/sphinx.rake file:

So this should be pretty self-explanatory, especially if you’ve already used acts_as_sphinx with a standard ActiveRecord-backed app. After you’ve gotten everything (sphinx and the mongosphinx gem, specifically) installed, you should be able to use these rake tasks to start and stop the searchd daemon, as well as run the indexer.

(update 1/22/10: Note that I’m suggesting you get dacort’s fork of mongosphinx. He’s done a nice job of adding excerpting, pagination, and better compatibility with the latest mongomapper. He also pulled in my fix that makes it play nice with ruby 1.9.)

One nicety here is the sphinx:genxml task. Running this is helpful when you’re trying to get everything setup, to prove that you’ve done things right. It should output a big XML file of all the documents it would index. If it doesn’t, or you get something weird, then ur doin’ it wrong.

config/sphinx.conf

Finally, to help you get up and running, here’s my config/sphinx.conf file. Pretty standard:

Again, all of this may fall down spectacularly once you get up to some serious data being pushed from the app into the indexer. At that point, do something else, something more awesome. But consider this a basic start on jamming data from your mongo collection(s) right up sphinx’s pipe.