buildr 1.3.5-x86-mswin32 → 1.4.0-x86-mswin32

data/lib/buildr/scala/compiler.rb

@@ -19,30 +19,52 @@ require 'buildr/core/compile'
 require 'buildr/packaging'
 
 module Buildr::Scala
-  DEFAULT_VERSION = '2.7.5'   # currently the latest (Jun 19, 2009)
-  
+  DEFAULT_VERSION = '2.7.7'   # currently the latest (Oct 31, 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
+      warn "Use of Scala.version_str is deprecated.  Use Scala.version instead"
+      version
+    end
+
+    def installed_version
+      unless @installed_version
+        @installed_version = if Scalac.installed?
+          begin
+            # try to read the value from the properties file
+            props = Zip::ZipFile.open(File.expand_path('lib/scala-library.jar', Scalac.scala_home)) do |zipfile|
+              zipfile.read 'library.properties'
+            end
+
+            version_str = props.match(/version\.number\s*=\s*([^\s]+)/).to_a[1]
+
+            if version_str
+              md = version_str.match(/\d+\.\d[\d\.]*/) or
+                fail "Unable to parse Scala version: #{version_str}"
+
+              md[0].sub(/.$/, "") # remove trailing dot, if any
+            end
+          rescue => e
+            warn "Unable to parse library.properties in $SCALA_HOME/lib/scala-library.jar: #{e}"
+            nil
+          end
+        end
       end
+
+      @installed_version
     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
+      Buildr.settings.build['scala.version'] || installed_version || DEFAULT_VERSION
+    end
+
+    def compatible_28?
+      major, minor = version.match(/^(\d)\.(\d)/).to_a[1,2]
+      if major && minor
+        (major.to_i == 2 && minor.to_i >= 8) || (major.to_i > 2)
       else
-        DEFAULT_VERSION       # TODO return the version installed from Maven repo
+        false
       end
     end
   end
@@ -60,7 +82,7 @@ module Buildr::Scala
   # * :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
     #
@@ -69,27 +91,36 @@ module Buildr::Scala
     # 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
+      version = Buildr.settings.build['scala.version'] || DEFAULT_VERSION
+      ns.library!      'org.scala-lang:scala-library:jar:>=' + version
+      ns.compiler!     'org.scala-lang:scala-compiler:jar:>=' + 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 use_installed?
+        if installed? && Buildr.settings.build['scala.version']
+          Buildr.settings.build['scala.version'] == Scala.installed_version
+        else
+          Buildr.settings.build['scala.version'].nil? && installed?
+        end
+      end
+
       def dependencies
-        if installed?
+        if use_installed?
           ['scala-library', 'scala-compiler'].map { |s| File.expand_path("lib/#{s}.jar", scala_home) }
         else
           REQUIRES.artifacts.map(&:to_s)
@@ -97,23 +128,24 @@ module Buildr::Scala
       end
 
       def use_fsc
-        installed? && ENV["USE_FSC"] =~ /^(yes|on|true)$/i
+        use_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
+
+    # Lazy evaluation to allow change in buildfile
+    Java.classpath << lambda { dependencies }
 
     specify :language=>:scala, :sources => [:scala, :java], :source_ext => [:scala, :java],
             :target=>'classes', :target_ext=>'class', :packaging=>:jar
@@ -124,25 +156,41 @@ module Buildr::Scala
       options[:warnings] = verbose if options[:warnings].nil?
       options[:deprecation] ||= false
       options[:optimise] ||= false
+      options[:make] ||= :transitivenocp if Scala.compatible_28?
       options[:javac] ||= {}
-      
+
       @java = Javac.new(project, options[:javac])
     end
 
     def compile(sources, target, dependencies) #:nodoc:
-      check_options options, OPTIONS
+      check_options(options, OPTIONS + (Scala.compatible_28? ? [:make] : []))
+
+      java_sources = java_sources(sources)
+      enable_dep_tracing = Scala.compatible_28? && java_sources.empty?
+
+      dependencies.unshift target if enable_dep_tracing
 
       cmd_args = []
-      cmd_args << '-classpath' << (dependencies + Scalac.dependencies).join(File::PATH_SEPARATOR)
+      cmd_args << '-classpath' << 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
+
+      if enable_dep_tracing
+        dep_dir = File.expand_path(target)
+        Dir.mkdir dep_dir unless File.exists? dep_dir
+
+        cmd_args << '-make:' + options[:make].to_s
+        cmd_args << '-dependencyfile'
+        cmd_args << File.expand_path('.scala-deps', dep_dir)
+      end
+
       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'
