buildr 1.3.5 → 1.4.0

data/spec/java/cobertura_spec.rb

@@ -24,54 +24,54 @@ describe Buildr::Cobertura do
     # Reloading the extension because the sandbox removes all its actions
     Buildr.module_eval { remove_const :Cobertura }
     load File.expand_path('../lib/buildr/java/cobertura.rb')
-    @tool_module = Buildr::Cobertura 
+    @tool_module = Buildr::Cobertura
   end
-  
+
   it_should_behave_like 'test coverage tool'
-  
+
   describe 'project-specific' do
-    
+
     describe 'data file' do
       it 'should have a default value' do
         define('foo').cobertura.data_file.should point_to_path('reports/cobertura.ser')
       end
-      
+
       it 'should be overridable' do
         define('foo') { cobertura.data_file = path_to('target/data.cobertura') }
         project('foo').cobertura.data_file.should point_to_path('target/data.cobertura')
       end
-      
+
       it 'should be created during instrumentation' do
         write 'src/main/java/Foo.java', 'public class Foo {}'
         define('foo')
         task('foo:cobertura:instrument').invoke
         file(project('foo').cobertura.data_file).should exist
       end
-      
+
       it 'should not instrument projects which have no sources' do
         write 'bar/src/main/java/Baz.java', 'public class Baz {}'
         define('foo') { define('bar') }
         task('foo:bar:cobertura:instrument').invoke
       end
     end
-      
+
     describe 'instrumentation' do
       before do
         ['Foo', 'Bar'].each { |cls| write File.join('src/main/java', "#{cls}.java"), "public class #{cls} {}" }
       end
-      
+
       it 'should instrument only included classes' do
         define('foo') { cobertura.include 'Foo' }
         task("foo:cobertura:instrument").invoke
         Dir.chdir('target/instrumented/classes') { Dir.glob('*').sort.should == ['Foo.class'] }
       end
-      
+
       it 'should not instrument excluded classes' do
         define('foo') { cobertura.exclude 'Foo' }
         task("foo:cobertura:instrument").invoke
         Dir.chdir('target/instrumented/classes') { Dir.glob('*').sort.should == ['Bar.class'] }
       end
-      
+
       it 'should instrument classes that are included but not excluded' do
         write 'src/main/java/Baz.java', 'public class Baz {}'
         define('foo') { cobertura.include('Ba').exclude('ar') }
@@ -79,7 +79,7 @@ describe Buildr::Cobertura do
         Dir.chdir('target/instrumented/classes') { Dir.glob('*').sort.should == ['Baz.class'] }
       end
     end
-    
+
     # TODO add specs for cobertura:check...somehow
   end
 end

data/spec/java/commands_spec.rb

@@ -0,0 +1,34 @@
+# 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')
+
+
+describe Java::Commands do
+
+  it "should not be verbose by default" do
+    write "build.xml", <<-BUILD
+    <project name="MyProject" default="dist" basedir=".">
+        <description>
+            simple example build file
+        </description>
+        <target name="dist"/>
+    </project>
+BUILD
+    lambda { Java::Commands.java("org.apache.tools.ant.Main", :classpath => Buildr::Ant.dependencies) }.should_not show_info(/java/)
+    lambda { Java::Commands.java("org.apache.tools.ant.Main", :classpath => Buildr::Ant.dependencies, :verbose => true) }.should show_info(/java/)
+  end
+
+end

data/spec/java/compiler_spec.rb

@@ -19,13 +19,13 @@ require File.join(File.dirname(__FILE__), '../spec_helpers')
 
 describe 'javac compiler' do
   it 'should identify itself from source directories' do
-    write 'src/main/java/com/example/Test.java', 'package com.example; class Test {}' 
+    write 'src/main/java/com/example/Test.java', 'package com.example; class Test {}'
     define('foo').compile.compiler.should eql(:javac)
   end
 
   it 'should identify from source directories using custom layout' do
