gsterndale-warrant 0.0.0 → 0.2.0

data/test/rails_root/vendor/gems/mocha-0.9.4/test/unit/sequence_test.rb

@@ -0,0 +1,104 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/sequence'
+require 'mocha/expectation'
+
+class SequenceTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  class FakeExpectation
+    
+    attr_reader :ordering_constraints
+    
+    def initialize(satisfied = false)
+      @satisfied = satisfied
+      @ordering_constraints = []
+    end
+    
+    def add_ordering_constraint(ordering_constraint)
+      @ordering_constraints << ordering_constraint
+    end
+    
+    def satisfied?
+      @satisfied
+    end
+    
+  end
+  
+  def test_should_be_satisfied_if_no_expectations_added
+    sequence = Sequence.new('name')
+    assert sequence.satisfied_to_index?(0)
+  end
+
+  def test_should_be_satisfied_if_one_unsatisfied_expectations_added_but_it_is_not_included_by_index
+    sequence = Sequence.new('name')
+    expectation = FakeExpectation.new(satisfied = false)
+    sequence.constrain_as_next_in_sequence(expectation)
+    assert sequence.satisfied_to_index?(0)
+  end
+
+  def test_should_not_be_satisfied_if_one_unsatisfied_expectations_added_and_it_is_included_by_index
+    sequence = Sequence.new('name')
+    expectation = FakeExpectation.new(satisfied = false)
+    sequence.constrain_as_next_in_sequence(expectation)
+    assert !sequence.satisfied_to_index?(1)
+  end
+
+  def test_should_be_satisfied_if_one_satisfied_expectations_added_and_it_is_included_by_index
+    sequence = Sequence.new('name')
+    expectation = FakeExpectation.new(satisfied = true)
+    sequence.constrain_as_next_in_sequence(expectation)
+    assert sequence.satisfied_to_index?(1)
+  end
+
+  def test_should_not_be_satisfied_if_one_satisfied_and_one_unsatisfied_expectation_added_and_both_are_included_by_index
+    sequence = Sequence.new('name')
+    expectation_one = FakeExpectation.new(satisfied = true)
+    expectation_two = FakeExpectation.new(satisfied = false)
+    sequence.constrain_as_next_in_sequence(expectation_one)
+    sequence.constrain_as_next_in_sequence(expectation_two)
+    assert !sequence.satisfied_to_index?(2)
+  end
+
+  def test_should_be_satisfied_if_two_satisfied_expectations_added_and_both_are_included_by_index
+    sequence = Sequence.new('name')
+    expectation_one = FakeExpectation.new(satisfied = true)
+    expectation_two = FakeExpectation.new(satisfied = true)
+    sequence.constrain_as_next_in_sequence(expectation_one)
+    sequence.constrain_as_next_in_sequence(expectation_two)
+    assert sequence.satisfied_to_index?(2)
+  end
+  
+  def test_should_add_ordering_constraint_to_expectation
+    sequence = Sequence.new('name')
+    expectation = FakeExpectation.new
+    sequence.constrain_as_next_in_sequence(expectation)
+    assert_equal 1, expectation.ordering_constraints.length
+  end
+
+  def test_should_not_allow_invocation_of_second_method_when_first_n_sequence_has_not_been_invoked
+    sequence = Sequence.new('name')
+    expectation_one = FakeExpectation.new(satisfied = false)
+    expectation_two = FakeExpectation.new(satisfied = false)
+    sequence.constrain_as_next_in_sequence(expectation_one)
+    sequence.constrain_as_next_in_sequence(expectation_two)
+    assert !expectation_two.ordering_constraints[0].allows_invocation_now?
+  end
+
+  def test_should_allow_invocation_of_second_method_when_first_in_sequence_has_been_invoked
+    sequence = Sequence.new('name')
+    expectation_one = FakeExpectation.new(satisfied = true)
+    expectation_two = FakeExpectation.new(satisfied = false)
+    sequence.constrain_as_next_in_sequence(expectation_one)
+    sequence.constrain_as_next_in_sequence(expectation_two)
+    assert expectation_two.ordering_constraints[0].allows_invocation_now?
+  end
+
+  def test_should_describe_ordering_constraint_as_being_part_of_named_sequence
+    sequence = Sequence.new('wibble')
+    expectation = FakeExpectation.new
+    sequence.constrain_as_next_in_sequence(expectation)
+    assert_equal "in sequence 'wibble'", expectation.ordering_constraints[0].mocha_inspect
+  end
+
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/unit/single_return_value_test.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/single_return_value'
+
+class SingleReturnValueTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_return_value
+    value = SingleReturnValue.new('value')
+    assert_equal 'value', value.evaluate
+  end
+  
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/unit/single_yield_test.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/single_yield'
+
+class SingleYieldTest < Test::Unit::TestCase
+  
+  include Mocha
+
+  def test_should_provide_parameters_for_single_yield_in_single_invocation
+    parameter_group = SingleYield.new(1, 2, 3)
+    parameter_groups = []
+    parameter_group.each do |parameters|
+      parameter_groups << parameters
+    end
+    assert_equal [[1, 2, 3]], parameter_groups
+  end
+  
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/unit/state_machine_test.rb

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/state_machine'
+
+class StateMachineTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_initially_be_in_no_state
+    state_machine = StateMachine.new('name')
+    any_state.each do |state|
+      assert !state_machine.is(state).active?
+      assert state_machine.is_not(state).active?
+    end
+  end
+  
+  def test_should_be_able_to_enter_a_state
+    state_machine = StateMachine.new('name')
+    state = 'A'
+    other_states = any_state.reject { |s| s == state }
+    
+    state_machine.is(state).activate
+    
+    assert state_machine.is(state).active?
+    assert !state_machine.is_not(state).active?
+    other_states.each do |s|
+      assert !state_machine.is(s).active?
+      assert state_machine.is_not(s).active?
+    end
+  end
+  
+  def test_should_be_able_to_change_state
+    state_machine = StateMachine.new('name')
+    state = 'B'
+    other_states = any_state.reject { |s| s == state }
+    
+    state_machine.is('A').activate
+    state_machine.is(state).activate
+    
+    assert state_machine.is(state).active?
+    assert !state_machine.is_not(state).active?
+    other_states.each do |s|
+      assert !state_machine.is(s).active?
+      assert state_machine.is_not(s).active?
+    end
+  end
+  
+  def test_should_be_put_into_an_initial_state
+    state_machine = StateMachine.new('name')
+    initial_state = 'A'
+    other_states = any_state.reject { |s| s == initial_state }
+    
+    state_machine.starts_as(initial_state)
+    
+    assert state_machine.is(initial_state).active?
+    assert !state_machine.is_not(initial_state).active?
+    other_states.each do |state|
+      assert !state_machine.is(state).active?
+      assert state_machine.is_not(state).active?
+    end
+  end
+  
+  def test_should_be_put_into_a_new_state
+    next_state = 'B'
+    
+    other_states = any_state.reject { |s| s == next_state }
+    state_machine = StateMachine.new('name').starts_as('A')
+    
+    state_machine.become(next_state)
+    
+    assert state_machine.is(next_state).active?
+    assert !state_machine.is_not(next_state).active?
+    other_states.each do |state|
+      assert !state_machine.is(state).active?
+      assert state_machine.is_not(state).active?
+    end
+  end
+  
+  def test_should_describe_itself_as_name_and_current_state
+    state_machine = StateMachine.new('state_machine_name')
+    assert_equal 'state_machine_name has no current state', state_machine.mocha_inspect
+    inspectable_state = Class.new { define_method(:mocha_inspect) { "'inspectable_state'" } }.new
+    state_machine.is(inspectable_state).activate
+    assert_equal "state_machine_name is 'inspectable_state'", state_machine.mocha_inspect
+  end
+  
+  def test_should_have_self_describing_states
+    state_machine = StateMachine.new('state_machine_name')
+    inspectable_state = Class.new { define_method(:mocha_inspect) { "'inspectable_state'" } }.new
+    assert_equal "state_machine_name is 'inspectable_state'", state_machine.is(inspectable_state).mocha_inspect
+    assert_equal "state_machine_name is not 'inspectable_state'", state_machine.is_not(inspectable_state).mocha_inspect
+  end
+  
+  def any_state
+    %w(A B C D)
+  end
+  
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/unit/string_inspect_test.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/inspect'
+
+class StringInspectTest < Test::Unit::TestCase
+  
+  def test_should_replace_escaped_quotes_with_single_quote
+    string = "my_string"
+    assert_equal "'my_string'", string.mocha_inspect
+  end
+  
+end

