Talk Like A Duck

Suppose I've got a fixture file for a model called Item:

	# == Schema Information
	# Schema version: 14
	#
	# Table name: items
	#
	#  id          :integer(11)   not null, primary key
	#  description :string(255)   
	#  name        :string(255)   
	#  price       :integer(11)   
	#

	# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
	lotr1:
	  id: 1
	  name: LOTR1
	  description: The Road Goes Ever On
	lotr2:
	  id: 2
	  name: LOTR2
	  description: Introduction to Elvish

If I type a new line at the end of this file with the snippet command item and hit tab I see this:

With NameMe selected so that I can easily replace it by typing. Note that the id was set to 3 since rows with ids 1 and 2 already exist.

Hitting tab again selects the first instance of string, and subsequent tabs step through the columns

Another feature which I won't show is that it looks at the table and if it doesn't have a primary key (e.g. for an association table in a has_and_belongs_to_many association), it won't generate the id: or a key.

You might be impressed, but I'm pretty happy with the results of a couple of hours of playing with TextMata and Ruby.

How it works.

The whole thing is done with a TextMate command implemented in Ruby. A few notes. First, it's just a coincidence that the snippet trigger is item and my example table is called items. Second, I'm not using the comments at the top of the fixture file which were generated when the model was created. The command works off of db/schema.db.

