buildr 1.4.2-x86-mswin32 → 1.4.3-x86-mswin32

data/spec/core/run_spec.rb

@@ -0,0 +1,92 @@
+# 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 Project, :run do
+
+  it 'should return the project\'s run task' do
+    define('foo')
+    project('foo').run.name.should eql('foo:run')
+  end
+
+  it 'should return a RunTask' do
+    define('foo')
+    project('foo').run.should be_kind_of(Run::RunTask)
+  end
+
+  it 'should include compile and test.compile dependencies' do
+    define('foo') do
+      compile.using(:javac).with 'group:compile:jar:1.0'
+      test.compile.using(:javac).with 'group:test:jar:1.0'
+    end
+    project('foo').run.classpath.should include(artifact('group:compile:jar:1.0'))
+    project('foo').run.classpath.should include(artifact('group:test:jar:1.0'))
+  end
+
+  it 'should respond to using() and return self' do
+    define 'foo' do
+      run.using(:foo=>'Fooing').should be(run)
+    end
+  end
+
+  it 'should respond to using() and accept options' do
+    define 'foo' do
+      run.using :foo=>'Fooing'
+    end
+    project('foo').run.options[:foo].should eql('Fooing')
+  end
+
+  it 'should select runner using run.using' do
+    define 'foo' do
+      run.using :java
+    end
+    project('foo').run.runner.should be_a(Run::JavaRunner)
+  end
+
+  it 'should select runner based on compile language' do
+    write 'src/main/java/Test.java', 'class Test {}'
+    define 'foo' do
+      # compile language detected as :java
+    end
+    project('foo').run.runner.should be_a(Run::JavaRunner)
+  end
+
+  it 'should depend on project''s compile and test.compile task' do
+    define 'foo'
+    project('foo').run.prerequisites.should include(project('foo').compile)
+  end
+
+  it 'should be local task' do
+    define 'foo' do
+      define('bar')
+    end
+    project('foo:bar').run.should_receive(:invoke_prerequisites)
+    project('foo:bar').run.should_receive(:run)
+    in_original_dir(project('foo:bar').base_dir) { task('run').invoke }
+  end
+
+  it 'should not recurse' do
+    define 'foo' do
+      define('bar') { run.using :java, :main => 'foo' }
+    end
+    project('foo:bar').run.should_not_receive(:invoke_prerequisites)
+    project('foo:bar').run.should_not_receive(:run)
+    project('foo').run.should_receive(:run)
+    project('foo').run.invoke
+  end
+
+end
+

data/spec/java/compiler_spec.rb

@@ -250,197 +250,3 @@ describe 'javac compiler options' do
   end
 end
 
-
-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}{}" }.
-      map { |name| "src/main/java/foo/#{name}.java" }
-  end
-
-  it 'should return the project\'s Javadoc task' do
-    define('foo') { compile.using(:javac) }
-    project('foo').doc.name.should eql('foo:doc')
-  end
-
-  it 'should return a DocTask' do
-    define('foo') { compile.using(:javac) }
-    project('foo').doc.should be_kind_of(Doc::DocTask)
-  end
-
-  it 'should set target directory to target/doc' do
-    define 'foo' do
-      compile.using(:javac)
-      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)
-      doc.should_receive(:invoke_prerequisites)
-    end
-    project('foo').file('target/doc').invoke
-  end
-
-  it 'should respond to into() and return self' do
-    define 'foo' do
-      compile.using(:javac)
-      doc.into('docs').should be(doc)
-    end
-  end
-
-  it 'should respond to into() and change target directory' do
-    define 'foo' do
-      compile.using(:javac)
-      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 = 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)
-      doc.from('srcs').should be(doc)
-    end
-  end
-
-  it 'should respond to from() and add file task' do
-    define 'foo' do
-      compile.using(:javac)
-      doc.from('srcs').should be(doc)
-    end
-    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
-    write 'bar/src/main/java/Test.java'
-    define 'foo' do
-      compile.using(:javac)
-      define('bar') { compile.using(:javac).with 'group:id:jar:1.0' }
-      doc.from project('foo:bar')
-    end
-    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 docs from project' do
-    sources
-    define('foo') { compile.using(:javac) }
-    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').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)
-      doc.include('srcs').should be(doc)
-    end
-  end
-
-  it 'should respond to include() and add files' do
-    included = sources.first
-    define 'foo' do
-      compile.using(:javac)
-      doc.include included
-    end
-    project('foo').doc.source_files.should include(included)
-  end
-
-  it 'should respond to exclude() and return self' do
-    define 'foo' do
-      compile.using(:javac)
-      doc.exclude('srcs').should be(doc)
-    end
-  end
-
-  it 'should respond to exclude() and ignore files' do
-    excluded = sources.first
-    define 'foo' do
-      compile.using(:javac)
-      doc.exclude excluded
-    end
-    sources
-    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)
-      doc.using(:windowtitle=>'Fooing').should be(doc)
-    end
-  end
-
-  it 'should respond to using() and accept options' do
-    define 'foo' do
-      compile.using(:javac)
-      doc.using :windowtitle=>'Fooing'
-    end
-    project('foo').doc.options[:windowtitle].should eql('Fooing')
-  end
-
-  it 'should pick -windowtitle from project name' do
-    define 'foo' do
-      compile.using(:javac)
-      doc.options[:windowtitle].should eql('foo')
-
-      define 'bar' do
-        compile.using(:javac)
-        doc.options[:windowtitle].should eql('foo:bar')
-      end
-    end
-  end
-
-  it 'should pick -windowtitle from project description' do
-    desc 'My App'
-    define 'foo' do
-      compile.using(:javac)
-      doc.options[:windowtitle].should eql('My App')
-    end
-  end
-
-  it 'should produce documentation' do
-    sources
-    define('foo') { compile.using(:javac) }
-    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)
-      doc.include 'Test.java'
-    end
-    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').doc.should_receive(:invoke_prerequisites)
-    in_original_dir(project('foo:bar').base_dir) { task('doc').invoke }
-  end
-
-  it 'should not recurse' do
-    define 'foo' do
-      compile.using(:javac)
-      define('bar') { compile.using(:javac) }
-    end
-    project('foo:bar').doc.should_not_receive(:invoke_prerequisites)
-    project('foo').doc.invoke
-  end
-end
-