-    write 'src/com/example/Code.java', 'package com.example; class Code {}' 
-    write 'testing/com/example/Test.java', 'package com.example; class Test {}' 
+    write 'src/com/example/Code.java', 'package com.example; class Code {}'
+    write 'testing/com/example/Test.java', 'package com.example; class Test {}'
     custom = Layout.new
     custom[:source, :main, :java] = 'src'
     custom[:source, :test, :java] = 'testing'
@@ -36,8 +36,8 @@ describe 'javac compiler' do
   end
 
   it 'should identify from compile source directories' do
-    write 'src/com/example/Code.java', 'package com.example; class Code {}' 
-    write 'testing/com/example/Test.java', 'package com.example; class Test {}' 
+    write 'src/com/example/Code.java', 'package com.example; class Code {}'
+    write 'testing/com/example/Test.java', 'package com.example; class Test {}'
     define 'foo' do
       lambda { compile.from 'src' }.should change { compile.compiler }.to(:javac)
       lambda { test.compile.from 'testing' }.should change { test.compile.compiler }.to(:javac)
@@ -103,28 +103,28 @@ describe 'javac compiler options' do
     compile_task.options.warnings.should be_false
   end
 
-  it 'should set wranings option to true when running with --verbose option' do
+  it 'should set warnings option to true when running with --verbose option' do
     verbose true
-    compile_task.options.warnings.should be_true
+    compile_task.options.warnings.should be_false
   end
 
   it 'should use -nowarn argument when warnings is false' do
     compile_task.using(:warnings=>false)
-    javac_args.should include('-nowarn') 
+    javac_args.should include('-nowarn')
   end
 
   it 'should not use -nowarn argument when warnings is true' do
     compile_task.using(:warnings=>true)
-    javac_args.should_not include('-nowarn') 
+    javac_args.should_not include('-nowarn')
   end
 
   it 'should not use -verbose argument by default' do
-    javac_args.should_not include('-verbose') 
+    javac_args.should_not include('-verbose')
   end
 
   it 'should use -verbose argument when running with --trace option' do
     trace true
-    javac_args.should include('-verbose') 
+    javac_args.should include('-verbose')
   end
 
   it 'should set debug option to true by default' do
@@ -251,7 +251,7 @@ describe 'javac compiler options' do
 end
 
 
-describe Project, '#javadoc' do
+describe Project, '#doc' do
   def sources
     @sources ||= (1..3).map { |i| "Test#{i}" }.
       each { |name| write "src/main/java/foo/#{name}.java", "package foo; public class #{name}{}" }.
@@ -260,64 +260,64 @@ describe Project, '#javadoc' do
 
   it 'should return the project\'s Javadoc task' do
     define('foo') { compile.using(:javac) }
-    project('foo').javadoc.name.should eql('foo:javadoc')
+    project('foo').doc.name.should eql('foo:doc')
   end
 
-  it 'should return a Javadoc task' do
+  it 'should return a DocTask' do
     define('foo') { compile.using(:javac) }
-    project('foo').javadoc.should be_kind_of(Javadoc::JavadocTask)
+    project('foo').doc.should be_kind_of(Doc::DocTask)
   end
 
-  it 'should set target directory to target/javadoc' do
+  it 'should set target directory to target/doc' do
     define 'foo' do
       compile.using(:javac)
-      javadoc.target.to_s.should point_to_path('target/javadoc')
+      doc.target.to_s.should point_to_path('target/doc')
     end
   end
 
   it 'should create file task for target directory' do
     define 'foo' do
       compile.using(:javac)
-      javadoc.should_receive(:invoke_prerequisites)
+      doc.should_receive(:invoke_prerequisites)
     end
-    project('foo').file('target/javadoc').invoke
+    project('foo').file('target/doc').invoke
   end
 
   it 'should respond to into() and return self' do
     define 'foo' do
       compile.using(:javac)