data/test/rails_root/vendor/gems/mocha-0.9.4/test/unit/yield_parameters_test.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/yield_parameters'
+require 'mocha/no_yields'
+require 'mocha/single_yield'
+require 'mocha/multiple_yields'
+
+class YieldParametersTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_return_null_yield_parameter_group_by_default
+    yield_parameters = YieldParameters.new
+    assert yield_parameters.next_invocation.is_a?(NoYields)
+  end
+  
+  def test_should_return_single_yield_parameter_group
+    yield_parameters = YieldParameters.new
+    yield_parameters.add(1, 2, 3)
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [1, 2, 3], parameter_group.parameters
+  end
+  
+  def test_should_keep_returning_single_yield_parameter_group
+    yield_parameters = YieldParameters.new
+    yield_parameters.add(1, 2, 3)
+    yield_parameters.next_invocation
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [1, 2, 3], parameter_group.parameters
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [1, 2, 3], parameter_group.parameters
+  end
+  
+  def test_should_return_consecutive_single_yield_parameter_groups
+    yield_parameters = YieldParameters.new
+    yield_parameters.add(1, 2, 3)
+    yield_parameters.add(4, 5)
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [1, 2, 3], parameter_group.parameters
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [4, 5], parameter_group.parameters
+  end
+  
+  def test_should_return_multiple_yield_parameter_group
+    yield_parameters = YieldParameters.new
+    yield_parameters.multiple_add([1, 2, 3], [4, 5])
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
+  end
+  
+  def test_should_keep_returning_multiple_yield_parameter_group
+    yield_parameters = YieldParameters.new
+    yield_parameters.multiple_add([1, 2, 3], [4, 5])
+    yield_parameters.next_invocation
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
+  end
+  
+  def test_should_return_consecutive_multiple_yield_parameter_groups
+    yield_parameters = YieldParameters.new
+    yield_parameters.multiple_add([1, 2, 3], [4, 5])
+    yield_parameters.multiple_add([6, 7], [8, 9, 0])
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[6, 7], [8, 9, 0]], parameter_group.parameter_groups
+  end
+  
+  def test_should_return_consecutive_single_and_multiple_yield_parameter_groups
+    yield_parameters = YieldParameters.new
+    yield_parameters.add(1, 2, 3)
+    yield_parameters.multiple_add([4, 5, 6], [7, 8])
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [1, 2, 3], parameter_group.parameters
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[4, 5, 6], [7, 8]], parameter_group.parameter_groups
+  end
+  
+end

