Medium eXposure

script/migrator for navigating migrations

hakunin — Thu, 04 Feb 2010 03:02:39 +0000

I got tired of digging through migrations, so here’s a simple console navigator. The instructions are all in there.

Rails 3 Reading Material

hakunin — Thu, 21 Jan 2010 10:25:45 +0000

Rails 3 is going to bring a lot of new stuff to the table. Wouldn’t hurt to organize some reading material in categorized and chronological order. So here goes whatever I scavenged so far. Leave comments so I can add more links or if I should mark something as obsolete.

Router

Revamped Routes in Rails 3 (12/20/09) — Examples of usage of the Rails 3 router.
Generic Actions in Rails 3 (12/20/09) — Interesting things you can do with Rails 3 routes.
The Rails 3 Router: Rack it Up (12/26/09) — A description of important design decisions made for the new Rails 3 router.

ActiveRecord

ActiveModel: Make Any Ruby Object Feel Like ActiveRecord (01/10/10) — Learn about the ActiveModel API.
Let your SQL Growl in Rails 3 (01/17/10) — A neat trick and an example on how to use Rails 3 subscription models.
Active Record Query Interface 3.0 (01/22/10) – The new ActiveRecord API (based on ARel) thoroughly explained.

Controllers

Dynamic session expiration time in Rails 3 (01/16/10) — An insight on how Rails 3 handles session cookies and a convenience plugin.
Render Options in Rails 3 (01/18/10) — Those render methods you call in your controllers: learn about their options in Rails 3.

ActionMailer

New ActionMailer API in Rails 3.0 (01/26/10) — ActionMailer now shares lots of logic with controllers, learn its new API.

Views

SafeBuffers and Rails 3.0 (02/01/10) — Learn about html_safe strings in Rails 3.0.

Generators

Making Generators for Rails 3 with Thor (01/15/10) — A thorough tutorial on how to create, gemify, and test Rails 3 generators.
Discovering Rails 3 generators (01/18/10) — A few important points to know about Rails 3 generators.

Running Rails 3 App

Spinning up a new Rails app (12/31/09) — One of the first posts on how to spin up a new Rails 3 app.
Rails 3 and Passenger (01/17/10) — A few tips on how to run Rails 3 on passenger.
Rails 2 & Rails 3 side by side (01/28/10) — Juggling both versions of rails on the same system (check comments too).
From Zero to Rails3 on Windows in 600 seconds (01/30/10) — Get a Rails 3 app running on Windows.

Upgrading to Rails 3

Upgrading an Application to Rails 3 — Part 1 (01/17/10) — Learn how to upgrade your Rails 2 app to Rails 3.
Migrating a Rails App from 2.x to 3.0 (01/17/10) — Another tutorial on steps needed to upgrade your Rails app.
Notes from the field upgrading to Rails 3 (01/20/10) — Thanks to bugmash there are now a few of these upgrade guides.
Getting Up To Speed With Rails 3 (01/22/10) — Good article on upgrading to Rails 3 and deploying with capistrano and passenger.
The Path to Rails 3: Approaching the upgrade (01/26/10) — Second part in series on understanding Rails 3, this one focusing on upgrade of existing app.
rails-upgrade: Automating a portion of the Rails 3 upgrade process (01/29/10) — Third part where a plugin is introduced to help automate the upgrade.
rails-upgrade is now an official plugin (02/01/10) — rails-upgrade is now an official rails tool (as in it sits under github.com/rails and rails team takes part in maintaining it).

Plugin/Gem Compatibility

Rails Bugmash 2010 (01/16/10) — Notes on how to get certain popular gems/plugins to run on Rails 3.
Notes from Rails 3 bugmash (01/17/10) — Another set of plugin/gem compatibility notes and Rails 3 discoveries.
Rails 3 Plugins and Gems — this wiki page lists major plugins and gems which have been verified to be Rails 3 compatible (or not).

Overall Architecture

My Five Favorite Things About Rails 3 (08/18/09) — Early view on what’s getting into Rails 3
The Path to Rails 3: Introduction (01/20/10) — A detailed description of architectural changes in Rails 3 (with pics).

Yehuda Katz Series on Rails 3 Progress

