realityforge-buildr 1.5.9

data/addon/buildr/top_level_generate_dir.rb

@@ -0,0 +1,37 @@
+# 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
+
+  # A simple extension that modifies the project layout to place generated files at the top level.
+  # Generated files are typically created below layout[:target, :generated], placing them at the top
+  # level makes it easy for IDEs to inspect source in the generated directory while ignoring the dir
+  # containing the intermediate artifacts.
+  #
+  module TopLevelGenerateDir
+    module ProjectExtension
+      include Extension
+
+      before_define do |project|
+        project.layout[:target, :generated] = "generated"
+        project.clean { rm_rf project._(:target, :generated) }
+      end
+    end
+  end
+end
+
+class Buildr::Project
+  include Buildr::TopLevelGenerateDir::ProjectExtension
+end

data/addon/buildr/wsgen.rb

@@ -0,0 +1,192 @@
+# 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 Wsgen
+    class << self
+
+      # :call-seq:
+      #    java2wsdl(project, classnames, options) => String
+      #
+      # Uses wsgen to generate wsdl files form annotated, compiled classes. The parameters are
+      # * :project -- The project in which the classes are compiled.
+      # * :classnames -- Either an array of classnames to convert to wsdl or a map keyed on classnames and service
+      #                  specific customizations provided.
+      #
+      # Service options include:
+      # * :service_name -- The name of the service.
+      # * :namespace_url -- The namespace of the service.
+      #
+      # Method options include:
+      # * :output_dir -- The target directory.
+      # * :namespace_url -- The default namespace for the services.
+      #
+      # For example:
+      #  Buildr::Wsgen.java2wsdl(project, %w(com.example.MyService))
+      #  Buildr::Wsgen.java2wsdl(project, %w(com.example.MyService com.example.MyOtherService))
+      #  Buildr::Wsgen.java2wsdl(project, %w(com.example.MyService com.example.MyOtherService), :namespace_url => "http://example.com/services")
+      #  Buildr::Wsgen.java2wsdl(project, {"com.example.MyService" => {:service_name => 'MiaService', :namespace_url => "http://example.com/it/services"}))
+      def java2wsdl(project, classnames, options = {})
+        desc 'Generate wsdl from java'
+        project.task('java2wsdl').enhance([project.compile.target])
+
+        base_wsdl_dir = File.expand_path(options[:output_dir] || project._(:target, :generated, :wsgen, :main, :wsdl))
+        project.iml.main_generated_source_directories << base_wsdl_dir if project.iml?
+        project.file(base_wsdl_dir)
+        project.task('java2wsdl').enhance([base_wsdl_dir])
+
+        services = classnames.is_a?(Array) ? classnames.inject({}) {|result, element| result[element] = {}; result} : classnames
+
+        services.each_pair do |classname, config|
+
+          name_parts = classname.split('.')
+          service_name = config[:service_name] || name_parts.last
+          namespace_url = config[:namespace_url] || options[:namespace_url] || "http://#{name_parts[0...-1].reverse.join('.')}"
+          wsdl_file = File.expand_path("#{base_wsdl_dir}/META-INF/wsdl/#{service_name}.wsdl")
+
+          project.file(wsdl_file) do
+            mkdir_p File.dirname(wsdl_file)
+            cp = Buildr.artifacts(project.compile.dependencies + [project.compile.target]).map(&:to_s).join(File::PATH_SEPARATOR)
+
+            java_dir = project._(:target, :ignored, :wsgen, :main, :java)
+            intermediate_dir = project._(:target, :ignored, :wsgen, :main, :java)
+
+            rm_rf java_dir
+            rm_rf intermediate_dir
+            mkdir_p java_dir
+            mkdir_p intermediate_dir
+
+            args = []
+            args << '-keep'
+            args << '-inlineSchemas' if (options[:inlineSchemas] && ENV_JAVA['java.version'] >= '1.7')
+            args << '-wsdl'
+            args << '-servicename'
+            args << "{#{namespace_url}}#{service_name}"
+            args << '-portname'
+            args << "{#{namespace_url}}#{service_name}Port"
+            args << '-d'
+            args << intermediate_dir
+            args << '-r'
+            args << "#{base_wsdl_dir}/META-INF/wsdl"
+            args << '-s'
+            args << java_dir
+            args << '-cp'
+            args << cp
+            args << classname
+
+            command = "wsgen #{args.join(' ')}"
+            trace command
+            sh command
+            if $? != 0
+              raise 'Problem building wsdl'
+            end
+
+            content = IO.read(wsdl_file).gsub('REPLACE_WITH_ACTUAL_URL', "http://example.com/#{service_name}")
+            File.open(wsdl_file, 'wb') { |f| f.write content }
+          end
+
+          project.file(base_wsdl_dir).enhance([wsdl_file])
+          project.task('java2wsdl').enhance([wsdl_file])
+        end
+
+        base_wsdl_dir
+      end
+
+      # :call-seq:
+      #    wsdl2java(project, wsdls, options) => String
+      #
+      # Uses wsgen to generate java files form wsdls. The parameters are
+      # * :project -- The project in which the classes are compiled.
+      # * :wsdls -- A hash of wsdl filenames to service configuration.
+      #
+      # Service options include:
+      # * :service_name -- The name of the service.
+      # * :package -- The package in which to generate the code.
+      # * :extension -- Should we allow non-portable extensions.
+      #
+      # Method options include:
+      # * :output_dir -- The target directory.
+      # * :target -- The target version for generated source..
+      # * :package -- The default package in which to generate the code.
+      #
+      # For example:
+      #  Buildr::Wsgen.wsdl2java(project, {_('src/main/wsdl/MyService.wsdl') => {}})
+      #  Buildr::Wsgen.wsdl2java(project, {_('src/main/wsdl/MyService.wsdl') => {:package => 'com.example'}})
+      #  Buildr::Wsgen.wsdl2java(project, {_('src/main/wsdl/MyService.wsdl') => {:output_dir => _(:target, :wsdl, :java)}})
+      #  Buildr::Wsgen.wsdl2java(project, {_('src/main/wsdl/MyService.wsdl') => {}}, :package => 'com.example' )
+      #  Buildr::Wsgen.wsdl2java(project, {_('src/main/wsdl/MyService.wsdl') => {}}, :wsdl_location => 'file:META-INF/wsdl/SpecificTaskService.wsdl' )
+      def wsdl2java(project, wsdls, options = {})
+        desc 'Generate java from wsdl'
+        project.task('wsdl2java')
+
+        ws_dir = File.expand_path(options[:output_dir] || project._(:target, :generated, 'ws/main/java'))
+        project.file(ws_dir)
+        project.task('wsdl2java').enhance([ws_dir])
+
+        target = options[:target] || '2.1'
+
+        wsdls.each_pair do |wsdl_file, config|
+          pkg = config[:package] || options[:package]
+          service = config[:service] || File.basename(wsdl_file, '.wsdl')
+          wsdl_location = config[:wsdl_location]
+          java_file = "#{ws_dir}/#{pkg.gsub('.', '/')}/#{service}.java"
+          project.file(java_file => [project.file(wsdl_file)]) do
+            mkdir_p ws_dir
+            command = []
+            command << 'wsimport'
+            command << '-keep'
+            command << '-Xnocompile'
+            command << '-target'
+            command << target
+            command << '-s'
+            command << ws_dir
+            command << '-p'
+            command << pkg
+            if config[:extension]
+              command << '-extension'
+            end
+            if wsdl_location
+              command << '-wsdllocation'
+              command << wsdl_location
+            end
+            command << wsdl_file
+
+            trace command.join(' ')
+            output = `#{command.join(' ')}`
+            if $? != 0
+              rm_rf java_file
+              puts output
+              raise 'Problem building webservices'
+            end
+            unless File.exist?(java_file)
+              puts output
+              raise 'Problem building webservices'
+            end
+            if output =~ /\[WARNING\]/
+              puts output
+            end
+          end
+          project.file(ws_dir).enhance([java_file])
+        end
+
+        project.compile.from ws_dir
+        project.iml.main_generated_source_directories << ws_dir if project.iml?
+        project.compile.enhance(['wsdl2java'])
+
+        ws_dir
+      end
+    end
+  end
+end

