Kerry Buckley

What’s the simplest thing that could possibly go wrong?

Archive for the ‘Ruby’ tag

Upgrading to Snow Leopard

one comment

A quick list of things I had to sort out after upgrading to Mac OS X 10.6 Snow Leopard:

Developer Tools

Dont’ forget to run the XCode installer on the Snow Leopard DVD, otherwise you’ll have trouble getting stuff to compile, even if you don’t use XCode. You’ll also have to download and install the iPhone SDK separately if you need it (and possibly even if you don’t – I installed it anyway, just in case).

Ruby and RubyGems

I had both of these installed from source, and although most things seemed to work OK, I couldn’t get Passenger to work at all until I reinstalled them. Instructions for installing are available on HiveLogic – this will overwrite any existing versions, assuming they’re in /usr/local (the system version of Ruby isn’t touched).

Before installing rubygems I removed all my installed gems (gem list|awk '{print $1}'|xargs sudo gem unin -a – there’s probably an easier way), then I reinstalled the ones I needed afterwards.

MySQL

Although I mostly use Postgres, I reinstalled MySQL following the instructions on the Norbauer blog.

MacPorts

Apparently you can rebuild your ports by just running sudo port upgrade --force installed, but by the time I came across that I’d already trashed and reinstalled as recommended on the link above.

For some reason the MacPorts installer hung while running the postinstall scripts, but after force-quitting the installer then running sudo port sync everything seemed fine.

I added +svn to the arguments for installing git-core (as if it didn’t have enough dependencies to build already!), and also installed postgresql84-server and imagemagick.

Apache and Passenger

I tried a whole bunch of stuff to get Passenger running, but it turned out in the end that rebuilding Ruby was the answer (see above). Once I’d done that, it was a simple case of installing the passenger gem and running sudo passenger-install-apache2-module to install the module.

Vim

The standard version of MacVim mostly works under 10.6, but there’s a custom-built binary that seems much more stable and a bit snappier.

Reader Notifier

The release version of Reader Notifier doesn’t work on 10.6, but for now there’s a patched version.

Safari Plugins

ClickToFlash needs to be upgraded to 1.5fc2.

DeliciousSafari hasn’t been updated for 64-bit Safari yet, but as a workaround you can force Safari to run in 32-bit mode. Do a ‘get info’ on the Safari app (in the Applications folder), and tick ‘Open in 32-bit mode’.

iStat Menus

Turns out I was using an old version (1.3) of iStat Menus, which doesn’t work in 10.6 (I noticed the missing menu when I went to check how high all the port install shenanigans were pushing the CPU temperatures). Upgrading to 2.0 sorted it out.

FlickrExport

Again, I was using an old version of this iPhoto exporter, but £6.90 and an upgrade to 3.0.2 later and everything was working again.

Remapping caps lock to escape

Not strictly 10.6-specific, but this was something I’d been meaning to get round to since switching back to vim. I was already to start installing input manager hacks until I stumbled across a blog post somewhere mentioning that it is already configurable (and has been for a while). Just open the keyboard preferences, hit ‘Modifier Keys…’ and change the action.

Written by Kerry

September 9th, 2009 at 2:33 pm

Posted in Apple

Tagged with , , , , , , , ,

Naresh Jain’s refactoring teaser

leave a comment

Naresh Jain recently posted a refactoring teaser. The original code was in Java, but I thought I’d have a go at refactoring it in Ruby instead. I deliberately didn’t look at Naresh’s solution beforehand, so mine goes in a rather different direction.

My code’s here (with the specs in the same file for simplicity), and you can step through the history to see the state at each step of the refactoring. The links in the text below take you to the relevant version of the file, and the Δs next to them link to the diffs.

