buildr 1.3.1.1-java → 1.3.2-java

data/rakelib/apache.rake

@@ -21,6 +21,20 @@ require 'sha1'
 # Tasks specific to Apache projects (license, release, etc).
 namespace 'apache' do
 
+  desc 'Upload snapshot packages over to people.apache.org'
+  task 'snapshot'=>'package' do
+    rm_rf 'snapshot' # Always start with empty directory
+    puts "Copying existing gems from Apache"
+    sh 'rsync', '--progress', '--recursive', 'people.apache.org:public_html/buildr/snapshot', './'
+    puts "Copying new gems over"
+    cp FileList['pkg/{*.gem,*.tgz,*.zip}'], 'snapshot/gems'
+    puts "Generating gem index ..."
+    sh 'gem', 'generate_index', '--directory', 'snapshot'
+    puts "Copying gem and index back to Apache" 
+    sh 'rsync', '--progress', '--recursive', 'snapshot', 'people.apache.org:public_html/buildr/'
+  end
+
+
   desc 'Check that source files contain the Apache license'
   task 'license' do |task|
     print 'Checking that files contain the Apache license ... '

data/rakelib/package.rake

@@ -42,3 +42,31 @@ task 'uninstall' do |task|
   sh *args
   puts 'Done'
 end
+
+
+desc 'Look for new dependencies, check transitive dependencies'
+task 'dependency' do
+  # Find if anything has a more recent dependency.  These are not errors, just reports.
+  for dep in spec.dependencies
+    current = Gem::SourceInfoCache.search(dep, true, true).last
+    latest = Gem::SourceInfoCache.search(Gem::Dependency.new(dep.name, '>0'), true, true).last
+    puts "A new version of #{dep.name} is available, #{latest.version} replaces #{current.version}" if latest.version > current.version
+  end
+
+  # Returns orderd list of transitive dependencies for the given dependency.
+  transitive = lambda { |depend|
+    dep_spec = Gem::SourceIndex.from_installed_gems.search(depend).last
+    dep_spec.dependencies.map { |trans| transitive[trans].push(trans) }.flatten.uniq }
+  # For each dependency, make sure *all* its transitive dependencies are listed
+  # as a Buildr dependency, and order is preserved.
+  spec.dependencies.each_with_index do |dep, index|
+    puts "checking #{dep.name}"
+    for trans in transitive[dep]
+      matching = spec.dependencies.find { |existing| trans =~ existing }
+      fail "#{trans} required by #{dep} and missing from spec" unless matching
+      fail "#{trans} must come before #{dep} in dependency list" unless spec.dependencies.index(matching) < index
+    end
+  end
+end
+
+task 'stage:check'=>'dependency'

data/rakelib/setup.rake

@@ -36,15 +36,16 @@ def which(name)
 end
 
 
-def install_gem(name, ver_requirement = nil)
+def install_gem(name, ver_requirement = ['> 0'])
   dep = Gem::Dependency.new(name, ver_requirement)
   rb_bin = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
   if Gem::SourceIndex.from_installed_gems.search(dep).empty?
     spec = Gem::SourceInfoCache.search(dep, true, true).last
     fail "#{dep} not found in local or remote repository!" unless spec
-    puts "Installing #{spec} ..."
+    puts "Installing #{spec.full_name} ..."
     args = [rb_bin, '-S', 'gem', 'install', spec.name, '-v', spec.version.to_s]
     args.unshift('sudo', 'env', 'JAVA_HOME=' + ENV['JAVA_HOME']) unless windows?
+    args = args.map{|a| a.inspect}.join(' ') if windows?
     sh *args
   end
 end

data/spec/compile_spec.rb

@@ -23,19 +23,18 @@ module CompilerHelper
   end
 
   def sources
-    @sources ||= ['Test1.java', 'Test2.java'].map { |f| File.join('src/java', f) }.
+    @sources ||= ['Test1.java', 'Test2.java'].map { |f| File.join('src/main/java', f) }.
       each { |src| write src, "class #{src.pathmap('%n')} {}" }
   end
 
   def jars
     @jars ||= begin
-      write 'src/main/java/Dependency.java', 'class Dependency { }'
-      define 'jars', :version=>'1.0' do
-        compile.into('dependency')
+      write 'jars/src/main/java/Dependency.java', 'class Dependency { }'
+      define 'jars', :version=>'1.0', :base_dir => 'jars' do
         package(:jar, :id=>'jar1')
         package(:jar, :id=>'jar2')
       end
-      project('jars').packages.each(&:invoke).map(&:to_s)
+      project('jars').packages.map(&:to_s)
     end
   end
 end
@@ -188,7 +187,7 @@ describe Buildr::CompileTask, '#dependencies' do
   end
 
   it 'should allow artifacts' do
