The Spotlight indexer process is now silent, and my battery life has doubled.

sudo gem install fastercsv --no-ri --no-rdoc

Better, though, is to set this up as the default in your ~/.gemrc file.

---
:verbose: true
:sources:
- http://gems.rubyforge.org/
- http://gems.github.com/
:update_sources: true
:backtrace: false
:bulk_threshold: 1000
:benchmark: false
gem: --no-ri --no-rdoc

Just add that last line and your gem installations will complete in no time.

For Caching
Let’s say that you’ve got some Users who have Roles.  These roles don’t change frequently at all, so they are prime candidates for caching.

class User < ActiveRecord::Base

  has_many :roles

  def roles_with_cache
    Rails.cache.fetch("user_roles/#{self.id}", :expires_in => 15.minutes) do
      roles_without_cache
    end
  end
  alias_method_chain :roles, :cache

end

When calling User#roles, the aliased method will try to fetch them from the cache first.  If they don’t exist there, they’ll be pulled from the database.

For Sharding
If you’re using the excellent DataFabric gem to shard your database, you know that your access (finders, etc.) to the sharded tables is done within a block.  We can use the same pattern from above to auto-shard access to these associated objects.

class User < ActiveRecord::Base

  has_many :tweets

  def tweets_with_shard
    self.in_shard { tweets_without_shard }
  end
  alias_method_chain :tweets, :shard

  def in_shard(&block)
    DataFabric.activate_shard(:store => shard, &block)
  end

end

Fun.  What other interesting uses for alias_method_chain on top of ActiveRecord associations have you seen?

You can find the slides HERE on SlideShare.

You can grab the code HERE on GitHub.

It’s awesome.  Well, it *was* awesome.

And then came the throttling.  Twitter throttling, that is, of unauthenticated GET requests against users’ public timelines.  This change meant that, if CampTweet polled Twitter more than 100 times in an hour for your teammates’ statuses, all subsequent requests from that IP received an error: Twitter REST Error (Bad Request).

Well…although it’s not a completely ideal solution, I’ve updated the camptweet gem to adjust its polling interval to keep it under the 100 reqs/hour limit.  After using this for a couple of weeks now at FiveRuns, the number of ‘Bad Request’ responses from Twitter has dropped dramatically and the turnaround on getting tweets into Campfire has greatly improved.

If you’re using CampTweet, I highly recommend that you get this update.  If you’re not using CampTweet, well…you should be.

sudo gem install camptweet

Enjoy!

>> Team.find(:all, :conditions => 'games_played > 500')
=> # [...a bunch of teams here...]

Oops.  I need to do a couple of operations on this set of teams.  Instead of retyping the above or going up/back in my irb history and changing the start of the line, I’ll just use the underscore. 

>> teams = _

Now, I can do what I originally wanted. 

>> winners = teams.select { |team| team.winning_percentage > 0.80 }.map(&:name)
>> losers = teams.select { |team| team.winning_percentage < 0.20 }.map(&:name)

Handy.

class CommandExecutor

  def execute(command)
    case command
    when StopClientCommand.name
      print "Stopping the Client..."
    when StartClientCommand.name
      print "Starting the Client..."
    when DisableClientCommand.name
      print "Disabling the Client..."
    else
      puts "Can't handle command: #{command}"
      return
    end

    puts "DONE."
  end

end

class StopClientCommand; end
class StartClientCommand; end
class DisableClientCommand; end

executor = CommandExecutor.new
executor.execute 'StopClientCommand'
executor.execute 'StartClientCommand'
executor.execute 'DisableClientCommand'

This code totally worked…

Stopping the Client...DONE.
Starting the Client...DONE.
Disabling the Client...DONE.

…but it gnawed at me that I was passing a string representation of the class name. It just felt dirty.

I pinged a colleague for input, and his reaction was immediate: “Oh, don’t pass a string; just pass and check for the actual class. It’s the more idiomatic way of doing class-checking.”

Ah, good to know. So…I made a couple of tweaks:

class CommandExecutor

  def execute(command)
    case command
    when StopClientCommand    # <-- check against a class, not a class name
      print "Stopping the Client..."
    when StartClientCommand
      print "Starting the Client..."
    when DisableClientCommand
      print "Disabling the Client..."
    else
      puts "Can’t handle command: #{command}"
      return
    end

    puts "DONE."
  end

end

class StopClientCommand; end
class StartClientCommand; end
class DisableClientCommand; end

executor = CommandExecutor.new
executor.execute StopClientCommand    # <-- pass a class, not a string
executor.execute StartClientCommand
executor.execute DisableClientCommand

And ran it…

Can't handle command: StopClientCommand
Can't handle command: StartClientCommand
Can't handle command: DisableClientCommand

