buildr-gemjar 1.0.0

data/vendor/buildr/spec/scala/doc_spec.rb

@@ -0,0 +1,88 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helpers'))
+
+describe "Scaladoc" do
+
+  before(:each) do
+    # Force Scala 2.8.1 for specs; don't want to rely on SCALA_HOME
+    Buildr.settings.build['scala.version'] = "2.8.1"
+  end
+
+  it 'should pick -doc-title from project name by default' do
+    define 'foo' do
+      compile.using(:scalac)
+
+      define 'bar' do
+        compile.using(:scalac)
+      end
+    end
+
+    project('foo').doc.options[:"doc-title"].should eql('foo')
+    project('foo:bar').doc.options[:"doc-title"].should eql('foo:bar')
+  end
+
+  it 'should pick -doc-title from project description by default, if available' do
+    desc 'My App'
+    define 'foo' do
+      compile.using(:scalac)
+    end
+    project('foo').doc.options[:"doc-title"].should eql('My App')
+  end
+
+  it 'should not override explicit "doc-title" option' do
+    define 'foo' do
+      compile.using(:scalac)
+      doc.using "doc-title" => 'explicit'
+    end
+    project('foo').doc.options[:"doc-title"].should eql('explicit')
+  end
+
+  it 'should convert :windowtitle to -doc-title for Scala 2.8.1' do
+    write 'src/main/scala/com/example/Test.scala', 'package com.example; class Test { val i = 1 }'
+    define('foo') do
+      doc.using :windowtitle => "foo"
+    end
+    Java.scala.tools.nsc.ScalaDoc.should_receive(:process) do |args|
+      # Convert Java Strings to Ruby Strings, if needed.
+      args.map { |a| a.is_a?(String) ? a : a.toString }.should include("-doc-title")
+      0 # normal return
+    end
+    project('foo').doc.invoke
+  end
+end
+
+describe "package(:scaladoc)" do
+  it "should generate target/project-version-scaladoc.jar" do
+    write 'src/main/scala/Foo.scala', 'class Foo'
+    define 'foo', :version=>'1.0' do
+      package(:scaladoc)
+    end
+
+    scaladoc = project('foo').package(:scaladoc)
+    scaladoc.should point_to_path('target/foo-1.0-scaladoc.jar')
+
+    lambda {
+      project('foo').task('package').invoke
+    }.should change { File.exist?('target/foo-1.0-scaladoc.jar') }.to(true)
+
+    scaladoc.should exist
+    scaladoc.should contain('index.html')
+    scaladoc.should contain('Foo.html')
+  end
+end
+

data/vendor/buildr/spec/scala/scala.rb

@@ -0,0 +1,38 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helpers'))
+
+describe 'scala' do
+  # Specific version of Scala required for specs
+  required_version = '2.8.1'
+  scala_version_str = "2.8.1.final"
+
+  it 'should automatically add the remote scala-tools.org repository' do
+    # NOTE: the sandbox environment clears "repositories.remote" so we can't
+    #       test for this spec right now.
+    #
+    # repositories.remote.should include('http://scala-tools.org/repo-releases')
+  end
+
+  it "specifications require Scala #{required_version}" do
+    Scala.version.should eql(required_version)
+  end
+
+  it "should provide the Scala version string" do
+    Scala.version_str.should eql(scala_version_str)
+  end
+end

data/vendor/buildr/spec/scala/tests_spec.rb