-    artifact('group:id:jar:1.0') { |task| mkpath File.dirname(task.to_s) ; cp jars.first.to_s, task.to_s }
+    artifact('group:id:jar:1.0') { |task| mkpath File.dirname(task.to_s) ; cp jars.first.to_s, task.to_s }.enhance jars
     compile_task.from(sources).with('group:id:jar:1.0').into('classes').invoke
   end
 
@@ -325,6 +324,7 @@ describe Buildr::CompileTask, '#invoke' do
   end
 
   it 'should force compilation if dependencies newer than compiled' do
+    jars; project('jars').task("package").invoke
     # On my machine the times end up the same, so need to push dependencies in the past.
     time = Time.now
     sources.map { |src| src.pathmap("#{compile_task.target}/%n.class") }.
@@ -334,10 +334,11 @@ describe Buildr::CompileTask, '#invoke' do
   end
 
   it 'should not force compilation if dependencies older than compiled' do
+    jars; project('jars').task("package").invoke
     time = Time.now
-    sources.map { |src| src.pathmap("#{compile_task.target}/%n.class") }.
+    jars.each { |jar| File.utime(time - 1 , time - 1, jar) }
+    sources.map { |src| File.utime(time, time, src); src.pathmap("#{compile_task.target}/%n.class") }.
       each { |kls| write kls ; File.utime(time, time, kls) }
-    jars.each { |jar| File.utime(time - 1, time - 1, jar) }
     lambda { compile_task.from(sources).with(jars).invoke }.should_not run_task('foo:compile')
   end
 

data/spec/java_test_frameworks_spec.rb

@@ -121,6 +121,25 @@ describe Buildr::JUnit do
     project('foo').test.tests.should eql(['InnerClassTest'])
   end
 
+  it 'should ignore abstract classes' do
+    write 'src/test/java/AbstractClassTest.java', <<-JAVA
+      public abstract class AbstractClassTest extends junit.framework.TestCase {
+        public void testNothing() { }
+      }
+    JAVA
+    define('foo').test.invoke
+    project('foo').test.tests.should be_empty
+  end
+
+  it 'should ignore classes with no tests in them' do
+    write 'src/test/java/NoTests.java', <<-JAVA
+      public class NoTests {
+      }
+    JAVA
+    define('foo').test.invoke
+    project('foo').test.tests.should be_empty
+  end
+
   it 'should pass when JUnit test case passes' do
     write 'src/test/java/PassingTest.java', <<-JAVA
       public class PassingTest extends junit.framework.TestCase {

data/spec/project_spec.rb

@@ -194,6 +194,18 @@ describe Layout do
     @layout[:foo, :bar] = 'none'
     @layout.expand(:foo, :bar).should eql('none')
   end
+
+  it 'should map strings to path' do
+    @layout[:foo, "bar"] = 'none'
+    @layout.expand(:foo, :bar).should eql('none')
+    @layout.expand(:foo, 'bar').should eql('none')
+  end
+
+  it 'should ignore nil elements' do
+    @layout[:foo, :bar] = 'none'
+    @layout.expand(:foo, nil, :bar).should eql('none')
+    @layout.expand(nil, :foo).should eql('foo')
+  end
   
   it 'should return nil if path not mapped' do
     @layout[:foo].should be_nil

data/spec/sandbox.rb

@@ -19,8 +19,12 @@
 # repository and cache these across test cases.
 Buildr.application.instance_eval { @rakefile = File.expand_path('buildfile') }
 repositories.remote << 'http://repo1.maven.org/maven2'
+repositories.remote << 'http://scala-tools.org/repo-releases'
+
 require 'buildr/java/groovyc'
 Java.load # Anything added to the classpath.
+task('buildr:scala:download').invoke
+Buildr::ScalaTest::ENABLED = true
 artifacts(TestFramework.frameworks.map(&:dependencies).flatten).each { |a| file(a).invoke }
 
 ENV['HOME'] = File.expand_path('tmp/home')

data/spec/scala_compilers_spec.rb

@@ -177,21 +177,11 @@ describe 'scalac compiler options' do
     scalac_args.should_not include('-optimise')
   end
 
-  it 'should not set source option by default' do
-    compile_task.options.source.should be_nil
-    scalac_args.should_not include('-source')
-  end
-
   it 'should not set target option by default' do
     compile_task.options.target.should be_nil
     scalac_args.should_not include('-target')
   end
 
-  it 'should use -source nn argument if source option set' do
-    compile_task.using(:source=>'1.5')
-    scalac_args.should include('-source', '1.5')
-  end
-
   it 'should use -target:xxx argument if target option set' do
     compile_task.using(:target=>'1.5')
     scalac_args.should include('-target:jvm-1.5')
@@ -219,13 +209,12 @@ describe 'scalac compiler options' do
 
   it 'should inherit options from parent' do
     define 'foo' do
-      compile.using(:warnings=>true, :debug=>true, :deprecation=>true, :source=>'1.5', :target=>'1.4')
+      compile.using(:warnings=>true, :debug=>true, :deprecation=>true, :target=>'1.4')
       define 'bar' do
         compile.using(:scalac)
         compile.options.warnings.should be_true
         compile.options.debug.should be_true
         compile.options.deprecation.should be_true
-        compile.options.source.should eql('1.5')
         compile.options.target.should eql('1.4')
       end
     end

data/spec/scala_test_frameworks_spec.rb

@@ -0,0 +1,216 @@
+# 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.join(File.dirname(__FILE__), 'spec_helpers')
+
+
+# TODO's
+#  -test w/ Specs
+#  -test w/ ScalaCheck
+#  -failing test
+#  -test passing System props
+#  -test passing ENV variables
+#  -test exclude group
+#  -test include Suite's
+#  -test exclude Suite's
+
+
+describe Buildr::ScalaTest do
+  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 be picked if the test language is Scala' do
+    define 'foo' do
+      test.compile.using(:scalac)
+      test.framework.should eql(:scalatest)
+    end
+  end
+
+  it 'should include Scalatest dependencies' do
+    define('foo') { test.using(:scalatest) }
+    project('foo').test.compile.dependencies.should include(*artifacts(ScalaTest::REQUIRES))
+    project('foo').test.dependencies.should include(*artifacts(ScalaTest::REQUIRES))
+  end
+
+  it 'should include JMock dependencies' do
+    define('foo') { test.using(:scalatest) }
+    project('foo').test.compile.dependencies.should include(*artifacts(JMock::REQUIRES))
+    project('foo').test.dependencies.should include(*artifacts(JMock::REQUIRES))
+  end
+
+  it 'should include Specs dependencies' do
+    define('foo') { test.using(:scalatest) }
+    project('foo').test.compile.dependencies.should include(*artifacts(ScalaSpecs::REQUIRES))
+    project('foo').test.dependencies.should include(*artifacts(ScalaSpecs::REQUIRES))
+  end
+
+  it 'should include ScalaCheck dependencies' do
+    define('foo') { test.using(:scalatest) }
+    project('foo').test.compile.dependencies.should include(*artifacts(ScalaCheck::REQUIRES))
+    project('foo').test.dependencies.should include(*artifacts(ScalaCheck::REQUIRES))
+  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.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 properties = Map[String, Any]()
+        test("testProperty") {
+          assert(properties("name") === "value")
+        }
+        
+        protected override def runTests(testName: Option[String], reporter: Reporter, stopper: Stopper,
+                                        includes: Set[String], excludes: Set[String], properties: Map[String, Any]) {
+          this.properties = properties;                              
+          super.runTests(testName, reporter, stopper, includes, excludes, properties)
+        }
+      }
+    SCALA
+    define('foo').test.using :properties=>{ 'name'=>'value' }
+    project('foo').test.invoke
+  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
+
+end
+