Um. What the heck? Maybe I fat-fingered something in there? I threw in a little ghetto-debugging for a sanity check and got the same results:

Passed-in command   : StopClientCommand
Can't handle command: StopClientCommand
Passed-in command   : StartClientCommand
Can't handle command: StartClientCommand
Passed-in command   : DisableClientCommand
Can't handle command: DisableClientCommand

The reason?

Case statements are evaluated using the Object#=== (Case Equality) method which, according to the documentation, is “typically overridden by descendents [sic] to provide meaningful semantics in case statements.”

Any chance that the Class class overrides this method? You betcha. Its case-equality behavior is to evaluate whether the case condition represents an instance of that class, NOT if it is a matching class definition.

With that in mind, I made one last change:

class CommandExecutor

  def execute(command)
    case command.new  # <-- check against an instance of the class
    when StopClientCommand
      print "Stopping the Client..."
    when StartClientCommand
      print "Starting the Client..."
    when DisableClientCommand
      print "Disabling the Client..."
    else
      puts "Can't handle command: #{command}"
      return
    end

    puts "DONE."
  end

end

And voila:

Stopping the Client...DONE.
Starting the Client...DONE.
Disabling the Client...DONE.

We finally have the correct output, and we’re using idiomatic Ruby to get there.

I know that there are a lot of Budding Rubyists out there. Are you a former (or current) Java developer? That was me, but I saw the light and have moved on to greener pastures.

A big step in the transition from Java to Ruby was the adoption of inject as a first-class weapon in my iteration arsenal. So, what’s the big deal, and how does it work? Let’s break it down.

You’re going to use inject to iterate through some values and use each of them to manipulate some other object. Let’s say that we have an array of two-element arrays (a la [['a', 1], ['b', 2], ['c', 3]]) and want to construct a hash with the first element as the key and the second element as the value ({ ‘a’ => 1, ‘b’ => 2, ‘c’ => 3}).  Someone just transitioning to Ruby might do this:

hash = {}
array.each do |current|
  hash[current[0]] = current[1]
end

You can do this with inject like so:

hash = array.inject({}) do |results, current|
  results[current[0]] = current[1]
  results
end

Ok, to be fair…this code is not simpler. Not as pretty, imho. More Ruby-esque? Sure. Patience, Grasshopper.

You can think of inject as a replacement for each that takes an argument representing the starting state of the object you want to manipulate. We want to construct a hash, so this starting state is {}. The block, then, receives another argument (I call it ‘results’ above): the value of your object passed in from the previous iteration.

One key thing to remember when using inject: you must return the ‘results’ from the iteration at the end of the block. Not doing so is a very common mistake that will totally break you.

Let’s pick a different example: we want to sum the values in an array. Old way:

total = 0
array.each do |current|
  total += current
end
total

With inject:

total = array.inject(0) do |total, current|
  total + current
end

Again, you mentally translate the above to:
- start with 0
- iterate through each value, adding the current value to the total, and
- pass the total on to the next iteration

Easy peasy. (What, you just want to use ActiveSupport’s Enumerable#sum? Bleh. Fair enough.) Ok, one more. This one actually shows it used in a realistic scenario.

Array.class_eval do

  # Construct a hash of objects, keyed by some object attribute.
  def hash_by(attribute)
    inject({}) do |results, obj|
      results[obj.send(attribute)] = obj
      results
    end
  end

end

Here, I have reopened the Array class to add a new method, hash_by(). I use it to construct a cache of objects so that I can quickly look up a specific object using a unique object attribute. Here it is in action:

class User
  attr_accessor :name, :age, :email

  def initialize(name, age, email)
    @name = name
    @age = age
    @email = email
  end
end

users = [User.new('Brian', 32, 'brian@foo.bar.com'),
          User.new('Jim', 46, 'jim@foo.bar.com'),
          User.new('Scott', 33, 'scott@foo.bar.com'),
          User.new('Kenton', 32, 'kenton@foo.bar.com'),
          User.new('Chris', 34, 'chris@foo.bar.com')]

user_cache = users.hash_by(:name)

puts user_cache['Brian'].inspect
# => #<User:0x28514 @email="brian@foo.bar.com", @age=32, @name="Brian">

puts user_cache['Scott'].inspect
# => #<User:0x2844c @email="scott@foo.bar.com", @age=33, @name="Scott">

With the constructed User cache, we can now get to the object of our choice in constant time. Yay, inject!

contexts.map! {|context| context.controller}.compact!.uniq!

The result?

undefined method `uniq!' for nil:NilClass

Yep, compact! was returning nil. From the documentation: “Returns nil if no changes were made.”

Well…bleh. I’d rather it had returned the (unchanged) array.

I understand the intent of the API’s design (explicitly let the caller know that there were no changes made to the input array) , but it just wasn’t what I expected.

So…be careful.