Reclusive Geek

Harvesting Fixtures from a Live Rails project

2008-04-21T19:14:00.004-04:00

So I've put together a simple plugin for grabbing fixtures out of a Live Rails project.


Harvixture is a tool that can be used to extract data, in the form of fixtures,
from a Rails project.  It is done by pointing the harvixture at a request_path
and dumping fixtures for all "found" ActiveRecord objects.

$ sudo gem install jeremyf-harvixture --source=http://gems.github.com/

$ cd path/to/rails/project

$ . harvixture run --request_path=/users/1/calendars./bug_100/users.yml
./bug_100/calendars.yml

Get the plugin here.
http://github.com/jeremyf/harvixture/tree/master

TODO:
- Possibly convert to a gem.

A little bash script hacking

2008-04-14T19:01:00.005-04:00

Puttering around the blog-o-tubes, I discovered an awesome little post concerning git and your command line. The problem with the script is its too limiting. I use both svn and git. So enter my little hack.

In ~/.bashrc



function parse_git_branch() {
  git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/(git::\1)/'
}
function parse_svn_branch() {
  parse_svn_url | sed -e 's#^'"$(parse_svn_repository_root)"'##g' | awk -F / '{print "(svn::"$1 "/" $2 ")"}'
}
function parse_svn_url() {
  svn info 2>/dev/null | grep -e '^URL*' | sed -e 's#^URL: *\(.*\)#\1#g '
}
parse_svn_repository_root() {
  svn info 2>/dev/null | grep -e '^Repository Root:*' | sed -e 's#^Repository Root: *\(.*\)#\1\/#g '
}
function parse_scm_branch() {
  local value=$(parse_git_branch) 
  if [ -z "$value" ]; then
    local value=$(parse_svn_branch)
  fi
  echo "$value"
}

export PS1="\[\033[00m\]\u@\h\[\033[01;34m\] \w \[\033[31m\]\$(parse_scm_branch) \[\033[00m\]$\[\033[00m\] "

For git directories


jeremyf@reclusive-geek ~/Documents/Repositories/git/ccs_portal (git::master) $

For svn directories


jeremyf@reclusive-geek ~/Documents/Repositories/svn/ccs_main/app/controllers (svn::ccs_main/trunk) $

If anyone knows how to tighten this script up, let me know.

git add --patch file.name

2008-04-08T15:25:00.002-04:00

I would highly recommend reading http://tomayko.com/writings/the-thing-about-git, it highlights yet another awesome feature of git. Git lets you do your work how you do it, instead of how the SCM says you should. Here is a great example. I have a hopelessly muddled set of changes in file_the_other.txt. The changes are for two (or more) different purposes, and I need to only push a portion of it. Enter `git add --patch`. I can go through each diff element and select to put it in the queue (the Index) for what will be committed.



$ git add --patch file_the_other.txt 
diff --git a/file_the_other.txt b/file_the_other.txt
index 2120d21..e3aa90d 100644
--- a/file_the_other.txt
+++ b/file_the_other.txt
@@ -1,3 +1,6 @@
+World is here
 A file like another file, but with different content.
 
-There is even more content here.
\ No newline at end of file
+There is even more content here.
+
+Hello World
\ No newline at end of file
Stage this hunk [y/n/a/d/s/?]?

Some rspec love for acts_as_state_machine

2008-03-14T12:43:00.003-04:00

So I've once again revisited the almighty "acts_as_state_machine" plugin (http://elitists.textdriven.com/svn/plugins/acts_as_state_machine). Its really helpful, but one thing I've never liked is testing the valid transitions. Because, really you should test a whole lot of stuff; Enter :describe_valid_event_transitions.


class MyStatedObject < ActiveRecord::Base
  acts_as_state_machine :initial => :pending, :column => 'status'
  state :pending
  state :active
  state :completed
  state :rejected

  event :approve! do
    transitions :to => :active, :from => :pending
  end

  event :reject! do
    transitions :to => :rejected, :from => :pending
  end
  event :complete! do
    transitions :to => :completed, :from => :active
  end
end

describe MyStatedObject do
  describe_valid_event_transitions do |transition|
    transition.is_valid(:event => :approve!,  :from => :pending, :to => :active)
    transition.is_valid(:event => :reject!,   :from => :pending, :to => :rejected)
    transition.is_valid(:event => :complete!, :from => :active,  :to => :completed)
  end
end

Using the above code it will generate 3 (events) * 4 (statuses) * 4 (statuses) specs. If I were to inadvertently add a validator for :event => :stupify!, then the number of specs would be 4 * 4 * 4, and there would be a whole lot of failures.


module Spec
  module Rails
    module Matchers
      # Specifies a valid state change
      #
      # options
      # :from: The from state
      # :to: The desired state
      # :via: The event to fire the transition
      def change_state(*args)
        options = args.extract_options!
        from_status = options[:from]
        to_status = options[:to]
        via_event = options[:via]
        return simple_matcher("model should change status from :#{from_status} to :#{to_status} via :#{via_event} event") do |klass|
          object = klass.is_a?(Class) ? klass.new : klass
          object.stub!(:current_state).and_return(from_status.to_sym)
          object.stub!(:status).and_return(from_status.to_s)
          if event = object.next_states_for_event(via_event).detect{|event| event.to == to_status}
            event.to.to_sym == to_status.to_sym
          else
            false
          end
        end
      end
    end
  end
end


class Spec::Rails::Example::RailsExampleGroup

  class ValidTransitionCollector #:nodoc:

    def events
      transition_table.collect{|t| t[:event]}.uniq
    end

    def states
      transition_table.collect{|t| [t[:to], t[:from]]}.flatten.uniq
    end

    def add(options = {})
      options.symbolize_keys!
      transition_table << {:event => (options[:event] || options[:via]).to_sym, :from => options[:from].to_sym, :to => options[:to].to_sym}
    end
    alias_method :is_valid, :add

    def has?(event, from, to)
      transition_table.detect{|o| o[:event] == event && o[:from] == from && o[:to] == to}
    end
    protected
    def transition_table
      @transition_table ||= []
    end
  end

  class << self
    # This method assumes the use of the awesome acts_as_state_machine, 
    #
    # Given all events (both defined and proposed to the validator)
    # and all statuses (both defined and proposed to the validator),
    # this method will iterate over the events, and then over
    # the statuses as the "from" status, and then over the
    # statuses again as the "to" status.  
    #
    # With the event, from status and to status, this method 
    # will check against the validator to say it should or
    # should_not state_change
    #
    #
    # Usage:
    #
    # describe MyStatedObject do
    #   describe_valid_event_transitions do |transition|
    #     transition.is_valid(:event => :approve!,  :from => :pending, :to => :active)
    #     transition.is_valid(:event => :reject!,   :from => :pending, :to => :rejected)
    #     transition.is_valid(:event => :complete!, :from => :active,  :to => :completed)
    #   end
    # end
    #
    def describe_valid_event_transitions
      collector = ValidTransitionCollector.new
      yield(collector)
      klass = description.constantize
      describe 'status changes' do
        (klass.event_table.keys + collector.events).uniq.each do |event|
          (klass.states + collector.states).each do |possible_from_state|
            (klass.states + collector.states).each do |possible_to_state|
              should_transition = false
              if result = collector.has?(event, possible_from_state, possible_to_state)
                should_transition = true
              end

              it "should #{should_transition ? '' : 'NOT '}change from :#{possible_from_state} to :#{possible_to_state} via :#{event}" do
                klass.send("#{should_transition ? 'should' : 'should_not'}", change_state(:via => event, :from => possible_from_state, :to => possible_to_state))
              end
            end
          end
        end
      end
    end
  end
