buildr 1.3.5-x86-mswin32

data/lib/buildr/scala.rb

@@ -0,0 +1,25 @@
+# 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.
+
+
+ENV['SCALA_HOME'] ||= '/opt/local/share/scala/' if File.exist?('/opt/local/share/scala/lib/scala-compiler.jar')
+Buildr.repositories.remote << 'http://scala-tools.org/repo-releases'
+
+require 'buildr/scala/compiler'
+require 'buildr/scala/tests'
+require 'buildr/scala/bdd'
+require 'buildr/scala/shell'
+
+Object::Scala = Buildr::Scala

data/lib/buildr/scala/bdd.rb

@@ -0,0 +1,109 @@
+# 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 'buildr/core/build'
+require 'buildr/core/compile'
+require 'buildr/java/bdd'
+require 'buildr/scala/tests'
+
+module Buildr::Scala
+  
+  # Specs is a Scala based BDD framework.
+  # To use in your project:
+  #
+  #   test.using :specs
+  # 
+  # This framework will search in your project for:
+  #   src/spec/scala/**/*.scala
+  class Specs < Buildr::TestFramework::JavaBDD
+    @lang = :scala
+    @bdd_dir = :spec
+
+    VERSION = '1.5.0'
+    
+    class << self
+      def version
+        Buildr.settings.build['scala.specs'] || VERSION
+      end
+      
+      def dependencies
+        ["org.scala-tools.testing:specs:jar:#{version}"] + Check.dependencies + JUnit.dependencies
+      end
+      
+      def applies_to?(project)  #:nodoc:
+        !Dir[project.path_to(:source, bdd_dir, lang, '**/*.scala')].empty?
+      end
+
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use Scala::Specs.dependencies/.version instead of ScalaSpecs::REQUIRES/VERSION"
+        dependencies
+      end
+    end
+
+    def initialize(task, options) #:nodoc:
+      super
+      
+      specs = task.project.path_to(:source, :spec, :scala)
+      task.compile.from specs if File.directory?(specs)
+      
+      resources = task.project.path_to(:source, :spec, :resources)
+      task.resources.from resources if File.directory?(resources)
+    end
+    
+    def tests(dependencies)
+      dependencies += [task.compile.target.to_s]
+      candidates = filter_classes(dependencies, :interfaces => ['org.specs.Specification'])
+      
+      Java.load   # Java is already loaded, but just in case
+      
+      filter = Java.org.apache.buildr.JavaTestFilter.new(dependencies.to_java(Java.java.lang.String))
+      filter.add_fields ['MODULE$'].to_java(Java.java.lang.String)
+      filter.filter(candidates.to_java(Java.java.lang.String))      # we only want singletons
+    end
+    
+    def run(specs, dependencies)  #:nodoc:
+      dependencies += [task.compile.target.to_s, File.join(File.dirname(__FILE__))] + Scalac.dependencies
+      
+      cmd_options = { :properties => options[:properties],
+                      :java_args => options[:java_args],
+                      :classpath => dependencies}
+
+      runner = 'org.apache.buildr.SpecsSingletonRunner'
+      specs.inject [] do |passed, spec|
+        begin
+          unless Util.win_os?
+            Java::Commands.java(runner, task.compile.target.to_s, '-c', spec, cmd_options)
+          else
+            Java::Commands.java(runner, task.compile.target.to_s, spec, cmd_options)
+          end
+        rescue => e
+          passed
+        else
+          passed << spec
+        end
+      end
+    end
+  end
+end
+
+# Backwards compatibility stuff.  Remove in 1.5.
+module Buildr
+  ScalaSpecs = Scala::Specs
+end
+
+Buildr::TestFramework << Buildr::Scala::Specs

data/lib/buildr/scala/compiler.rb