data/spec/test_spec.rb

@@ -189,7 +189,7 @@ describe Buildr::TestTask do
   end
 
   it 'should include the main resources target in its dependencies' do
-    write 'src/main/resources/test'
+    write 'src/main/resources/config.xml'
     define('foo').test.dependencies.should include(project('foo').resources.target)
   end
 
@@ -203,11 +203,27 @@ describe Buildr::TestTask do
     project('foo').test.dependencies.should include(project('foo').test.compile.target)
   end
 
+  it 'should add test compile target ahead of regular compile target' do
+    write 'src/main/java/Code.java'
+    write 'src/test/java/Test.java'
+    define 'foo'
+    depends = project('foo').test.dependencies
+    depends.index(project('foo').test.compile.target).should < depends.index(project('foo').compile.target)
+  end
+
   it 'should include the test resources target in its dependencies' do
-    write 'src/test/resources/test'
+    write 'src/test/resources/config.xml'
     define('foo').test.dependencies.should include(project('foo').test.resources.target)
   end
 
+  it 'should add test resource target ahead of regular resource target' do
+    write 'src/main/resources/config.xml'
+    write 'src/test/resources/config.xml'
+    define 'foo'
+    depends = project('foo').test.dependencies
+    depends.index(project('foo').test.resources.target).should < depends.index(project('foo').resources.target)
+  end
+
   it 'should clean after itself (test files)' do
     define('foo') { test.compile.using(:javac) }
     mkpath project('foo').test.compile.target.to_s
@@ -467,9 +483,9 @@ describe Buildr::Project, 'test:resources' do
   end
 
   it 'should copy to the resources target directory' do
-    write 'src/test/resources/foo', 'Foo'
+    write 'src/test/resources/config.xml', '</xml>'
     define('foo', :target=>'targeted').test.invoke
-    file('targeted/test/resources/foo').should contain('Foo')
+    file('targeted/test/resources/config.xml').should contain('</xml>')
   end
 
   it 'should create target directory even if no files to copy' do