end

RSpec Delegation Assertion

2008-01-24T16:34:00.000-05:00

So I've made the jump to using RSpec, and I love it. I really like the declarative nature of the matchers, and feel compelled to write useful ones. Below is a matcher for testing delegations. As of right now, I have not yet decided if I should have the
matcher be at the class level or the object level. We'll see. Perhaps iteration 2.


class Comment < ActiveRecord::Base
  extend Forwardable
  belongs_to :user
  def_delegator :user, :name, :author_name
end

describe Comment do
  it 'should delegate author_name to user' do   
    Comment.should delegate(:author_name, :to => :user, :via => :name)
  end
end

Below is a helpful tester for delegations, inspired by Jay Fields, and more importantly made possible by Obie Fernandez's most excellent The Rails Way.


module Spec
  module Rails
    module Matchers
      # describe Comment do
      #   it 'should delegate author_name to user' do
      #      Comment.should delegate(:author_name, :to => :user, :via => :name)
      #   end
      # end
      class Delegation
        private
        attr_reader :expected, :actual, :method_name, :options, :to, :via
        public
        def initialize(method_name, options = {})
          @method_name = method_name
          options.symbolize_keys!
          @to = options[:to]
          @via = options[:via] || method_name
        end

        def matches?(klass)
          @actual = klass
          delegate_class = Class.new
          delegate_class.send(:attr_accessor, @via)

          delegate_object = delegate_class.new
          delegate_object.send("#{@via}=", :spec_rails_matchers_delegation)

          @base_object = @actual.new
          
          # Use the singleton class of the base_object
          # I am rewriting the @to method on the base_object's meta_class
          # but not altering the base_object's parent class
          # So if I instantiate another instance of @actual
          # it will not have the below behavior, only the @base_object will
          #
          # http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
          singleton = @base_object.instance_eval("class << self; self; end")
          singleton.class_eval("attr_accessor :#{@to}")

          @base_object.send("#{@to}=", delegate_object)
          @base_object.send(method_name) == :spec_rails_matchers_delegation
        end

        def failure_message
          "expected #{actual.to_s} to delegate :#{method_name} to :#{to} via :#{via}"
        end

        def negative_failure_message
          "expected #{actual.to_s} to NOT delegate :#{method_name} to :#{to} via :#{via}"
        end

        def to_s
          "#{actual.to_s} delegates :#{method_name} to :#{to} via :#{via}"
        end

      end
      def delegates(method_name, options = {})
        Delegation.new(method_name, options)
      end
      alias_method :delegate, :delegates
    end
  end
end

Ruby UML Diagrammer

2007-08-27T19:38:00.000-04:00

Well, after a few bursts of creativity, I've finally posted the Ruby UML Diagrammer (http://rumld.rubyforge.org/)


$ sudo gem install rumld --included-dependencies
$ rumld --help

Digging for method signatures

2007-08-08T23:36:00.000-04:00

This evening I decided to write some UML for the permission sub-system that I'd been working on. I decided that I really should have it in dot format because 1) I want to learn it better, 2) its plain text and thus more "Pragmatic", 3) there are rails gems (i.e. railroad) that can generate dot format. So I wrote the dot file (with inspiration from a railroad output). During the process, I decided to include the method signatures, which definitely helps to explain what's going on.

Then, I decided that I'd really like my classes to be able to generate this UML (in particular I wanted the method signature). So with a little thinking, I started to roll my own, but it gets a bit complicated parsing the source file and determining what's going on. Fortunately, after 30 minutes, I realized that RDoc does the hard-work for me, and all I need to do is parse the html.

Enter RdocInspector. It takes a string and finds and collects the Public Class methods, Public Instance methods, and Protected Instance methods (as well as their arguements). The string is the result of File.read(some_rdoc_html_file).

My UML automation work is not yet done, but the issue of what methods are explicitly defined in a given file has been solved.

Mocha

2007-07-18T22:03:00.000-04:00

So my previous post talked about overriding delegation. Then I remembered, Mocha. An honest to goodness stubbing/mocking library. Rather obviously, when testing units, I really don't want to fiddle around with the interaction of objects in each and every instance.

So instead of my convoluted example of conditionally_overriding_delegation, I can do the following (but hey you may have already known this):


class AbstractUnit
  extend Forwardable
  def_delegate :foo, :name

  def has_name?
    !(name.nil? || name.blank?)
  end
end

class AbstractUnitTest < Test::Unit::TestCase
  def setup
     @object = AbstractUnit.new
  end

  # Perhaps a reasonable test for delegation?
  def test_should_delegate_name_to_foo
    assert_equal @object.name, @object.foo.name
  end

  def test_has_name_should_be_false_if_name_is_empty
    @object.stubs(:name).returns('')
    assert ! @object.has_name?
  end

  def test_has_name_should_be_false_if_name_is_nil
    @object.stubs(:name).returns(nil)
    assert ! @object.has_name?
  end

  def test_has_name_should_be_false_if_name_is_blank
    @object.stubs(:name).returns('hello world')
    assert @object.has_name?
  end

end

Even in this case, Mocha is rather useful, I don't have to worry about testing the coupling that occurs due to delegation, and can test the objects responsibilities. Of course, now its time to look more into Mocha's documentation. It looks like there is some rather amazing stuff that can be done.

assert_interface

2007-07-16T21:23:00.000-04:00

I've been reading quite a bit on programming these days. And one of the things I'm liking more and more is the concept of programming for the interface.
Now I use Ruby and not Java or C# or other languages, so the idea of the interface is a bit different. I can implement them, kind of, via a module.
However, I want to make sure that my objects quack appropriately. Enter assert_interface(object, module). The object is assumed to be an
instance of a class. The module is assumed to be "well-formed" for interfaces