@@ -0,0 +1,195 @@
+# 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 'buildr/core/project'
+require 'buildr/core/common'
+require 'buildr/core/compile'
+require 'buildr/packaging'
+
+module Buildr::Scala
+  DEFAULT_VERSION = '2.7.5'   # currently the latest (Jun 19, 2009)
+  
+  class << self
+    
+    # Retrieves the Scala version string from the 
+    # standard library or nil if Scala is not
+    # available.
+    def version_str
+      begin
+        # Scala version string normally looks like "version 2.7.3.final"
+        Java.scala.util.Properties.versionString.sub 'version ', ''
+      rescue
+        nil
+      end
+    end
+    
+    def version
+      if version_str
+        # any consecutive sequence of numbers followed by dots
+        match = version_str.match(/\d+\.\d[\d\.]*/) or
+          fail "Unable to parse Scala version: #{version_str} "
+        match[0].sub(/.$/, "") # remove trailing dot, if any
+      else
+        DEFAULT_VERSION       # TODO return the version installed from Maven repo
+      end
+    end
+  end
+
+  # Scalac compiler:
+  #   compile.using(:scalac)
+  # Used by default if .scala files are found in the src/main/scala directory (or src/test/scala)
+  # and sets the target directory to target/classes (or target/test/classes).
+  #
+  # Accepts the following options:
+  # * :warnings    -- Generate warnings if true (opposite of -nowarn).
+  # * :deprecation -- Output source locations where deprecated APIs are used.
+  # * :optimise    -- Generates faster bytecode by applying optimisations to the program.
+  # * :target      -- Class file compatibility with specified release.
+  # * :debug       -- Generate debugging info.
+  # * :other       -- Array of options to pass to the Scalac compiler as is, e.g. -Xprint-types
+  class Scalac < Buildr::Compiler::Base
+    
+    # The scalac compiler jars are added to classpath at load time,
+    # if you want to customize artifact versions, you must set them on the
+    #
+    #      artifact_ns['Buildr::Compiler::Scalac'].library = '2.7.5'
+    #
+    # namespace before this file is required.  This is of course, only
+    # if SCALA_HOME is not set or invalid.
+    REQUIRES = ArtifactNamespace.for(self) do |ns|
+      ns.library!      'org.scala-lang:scala-library:jar:>=' + DEFAULT_VERSION
+      ns.compiler!     'org.scala-lang:scala-compiler:jar:>=' + DEFAULT_VERSION
+    end
+    
+    class << self
+      def scala_home
+        env_home = ENV['SCALA_HOME']
+        
+        @home ||= (if !env_home.nil? && File.exists?(env_home + '/lib/scala-library.jar') && File.exists?(env_home + '/lib/scala-compiler.jar')
+          env_home
+        else
+          nil
+        end)
+      end
+      
+      def installed?
+        !scala_home.nil?
+      end
+
+      def dependencies
+        if installed?
+          ['scala-library', 'scala-compiler'].map { |s| File.expand_path("lib/#{s}.jar", scala_home) }
+        else
+          REQUIRES.artifacts.map(&:to_s)
+        end
+      end
+
+      def use_fsc
+        installed? && ENV["USE_FSC"] =~ /^(yes|on|true)$/i
+      end
+      
+      def applies_to?(project, task) #:nodoc:
+        paths = task.sources + [sources].flatten.map { |src| Array(project.path_to(:source, task.usage, src.to_sym)) }
+        paths.flatten!
+        
+        # Just select if we find .scala files
+        paths.any? { |path| !Dir["#{path}/**/*.scala"].empty? }
+      end
+    end
+    
+    Javac = Buildr::Compiler::Javac
+
+    OPTIONS = [:warnings, :deprecation, :optimise, :target, :debug, :other, :javac]
+    
+    Java.classpath << dependencies
+
+    specify :language=>:scala, :sources => [:scala, :java], :source_ext => [:scala, :java],
+            :target=>'classes', :target_ext=>'class', :packaging=>:jar
+
+    def initialize(project, options) #:nodoc:
+      super
+      options[:debug] = Buildr.options.debug if options[:debug].nil?
+      options[:warnings] = verbose if options[:warnings].nil?
+      options[:deprecation] ||= false
+      options[:optimise] ||= false
+      options[:javac] ||= {}
+      
+      @java = Javac.new(project, options[:javac])
+    end
+
+    def compile(sources, target, dependencies) #:nodoc:
+      check_options options, OPTIONS
+
+      cmd_args = []
+      cmd_args << '-classpath' << (dependencies + Scalac.dependencies).join(File::PATH_SEPARATOR)
+      source_paths = sources.select { |source| File.directory?(source) }
+      cmd_args << '-sourcepath' << source_paths.join(File::PATH_SEPARATOR) unless source_paths.empty?
+      cmd_args << '-d' << File.expand_path(target)
+      cmd_args += scalac_args
+      cmd_args += files_from_sources(sources)
+
+      unless Buildr.application.options.dryrun
+        trace((['scalac'] + cmd_args).join(' '))
+        
+        if Scalac.use_fsc
+          system(([File.expand_path('bin/fsc', Scalac.scala_home)] + cmd_args).join(' ')) or
+            fail 'Failed to compile, see errors above'
+        else
+          Java.load
+          begin
+            Java.scala.tools.nsc.Main.process(cmd_args.to_java(Java.java.lang.String))
+          rescue => e
+            fail "Scala compiler crashed:\n#{e.inspect}" 
+          end
+          fail 'Failed to compile, see errors above' if Java.scala.tools.nsc.Main.reporter.hasErrors
+        end
+ 
+        java_sources = java_sources(sources)
+        unless java_sources.empty?
+          trace 'Compiling mixed Java/Scala sources'
+          
+          # TODO  includes scala-compiler.jar
+          deps = dependencies + Scalac.dependencies + [ File.expand_path(target) ]
+          @java.compile(java_sources, target, deps)
+        end
+      end
+    end
+
+  private
+
+    def java_sources(sources)
+      sources.flatten.map { |source| File.directory?(source) ? FileList["#{source}/**/*.java"] : source } .
+        flatten.reject { |file| File.directory?(file) || File.extname(file) != '.java' }.map { |file| File.expand_path(file) }.uniq
+    end
+
+    # Returns Scalac command line arguments from the set of options.
+    def scalac_args #:nodoc:
+      args = []
+      args << "-nowarn" unless options[:warnings]
+      args << "-verbose" if Buildr.application.options.trace
+      args << "-g" if options[:debug]
+      args << "-deprecation" if options[:deprecation]
+      args << "-optimise" if options[:optimise]
+      args << "-target:jvm-" + options[:target].to_s if options[:target]
+      args + Array(options[:other])
+    end
+
+  end
+    
+end
+
+# Scala compiler comes first, ahead of Javac, this allows it to pick
+# projects that mix Scala and Java code by spotting Scala code first.
+Buildr::Compiler.compilers.unshift Buildr::Scala::Scalac