data/bin/buildr

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# 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 'rubygems'
+require 'bundler/setup'
+require 'buildr'
+Buildr.application.run

data/buildr.gemspec

@@ -0,0 +1,61 @@
+# 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.
+
+unless defined?(Buildr::VERSION)
+  require File.join(File.dirname(__FILE__), 'lib', 'buildr', 'version.rb')
+  $LOADED_FEATURES << 'buildr/version.rb'
+end
+
+Gem::Specification.new do |spec|
+  spec.name           = 'realityforge-buildr'
+  spec.version        = Buildr::VERSION.dup
+  spec.platform       = Gem::Platform::RUBY
+  spec.author         = 'Apache Buildr'
+  spec.email          = 'users@buildr.apache.org'
+  spec.homepage       = 'http://buildr.apache.org/'
+  spec.summary        = 'Build like you code'
+  spec.licenses        = %w(Apache-2.0)
+  spec.description    = <<-TEXT
+Apache Buildr is a build system for Java-based applications.  We wanted
+something that's simple and intuitive to use, so we only need to tell it what
+to do, and it takes care of the rest.  But also something we can easily extend
+for those one-off tasks, with a language that's a joy to use.
+  TEXT
+
+  spec.files          = Dir['{addon,bin,lib,rakelib,spec}/**/*', '*.{gemspec}'] +
+                        %w(LICENSE NOTICE CHANGELOG.md README.md Rakefile)
+  spec.require_paths  = 'lib', 'addon'
+  spec.bindir         = 'bin'
+  spec.executable     = 'buildr'
+
+  spec.extra_rdoc_files = 'README.md', 'CHANGELOG.md', 'LICENSE', 'NOTICE'
+  spec.rdoc_options     = '--title', 'Buildr', '--main', 'README.md',
+                          '--webcvs', 'https://github.com/realityforge/buildr'
+  spec.post_install_message = 'To get started run buildr --help'
+
+  # Tested against these dependencies.
+  spec.add_dependency 'rake',                 '0.9.2.2'
+  spec.add_dependency 'builder',              '3.2.4'
+  spec.add_dependency 'rubyzip',              '2.3.0'
+  spec.add_dependency 'json_pure',            '2.5.1'
+  spec.add_dependency 'xml-simple',           '1.1.8'
+  spec.add_dependency 'bundler'
+
+  spec.add_development_dependency 'rspec-expectations',   '2.14.3'
+  spec.add_development_dependency 'rspec-mocks',          '2.14.3'
+  spec.add_development_dependency 'rspec-core',           '2.14.5'
+  spec.add_development_dependency 'rspec',                '2.14.1'
+  spec.add_development_dependency 'rspec-retry',          '0.2.1'
+end

