class CreatePages < ActiveRecord::Migration
  def self.up
    create_table :pages do |t|
      t.column :title, :string
      t.column :parent_id, :integer
      t.column :rgt, :integer
      t.column :lft, :integer
    end
  end

  def self.down
    drop_table :pages
  end
end

class Page < ActiveRecord::Base
  acts_as_nested_set
end

class Page < ActiveRecord::Base
  acts_as_nested_set
 
  belongs_to :parent,
             :foreign_key => :parent_id,
             :class_name => "Page"
  has_many   :children,
             :foreign_key => :parent_id,
             :class_name => "Page"
end

class PagesController < ApplicationController

  active_scaffold :page do |config|
    config.columns[:children].association.reverse = :parent
    config.nested.add_link("Show Children", [:children])
  end

end

1. Get a communication going
   1. Establish a communication line with the person who wants the site.
   2. Make sure they know who you are, what you do, what you have done. Get a feel for them as well
2. Find out what is needed and wanted
   1. TALK WITH YOUR CLIENT
   2. Draw, look at pervious websites together, look at websites they like, do they want professional and slick, or fun and friendly?  What is the mood they want to convey?  Safe and reliable, or cutting edge and in your face?  Get the feel.
   3. Get lists of things they want on the site
3. Do, Produce or Present it
   1. Wireframe design and work out what is needed on the pages
   2. Basic look and feel design, how is the site going to hang together
   3. Getting the pages up by using Design Driven Development
      
   4. Getting the look and feel working (Lorem Ipsum stage)
   5. Coding the backend to the site using Behaviour Driven Development (BDD)
      
   6. Coding the interactions with other services (payment gateways etc) using BDD
   7. Populating the site with data
   8. Staging the server and inhouse testing
   9. Putting the site online!

1. Login to the admin module
2. Get the MAC address of the NIC #1 on the blade you want to install
3. Set up a DHCP setting which includes the MAC address and the pxeboot filename per the OpenBSD website
4. Extract the kernal from an OpenBSD boot floppy (see below)
5. Make a custom boot.conf to fix the port and speed to com1 and 115200 respectively (see below)
   
6. Copy the bsd file and etc directoy of your custom floppy image to /tftpboot/
7. Boot your blade,
   
8. Connect to your blade
9. Select PXE boot (ESC-SHIFT-2 at the appropriate prompt)
10. Type "floppy41.fs" or whatever name you called your floppy

1. The user that Capistrano uses to ssh in has to have a POSIX shell... that basically means BASH.  So if the account you are using for Capistrano uses TCSH... it ain't gonna werk Caap'n!
2. You are deploying into a chrooted environment... chrooted... got it?  Repeat after me, ch root ed.  That means... actually... lets get out of this list and i'll explain more fully.

development:
   adapter: mysql
   database: test_development
   socket: /var/run/mysql/mysql.sock
   username: username
   password: password
   host: localhost 

development:
  adapter: mysql
  database: test_development
  username: username
  password: password
  host: 127.0.0.1
  port: 3306

  Resolv::DNS.open do |dns|
    @mx = dns.getresources(domain_name, Resolv::DNS::Resource::IN::MX)
  end

 @dns = mock(Resolv::DNS)
 Resolv::DNS.should_receive(:open).once.and_yield(@dns)

describe Mock, "usage" do

  before(:each) do
    @type_of = mock(YouShould, :define => "your mock requirements")
    AMock.should_receive(:requests_for_data).
          with("information you provide").and_return("anything")
  end

  it "should be intuitive" do
    @mocks.should_be easy_to_read
  end
  
  it "should not be reliant on fixtures" do
    @a_good = mock(IsNotReliantOn, :fixtures => "at all")
    @a_good.without_fixtures = "happiness"
  end

  it "should describe what you are doing" do
    @mocks.help("You define your application")
    @mocks.should help_not_hinder_production
  end

end

  module ActiveRecord
    module Reflection
      class AssociationReflection
        def to_hash
          {
            :macro => @macro,
            :options => @options,
            :class_name => @class_name || @name.to_s.singularize.camelize
          }
        end
      end
    end
  end 

  it "should test reflection details" do

    association_results = {
      :macro => :belongs_to,
      :options => {:counter_cache => :true},
      :class_name => "Location"
    }

    User.reflect_on_association(:location).to_hash.should == association_results
    
  end