Rails and Merb Merge: The Anniversary (Part 1 of 6) (12/23/09) — On refactoring Rails components for modularity.
Rails and Merb Merge: Performance (Part 2 of 6) (12/29/09) — On improving rendering/routing performance.
Rails and Merb Merge: Plugin API (Part 3 of 6) (01/11/10) — On API for plugin developers.
Rails and Merb Merge: Rails Core (Part 4 of 6) (01/22/10) — On refactoring Rails core for modularity.

Multiple Table Inheritance with ActiveRecord

hakunin — Thu, 21 Jan 2010 04:01:40 +0000

Update 02/02/10: There are two new sections: Fixing method_missing and Handling attributes hash, which fix a few issues that popped up since first post.

If you aren’t interested in reading all the details you may want to make the long story short.

Imagine writing an online shop with different types of products. Normally all products would have common attributes such as title and price. Some attributes will likely differ. Tee may have size such as S, M, or L, while a Pen could have an ink_color. It’s easy to see that Tee is a Product, and so is Pen. We are looking at an is_a relationship. When I program this type of relationship I usually use inheritance.

class Product < ActiveRecord::Base
end

class Tee < Product
end

class Pen < Product
end

This inheritance looks reasonable, but now we have to come up with relational database structure. We need to find a way to store tee’s own attributes, pen’s own attributes, as well as their common (product’s) attributes without duplication. Some databases (PostgreSQL) provide support for table inheritance, but it’s a specialized feature which ties you down to the given db.

Single Table Inheritance

ActiveRecord provides only one way to handle a is_a relationship which is Single Table Inheritance. You’d have to create a table looking somewhat like the following.

+----+------+-------+-----------------+------+-----------+
| id | type | price | title | size | ink_color |
+----+------+-------+-----------------+------+-----------+
| 1 | Tee | 1000 | tie-dye t-shirt | M | |
| 2 | Pen | 500 | ball pen | | blue |
+----+------+-------+-----------------+------+-----------+

The problem here is that all attributes are stored in the same table. It’s likely that soon the number of attributes will grow unmanageable, and most of them will always stay NULL since they’ll be specific to only one type.

Polymorphic has_one Association

A has_one association allows us to split out tees, pens, and products into three different tables. In fact — as you’re about to see — this is the only way to get what we want. The problem is that it creates a has_a relationship, and we want is_a. Since there isn’t much choice, we can make it look like we have an is_a relationship, which I’m about to show.

Multiple Table Inheritance (Simulated)

I was speaking with the awesome @fowlduck over at #railsbridge IRC channel about ways to achieve something like MTI with Active Record. He pointed me to a pastie where he implemented an MTI-like behavior and called it a “hydra” pattern, which I subsequently cleaned up a bit.

So we want to have 3 tables in the database.

product_properties
tees
pens

class ProductProperties < ActiveRecord::Base
belongs_to :sellable, :polymorphic => true, :dependent => :destroy
end

class Tee < ActiveRecord::Base
has_one :product_properties, :as => :sellable, :autosave => true
end

class Pen < ActiveRecord::Base
has_one :product_properties, :as => :sellable, :autosave => true
end

Immediately we can see duplicated code between Tee and Pen. This can be easily solved with a mixin.

module Sellable
def self.included(base)
base.has_one :product_properties, :as => :sellable, :autosave => true
end
end

class Tee < ActiveRecord::Base
include Sellable
end

class Pen < ActiveRecord::Base
include Sellable
end

Now comes another issue. Every time we want to access price or title attributes (stored in product_properties) we have to call @tee.product_properties.price. This isn’t very convenient, especially considering that product_properties has to be built first in case it doesn’t exist. So let’s ensure it’s always built by updating the module.

Awesome, now product_properties is built automatically in case it doesn’t exist. We still have the method accessing issue though. For that I used method_missing.

module Sellable
def self.included(base)
base.has_one :product_properties, :as => :sellable, :autosave => true
base.alias_method_chain :product_properties, :autobuild
end

def product_properties_with_autobuild
product_properties_without_autobuild || build_product_properties
end

def method_missing(meth, *args, &blk)
if product_properties.public_methods.include?(meth.to_s)
product_properties.send(meth, *args, &blk)
else
super
end
end
end

Now if a method is missing from Tee or Pen instance it will be delegated to product_properties, which enables us to use @tee.price and @tee.title.