data/lib/buildr.rb

@@ -0,0 +1,86 @@
+# 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.
+
+unless defined?(Buildr::VERSION)
+  require 'buildr/version'
+end
+
+require 'rake'
+include Rake::DSL
+Rake::TaskManager.record_task_metadata = true
+
+require 'rbconfig'
+require 'pathname'
+autoload :Tempfile, 'tempfile'
+autoload :YAML, 'yaml'
+autoload :REXML, 'rexml/document'
+autoload :XmlSimple, 'xmlsimple'
+autoload :Builder, 'builder' # A different kind of buildr, one we use to create XML.
+require 'erb'
+require 'find'
+require 'uri'
+require 'stringio'
+require 'fileutils'
+require 'securerandom'
+
+require 'buildr/core/util'
+require 'buildr/core/console'
+require 'buildr/core/common'
+require 'buildr/core/application'
+require 'buildr/core/project'
+require 'buildr/core/assets'
+require 'buildr/core/environment'
+require 'buildr/core/help'
+require 'buildr/core/build'
+require 'buildr/core/filter'
+require 'buildr/core/compile'
+require 'buildr/core/test'
+require 'buildr/java/commands'
+require 'buildr/core/transports'
+require 'buildr/java/pom'
+require 'buildr/core/doc'
+require 'buildr/packaging/version_requirement'
+require 'buildr/packaging/artifact_namespace'
+require 'buildr/packaging/artifact'
+require 'buildr/packaging/package'
+require 'buildr/packaging/archive'
+require 'buildr/packaging/ziptask'
+require 'buildr/packaging/zip'
+require 'buildr/java/compiler'
+require 'buildr/java/tests'
+require 'buildr/java/test_result'
+require 'buildr/java/packaging'
+require 'buildr/java/commands'
+require 'buildr/java/doc'
+require 'buildr/java/custom_pom'
+require 'buildr/ide/idea'
+
+# Methods defined in Buildr are both instance methods (e.g. when included in Project)
+# and class methods when invoked like Buildr.artifacts().
+module Buildr ; extend self ; end
+
+# The Buildfile object (self) has access to all the Buildr methods and constants.
+class << self ; include Buildr ; end
+
+# All modules defined under Buildr::* can be referenced without Buildr:: prefix
+# unless a conflict exists (e.g.  Buildr::RSpec vs ::RSpec)
+class Object #:nodoc:
+  Buildr.constants.each do |name|
+    const = Buildr.const_get(name)
+    if const.is_a?(Module)
+      const_set name, const unless const_defined?(name)
+    end
+  end
+end

