buildr-gemjar 1.0.0

data/vendor/buildr/spec/sandbox.rb

@@ -0,0 +1,165 @@
+# 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.
+
+
+# The local repository we use for testing is void of any artifacts, which will break given
+# that the code requires several artifacts. So we establish them first using the real local
+# 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'
+
+# Force Scala 2.8.1 for specs; don't want to rely on SCALA_HOME
+Buildr.settings.build['scala.version'] = "2.8.1"
+
+# Add a 'require' here only for optional extensions, not for extensions that should be loaded by default.
+require 'buildr/clojure'
+require 'buildr/groovy'
+require 'buildr/scala'
+require 'buildr/bnd'
+require 'buildr/jaxb_xjc'
+
+Java.load # Anything added to the classpath.
+artifacts(
+  TestFramework.frameworks.map(&:dependencies).flatten,
+  JUnit.ant_taskdef,
+  Buildr::Groovy.dependencies,
+  Buildr::JaxbXjc.dependencies,
+  Buildr::Bnd.dependencies,
+  Buildr::Scala::Specs.dependencies,
+  Buildr::Shell::BeanShell.artifact,
+  Buildr::Clojure.dependencies
+).each do |path|
+  file(path).invoke
+end
+
+ENV['HOME'] = File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp', 'home'))
+mkpath ENV['HOME']
+
+# We need to run all tests inside a _sandbox, tacking a snapshot of Buildr before the test,
+# and restoring everything to its previous state after the test. Damn state changes.
+module Sandbox
+
+  class << self
+    attr_reader :tasks, :rules
+
+    def included(spec)
+      spec.before(:each) { sandbox }
+      spec.after(:each) { reset }
+    end
+
+    # Require an optional extension without letting its callbacks pollute the Project class.
+    def require_optional_extension(extension_require_path)
+      project_callbacks_without_extension = Project.class_eval { @global_callbacks }.dup
+      begin
+        require extension_require_path
+      ensure
+        Project.class_eval { @global_callbacks = project_callbacks_without_extension }
+      end
+    end
+  end
+
+  @tasks = Buildr.application.tasks.collect do |original|
+    prerequisites = original.send(:prerequisites).map(&:to_s)
+    actions = original.instance_eval { @actions }.clone
+    lambda do
+      original.class.send(:define_task, original.name=>prerequisites).tap do |task|
+        task.comment = original.comment
+        actions.each { |action| task.enhance &action }
+      end
+    end
+  end
+  @rules = Buildr.application.instance_variable_get(:@rules)
+
+  def sandbox
+    @_sandbox = {}
+
+    # Create a temporary directory where we can create files, e.g,
+    # for projects, compilation. We need a place that does not depend
+    # on the current directory.
+    @_sandbox[:original_dir] = Dir.pwd
+    @temp = File.join(File.dirname(__FILE__), '../tmp')
+    FileUtils.mkpath @temp
+    Dir.chdir @temp
+
+    ARGV.clear
+    Buildr.application = Buildr::Application.new
+    Sandbox.tasks.each { |block| block.call }
+    Buildr.application.instance_variable_set :@rules, Sandbox.rules.clone
+    Buildr.application.instance_eval { @rakefile = File.expand_path('buildfile') }
+
+    @_sandbox[:load_path] = $LOAD_PATH.clone
+    #@_sandbox[:loaded_features] = $LOADED_FEATURES.clone
+
+    # Later on we'll want to lose all the on_define created during the test.
+    @_sandbox[:on_define] = Project.class_eval { (@on_define || []).dup }
+    @_sandbox[:extension_modules] = Project.class_eval { (@extension_modules || []).dup }
+    @_sandbox[:global_callbacks] = Project.class_eval { (@global_callbacks || []).dup }
+    @_sandbox[:layout] = Layout.default.clone
+
+    # Create a local repository we can play with. However, our local repository will be void
+    # of some essential artifacts (e.g. JUnit artifacts required by build task), so we create
+    # these first (see above) and keep them across test cases.
+    @_sandbox[:artifacts] = Artifact.class_eval { @artifacts }.clone
+    Buildr.repositories.local = File.expand_path('repository')
+    ENV['HOME'] = File.expand_path('home')
+    ENV['BUILDR_ENV'] = 'development'
+
+    @_sandbox[:env_keys] = ENV.keys
+    ['DEBUG', 'TEST', 'HTTP_PROXY', 'HTTPS_PROXY', 'USER'].each { |k| ENV.delete(k) ; ENV.delete(k.downcase) }
+
+    # Remove testing local repository, and reset all repository settings.
+    Buildr.repositories.instance_eval do
+      @local = @remote = @release_to = nil
+    end
+    Buildr.options.proxy.http = nil
+
+    # Don't output crap to the console.
+    trace false
+    verbose false
+  end
+
+  # Call this from teardown.
+  def reset
+    # Get rid of all the projects and the on_define blocks we used.
+    Project.clear
+
+    on_define = @_sandbox[:on_define]
+    extension_modules = @_sandbox[:extension_modules]
+    global_callbacks = @_sandbox[:global_callbacks]
+
+    Project.class_eval do
+      @on_define = on_define
+      @global_callbacks = global_callbacks
+      @extension_modules = extension_modules
+    end
+
+    Layout.default = @_sandbox[:layout].clone
+
+    $LOAD_PATH.replace @_sandbox[:load_path]
+    FileUtils.rm_rf @temp
+    mkpath ENV['HOME']
+
+    # Get rid of all artifacts.
+    @_sandbox[:artifacts].tap { |artifacts| Artifact.class_eval { @artifacts = artifacts } }
+
+    # Restore options.
+    Buildr.options.test = nil
+    (ENV.keys - @_sandbox[:env_keys]).each { |key| ENV.delete key }
+
+    Dir.chdir @_sandbox[:original_dir]
+  end
+
+end

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

