In this example, I am going to use a fairly inefficient piece of Ruby code I created a while ago for Project Euler (Problem 10) for finding the sum of all primes under 2000000:

class Integer
 
  def prime?
    return true if self == 2
    return false if (self & 1) == 0
    square = Math.sqrt(self).round + 1
    i = 1
    while i <= square
      i+= 2
      return false if (self % i) == 0
    end
    true
  end
 
end
 
numbers = (2..2000000).to_a
 
numbers = numbers.select { |n| n.prime? }
puts numbers.inject { |result, element| result = element + result }

At the time that I wrote this, I was relatively unaware of more efficient ways of resolving prime numbers (such as a euler sieve), however the code still ran under the allotted 2 minute window (52 seconds) so I went with it. Now to speed it up. To write a C extension you need, at a bare minimum two things:

1. an extconf.rb file – this file is used by ruby to generate the Makefile that is used to compile the extension
2. the source file for the extension (in this case primed.c)

Here is a look at these two files for my new version of problem 10:
primed.c

#include "ruby.h"
#include <stdlib.h>
#include <math.h>
 
VALUE Primed;
 
VALUE method_prime(VALUE obj, VALUE args)
{
	register uint64_t n;
	n = NUM2INT(obj);
	if (n == 2)
		return Qtrue;
	if ((n & 1) == 0)
		return Qfalse;
 
	register uint64_t sqrt_n = ((uint64_t)sqrt(n)) + 1;
	register uint64_t i=3;
	for (i; i<= sqrt_n; i+=2) {
		if (n % i == 0)
			return Qfalse;
	}
	return Qtrue;
}
 
void Init_primed() {
	Primed = rb_define_module("Primed");
	rb_define_method(Primed, "prime?", method_prime, -2);
}

extconf.rb

# Loads mkmf which is used to make makefiles for Ruby extensions
require 'mkmf'
 
# Give it a name
extension_name = 'primed'
 
# The destination
dir_config(extension_name)
 
# Do the work
create_makefile(extension_name)

First let me explain primed.c. The objective of this extension is to determine whether or not a number is prime, so that an integer can call x.prime? and return true or false. It is essentially identical to the method used in the pure ruby script above. One of the first thing you may notice is this line:

VALUE Primed

VALUE is a data type defined by Ruby that represents the Ruby object in memory. It is basically a struct that contains the data related to the object. In this case, the object will represent the “Primed” module in ruby, so it will contain data about the instance methods, variables, etc. for that module. All Ruby objects are represented in C by VALUE, regardless of their type within the Ruby VM, anything else will likely result in a segfault.

Next we define the actual method to calculate whether the value is prime. Note that because we need to return a Ruby object, we set the return type as VALUE as well. QTrue and QFalse are directly representative of true and false in ruby, and also return correctly within C (QTrue will evaluate as true, QFalse will evaluate as false).

Finally we see the Init_primed method. Every time a class or module is instantiated within the Ruby VM it calles Init_name. It is here we actually instantiate the Primed module and bind the method_prime function to the Ruby method prime?. Both functions used are pretty self explanatory as to what they do, except for the last argument used in ruby_define_method which is essentially the arity or number of arguments to expect in the Ruby method. In this case, -2 actually make ruby send back self as the first argument to the method_prime function, and an array of any other arguments as the second.

Now we have all of our code. The last thing to put in place is extconf.rb:

# Loads mkmf which is used to make makefiles for Ruby extensions
require 'mkmf'
 
# Give it a name
extension_name = 'primed'
 
# The destination
dir_config(extension_name)
 
# Do the work
create_makefile(extension_name)

Pretty simple right? Now when you call ruby extconf.rb it will generate a Makefile that you can use to build the extension. And the final result? Using the C extension the code runs in just under 3 seconds. Still not really efficient, but it demonstrates the point. When Ruby’s speed is the bottle neck, using C is a viable and easy option.

With one equals sign you assign a value to a variable:

composer = "Beethoven"

With two equals signs you see if two things are the same thing:

puts "9th Symphony" if melody == "Ode to Joy"

With three equal signs you get, well, essentially you get a placeholder that you can use to define arbitrary relationships between objects which you will mostly never call by hand yourself but which Ruby will call for you when you run case statements:

class Composer
  attr_accessor :works
  def initialize(*works)
    @works = works
  end
 
  def ===(work)
    @works.include?(work)
  end
end

