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.

 # Portion of this file derived from Rake.

 # Copyright (c) 2003, 2004 Jim Weirich

 #

 # Permission is hereby granted, free of charge, to any person obtaining a copy

 # of this software and associated documentation files (the "Software"), to deal

 # in the Software without restriction, including without limitation the rights

 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 # copies of the Software, and to permit persons to whom the Software is

 # furnished to do so, subject to the following conditions:

 #

 # The above copyright notice and this permission notice shall be included in

 # all copies or substantial portions of the Software.

 #

 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 # SOFTWARE.

 require 'rake'

 module Buildr

   # Provide settings that come from three sources.

   #

   # User settings are placed in the .buildr/settings.yaml file located in the user's home directory.

   # They should only be used for settings that are specific to the user and applied the same way

   # across all builds.  Example for user settings are preferred repositories, path to local repository,

   # user/name password for uploading to remote repository.

   #

   # Build settings are placed in the build.yaml file located in the build directory.  They help keep

   # the buildfile and build.yaml file simple and readable, working to the advantages of each one.

   # Example for build settings are gems, repositories and artifacts used by that build.

   #

   # Profile settings are placed in the profiles.yaml file located in the build directory.  They provide

   # settings that differ in each environment the build runs in.  For example, URLs and database

   # connections will be different when used in development, test and production environments.

   # The settings for the current environment are obtained by calling #profile.

   class Settings

     def initialize(application) #:nodoc:

     # User settings loaded from setting.yaml file in user's home directory.

     def user

     # Build settings loaded from build.yaml file in build directory.

     def build

     # Profiles loaded from profiles.yaml file in build directory.

     def profiles

     # :call-seq:

     #    profile => hash

     #

     # Returns the profile for the current environment.

     def profile

   private

     def load_from(name, path = nil)

       file_name = ['yaml', 'yml'].map { |ext| File.join(path, "#{name}.#{ext}") }.find { |fn| File.exist?(fn) }

       fail "Expecting #{file_name} to be a map (name: value)!" unless Hash === yaml

       @application.buildfile.enhance [file_name]

       yaml

     end

   end

   class Application < Rake::Application #:nodoc:

     # Deprecated: rakefile/Rakefile, removed in 1.5

     DEFAULT_BUILDFILES = ['buildfile', 'Buildfile', 'buildfile.rb', 'Buildfile.rb'] + DEFAULT_RAKEFILES

     attr_reader :rakefiles, :requires

     def initialize

     def run

         init 'Buildr'

         load_buildfile

         top_level

       end

     end

     # Not for external consumption.

     def switch_to_namespace(names) #:nodoc:

       begin

         yield

       ensure

         @scope = current

       end

     end

     # Returns list of Gems associated with this buildfile, as listed in build.yaml.

     # Each entry is of type Gem::Specification.

     attr_reader :gems

     # Buildr home directory, .buildr under user's home directory.

     attr_reader :home_dir

     # Copied from BUILD_ENV.

     def environment

     # Returns the Settings associated with this build.

     attr_reader :settings

     # :call-seq:

     #   buildfile

     # Returns the buildfile as a task that you can use as a dependency.

     def buildfile

     # Files that complement the buildfile itself

     def build_files #:nodoc:

       buildfile.prerequisites

     end

     # Yields to block on successful completion. Primarily used for notifications.

     def on_completion(&block)

     # Yields to block on failure with exception. Primarily used for notifications.

     def on_failure(&block)

     # Call on_completion hooks with the given title and message

     def build_completed(title, message)

         block.call(title, message) rescue nil

       end

     end

     # Call on_failure hooks with the given title, message and exception

     def build_failed(title, message, ex = nil)

         block.call(title, message, ex) rescue nil

       end

     end

     # :call-seq:

     #   deprecated(message)

     #

     # Use with deprecated methods and classes. This method automatically adds the file name and line number,

     # and the text 'Deprecated' before the message, and eliminated duplicate warnings. It only warns when

     # running in verbose mode.

     #

     # For example:

     #   deprecated 'Please use new_foo instead of foo.'

     def deprecated(message) #:nodoc:

       "#{caller[1]}: Deprecated: #{message}".tap do |message|

         @deprecated ||= {}

         unless @deprecated[message]

           @deprecated[message] = true

           warn message

         end

       end

     end

   protected

     def load_buildfile # replaces load_rakefile

         find_buildfile

         load_gems

         load_artifact_ns

         load_tasks

         raw_load_buildfile

       end

     end

     def top_level # adds on_completion hook

         if options.show_tasks

           display_tasks_and_comments

         elsif options.show_prereqs

           display_prerequisites

         elsif options.execute

           eval options.execute

         else

           @start = Time.now

           top_level_tasks.each { |task_name| invoke_task(task_name) }

           if verbose

             elapsed = Time.now - @start

             real = []

             real << ('%ih' % (elapsed / 3600)) if elapsed >= 3600

             real << ('%im' % ((elapsed / 60) % 60)) if elapsed >= 60

             real << ('%.3fs' % (elapsed % 60))

             puts $terminal.color("Completed in #{real.join}", :green)

           end

           # On OS X this will load Cocoa and Growl which takes half a second we

           # don't want to measure, so put this after the console message.

           title, message = "Your build has completed", "#{Dir.pwd}\nbuildr #{@top_level_tasks.join(' ')}"

           build_completed(title, message)

         end

       end

     end

     def handle_options

       OptionParser.new do |opts|

         opts.banner = "buildr [-f rakefile] {options} targets..."

         opts.separator ""

         opts.separator "Options are ..."

         opts.on_tail("-h", "--help", "-H", "Display this help message.") do

           puts opts

           exit 0

         end

         standard_buildr_options.each { |args| opts.on(*args) }

       end.parse!

     end

     def standard_buildr_options # replaces standard_rake_options

             options.show_tasks = true

             options.full_description = true

             options.show_task_pattern = Regexp.new(value || '')

           }

         ],

         ['--execute',  '-E CODE',

           "Execute some Ruby code after loading the buildfile",

           lambda { |value| options.execute = value }

         ],

         ['--environment',  '-e ENV',

           "Environment name (e.g. development, test, production).",

           lambda { |value| ENV['BUILDR_ENV'] = value }

         ],

         ['--generate [PATH]',

          "Generate buildfile from either pom.xml file or directory path.",

           lambda { |value|

             value ||= File.exist?('pom.xml') ? 'pom.xml' : Dir.pwd

             raw_generate_buildfile value

             exit 0

           }

         ],

         ['--libdir', '-I LIBDIR', "Include LIBDIR in the search path for required modules.",

           lambda { |value| $:.push(value) }

         ],

         ['--prereqs', '-P [PATTERN]', "Display the tasks and dependencies (matching optional PATTERN), then exit.",

           lambda { |value|

             options.show_prereqs = true

             options.show_task_pattern = Regexp.new(value || '')

           }

         ],

         ['--quiet', '-q', "Do not log messages to standard output.",

           lambda { |value| verbose(false) }

         ],

         ['--buildfile', '-f FILE', "Use FILE as the buildfile.",

           lambda { |value|

             @rakefiles.clear

             @rakefiles << value

           }

         ],

         ['--rakelibdir', '--rakelib', '-R PATH',

           "Auto-import any .rake files in PATH. (default is 'tasks')",

           lambda { |value| options.rakelib = value.split(':') }

         ],

         ['--require', '-r MODULE', "Require MODULE before executing rakefile.",

           lambda { |value|

             begin

               require value

             rescue LoadError => ex

               begin

                 rake_require value

               rescue LoadError => ex2

                 raise ex

               end

             end

           }

         ],

         ['--rules', "Trace the rules resolution.",

           lambda { |value| options.trace_rules = true }

         ],

         ['--no-search', '--nosearch', '-N', "Do not search parent directories for the Rakefile.",

           lambda { |value| options.nosearch = true }

         ],

         ['--silent', '-s', "Like --quiet, but also suppresses the 'in directory' announcement.",

           lambda { |value|

             verbose(false)

             options.silent = true

           }

         ],

         ['--tasks', '-T [PATTERN]', "Display the tasks (matching optional PATTERN) with descriptions, then exit.",

           lambda { |value|

             options.show_tasks = true

             options.show_task_pattern = Regexp.new(value || '')

             options.full_description = false

           }

         ],

         ['--trace', '-t [CATEGORIES]', "Turn on invoke/execute tracing, enable full backtrace.",

           lambda { |value|

             options.trace = true

             options.trace_categories = value ? value.split(',').map { |v| v.downcase.to_sym } : []

             options.trace_all = options.trace_categories.include? :all

             verbose(true)

           }

         ],

         ['--verbose', '-v', "Log message to standard output (default).",

           lambda { |value| verbose(true) }

         ],

         ['--version', '-V', "Display the program version.",

           lambda { |value|

             puts "Buildr #{Buildr::VERSION}#{RUBY_PLATFORM[/java/] ? " (JRuby #{JRUBY_VERSION})" : ""}"

             exit 0

           }

         ],

         ['--offline', '-o', "Do not try to download anything",

           lambda { |value|

             trace 'Working in offline mode; snapshot will not be updated.'

             options.work_offline = true

           }

         ],

         ['--update-snapshots', '-u', "Force updating all dependencies whose version contains SNAPSHOT",

           lambda { |value|

             trace 'Force update of SNAPSHOT artifacts.'

             options.update_snapshots = true

           }

         ]

       ]

     end

     def find_buildfile

       fail "No Buildfile found (looking for: #{@rakefiles.join(', ')})" if buildfile.nil?

       @rakefile = buildfile

       Dir.chdir(location)

     end

     def ask_generate_buildfile

         menu.header = "To use Buildr you need a buildfile. Do you want me to create one?"

         menu.choice("From Maven2 POM file") { 'pom.xml' } if File.exist?('pom.xml')

         menu.choice("From directory structure") { Dir.pwd }

         menu.choice("Cancel") { }

       end

       if source

         buildfile = raw_generate_buildfile(source)

         [buildfile, File.dirname(buildfile)]

       end

     end

     def raw_generate_buildfile(source)

       @rakefile = File.expand_path(DEFAULT_BUILDFILES.first)

       fail "Buildfile already exists" if File.exist?(@rakefile) && !(tty_output? && agree('Buildfile exists, overwrite?'))

       script = File.directory?(source) ? Generate.from_directory(source) : Generate.from_maven2_pom(source)

       File.open @rakefile, 'w' do |file|

         file.puts script

       end

       puts "Created #{@rakefile}" if verbose

       @rakefile

     end

     def raw_load_buildfile # replaces raw_load_rakefile

       load File.expand_path(@rakefile) if @rakefile && @rakefile != ''

       load_imports

       Buildr.projects

     end

     # Load/install all Gems specified in build.yaml file.

     def load_gems #:nodoc:

       unless missing_deps.empty?

         newly_installed = Util::Gems.install(*missing_deps)

         installed += newly_installed

       end

       installed.each do |spec|

         if gem(spec.name, spec.version.to_s)

           # TODO: is this intended to load rake tasks from the installed gems?

           # We should use a convention like .. if the gem has a _buildr.rb file, load it.

           #FileList[spec.require_paths.map { |path| File.expand_path("#{path}/*.rb", spec.full_gem_path) }].

           #  map { |path| File.basename(path) }.each { |file| require file }

           #FileList[File.expand_path('tasks/*.rake', spec.full_gem_path)].each do |file|

           #  Buildr.application.add_import file

           #end

         end

       end

       @gems = installed

     end

     # Returns Gem::Specification for every listed and installed Gem, Gem::Dependency

     # for listed and uninstalled Gem, which is the installed before loading the buildfile.

     def listed_gems #:nodoc:

         name, trail = dep.scan(/^\s*(\S*)\s*(.*)\s*$/).first

         versions = trail.scan(/[=><~!]{0,2}\s*[\d\.]+/)

         versions = ['>= 0'] if versions.empty?

         dep = Gem::Dependency.new(name, versions)

         Gem::SourceIndex.from_installed_gems.search(dep).last || dep

       end

     end

     # Load artifact specs from the build.yaml file, making them available

     # by name ( ruby symbols ).

     def load_artifact_ns #:nodoc:

       return unless hash

       raise "Expected 'artifacts' element to be a hash" unless Hash === hash

       # Currently we only use one artifact namespace to rule them all. (the root NS)

       Buildr::ArtifactNamespace.load(:root => hash)

     end

     # Loads buildr.rb files from home/.buildr directory and project directory.

     # Loads custom tasks from .rake files in tasks directory.

     def load_tasks #:nodoc:

       old = File.expand_path('buildr.rb', ENV['HOME'])

       new = File.expand_path('buildr.rb', home_dir)

       if File.exist?(old) && !File.exist?(new)

         warn "Deprecated: Please move buildr.rb from your home directory to the .buildr directory in your home directory"

       end

       # Load home/.buildr/buildr.rb in preference

       files = [ File.exist?(new) ? new : old, 'buildr.rb' ].select { |file| File.exist?(file) }

       files += [ File.expand_path('buildr.rake', ENV['HOME']), File.expand_path('buildr.rake') ].

         select { |file| File.exist?(file) }.each { |file| warn "Please use '#{file.ext('rb')}' instead of '#{file}'" }

       files += (options.rakelib || []).collect { |rlib| Dir["#{rlib}/*.rake"] }.flatten

       if options.full_description

         displayable_tasks.each do |t|

           puts "buildr #{t.name_with_args}"

           t.full_comment.split("\n").each do |line|

             puts "    #{line}"

           end

           puts

         end

       else

         width = displayable_tasks.collect { |t| t.name_with_args.length }.max || 10

         max_column = truncate_output? ? terminal_width - name.size - width - 7 : nil

         exit(1)

       end

     end

   end

   # This task stands for the buildfile and all its associated helper files (e.g., buildr.rb, build.yaml).

   # By using this task as a prerequisite for other tasks, you can ensure these tasks will be needed

   # whenever the buildfile changes.

   class BuildfileTask < Rake::FileTask #:nodoc:

     def timestamp

   class << self

     # Returns the Buildr::Application object.

     def application

     def application=(app) #:nodoc:

     # Returns the Settings associated with this build.

     def settings

     # Copied from BUILD_ENV.

     def environment

   Buildr.application = Buildr::Application.new

 end

 # Add a touch of color when available and running in terminal.

 HighLine.use_color = false

 alias :warn_without_color :warn

 # Show warning message.

 def warn(message)

 # Show error message.  Use this when you need to show an error message and not throwing

 # an exception that will stop the build.

 def error(message)

 # Show optional information.  The message is printed only when running in verbose

 # mode (the default).

 def info(message)

 # Show message.  The message is printed out only when running in trace mode.

 def trace(message)

 def trace?(*category)

   return options.trace if category.empty?

   return true if options.trace_all

   return false unless Buildr.application.options.trace_categories

   options.trace_categories.include?(category.first)

 end

 module Rake #:nodoc

   # all other cases result in the non too-descriptive thread sleeping error. This change can

   # deal with circular dependencies that occur from direct task invocation, e.g:

   #   task 'foo'=>'bar'

   #   task 'bar' do

   #     task('foo').invoke

   #   end

   class Task #:nodoc:

     def invoke_with_call_chain(task_args, invocation_chain)

         return if @already_invoked

           trace "Exception while invoking prerequisites of task #{self.inspect}"

           raise

         end

           Thread.current[:rake_chain] = old_chain

 module RakeFileUtils #:nodoc:

     next if default_options.empty?