module WellFormedInterface
  def self.included(base)
    base.send(:include, InstanceMethods)
    base.extend(ClassMethods)
  end
  
  module ClassMethods
  end
  module InstanceMethods
  end
end

class AbstractUnit
  include WellFormedInterface
end


class Test::Unit::TestCase
  # Given an object (i.e. Foo.new), and a module (i.e. SomethingCool)
  # assert that all methods explicitly defined in the module
  # are present in the object.
  #
  # This isn't the end all test, as you are still responsible for
  # testing the implementation of the interface
  def assert_interface(object, mod)
    methods = {object => [], object.class => []}

    mod::InstanceMethods.instance_methods(false).each do |method|
      methods[object] << method unless object.respond_to?(method)
    end

    mod::ClassMethods.instance_methods(false).each do |method|
      methods[object.class] << method unless object.class.respond_to?(method)
    end
  
    msg = []
    methods.each_pair do |key, value|
      msg << "Expected #{key} to respond to the following :#{value.join(' :')}" unless value.empty?
    end

    if msg.empty?
      assert true, 'Hey, it all worked'
    else
      flunk msg.join('. ')
    end
  end
end

Overriding def_delegator

2007-07-12T14:22:00.000-04:00

In the project I work on, I make heavy use of the def_delegator method (yeah composition). One of the intrinsic problems of the delegation, is that my tests can get rather convoluted (and tightly coupled to implementation). I'm sure I could look into mock methods, but I needed an immediate solution.

Enter the ConditionallyOverrideDelegation module. This is a rails specific solution as it makes use of alias_method_chain.


module ConditionallyOverrideDelegation
  def self.included(base)
    base.extend(Macro)
  end
  module Macro

    # class Foo
    #   extend Forwardable
    #   def_delegator :bar, :name
    #   conditionally_override_delegation :name
    # end
    # class Bar
    #   def name
    #     'Bar'
    #   end
    # end
    # 
    # @foo = Foo.new
    # @foo.bar.name == @foo.name
    # => true
    #
    # @foo.name_with_delegation_override = @foo.bar.name * 2
    # @foo.bar.name == @foo.name
    # => false
    #
    # Take a look at the tests to see how this truly behaves
    #
    # Really you probably only want to use this method in test
    #
    def conditionally_override_delegation(*targets)
      targets.flatten.each do |target|
        aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
        src = <<-EOV
        def #{aliased_target}_with_delegation_override#{punctuation}(*args)
          if @#{aliased_target}_with_delegation_override.nil?
            #{aliased_target}_without_delegation_override#{punctuation}(*args)
          else
            @#{aliased_target}_with_delegation_override
          end
        end
        EOV
        module_eval src, __FILE__, __LINE__
        alias_method_chain target, :delegation_override
        attr_writer "#{aliased_target}_with_delegation_override"
      end
    end

  end
end

And the obligatory tests


require File.dirname(__FILE__) + '/../test_helper'
require 'conditionally_override_delegation'
class ConditionallyOverrideDelegationTest < Test::Unit::TestCase
  class AbstractUnit
    extend Forwardable
    include ConditionallyOverrideDelegation
    
    def_delegators :related_object, :to_s, :string=, :string, :string?
    
    conditionally_override_delegation :to_s, :string
    
    def related_object
      @related_object ||= RelatedObject.new
    end
  end
  
  class RelatedObject
    def to_s
      'Hello World'
    end
    attr_accessor :string
    def string?
      !!string
    end
  end
  
  def setup
    @unit = AbstractUnit.new
  end
  
  def test_delegation_is_working
    assert_equal @unit.related_object.to_s, @unit.to_s
  end

  def test_overridding_delegation_is_working
    @unit.to_s_with_delegation_override = 'Turkey Sandwich'
    assert_equal 'Turkey Sandwich', @unit.to_s
  end

  def test_overridding_delegation_is_working_when_override_is_false
    @unit.to_s_with_delegation_override = false
    assert_equal false, @unit.to_s
  end

  def test_overridding_delegation_is_working_when_override_is_nil
    @unit.to_s_with_delegation_override = nil
    assert_equal @unit.related_object.to_s, @unit.to_s
  end

  def test_overridding_delegation_is_working_with_punctuation
    @unit.related_object.string = 'Troy Mclure'
    assert_equal 'Troy Mclure', @unit.string
    
    @unit.string_with_delegation_override = 'Pancake'
    assert_equal 'Pancake', @unit.string
  end
end

Of Childhood Discoveries

2007-07-07T20:53:00.000-04:00

Recently I've been running a Star Wars Saga edition campaign for my children. They really love it (who doesn't want to be a Jedi or a space-faring princess). The Star Wars Saga rules are very slick and take a lot of the obnoxious complexities out of the d20 system. This has sparked my interest in running a sci-fi campaign. And as such, I've been trolling (in the fishing manner not the forum-posting manner) the inter-tubes for inspiration. And that is when I stumbled onto Star Frontiers.

Twenty one years ago, I played my first role-playing game. It was Star Frontiers, published by the now defunct TSR. During the first session, I played a Dralasite that made use of tangler grenades. It was a blast, and to this day, Star Frontiers holds a special spot in my heart. Apparently, there are many others that also remember the good ole' days, and are keeping the torch burning.

Its not like I've forgotten about the system, its just that its old and not the cool new system with all the bells and whistles. Its just a well written game, with an excellent underlying system that doesn't have quite the same internal harmony of a more modern gaming system. But oddly enough, I find myself intrigued and interested in running a game of it. Why? Partly because of nostalgia, and partly because the rules seem to focus more on playing the game and not tweaking yourself out for the next level (an intrinsic problem in the current manifestation of D&D).

All told, I'll probably run a Star Wars Saga edition game (its got Jedi), but maybe I won't use the Star Wars universe.

Corrupt Session?

2007-05-21T08:42:00.000-04:00

The system that I have been working on for the past while had a particularly vexing problem. Every morning, I had to restart the mongrel cluster. The reason, each morning the login process just stopped working. It was especially annoying, because I had one shot each day to attempt to fix it (to apply the fix, I had to restart the server). After a two weeks of various attempts at correcting the problem, we finally stumbled upon the problem.


class ApplicationController < ActionController::Base
  session :session_expires => 12.hours.from_now
end

I was assuming that a session would gracefully expire 12 hours after first being created. In fact, what was happening is the session would expire 12 hours after the server restarted. So once twelve hours would pass, each request would generate a new session that would in essence be immediately expired. Not exactly the behavior I was looking for.

So if you are looking for corrupt session, session corruption, or unresponsive mongrel it may just be related to the code above.

A "Best Migration Practice"

2007-05-09T11:21:00.000-04:00

So today, I discovered a "good idea" for migrations.