However, what about validations? Let’s say we want all products to always have a title, and we want to see an error appear on a Tee instance when ProductProperties#title is missing. Basically I want to completely remove product_properties from my sight as if it doesn’t exist, make it absolutely transparent. Let’s add the necessary validation in ProductProperties.

class ProductProperties < ActiveRecord::Base
belongs_to :sellable, :polymorphic => true, :dependent => :destroy
validates_presence_of :title
end

And now let’s make all Sellable models respect the validation as if it’s their own.

module Sellable
def self.included(base)
base.has_one :product_properties, :as => :sellable, :autosave => true
base.validate :product_properties_must_be_valid
base.alias_method_chain :product_properties, :autobuild
end

def product_properties_with_autobuild
product_properties_without_autobuild || build_product_properties
end

def method_missing(meth, *args, &blk)
if product_properties.public_methods.include?(meth.to_s)
product_properties.send(meth, *args, &blk)
else
super
end
end

protected
def product_properties_must_be_valid
unless product_properties.valid?
product_properties.errors.each do |attr, message|
errors.add(attr, message)
end
end
end
end

Notice that I’m including an additional validator with the Sellable module. The validator collects all the errors on ProductProperties and adds them to parent class as if the errors are on a Tee or Pen itself.

As a nice finishing touch we can put this snippet into a Rails initializer.

class ActiveRecord::Base
def self.acts_as_product
include Sellable
end
end

# now we can say

class Tee < ActiveRecord::Base
acts_as_product
end

Although that’s a matter of taste.

Fixing method_missing

There is a problem with method_missing. It checks the array of public_methods on product_properties to find out if delegation should occur. This check will fail in cases like @tee.title_changed?. That’s a magic method and therefore will not be part of static method array. Well, this is an easy fix.

# Replace old method_missing with this one:
def method_missing(meth, *args, &blk)
product_properties.send(meth, *args, &blk)
rescue NoMethodError
super
end

As you can see, even magic methods will work this way. Only if a NoMethodError is thrown we withdraw back into super.

Handling attributes hash

In the comments Austin brought up a case where initializing new models like Tee.new(:title => "foo") will throw an unknown attribute error. That’s expected since we rely on method_missing for accessing ProductProperties attributes. Instead we should define accessor methods explicitly in our individual products. Thankfully, it’s not too hard to accomplish with our Sellable mixin. First we need to add a submodule ClassMethods with a class method that uses class_eval to magically generate missing attributes.

module ClassMethods
def define_product_properties_accessors
all_attributes = ProductProperties.content_columns.map(&:name)
ignored_attributes = ["created_at", "updated_at", "sellable_type"]
attributes_to_delegate = all_attributes - ignored_attributes
attributes_to_delegate.each do |attrib|
class_eval <<-RUBY
def #{attrib}
product_properties.#{attrib}
end

def #{attrib}=(value)
self.product_properties.#{attrib} = value
end

def #{attrib}?
self.product_properties.#{attrib}?
end
RUBY
end
end
end

I’ll walk through this code quickly. First we’re extracting only the columns that we want to access. When we call content_columns in the first line of the method, it already excludes a bunch of special columns such as id and type. We then manually subtract more columns we’d like to ignore, such as timestamps, and polymorphic type.

Next we iterate over each remaining attribute and creating instance methods for it, such as title, title= and (for completeness) title?. Having these accessors defined explicitly is enough for ActiveRecord to see them when performing mass assignment, etc. We can now do something like Tee.new(:title => "foo") without any problems. The extra cases such as @tee.title_changed? are still handled by method_missing so we’re good.

One more thing left. We need to run this method on the base class into which we include Sellable. Just need to add a couple of lines to the self.included hook.

def self.included(base)
base.has_one :product_properties, :as => :sellable, :autosave => true
base.validate :product_properties_must_be_valid
base.alias_method_chain :product_properties, :autobuild

# Add these two lines:
base.extend ClassMethods
base.define_product_properties_accessors
end

And we’re all set.

All together now

Here’s the full picture of everything we just did.

class ActiveRecord::Base
def self.acts_as_product
include Sellable
end
end

class ProductProperties < ActiveRecord::Base
belongs_to :sellable, :polymorphic => true, :dependent => :destroy
validates_presence_of :title # for example
end