data/spec/java/doc_spec.rb

@@ -0,0 +1,56 @@
+# 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 'Javadoc' do
+  def sources
+    @sources ||= (1..3).map { |i| "Test#{i}" }.
+      each { |name| write "src/main/java/foo/#{name}.java", "package foo; public class #{name}{}" }.
+      map { |name| "src/main/java/foo/#{name}.java" }
+  end
+
+  it 'should pick -windowtitle from project name by default' do
+    define 'foo' do
+      compile.using(:javac)
+
+      define 'bar' do
+        compile.using(:javac)
+      end
+    end
+
+    project('foo').doc.options[:windowtitle].should eql('foo')
+    project('foo:bar').doc.options[:windowtitle].should eql('foo:bar')
+  end
+
+  it 'should pick -windowtitle from project description by default, if available' do
+    desc 'My App'
+    define 'foo' do
+      compile.using(:javac)
+    end
+    project('foo').doc.options[:windowtitle].should eql('My App')
+  end
+
+  it 'should not override explicit :windowtitle' do
+    define 'foo' do
+      compile.using(:javac)
+      doc.using :windowtitle => 'explicit'
+    end
+    project('foo').doc.options[:windowtitle].should eql('explicit')
+  end
+
+end
+

data/spec/java/packaging_spec.rb

@@ -567,12 +567,19 @@ describe Packaging, 'war' do
   end
 
   it 'should accept file from :libs option' do
+    write 'lib/foo.jar'
+    define('foo', :version=>'1.0') { package(:war).libs << 'lib/foo.jar' }
+    inspect_war { |files| files.should include('META-INF/MANIFEST.MF', 'WEB-INF/lib/foo.jar') }
+  end
+
+
+  it 'should accept artifacts from :libs option' do
     make_jars
     define('foo', :version=>'1.0') { package(:war).with(:libs=>'group:id:jar:1.0') }
     inspect_war { |files| files.should include('META-INF/MANIFEST.MF', 'WEB-INF/lib/id-1.0.jar') }
   end
 
-  it 'should accept file from :libs option' do
+  it 'should accept artifacts from :libs option' do
     make_jars
     define('foo', :version=>'1.0') { package(:war).with(:libs=>['group:id:jar:1.0', 'group:id:jar:2.0']) }
     inspect_war { |files| files.should include('META-INF/MANIFEST.MF', 'WEB-INF/lib/id-1.0.jar', 'WEB-INF/lib/id-2.0.jar') }
@@ -601,25 +608,25 @@ describe Packaging, 'war' do
     define('foo', :version=>'1.0') { compile.with 'group:id:jar:1.0', 'group:id:jar:2.0' ; package(:war).exclude('**/id-2.0.jar')   }
     inspect_war { |files| files.should include('META-INF/MANIFEST.MF', 'WEB-INF/lib/id-1.0.jar') }
   end