@@ -0,0 +1,283 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helpers'))
+
+# TODO's
+#  -test passing System props
+#  -test passing ENV variables
+#  -test exclude group
+#  -test include Suite's
+#  -test exclude Suite's
+
+
+describe Buildr::Scala::ScalaTest do
+  
+  before(:each) do
+    # Force Scala 2.8.1 for specs; don't want to rely on SCALA_HOME
+    Buildr.settings.build['scala.version'] = "2.8.1"
+  end
+    
+  it 'should be the default test framework when test cases are in Scala' do
+    write 'src/test/scala/com/example/MySuite.scala', <<-SCALA
+      package com.example
+      import org.scalatest.FunSuite
+      class MySuite extends FunSuite {
+        test("addition") {
+          val sum = 1 + 1
+          assert(sum === 2)
+        }
+      }
+    SCALA
+    define 'foo'
+    project('foo').test.framework.should eql(:scalatest)
+  end
+
+  it 'should include Scalatest dependencies' do
+    define('foo') { test.using(:scalatest) }
+    project('foo').test.compile.dependencies.should include(*artifacts(Scala::ScalaTest.dependencies))
+    project('foo').test.dependencies.should include(*artifacts(Scala::ScalaTest.dependencies))
+  end
+
+  it 'should include JMock dependencies' do
+    define('foo') { test.using(:scalatest) }
+    project('foo').test.compile.dependencies.should include(*artifacts(JMock.dependencies))
+    project('foo').test.dependencies.should include(*artifacts(JMock.dependencies))
+  end
+
+  it 'should include ScalaCheck dependencies' do
+    define('foo') { test.using(:scalatest) }
+    project('foo').test.compile.dependencies.should include(*artifacts(Scala::Check.dependencies))
+    project('foo').test.dependencies.should include(*artifacts(Scala::Check.dependencies))
+  end
+
+  it 'should set current directory' do
+    mkpath 'baz'
+    expected = File.expand_path('baz')
+    expected.gsub!('/', '\\') if expected =~ /^[A-Z]:/ # Java returns back slashed paths for windows
+    write 'baz/src/test/scala/CurrentDirectoryTestSuite.scala', <<-SCALA
+      class CurrentDirectoryTestSuite extends org.scalatest.FunSuite {
+        test("testCurrentDirectory") {
+          assert("value" === System.getenv("NAME"))
+          assert(#{expected.inspect} === new java.io.File(".").getCanonicalPath())
+        }
+      }
+    SCALA
+    define 'bar' do
+      define 'baz' do
+        test.include 'CurrentDirectoryTest'
+      end
+    end
+    project('bar:baz').test.invoke
+  end
+
+  it 'should include public classes extending org.scalatest.FunSuite' do
+    write 'src/test/scala/com/example/MySuite.scala', <<-SCALA
+      package com.example
+      import org.scalatest.FunSuite
+      class MySuite extends FunSuite {
+        test("addition") {
+          val sum = 1 + 1
+          assert(sum === 2)
+        }
+      }
+    SCALA
+    define('foo').test.invoke
+    project('foo').test.tests.should include('com.example.MySuite')
+  end
+
+  it 'should ignore classes not extending org.scalatest.FunSuite' do
+    write 'src/test/scala/com/example/NotASuite.scala', <<-SCALA
+      package com.example
+      class Another {
+      }
+    SCALA
+    define('foo').test.invoke
+    project('foo').test.tests.should be_empty
+  end
+
+  it 'should ignore inner classes' do
+    write 'src/test/scala/com/example/InnerClassTest.scala', <<-SCALA
+      package com.example
+      import org.scalatest.FunSuite
+      class InnerClassTest extends FunSuite {
+        test("addition") {
+          val sum = 1 + 1
+          assert(sum === 2)
+        }
+
+        class InnerSuite extends FunSuite {
+          test("addition") {
+            val sum = 1 + 1
+            assert(sum === 2)
+          }
+        }
+      }
+    SCALA
+    define('foo').test.invoke
+    project('foo').test.tests.should eql(['com.example.InnerClassTest'])
+  end
+
+  it 'should pass when ScalaTest test case passes' do
+    write 'src/test/scala/PassingSuite.scala', <<-SCALA
+      class PassingSuite extends org.scalatest.FunSuite {
+        test("addition") {
+          val sum = 1 + 1
+          assert(sum === 2)
+        }
+      }
+    SCALA
+    lambda { define('foo').test.invoke }.should_not raise_error
+  end
+
+  it 'should fail when ScalaTest test case fails' do
+    write 'src/test/scala/FailingSuite.scala', <<-SCALA
+      class FailingSuite extends org.scalatest.FunSuite {
+        test("failing") {
+          assert(false)
+        }
+      }
+    SCALA
+    lambda { define('foo').test.invoke }.should raise_error(RuntimeError, /Tests failed/) rescue nil
+  end
+
+  it 'should report failed test names' do
+    write 'src/test/scala/FailingSuite.scala', <<-SCALA
+      class FailingSuite extends org.scalatest.FunSuite {
+        test("failing") {
+          assert(false)
+        }
+      }
+    SCALA
+    define('foo').test.invoke rescue
+    project('foo').test.failed_tests.should include('FailingSuite')
+  end
+
+  it 'should report to reports/scalatest/TEST-TestSuiteName.xml' do
+    write 'src/test/scala/PassingSuite.scala', <<-SCALA
+      class PassingSuite extends org.scalatest.FunSuite {
+        test("passing") {
+          assert(true)
+        }
+      }
+    SCALA
+    define 'foo' do
+      test.report_to.should be(file('reports/scalatest'))
+    end
+    project('foo').test.invoke
+    project('foo').file('reports/scalatest/TEST-PassingSuite.xml').should exist
+  end
+
+  it 'should report to reports/scalatest/TEST-TestSuiteName.txt' do
+    write 'src/test/scala/PassingSuite.scala', <<-SCALA
+      class PassingSuite extends org.scalatest.FunSuite {
+        test("passing") {
+          assert(true)
+        }
+      }
+    SCALA
+    define 'foo' do
+      test.report_to.should be(file('reports/scalatest'))
+    end
+    project('foo').test.invoke
+    project('foo').file('reports/scalatest/TEST-PassingSuite.txt').should exist
+  end
+
+  it 'should pass properties to Suite' do
+    write 'src/test/scala/PropertyTestSuite.scala', <<-SCALA
+      import org.scalatest._
+      class PropertyTestSuite extends FunSuite {
+        var configMap = Map[String, Any]()
+        test("testProperty") {
+          assert(configMap("name") === "value")
+        }
+
+        protected override def runTests(testName: Option[String], reporter: Reporter, stopper: Stopper,
+                                        filter: Filter, configMap: Map[String, Any],
+                                        distributor: Option[Distributor], tracker: Tracker) {
+          this.configMap = configMap
+          super.runTests(testName, reporter, stopper, filter, configMap, distributor, tracker)
+        }
+      }
+    SCALA
+    define('foo').test.using :properties=>{ 'name'=>'value' }
+    project('foo').test.invoke
+  end
+
+  it 'should run with ScalaCheck automatic test case generation' do
+    write 'src/test/scala/MySuite.scala', <<-SCALA
+      import org.scalatest.FunSuite
+      import org.scalatest.prop.Checkers
+      import org.scalacheck.Arbitrary._
+      import org.scalacheck.Prop._
+
+      class MySuite extends FunSuite with Checkers {
+
+        test("list concatenation") {
+          val x = List(1, 2, 3)
+          val y = List(4, 5, 6)
+          assert(x ::: y === List(1, 2, 3, 4, 5, 6))
+          check((a: List[Int], b: List[Int]) => a.size + b.size == (a ::: b).size)
+        }
+
+        test("list concatenation using a test method") {
+          check((a: List[Int], b: List[Int]) => a.size + b.size == (a ::: b).size)
+        }
+      }
+    SCALA
+    define('foo')
+    project('foo').test.invoke
+    project('foo').test.passed_tests.should include('MySuite')
+  end
+
+  it 'should fail if ScalaCheck test case fails' do
+    write 'src/test/scala/StringSuite.scala', <<-SCALA
+      import org.scalatest.FunSuite
+      import org.scalatest.prop.Checkers
+      import org.scalacheck.Arbitrary._
+      import org.scalacheck.Prop._
+
+      class StringSuite extends FunSuite with Checkers {
+        test("startsWith") {
+          check( (a: String, b: String) => (a+b).startsWith(a) )
+        }
+
+        test("endsWith") {
+          check( (a: String, b: String) => (a+b).endsWith(b) )
+        }
+
+        // Is this really always true?
+        test("concat") {
+          check( (a: String, b: String) => (a+b).length > a.length && (a+b).length > b.length )
+        }
+
+        test("substring2") {
+          check( (a: String, b: String) => (a+b).substring(a.length) == b )
+        }
+
+        test("substring3") {
+          check( (a: String, b: String, c: String) =>
+                   (a+b+c).substring(a.length, a.length+b.length) == b )
+        }
+      }
+    SCALA
+    define('foo')
+    project('foo').test.invoke rescue
+    project('foo').test.failed_tests.should include('StringSuite')
+  end
+
+end
+

data/vendor/buildr/spec/spec_helpers.rb

@@ -0,0 +1,369 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+# This file gets loaded twice when running 'spec spec/*' and not with pleasent results,
+# so ignore the second attempt to load it.
+unless defined?(SpecHelpers)
+
+  require 'rubygems'
+
+  # For testing we use the gem requirements specified on the buildr.gemspec
+  spec = Gem::Specification.load(File.expand_path('../buildr.gemspec', File.dirname(__FILE__)))
+  # Dependency.version_requirements deprecated in rubygems 1.3.6
+  spec.dependencies.select {|dep| dep.type == :runtime }.each { |dep| gem dep.name, (dep.respond_to?(:requirement) ? dep.requirement.to_s : dep.version_requirements.to_s) }
+
+  # Make sure to load from these paths first, we don't want to load any
+  # code from Gem library.
+  $LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__)),
+                     File.expand_path('../addon', File.dirname(__FILE__))
+
+  # Buildr uses autoload extensively, but autoload when running specs creates
+  # a problem -- we sandbox $LOADED_FEATURES, so we endup autoloading the same
+  # module twice. This turns autoload into a require, which is not the right
+  # thing, but will do for now.
+  def autoload(symbol, path)
+    require path
+  end
+  require 'buildr'
+  # load ecj
+  require 'buildr/java/ecj'
+  #Make ecj appear as a compiler that doesn't apply:
+  class Buildr::Compiler::Ecj
+    class << self
+      def applies_to?(project, task)
+        false
+      end
+    end
+  end
+
+  # Give a chance for plugins to do a few things before requiring the sandbox.
+  include SandboxHook if defined?(SandboxHook)
+
+  require File.expand_path('sandbox', File.dirname(__FILE__))
+
+  module SpecHelpers
+
+    include Checks::Matchers
+
+    [:info, :warn, :error, :puts].each do |severity|
+      ::Object.class_eval do
+        define_method severity do |*args|
+          $messages ||= {}
+          $messages[severity] ||= []
+          $messages[severity].push(*args)
+        end
+      end
+    end
+
+    class << Buildr.application
+      alias :deprecated_without_capture :deprecated
+      def deprecated(message)
+        verbose(true) { deprecated_without_capture message }
+      end
+    end
+
+    class MessageWithSeverityMatcher
+      def initialize(severity, message)
+        @severity = severity
+        @expect = message
+      end
+
+      def matches?(target)
+        $messages = {@severity => []}
+        target.call
+        return Regexp === @expect ? $messages[@severity].join('\n') =~ @expect : $messages[@severity].include?(@expect.to_s)
+      end
+
+      def failure_message
+        "Expected #{@severity} #{@expect.inspect}, " +
+          ($messages[@severity].empty? ? "no #{@severity} issued" : "found #{$messages[@severity].inspect}")
+      end
+
+      def negative_failure_message
+        "Found unexpected #{$messages[@severity].inspect}"
+      end
+    end
+
+    # Test if an info message was shown.  You can use a string or regular expression.
+    #
+    # For example:
+    #   lambda { info 'ze test' }.should show_info(/ze test/)
+    def show_info(message)
+      MessageWithSeverityMatcher.new :info, message
+    end
+
+    # Test if a warning was shown. You can use a string or regular expression.
+    #
+    # For example:
+    #   lambda { warn 'ze test' }.should show_warning(/ze test/)
+    def show_warning(message)
+      MessageWithSeverityMatcher.new :warn, message
+    end
+
+    # Test if an error message was shown.  You can use a string or regular expression.
+    #
+    # For example:
+    #   lambda { error 'ze test' }.should show_error(/ze test/)
+    def show_error(message)
+      MessageWithSeverityMatcher.new :error, message
+    end
+
+    # Test if any message was shown (puts).  You can use a string or regular expression.
+    #
+    # For example:
+    #   lambda { puts 'ze test' }.should show(/ze test/)
+    def show(message)
+      MessageWithSeverityMatcher.new :puts, message
+    end
+
+    # Yields a block that should try exiting the application.
+    # Accepts
+    #
+    # For example:
+    #   test_exit(1) {  puts "Hello" ; exit(1) }.should show("Hello")
+    #
+    def test_exit(status = nil)
+      return lambda {
+        begin
+          yield
+          raise "Exit was not called!"
+        rescue SystemExit => e
+          raise "Exit status incorrect! Expected: #{status}, got #{e.status}" if status && (e.status != status)
+        end
+      }
+    end
+
+    class ::Rake::Task
+      alias :execute_without_a_record :execute
+      def execute(args)
+        $executed ||= []
+        $executed << name
+        execute_without_a_record args
+      end
+    end
+
+    class InvokeMatcher
+      def initialize(*tasks)
+        @expecting = tasks.map { |task| [task].flatten.map(&:to_s) }
+      end
+
+      def matches?(target)
+        $executed = []
+        target.call
+        return false unless all_ran?
+        return !@but_not.any_ran? if @but_not
+        return true
+      end
+
+      def failure_message
+        return @but_not.negative_failure_message if all_ran? && @but_not
+        "Expected the tasks #{expected} to run, but #{remaining} did not run, or not in the order we expected them to." +
+          "  Tasks that ran: #{$executed.inspect}"
+      end
+
+      def negative_failure_message
+        if all_ran?
+          "Expected the tasks #{expected} to not run, but they all ran."
+        else
+          "Expected the tasks #{expected} to not run, and all but #{remaining} ran."
+        end
+      end
+
+      def but_not(*tasks)
+        @but_not = InvokeMatcher.new(*tasks)
+        self
+      end
+
+    protected
+
+      def expected
+        @expecting.map { |tests| tests.join('=>') }.join(', ')
+      end
+
+      def remaining
+        @remaining.map { |tests| tests.join('=>') }.join(', ')
+      end
+
+      def all_ran?
+        @remaining ||= $executed.inject(@expecting) do |expecting, executed|
+          expecting.map { |tasks| tasks.first == executed ? tasks[1..-1] : tasks }.reject(&:empty?)
+        end
+        @remaining.empty?
+      end
+
+      def any_ran?
+        all_ran?
+        @remaining.size < @expecting.size
+      end
+
+    end
+
+    # Tests that all the tasks ran, in the order specified. Can also be used to test that some
+    # tasks and not others ran.
+    #
+    # Takes a list of arguments. Each argument can be a task name, matching only if that task ran.
+    # Each argument can be an array of task names, matching only if all these tasks ran in that order.
+    # So run_tasks('foo', 'bar') expects foo and bar to run in any order, but run_task(['foo', 'bar'])
+    # expects foo to run before bar.
+    #
+    # You can call but_not on the matchers to specify that certain tasks must not execute.
+    #
+    # For example:
+    #   # Either task
+    #   lambda { task('compile').invoke }.should run_tasks('compile', 'resources')
+    #   # In that order
+    #   lambda { task('build').invoke }.should run_tasks(['compile', 'test'])
+    #   # With exclusion
+    #   lambda { task('build').invoke }.should run_tasks('compile').but_not('install')
+    def run_tasks(*tasks)
+      InvokeMatcher.new *tasks
+    end
+
+    # Tests that a task ran. Similar to run_tasks, but accepts a single task name.
+    #
+    # For example:
+    #   lambda { task('build').invoke }.should run_task('test')
+    def run_task(task)
+      InvokeMatcher.new [task]
+    end
+
+    class UriPathMatcher
+      def initialize(re)
+        @expression = re
+      end
+
+      def matches?(uri)
+        @uri = uri
+        uri.path =~ @expression
+      end
+
+      def description
+        "URI with path matching #{@expression}"
+      end
+    end
+
+    # Matches a parsed URI's path against the given regular expression
+    def uri(re)
+      UriPathMatcher.new(re)
+    end
+
+
+    class AbsolutePathMatcher
+      def initialize(path)
+        @expected = File.expand_path(path.to_s)
+      end
+
+      def matches?(path)
+        @provided = File.expand_path(path.to_s)
+        @provided == @expected
+      end
+
+      def failure_message
+        "Expected path #{@expected}, but found path #{@provided}"
+      end
+
+      def negative_failure_message
+        "Expected a path other than #{@expected}"
+      end
+    end
+
+    def point_to_path(path)
+      AbsolutePathMatcher.new(path)
+    end
+
+
+    # Value covered by range. For example:
+    #   (1..5).should cover(3)
+    RSpec::Matchers.define :cover do |actual|
+      match do |range|
+        actual >= range.min && actual <= range.max
+      end
+    end
+
+
+    def suppress_stdout
+      stdout = $stdout
+      $stdout = StringIO.new
+      begin
+        yield
+      ensure
+        $stdout = stdout
+      end
+    end
+
+    def dryrun
+      Buildr.application.options.dryrun = true
+      begin
+        suppress_stdout { yield }
+      ensure
+        Buildr.application.options.dryrun = false
+      end
+    end
+
+    # We run tests with tracing off. Then things break. And we need to figure out what went wrong.
+    # So just use trace() as you would use verbose() to find and squash the bug.
+    def trace(value = nil)
+      old_value = Buildr.application.options.trace
+      Buildr.application.options.trace = value unless value.nil?
+      if block_given?
+        begin
+          yield
+        ensure
+          Buildr.application.options.trace = old_value
+        end
+      end
+      Buildr.application.options.trace
+    end
+
+    # Change the Buildr original directory, faking invocation from a different directory.
+    def in_original_dir(dir)
+      begin
+        original_dir = Buildr.application.original_dir
+        Buildr.application.instance_eval { @original_dir = File.expand_path(dir) }
+        yield
+      ensure
+        Buildr.application.instance_eval { @original_dir = original_dir }
+      end
+    end
+
+
+    # Buildr's define method creates a project definition but does not evaluate it
+    # (that happens once the buildfile is loaded), and we include Buildr's define in
+    # the test context so we can use it without prefixing with Buildr. This just patches
+    # define to evaluate the project definition before returning it.
+    def define(name, properties = nil, &block) #:yields:project
+      Project.define(name, properties, &block).tap { |project| project.invoke }
+    end
+
+  end
+
+
+  # Allow using matchers within the project definition.
+  class Buildr::Project
+    include ::RSpec::Matchers, SpecHelpers
+  end
+
+
+  ::RSpec.configure do |config|
+    # Make all Buildr methods accessible from test cases, and add various helper methods.
+    config.include Buildr
+    config.include SpecHelpers
+
+    # Sanbdox Buildr for each test.
+    config.include Sandbox
+  end
+
+end