@@ -151,15 +199,14 @@ module Buildr::Scala
           begin
             Java.scala.tools.nsc.Main.process(cmd_args.to_java(Java.java.lang.String))
           rescue => e
-            fail "Scala compiler crashed:\n#{e.inspect}" 
+            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)
@@ -187,7 +234,7 @@ module Buildr::Scala
     end
 
   end
-    
+
 end
 
 # Scala compiler comes first, ahead of Javac, this allows it to pick

data/lib/buildr/scala/doc.rb

@@ -0,0 +1,106 @@
+# 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/doc'
+require 'buildr/scala/compiler'   # ensure Scala dependencies are ready
+
+module Buildr
+  module Doc
+    class Scaladoc < Base
+      specify :language => :scala, :source_ext => 'scala'
+
+      def generate(sources, target, options = {})
+        cmd_args = [ '-d', target, Buildr.application.options.trace ? '-verbose' : '' ]
+        options.reject { |key, value| [:sourcepath, :classpath].include?(key) }.
+          each { |key, value| value.invoke if value.respond_to?(:invoke) }.
+          each do |key, value|
+            case value
+            when true, nil
+              cmd_args << "-#{key}"
+            when false
+              cmd_args << "-no#{key}"
+            when Hash
+              value.each { |k,v| cmd_args << "-#{key}" << k.to_s << v.to_s }
+            else
+              cmd_args += Array(value).map { |item| ["-#{key}", item.to_s] }.flatten
+            end
+          end
+        [:sourcepath, :classpath].each do |option|
+          Array(options[option]).flatten.tap do |paths|
+            cmd_args << "-#{option}" << paths.flatten.map(&:to_s).join(File::PATH_SEPARATOR) unless paths.empty?
+          end
+        end
+        cmd_args += sources.flatten.uniq
+        unless Buildr.application.options.dryrun
+          info "Generating Scaladoc for #{project.name}"
+          trace (['scaladoc'] + cmd_args).join(' ')
+          Java.load
+          Java.scala.tools.nsc.ScalaDoc.main(cmd_args.to_java(Java.java.lang.String)) == 0 or
+            fail 'Failed to generate Scaladocs, see errors above'
+        end
+      end
+    end
+
+    class VScaladoc < Base
+      VERSION = '1.2-SNAPSHOT'
+      Buildr.repositories.remote << 'http://scala-tools.org/repo-snapshots'
+
+      class << self
+        def dependencies
+          [ "org.scala-tools:vscaladoc:jar:#{VERSION}" ]
+        end
+      end
+
+      Java.classpath << dependencies
+
+      specify :language => :scala, :source_ext => 'scala'
+
+      def generate(sources, target, options = {})
+        cmd_args = [ '-d', target, (Buildr.application.options.trace ? '-verbose' : ''),
+          '-sourcepath', project.compile.sources.join(File::PATH_SEPARATOR) ]
+        options.reject { |key, value| [:sourcepath, :classpath].include?(key) }.
+          each { |key, value| value.invoke if value.respond_to?(:invoke) }.
+          each do |key, value|
+            case value
+            when true, nil
+              cmd_args << "-#{key}"
+            when false
+              cmd_args << "-no#{key}"
+            when Hash
+              value.each { |k,v| cmd_args << "-#{key}" << k.to_s << v.to_s }
+            else
+              cmd_args += Array(value).map { |item| ["-#{key}", item.to_s] }.flatten
+            end
+          end
+        [:sourcepath, :classpath].each do |option|
+          Array(options[option]).flatten.tap do |paths|
+            cmd_args << "-#{option}" << paths.flatten.map(&:to_s).join(File::PATH_SEPARATOR) unless paths.empty?
+          end
+        end
+        cmd_args += sources.flatten.uniq
+        unless Buildr.application.options.dryrun
+          info "Generating VScaladoc for #{project.name}"
+          trace (['vscaladoc'] + cmd_args).join(' ')
+          Java.load
+          Java.org.scala_tools.vscaladoc.Main.main(cmd_args.to_java(Java.java.lang.String)) == 0 or
+            fail 'Failed to generate VScaladocs, see errors above'
+        end
+      end
+    end
+  end
+end
+
+Buildr::Doc.engines << Buildr::Doc::Scaladoc
+Buildr::Doc.engines << Buildr::Doc::VScaladoc

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