module Sellable
def self.included(base)
base.has_one :product_properties, :as => :sellable, :autosave => true
base.validate :product_properties_must_be_valid
base.alias_method_chain :product_properties, :autobuild
base.extend ClassMethods
base.define_product_properties_accessors
end

def product_properties_with_autobuild
product_properties_without_autobuild || build_product_properties
end

def method_missing(meth, *args, &blk)
product_properties.send(meth, *args, &blk)
rescue NoMethodError
super
end

module ClassMethods
def define_product_properties_accessors
all_attributes = ProductProperties.content_columns.map(&:name)
ignored_attributes = ["created_at", "updated_at", "sellable_type"]
attributes_to_delegate = all_attributes - ignored_attributes
attributes_to_delegate.each do |attrib|
class_eval <<-RUBY
def #{attrib}
product_properties.#{attrib}
end

def #{attrib}=(value)
self.product_properties.#{attrib} = value
end

def #{attrib}?
self.product_properties.#{attrib}?
end
RUBY
end
end
end

protected
def product_properties_must_be_valid
unless product_properties.valid?
product_properties.errors.each do |attr, message|
errors.add(attr, message)
end
end
end
end

class Tee < ActiveRecord::Base
acts_as_product
end

class Pen < ActiveRecord::Base
acts_as_product
end

This can be easily adapted for any other use case besides products in a store. In fact, with some meta magic or code generation this can easily be made into a plugin which I encourage you to try and send me the link when you’re done. :)

Testing Helpers That Use Scoped Translations

hakunin — Mon, 02 Nov 2009 21:00:03 +0000

Update: While this technique is useful when you actually need to bind a template to your helper test, most of the time you can simply stub the helper right there, using something like stub(self).t('.title') { "Title" }

Once on a beautiful day the sun was shining and the room was full of pleasant warmth. I was whistling a tune happily to myself while writing the following rails helper.

def title(page_title, show_title = true)
content_for(:title) { t('.title', :default => page_title) }
@show_title = show_title
end

It’s so neat and simple. It allows you to write title "English Title" and provides a way to override title with translation scoped like pages.index.title.

Then came the test (apologies, TDD purists). Whistling along with the chirping birds I put the following in my helper test.

require 'test_helper'

class LayoutHelperTest < ActionView::TestCase
context "#title helper" do
should "create content for title" do
title("foobar")
assert_equal "foobar", @content_for_title
end
end
end

Suddenly the birds went silent. The room got colder and darker. I got an error.