Firstly, I converted the code to Ruby, and made sure the tests (which I converted to RSpec) still passed. It’s a fairly straight conversion, although I made a couple of changes while I was at it – mainly turning it into a module which I mixed into String. I changed the name of the method to phrases, to avoid conflicting with the built-in String#split. The regular expression to split on is much simpler too, because Ruby didn’t understand the original, and I had no idea what it was supposed to do anyway.

Here’s my initial Ruby version:

[ruby]
#!/usr/bin/env ruby
#
#See http://blogs.agilefaqs.com/2009/07/08/refactoring-teaser-part-1/

require ‘spec’

module StringExtensions
REGEX_TO_SPLIT_ALONG_WHITESPACES = /\s+/

def phrases(number)
list_of_keywords = “”
count = 0
strings = split(REGEX_TO_SPLIT_ALONG_WHITESPACES)
all_strings = single_double_triple_words(strings)
size = all_strings.size
all_strings.each do |phrase|
break if count == number
list_of_keywords += “‘” + phrase + “‘”
count += 1
if (count < size && count < number)
list_of_keywords += ", "
end
end
return list_of_keywords
end

private

def single_double_triple_words(strings)
all_strings = []
num_words = strings.size

return all_strings unless has_enough_words(num_words)

# Extracting single words. Total size of words == num_words

# Extracting single-word phrases.
(0...num_words).each do |i|
all_strings << strings[i]
end

# Extracting double-word phrases
(0...num_words - 1).each do |i|
all_strings << "#{strings[i]} #{strings[i + 1]}"
end

# Extracting triple-word phrases
(0...num_words - 2).each do |i|
all_strings << "#{strings[i]} #{strings[i + 1]} #{strings[i + 2]}"
end
return all_strings
end

def has_enough_words(num_words)
num_words >= 3
end
end

String.send(:include, StringExtensions)

describe StringExtensions do
it ‘finds all phrases’ do
‘Hello World Ruby’.phrases(6).should == “‘Hello’, ‘World’, ‘Ruby’, ‘Hello World’, ‘World Ruby’, ‘Hello World Ruby'”
end

it ‘returns all phrases when asked for more than exist’ do
‘Hello World Ruby’.phrases(10).should == “‘Hello’, ‘World’, ‘Ruby’, ‘Hello World’, ‘World Ruby’, ‘Hello World Ruby'”
end

it ‘returns the first n phrases when asked for fewer than exist’ do
‘Hello World Ruby’.phrases(4).should == “‘Hello’, ‘World’, ‘Ruby’, ‘Hello World'”
end

it ‘returns the first word when asked for one phrase’ do
‘Hello World Ruby’.phrases(1).should == “‘Hello'”
end
end
[/ruby]

I didn’t change the specs at all during the refactoring (because I didn’t change the API or add any new public methods or classes), and made sure they all passed at each step.

The first thing Δ I changed was to simplify that big iterator in phrases that loops through the list of phrases, formatting the output string. Basically all this does is to put each phrase in quotes, then stitch them all together separated by a comma and a space. The first of those tasks is a simple map, and the second is a join. The whole method collapses down to this (ruby methods automatically return the result of their last statement):