The trequals operator (ok, method) returns true or false depending on a condition I’ve defined. Now I can test a given work against a bunch of composer objects using a case statement:

beethoven = Composer.new("Fur Elise", "Missa Solemnis", "9th Symphony")
mozart = Composer.new("The Magic Flute", "C Minor Mass", "Requiem")
bach = Composer.new("St. Matthew Passion", "Jesu, Joy of Man's Desiring")
 
case "Requiem"
  when beethoven
    process_beethoven_work
  when mozart
    process_mozart_work
  when bach
    process_bach_work
end

The trequals is called behind the scenes by Ruby. Since I’ve defined it on the Composer class to look for a matching entry in that composer’s list of works, the case statement becomes a way of running different code based on which composer wrote the work in question.

This example is contrived, of course, because if it was this simple a need you’d probably just check “some_composer.works.include?(‘Requiem’)” by hand. But the example demonstrates the crucial point, that there’s no equality being checked for. A work in no way is the composer. It’s a relationship that the case statement is checking for–the given work was written by the given composer–and it’s a relationship that I’ve defined explicitly for my own music-categorizing purposes.

That case statements work this way is yet another example of the magical and powerful stuff that characterizes Ruby. Instead of simply a strict equality match, we can now switch against multiple types, all with different definitions of what qualifies as a relationship:

class String
  def ===(other_str)
    self.strip[0, other_str.length].downcase == other_str.downcase
  end
end
 
class Array
  def ===(str)
    self.any? {|elem| elem.include?(str)}
  end
end
 
class Fixnum
  def ===(str)
    self == str.to_i
  end
end
 
string_to_test = "99 Monkeys"
case string_to_test
  when "99 monkeys jumping on the bed"
    do_monkey_stuff
  when ["77 Rhinos Jumped", "88 Giraffes Danced", "99 Monkeys Sang"]
    do_animal_behavior_stuff
  when 99
    do_quantity_stuff
  when /^\d+\s+\w+/
     do_regex_stuff
end

Here, if the string to be tested is the first portion of the larger string (case-insensitively speaking), if it is part of any of the elements in the specified array, if it starts out with 99 (string.to_i returns only leading integers), or if it matches the given regular expression, the respective code will be run. In this case, it matches all of them, so only the code for the first case–the string match–will be run (in Ruby, switches automatically stop at the first match, so you don’t need to give each case its own “end” line).

Note that I didn’t need to define (actually, override) the trequals on the regular expression. The relationship operator is a method on Object, so all Ruby objects inherit it. If not overridden, it defaults to a simple double-equals equality check (thus contributing to the momentum of the misnomer “case equality”). But some standard Ruby classes already come with their own definition for trequals. Regexp and Range are the notable examples: Regexp defines it to mean a match on that regular expression, and Range defines it to mean a number that falls somewhere within that range, as such:

num = 77
case num
  when 1..50
    puts "found a lower number"
  when 51..100
    puts "found a higher number"
end

Note that since === is really a method, it is not commutative, meaning you can’t swap sides on the call; “a === b” is not the same as “b === a”. If you think through it, it makes sense. You’re really calling “a.===(b)”. If a is an array, you’re calling a method on Array, which will be defined for Array’s own purposes. If b is a string, and you swapped the order, you’d be calling a String method, which would have a different purpose for its trequals operator, so “b.===(a)” would most likely be something quite different. This concept also means that the variable you’re testing in a case statement is being passed as a parameter to the trequals methods of the various case objects, not the other way around. These two snippets are equivalent:

case "St. Matthew Passion"
  when mozart
    process_mozart_work
end
 
process_mozart_work if mozart === "St. Matthew Passion"

Note that the second snippet was not

process_mozart_work if "St. Matthew Passion" === mozart

It’s also good (although I’m not sure how useful) to know that the relationship operator is used implicitly by Ruby when rescuing errors in a begin-rescue block.

begin
  do_some_stuff
rescue ArgumentError, SyntaxError
  handle_arg_or_syn_error
rescue IOError
  handle_io_error
rescue NoMemoryError
  handle_mem_error
end

In this example, Ruby runs ArgumentError.===, passing it the global variable $!, which holds the most recent error. If that returns false, it moves along, doing the same with SyntaxError, IOError, and NoMemoryError, each in turn. With errors, the trequals is defined to just compare the class of the error that occurred with that of each candidate class (in this case, ArgumentError, etc.) and its ancestors.

