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/core/project'

 module Buildr

   class Options

     # Runs the build in parallel when true (defaults to false). You can force a parallel build by

     # setting this option directly, or by running the parallel task ahead of the build task.

     #

     # This option only affects recursive tasks. For example:

     #   buildr parallel package

     # will run all package tasks (from the sub-projects) in parallel, but each sub-project's package

     # task runs its child tasks (prepare, compile, resources, etc) in sequence.

     attr_accessor :parallel

   end

   task('parallel') { Buildr.options.parallel = true }

   module Build

     include Extension

       desc 'The default task is build'

       project.recursive_task 'clean'

       project.clean do

         rm_rf project.path_to(:target)

         rm_rf project.path_to(:reports)

       end

     end

     after_define(:build)

     # *Deprecated:* Use +path_to(:target)+ instead.

     def target

       layout.expand(:target)

     end

     # *Deprecated:* Use Layout instead.

     def target=(dir)

       layout[:target] = _(dir)

     end

     # *Deprecated:* Use +path_to(:reports)+ instead.

     def reports()

       layout.expand(:reports)

     end

     # *Deprecated:* Use Layout instead.

     def reports=(dir)

       layout[:reports] = _(dir)

     end

     # :call-seq:

     #    build(*prereqs) => task

     #    build { |task| .. } => task

     #

     # Returns the project's build task. With arguments or block, also enhances that task.

     def build(*prereqs, &block)

     # :call-seq:

     #    clean(*prereqs) => task

     #    clean { |task| .. } => task

     #

     # Returns the project's clean task. With arguments or block, also enhances that task.

     def clean(*prereqs, &block)

   module Git  #:nodoc:

     # :call-seq:

     #   git(*args)

     #

     # Executes a Git command and returns the output. Throws exception if the exit status

     # is not zero. For example:

     #   git 'commit'

     #   git 'remote', 'show', 'origin'

     def git(*args)

       output = `#{cmd}`

       fail "GIT command \"#{cmd}\" failed with status #{$?.exitstatus}\n#{output}" unless $?.exitstatus == 0

       return output

     end

     # Returns list of uncommited/untracked files as reported by git status.

     def uncommitted_files

     # Commit the given file with a message.

     # The file has to be known to Git meaning that it has either to have been already committed in the past

     # or freshly added to the index. Otherwise it will fail.

     def commit(file, message)

     # Update the remote refs using local refs

     #

     # By default, the "remote" destination of the push is the the remote repo linked to the current branch.

     # The default remote branch is the current local branch.

     def push(remote_repo = remote, remote_branch = current_branch)

     # Return the name of the remote repository whose branch the current local branch tracks,

     # or nil if none.

     def remote(branch = current_branch)

       remote if !remote.empty? && git('remote').include?(remote)

     end

     # Return the name of the current branch

     def current_branch

   module Svn #:nodoc:

     # :call-seq:

     #   svn(*args)

     #

     # Executes a SVN command and returns the output. Throws exception if the exit status

     # is not zero. For example:

     #   svn 'commit'

     def svn(*args)

       fail "SVN command failed with status #{$?.exitstatus}" unless $?.exitstatus == 0

       return output

     end

     def tag(tag_name)

       remove url, 'Removing old copy' rescue nil

       copy Dir.pwd, url, "Release #{tag_name}"

     end

     # Status check reveals modified files, but also SVN externals which we can safely ignore.

     def uncommitted_files

     def commit(file, message)

     # :call-seq:

     #   tag_url(svn_url, version) => tag_url

     #

     # Returns the SVN url for the tag.

     # Can tag from the trunk or from branches.

     # Can handle the two standard repository layouts.

     #   - http://my.repo/foo/trunk => http://my.repo/foo/tags/1.0.0

     #   - http://my.repo/trunk/foo => http://my.repo/tags/foo/1.0.0

     def tag_url(svn_url, tag)

       match = trunk_or_branches.match(svn_url)

       prefix = match[1] || match[3]

       suffix = match[2] || match[4]

       prefix + '/tags' + suffix + '/' + tag

     end

     # Return the current SVN URL

     def repo_url

     def copy(dir, url, message)

     def remove(url, message)

   class Release #:nodoc:

     THIS_VERSION_PATTERN  = /(THIS_VERSION|VERSION_NUMBER)\s*=\s*(["'])(.*)\2/

     class << self

       # Use this to specify a different tag name for tagging the release in source control.

       # You can set the tag name or a proc that will be called with the version number,

       # for example:

       #   Release.tag_name = lambda { |ver| "foo-#{ver}" }

       attr_accessor :tag_name

       # Use this to specify a different commit message to commit the buildfile with the next version in source control.

       # You can set the commit message or a proc that will be called with the next version number,

       # for example:

       #   Release.commit_message = lambda { |ver| "Changed version number to #{ver}" }

       attr_accessor :commit_message

       # Use this to specify the next version number to replace VERSION_NUMBER with in the buildfile.

       # You can set the next version or a proc that will be called with the current version number.

       # For example, with the following buildfile:

       #   THIS_VERSION = "1.0.0-rc1" 

       #   Release.next_version = lambda { |version| 

       #       version[-1] = version[-1].to_i + 1

       #       version

       #   } 

       # 

       # Release.next_version will return "1.0.0-rc2", so at the end of the release, the buildfile will contain VERSION_NUMBER = "1.0.0-rc2" 

       #

       attr_accessor :next_version

       # :call-seq:

       #     add(MyReleaseClass)

       #

       # Add a Release implementation to the list of available Release classes.

       def add(release)

       # The list of supported Release implementations

       def list

       # Finds and returns the Release instance for this project.

       def find

           klass = list.detect { |impl| impl.applies_to? }

           @release = klass.new if klass

         end

         @release

       end

     end

     # :call-seq:

     #   make()

     #

     # Make a release.

     def make

       check

       with_release_candidate_version do |release_candidate_buildfile|

         args = '-S', 'buildr', "_#{Buildr::VERSION}_", '--buildfile', release_candidate_buildfile

         args << '--environment' << Buildr.environment unless Buildr.environment.to_s.empty?

         args << 'clean' << 'upload' << 'DEBUG=no'

         ruby *args

       end

       tag_release resolve_tag

       update_version_to_next if this_version != resolve_next_version(this_version)

     end

     def check

         fail "The next version can't be equal to the current version #{this_version}.\nUpdate THIS_VERSION/VERSION_NUMBER, specify Release.next_version or use NEXT_VERSION env var" 

       end

     end

     # :call-seq:

     #   extract_version() => this_version

     #

     # Extract the current version number from the buildfile.

     # Raise an error if not found.

     def extract_version

       buildfile.scan(THIS_VERSION_PATTERN)[0][2]

     rescue

       fail 'Looking for THIS_VERSION = "..." in your Buildfile, none found'

     end

     # Use this to specify a different tag name for tagging the release in source control.

     # You can set the tag name or a proc that will be called with the version number,

     # for example:

     #   Release.find.tag_name = lambda { |ver| "foo-#{ver}" }

     # Deprecated: you should use Release.tag_name instead

     def tag_name=(tag_proc)

       Release.tag_name=(tag_proc)

     end

   protected

     # the initial value of THIS_VERSION

     attr_accessor :this_version

     # :call-seq:

     #   with_release_candidate_version() { |filename| ... }

     #

     # Yields to block with release candidate buildfile, before committing to use it.

     #

     # We need a Buildfile with upgraded version numbers to run the build, but we don't want the

     # Buildfile modified unless the build succeeds. So this method updates the version number in

     # a separate (Buildfile.next) file, yields to the block with that filename, and if successful

     # copies the new file over the existing one.

     #

     # The release version is the current version without '-SNAPSHOT'.  So:

     #   THIS_VERSION = 1.1.0-SNAPSHOT

     # becomes:

     #   THIS_VERSION = 1.1.0

     # for the release buildfile.

     def with_release_candidate_version

       release_candidate_buildfile_contents = change_version { |version|

         version.gsub(/-SNAPSHOT$/, "")

       }

       File.open(release_candidate_buildfile, 'w') { |file| file.write release_candidate_buildfile_contents }

       begin

         yield release_candidate_buildfile

         mv release_candidate_buildfile, Buildr.application.buildfile.to_s

       ensure

         rm release_candidate_buildfile rescue nil

       end

     end

     # :call-seq:

     #   change_version() { |this_version| ... } => buildfile

     #

     # Change version number in the current Buildfile, but without writing a new file (yet).

     # Returns the contents of the Buildfile with the modified version number.

     #

     # This method yields to the block with the current (this) version number and expects

     # the block to return the updated version.

     def change_version

       new_version = yield(current_version)

       buildfile = File.read(Buildr.application.buildfile.to_s)

       buildfile.gsub(THIS_VERSION_PATTERN) { |ver| ver.sub(/(["']).*\1/, %Q{"#{new_version}"}) }

     end

     # Return the name of the tag to tag the release with.

     def resolve_tag

       tag = Release.tag_name || version

       tag = tag.call(version) if Proc === tag

       tag

     end

     # Return the new value of THIS_VERSION based on the version passed.

     #

     # This method receives the existing value of THIS_VERSION

     def resolve_next_version(current_version)

         next_version ||= lambda { |v|

           snapshot = v.match(/-SNAPSHOT$/)

           version = v.gsub(/-SNAPSHOT$/, "").split(/\./)

           if snapshot