Put your database schema changes in one migration, then your data changes in the next. This becomes self-evident when you mix the two and watch as part way through your migration, the data change fails and suddenly your tables have been altered.

Complex views and conventional trickery

2007-04-01T16:46:00.000-04:00

This past month, I've been working on a Content Management System (CMS). The CMS is comprised of many sites, each of which have many subwebs (permissioned collections), each site has many pages, each page has many content blocks. The navigation tree of a subweb is a polymorphic relation. So when generating the navigation in the CMS Admin, I use the following method:


module PagesHelper
  # Generate a link to the show page of navigation node
  def link_to_node(node)
    link_to( h(node.display_title), send(*node.route_for_show), :class => node.published? ? 'published' : 'unpublished' ) 
  end
end

In the above example, node the send(*node.route_for_show). I ask the node (which is either a subweb or a page to tell me how to generate the path.


class Page < ActiveRecord::Base
  def route_for_show
    return :page_path, subweb, self
  end
end
class Subweb < ActiveRecord::Base
  def route_for_show
    return :subweb_path, self
  end
end

So the module knows the method to generate its path, but can't actually build the URL. So it passes the information back to the helper, which can generate the path.

I don't know if this is the best way to do it, but its working for me (and I've used this pattern for rendering links for another polymorphic relation).

The ever evolving test suite

2007-02-20T08:44:00.000-05:00

I've been working on a rather http://www2.blogger.com/img/gl.link.giflarge rails project and have watched my testing style evolve. And this next step, inspired by Jay Fields has really got me excited. Take a peek.


class Test::Unit::TestCase
  class << self
    def test(*names, &block)
      test_name = :"test_#{names.join('_').gsub(/[^\w ]+/, '').gsub(/ +/, '_')}"
      raise ArgumentError, "#{test_name} is already defined" if self.instance_methods.include?( test_name.to_s )
      if block_given?
        define_method( test_name, &block )
      else
        define_method( test_name) do
          $stderr.puts "Incomplete test '#{names.join(', ')}' @ #{caller.last}"
        end
      end
    end
  end
end

What the above method does is allows for very "fast and loose" test definitions. For example, I can do the following:


class Foo < Test::Unit::TestCase
  # This is a place holder test, and when ran will 
  # print a warning
  test 'this will print a warning when the test runs'

  # This is a genuine test
  test 'this will assert true' do
    assert true
  end
  
  # This is another genuine test, but I'm providing visually 
  # putting the test in another namespace
  test :index => 'should render a list' do
    assert_template 'list'
  end
end

Ultimately, I'm extremely satisfied with how this works. My functional tests can have test definitions with a prefix of the action.

I have updated my Textmate so I can Run Focused Unit Tests, as well as having test highlighted like other keywords (alias, class, require, etc.)

Hpricot, screen_scrape, and horrible pages

2007-02-07T13:22:00.000-05:00

I'm an avid Dungeons and Dragons player and have decided I'm going to make a Rails application that will help consolidate the rules for personal use.

So I decided to do a screen scrape http://www.wizards.com/default.asp?x=dnd/lists/feats . I wanted the list of feats. To get to the table, and each row of feats, here was the xPath I used:

"/html/body/table[2]/tr[2]/td[3]/table/tr[3]/td/table[4]/tr/td/table/tr"

Of particular note, I was having trouble with the tbody in xPath, so I removed those references. Let me tell you, without Firebug's copy xPath, I would've went insane getting this out.

So I ask, why the heck does Wizards of the Coast use table based layouts. They hurt my brain hurt.

If you are interested here is the code that I wrote. It doesn't have any underlying tests, but I ran the import without fail, so for now, its good enough for me.


class Feat < ActiveRecord::Base
  validates_presence_of :name, :description
  belongs_to :rule_source

  class << self
    # Run the import, first getting the RuleSources
    def import!
      File.open(File.dirname(__FILE__) + '/feats.html', 'w') do |f|
        f.puts (open("http://www.wizards.com/default.asp?x=dnd/lists/feats").read)
      end
      doc = File.open(File.dirname(__FILE__) + '/feats.html') {|f| Hpricot(f) }

      RuleSource.parse_rule_source(doc)
      
      parse_feats(doc)
    end
    private
    def parse_feats(doc)
      feats = (doc/"/html/body/table[2]/tr[2]/td[3]/table/tr[3]/td/table[4]/tr/td/table/tr")      
      feats.pop     # Get rid of the results count

      feats.each_with_index do |feat, index|
        parse_feat(feat) if index > 1
      end
    end
    def parse_feat(feat)
      ... Do the actual parsing of the row ...
    end
  end
end

class RuleSource < ActiveRecord::Base
  validates_presence_of   :code, :name

  class << self
    def parse_rule_source(doc, publisher = nil)
      (doc/"div.keyboxscroll/table/tr").each do |source|
        if source_code = (source/"td[1]")
          source_code  =  source_code.inner_html.strip
        end
        if source_name = (source/"td[2]/i")
          source_name  = source_name.inner_html.strip
        end
        
        find_or_create_by_code_and_name( source_code, source_name )
      end
    end
  end
end

Single Table Infuriation

2007-01-30T20:21:00.000-05:00

Single Table Inheritance in Rails is an excellent pattern that works really well, except when it doesn't.


class Parent < ActiveRecord::Base
end

class Child < Parent
end

class GrandChild < Child
end

Each of the above classes are defined in their own files (app/models). There are times in development mode that I've noticed that Child.find(:all) will generate the following SQL:


SELECT * FROM parents WHERE (type='Child')

In Rails 1.2 the fix for this is perhaps a little obfuscated.


class Parent < ActiveRecord::Base
  require_dependency 'child'
end

class Child < Parent
  require_dependency 'grand_child'
end

class GrandChild < Child
end

Now, the other part of this solution is that you probably want to call require_dependency at the end of the class definition as there may be methods in the parent object that the child object needs. I suppose you could re-open the class at the end of the file.

capture, binding and other diabolical machinations

2007-01-24T22:45:00.000-05:00

For the South Bend Ruby Group I volunteered to talk about form builders for February. At the time of volunteering, I knew close to nothing about form builders. I decided to take the upcoming meeting as a reason for learning about the builders. And now I'm hooked.

But that is not the point of this particular post. What I'm talking about is the bizarre magic involved in the form builder. In a project that I've been working on we have a need for rendering lists both in tables and in lists. However we'd really like to re-use the view logic in generating the list. Its pretty much a matter of hot-swapping the tags appropriately.