data/lib/buildr/scala/org/apache/buildr/SpecsSingletonRunner.scala

@@ -0,0 +1,35 @@
+package org.apache.buildr
+
+import java.net.{URL, URLClassLoader}
+import java.io.File
+
+/**
+ * @author Daniel Spiewak
+ */
+object SpecsSingletonRunner {
+  type Spec = { def main(args: Array[String]) }
+  
+  // Incompatible with JVM 1.4 target
+  // @throws(classOf[Throwable])
+  def main(args: Array[String]) {
+    val (colors, spec) = if (args.length > 1 && args(1) == "-c")
+      (true, args(2))
+    else
+      (false, args(1))
+    
+    run(args(0), colors, spec)
+  }
+  
+  // Incompatible with JVM 1.4 target
+  // @throws(classOf[Throwable])
+  def run(path: String, colors: Boolean, spec: String) = {
+    val parent = new File(path)
+    val specURL = new File(parent, spec.replace('.', '/') + ".class").toURL
+    val loader = new URLClassLoader(Array(specURL), getClass.getClassLoader)
+    
+    val clazz = loader.loadClass(spec)
+    val instance = clazz.getField("MODULE$").get(null).asInstanceOf[Spec]
+    
+    instance.main(if (colors) Array("-c") else Array())
+  }
+}

data/lib/buildr/scala/shell.rb

@@ -0,0 +1,55 @@
+# 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 'buildr/shell'
+require 'buildr/java/commands'
+
+module Buildr
+  module Scala
+    class ScalaShell < Buildr::Shell::Base
+      include Buildr::Shell::JavaRebel
+      
+      class << self
+        def lang
+          :scala
+        end
+        
+        def to_sym
+          :scala
+        end
+      end
+      
+      def launch
+        cp = project.compile.dependencies + 
+          Scalac.dependencies +
+          [project.path_to(:target, :classes)]
+        
+        props = {
+          'env.classpath' => cp.join(File::PATH_SEPARATOR),
+          'scala.home' => Scalac.scala_home
+        }
+        
+        Java::Commands.java 'scala.tools.nsc.MainGenericRunner', {
+          :properties => props.merge(rebel_props(project)),
+          :classpath => cp,
+          :java_args => rebel_args
+        }
+      end
+    end
+  end
+end
+
+Buildr::ShellProviders << Buildr::Scala::ScalaShell

data/lib/buildr/scala/tests.rb