[ruby]
def phrases(number)
strings = split(REGEX_TO_SPLIT_ALONG_WHITESPACES)
all_strings = single_double_triple_words(strings)
all_strings[0, number].map {|s| “‘#{s}'”}.join(‘, ‘)
end
[/ruby]

Next Δ I remembered that by default String#split splits at whitespace anyway, so I did away with the regular expression. Then Δ I renamed the strings variable to words to make its purpose a little clearer, leaving the phrases method looking like this:

[ruby]
def phrases(number)
words = split
all_strings = single_double_triple_words(words)
all_strings[0, number].map {|s| “‘#{s}'”}.join(‘, ‘)
end
[/ruby]

The section of single_double_triple_words that extracted the single words seemed redundant, as we already had that list – the original words. I removed it Δ, and initialised all_strings to the word list instead (not forgetting to rename single_double_triple_words to match its new behaviour):

[ruby]
module StringExtensions
def phrases(number)
words = split
all_strings = words
all_strings += double_triple_words(words)
all_strings[0, number].map {|s| “‘#{s}'”}.join(‘, ‘)
end

private

def double_triple_words(strings)
all_strings = []
num_words = strings.size

return all_strings unless has_enough_words(num_words)

# Extracting double-word phrases
(0…num_words – 1).each do |i|
all_strings << "#{strings[i]} #{strings[i + 1]}"
end

# Extracting triple-word phrases
(0...num_words - 2).each do |i|
all_strings << "#{strings[i]} #{strings[i + 1]} #{strings[i + 2]}"
end
return all_strings
end

def has_enough_words(num_words)
num_words >= 3
end
end
[/ruby]

That has_enough_words method seemed a bit odd – particularly the way it was only called once, rather than after extracting each set of phrases. I decided it was probably a premature and incomplete attempt at optimisation, and removed it Δ for now.

My next target was the duplication in the blocks that calculate double- and triple-word phrases. First Δ I extracted them into separate methods:

[ruby]
module StringExtensions
def phrases(number)
words = split
all_strings = words
all_strings += double_words(words)
all_strings += triple_words(words)
all_strings[0, number].map {|s| “‘#{s}'”}.join(‘, ‘)
end

private

def double_words(strings)
all_strings = []
num_words = strings.size

# Extracting double-word phrases
(0…num_words – 1).each do |i|
all_strings << "#{strings[i]} #{strings[i + 1]}"
end
return all_strings
end

def triple_words(strings)
all_strings = []
num_words = strings.size

(0...num_words - 2).each do |i|
all_strings << "#{strings[i]} #{strings[i + 1]} #{strings[i + 2]}"
end
return all_strings
end
end
[/ruby]

I decided that the num_words variable in the two new methods wasn’t really necessary (it was only used once, and I think strings.size expresses intent perfectly clearly), so I inlined it Δ (and the same in triple_words):

[ruby]
def double_words(strings)
all_strings = []

# Extracting double-word phrases
(0…strings.size – 1).each do |i|
all_strings << "#{strings[i]} #{strings[i + 1]}"
end
return all_strings
end
[/ruby]

Most of the code in double_words and triple_words was obviously very similar, so I created Δ a general extract_phrases method, and called it from both. The new method uses the start position and length version of Array#[] to extract the appropriate number of words, then Array#join to string them together separated by spaces:

[ruby]
def double_words(strings)
extract_phrases(strings, 2)
end

def triple_words(strings)
extract_phrases(strings, 3)
end

def extract_phrases(strings, number_of_words)
result = []
(0…strings.size – number_of_words + 1).each do |i|
phrase = strings[i, number_of_words].join(‘ ‘)
result << phrase
end
result
end
[/ruby]

At this point double_words and triple_words have become just dumb wrappers around extract_phrases, so I removed them Δ and just called extract_phrases directly:

[ruby]
def phrases(number)
words = split
all_strings = words
all_strings += extract_phrases(words, 2)
all_strings += extract_phrases(words, 3)
all_strings[0, number].map {|s| “‘#{s}'”}.join(‘, ‘)
end
[/ruby]

Rather than hardcoding the calls for two and three words, I changed it Δ to use a loop:

[ruby]
def phrases(number)
words = split
all_strings = words
(2..words.size).each do |number_of_words|
all_strings += extract_phrases(words, number_of_words)
end
all_strings[0, number].map {|s| “‘#{s}'”}.join(‘, ‘)
end
[/ruby]

I decided this was the point to put the optimisation back Δ and stop looking for phrases once we had enough:

[ruby]
def phrases(number)
words = split
all_strings = words
(2..words.size).each do |number_of_words|
break if all_strings.length >= number
all_strings += extract_phrases(words, number_of_words)
end
all_strings[0, number].map {|s| “‘#{s}'”}.join(‘, ‘)
end
[/ruby]

I decided that number_of_words wasn’t particularly clear, so changed it Δ to phrase_length, then Δ made the iterator in extract_phrases more ruby-like by using map:

[ruby]
def extract_phrases(strings, phrase_length)
(0…strings.size – phrase_length + 1).map do |i|
strings[i, phrase_length].join(‘ ‘)
end
end
[/ruby]

I then noticed that I hadn’t been consistent in changing strings to words, so fixed that Δ.

Lastly Δ, I decided that even though it was only one line, the code that formats the output deserved pulling out into a method.

Here’s my final version of the code:

[ruby]
module StringExtensions
def phrases(number)
words = split
all_strings = words
(2..words.size).each do |phrase_length|
break if all_strings.length >= number
all_strings += extract_phrases(words, phrase_length)
end
format_output(all_strings[0, number])
end

private

def extract_phrases(words, phrase_length)
(0…words.size – phrase_length + 1).map do |i|
words[i, phrase_length].join(‘ ‘)
end
end

def format_output(phrases)
phrases.map {|s| “‘#{s}'”}.join(‘, ‘)
end
end
[/ruby]

Written by Kerry

July 17th, 2009 at 8:03 am

Posted in Ruby

Tagged with , ,

A couple of rspec mocking gotchas

3 comments

Just a couple of things that have caused a bit of head-scratching lately when writing RSpec specs using the built-in mocking framework.

Catching StandardError

Watch out if the code you’re testing catches StandardError (of course you’re not catching Exception, right?). Try this:

[ruby]
require ‘rubygems’
require ‘spec’

class Foo
def self.foo
Bar.bar
rescue StandardError
# do something here and don’t re-raise
end
end

class Bar
def self.bar
end
end

describe ‘Calling a method that catches StandardError’ do
it ‘calls Bar.bar’ do
Bar.should_receive :bar
Foo.foo
end
end
[/ruby]

Nothing particularly exciting there. Let’s run it and check that it passes:

$ spec foo.rb 
.

Finished in 0.001862 seconds

1 example, 0 failures

However, what if we change the example to test the opposite behaviour?

[ruby]
describe ‘Calling a method that catches StandardError’ do
it ‘does NOT call Bar.bar’ do
Bar.should_not_receive :bar
Foo.foo
end
end
[/ruby]

$ spec foo.rb 
.

Finished in 0.001865 seconds

1 example, 0 failures

Wait, surely they can’t both pass? Let’s take out the rescue and see what’s going on:

[ruby]
class Foo
def self.foo
Bar.bar
end
end
[/ruby]

$ spec foo.rb 
F

1)
Spec::Mocks::MockExpectationError in 'Calling a method that catches StandardError does NOT call Bar.bar'
 expected :bar with (no args) 0 times, but received it once
./foo.rb:6:in `foo'
./foo.rb:18:

Finished in 0.002276 seconds

1 example, 1 failure

That’s more like it.

Of course, what’s really happening here is that Spec::Mocks::MockExpectationError is a subclass of StandardError, so is being caught and silently discarded by our method under test.

If you’re doing TDD properly, this won’t result in a useless test (at least not immediately), but it might cause you to spend a while trying to figure out how to get a failing test before you add the call to Foo.foo (assuming the method with the rescue already existed). Generally you can solve the problem by making the code a bit more selective about which exception class(es) it catches, but I wonder whether RSpec exceptions are special cases which ought to directly extend Exception.

Checking receive counts on previously-stubbed methods

It’s quite common to stub a method on a collaborator in a before block, then check the details of the call to the method in a specific example. This doesn’t work quite as you would expect if for some reason you want to check that the method is only called a specific number of times:

[ruby]
require ‘rubygems’
require ‘spec’

class Foo
def self.foo
Bar.bar
Bar.bar
end
end

class Bar
def self.bar
end
end

describe ‘Checking call counts for a stubbed method’ do
before do
Bar.stub! :bar
end

it ‘only calls a method once’ do
Bar.should_receive(:bar).once
Foo.foo
end
end
[/ruby]

$ spec foo.rb 
.

Finished in 0.001867 seconds

1 example, 0 failures

I think what’s happening here is that the mock object would normally receive an unexpected call, causing the expected :bar with (any args) once, but received it twice error that you’d expect. Unfortunately the second call to the method is handled by the stub, so never triggers the error.

You can fix it, but it’s messy:

[ruby]
it ‘only calls a method once’ do
Bar.send(:__mock_proxy).reset
Bar.should_receive(:bar).once
Foo.foo
end
[/ruby]

$ spec foo.rb 
F

1)
Spec::Mocks::MockExpectationError in 'Checking call counts for a stubbed method only calls a method once'
 expected :bar with (any args) once, but received it twice
./foo.rb:23:

Finished in 0.002542 seconds

1 example, 1 failure

Does anyone know a better way?

The full example code is in this gist.

Written by Kerry

May 28th, 2009 at 12:05 pm

Posted in rspec

Tagged with ,

API vs RSI

one comment

World’s-most-famous-twitterer Stephen Fry has a system for handling follow requests: you tweet using the #followmestephen hashtag, and he wades diligently through them, manually following people.

This seems an odd sort of thing to do – most people choose whom to follow based on whether they know them or like what they say, rather than on request – but I suppose when you have over a quarter of a million followers things work a little differently. It also creates lots of work , and looks like an ideal candidate for automation.

I thought I’d have a quick play with the Twitter API this morning (no doubt I’m not the only one), and cobbled together the script below, which you can also download as follow_me_stephen.rb (although if you’re not Mr Fry I’m not sure why you would want to). Save the file, and run using ruby follow_me_stephen.rb.

I wanted to avoid having too many dependencies, so I didn’t use the twitter gem, or the excellent httparty, but I was too lazy to figure out all the XPaths to handle the Atom version of the API. This means you need to have the JSON gem installed, which is as simple as sudo gem install json (omit the sudo on Windows).

The script’s pretty dumb, in that it grabs the whole set of search results every time, and blindly requests to follow everyone, regardless of whether you’re already following them.

[ruby]
#!/usr/bin/env ruby

require ‘net/http’

begin
require ‘json’
rescue LoadError
STDERR.puts <

No JSON parser found. Please run the following command to install:

sudo gem install json

EOF
raise
end

module FollowMeStephen
def run
auth_user, password = get_user_details
requestors = fetch_requestors
requestors.each do |user|
follow user, auth_user, password
end
end

private

def get_user_details
print ‘Please enter your Twitter username: ‘
auth_user = gets.chomp
print ‘Please enter your Twitter password: ‘
password = gets.chomp
return auth_user, password
end

def fetch_requestors
requestors = []
puts ‘Searching for hashtag “followmestephen”…’
query = ‘?q=%23followmestephen&rpp=150′
while query do
search = JSON.parse(get(“/search.json#{query}”))
puts “Received page #{search[‘page’]}”
requestors += search[‘results’].map {|r| r[‘from_user’]}
query = search[‘next_page’]
end
requestors.uniq
end

def follow user, auth_user, password
print “Following #{user}… ”
result = post “/friendships/create/#{user}.json”, auth_user, password
puts result
end

def get path
Net::HTTP.get ‘search.twitter.com’, path
end

def post path, auth_user, password
request = Net::HTTP::Post.new path
request.basic_auth auth_user, password
response = Net::HTTP.new(‘twitter.com’).start {|http| http.request(request)}
(response.kind_of? Net::HTTPSuccess) ? ‘OK’ : ‘Failed’
end
end

include FollowMeStephen
run
[/ruby]

Written by Kerry

March 15th, 2009 at 12:16 pm

Posted in Ruby

Tagged with , , ,