<% list_for(@list) do | l | %>
  <% l.caption 'Hello World' %>
  <% l.header_row(:id => 'list_head') do %>
    <%= l.header_cell 'title' %>
    <%= l.header_cell 'edit' %>
    <%= l.header_cell 'delete' %>
  <% end %>
  <% l.row( :class => 'spam', :id => 'hot_dog') do | list_item | %>
    <%= l.cell l.title %>
    <%= l.cell 'edit_link' %>
    <%= l.cell 'delete_link'  %>
  <% end %>
<% end %>

We opted to create a builder class. You call :list_for, and can optionally pass a builder class (like the one below). Of particular note there is use of bindings and captures. I'm still a bit dazzled by what all is going on (and wrote the tests to make sure it all works). Below is my understanding of what is going on.

1) There is the :concat method (as defined in the ActionView::Helpers::TextHelper module). We are taking the results of first parameter and appending it to the proc's binding. The proc's binding is the result of the stuff in that proc. In the case of the above :list_for its all of the text generated :list_for's block.

2) There is the :capture method (as defined in ActionView::Helpers::CaptureHelper module). This little critter packages up the input block as text. I tried using block.call but this didn't work as intended (I got double the block text). If I didn't want the option of passing options to each of the elements, I could conceptually simplify the method by doing a manual opening of a tag, block.call, then manually closing the tag. This could be a performance piece that I will implement at a later point (though I'll need a Hash#to_markup_attributes method).



def list_for(object, *args, &block)
  raise ArgumentError, "Missing block" unless block_given?
  options = args.last.is_a?(Hash) ? args.pop.symbolize_keys! : {}
  builder = options.delete(:builder) || ListTableBuilder
  builder.new(object, self, options, &block)
end

# <table>
#  <caption>
#  <tr>
#    <th />
#  </tr>
#  <tr>
#    <td />
#  </tr>
# </table>
class ListTableBuilder

  # Welcome to the insanely bizarre initialize function
  def initialize(collection, template, options, &proc)
    @collection, @template, @proc = collection, template, proc        
    @options = options.reverse_merge( :class => 'list', :id => 'list')
    @template.concat( @template.content_tag('table', @template.capture(self, &proc) , @options ), @proc.binding)
  end

  # :options are applied to content_tag('td')
  def cell(text, options = {})
    @template.content_tag('td', text, options)
  end

  # :options are applied to content_tag('th')
  def header_cell(title, options = {}) 
    @template.content_tag('th', title, options)
  end

  # :options are applied to content_tag('caption')
  def caption(text, options={})
    @template.concat( @template.content_tag('caption', text, options), @proc.binding )
  end

  # :options are applied to content_tag('tr')
  def header_row(options={}, &block)
    raise ArgumentError, "Missing block" unless block_given?
    @template.concat( @template.content_tag('tr', @template.capture(&block), options) , block.binding)
  end

  # Options
  # The options will be added to each row.  
  # :class will append and not destroy the internal classes
  # :id will be used as a prefix for the internal id generation
  def row(options={}, &block)
    raise ArgumentError, "Missing block" unless block_given?
    options.symbolize_keys!
    @collection.each do | c |
      row_options = options.reverse_merge( :class => '' )
      row_options[:class] += ' ' + @template.cycle('odd_row', 'even_row')
      row_options[:id] += '_' + @template.send(:dom_id, c)
      @template.concat( @template.content_tag('tr', @template.capture(c,  &block ), row_options), block.binding )
    end
  end
end

Ruby Cookbook from O'Reilly

2007-01-22T20:00:00.000-05:00

Ruby Cookbook: Recipes for Object-Oriented Scripting
by Lucas Carlson & Leonard Richardson

ISBN 0-596-52369-6

I haven't read this book cover-to-cover, but I have given it a very thorough inspection, skimming through sections to find points of interest and then stopping to read those recipes. So, actually, I've probably read a whole bunch of the book and didn't realize it.

The book is written in a very concise manner, with plenty of examples, lots of useful code, excellent cross-references and a very generous license that allows you to use the code from the book (albeit with some restrictions).

Each recipe is presented as a quartet of Problem, Solution, Discussion and See Also sections. Each problem is presented succinctly, and the solutions dive right into the required code (with code comments explaining some of the more complicated lines of code, but not explaining the self-documenting lines). The discussion section of each solution really digs into what is going on, code choices that were made, variations, and basically anything else that might be interesting. The see also section cross-references other recipes that may be pertinent to the given problem.

All told, this book does an amazing job of going through a wide range of problems, from Strings & Numbers to Meta-Programming & Rails and Graphics. This book is loaded with useful bits of information and I would highly recommend adding it to your collection.

Some Weird Weird Ruby (or nest Classes and Inheritence)

2007-01-17T22:13:00.000-05:00

Thinking cap time. I am working on a CMS and the short of it is that a Page will have many PageBlock objects. The PageBlock is versioned and can have multiple things associated with it (i.e. Links or Files or Other Stuff, thankfully each page block is homogenous). I decided that the Links/Files will be serialized. So I wrote a serializing helper object. This serializing object


class PageBlock < ActiveRecord::Base
  class << self
    # I want to be able to configure the underlying DataSerializer
    # in the containing class
    delegate :set_valid_serialized_keys, :to => :data_serializing_class
    def data_serializing_class
      self::DataSerializer
    end
  end
  class DataSerializer
    class << self
      def set_valid_serialized_keys( *attrs )
        write_inheritable_attribute :valid_serialized_keys, attrs
        class_inheritable_reader    :valid_serialized_keys
      end
    end
    
    def add_data(data = {})
      data.assert_valid_keys(valid_serialized_keys)
      ... do the magic ...
    end
  end
end

Now


$ PageBlock.valid_serialized_keys
=> NoMethodError: undefined method `valid_serialized_keys' for PageBlock::DataSerializer:Class


class PageLinkBlock < PageBlock
  set_valid_serialized_keys :path, :name
end


$ PageBlock.valid_serialized_keys
=> [:path, :name]

DOH!!! Man that is definitely not the behavior I want. I guess my nested Class has some behavior that I'm not aware of. I'm certain the behavior is intentional, I just didn't know about it

So the solution?


class PageBlock < ActiveRecord::Base
  class << self
    # I want to be able to configure the underlying DataSerializer
    # in the containing class
    delegate :set_valid_serialized_keys, :to => :data_serializing_class

    def data_serializing_class
      self::DataSerializer
    end

    def inherited(page_block_subclass)
      page_block_subclass.module_eval <<-EOV
      class DataSerializer < PageBlock::DataSerializer
      end
      EOV
      super
    end

  end
  class DataSerializer
    class << self
      def set_valid_serialized_keys( *attrs )
        write_inheritable_attribute :valid_serialized_keys, attrs
        class_inheritable_reader    :valid_serialized_keys
      end
    end
    
    def add_data(data = {})
      data.assert_valid_keys(valid_serialized_keys)
      ... do the magic ...
    end
  end
end

Then I define PageLinkBlock and


$ PageBlock.valid_serialized_keys
=> NoMethodError: undefined method `valid_serialized_keys' for PageBlock::DataSerializer:Class

Alas, the behavior that I want. Time to dig out the Pickaxe Book to see if there is a reference to this.

Helper Module Testing

2007-01-16T19:32:00.000-05:00

First and foremost


sudo gem install ZenTest

Then in your app/test/test_helper.rb add


require 'test/rails'

Then make a test class


class FooHelper
  def print_hello_world
    content_tag('p', 'Hello World!')
  end
end

class FooHelperTest < Test::Rails::HelperTestCase
  def test_method_goes_here
    assert_equal '<p>Hello World</p>', print_hello_world
  end
end

Of particular note, the name of the class that inherits from Test::Rails::HelperTestCase is very important. If the inheriting class name is MyHelperTest, make sure a module named MyHelper exists.

Dear RDoc,

2007-01-03T23:39:00.000-05:00

One thing that I've quickly taken for granted is RDoc. Prior to RDoc, I lamented that the documentation that I wrote in code was impossible to discover, and thus the in-code documentation was useless for non-programmers. Thus, in order to "say" what the system did, additional documentation needed to be created. So now there were two sets of documents, both saying what the system did, but not communicating with each other.

Oh the humanity!

Enter RDoc. I can now rake that information and generate a useful document defining the system. It gets even better if I start using should-language, either in specify or test context (i.e. specify 'student should have a name' or def test_student_should_have_a_name). Then I can rake just the method names and get a document that says concisely what the system should do.

Of course this leads itself to writing test stubs earlier in the project process. Even better, it is possible for a project manager to write some of these specifications.

Suddenly, the tests, which everyone wants and needs, become useful not only for documentation but also for communication and um... testing. And better yet, the documentation is not discarded nor duplicated.

Only write what you need.

2007-01-03T23:16:00.000-05:00

I don't recall where I read this, but someone once wrote that each line of code should be viewed as a liability.

At work, a colleague and I have begun referring to the test code as a contract; it describes the behavior of the system. The more tests, the tighter the contract. By extension, the more code in the system, the more restrictive the implicit contract. The implicit contract is the written, and all to often unwritten, expectations of the system.

So the less code needed to get the job done, the better.

Contextual Decoration of a Ruby object

2006-12-23T13:11:00.000-05:00

One of my current work problems is that I have an Account class that needs optional decoration if it has been initialized in the context of an Import. I was kicking around an Observer or AspectR but the latter library wreaks of Java, and the former just isn't as seamless as I'd like. Also, I need to be mindful of multiple threads. Below is the solution I came up with, without the problem specific code.

The situation is actually more complicated than what I am modeling below.


class Import
  attr_reader :start_at, :stop_at
  class << self
    def run!(&block)
      Thread.new do
        Thread.current['import_log'] = import_log = self.new
        import_log.start!
        yield block if block
        import_log.stop!
      end
    end
  end
  [:start, :stop].eacha do |m|
    define_method("#{m}!") do
      instance_variable_set("@#{m}_at", Time.now)
    end
  end
  
  def log_change(message)
    ... magical stuff happens here
  end
end

class Account < ActiveRecord::Base
  attr_reader :import_log
  def initialize
    @import_log = Thread.current['import_log']
    super
  end
  
  def after_save
    import_log.log_change("Saved Account with ID=#{self.id}") if import_log
  end
end

What is actually happening is that I have numerous objects that use the "is_a_import_model" interface. If a class "is_a_import_model" then its initialize method needs to be overwritten to account for the import_log. There is also a StreamParser that is reading an XML document to process the lots of imports. If the StreamParser is created in the context of an Import.run!, it needs to log and rescue all exceptions, otherwise, it re-raises those exceptions.

Sandman and Desire

2006-12-19T21:27:00.000-05:00

This week, I received an Amazon gift certificate. I spent quite awhile deliberating and thinking about what I wanted. Should I get Zelda for the Wii? Or should I get a couple of game books that I want? What about my wishlist?

I looked on my wishlist and started investigating what Dungeons and Dragons books I wanted. I looked at reviews and was close to ordering when I decided to give my wishlist a final review. There were a few books that I think would be truly interesting (Prime Obsession by John Derbyshire, The Master of Go by Yasunari Kawabata, A History of the Ancient Near East by Marc Van de Mieroop, etc). There were a couple of D&D books that I had earmarked, as well as a couple of CDs. And then there are the Sandman volumes (by Neil Gaiman), the perpetual inhabitant of my wishlist.

Four years ago, I borrowed the 10 volume Sandman series from a friend. I started reading it, and was immediately drawn in by Neil Gaiman's prose. I was hungry, and devoured the volumes in rapid succession, feeling a bit of remorse that I wasn't savoring this feast. As the series drew to a close, I knew that I wanted to own a copy of this particular work of art. The story so seamlessly dovetails with the human mythos that I can't help but feel like it is a part of me.

What is even more odd, is that during college, the Sandman series was being released, and several of my comic-book geek friends were all eagerly awaiting the next issue. They would talk about it, discuss and dissect and absorb each issue. I sort of wonder how I missed out on this phenomenon (ah yes Magic the Gathering and D&D). In any case, having read the 10 volume series I knew that I wanted to own it so I could read and re-read it.

As the years have passed, I've always thought about getting the whole shebang, but could never quite rationalize spending $150 in one pop. I also never felt quite right about just getting one book at a time (there is a part of me that figures that I'll stop at 6 books or something silly).