It took me a long time before I cared about this little Ruby feature, which I think is sad. I think I just saw the phrase “case equality” and thought something like “Hmm, another subtle variation on what it means for two objects to be equal. I’m sure I’ll have occasion to use this someday. I’ll figure it out then.” But it’s more useful than that, and I think it would get better traction without the specious nomenclature.

e.g.

rec1,field2,,,,,,xxx,fieldn,,,1,2,3,,,fieldx

rec2,field22,,,a,s,d,fieldmore,,,,etc

.

.

.

recn,field2n,,,,ring,,,,ring,1,2,,,hello?,,etc

While testing the setup, we had smaller files to work with. The goal was to create a new file containing only the first field from each record.

e.g.

rec1

rec2

.

.

.

recn

During testing this was easily done by opening the file in a spreadsheet program (such as OpenOffice), which would split the records on the comma delimiter and place each field in a different column. Then, it was easy to select the first column and write it out to the new file.

On switching to production files, we discovered that OpenOffice has a limit of 65k rows – a fraction of what we needed. We then tried some other spreadsheet programs, which produced the same results. We knew there was at least one spreadsheet program that would work, but it was not open source.

At this point the comment was made: “well, we ARE ruby developers …”

And that lead to the following simple solution to the problem at hand.

With a few lines of ruby code, the source files could be read in, line by line, split on the comma delimiter, and the first entry written out to the destination file.

So, when the usual tools just don’t work – remember that a new ruby tool might be just around the corner.

#!/usr/bin/ruby

#

#  trimfile.rb

#

require “rubygems”

require “ruby-debug”

class Trimfile

attr_accessor :fileName, :newFile

def initialize(fileName, newFile)

puts “\nSplit off first comma delimited item of each line.”

@fnam = fileName

if @fnam == nil then @fnam = “trimin.txt” end

@newfnam = newFile

if @newfnam == nil then @newfnam = “trimout.txt” end

linecount = 0

puts “\nFilenames – input: #{@fnam}, output: #{@newfnam}”

aFile = File.new(@newfnam, “w”)

IO.foreach(@fnam) do |line|

aFile.puts line.split(‘,’)[0]

linecount += 1

end

aFile.close

puts “\nTotal lines: #{linecount}”

end

end

test = Trimfile.new(ARGV[0], ARGV[1])

First, install Starling:

 sudo gem install starling

This will install Starling and it’s dependencies (memcache-client and eventmachine) if you don’t already have them.

Now install Workling. This doesn’t have a gemspec so we will install it as a plugin:

cd ~/path_to_your_project
script/plugin install git://github.com/purzelrakete/workling.git

Finally, tell Workling, which will want to use Spawn by default if it is installed on your machine, to use Starling by placing this in your environment.rb:

Workling::Remote.dispatcher = Workling::Remote::Runners::StarlingRunner.new

That is it for the installation process! Easy. Now for actually handling requests. Believe it or not, it is just as simple as the installation. Say you have a controller that has to do several long running tasks:

class SkinnyController < ActionController::Base
 
  def fat_action
    .. do some crazy stuff that takes a few minutes ..
  end
 
end

Now typically, you should avoid doing things that take longer than a few seconds to complete. And this is okay for most application requirements, however in some cases, it is inevitable that a few tasks will take much longer, such as above. That is where Workling comes in. Simply refactor the code into a worker (conveniently located in app/workers):

# app/workers/fat_worker.rb
class FatWorker < Workling::Base
 
  # this method can be named anything you want
  def do_work(*args)
    .. you get the picture ..
  end
end

Now, in your controller, call the worker:

class SkinnyController < ActionController::Base
 
  def fat_action
    FatWorker.asynch_do_work(some_args)
  end
 
end

Just start up starling and workling (starling start, and script/workling_client start respectively) And that is all. You can now handle large tasks asynchronously, and because the tasks are queued with starling, the action can be called multiple times, and it will queue up the worker and process it as soon as the previous tasks are complete.

Back to my script, since I wanted to find the number of occurrences white space showed up in a given string I had to come up with a way to count white space. My first thought was to do some regular expression matching. Well after a little thought and a lot of reading, I found a this:


answer = params[:string].scan(/(\s)/)
puts answer.size

Here’s a little breakdown of whats happening for those that don’t know.

GIVEN: params is a hash with the values that were posted via a form.
Line 1: we are running the scan method on params[:string] which the value is a string. Then we pass scan method a regular expression that looks for any white space. Then the value of that is assigned to the local answer variable.
Line 2: we print the answer’s size.