data/test/rails_root/vendor/gems/quietbacktrace-0.1.1/History.txt

@@ -0,0 +1,50 @@
+== 0.1.1 / 2007-12-04
+
+* Added Seth Fitzsimmons' fix for view backtraces, which are a special case.
+* View backtraces are an array with a single element, not an array of all lines.
+
+== 0.1.0 / 2007-12-03
+
+* Protected the ActiveSupport snippets with unless defined?(ActiveSupport).
+* That way, alias_method_chain, etc. won't be overridden in Rails apps.
+
+== 0.0.9 / 2007-12-03
+
+* Fixed file path bugs with File.expand_path
+
+== 0.0.8 / 2007-12-03
+
+* Attempt to fix ERROR:  While executing gem ... (OpenURI::HTTPError)
+
+== 0.0.7 / 2007-12-03
+
+* Updated the README and RDocs to reflect API changes.
+
+== 0.0.6 / 2007-12-03
+
+* Reworked the API again.
+* Step one - create new silencers/filters.
+* Step two - add them to the backtrace_silencers and backtrace_filters Arrays.
+
+== 0.0.5 / 2007-12-03
+
+* Improved the API with James Golick's code
+* Dan Croak renamed the methods silences_backtrace and filters_backtrace
+
+== 0.0.4 / 2007-12-03
+
+* Added an init file so it can be added to Rails with gemsonrails
+
+== 0.0.3 / 2007-12-03
+
+* Trying to get RDoc with Allison template showing on home page
+
+== 0.0.2 / 2007-12-03
+
+* Cleaned up README
+
+== 0.0.1 / 2007-12-03
+
+* Dan Croak and James Golick announce Quiet Backtrace. Features include:
+  * hooks into quiet_backtrace to add and remove silencers and filters
+  * ability to turn quiet_backtrace on and off at any level in your test suite