So with the above in mind I decided yet again to forgo getting the Sandman series, but I noticed something strange. Volumes 1 & 2 were not on the list. Had I missed them? No one ever orders anything from my wishlist, so I went through the steps of adding them back on, but lo, they refused to be added to the wishlist. Someone had in fact gotten me two of them.

So I cleared my shopping cart of some D&D books, and added the remaining 8 books. The gift certificate won't cover it all, but thats a small price to pay for literary genius.

Lightsky Rocks!!!

2006-12-14T17:22:00.000-05:00

Today was our Lightsky Christmas Break. We had snacks, drinks, and were given our Christmas present. Each employee received a Wii (actually 6 Wii were given out and there were three IOUs). The gift was most certainly a surprise. But what really impressed me was the amount of time and effort that went into these gifts. There were several early mornings, frequent visits to stores over lunch or on the way home, conscription of spouses to help get them. In all, a real dedication and desire to make sure that everyone got one. So while my place of employment rocks, its really my co-workers and the owners that rock.

I am stunned by this gracious gift of time and money.

Protected Find

2006-12-12T19:03:00.000-05:00

One of the greatest professional compliments I've ever received was regarding a system that I designed and developed. The purpose was to provide an interface for numerous reporting systems to funnel reporting data into a unified location. I designed the system so that all data was retrieved via task specific finders (i.e. :find_agreement_number, :find_current_document_type). As a result, if the database changed, the methods could still be used (albeit with a tweak to the internal logic). Since I was working in a compiled environment where changing a table meant recompiling the functions that directly accessed the table, the need for public finders was required.