-      javadoc.into('docs').should be(javadoc)
+      doc.into('docs').should be(doc)
     end
   end
 
   it 'should respond to into() and change target directory' do
     define 'foo' do
       compile.using(:javac)
-      javadoc.into('docs')
-      javadoc.should_receive(:invoke_prerequisites)
+      doc.into('docs')
+      doc.should_receive(:invoke_prerequisites)
     end
     file('docs').invoke
   end
 
   it 'should respond to from() and return self' do
     task = nil
-    define('foo') { task = javadoc.from('srcs') }
-    task.should be(project('foo').javadoc)
+    define('foo') { task = doc.from('srcs') }
+    task.should be(project('foo').doc)
   end
 
   it 'should respond to from() and add sources' do
     define 'foo' do
       compile.using(:javac)
-      javadoc.from('srcs').should be(javadoc)
+      doc.from('srcs').should be(doc)
     end
   end
 
   it 'should respond to from() and add file task' do
     define 'foo' do
       compile.using(:javac)
-      javadoc.from('srcs').should be(javadoc)
+      doc.from('srcs').should be(doc)
     end
-    project('foo').javadoc.source_files.first.should point_to_path('srcs')
+    project('foo').doc.source_files.first.should point_to_path('srcs')
   end
 
   it 'should respond to from() and add project\'s sources and dependencies' do
@@ -325,27 +325,27 @@ describe Project, '#javadoc' do
     define 'foo' do
       compile.using(:javac)
       define('bar') { compile.using(:javac).with 'group:id:jar:1.0' }
-      javadoc.from project('foo:bar')
+      doc.from project('foo:bar')
     end
-    project('foo').javadoc.source_files.first.should point_to_path('bar/src/main/java/Test.java')
-    project('foo').javadoc.classpath.map(&:to_spec).should include('group:id:jar:1.0')
+    project('foo').doc.source_files.first.should point_to_path('bar/src/main/java/Test.java')
+    project('foo').doc.classpath.map(&:to_spec).should include('group:id:jar:1.0')
   end
 
-  it 'should generate javadocs from project' do
+  it 'should generate docs from project' do
     sources
     define('foo') { compile.using(:javac) }
-    project('foo').javadoc.source_files.sort.should == sources.sort.map { |f| File.expand_path(f) }
+    project('foo').doc.source_files.sort.should == sources.sort.map { |f| File.expand_path(f) }
   end
 
   it 'should include compile dependencies' do
     define('foo') { compile.using(:javac).with 'group:id:jar:1.0' }
-    project('foo').javadoc.classpath.map(&:to_spec).should include('group:id:jar:1.0')
+    project('foo').doc.classpath.map(&:to_spec).should include('group:id:jar:1.0')
   end
 
   it 'should respond to include() and return self' do
     define 'foo' do
       compile.using(:javac)
-      javadoc.include('srcs').should be(javadoc)
+      doc.include('srcs').should be(doc)
     end
   end
 
@@ -353,15 +353,15 @@ describe Project, '#javadoc' do
     included = sources.first
     define 'foo' do
       compile.using(:javac)
-      javadoc.include included
+      doc.include included
     end
-    project('foo').javadoc.source_files.should include(included)
+    project('foo').doc.source_files.should include(included)
   end
 
   it 'should respond to exclude() and return self' do
     define 'foo' do
       compile.using(:javac)
-      javadoc.exclude('srcs').should be(javadoc)
+      doc.exclude('srcs').should be(doc)
     end
   end
 
@@ -369,35 +369,35 @@ describe Project, '#javadoc' do
     excluded = sources.first
     define 'foo' do
       compile.using(:javac)
-      javadoc.exclude excluded
+      doc.exclude excluded
     end
     sources
-    project('foo').javadoc.source_files.sort.should == sources[1..-1].map { |f| File.expand_path(f) }
+    project('foo').doc.source_files.sort.should == sources[1..-1].map { |f| File.expand_path(f) }
   end
 
   it 'should respond to using() and return self' do
     define 'foo' do
       compile.using(:javac)