data/lib/buildr/core/application.rb

@@ -0,0 +1,705 @@
+# 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.
+
+
+# Gem::user_home is nice, but ENV['HOME'] lets you override from the environment.
+ENV['HOME'] ||= File.expand_path(Gem::user_home)
+ENV['BUILDR_ENV'] ||= 'development'
+
+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:
+      @application = application
+    end
+
+    # User settings loaded from setting.yaml file in user's home directory.
+    def user
+      @user ||= load_from('settings', @application.home_dir)
+    end
+
+    # Build settings loaded from build.yaml file in build directory.
+    def build
+      @build ||= load_from('build')
+    end
+
+    # Profiles loaded from profiles.yaml file in build directory.
+    def profiles
+      @profiles ||= load_from('profiles')
+    end
+
+    # :call-seq:
+    #    profile => hash
+    #
+    # Returns the profile for the current environment.
+    def profile
+      profiles[@application.environment] ||= {}
+    end
+
+  private
+
+    def load_from(name, path = nil)
+      unless path
+        fail "Internal error: attempting to access local setting before buildfile located" unless @application.rakefile
+        path = File.expand_path(File.dirname(@application.rakefile))
+      end
+      file_name = %w[yaml yml].map { |ext| File.join(path, "#{name}.#{ext}") }.find { |fn| File.exist?(fn) }
+      return {} unless file_name
+      yaml = YAML.load(File.read(file_name)) || {}
+      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:
+
+    DEFAULT_BUILDFILES = %w[buildfile Buildfile buildfile.rb Buildfile.rb]
+
+    attr_reader :rakefiles, :requires
+    private :rakefiles, :requires
+
+    def initialize
+      super
+      @rakefiles = DEFAULT_BUILDFILES.dup
+      @top_level_tasks = []
+      @home_dir = File.expand_path('.buildr', ENV['HOME'])
+      mkpath @home_dir if !File.exist?(@home_dir) && File.writable?(ENV['HOME'])
+      @settings = Settings.new(self)
+      @on_completion = []
+      @on_failure = []
+    end
+
+    def run
+      @start = Time.now
+      standard_exception_handling do
+        init 'Buildr'
+        load_buildfile
+        top_level
+      end
+    end
+
+    # Not for external consumption.
+    def switch_to_namespace(names) #:nodoc:
+      current, @scope = @scope, names
+      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
+      ENV['BUILDR_ENV']
+    end
+
+    # 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
+      @buildfile_task ||= BuildfileTask.define_task(File.expand_path(rakefile))
+    end
+
+    # Files that complement the buildfile itself
+    def build_files #:nodoc:
+      deprecated 'Please call buildfile.prerequisites instead'
+      buildfile.prerequisites
+    end
+
+    # Yields to block on successful completion. Primarily used for notifications.
+    def on_completion(&block)
+      @on_completion << block
+    end
+
+    # Yields to block on failure with exception. Primarily used for notifications.
+    def on_failure(&block)
+      @on_failure << block
+    end
+
+    # Call on_completion hooks with the given title and message
+    def build_completed(title, message)
+      @on_completion.each do |block|
+        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)
+      @on_failure.each do |block|
+        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:
+      return unless verbose
+      "#{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
+      standard_exception_handling do
+        find_buildfile
+        load_gems
+        load_artifact_ns
+        load_tasks
+        raw_load_buildfile
+      end
+    end
+
+    def top_level # adds on_completion hook
+      standard_exception_handling do
+        if options.show_tasks
+          display_tasks_and_comments
+        elsif options.show_prereqs
+          display_prerequisites
+        elsif options.execute
+          eval options.execute
+        else
+          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 Buildr::Console.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
+      options.rakelib = ['tasks']
+
+      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
+      [
+        ['--describe', '-D [PATTERN]', "Describe the tasks (matching optional PATTERN), then exit.",
+          lambda { |value|
+            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 Buildfile.",
+          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}"
+            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
+      buildfile, location = find_rakefile_location || (tty_output? && ask_generate_buildfile)
+      fail "No Buildfile found (looking for: #{@rakefiles.join(', ')})" if buildfile.nil?
+      @rakefile = buildfile
+      Dir.chdir(location)
+    end
+
+    def ask_generate_buildfile
+      header = "To use Buildr you need a buildfile. Do you want me to create one?"
+      options = {}
+      options["From Maven2 POM file"] = ['pom.xml', false] if File.exist?('pom.xml')
+      options["From directory structure"] = [Dir.pwd, false]
+      options["Cancel"]= nil
+      source, from_eclipse = Buildr::Console.present_menu(header, options)
+      if source
+        buildfile = raw_generate_buildfile(source, from_eclipse)
+        [buildfile, File.dirname(buildfile)]
+      end
+    end
+
+    def raw_generate_buildfile(source, from_eclipse=Generate.has_eclipse_project?)
+      # We need rakefile to be known, for settings.build to be accessible.
+      @rakefile = File.expand_path(DEFAULT_BUILDFILES.first)
+      fail "Buildfile already exists" if File.exist?(@rakefile) && !(tty_output? && Buildr::Console.agree?('Buildfile exists, overwrite?'))
+      script = nil
+      if from_eclipse
+        script = Generate.from_eclipse(source)
+      elsif File.directory?(source)
+        script = Generate.from_directory(source)
+      else
+        script = Generate.from_maven2_pom(source)
+      end
+      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
+      puts "(in #{Dir.pwd}, #{environment})" unless options.silent
+      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:
+      installed, missing_deps = listed_gems
+      unless missing_deps.empty?
+        fail Gem::LoadError, "Build requires the gems #{missing_deps.join(', ')}, which cannot be found in the local repository. Please install the gems before attempting to build project."
+      end
+      installed.each { |spec| spec.activate }
+      @gems = installed
+    end
+
+    # Returns two lists. The first contains a Gem::Specification for every listed and installed
+    # Gem, the second contains a Gem::Dependency for every listed and uninstalled Gem.
+    def listed_gems #:nodoc:
+      found = []
+      missing = []
+      Array(settings.build['gems']).each do |dep|
+        name, versions = parse_gem_dependency(dep)
+        begin
+          found << Gem::Specification.find_by_name(name, versions)
+        rescue Exception
+          missing << Gem::Dependency.new(name, versions)
+        end
+      end
+      return [found, missing]
+    end
+
+    def parse_gem_dependency(dep) #:nodoc:
+      name, trail = dep.scan(/^\s*(\S*)\s*(.*)\s*$/).first
+      versions = trail.scan(/[=><~!]{0,2}\s*[\d\.]+/)
+      versions = ['>= 0'] if versions.empty?
+      return name, versions
+    end
+
+    # Load artifact specs from the build.yaml file, making them available
+    # by name ( ruby symbols ).
+    def load_artifact_ns #:nodoc:
+      hash = settings.build['artifacts']
+      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:
+      # TODO: this might need to be split up, look for deprecated features, better method name.
+      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["#{File.expand_path(rlib)}/*.rake"] }.flatten
+
+      # Load .buildr/_buildr.rb same directory as buildfile
+      %w{.buildr.rb _buildr.rb}.each do |f|
+        local_buildr = File.expand_path("#{File.dirname(Buildr.application.buildfile.to_s)}/#{f}")
+        files << local_buildr if File.exist?( local_buildr )
+      end
+
+      files.each do |file|
+        file = File.expand_path(file)
+        unless $LOADED_FEATURES.include?(file)
+          load file
+          $LOADED_FEATURES << file
+        end
+      end
+      buildfile.enhance files
+      true
+    end
+
+    def display_tasks_and_comments
+      displayable_tasks = tasks.select { |t| t.comment && t.name =~ options.show_task_pattern }
+      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
+        displayable_tasks.each do |t|
+          printf "buildr %-#{width}s  # %s\n",
+            t.name_with_args, max_column ? truncate(t.comment, max_column) : t.comment
+        end
+      end
+    end
+
+    def display_prerequisites
+      displayable_tasks = tasks.select { |t| t.name =~ options.show_task_pattern }
+      displayable_tasks.each do |t|
+        puts "buildr #{t.name}"
+        t.prerequisites.each { |pre| puts "    #{pre}" }
+      end
+    end
+
+    def standard_exception_handling # adds on_failure hook
+      begin
+        yield
+      rescue SystemExit => ex
+        # Exit silently with current status
+        exit(ex.status)
+      rescue OptionParser::ParseError => ex
+        $stderr.puts Buildr::Console.color(ex.message, :red)
+        exit(1)
+      rescue Exception => ex
+        ex_msg = ex.class.name == "Exception" ? ex.message : "#{ex.class.name} : #{ex.message}"
+        title, message = "Your build failed with an error", "#{Dir.pwd}:\n#{ex_msg}"
+        build_failed(title, message, ex)
+        # Exit with error message
+        $stderr.puts "Buildr aborted!"
+        $stderr.puts Buildr::Console.color(ex_msg, :red)
+        if options.trace
+          $stderr.puts ex.backtrace.join("\n")
+        else
+          $stderr.puts ex.backtrace.select { |str| str =~ /#{rakefile}/ }.map { |line| Buildr::Console.color(line, :red) }.join("\n") if rakefile
+          $stderr.puts "(See full trace by running task with --trace)"
+        end
+        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
+      ([name] + prerequisites).map { |f| File.stat(f).mtime }.max rescue Time.now
+    end
+  end
+
+
+  class << self
+
+    # Returns the Buildr::Application object.
+    def application
+      Rake.application
+    end
+
+    def application=(app) #:nodoc:
+      Rake.application = app
+    end
+
+    # Returns the Settings associated with this build.
+    def settings
+      Buildr.application.settings
+    end
+
+    # Copied from BUILD_ENV.
+    def environment
+      Buildr.application.environment
+    end
+
+  end
+
+  Buildr.application = Buildr::Application.new
+
+end
+
+alias :warn_without_color :warn
+
+# Show warning message.
+def warn(*message, uplevel: nil)
+  warn_without_color(Buildr::Console.color(message.join(' '), :blue), :uplevel => uplevel) if verbose
+end
+
+# 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)
+  puts Buildr::Console.color(message.to_s, :red)
+end
+
+# Show optional information.  The message is printed only when running in verbose
+# mode (the default).
+def info(message)
+  puts message if verbose
+end
+
+# Show message.  The message is printed out only when running in trace mode.
+def trace(message)
+  puts message if Buildr.application.options.trace
+end
+
+def trace?(*category)
+  options = Buildr.application.options
+  return options.trace if category.empty?
+  return true if options.trace_all
+  return false unless options.trace_categories
+  options.trace_categories.include?(category.first)
+end
+
+module Rake #:nodoc
+  # Rake's circular dependency checks (InvocationChain) only applies to task prerequisites,
+  # 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(*args)
+      task_args = TaskArguments.new(arg_names, args)
+      invoke_with_call_chain(task_args, Thread.current[:rake_chain] || InvocationChain::EMPTY)
+    end
+
+    def invoke_with_call_chain(task_args, invocation_chain)
+      new_chain = InvocationChain.append(self, invocation_chain)
+      @lock.synchronize do
+        if application.options.trace
+          puts "** Invoke #{name} #{format_trace_flags}"
+        end
+        return if @already_invoked
+        @already_invoked = true
+        begin
+          invoke_prerequisites(task_args, new_chain)
+        rescue
+          trace "Exception while invoking prerequisites of task #{self.inspect}"
+          raise
+        end
+        begin
+          old_chain, Thread.current[:rake_chain] = Thread.current[:rake_chain], new_chain
+          execute(task_args) if needed?
+        ensure
+          Thread.current[:rake_chain] = old_chain
+        end
+      end
+    end
+  end
+end
+
+module FileUtils
+  def fu_output_message(msg)   #:nodoc:
+    if Rake::FileUtilsExt::DEFAULT == RakeFileUtils.verbose_flag
+      # Swallow the default output
+    elsif RakeFileUtils.verbose_flag
+      @fileutils_output ||= $stderr
+      @fileutils_label ||= ''
+      @fileutils_output.puts @fileutils_label + msg
+    end
+  end
+  module_function :fu_output_message
+  private_class_method :fu_output_message
+end
+
+module ::Rake
+  class FileList
+    # Add matching glob patterns.
+    def add_matching(pattern)
+      # Patch to use File::FNM_DOTMATCH where appropriate
+      flags = 0
+      args = [pattern]
+      flags |= File::FNM_DOTMATCH if pattern =~ /\.\*/
+      flags |= File::FNM_EXTGLOB if pattern =~ /[^\\]\{.*\}/
+      args << flags unless 0 == flags
+      FileList.glob(*args).each do |fn|
+        self << fn unless exclude?(fn)
+      end
+    end
+    private :add_matching
+
+    class << self
+      def glob(pattern, *args)
+        Dir.glob(pattern, *args).sort
+      end
+    end
+  end
+end if RUBY_VERSION >= "2.0.0"