The compliment I received was that 6 months after the design was done, the vendor's system that we were integrating with required a major upgrade and changes. And in order to make my system work, they just pointed the finders to a different table, and presto things were working again.

Now what does this have to do with Ruby on Rails? Today I was having a conversation with a co-worker regarding find. After some discussion, I came out and said I really wish :find were a protected method. Find is a very powerful method that allows you to fully access all data from anywhere. This power exposes your your view, controller, and other models to the risk that your model will change. To reduce this risk, I feel it is important to create specific finders in your model and test them. Also, if you use :find_by_name (a free method on any table that has a :name column), you should also write a test for this (at a minimum making sure that your model responds to that particular find).

The entire goal of creating specific finders is to make the maintenance of a project easier. In addition, it is much easier, in Rails, to test models than controllers or views.

Pimping a Controller

2006-12-09T14:00:00.000-05:00

I've recently started working on a REST based rails project. I've been thinking about the Rails model associations, and in particular has_many :through, which is used to help expose the join between two models. Given the following three models:



class User < ActiveRecord::Base
  has_many :permissions
  has_many :roles, :through => :permissions
end
class Permission < ActiveRecord::Base
  belongs_to :role
  belongs_to :user
end
class Role < ActiveRecord::Base
  has_many :permissions
  has_many :users, :through => :permissions
end

I want to be able to look at permissions in a few different ways (and roles and users for that matter). Now, I can modify my PermissionsController to set the object that will be used for all find calls. By default, the PermissionsController will use Permission.find, but if I swap the Permission object for @finder_object, I can set that @finder_object before_filter. See below:



class PermissionsController < ActiveRecord::Base
  before_filter :determine_finder_object

  def index
    @permissions = @finder_object.find(:all)
    # respond to stuff, though you might want to use different templates
    # based on the finder object
  end

  def determine_finder_object
    if params[:user_id]
      @finder_object = User.find(params[:user_id]).permissions
    elsif params[:role_id]
      @finder_object = Role.find(params[:role_id]).permissions
    else
      @finder_object = Permission
    end
  end
end

Now, is this the best practice? I don't know, however, it feels like its something to explore. One noticeable caveat is that if you are using a REST-based controller, you will want to look at all of your Object.new calls and think about replacing them with @finder_object.build.

As an aside, the above controller would probably end up with several chunks of code that were:



  if params[:user_id]
    #do something for users
  elsif params[:role_id]
    #do something for roles
  else
    #do something in the generic
  end

What can I do to encapsulate this particular logic? I dug up the code from the :respond_to controller instance method, and created a construct for:



