Buildr C0 Coverage Information - RCov

 # 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/java/tests'

 module Buildr

   # Mixin for test frameworks using src/spec/{lang}

   class TestFramework::JavaBDD < TestFramework::Java #:nodoc:

     class << self

     def initialize(task, options)

       project = task.project

       project.task('test:compile').tap do |comp|

         comp.send :associate_with, project, bdd_dir

         self.lang = comp.language || self.class.lang

       end

       project.task('test:resources').tap do |res|

         res.send :associate_with, project, bdd_dir

         res.filter.clear

         project.path_to(:source, bdd_dir, :resources).tap { |dir| res.from dir if File.exist?(dir) }

       end

       super

     end

   end

   module TestFramework::JRubyBased

     VERSION = '1.5.4' # Note: JtestR 0.6.0 only works up to 1.5.4

     class << self

       def jruby_artifact

       def dependencies

         @dependencies

       def included(mod)

     module ClassMethods

         @dependencies

     def run(tests, dependencies)

       dependencies |= [task.compile.target.to_s]

       spec_dir = task.project.path_to(:source, :spec, :ruby)

       report_dir = task.report_to.to_s

       rm_rf report_dir

       mkdir_p report_dir

       ENV['CI_REPORTS'] = report_dir

       runner = runner_config

       runner.content = runner_content(binding)

       Buildr.write(runner.file, runner.content)

       rm_f runner.result

       if RUBY_PLATFORM[/java/] && !options.fork

         runtime = new_runtime

         runtime.getObject.java.lang.System.getProperties().putAll(options[:properties] || {})

         runtime.getLoadService.require runner.file

       else

         cmd_options = task.options.only(:properties, :java_args)

         cmd_options.update(:classpath => dependencies, :project => task.project)

         jruby runner.file, tests, cmd_options rescue nil

       end

       fail "Missing result YAML file: #{runner.result}" unless File.exist? runner.result

       result = YAML.load(File.read(runner.result))

       if Exception === result

         raise [result.message, result.backtrace].flatten.join("\n")

       end

       tests - result.failed

     end

     def jruby_home

         ( ENV['JRUBY_HOME'] || File.expand_path('~/.jruby') )

     def jruby_installed?

   protected

         jruby_artifact = Buildr.artifact(TestFramework::JRubyBased.jruby_artifact)

         msg = "JRUBY_HOME is not correctly set or points to an invalid JRuby installation: #{jruby_home}"

         say msg

         say ''

         say "You need to install JRuby version #{jruby_artifact.version} using your system package manager."

         fail msg unless jruby_installed?

       end

     end

     def jruby(*args)

       java_args << {} unless Hash === args.last

       cmd_options = java_args.last

       project = cmd_options.delete(:project)

       cmd_options[:classpath] ||= []

       if jruby_home && jruby_home != ''

         Dir.glob(File.join(jruby_home, 'lib', '*.jar')) { |jar| cmd_options[:classpath] << jar }

         cmd_options[:properties]['jruby.home'] = jruby_home

       end

       cmd_options[:java_args] ||= []

       cmd_options[:java_args] << '-Xmx512m' unless cmd_options[:java_args].detect {|a| a =~ /^-Xmx/}

       cmd_options[:properties] ||= {}

       Java::Commands.java(*java_args)

     end

     def new_runtime(cfg = {})

       cfg.each_pair do |name, value|

         config.send("#{name}=", value)

       end

       yield config if block_given?

       Java.org.jruby.Ruby.newInstance config

     end

     def jruby_gem

           unless JRUBY_VERSION >= expected_version

             fail "Expected JRuby version \#{expected_version} installed at \#{jruby_home} but got \#{JRUBY_VERSION}"

           end

           require 'rubygems'

           begin

             Kernel.send :gem, name, version

           rescue LoadError, Gem::LoadError => e

             require 'rubygems/gem_runner'

             args = ['install', name, '--version', version] + args

             Gem::GemRunner.new.run(args)

             Kernel.send :gem, name, version

           end

        end

       }

     end

     def runner_config(runner = OpenStruct.new)

         runner.send("#{key}=", options[key])

       end

       runner.html_report ||= File.join(task.report_to.to_s, 'report.html')

       runner.result ||= task.project.path_to(:target, :spec, 'result.yaml')

       runner.file ||= task.project.path_to(:target, :spec, 'runner.rb')

       runner.requires ||= []

       runner.requires.unshift File.join(File.dirname(__FILE__), 'test_result')

       runner.gems ||= {}

       runner.rspec ||= ['--format', 'progress', '--format', "html:#{runner.html_report}"]

       runner.format.each { |format| runner.rspec << '--format' << format } if runner.format

       runner.rspec.push '--format', "Buildr::TestFramework::TestResult::YamlFormatter"

       runner.rspec.push '-o', runner.result

       runner

     end

   end

   # <a href="http://rspec.info">RSpec</a> is the defacto BDD framework for ruby.

   # To test your project with RSpec use:

   #   test.using :rspec

   #

   #

   # Support the following options:

   # * :gems       -- A hash of gems to install before running the tests.

   #                  The keys of this hash are the gem name, the value must be the required version.

   # * :requires   -- A list of ruby files to require before running the specs

   #                  Mainly used if an rspec format needs to require some file.

   # * :format     -- A list of valid Rspec --format option values. (defaults to 'progress')

   # * :output     -- File path to output dump. @false@ to suppress output

   # * :fork       -- Create a new JavaVM to run the tests on

   # * :properties -- Hash of properties passed to the test suite.

   # * :java_args  -- Arguments passed to the JVM.

   class RSpec < TestFramework::JavaBDD

     include TestFramework::JRubyBased

     TESTS_PATTERN = [ /_spec.rb$/ ]

     def self.applies_to?(project) #:nodoc:

     def tests(dependencies) #:nodoc:

         selector = ENV['SPEC']

         selector.nil? || Regexp.new(selector) === name

       end

     end

     def runner_config

       runner.gems.update 'rspec' => '~> 2.1.0'

       runner.requires.unshift 'rspec'

       runner

     end

     def runner_content(binding)

         <%= runner.gems.inspect %>.each { |ary| JRuby.gem(*ary.flatten) }

         <%= runner.requires.inspect %>.each { |rb| Kernel.require rb }

         <% if runner.output == false %>

           output = StringIO.new

         <% elsif runner.output.kind_of?(String) %>

           output = File.open(<%= result.output.inspect %>, 'w')

         <% else %>

           output = STDOUT

         <% end %>

         parser = ::RSpec::Core::Parser.new

         argv = <%= runner.rspec.inspect %> || []

         argv.push *<%= tests.inspect %>

         Buildr::TestFramework::TestResult::Error.guard('<%= runner.result %>') do

           ::RSpec::Core::CommandLine.new(argv).run(output, output)

         end

         exit 0 # let buildr figure the result from the yaml file

       }

       Filter::Mapper.new(:erb, binding).transform(runner_erb)

     end

   end

   # <a href="http://jtestr.codehaus.org/">JtestR</a> is a framework for BDD and TDD using JRuby and ruby tools.

   # To test your project with JtestR use:

   #   test.using :jtestr

   #

   #

   # Support the following options:

   # * :config     -- path to JtestR config file. defaults to @spec/ruby/jtestr_config.rb@

   # * :gems       -- A hash of gems to install before running the tests.

   #                  The keys of this hash are the gem name, the value must be the required version.

   # * :requires   -- A list of ruby files to require before running the specs

   #                  Mainly used if an rspec format needs to require some file.

   # * :format     -- A list of valid Rspec --format option values. (defaults to 'progress')

   # * :output     -- File path to output dump. @false@ to supress output

   # * :fork       -- Create a new JavaVM to run the tests on

   # * :properties -- Hash of properties passed to the test suite.

   # * :java_args  -- Arguments passed to the JVM.

   class JtestR < TestFramework::JavaBDD

     include TestFramework::JRubyBased

     VERSION = '0.6'

     # pattern for rspec stories

     STORY_PATTERN    = /_(steps|story)\.rb$/

     TESTUNIT_PATTERN = /(_test|Test)\.rb$|(tc|ts)[^\\\/]+\.rb$/

     EXPECT_PATTERN   = /_expect\.rb$/

     TESTS_PATTERN = [STORY_PATTERN, TESTUNIT_PATTERN, EXPECT_PATTERN] + RSpec::TESTS_PATTERN

     class << self

       def version

       def dependencies

         @dependencies

       def applies_to?(project) #:nodoc:

     private

         Buildr.application.deprecated 'Please use JtestR.dependencies/.version instead of JtestR::REQUIRES/VERSION'

         dependencies

       end

     end

     def initialize(task, options) #:nodoc:

       [:test, :spec].each do |usage|

         java_tests = task.project.path_to(:source, usage, :java)

         task.compile.from java_tests if File.directory?(java_tests)

         resources = task.project.path_to(:source, usage, :resources)

         task.resources.from resources if File.directory?(resources)

       end

     end

     def user_config

     def tests(dependencies) #:nodoc:

       types = { :story => STORY_PATTERN, :rspec => RSpec::TESTS_PATTERN,

                 :testunit => TESTUNIT_PATTERN, :expect => EXPECT_PATTERN }

       tests = types.keys.inject({}) { |h, k| h[k] = []; h }

       tests[:junit] = JUnit.new(task, {}).tests(dependencies)

       tests[:testng] = TestNG.new(task, {}).tests(dependencies)

       Dir[task.project.path_to(:source, bdd_dir, lang, '**/*.rb')].each do |rb|

         type = types.find { |k, v| Array(v).any? { |r| r === rb } }

         tests[type.first] << rb if type

       end

       @jtestr_tests = tests

       tests.values.flatten

     end

     def runner_config

       # JtestR 0.6.0 comes with rspec 1.3.0 (and any other jtestr dependency) included,

       # so the rspec version used depends on the jtestr jar.

       runner.gems.update 'rspec' => '=1.3.0'

       runner.requires.clear

       runner.requires.unshift 'jtestr'

       runner.requires.unshift 'spec'

       runner.requires.unshift File.join(File.dirname(__FILE__), 'jtestr_result')

       runner.rspec = ['--format', 'progress', '--format', "html:#{runner.html_report}"]

       runner.format.each { |format| runner.rspec << '--format' << format } if runner.format

       runner.rspec.push '--format', "Buildr::JtestR::YamlFormatter:#{runner.result}"

       runner

     end

     def runner_content(binding)

       Filter::Mapper.new(:erb, binding).transform(File.read(runner_erb), runner_erb)

     end

   end

   # JBehave is a Java BDD framework. To use in your project:

   #   test.using :jbehave

   #

   # This framework will search in your project for:

   #   src/spec/java/**/*Behaviour.java

   #

   # JMock libraries are included on runtime.

   #

   # Support the following options:

   # * :properties -- Hash of properties to the test suite

   # * :java_args -- Arguments passed to the JVM

   class JBehave < TestFramework::JavaBDD

     VERSION = '1.0.1'

     class << self

       def dependencies

         @dependencies

       def applies_to?(project) #:nodoc:

     def run(tests, dependencies) #:nodoc:

       cmd_options = { :properties=>options[:properties], :java_args=>options[:java_args], :classpath=>dependencies }

       tests.inject([]) do |passed, test|

         begin

           Java::Commands.java cmd_args, test, cmd_options

           passed << test

         rescue

           passed

         end

       end

     end

   end

 end

 Buildr::TestFramework << Buildr::RSpec