@@ -0,0 +1,157 @@
+# 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 'buildr/core/build'
+require 'buildr/core/compile'
+require 'buildr/java/ant'
+require 'buildr/java/tests'
+
+
+module Buildr::Scala
+  # Scala::Check is available when using Scala::Test or Scala::Specs
+  module Check
+    VERSION = '1.5'
+    
+    class << self
+      def version
+        Buildr.settings.build['scala.check'] || VERSION
+      end
+      
+      def dependencies
+        ["org.scala-tools.testing:scalacheck:jar:#{version}"]
+      end  
+
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use Scala::Check.dependencies/.version instead of ScalaCheck::REQUIRES/VERSION"
+        dependencies
+      end
+    end
+  end
+  
+  
+  # ScalaTest framework, the default test framework for Scala tests.
+  #
+  # Support the following options:
+  # * :properties  -- Hash of system properties available to the test case.
+  # * :environment -- Hash of environment variables available to the test case.
+  # * :java_args   -- Arguments passed as is to the JVM.
+  class ScalaTest < Buildr::TestFramework::Java
+
+    VERSION = '0.9.5'
+
+    class << self
+      def version
+        Buildr.settings.build['scala.test'] || VERSION
+      end
+      
+      def dependencies
+        ["org.scala-tools.testing:scalatest:jar:#{version}"] + Check.dependencies + 
+          JMock.dependencies + JUnit.dependencies
+      end  
+
+      def applies_to?(project) #:nodoc:
+        !Dir[project.path_to(:source, :test, :scala, '**/*.scala')].empty?
+      end 
+      
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use Scala::Test.dependencies/.version instead of ScalaTest::REQUIRES/VERSION"
+        dependencies
+      end
+    end          
+
+    # annotation-based group inclusion
+    attr_accessor :group_includes
+    
+    # annotation-based group exclusion
+    attr_accessor :group_excludes
+    
+    def initialize(test_task, options)
+      super
+      @group_includes = []
+      @group_excludes = []
+    end
+
+    def tests(dependencies) #:nodoc:
+      filter_classes(dependencies, :interfaces => %w{org.scalatest.Suite})
+    end
+
+    def run(scalatest, dependencies) #:nodoc:
+      mkpath task.report_to.to_s
+      success = []
+
+      reporter_options = 'TFGBSAR' # testSucceeded, testFailed, testIgnored, suiteAborted, runStopped, runAborted, runCompleted
+      scalatest.each do |suite|
+        info "ScalaTest #{suite.inspect}"
+        # Use Ant to execute the ScalaTest task, gives us performance and reporting.
+        reportFile = File.join(task.report_to.to_s, "TEST-#{suite}.txt")
+        taskdef = Buildr.artifacts(self.class.dependencies).each(&:invoke).map(&:to_s)
+        Buildr.ant('scalatest') do |ant|
+          ant.taskdef :name=>'scalatest', :classname=>'org.scalatest.tools.ScalaTestTask',
+            :classpath=>taskdef.join(File::PATH_SEPARATOR)
+          ant.scalatest :runpath=>dependencies.join(File::PATH_SEPARATOR) do
+            ant.suite    :classname=>suite
+            ant.reporter :type=>'stdout', :config=>reporter_options
+            ant.reporter :type=>'file', :filename=> reportFile, :config=>reporter_options
+            # TODO: This should be name=>value pairs!
+            #ant.includes group_includes.join(" ") if group_includes
+            #ant.excludes group_excludes.join(" ") if group_excludes
+            (options[:properties] || []).each { |name, value| ant.property :name=>name, :value=>value }
+          end
+        end
+        
+        # Parse for failures, errors, etc.
+        # This is a bit of a pain right now because ScalaTest doesn't flush its
+        # output synchronously before the Ant test finishes so we have to loop 
+        # and wait for an indication that the test run was completed. 
+        failed = false
+        completed = false
+        wait = 0
+        while (!completed) do
+          File.open(reportFile, "r") do |input|
+            while (line = input.gets) do
+              failed = (line =~ /(TESTS? FAILED -)|(RUN STOPPED)|(RUN ABORTED)/) unless failed
+              completed |= (line =~ /Run completed\./)
+              break if (failed)
+            end
+          end
+          wait += 1
+          break if (failed || wait > 10) 
+          unless completed
+            sleep(1)
+          end
+        end
+        success << suite if (completed && !failed)
+      end
+      
+      success
+    end # run
+
+  end # ScalaTest
+  
+end
+
+
+# Backwards compatibility stuff.  Remove in 1.5.
+module Buildr
+  ScalaCheck = Scala::Check
+  ScalaTest = Scala::ScalaTest
+end
+
+Buildr::TestFramework << Buildr::Scala::ScalaTest