First add the following line to /etc/powerdns/pdns.conf:

 gmysql-any-query=select content,ttl,prio,type,domain_id,name from records where name='%s' and (prio<>-1 or prio is null)

Thats the trickiest part. If you mess up on the sql query, PowerDNS may not return any results for your domain.
Then restart pdns. I use CentOS so I type

service pdns restart

Now you just need a daemon to monitor your websites. Something like the following might work for you:

#!/usr/bin/env ruby
require 'net/http'
require 'rubygems'
require 'activerecord'
 
SITE_ADDRESSES = %w( www.yourdomain.com www.example.com )
SITE_THAT_IS_ALWAYS_UP = "" # some well known site that is always up
 
class Record < ActiveRecord::Base
  ActiveRecord::Base.establish_connection(:adapter => "mysql",
    :encoding => "utf8", :database => "powerdns_production",
    :username => "your_mysql_username", :password => "your_secret_password_here",
    :host => "ns1.your_isp.com")
  set_inheritance_column :ruby_type
end
 
$running = true
 
def signal_trap_exit(signal_name)
  puts "#{Time.now} received #{signal_name} signal"
  $running = false
end
 
our_exit_signals = ["TERM", "INT", "KILL", "HUP"]
for exit_signal_name in our_exit_signals
  Signal.trap(exit_signal_name, "signal_trap_exit('#{exit_signal_name}')")
end
 
def check_internet
  begin
    Timeout::timeout(5) do
      Net::HTTP.get_response(SITE_THAT_IS_ALWAYS_UP, "/", 80) do |response|
        return response.code.match(/2|3\d{2}/)
      end
    end
  rescue => e
    puts "#{Time.now} Error connecting to internet: #{e}"
    return false
  end
end
 
def get_site_ip_addresses
  begin
    Record.find(:all, :conditions => ["type = ? and name in (?)", "A", SITE_ADDRESSES])
  rescue => e
    puts "#{Time.now} Error finding all records: #{e}"
    return []
  end
end
 
def make_inactive(ip_record)
  Record.update_all("prio=-1", "name='#{ip_record.name}' and content='#{ip_record.content}'")
end
 
def make_active(ip_record)
  Record.update_all("prio=1", "name='#{ip_record.name}' and content='#{ip_record.content}'")
end
 
while($running) do
  get_site_ip_addresses.each do |ip_address|
    begin
      Timeout::timeout(5) do
        Net::HTTP.get_response(ip_address.content.to_s, "/", 80) do |response|
          puts "#{Time.now} Response code for #{ip_address.content.to_s}: #{response.code}"
          make_active(ip_address) if ip_address.prio == -1
        end
      end
    rescue => e
      puts "#{Time.now} Error connecting to #{ip_address.content.to_s}: #{e}"
      if check_internet
        make_inactive(ip_address) unless ip_address.prio == -1
      end
    end
  end
 
  sleep 15 if $running
end

(?!someregexp)

where “someregexp” is a regular expression to match. The negative lookahead will reverse the logic for you. So when I needed to find all Master’s degree programs except Master of Science, I used something like

master(?!\sof\sscience)

to match say “master of arts” or “master” but not “master of science”.

The lookahead doesn’t move the position, so you can think of it as saving the spot it was in, checking forward, then returning. If you like regular expressions, you should experiment with lookaheads to get a feel for what they can do. I like to use rublar, a ruby regular expression editor and tester.

Even with an army of QA Engineers, some bugs will sneak through. QA time on untested code takes longer, and debugging the code even longer than that. The release process can go from a day to several days, or even weeks.

With BDD, when new features are added to the application, it as easy as running your spec or test suite to ensure that the original functionality is undamaged. It of course seems like a no brainer to me now. It’s like looking back and remembering when you thought the world was flat, and seeing how narrow minded you were. The moral of the story? Test before you code! You fill find yourself with more time, and less headaches.

So instead of doing this:

  Factory.sequence :email do |n|
    "person#{n}@example.com"
  end

you could do something like this:

  Factory.sequence(:email, ['angela', 'brett', 'alec']) do |name|
    "#{name}@example.com"
  end

It will start over at the beginning when it’s gone through all of them:

>> Factory.next :email
=> "angela@example.com"
>> Factory.next :email
=> "brett@example.com"
>> Factory.next :email
=> "alec@example.com"
>> Factory.next :email
=> "angela@example.com"
>> Factory.next :email
=> "brett@example.com"

