buildr 1.3.2 → 1.3.3

data/lib/buildr/java/groovyc.rb

@@ -1,137 +0,0 @@
-# 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 Compiler
-    # Groovyc compiler:
-    #  compile.using(:groovyc)
-    #
-    # You need to require 'buildr/java/groovyc' if you need to use this compiler.
-    #
-    # Used by default if .groovy files are found in the src/main/groovy directory (or src/test/groovy)
-    # and sets the target directory to target/classes (or target/test/classes).
-    #
-    # Groovyc is a joint compiler, this means that when selected for a project, this compiler is used
-    # to compile both groovy and java sources. It's recommended that Groovy sources are placed in the
-    # src/main/groovy directory, even though this compiler also looks in src/main/java
-    #
-    # Groovyc accepts the following options:
-    #
-    # * :encoding          -- Encoding of source files
-    # * :verbose           -- Asks the compiler for verbose output, true when running in verbose mode.
-    # * :fork              -- Whether to execute groovyc using a spawned instance of the JVM; defaults to no
-    # * :memoryInitialSize -- The initial size of the memory for the underlying VM, if using fork mode; ignored otherwise. 
-    #                                     Defaults to the standard VM memory setting. (Examples: 83886080, 81920k, or 80m)
-    # * :memoryMaximumSize -- The maximum size of the memory for the underlying VM, if using fork mode; ignored otherwise. 
-    #                                     Defaults to the standard VM memory setting. (Examples: 83886080, 81920k, or 80m)
-    # * :listfiles         -- Indicates whether the source files to be compiled will be listed; defaults to no
-    # * :stacktrace        -- If true each compile error message will contain a stacktrace
-    # * :warnings          -- Issue warnings when compiling.  True when running in verbose mode.
-    # * :debug             -- Generates bytecode with debugging information.  Set from the debug
-    #                                     environment variable/global option.
-    # * :deprecation       -- If true, shows deprecation messages.  False by default.
-    # * :optimise          -- Generates faster bytecode by applying optimisations to the program.
-    # * :source            -- Source code compatibility.
-    # * :target            -- Bytecode compatibility.
-    # * :javac             -- Hash of options passed to the ant javac task
-    #
-    class Groovyc < Base
-      
-      # The groovyc 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::Groovyc'].groovy = '1.5.4'
-      #
-      # namespace before this file is required.
-      REQUIRES = ArtifactNamespace.for(self) do |ns|
-        ns.groovy!       'org.codehaus.groovy:groovy:jar:>=1.5.3'
-        ns.commons_cli!  'commons-cli:commons-cli:jar:>=1.0'
-        ns.asm!          'asm:asm:jar:>=2.2'
-        ns.antlr!        'antlr:antlr:jar:>=2.7.7'
-      end
-      
-      ANT_TASK = 'org.codehaus.groovy.ant.Groovyc'
-      GROOVYC_OPTIONS = [:encoding, :verbose, :fork, :memoryInitialSize, :memoryMaximumSize, :listfiles, :stacktrace]
-      JAVAC_OPTIONS = [:optimise, :warnings, :debug, :deprecation, :source, :target, :javac]
-      OPTIONS = GROOVYC_OPTIONS + JAVAC_OPTIONS
-
-      class << self
-        def dependencies #:nodoc:
-          REQUIRES.artifacts
-        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 .groovy files
-          paths.any? { |path| !Dir["#{path}/**/*.groovy"].empty? }
-        end
-      end
-      
-      Java.classpath << dependencies
-      
-      specify :language => :groovy, :sources => [:groovy, :java], :source_ext => [:groovy, :java], 
-              :target => 'classes', :target_ext => 'class', :packaging => :jar
-
-      def initialize(project, options) #:nodoc:
-        super
-        options[:debug] = Buildr.options.debug if options[:debug].nil?
-        options[:deprecation] ||= false
-        options[:optimise] ||= false
-        options[:verbose] ||= Buildr.application.options.trace if options[:verbose].nil?
-        options[:warnings] = verbose if options[:warnings].nil?
-        options[:javac] = OpenObject.new if options[:javac].nil?
-      end
-
-      # http://groovy.codehaus.org/The+groovyc+Ant+Task
-      def compile(sources, target, dependencies) #:nodoc:
-        return if Buildr.application.options.dryrun
-        Buildr.ant 'groovyc' do |ant|
-          classpath = dependencies | self.class.dependencies.map(&:to_s)
-          ant.taskdef :name => 'groovyc', :classname => ANT_TASK, :classpath => classpath.join(File::PATH_SEPARATOR)
-          ant.groovyc groovyc_options(sources, target) do
-            sources.each { |src| ant.src :path => src }
-            ant.classpath do
-              classpath.each { |dep| ant.pathelement :path => dep }
-            end
-            ant.javac(javac_options)
-          end
-        end
-      end
-
-     private 
-      def groovyc_options(sources, target)
-        check_options options, OPTIONS
-        groovyc_options = options.to_hash.only(*GROOVYC_OPTIONS)
-        groovyc_options[:destdir] = File.expand_path(target)
-        groovyc_options
-      end
-
-      def javac_options
-        check_options options, OPTIONS
-        javac_options = options.to_hash.only(*JAVAC_OPTIONS)
-        javac_options[:optimize] = (javac_options.delete(:optimise) || false)
-        javac_options[:nowarn] = (javac_options.delete(:warnings) || verbose).to_s !~ /^(true|yes|on)$/i
-        other = javac_options.delete(:javac) || {}
-        javac_options.merge!(other)
-        javac_options
-      end
-      
-    end
-  end
-end
-
-Buildr::Compiler.compilers.unshift Buildr::Compiler::Groovyc