@@ -0,0 +1,57 @@
+/* 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.
+ */
+
+package org.apache.buildr;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.io.File;
+
+/**
+ * @author Daniel Spiewak
+ */
+public class SpecsSingletonRunner {
+  // Incompatible with JVM 1.4 target
+  // @throws(classOf[Throwable])
+  public static void main(String[] args) {
+      boolean colors = (args.length > 1 && args[1].equals("-c"));
+      String spec = colors ? args[2] : args[1];
+
+      run(args[0], colors, spec);
+  }
+
+  // Incompatible with JVM 1.4 target
+  // @throws(classOf[Throwable])
+  static void run(String path, boolean colors, String spec) {
+      try {
+          File parent = new File(path);
+          URL specURL = new File(parent, spec.replace('.', '/') + ".class").toURL();
+          URLClassLoader loader = new URLClassLoader(new URL[] { specURL }, Thread.currentThread().getContextClassLoader());
+
+          Class clazz = loader.loadClass(spec);
+          Object instance = clazz.getField("MODULE$").get(null);
+
+          Method main = clazz.getMethod("main", String[].class);
+
+          String[] args = colors ? new String[] { "-c" } : new String[] {};
+          main.invoke(instance, new Object[] { args });
+      } catch (Exception e) {
+          throw new RuntimeException(e);
+      }
+  }
+}

data/lib/buildr/scala/shell.rb

@@ -21,30 +21,35 @@ 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 + 
+        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', {
+
+        jline = [File.expand_path("lib/jline.jar", Scalac.scala_home)].find_all do |f|
+          File.exist? f
+        end
+
+        Java::Commands.java 'scala.tools.nsc.MainGenericRunner',
+                            '-cp', cp.join(File::PATH_SEPARATOR),
+        {
           :properties => props.merge(rebel_props(project)),
-          :classpath => cp,
+          :classpath => Scalac.dependencies + jline,
           :java_args => rebel_args
         }
       end

data/lib/buildr/scala/tests.rb

@@ -23,16 +23,20 @@ require 'buildr/java/tests'
 module Buildr::Scala
   # Scala::Check is available when using Scala::Test or Scala::Specs
   module Check
-    VERSION = '1.5'
-    
+    VERSION = '1.6'
+
     class << self
       def version
         Buildr.settings.build['scala.check'] || VERSION
       end
-      
+
+      def classifier
+        Buildr.settings.build['scala.check.classifier'] || ""
+      end
+
       def dependencies
-        ["org.scala-tools.testing:scalacheck:jar:#{version}"]
-      end  
+        ["org.scala-tools.testing:scalacheck:jar:#{classifier}:#{version}"]
+      end
 
     private
       def const_missing(const)
@@ -42,8 +46,8 @@ module Buildr::Scala
       end
     end
   end
-  
-  
+
+
   # ScalaTest framework, the default test framework for Scala tests.
   #
   # Support the following options:
@@ -52,36 +56,36 @@ module Buildr::Scala
   # * :java_args   -- Arguments passed as is to the JVM.
   class ScalaTest < Buildr::TestFramework::Java
 
-    VERSION = '0.9.5'
+    VERSION = '1.0.1'
 
     class << self
       def version
         Buildr.settings.build['scala.test'] || VERSION
       end
-      
+
       def dependencies
-        ["org.scala-tools.testing:scalatest:jar:#{version}"] + Check.dependencies + 
+        ["org.scalatest:scalatest:jar:#{version}"] + Check.dependencies +
           JMock.dependencies + JUnit.dependencies
-      end  
+      end
 
       def applies_to?(project) #:nodoc:
         !Dir[project.path_to(:source, :test, :scala, '**/*.scala')].empty?
-      end 
-      
+      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          
+    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 = []
@@ -100,7 +104,8 @@ module Buildr::Scala
       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")
+        reportDir = task.report_to.to_s
+        reportFile = File.join(reportDir, "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',
@@ -109,42 +114,44 @@ module Buildr::Scala
             ant.suite    :classname=>suite
             ant.reporter :type=>'stdout', :config=>reporter_options
             ant.reporter :type=>'file', :filename=> reportFile, :config=>reporter_options
+            ant.reporter :type=>(ScalaTest.version == "1.0") ? "xml" : "junitxml",
+                         :directory=> reportDir, :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 }
+            (options[:properties] || []).each { |name, value| ant.config :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. 
+        # 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\./)
+              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) 
+          break if (failed || wait > 10)
           unless completed
             sleep(1)
           end
         end
         success << suite if (completed && !failed)
       end
-      
+
       success
     end # run
 
   end # ScalaTest
-  
+
 end