determine do |d| 
 d.user_id { #do something for users}
 d.role_id { #do something for roles}
end

I'm not satisfied with it, but am wondering what I might be able to do.

Creatively Captivated

2006-11-29T21:55:00.000-05:00

About 1 year ago, the developers of Lightsky went to the Snakes and Rubies seminar in Chicago (Dec 3, 2005). The event really got us talking and thinking. Corporately we decided to shift from PHP to Ruby on Rails. The decision has proven to be exhilarating. We started using Subversion. We started work on a core infrastructure that has been unit tested (and is being re-factored to REST). We are able to easily re-use code that is freely available (thank heaven for well tested plugins).

I owe a lot to that trip.

$ raving_ruby_fanboy += 1

Peepcode's Restful Rails

2006-11-28T22:36:00.000-05:00

I just finished watching Peepcode's Restful-Rails video. I highly recommend it. I've followed the RESTful push by the rails team, but I haven't seen the true impact. And now, having watched the video, I'm in the mood to re-factor the existing code for my project. I'm going to refrain from this refactoring because of the complications of the existing code-base. However, I'm curious to see what can come of this. The next project I work on will make use of REST.

http://peepcode.com/articles/2006/10/08/restful-rails

Loving the test dots ..................F.....................

2006-11-27T20:18:00.000-05:00

For the past while, I've been working on the largest project my company (www.lightsky.com) has ever undertaken. The scope is rather large and requires lots of data import. To make sure that we got off on the right foot, we spent a lot of time (perhaps too much) developing our framework for what is to come. One of the issues was that we were dealing with a very abstract tool in the beginning (an authorization system).

It has taken a lot of back and forth work, and a lot of diagramming and what-if scenarios. But in the end, I really think the system that we have is rather impressive. I also thank heaven that it is being developed in Ruby (forget Rails for the moment). Prior to Ruby, I had programmed in RPG, VBA, Cool: Plex (a CA case tool), PHP (only 3 months!) and Lotus Notes. One thing that was missing from all of these was a tightly integrated unit test suite. Ruby does this, and does it rather well. I'm certain there are test suites out there, but to have it built right into the language's core functions is shear brilliance.

Now, if I write good tests (which is a challenge as well), I can rest assured that my code works how I say it should work. This allows me to more easily pass the tool off and let others poke around with it. And, if a test breaks, its something they should look into. I have never felt so liberated by applying the constraint of testing as much as I can.

Creating a unified UI

2006-11-26T22:49:00.000-05:00

I've been working on a site that makes use of a view mixin structure. If the view is defined in the for the controller, use it, otherwise use the default view for that action. The views are very atomized [list.rhtml, _list.rhtml, _list_search_panel.rhtml, _list_search_form.rhtml, _list_table.rhtml, _list_table_head.rhtml, _list_table_row.rhtml]. It works great, but there are limitations. Now, the system was not created by me, but had input from me, so I'm not going to bad-mouth it. But what it has gotten me thinking about is my need for an ActionHelper object.

The ActionHelper object would be responsible for knowing what the breadcrumb trail should be as well as the page title, and "tabs" that should be on the page, actions that can be taken, the current location in the menu list. As of right now, this idea is sort of floating around gathering mental momentum. The purpose of this ActionHelper object is to create the interface for building a unified UI.

BAB ruby class for OGL system

2006-11-26T15:13:00.000-05:00

Jamis Buck's Dice class inspired me (a lot). A few weeks ago, I decided to start thinking about a role-playing session manager. I'm still thinking about it, but in the interim, I started work on a few classes, just to "feel better". Included below is a BAB class. It is released as OGC as described by the OGL. This class also has associated tests, if you are truly curious.


$ 5.bab.good 
=> 5

$ 4.bab.poor # Suck it wizard
=> 2

$ 3.bab.medium + 5.bab.poor + 3.bab.poor # 3 Rogue / 5 Wizard / 3 Arcane Trickster
=> 5



class Bab
  class InvalidCount < Exception # :nodoc:
  end
  TYPES = [:good, :medium, :poor]
  attr_reader :count, :epic_count

  def initialize( count )
    raise InvalidCount unless count.is_a?(Integer) && count > 0
    @count = count > 20 ? 20 : count
    @epic_count = count > 20 ? count - 20 : 0
  end

  def good
    self.count + epic_value    
  end

  def medium
    ((self.count * 3) / 4)  + epic_value
  end

  def poor
    (self.count / 2)  + epic_value
  end

  private
  def epic_value
    (self.epic_count + 1) / 2 
  end

end

class Integer
  def bab
    Bab.new(self)
  end
end

The Open Game License for Items posted on this blog.

2006-11-26T14:52:00.000-05:00

OPEN GAME LICENSE Version 1.0a

The following text is the property of Wizards of the Coast, Inc. and is Copyright 2000 Wizards of the Coast, Inc ("Wizards"). All Rights Reserved.

1. Definitions: (a)"Contributors" means the copyright and/or trademark owners who have contributed Open Game Content; (b)"Derivative Material" means copyrighted material including derivative works and translations (including into other computer languages), potation, modification, correction, addition, extension, upgrade, improvement, compilation, abridgment or other form in which an existing work may be recast, transformed or adapted; (c) "Distribute" means to reproduce, license, rent, lease, sell, broadcast, publicly display, transmit or otherwise distribute; (d)"Open Game Content" means the game mechanic and includes the methods, procedures, processes and routines to the extent such content does not embody the Product Identity and is an enhancement over the prior art and any additional content clearly identified as Open Game Content by the Contributor, and means any work covered by this License, including translations and derivative works under copyright law, but specifically excludes Product Identity. (e) "Product Identity" means product and product line names, logos and identifying marks including trade dress; artifacts; creatures characters; stories, storylines, plots, thematic elements, dialogue, incidents, language, artwork, symbols, designs, depictions, likenesses, formats, poses, concepts, themes and graphic, photographic and other visual or audio representations; names and descriptions of characters, spells, enchantments, personalities, teams, personas, likenesses and special abilities; places, locations, environments, creatures, equipment, magical or supernatural abilities or effects, logos, symbols, or graphic designs; and any other trademark or registered trademark clearly identified as Product identity by the owner of the Product Identity, and which specifically excludes the Open Game Content; (f) "Trademark" means the logos, names, mark, sign, motto, designs that are used by a Contributor to identify itself or its products or the associated products contributed to the Open Game License by the Contributor (g) "Use", "Used" or "Using" means to use, Distribute, copy, edit, format, modify, translate and otherwise create Derivative Material of Open Game Content. (h) "You" or "Your" means the licensee in terms of this agreement.

2. The License: This License applies to any Open Game Content that contains a notice indicating that the Open Game Content may only be Used under and in terms of this License. You must affix such a notice to any Open Game Content that you Use. No terms may be added to or subtracted from this License except as described by the License itself. No other terms or conditions may be applied to any Open Game Content distributed using this License.

3.Offer and Acceptance: By Using the Open Game Content You indicate Your acceptance of the terms of this License.

4. Grant and Consideration: In consideration for agreeing to use this License, the Contributors grant You a perpetual, worldwide, royalty-free, non-exclusive license with the exact terms of this License to Use, the Open Game Content.

5.Representation of Authority to Contribute: If You are contributing original material as Open Game Content, You represent that Your Contributions are Your original creation and/or You have sufficient rights to grant the rights conveyed by this License.

6.Notice of License Copyright: You must update the COPYRIGHT NOTICE portion of this License to include the exact text of the COPYRIGHT NOTICE of any Open Game Content You are copying, modifying or distributing, and You must add the title, the copyright date, and the copyright holder's name to the COPYRIGHT NOTICE of any original Open Game Content you Distribute.

7. Use of Product Identity: You agree not to Use any Product Identity, including as an indication as to compatibility, except as expressly licensed in another, independent Agreement with the owner of each element of that Product Identity. You agree not to indicate compatibility or co-adaptability with any Trademark or Registered Trademark in conjunction with a work containing Open Game Content except as expressly licensed in another, independent Agreement with the owner of such Trademark or Registered Trademark. The use of any Product Identity in Open Game Content does not constitute a challenge to the ownership of that Product Identity. The owner of any Product Identity used in Open Game Content shall retain all rights, title and interest in and to that Product Identity.

8. Identification: If you distribute Open Game Content You must clearly indicate which portions of the work that you are distributing are Open Game Content.

9. Updating the License: Wizards or its designated Agents may publish updated versions of this License. You may use any authorized version of this License to copy, modify and distribute any Open Game Content originally distributed under any version of this License.

10 Copy of this License: You MUST include a copy of this License with every copy of the Open Game Content You Distribute.

11. Use of Contributor Credits: You may not market or advertise the Open Game Content using the name of any Contributor unless You have written permission from the Contributor to do so.

12 Inability to Comply: If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Open Game Content due to statute, judicial order, or governmental regulation then You may not Use any Open Game Material so affected.

13 Termination: This License will terminate automatically if You fail to comply with all terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses shall survive the termination of this License.

14 Reformation: If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.

15 COPYRIGHT NOTICE
Open Game License v 1.0 Copyright 2000, Wizards of the Coast, Inc.

Jeremy Friesen copyright

OPEN GAME CONTENT: Open game content will in box, as indicated below.

This is open game content

OSX and Textmate and Ruby

2006-11-26T12:57:00.000-05:00

This morning I spent an hour reviewing Textmate's Rails and Ruby bundle. Trying to eek out any bits of efficiency that I can. I was particularly interested in the Rails > Model > Show DB Schema for Current Class command. I tried to run it, and it squacked. The process.rb file said that rubygems was missing. Odd.

So time for a little hacking. I added `echo $PATH` and it returned rather odd results (at least as I was envisioning). It had omitted /usr/local/bin, which is where my primary ruby installation can be found. I checked the Textmate documentation, and all should have been well. In my ~/.bash_profile I was prepending /usr/local/bin, but this was not registering. So the fix I settled on was modifying /etc/profile (and restarting my machine).

With the changes in place the command worked splendidly.

As if to pretend like I'll post to this thing

2006-11-26T00:44:00.000-05:00

This afternoon and evening, I spent most of my time verifying that the internet had not in fact gone anywhere. I checked my feeds, eager to find something new to read. I ended up reading several IBM articles related to Ruby and helped a friend with his statistics. All told, a rather fruitless day.