Here's the code:

  #!/usr/bin/env ruby -w  
  #
  #  Created by Rick DeNatale on 2007-10-09.
  #  Copyright (c) 2007. You may use this under the ruby license.                    

  $LOAD_PATH << "#{ENV['TM_SUPPORT_PATH']}/lib"
  require 'exit_codes.rb'


  class FixtureSnipGen
    attr_reader :rails_root, :table_name
    def initialize(fixture_file)
      match  = %r{(.*)test/fixtures/(.*).yml}.match(ENV["TM_FILEPATH"])
      @rails_root = match[1]
      @table_name = match[2]
      @no_id = false  
    end

    def next_id
      max_id = 0     
      while line = gets
        claimed = %r{\s+id:\s+(\d+)}.match(line) 
        max_id = [max_id, claimed[1].to_i].max if claimed
      end
      max_id + 1
    end

    def gen_snippet
      cols = gen_columns
      if cols
        puts "${1:NameMe}:"
        puts "  id: #{next_id}" unless @no_id
        puts cols.join("\n")
      else 
        puts "Couldn't find #{table_name} in schema.rb"
        TextMate.exit_show_tool_tip
      end
      puts "$0"
    end

    def schema_file_name  
      "#{rails_root}db/schema.rb"
    end 

    def value_tab(text)
      @tab_stop += 1
      (@tab_stop < 10) ? "${#{@tab_stop}:#{text}}" : " # #{text}"
    end


    def gen_columns
      #    raise Exception.new("No schema file") unless File.exist?(schema_file_name)
      started = false
      @tab_stop = @no_id ? 0 : 1
      result = []
      File.new(schema_file_name).each do | line |
        if started
          break if %r{^(\s*)create_table\s+}.match(line)
          col_match = %r{\.column\s+\"(.*)\"\s*,\s*:(\w+)}.match(line)
          result << "  #{col_match[1]}: #{value_tab(col_match[2])}" if col_match
        else
          started = %r{^(\s*)create_table\s+["']#{table_name}['"]}.match(line)
          @no_id = %r{:id\s+=>\s+false}.match(line) if started
        end
      end
      return result.empty? ? nil : result    
    end
  end

  begin
    FixtureSnipGen.new(ENV["TM_FILEPATH"]).gen_snippet
  rescue Exception => ex
    puts ex
    TextMate.exit_show_tool_tip
  end

In the TextMate bundle editor, I just added a new command with this code, and set the following options:

Save:

Nothing

Input:

Entire Document - which pipes the entire textmate buffer for the file into stdin.

Output:

Insert as Snippet - which triggers TextMate to interpret the output as a snippet once the script has finished.

Activation:

Tab Trigger = item

Scope Selector

source.yaml - this only works within yml files.

Finally note that although my example uses a table called items, it's just a coincidence that the tab trigger is item. It would be item in any fixture file.

The Initial Approach

In order to control the time, I decided to add a module in Test::Unit::Testcase called TimeMachine, so that a testcase could just include TimeMachine when it needed the function.

The way it’s used is to write something like:

def testSomethingYesterday
   now_as(1.days.ago) do
     #code to be run yesterday here
   end
end

The now_as method takes a time as a parameter. Within the block, Time.now will return that time, and Date.today will return the date corresponding to that time.

Doing this was fairly straightforward. The method aliased the two methods, redefined them, then, within a begin block with an ensure clause to restore the methods afterwards, yielded to the block.

Non-stop Time Trip Only

While this simple approach worked well, it had one drawback. It couldn’t be stacked. If you called now_as again within the block, the inner call would remove the monkeypatched methods when it returned. This first showed up when I had a bug in one of my testcase methods. That was fixed easily enough by rewriting that test.

But when I ran into the code which was using implicit times, I figured it would be easier to make my test helper a bit more sophisticated. I needed a time machine which could make side-trips along it’s round, trip in time.

The TimeMachine as of Now

So here’s my current implementation of Test::Unit:Testcase::TimeMachine:

class Test::Unit::TestCase                    # 1
  module TimeMachine

    def now_as(time)
      time_class = class << Time; self; end   # 5
      date_class = class << Date; self; end
      begin
        Time.class_eval do 
          @now_stack ||= []
          if @now_stack.empty?                # 10
            time_class.class_eval do
              alias_method :old_now, :now
              def now
                @now_stack.last.dup
              end                             # 15
            end
            date_class.class_eval do
              alias_method :old_today, :today
              def today
                Time.now.to_date              # 20
              end
            end
          end
          @now_stack.push(time.dup)
        end                                   # 25 
        yield
      ensure
        Time.class_eval do 
          @now_stack.pop
          if @now_stack.empty?                # 30
            date_class.class_eval {alias_method :today, :old_today}
            time_class.class_eval {alias_method :now, :old_now}
          end
        end
      end                                     # 35
    end
end

The basic idea is to maintain a stack of times in a class instance variable of Time. We define the pseudo now and today methods when the first time is placed on this stack, and restore them when the last time is removed.

The tricky part of this code is knowing when to talk to the Time and Date classes and when to talk to their respective metaclasses. In lines 5 and 6 I grab the two metaclasses so that I can refer to them in the code below (DRY). In line 7 I start the begin block which ensures that things will be restored when now_as has finished.

On line 9, running in the context of the Time class, I ensure that it has an instance variable to contain the stack of now times. Then if the stack is empty, I define the methods. Lines 12-15 run in the context of Time’s metaclass to define now as a class method of Time. Lines 18-21 handle the today method in a similar fashion.

After we’ve ensured that our newly patched methods are there, we push the time on line 24.

The yield, on line 26 runs back in the context of the testcase, which proceeds to do it’s thing.

Once that’s done, succeed or not, the ensure block cleans things up. Lines 29-33 go back to the context of the Time class to manipulate the stack and, if it’s empty again, restore the original methods.

What’s in the Future?

So that’s where the time machine sits right now. It does the simplest thing that could possbily work, right now. It might be nice if it could, perhaps optionally, have the current time change rather than being fixed, in other words, Time.now would return the originally stated time plus whatever time increment had elapsed since the as_now call. But for now, I haven’t needed it, and I’m not planning to use the time machine to artifically skip ahead to find future requirements before I discover them in real time.

Postscript

After posting this yesterday, I discovered that the nesting didn’t really work. I was only pushing the time on to the stack the first time. I’ve just corrected the code above.

class MyTest < Test::Unit::TestCase

  def self.been_here
    result = @been_here
    @been_here = true
     result
   end

  class RowCounter < ActiveRecord::Base
  end

  def setup
    unless self.class.been_here
      File.open("#{RAILS_ROOT}/data_dump_#{Time.now.strftime("%m%d%H%M%S")}", "w") do |file|
        Account.connection.tables.each do |table_name|
          RowCounter.table_name = table_name
          file.puts "#{table_name}:  #{RowCounter.count}"
        end
      end
    end
    # The rest of your setup code goes here
  end

# And the rest of the TestCase code here
end

This will dump a list of each table with a count of its rows the first time setup is run for the testcase. The file name is generated with a time stamp

Okay, so the example does go along with this weeks Harry Potter fever.

rails_developer@hogwarts.edu.magic.uk/cauldron_project/trunk$ cat data_dump_0717105533
students:  17
professors:  2
owls:  2
potions:  2
magical_creatures:  2
muggles:  0

Now you can run the test individually and then along with others. Then use a diff tool to see which tables have different numbers of rows before your test case starts for the first time.

A test helper

If you find this useful, why not add it to a test helper. If you don’t already have one, edit your test/test_helper.rb file, and add the following code inside of the Test::Unit::Testcase class:

  def self.been_here
    result = @been_here
    @been_here = true
    result
  end

  class RowCounter < ActiveRecord::Base
  end

  def dump_table_counts(file_name)
    File.open(file_name, "w") do |file|
      Account.connection.tables.each do |table_name|
        RowCounter.table_name = table_name
        file.puts "#{table_name}:  #{RowCounter.count}"
      end
    end
  end

I’ve moved the definition of the been_here method and the class Rowcounter from the individual testcase to the superclass. The only code in the testcase needed to use this is in the setup method, which now becomes:

  def setup
    dump_table_counts("#{RAILS_ROOT}/data_dump_#{Time.now.strftime("%m%d%H%M%S")}") unless self.class.been_here

    # rest of setup code here
  end