data/test/rails_root/vendor/gems/quietbacktrace-0.1.1/Manifest.txt

@@ -0,0 +1,9 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+init.rb
+lib/aliasing.rb
+lib/attribute_accessors.rb
+lib/quietbacktrace.rb
+test/quiet_backtrace_test.rb

data/test/rails_root/vendor/gems/quietbacktrace-0.1.1/README.txt

@@ -0,0 +1,103 @@
+= Quiet Backtrace
+
+Quiet Backtrace suppresses the noise in your Test::Unit backtrace.
+It also provides hooks for you to add additional silencers and filters.
+
+== Install
+
+sudo gem install quietbacktrace
+
+== Usage
+
+Quiet Backtrace works by adding new attributes to Test::Unit::TestCase. 
+By default, their values are: 
+  self.quiet_backtrace = true
+  self.backtrace_silencers = [:test_unit, :gem_root, :e1]
+  self.backtrace_filters = [:method_name]
+
+Silencers remove lines from the backtrace that return true for given conditions.
+Filters modify the output of backtrace lines.
+
+Override the defaults by adding your own backtrace_silencers:
+  class Test::Unit::TestCase
+  	self.new_backtrace_silencer :shoulda do |line| 
+      line.include? 'vendor/plugins/shoulda'
+    end
+    self.backtrace_silencers << :shoulda
+  end
+
+Or your own backtrace_filters:
+  class Test::Unit::TestCase
+    self.new_backtrace_filter :ruby_path do |line|
+       ruby_file_path = '/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8'
+       line.slice!(0..(line =~ ruby_file_path)) if (line =~ ruby_file_path)
+    end
+    self.backtrace_filters << :ruby_path
+  end
+
+Turn Quiet Backtrace off anywhere in your test suite by setting the flag to false:
+  Test::Unit::TestCase.quiet_backtrace = false
+
+== Rails-specific usage
+
+Install gemsonrails, add it your Rails app, then freeze quietbacktrace:
+
+* gem install gemsonrails
+* cd rails-app-folder
+* gemsonrails
+* rake gems:freeze GEM=quietbacktrace
+
+Quiet Backtrace comes with an excellent Rails-specific silencer and filter.
+They must be added (usually in test_helper.rb) because they are not turned on by default:
+  class Test::Unit::TestCase
+    self.backtrace_silencers << :rails_vendor
+    self.backtrace_filters   << :rails_root
+  end
+
+Because Quiet Backtrace works by adding attributes onto Test::Unit::TestCase,
+you can add and remove silencers and filters at any level in your test suite,
+down to the individual test. 
+
+== Resources
+
+* mailing list: http://groups.google.com/group/quiet_backtrace
+* project site: http://rubyforge.org/projects/quietbacktrace
+
+== Authors
+
+* Dan Croak (dcroak@thoughtbot.com, http://dancroak.com) 
+* James Golick (james@giraffesoft.ca, http://jamesgolick.com) 
+* Joe Ferris (jferris@thoughtbot.com)
+
+Special thanks to the Boston.rb group (http://boston.rubygroup.org)
+for cultivating this idea at our inaugural hackfest. 
+
+== Requirements
+
+* Test::Unit 
+* aliasing.rb and attribute_accessors.rb, which are snipped from ActiveSupport and 
+  are included in the gem. They allow quiet_backtrace.rb to use alias_method_chain, 
+  cattr_accessor, and mattr_accessor.
+
+== Copyright
+
+Copyright (c) 2007 Dan Croak, thoughtbot, inc., released under the MIT license
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/test/rails_root/vendor/gems/quietbacktrace-0.1.1/Rakefile

@@ -0,0 +1,21 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/quietbacktrace.rb'
+
+Hoe.new('quietbacktrace', '0.1.1') do |p|
+  p.rubyforge_name = 'quietbacktrace'
+  p.author = 'Dan Croak'
+  p.email = 'dcroak@thoughtbot.com'
+  p.summary = <<-EOF
+    quiet_backtrace suppresses the noise in your Test::Unit backtrace.
+    It also provides hooks for you to add additional filters.
+  EOF
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.remote_rdoc_dir = '' # Release to root
+end
+
+# vim: syntax=Ruby

data/test/rails_root/vendor/gems/quietbacktrace-0.1.1/init.rb

@@ -0,0 +1 @@
+require 'quietbacktrace'

data/test/rails_root/vendor/gems/quietbacktrace-0.1.1/lib/aliasing.rb

@@ -0,0 +1,89 @@
+# :stopdoc:
+#
+# Snipped directly from ActiveSupport from Rails 1.2.3
+# If Quiet Backtrace is run from a Rails app, the actual ActiveSupport
+# methods will be used. That way, alias_method_chain will not be 
+# overridden in your Rails app if Quiet Backtrace is installed.
+#
+# Copyright (c) 2005-2006 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# activesupport/lib/activesupport/core_ext/module/aliasing.rb
+unless defined?(ActiveSupport)
+  class Module  # :nodoc:
+    # Encapsulates the common pattern of:
+    #
+    #   alias_method :foo_without_feature, :foo
+    #   alias_method :foo, :foo_with_feature
+    #
+    # With this, you simply do:
+    #
+    #   alias_method_chain :foo, :feature
+    #
+    # And both aliases are set up for you.
+    #
+    # Query and bang methods (foo?, foo!) keep the same punctuation:
+    #
+    #   alias_method_chain :foo?, :feature
+    #
+    # is equivalent to
+    #
+    #   alias_method :foo_without_feature?, :foo?
+    #   alias_method :foo?, :foo_with_feature?
+    #
+    # so you can safely chain foo, foo?, and foo! with the same feature.
+    def alias_method_chain(target, feature)
+      # Strip out punctuation on predicates or bang methods since
+      # e.g. target?_without_feature is not a valid method name.
+      aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+      yield(aliased_target, punctuation) if block_given?
+      alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target
+      alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
+    end
+
+    # Allows you to make aliases for attributes, which includes 
+    # getter, setter, and query methods.
+    #
+    # Example:
+    #
+    #   class Content < ActiveRecord::Base
+    #     # has a title attribute
+    #   end
+    #
+    #   class Email < ActiveRecord::Base
+    #     alias_attribute :subject, :title
+    #   end
+    #
+    #   e = Email.find(1)
+    #   e.title    # => "Superstars"
+    #   e.subject  # => "Superstars"
+    #   e.subject? # => true
+    #   e.subject = "Megastars"
+    #   e.title    # => "Megastars"
+    def alias_attribute(new_name, old_name)
+      module_eval <<-STR, __FILE__, __LINE__+1
+        def #{new_name}; #{old_name}; end
+        def #{new_name}?; #{old_name}?; end
+        def #{new_name}=(v); self.#{old_name} = v; end
+      STR
+    end
+  end
+end