You can also hand it a range (the internal implementation on this is none too efficient, so don’t give it billions at a time):

Factory.sequence(:email, 50..60) do |n|
  "user_#{n}@example.com"
end
 
>> Factory.next :email
=> "user_50@example.com"
>> Factory.next :email
=> "user_51@example.com"
>> Factory.next :email
=> "user_52@example.com"

The infinitely incrementing counter is still available if you want it:

Factory.sequence(:email, %w[angela brett alec]) do |name,i|
  "#{name}_#{i}@example.com"
end
 
>> Factory.next :email
=> "angela_0@example.com"
>> Factory.next :email
=> "brett_1@example.com"
>> Factory.next :email
=> "alec_2@example.com"
>> Factory.next :email
=> "angela_3@example.com"
>> Factory.next :email
=> "brett_4@example.com"

This sort of thing is useful when you want two different factories to use the same sequence and have some overlap between the two groups. For example, we need a bunch of email addresses to test on, many of which share the same domain:

Factory.sequence(:name, %w[angela brett alec hal debbie tracey jared]) do |name,i|
  "#{name}_#{i}"
end
 
Factory.sequence(:domain, %w[something.com example.com mydomain.com]) do |domain|
  domain
end
 
Factory.define(:email_address) do |f|
  f.address { "#{Factory.next(:name)}@#{Factory.next(:domain)}" }
end
 
>> 20.times { ea = Factory.build :email_address; puts ea.address }
angela_0@something.com
brett_1@example.com
alec_2@mydomain.com
hal_3@something.com
debbie_4@example.com
tracey_5@mydomain.com
jared_6@something.com
angela_7@example.com
brett_8@mydomain.com
alec_9@something.com
hal_10@example.com
debbie_11@mydomain.com
tracey_12@something.com
jared_13@example.com
angela_14@mydomain.com
brett_15@something.com
alec_16@example.com
hal_17@mydomain.com
debbie_18@something.com
tracey_19@example.com

For our last trick, the reset method returns both the looping index and the infinite counter back to zero:

>> Factory.reset :name
>> Factory.next :name
=> "angela_0"

Here’s the code to make it happen:

class Factory
  def self.sequence(sequence_name, enum = nil, &blk)
    @@sequences ||= {}
 
    enum = enum.to_a
 
    @@sequences[sequence_name] = {
      :enum => enum,
      :index => 0,
      :infinite_counter => 0,
      :template  => blk
    }
  end
 
  def self.next(sequence_name)
    seq = @@sequences[sequence_name]
 
    retval = case seq[:template].arity
      when 1
        seq[:template].call(seq[:enum][seq[:index]])
      when 2
        seq[:template].call(seq[:enum][seq[:index]], seq[:infinite_counter])
    end
 
    seq[:index] = (seq[:index]+1 == seq[:enum].size) ? 0 : seq[:index]+1
    seq[:infinite_counter] += 1
    @@sequences[sequence_name] = seq
    retval
  end
 
  def self.reset(sequence_name)
    @@sequences[sequence_name][:index] = 0
    @@sequences[sequence_name][:infinite_counter] = 0
  end
end

Just put that into some file–perhaps in your rails lib directory–and make sure that file gets required–probably in your rails config/environment.rb. When doing it by hand like this, you’ll want to make sure your library file is loaded after the factory_girl gem is loaded, or you’ll get weirdness like methods you’ve overridden acting in non-overridden ways and the like; config.after_initialize in your environment.rb’s Rails::Initializer block is your friend.

You can also now use the gem BrettRasmussen-factory_girl from gems.github.com. I mean to submit it as a patch back to the original factory_girl, which I’m sure I’ll have time to do Any Day Now.

That being said, I’m curious to see what other people find running the indexer against their code. You can get it at http://github.com/woody2shoes/indexer/tree/master. Please comment and let me know what your code looks like.

Here’s the output from one of my rails controllers:

'school' appears 69 times in signup_controller.rb
'campus' appears 61 times in signup_controller.rb
'the' appears 52 times in signup_controller.rb
'id' appears 47 times in signup_controller.rb
'params' appears 42 times in signup_controller.rb
'end' appears 24 times in signup_controller.rb
'session' appears 23 times in signup_controller.rb
'to' appears 23 times in signup_controller.rb
'save' appears 21 times in signup_controller.rb
'user' appears 20 times in signup_controller.rb
'information' appears 19 times in signup_controller.rb
'commit' appears 17 times in signup_controller.rb
'domain' appears 17 times in signup_controller.rb
'campuses' appears 16 times in signup_controller.rb
'if' appears 16 times in signup_controller.rb
'action' appears 15 times in signup_controller.rb
'enrollment' appears 15 times in signup_controller.rb
'redirect' appears 15 times in signup_controller.rb
'find' appears 15 times in signup_controller.rb
'post' appears 14 times in signup_controller.rb
'programs' appears 14 times in signup_controller.rb
'get' appears 13 times in signup_controller.rb
'is' appears 11 times in signup_controller.rb
'this' appears 11 times in signup_controller.rb
'name' appears 10 times in signup_controller.rb
'by' appears 10 times in signup_controller.rb
'go' appears 10 times in signup_controller.rb
'yes' appears 10 times in signup_controller.rb
'form' appears 10 times in signup_controller.rb
'info' appears 10 times in signup_controller.rb
'next' appears 9 times in signup_controller.rb
'contact' appears 9 times in signup_controller.rb
'variables' appears 8 times in signup_controller.rb
'7' appears 8 times in signup_controller.rb
'program' appears 8 times in signup_controller.rb
'submission' appears 8 times in signup_controller.rb
'new' appears 8 times in signup_controller.rb
'for' appears 7 times in signup_controller.rb
'title' appears 7 times in signup_controller.rb
'requirements' appears 7 times in signup_controller.rb
'update' appears 7 times in signup_controller.rb
'all' appears 7 times in signup_controller.rb
'step' appears 7 times in signup_controller.rb
'we' appears 7 times in signup_controller.rb
'up' appears 6 times in signup_controller.rb
'a' appears 6 times in signup_controller.rb
'valid' appears 6 times in signup_controller.rb
'campusprogram' appears 6 times in signup_controller.rb
'else' appears 5 times in signup_controller.rb
'set' appears 5 times in signup_controller.rb
'in' appears 5 times in signup_controller.rb
'conditions' appears 5 times in signup_controller.rb
'elsif' appears 5 times in signup_controller.rb
'lead' appears 5 times in signup_controller.rb
'back' appears 4 times in signup_controller.rb
'no' appears 4 times in signup_controller.rb
'values' appears 4 times in signup_controller.rb
'populate' appears 4 times in signup_controller.rb
'pre' appears 4 times in signup_controller.rb
'include' appears 4 times in signup_controller.rb
'primary' appears 4 times in signup_controller.rb
'site' appears 4 times in signup_controller.rb
'merge' appears 4 times in signup_controller.rb
'about' appears 3 times in signup_controller.rb
'1' appears 3 times in signup_controller.rb
'collects' appears 3 times in signup_controller.rb
'another' appears 3 times in signup_controller.rb
'fields' appears 3 times in signup_controller.rb
'or' appears 3 times in signup_controller.rb
'signup' appears 3 times in signup_controller.rb
'each' appears 3 times in signup_controller.rb
'cp' appears 3 times in signup_controller.rb
's' appears 3 times in signup_controller.rb
'create' appears 3 times in signup_controller.rb
'attributes' appears 3 times in signup_controller.rb
't' appears 2 times in signup_controller.rb
'haven' appears 2 times in signup_controller.rb
'first' appears 2 times in signup_controller.rb
'i' appears 2 times in signup_controller.rb
'initialize' appears 2 times in signup_controller.rb
'zips' appears 2 times in signup_controller.rb
'direct' appears 2 times in signup_controller.rb
'clause' appears 2 times in signup_controller.rb
'codes' appears 2 times in signup_controller.rb
'errors' appears 2 times in signup_controller.rb
'unless' appears 2 times in signup_controller.rb
'who' appears 2 times in signup_controller.rb
'applies' appears 2 times in signup_controller.rb
'0' appears 2 times in signup_controller.rb
'complete' appears 2 times in signup_controller.rb
'as' appears 1 times in signup_controller.rb
'class' appears 1 times in signup_controller.rb
'n' appears 1 times in signup_controller.rb
'wizard' appears 1 times in signup_controller.rb
'movement' appears 1 times in signup_controller.rb
'default' appears 1 times in signup_controller.rb
'associate' appears 1 times in signup_controller.rb
'applicationcontroller' appears 1 times in signup_controller.rb

Comments are also welcome regarding ways I can parse the data to find other relevant trends in the code.