-  
+
   it 'should exclude files regardless of the path where they are included, specifying target path entirely' do
      make_jars
      define('foo', :version=>'1.0') { compile.with 'group:id:jar:1.0', 'group:id:jar:2.0' ; package(:war).exclude('WEB-INF/lib/id-2.0.jar')   }
      inspect_war { |files| files.should include('META-INF/MANIFEST.MF', 'WEB-INF/lib/id-1.0.jar') }
    end
-  
-  it 'should exclude files regardless of the path where they are included for war files' do 
-     write 'src/main/java/com/example/included/Test.java', 'package com.example.included; class Test {}' 
-     write 'src/main/java/com/example/excluded/Test.java', 'package com.example.excluded; class Test {}' 
-     define('foo', :version=>'1.0') do 
-       package(:war).enhance do |war| 
+
+  it 'should exclude files regardless of the path where they are included for war files' do
+     write 'src/main/java/com/example/included/Test.java', 'package com.example.included; class Test {}'
+     write 'src/main/java/com/example/excluded/Test.java', 'package com.example.excluded; class Test {}'
+     define('foo', :version=>'1.0') do
+       package(:war).enhance do |war|
          war.exclude('WEB-INF/classes/com/example/excluded/**.class')
        end
-     end 
-     inspect_war do |files| 
-       files.should include('WEB-INF/classes/com/example/included/Test.class') 
-       files.should_not include('WEB-INF/classes/com/example/excluded/Test.class') 
-     end 
+     end
+     inspect_war do |files|
+       files.should include('WEB-INF/classes/com/example/included/Test.class')
+       files.should_not include('WEB-INF/classes/com/example/excluded/Test.class')
+     end
    end
 
   it 'should include only specified libraries' do
@@ -1106,11 +1113,20 @@ describe Packaging, 'sources' do
     end
   end
 
-  it 'should contain source files' do
+  it 'should contain source and resource files' do
     write 'src/main/java/Source.java'
+    write 'src/main/resources/foo.properties', 'foo=bar'
     define('foo', :version=>'1.0') { package(:sources) }
     project('foo').task('package').invoke
     project('foo').packages.first.should contain('Source.java')
+    project('foo').packages.first.should contain('foo.properties')
+  end
+
+  it 'should create sources jar if resources exists (but not sources)' do
+    write 'src/main/resources/foo.properties', 'foo=bar'
+    define('foo', :version=>'1.0') { package(:sources) }
+    project('foo').package(:sources).invoke
+    project('foo').packages.first.should contain('foo.properties')
   end
 
   it 'should be a ZipTask' do

data/spec/java/run_spec.rb

@@ -0,0 +1,78 @@
+# 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 Run::JavaRunner do
+
+  it 'should fail on error' do
+    define 'foo' do
+      run.using :java, :main => 'org.example.NonExistentMain' # class doesn't exist
+    end
+    lambda { project('foo').run.invoke }.should raise_error(RuntimeError, /Failed to execute java/)
+  end
+
+  it 'should execute main class' do
+    write 'src/main/java/org/example/Main.java', <<-JAVA
+      package org.example;
+      public class Main {
+        public static void main(String[] args) {
+          System.out.println("Hello, world!");
+        }
+      }
+    JAVA
+    define 'foo' do
+      run.using :main => 'org.example.Main'
+    end
+    project('foo').run.prerequisites.should include(task("foo:compile"))
+  end
+
+  it 'should accept :main option as an array including parameters for the main class' do
+    define 'foo' do
+      run.using :java, :main => ['org.example.Main', '-t', 'input.txt']
+    end
+    Java::Commands.should_receive(:java).once.with do |*args|
+      args[0].should == ['org.example.Main', '-t', 'input.txt']
+    end
+    project('foo').run.invoke
+  end
+
+  it 'should accept :java_args and pass them to java' do
+    define 'foo' do
+      run.using :java, :main => 'foo', :java_args => ['-server']
+    end
+    Java::Commands.should_receive(:java).once.with do |*args|
+      args[0].should == 'foo'
+      args[1][:java_args].should include('-server')
+    end
+    project('foo').run.invoke
+  end
+
+  it 'should accept :properties and pass them as -Dproperty=value to java' do
+    define 'foo' do
+      run.using :java, :main => 'foo', :properties => { :foo => 'one', :bar => 'two' }
+    end
+    Java::Commands.should_receive(:java).once.with do |*args|
+      args[0].should == 'foo'
+      args[1][:properties][:foo].should == 'one'
+      args[1][:properties][:bar].should == 'two'
+    end
+    project('foo').run.invoke
+  end
+
+end
+