@@ -0,0 +1,124 @@
+# 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 Buildr::Scala::Specs 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 when tests in src/spec/scala' do
+    write 'src/spec/scala/com/example/MySpecs.scala', <<-SCALA
+      package com.example
+      object MySpecs extends org.specs.Specification {
+        "it" should {
+          "add" in {
+            val sum = 1 + 1
+            sum mustEqual 2
+          }
+        }
+      }
+    SCALA
+    define 'foo'
+    project('foo').test.framework.should eql(:specs)
+  end
+
+  it 'should include Specs dependencies' do
+    define('foo') { test.using(:specs) }
+    project('foo').test.compile.dependencies.should include(*artifacts(Scala::Specs.dependencies))
+    project('foo').test.dependencies.should include(*artifacts(Scala::Specs.dependencies))
+  end
+
+  it 'should include ScalaCheck dependencies' do
+    define('foo') { test.using(:specs) }
+    project('foo').test.compile.dependencies.should include(*artifacts(Scala::Check.dependencies))
+    project('foo').test.dependencies.should include(*artifacts(Scala::Check.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 public objects extending org.specs.Specification' do
+    write 'src/spec/scala/com/example/MySpecs.scala', <<-SCALA
+      package com.example
+      object MySpecs extends org.specs.Specification {
+        "it" should {
+          "add" in {
+            val sum = 1 + 1
+            sum mustEqual 2
+          }
+        }
+      }
+    SCALA
+    define('foo').test.invoke
+    project('foo').test.tests.should include('com.example.MySpecs')
+  end
+
+  it 'should include public objects extending org.specs.Specification even with companion classes' do
+    write 'src/spec/scala/com/example/MySpecs.scala', <<-SCALA
+      package com.example
+      object MySpecs extends org.specs.Specification {
+        "it" should {
+          "add" in {
+            val sum = 1 + 1
+            sum mustEqual 2
+          }
+        }
+      }
+      class MySpecs extends org.specs.runner.JUnit4(MySpecs)
+    SCALA
+    define('foo').test.invoke
+    project('foo').test.tests.should include('com.example.MySpecs')
+  end
+
+  it 'should pass when spec passes' do
+    write 'src/spec/scala/PassingSpecs.scala', <<-SCALA
+      object PassingSpecs extends org.specs.Specification {
+        "it" should {
+          "add" in {
+            val sum = 1 + 1
+            sum mustEqual 2
+          }
+        }
+      }
+    SCALA
+    lambda { define('foo').test.invoke }.should_not raise_error
+  end
+
+  it 'should fail when spec fails' do
+    write 'src/spec/scala/StringSpecs.scala', <<-SCALA
+      import org.specs._
+      import org.specs.runner._
+
+      object StringSpecs extends Specification {
+        "empty string" should {
+          "have a zero length" in {
+            ("".length) mustEqual(1)
+          }
+        }
+      }
+    SCALA
+    define('foo')
+    project('foo').test.invoke rescue
+    project('foo').test.failed_tests.should include('StringSpecs')
+  end
+end

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

@@ -0,0 +1,289 @@
+# 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'))
+
+# need to test both with and without SCALA_HOME
+share_as :ScalacCompiler 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 identify itself from source directories' do
+    write 'src/main/scala/com/example/Test.scala', 'package com.example; class Test { val i = 1 }'
+    define('foo').compile.compiler.should eql(:scalac)
+  end
+
+  it 'should report the language as :scala' do
+    define('foo').compile.using(:scalac).language.should eql(:scala)
+  end
+
+  it 'should set the target directory to target/classes' do
+    define 'foo' do
+      lambda { compile.using(:scalac) }.should change { compile.target.to_s }.to(File.expand_path('target/classes'))
+    end
+  end
+
+  it 'should not override existing target directory' do
+    define 'foo' do
+      compile.into('classes')
+      lambda { compile.using(:scalac) }.should_not change { compile.target }
+    end
+  end
+
+  it 'should not change existing list of sources' do
+    define 'foo' do
+      compile.from('sources')
+      lambda { compile.using(:scalac) }.should_not change { compile.sources }
+    end
+  end
+
+  it 'should include as classpath dependency' do
+    write 'src/dependency/Dependency.scala', 'class Dependency {}'
+    define 'dependency', :version=>'1.0' do
+      compile.from('src/dependency').into('target/dependency')
+      package(:jar)
+    end
+    write 'src/test/DependencyTest.scala', 'class DependencyTest { var d: Dependency = _ }'
+    lambda { define('foo').compile.from('src/test').with(project('dependency')).invoke }.should run_task('foo:compile')
+    file('target/classes/DependencyTest.class').should exist
+  end
+
+  def define_test1_project
+    write 'src/main/scala/com/example/Test1.scala', 'package com.example; class Test1 { val i = 1 }'
+    define 'test1', :version=>'1.0' do
+      package(:jar)
+    end
+  end
+
+  it 'should compile a simple .scala file into a .class file' do
+    define_test1_project
+    task('test1:compile').invoke
+    file('target/classes/com/example/Test1.class').should exist
+  end
+
+  it 'should package .class into a .jar file' do
+    define_test1_project
+    task('test1:package').invoke
+    file('target/test1-1.0.jar').should exist
+    Zip::ZipFile.open(project('test1').package(:jar).to_s) do |zip|
+      zip.file.exist?('com/example/Test1.class').should be_true
+    end
+  end
+
+  it 'should compile scala class depending on java class in same project' do
+    write 'src/main/java/com/example/Foo.java', 'package com.example; public class Foo {}'
+    write 'src/main/scala/com/example/Bar.scala', 'package com.example; class Bar extends Foo'
+    define 'test1', :version=>'1.0' do
+      package(:jar)
+    end
+    task('test1:package').invoke
+    file('target/test1-1.0.jar').should exist
+    Zip::ZipFile.open(project('test1').package(:jar).to_s) do |zip|
+      zip.file.exist?('com/example/Foo.class').should be_true
+      zip.file.exist?('com/example/Bar.class').should be_true
+    end
+  end
+
+  it 'should compile java class depending on scala class in same project' do
+    write 'src/main/scala/com/example/Foo.scala', 'package com.example; class Foo'
+    write 'src/main/java/com/example/Bar.java',  'package com.example; public class Bar extends Foo {}'
+    define 'test1', :version=>'1.0' do
+      package(:jar)
+    end
+    task('test1:package').invoke
+    file('target/test1-1.0.jar').should exist
+    Zip::ZipFile.open(project('test1').package(:jar).to_s) do |zip|
+      zip.file.exist?('com/example/Foo.class').should be_true
+      zip.file.exist?('com/example/Bar.class').should be_true
+    end
+  end
+end
+
+
+describe 'scala compiler (installed in SCALA_HOME)' do
+  it 'requires present SCALA_HOME' do
+    ENV['SCALA_HOME'].should_not be_nil
+  end
+
+  it_should_behave_like ScalacCompiler
+end
+
+
+describe 'scala compiler (downloaded from repository)' do
+  old_home = ENV['SCALA_HOME']
+
+  before :all do
+    ENV['SCALA_HOME'] = nil
+  end
+
+  it 'requires absent SCALA_HOME' do
+    ENV['SCALA_HOME'].should be_nil
+  end
+
+  it_should_behave_like ScalacCompiler
+
+  after :all do
+    ENV['SCALA_HOME'] = old_home
+  end
+end
+
+
+describe 'scalac compiler options' do
+  def compile_task
+    @compile_task ||= define('foo').compile.using(:scalac)
+  end
+
+  def scalac_args
+    compile_task.instance_eval { @compiler }.send(:scalac_args)
+  end
+
+  it 'should set warnings option to false by default' do
+    compile_task.options.warnings.should be_false
+  end
+
+  it 'should set warnings option to true when running with --verbose option' do
+    verbose true
+    compile_task.options.warnings.should be_true
+  end
+
+  it 'should use -nowarn argument when warnings is false' do
+    compile_task.using(:warnings=>false)
+    scalac_args.should include('-nowarn')
+  end
+
+  it 'should not use -nowarn argument when warnings is true' do
+    compile_task.using(:warnings=>true)
+    scalac_args.should_not include('-nowarn')
+  end
+
+  it 'should not use -verbose argument by default' do
+    scalac_args.should_not include('-verbose')
+  end
+
+  it 'should use -verbose argument when running with --trace=scalac option' do
+    Buildr.application.options.trace_categories = [:scalac]
+    scalac_args.should include('-verbose')
+  end
+
+  it 'should set debug option to true by default' do
+    compile_task.options.debug.should be_true
+  end
+
+  it 'should set debug option to false based on Buildr.options' do
+    Buildr.options.debug = false
+    compile_task.options.debug.should be_false
+  end
+
+  it 'should set debug option to false based on debug environment variable' do
+    ENV['debug'] = 'no'
+    compile_task.options.debug.should be_false
+  end
+
+  it 'should set debug option to false based on DEBUG environment variable' do
+    ENV['DEBUG'] = 'no'
+    compile_task.options.debug.should be_false
+  end
+
+  it 'should use -g argument when debug option is true' do
+    compile_task.using(:debug=>true)
+    scalac_args.should include('-g')
+  end
+
+  it 'should not use -g argument when debug option is false' do
+    compile_task.using(:debug=>false)
+    scalac_args.should_not include('-g')
+  end
+
+  it 'should set deprecation option to false by default' do
+    compile_task.options.deprecation.should be_false
+  end
+
+  it 'should use -deprecation argument when deprecation is true' do
+    compile_task.using(:deprecation=>true)
+    scalac_args.should include('-deprecation')
+  end
+
+  it 'should not use -deprecation argument when deprecation is false' do
+    compile_task.using(:deprecation=>false)
+    scalac_args.should_not include('-deprecation')
+  end
+
+  it 'should set optimise option to false by default' do
+    compile_task.options.optimise.should be_false
+  end
+
+  it 'should use -optimise argument when deprecation is true' do
+    compile_task.using(:optimise=>true)
+    scalac_args.should include('-optimise')
+  end
+
+  it 'should not use -optimise argument when deprecation is false' do
+    compile_task.using(:optimise=>false)
+    scalac_args.should_not include('-optimise')
+  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 -target:xxx argument if target option set' do
+    compile_task.using(:target=>'1.5')
+    scalac_args.should include('-target:jvm-1.5')
+  end
+
+  it 'should not set other option by default' do
+    compile_task.options.other.should be_nil
+  end
+
+  it 'should pass other argument if other option is string' do
+    compile_task.using(:other=>'-unchecked')
+    scalac_args.should include('-unchecked')
+  end
+
+  it 'should pass other argument if other option is array' do
+    compile_task.using(:other=>['-unchecked', '-Xprint-types'])
+    scalac_args.should include('-unchecked', '-Xprint-types')
+  end
+
+  it 'should complain about options it doesn\'t know' do
+    write 'source/Test.scala', 'class Test {}'
+    compile_task.using(:unknown=>'option')
+    lambda { compile_task.from('source').invoke }.should raise_error(ArgumentError, /no such option/i)
+  end
+
+  it 'should inherit options from parent' do
+    define 'foo' do
+      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.target.should eql('1.4')
+      end
+    end
+  end
+
+  after do
+    Buildr.options.debug = nil
+    ENV.delete "debug"
+    ENV.delete "DEBUG"
+  end
+end