-      javadoc.using(:windowtitle=>'Fooing').should be(javadoc)
+      doc.using(:windowtitle=>'Fooing').should be(doc)
     end
   end
 
   it 'should respond to using() and accept options' do
     define 'foo' do
       compile.using(:javac)
-      javadoc.using :windowtitle=>'Fooing'
+      doc.using :windowtitle=>'Fooing'
     end
-    project('foo').javadoc.options[:windowtitle].should eql('Fooing')
+    project('foo').doc.options[:windowtitle].should eql('Fooing')
   end
 
   it 'should pick -windowtitle from project name' do
     define 'foo' do
       compile.using(:javac)
-      javadoc.options[:windowtitle].should eql('foo')
+      doc.options[:windowtitle].should eql('foo')
 
       define 'bar' do
         compile.using(:javac)
-        javadoc.options[:windowtitle].should eql('foo:bar')
+        doc.options[:windowtitle].should eql('foo:bar')
       end
     end
   end
@@ -406,32 +406,32 @@ describe Project, '#javadoc' do
     desc 'My App'
     define 'foo' do
       compile.using(:javac)
-      javadoc.options[:windowtitle].should eql('My App')
+      doc.options[:windowtitle].should eql('My App')
     end
   end
 
   it 'should produce documentation' do
     sources
     define('foo') { compile.using(:javac) }
-    project('foo').javadoc.invoke
-    (1..3).map { |i| "target/javadoc/foo/Test#{i}.html" }.each { |f| file(f).should exist }
+    project('foo').doc.invoke
+    (1..3).map { |i| "target/doc/foo/Test#{i}.html" }.each { |f| file(f).should exist }
   end
 
   it 'should fail on error' do
     write 'Test.java', 'class Test {}'
     define 'foo' do
       compile.using(:javac)
-      javadoc.include 'Test.java'
+      doc.include 'Test.java'
     end
-    lambda { project('foo').javadoc.invoke }.should raise_error(RuntimeError, /Failed to generate Javadocs/)
+    lambda { project('foo').doc.invoke }.should raise_error(RuntimeError, /Failed to generate Javadocs/)
   end
 
   it 'should be local task' do
     define 'foo' do
       define('bar') { compile.using(:javac) }
     end
-    project('foo:bar').javadoc.should_receive(:invoke_prerequisites)
-    in_original_dir(project('foo:bar').base_dir) { task('javadoc').invoke }
+    project('foo:bar').doc.should_receive(:invoke_prerequisites)
+    in_original_dir(project('foo:bar').base_dir) { task('doc').invoke }
   end
 
   it 'should not recurse' do
@@ -439,8 +439,8 @@ describe Project, '#javadoc' do
       compile.using(:javac)
       define('bar') { compile.using(:javac) }
     end
-    project('foo:bar').javadoc.should_not_receive(:invoke_prerequisites)
-    project('foo').javadoc.invoke
+    project('foo:bar').doc.should_not_receive(:invoke_prerequisites)
+    project('foo').doc.invoke
   end
 end
 

data/spec/java/emma_spec.rb

@@ -28,18 +28,18 @@ describe Buildr::Emma do
   end
 
   it_should_behave_like 'test coverage tool'
-  
+
   describe 'project-specific' do
     describe 'metadata file' do
       it 'should have a default value' do
         define('foo').emma.metadata_file.should point_to_path('reports/emma/coverage.em')
       end
-      
+
       it 'should be overridable' do
         define('foo') { emma.metadata_file = path_to('target/metadata.emma') }
         project('foo').emma.metadata_file.should point_to_path('target/metadata.emma')
       end
-      
+
       it 'should be created during instrumentation' do
         write 'src/main/java/Foo.java', 'public class Foo {}'
         define('foo')
@@ -47,17 +47,17 @@ describe Buildr::Emma do
         file(project('foo').emma.metadata_file).should exist
       end
     end