NameError: undefined local variable or method `template' for #

Here’s what happened. Using scoped translations such as t('.title') requires a template. It makes perfect sense because scope can only be looked up for a particular template’s path. After some research I found that it’s quite easy to stub a template for tests to work. You can put something like this in your setup method.

# Using RR (http://github.com/btakita/rr) for stubbing.
# Easy to convert to equivalent in mocha/flexmock/etc.
stub(self).template { ActionView::Template.new "app/views/index.html.haml" }

This is the kind of usefulness that could easily be made into a helper. You can put this in your test_helper.rb.

def use_template(path)
stub(self).template { ActionView::Template.new File.join("app", "views", path) }
end

Now my test looks very neat.

require 'test_helper'

class LayoutHelperTest < ActionView::TestCase
context "#title helper" do
setup do
use_template "pages/index.html.haml"
end

should "create content for title" do
title("foobar")
assert_equal "foobar", @content_for_title
end
end
end

Running tests… Green! And birds are back!

Off Github

hakunin — Wed, 28 Oct 2009 16:36:10 +0000

Right about now everyone is switching away from GitHub gem host. It’s crappy enough that you have to edit environments in your config files — you also have to reinstall the big pile of gems on your machines. Cleaning up my big old gem list doesn’t strike me as a fun leisure time.

Off Github is there to make this process less painful. Run it on the machines where you have gems installed and it will help you get rid of github legacy.

Drier gem configs

hakunin — Tue, 27 Oct 2009 22:32:12 +0000

Update: This article is obsolete. Gemcutter should take first place in your gem sources. This way there is no reason to use :source option at all.

Now is the worst time for duplication in gem configs with all the changes going on. GitHub is not a gem host anymore. Soon RubyForge may follow the same path.

with_options provides a perfect way to minimize this duplication. I personally forgot it even existed until now. Watch how this mess:

config.gem "settingslogic", :source => "http://gemcutter.org"
config.gem "authlogic", :source => "http://gemcutter.org"
config.gem "compass", :source => "http://gemcutter.org"
config.gem "will_paginate", :source => "http://gemcutter.org"
config.gem "inherited_resources", :source => "http://gemcutter.org"
config.gem "haml", :source => "http://gemcutter.org"

becomes dry

config.with_options :source => "http://gemcutter.org" do |c|
c.gem "settingslogic"
c.gem "authlogic"
c.gem "compass"
c.gem "will_paginate"
c.gem "inherited_resources"
c.gem "haml"
end

Update: Forgot to mention that you need to require "active_support" in order for this to work in tests, etc. Thanks daeltar in comments.

My Tools of the Trade

hakunin — Mon, 12 Oct 2009 02:00:54 +0000

I used to be somewhat settled, living my stationary life in a Brooklyn apartment. Circumstances have changed in 2009, when I started to spend a lot of time on the go. This was the point at which all of the commitments, contracts, and physical commodities I had been piling up over the years have emerged in the form of monumental pain. It felt like a greasy, sticky pile of goo keeping me in place. There were car lease, apartment rent, phone contract to name a few. Each one is very costly to terminate. Above realizations have effectively changed the way I think. What used to be a passive crawl towards comfort-in-the-goo has now morphed into an active strive to achieve compactness and simplicity. A strive for “life in a backpack” if you will.

Certainly these changes have reflected on my tools of trade.

Backpack

Incase backpack

I had to search through half Manhattan for it (urgent at that moment). It fits everything I need to carry, which is essentially everything I listed here shy of the “Stationary Hardware” section.

Mobile Hardware

Late 2007 17” MacBook Pro

It has 2.6Ghz Core 2 Duo, 4GB RAM, and 200GB 7200RPM HDD. I do vast majority of the work on it.
Acer Aspire One

My “backup” computer (with 16Gb SSD and 16Gb SD card) running both WinXP and Ubuntu Netbook Remix. I use it primarily for leisure as I happen to be a fan of pre-2004 computer RPGs and strategies which netbooks are perfect for. Acer is good for programming too, since it sports an incredible 9hr battery which is perfect for long travels (although most would hate the small size constraint.)
Logitech Optical Notebook Mouse Plus

When it comes to mouse, I never understood wireless. Mouse is not a remote control, you only use it close to the screen, so why care about batteries or recharging? For me it’s just extra mental/physical weight. Therefore my choice is this neat, wire-wrapping simple mouse.
iPhone 3G
Nintendo DS

Stationary Hardware

Since I had some hardware accumulated over the years, and getting rid of it all wouldn’t make sense, I keep a couple of things in places where I spend most of the time. Mostly it comes down to the following two:

24” Samsung monitor

Located at one of my destinations.
1TB Seagate FreeAgent Pro HDD

Stationed at another location. I use it for time machine backups.

Misc

In this small pocket I keep all kinds of misc SD cards, USB thumb drives, and DS games.

Moleskine sketchbook — I’m not a proponent of using Balsamiq or other wireframe solutions, todo, or time management software. Instead I prefer a small sketchbook (notes and small drawings), a big sketchbook (wire-framing, mind-mapping), and a pencil. I like that particular linked sketchbook because IMHO reporter-style is more comfortable than normal book-style. Besides, I hate any kind of grid on the pages, hence plain.

Software

Firefox — I use it with (and because of) following extensions.
- 1Password — no more looking for wallet, and no more reusing of the same password.
- Adblock Plus — block ads (duh).
- All-in-One Sidebar — replaces all the meddling firefox popups (downloads/extensions/history panels) with a neat sidebar.
- CustomizeGoogle — tons of Google search customizations.
- DownloadHelper — because sometimes online flash players suck.
- Firebug — ultimate front-end debugger.
- Flagfox — I always found it fun to know in which country a website is hosted.
- GooglePreview — helps browse results and quickly know what to expect.
- Server Spy — quick and convenient way to know which server is running on visited websites. One more curiosity satisfier.
- Tab Kit — primary reason I’m sticking with Firefox. When you have > 30 tabs open at a time, and you’re using widescreen — vertical tabs are the way to go. Additionally, this plugin also does nesting and coloring which is incredibly useful for relating tabs to one-another (ie: links opened from this blog post will appear in tabs nested under the post’s tab).
- Ubiquity — this extension contains tons of awesomeness – you better see their screencast. However, I primarily use it as QuickSilver of Firefox. Opt+Space, type some words from the needed tab, Enter, the tab focuses. Incredibly useful when you have >30 tabs open.
- Web Developer — mostly for “disable cache” feature, different enable/disable shortcuts for javascript, css, etc, and cleaning cookies.
- XMarks — former Foxmarks for bookmark sync across browsers and computers.
- YSlow — a treasure chest of optimization tips and benchmarks for improving site performance.
TextMate — This is my code editor of choice. I also recently got interested in vim, and have been learning it, but haven’t really gotten comfortable enough to use it for most tasks.
NetNewsWire — This is a great RSS reader which syncs with Google Reader as well as its complementary iPhone app. Definitely my favorite.
Pwitter — I’m not a heavy twitterer. I want a simple, resource-friendly mac client which works with growl and has all basic features. Pwitter has met and exceeded (in a good way) everything I wanted from a twitter client. I think it’s pretty underestimated.
Thunderbird 3 — this is my shaky ground right now. I grew tired of how primitive Mail.app is. At the same time, I can’t keep gmail.com open. It runs flash which keeps crashing my browser under Snow Leopard. I was pleasantly surprised by the new features of Thunderbird 3. Among other additions, Mozilla taught it to speak the Gmail language (archiving, all mail, etc). This wasn’t the case in previous versions, which I disliked. It also serves as a great newsgroups reader, which I use to read comp.lang.ruby.
Terminal — this is another treasure chest of irreplaceable tools some of which have existed since Unix inception.
iTunes — helps me stay updated with podcasts such as Railscasts, RailsEnvy, and Ruby5.
GitX — Awesome git browser for mac with some repo-manipulating capabilities. However, I mostly use it for its staging convenience. Sometimes I do too much at once. GitX provides very convenient GUI to split all the unstaged mess into separate neat commits.
Photoshop — I’ve become quite comfortable with photoshop. Use it for any non-batch image tasks.
Cyberduck — this is my sftp client of choice. It’s free and works well for me.
Dropbox — great for quick file upload/sync/backup. Pics for this blog post were taken on iPhone, synced through dropbox, and are linked directly from there.
iCal — I tend to use reminders a lot. I also keep track of bills and projects this way. However, I prefer my physical notepad for daily goals.
QuickSilver — this is definitely my Swiss Army Knife. Irreplaceable for navigation and file operations.
ImageResizer — convenient little tool for batch image resizing.
Communication
- Skype — I work remotely a lot as you can imagine.
- Adium — looks like the best AOL/ICQ/YIM/MSN/GTK mac client out there.
- LimeChat – I used to like Colloquy, but its resource-hogging habits forced me to look for better alternatives. So far this has been incredibly nice and lightweight sporting all the features I need in an IRC client.

Hosting

Dreamhost — this is my sandbox environment. I don’t use it for anything but hosting this blog and some personal side-projects. The occasional bumpy service is justified by the price though.
WebFaction — a very easy-to-use, affordable, and incredibly fast/stable shared hosting. Currently runs two projects (Scripteka and Wehike) on one account without any problems.
Linode — our first stage heavy-weight. If an app is expected to have any significant load, this is where we start developing.
Turnkey Internet — we use this for dedicated servers because they seem to be the most affordable while having well-performing network. However, most of sysadmin burden goes on your shoulders. There are options with more support, but they aren’t cheap.
Heroku — lately this is the place I go for my personal Rails projects. The deployment strategy there is pretty freaking incredible.

Simplifying and compacting your life is not easy. I mostly try to have fewer tools covering broader range of tasks. This helps portability and keeps me sane. As opposed to Mike Gunderloy’s Tools of Trade my set tends to have very little overlap in functionality. Single image editor, single organizational tool, etc. Interestingly, I don’t actively pursue this concept. I just don’t feel the need for more yet. Surely this list will expand in the future.

This post was inspired by Mike Gunderloy’s Tools of Trade. I’d like to join him in encouraging you to write your own “Tools of Trade” post.

Rake script for managing Rails plugins with Git submodules

hakunin — Sat, 12 Sep 2009 18:47:59 +0000

Problem with gitmodules and rails plugins

Submodules aren’t very easy. You have to know a few things before messing with them. When installing you have to follow a bunch of steps in order to get them properly registered within git. Uninstalling is even sadder. You need to manually edit a couple of git config files, and perform some more git operations. When dealing with Rails plugins – you should also remember to check if plugin contains an install.rb/uninstall.rb hook and run them manually. This is enough repetitive crap for me to justify some automation.

Solution: Automation with Rake

Note: This solution is specifically for rails plugins hosted on github.

When I think automation in the context of Rails – I immediately think rake. Without further ado I present a rake script which takes care of all the aforementioned problems for you.

Automated module install – no need to run any git commands.
Automated module uninstall – no need to edit git config files by hand.
Automated running of install.rb/uninstall.rb plugin hooks.
Automated module updates.
Automatically uses github.

The usage is as simple as it gets. Read comments on top for list of available tasks.

Grab it here: http://gist.github.com/185746

Getting Rails 2.3.3 and Mocha >=0.9.6 to play nice with Test::Unit and Shoulda

hakunin — Sun, 02 Aug 2009 14:59:33 +0000

Simultaneous changes in Rails 2.3.3 and Mocha >=0.9.6 have caused some headaches in test::unit (or shoulda) tests. In my case I saw anomalies such as expectations persisting across tests. You put expects(:foo).never in test A and get “unsatisfied expectation” failure in test B where you happen to call :foo. This is due to unfortunate dependency on load order which could cause runner logic to be erroneously overridden. Here’s the steps you need to take to tidy up this setup to make sure it works correctly.

Update mocha to >= 0.9.7

~% sudo gem update mocha

Install test-unit gem

~% sudo gem install test-unit

Don’t load mocha yourself

If you had anything like this line in your test environment, REMOVE IT.

~~config.gem "mocha"~~

Ensure correct load order

If using Shoulda, make sure your test.rb environment loads test-unit before shoulda.

config.gem "test-unit", :lib => "test/unit", :version => ">=2.0.3"
config.gem "thoughtbot-shoulda", :lib => "shoulda", :source => "http://gems.github.com", :version => ">=2.10.1"

This should hopefully fix mocha issues with rails 2.3.3.

For more explanation check out this message on mocha’s mail list and this lighthouse ticket.

Avoiding nested blocks

hakunin — Thu, 16 Jul 2009 05:48:32 +0000

Today I had to silence some output streams so that messages don’t pollute the STDOUT. I used the silence_stream method built into Rails, described well in this article.

silence_stream(STDOUT) do
# ...my code...
end

Very nice, except I also wanted to filter STDERR output. Not a problem.

silence_stream(STDOUT, STDERR) do
# ...my code...
end

Well, shit. Here I got a “too many arguments” error. So it doesn’t support multiple streams. I guess it wants me to be ugly.

silence_stream(STDOUT) do
silence_stream(STDERR) do
# ...my code...
end
end

I personally don’t take kindly this level of suckiness around here. I want example #2 to work. Well, after lighting some candles and praying to the Ruby gods, I came up with a scary implementation. In fact it’s so spooky that it may have the same effect as glancing at the Mexican Starting Frog of Southern Sri Lanka. You may then throw a chair at me on the Jerry Springer show, so I rather not show it to you.

However, after having cleansed my .rb file with some broc flowers and xander roots I came up with a better solution. Recursion is the key. See if you can understand what is happening.

def silence_streams(*streams, &blk)
silence_stream(streams.pop) do
if streams.empty?
yield
else
silence_streams(*streams, &blk)
end
end
end

This is a basic use of recursion, which is not immediately clear when dealing with nested Ruby blocks. When multiple streams are passed in I’m popping out the last stream and silencing it alone, then calling the same method with the remaining streams. This is happening until only one stream left to silence. The last one gets silenced with the original block passed in, which means that the original block is executed at the deepest nesting level, where all passed streams are silenced. As a result I got this much desired functionality without resorting to eval, yay.

silence_streams(STDOUT, STDERR) do
# ...my code...
end

There we go. This solution can be applied to cases where you’d rather avoid overriding stuff (thus keeping out of method implementation details).

Update: Made recursion more concise thanks to apeiros on #railsbridge.