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.

 module Buildr

     class << self

       def select_by_lang(lang)

         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)

         providers.detect { |e| e.to_sym == name.to_sym }

       end

       def define_task(project, name, provider = nil)

           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

       providers.each { |provider| Project.local_task "shell:#{provider.to_sym}" }

       providers.each { |provider| define_task(project, "shell:#{provider.to_sym}", provider) }

     end

         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

       class << self

         def specify(options)

         def to_sym

       def initialize(project)

       def launch(task)

     class ShellTask < Rake::Task

       # Classpath dependencies.

       attr_accessor :classpath

       # Returns the run options.

       attr_reader :options

       # Underlying shell provider

       attr_reader :provider

       def initialize(*args) # :nodoc:

         @options = {}

         @classpath = []

       end

       # :call-seq:

       #   with(*artifacts) => self

       #

       # Adds files and artifacts as classpath dependencies, and returns self.

       def with(*specs)

         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)

           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

         provider.launch(self)

       end

       def prerequisites #:nodoc:

       def java_args

       def properties

     private

     # :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)

         t.enhance &block if block

       end

     end

   end

   class Project