-    
+
     describe 'coverage file' do
       it 'should have a default value' do
         define('foo').emma.coverage_file.should point_to_path('reports/emma/coverage.ec')
       end
-      
+
       it 'should be overridable' do
         define('foo') { emma.coverage_file = path_to('target/coverage.emma') }
         project('foo').emma.coverage_file.should point_to_path('target/coverage.emma')
       end
-      
+
       it 'should be created during test' do
         write 'src/main/java/Foo.java', 'public class Foo {}'
         write_test :for=>'Foo', :in=>'src/test/java'
@@ -83,7 +83,7 @@ describe Buildr::Emma do
         task("foo:emma:instrument").invoke
         Dir.chdir('target/instrumented/classes') { Dir.glob('*').sort.should == ['Bar.class'] }
       end
-      
+
       it 'should instrument classes that are included but not excluded' do
         write 'src/main/java/Baz.java', 'public class Baz {}'
         define('foo') { emma.include('Ba*').exclude('*ar') }
@@ -91,13 +91,13 @@ describe Buildr::Emma do
         Dir.chdir('target/instrumented/classes') { Dir.glob('*').sort.should == ['Baz.class'] }
       end
     end
-    
+
     describe 'reports' do
       before do
         write 'src/main/java/Foo.java', 'public class Foo {}'
         write_test :for=>'Foo', :in=>'src/test/java'
       end
-      
+
       describe 'in html' do
         it 'should inform the user if no coverage data' do
           rm 'src/test/java/FooTest.java'
@@ -106,14 +106,14 @@ describe Buildr::Emma do
             should show_info(/No test coverage report for foo. Missing: #{project('foo').emma.coverage_file}/)
         end
       end
-      
+
       describe 'in xml' do
         it 'should have an xml file' do
           define('foo')
           task('foo:emma:xml').invoke
           file(File.join(project('foo').emma.report_dir, 'coverage.xml')).should exist
         end
-      end      
+      end
     end
   end
 end

data/spec/java/java_spec.rb

@@ -48,42 +48,42 @@ describe Java, '#tools_jar' do
   before do
     @old_home = ENV['JAVA_HOME']
   end
-  
+
   describe 'when JAVA_HOME points to a JDK' do
     before do
       Java.instance_eval { @tools_jar = nil }
       write 'jdk/lib/tools.jar'
       ENV['JAVA_HOME'] = File.expand_path('jdk')
     end
-  
+
     it 'should return the path to tools.jar' do
       Java.tools_jar.should point_to_path('jdk/lib/tools.jar')
     end
   end
-  
+
   describe 'when JAVA_HOME points to a JRE inside a JDK' do
     before do
       Java.instance_eval { @tools_jar = nil }
       write 'jdk/lib/tools.jar'
       ENV['JAVA_HOME'] = File.expand_path('jdk/jre')
     end
-    
+
     it 'should return the path to tools.jar' do
       Java.tools_jar.should point_to_path('jdk/lib/tools.jar')
     end
   end
-  
+
   describe 'when there is no tools.jar' do
     before do
       Java.instance_eval { @tools_jar = nil }
       ENV['JAVA_HOME'] = File.expand_path('jdk')
     end
-    
+
     it 'should return nil' do
       Java.tools_jar.should be_nil
     end
   end
-  
+
   after do
     ENV['JAVA_HOME'] = @old_home
   end
@@ -93,13 +93,13 @@ describe Java, '#java' do
   before do
     @old_home = ENV['JAVA_HOME']
   end
-  
+
   describe 'when JAVA_HOME points to an invalid JRE/JDK installation' do
     before do
       write 'jdk'
       ENV['JAVA_HOME'] = File.expand_path('jdk')
     end
-  
+
     it 'should fail with an error message mentioning JAVA_HOME' do
       begin
         Java.java ['-version']
@@ -109,7 +109,7 @@ describe Java, '#java' do
       end
     end
   end
-  
+
   after do
     ENV['JAVA_HOME'] = @old_home
   end