data/lib/buildr/java/test_frameworks.rb

@@ -1,450 +0,0 @@
-# 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'
-
-module Buildr
-
-  class TestFramework
-    module JavaTest
-
-      # Add buildr utilities (JavaTestFilter) to classpath
-      Java.classpath << File.join(File.dirname(__FILE__))
-
-      def self.included(mod)
-        super
-        mod.extend ClassMethods
-      end
-
-      private
-      # :call-seq:
-      #     filter_classes(dependencies, criteria)
-      # 
-      # Return a list of classnames that match the given criteria. 
-      # The criteria parameter is a hash that must contain at least one of:
-      #
-      # * :class_names -- List of patterns to match against class name
-      # * :interfaces -- List of java interfaces or java classes
-      # * :class_annotations -- List of annotations on class level
-      # * :method_annotations -- List of annotations on method level
-      #
-      def filter_classes(dependencies, criteria = {})
-        return [] unless task.compile.target
-        target = task.compile.target.to_s
-        candidates = Dir["#{target}/**/*.class"].
-          map { |file| Util.relative_path(file, target).ext('').gsub(File::SEPARATOR, '.') }.
-          reject { |name| name =~ /\$/ }
-        result = []
-        if criteria[:class_names]
-          result.concat candidates.select { |name| criteria[:class_names].flatten.any? { |pat| pat === name } }
-        end
-        begin
-          Java.load
-          filter = Java.org.apache.buildr.JavaTestFilter.new(dependencies.to_java(Java.java.lang.String))
-          if criteria[:interfaces]
-            filter.add_interfaces(criteria[:interfaces].to_java(Java.java.lang.String)) 
-          end
-          if criteria[:class_annotations]
-            filter.add_class_annotations(criteria[:class_annotations].to_java(Java.java.lang.String))
-          end
-          if criteria[:method_annotations]
-            filter.add_method_annotations(criteria[:method_annotations].to_java(Java.java.lang.String))
-          end
-          result.concat filter.filter(candidates.to_java(Java.java.lang.String)).map(&:to_s)
-        rescue =>ex
-          puts "#{ex.class}: #{ex.message}" if verbose
-          raise
-        end
-        result.uniq
-      end
-      
-      module ClassMethods
-        def applies_to?(project) #:nodoc:
-          project.test.compile.language == :java
-        end        
-      end
-      
-    end
-  end
-
-  # JMock is available when using JUnit and TestNG, JBehave.
-  module JMock
-    # JMock version.
-    VERSION = '1.2.0' unless const_defined?('VERSION')
-    # JMock specification.
-    REQUIRES = ["jmock:jmock:jar:#{VERSION}"]
-  end
-
-  # Specs is available when using ScalaTest
-  module ScalaSpecs
-    # Specs version number.
-    VERSION = '1.2.9' unless const_defined?('VERSION')
-    # Specs artifact(s)
-    REQUIRES = ["org.specs:specs:jar:#{VERSION}"]
-  end
-
-  # ScalaCheck is available when using ScalaTest
-  module ScalaCheck
-    # ScalaCheck version number.
-    VERSION = '1.3' unless const_defined?('VERSION')
-    # ScalaCheck artifact(s)
-    REQUIRES = ["org.scalacheck:scalacheck:jar:#{VERSION}"]
-  end
-  
-  # JUnit test framework, the default test framework for Java tests.
-  #
-  # Support the following options:
-  # * :fork        -- If true/:once (default), fork for each test class.  If :each, fork for each individual
-  #                   test case.  If false, run all tests in the same VM (fast, but dangerous).
-  # * :clonevm     -- If true clone the VM each time it is forked.
-  # * :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 JUnit < TestFramework::Base
-
-    # Used by the junit:report task. Access through JUnit#report if you want to set various
-    # options for that task, for example:
-    #   JUnit.report.frames = false
-    class Report
-
-      # Ant-Trax required for running the JUnitReport task.
-      Java.classpath << "org.apache.ant:ant-trax:jar:#{Ant::VERSION}"
-
-      # Parameters passed to the Ant JUnitReport task.
-      attr_reader :params
-      # True (default) to produce a report using frames, false to produce a single-page report.
-      attr_accessor :frames
-      # Directory for the report style (defaults to using the internal style).
-      attr_accessor :style_dir
-      # Target directory for generated report.
-      attr_accessor :target
-
-      def initialize
-        @params = {}
-        @frames = true
-        @target = 'reports/junit'
-      end
-
-      # :call-seq:
-      #   generate(projects, target?)
-      #
-      # Generates a JUnit report for these projects (must run JUnit tests first) into the
-      # target directory. You can specify a target, or let it pick the default one from the
-      # target attribute.
-      def generate(projects, target = @target.to_s)
-        html_in = File.join(target, 'html')
-        rm_rf html_in ; mkpath html_in
-        
-        Buildr.ant('junit-report') do |ant|
-          ant.junitreport :todir=>target do
-            projects.select { |project| project.test.framework == :junit }.
-              map { |project| project.test.report_to.to_s }.select { |path| File.exist?(path) }.
-              each { |path| ant.fileset(:dir=>path) { ant.include :name=>'TEST-*.xml' }  }
-            options = { :format=>frames ? 'frames' : 'noframes' }
-            options[:styledir] = style_dir if style_dir
-            ant.report options.merge(:todir=>html_in) do
-              params.each { |key, value| ant.param :name=>key, :expression=>value }
-            end
-          end
-        end
-      end
-
-    end
-
-    class << self
-
-      # :call-seq:
-      #    report()
-      #
-      # Returns the Report object used by the junit:report task. You can use this object to set
-      # various options that affect your report, for example:
-      #   JUnit.report.frames = false
-      #   JUnit.report.params['title'] = 'My App'
-      def report
-        @report ||= Report.new
-      end
-
-    end
-
-    # JUnit version number.
-    VERSION = '4.4' unless const_defined?('VERSION')
-    
-    REQUIRES = ["junit:junit:jar:#{VERSION}"] + JMock::REQUIRES
-
-    # Ant-JUnit requires for JUnit and JUnit reports tasks.
-    Java.classpath << "org.apache.ant:ant-junit:jar:#{Ant::VERSION}"
-
-    include TestFramework::JavaTest
-    
-    def tests(dependencies) #:nodoc:
-      filter_classes(dependencies, 
-                     :interfaces => %w{junit.framework.TestCase},
-                     :class_annotations => %w{org.junit.runner.RunWith},
-                     :method_annotations => %w{org.junit.Test})
-    end
-
-    def run(tests, dependencies) #:nodoc:
-      # Use Ant to execute the Junit tasks, gives us performance and reporting.
-      Buildr.ant('junit') do |ant|
-        case options[:fork]
-        when false
-          forking = {}
-        when :each
-          forking = { :fork=>true, :forkmode=>'perTest' }
-        when true, :once
-          forking = { :fork=>true, :forkmode=>'once' }
-        else
-          fail 'Option fork must be :once, :each or false.'
-        end
-        mkpath task.report_to.to_s
-        ant.junit forking.merge(:clonevm=>options[:clonevm] || false, :dir=>task.send(:project).path_to) do
-          ant.classpath :path=>dependencies.join(File::PATH_SEPARATOR)
-          (options[:properties] || []).each { |key, value| ant.sysproperty :key=>key, :value=>value }
-          (options[:environment] || []).each { |key, value| ant.env :key=>key, :value=>value }
-          Array(options[:java_args]).each { |value| ant.jvmarg :value=>value }
-          ant.formatter :type=>'plain'
-          ant.formatter :type=>'plain', :usefile=>false # log test
-          ant.formatter :type=>'xml'
-          ant.batchtest :todir=>task.report_to.to_s, :failureproperty=>'failed' do
-            ant.fileset :dir=>task.compile.target.to_s do
-              tests.each { |test| ant.include :name=>File.join(*test.split('.')).ext('class') }
-            end
-          end
-        end
-        return tests unless ant.project.getProperty('failed')
-      end
-      # But Ant doesn't tell us what went kaput, so we'll have to parse the test files.
-      tests.inject([]) do |passed, test|
-        report_file = File.join(task.report_to.to_s, "TEST-#{test}.txt")
-        if File.exist?(report_file)
-          report = File.read(report_file)
-          # The second line (if exists) is the status line and we scan it for its values.
-          status = (report.split("\n")[1] || '').scan(/(run|failures|errors):\s*(\d+)/i).
-            inject(Hash.new(0)) { |hash, pair| hash[pair[0].downcase.to_sym] = pair[1].to_i ; hash }
-          passed << test if status[:failures] == 0 && status[:errors] == 0
-        end
-        passed
-      end
-    end
-
-    namespace 'junit' do
-      desc "Generate JUnit tests report in #{report.target}"
-      task('report') do |task|
-        report.generate Project.projects
-        puts "Generated JUnit tests report in #{report.target}" if verbose
-      end
-    end
-
-    task('clean') { rm_rf report.target.to_s }
-
-  end
-
-
-  # TestNG test framework.  To use in your project:
-  #   test.using :testng
-  #
-  # Support the following options:
-  # * :properties -- Hash of properties passed to the test suite.
-  # * :java_args -- Arguments passed to the JVM.
-  class TestNG < TestFramework::Base
-
-    # TestNG version number.
-    VERSION = '5.7' unless const_defined?('VERSION')
-    # TestNG specification.
-    REQUIRES = ["org.testng:testng:jar:jdk15:#{VERSION}"] + JMock::REQUIRES
-
-    include TestFramework::JavaTest
-
-    def tests(dependencies) #:nodoc:
-      filter_classes(dependencies, 
-                     :class_annotations => %w{org.testng.annotations.Test},
-                     :method_annotations => %w{org.testng.annotations.Test})
-    end
-
-    def run(tests, dependencies) #:nodoc:
-      cmd_args = [ 'org.testng.TestNG', '-sourcedir', task.compile.sources.join(';'), '-suitename', task.send(:project).name ]
-      cmd_args << '-d' << task.report_to.to_s
-      cmd_options = { :properties=>options[:properties], :java_args=>options[:java_args],
-                      :classpath=>dependencies }
-      tests.inject([]) do |passed, test|
-        begin
-          Java::Commands.java cmd_args, '-testclass', test, cmd_options.merge(:name=>test)
-          passed << test
-        rescue
-          passed
-        end
-      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 < TestFramework::Base
-    
-    class << self
-      # ScalaTest version number.
-      VERSION = '0.9.3' unless const_defined?('VERSION')
-
-      # ScalaTest dependencies
-      DEPENDS = ["org.scalatest:scalatest:jar:#{VERSION}"] + 
-                 JMock::REQUIRES + 
-                 ScalaSpecs::REQUIRES + 
-                 ScalaCheck::REQUIRES
-
-      ENABLED = DEPENDS.all? { |d| File.exist?(Buildr::Repositories.instance.locate(d)) } 
-
-      desc "Download Scala artifacts"
-      task "buildr:scala:download" do
-        ScalaTest.download_dependencies
-      end
-        
-      def required_artifacts
-        ENABLED ? DEPENDS : []
-      end
-      
-      def download_dependencies
-        DEPENDS.each { |d| Buildr.artifact(d).invoke }
-      end
-      
-      def applies_to?(project) #:nodoc:
-        if project.test.compile.language == :scala && !ENABLED
-          download_dependencies
-          fail "You must re-run buildr after downloading Scala artifacts for the first time"
-        end
-        project.test.compile.language == :scala
-      end  
-
-      def available?(artifact_spec) #:nodoc:
-        File.exist?(Buildr::Repositories.instance.locate(artifact_spec))
-      end
-    end
-
-    REQUIRES = required_artifacts
-    
-    # ScalaTest ant task
-    Java.classpath << "org.apache.ant:ant-junit:jar:#{Ant::VERSION}"
-    Java.classpath << REQUIRES
-
-    include TestFramework::JavaTest
-
-    # 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:
-      suites = filter_classes(dependencies, :interfaces => %w{org.scalatest.Suite})
-      # we should really filter using :class => %w{org.specs.Specification} instead of naming convention
-      specs = filter_classes(dependencies, :class_names => [/Specs?$/])
-      [suites, specs].flatten
-    end
-
-    def run(tests, dependencies) #:nodoc:
-      mkpath task.report_to.to_s
-      success = []
-      scalatest = tests.select { |t| t !~ /Specs?$/ }
-      specs = tests.select { |t| t =~ /Specs?$/ }
-
-      # Specs
-      #options = { :nostacktrace => false }.merge(options)
-      nostacktrace = (options[:nostacktrace]) ? "-ns" : ""
-      cmd_options = { :properties => options[:properties],
-                      :java_args => options[:java_args],
-                      :classpath => dependencies}
-      specs.each do |spec|
-        Java.load
-        begin
-          Java::Commands.java(spec, {:classpath => dependencies})
-        rescue => e
-          print e.message
-        else
-          success << spec
-        end
-      end
-
-      # ScalaTest
-      reporter_options = 'TFGBSAR' # testSucceeded, testFailed, testIgnored, suiteAborted, runStopped, runAborted, runCompleted
-      scalatest.each do |suite|
-        puts "ScalaTest #{suite.inspect}" if verbose
-        # Use Ant to execute the ScalaTest task, gives us performance and reporting.
-        reportFile = File.join(task.report_to.to_s, "TEST-#{suite}.txt")
-        Buildr.ant('scalatest') do |ant|
-          ant.taskdef :name=>'scalatest', :classname=>'org.scalatest.tools.ScalaTestTask'
-          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.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 =~ /(TEST FAILED -)|(RUN STOPPED)|(RUN ABORTED)/) unless failed
-              completed |= (line =~ /Run completed\./)
-              break if (failed || completed)
-            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 # Buildr
-
-
-Buildr::TestFramework << Buildr::JUnit
-Buildr::TestFramework << Buildr::TestNG
-Buildr::TestFramework << Buildr::ScalaTest
-
-# Backward compatibility crap.
-Buildr::JUnit::JUNIT_REQUIRES = Buildr::JUnit::REQUIRES
-Buildr::TestNG::TestNG_REQUIRES = Buildr::TestNG::REQUIRES
-Java::JUnit = Buildr::JUnit
-Java::TestNG = Buildr::TestNG