buildr-gemjar 1.0.0

data/vendor/buildr/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/vendor/buildr/lib/buildr/scala/shell.rb

@@ -0,0 +1,52 @@
+# 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::JRebel
+
+      specify :name => :scala, :languages => [:scala]
+
+      def launch(task)
+        jline = [File.expand_path("lib/jline.jar", Scalac.scala_home)].find_all { |f| File.exist? f }
+        jline = ['jline:jline:jar:0.9.94'] if jline.empty?
+
+        cp = project.compile.dependencies +
+             Scalac.dependencies +
+             [ project.path_to(:target, :classes) ] +
+             task.classpath
+
+        java_args = jrebel_args + task.java_args
+
+        props = jrebel_props(project).merge(task.properties)
+
+        Java::Commands.java 'scala.tools.nsc.MainGenericRunner',
+                            '-cp', cp.join(File::PATH_SEPARATOR),
+        {
+          :properties => props,
+          :classpath => cp + jline,
+          :java_args => java_args
+        }
+      end
+    end
+  end
+end
+
+Buildr::Shell.providers << Buildr::Scala::ScalaShell

data/vendor/buildr/lib/buildr/scala/tests.rb

@@ -0,0 +1,171 @@
+# 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.8'
+
+    class << self
+      def version
+        Buildr.settings.build['scala.check'] || VERSION
+      end
+
+      def classifier
+        Buildr.settings.build['scala.check.classifier'] || ""
+      end
+
+      def artifact
+        Buildr.settings.build['scala.check.artifact'] || "scalacheck_#{Buildr::Scala.version}"
+      end
+
+      def dependencies
+        (version =~ /:/) ? [version] : ["org.scala-tools.testing:#{artifact}:jar:#{classifier}:#{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 = '1.2'
+
+    class << self
+      def version
+        Buildr.settings.build['scala.test'] || VERSION
+      end
+
+      def dependencies
+        ["org.scalatest: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.
+        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|
+          # ScalaTestTask was deprecated in 1.2, in favor of ScalaTestAntTask
+          classname = (ScalaTest.version =~ /1\.[01]/) ? \
+            'org.scalatest.tools.ScalaTestTask' : 'org.scalatest.tools.ScalaTestAntTask'
+          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
+            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.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.
+        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

data/vendor/buildr/lib/buildr/shell.rb

@@ -0,0 +1,185 @@
+# 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.
+
+
+module Buildr
+  module Shell
+    include Extension
+
+    class << self
+      def providers
+        @providers ||= []
+      end
+
+      def select_by_lang(lang)
+        fail 'Unable to define shell task for nil language' if lang.nil?
+        providers.detect { |e| e.languages.nil? ? false : e.languages.include?(lang.to_sym) }
+      end
+
+      alias_method :select, :select_by_lang
+
+      def select_by_name(name)
+        fail 'Unable to define run task for nil' if name.nil?
+        providers.detect { |e| e.to_sym == name.to_sym }
+      end
+
+      def define_task(project, name, provider = nil)
+        ShellTask.define_task(name).tap do |t|
+          t.send(:associate_with, project)
+          t.enhance([project.compile]) do |t|
+            # double-enhance to execute the provider last
+            t.enhance { |t| t.run }
+          end
+          t.using provider.to_sym if provider
+        end
+      end
+    end
+
+    first_time do
+      Project.local_task 'shell'
+
+      providers.each { |provider| Project.local_task "shell:#{provider.to_sym}" }
+    end
+
+    before_define(:shell => :compile) do |project|
+      define_task(project, "shell")
+      providers.each { |provider| define_task(project, "shell:#{provider.to_sym}", provider) }
+    end
+
+    after_define(:shell => :compile) do |project|
+      unless project.shell.provider
+        provider = providers.find { |p| p.languages.include? project.compile.language if p.languages }
+        if provider
+          project.shell.using provider.to_sym
+          project.shell.with project.test.compile.dependencies
+        end
+      end
+    end
+
+    # Base class for any shell provider.
+    class Base
+      attr_reader :project # :nodoc:
+
+      class << self
+        attr_accessor :shell_name, :languages
+
+        def specify(options)
+          @shell_name ||= options[:name]
+          @languages ||= options[:languages]
+        end
+
+        def to_sym
+          @shell_name || name.split('::').last.downcase.to_sym
+        end
+      end
+
+      def initialize(project)
+        @project = project
+      end
+
+      def launch(task)
+        fail 'Not implemented'
+      end
+
+    end
+
+    class ShellTask < Rake::Task
+      attr_reader :project # :nodoc:
+
+      # Classpath dependencies.
+      attr_accessor :classpath
+
+      # Returns the run options.
+      attr_reader :options
+
+      # Underlying shell provider
+      attr_reader :provider
+
+      def initialize(*args) # :nodoc:
+        super
+        @options = {}
+        @classpath = []
+      end
+
+      # :call-seq:
+      #   with(*artifacts) => self
+      #
+      # Adds files and artifacts as classpath dependencies, and returns self.
+      def with(*specs)
+        @classpath |= Buildr.artifacts(specs.flatten).uniq
+        self
+      end
+
+      # :call-seq:
+      #   using(options) => self
+      #
+      # Sets the run options from a hash and returns self.
+      #
+      # For example:
+      #   shell.using :properties => {'foo' => 'bar'}
+      #   shell.using :bsh
+      def using(*args)
+        if Hash === args.last
+          args.pop.each { |key, value| @options[key.to_sym] = value }
+        end
+
+        until args.empty?
+          new_shell = Shell.select_by_name(args.pop)
+          @provider = new_shell.new(project) unless new_shell.nil?
+        end
+
+        self
+      end
+
+      def run
+        fail "No shell provider defined in project '#{project.name}' for language '#{project.compile.language.inspect}'" unless provider
+        provider.launch(self)
+      end
+
+      def prerequisites #:nodoc:
+        super + classpath
+      end
+
+      def java_args
+        @options[:java_args] || (ENV['JAVA_OPTS'] || ENV['JAVA_OPTIONS']).to_s.split
+      end
+
+      def properties
+        @options[:properties] || {}
+      end
+
+    private
+      def associate_with(project)
+        @project ||= project
+      end
+
+    end
+
+    # :call-seq:
+    #   shell(&block) => ShellTask
+    #
+    # This method returns the project's shell task. It also accepts a block to be executed
+    # when the shell task is invoked.
+    def shell(&block)
+      task('shell').tap do |t|
+        t.enhance &block if block
+      end
+    end
+  end
+
+  class Project
+    include Shell
+  end
+end