buildr 1.3.0-java

data/addon/buildr/javacc.rb

@@ -0,0 +1,85 @@
+# 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'
+
+
+module Buildr
+  # Provides JavaCC compile tasks. Require explicitly using <code>require "buildr/javacc"</code>.
+  module JavaCC
+
+    REQUIRES = [ "net.java.dev.javacc:javacc:jar:4.0", "net.java.dev.javacc:javacc:jar:4.0" ]
+
+    Java.classpath << REQUIRES
+
+    class << self
+
+      def javacc(*args)
+        options = Hash === args.last ? args.pop : {}
+        rake_check_options options, :output
+
+        args = args.flatten.map(&:to_s).collect { |f| File.directory?(f) ? FileList[f + "/**/*.jj"] : f }.flatten
+        args.unshift "-OUTPUT_DIRECTORY=#{options[:output]}" if options[:output]
+        Java.load
+        Java.org.javacc.parser.Main.mainProgram(args.to_java(Java.java.lang.String)) == 0 or
+          fail "Failed to run JavaCC, see errors above."
+      end
+
+      def jjtree(*args)
+        options = Hash === args.last ? args.pop : {}
+        rake_check_options options, :output, :build_node_files
+
+        args = args.flatten.map(&:to_s).collect { |f| File.directory?(f) ? FileList[f + "**/*.jjt"] : f }.flatten
+        args.unshift "-OUTPUT_DIRECTORY=#{options[:output]}" if options[:output]
+        args.unshift "-BUILD_NODE_FILES=#{options[:build_node_files] || false}"
+        Java.load
+        Java.org.javacc.jjtree.JJTree.new.main(args.to_java(Java.java.lang.String)) == 0 or
+          fail "Failed to run JJTree, see errors above."
+      end
+
+    end
+
+    def javacc(*args)
+      if Hash === args.last
+        options = args.pop 
+        in_package = options[:in_package].split(".")
+      else
+        in_package = []
+      end
+      file(path_to(:target, :generated, :javacc)=>args.flatten) do |task|
+        JavaCC.javacc task.prerequisites, :output=>File.join(task.name, in_package)
+      end         
+    end
+
+    def jjtree(*args)
+      if Hash === args.last
+        options = args.pop 
+        in_package = options[:in_package].split(".")
+        build_node_files = options[:build_node_files]
+      else
+        in_package = []
+      end
+      file(path_to(:target, :generated, :jjtree)=>args.flatten) do |task|
+        JavaCC.jjtree task.prerequisites, :output=>File.join(task.name, in_package), :build_node_files=>build_node_files
+      end         
+    end
+
+  end
+
+  class Project
+    include JavaCC
+  end
+end

data/addon/buildr/jdepend.rb

@@ -0,0 +1,60 @@
+# 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'
+
+
+module Buildr
+
+  # Addes the <code>jdepend:swing</code>, <code>jdepend:text</code> and <code>jdepend:xml</code> tasks.
+  # Require explicitly using <code>require "buildr/jdepend"</code>.
+  module Jdepend
+
+    REQUIRES = ["jdepend:jdepend:jar:2.9.1"]
+
+    class << self
+
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES).each(&:invoke).map(&:to_s)
+      end
+
+      def paths()
+        Project.projects.map(&:compile).each(&:invoke).map(&:target).
+          map(&:to_s).select { |path| File.exist?(path) }.map { |path| File.expand_path(path) }
+      end
+
+    end
+
+    namespace "jdepend" do
+
+      desc "Runs JDepend on all your projects (Swing UI)"
+      task "swing" do
+        Java::Commands.java "jdepend.swingui.JDepend", paths, :classpath=>requires, :name=>"JDepend"
+      end
+
+      desc "Runs JDepend on all your projects (Text UI)"
+      task "text" do
+        Java::Commands.java "jdepend.textui.JDepend", paths, :classpath=>requires, :name=>"JDepend"
+      end
+
+      desc "Runs JDepend on all your projects (XML output to jdepend.xml)"
+      task "xml" do
+        Java::Commands.java "jdepend.xmlui.JDepend", "-file", "jdepend.xml", paths, :classpath=>requires, :name=>"JDepend"
+        puts "Created jdepend.xml"
+      end
+    end
+  end
+end

data/addon/buildr/jetty.rb

@@ -0,0 +1,248 @@
+# 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 'uri'
+require 'net/http'
+require 'buildr/core/project'
+require 'buildr/java'
+require 'buildr/packaging'
+require 'thread'
+
+
+module Buildr
+
+  # Provides a collection of tasks and methods for using Jetty, specifically as a server
+  # for testing your application.
+  #
+  # Build files should always start Jetty by invoking the #use task, typically as
+  # a prerequisite. This task will start Jetty once during the build, and shut it down
+  # when the build completes.
+  #
+  # If you want to keep Jetty running across builds, and look at error messages, you can
+  # start Jetty in a separate console with:
+  #   buildr jetty:start
+  # To stop this instance of Jetty, simply kill the process (Ctrl-C) or run:
+  #   buildr jetty:stop
+  #
+  # If you start Jetty separately from the build, the #use task will connect to that
+  # existing server. Since you are using Jetty across several builds, you will want to
+  # cleanup any mess created by each build. You can use the #setup and #teardown tasks,
+  # which are called when Jetty is first used in the build, and when the build ends.
+  class Jetty
+
+    # Which version of Jetty we're using by default (change with options.jetty.version).
+    VERSION = "6.1.3" unless const_defined?('VERSION')
+    SLF4J_VERSION = "1.4.3"
+    
+    # Libraries used by Jetty.
+    REQUIRES = [ "org.mortbay.jetty:jetty:jar:#{VERSION}", "org.mortbay.jetty:jetty-util:jar:#{VERSION}",
+      "org.mortbay.jetty:servlet-api-2.5:jar:#{VERSION}", "org.slf4j:slf4j-api:jar:#{SLF4J_VERSION}", 
+      "org.slf4j:slf4j-simple:jar:#{SLF4J_VERSION}", "org.slf4j:jcl104-over-slf4j:jar:#{SLF4J_VERSION}" ]
+     
+    Java.classpath <<  REQUIRES
+    Java.classpath << File.dirname(__FILE__)
+    
+    # Default URL for Jetty (change with options.jetty.url).
+    URL = "http://localhost:8080"
+
+    class << self
+
+      # :call-seq:
+      #   instance() => Jetty
+      #
+      # Returns an instance of Jetty.
+      def instance()
+        @instance ||= Jetty.new("jetty", URL)
+      end
+
+    end
+
+    def initialize(name, url) #:nodoc:
+      @url = url
+      namespace name do
+        @setup = task("setup")
+        @teardown = task("teardown")
+        @use = task("use") { fire }
+      end
+    end
+
+    # The URL for the Jetty server. Leave as is if you want to use the default server
+    # (http://localhost:8080).
+    attr_accessor :url
+
+    # :call-seq:
+    #    start(pipe?)
+    #
+    # Starts Jetty. This method does not return, it keeps the thread running until
+    # Jetty is stopped. If you want to run Jetty parallel with other tasks in the build,
+    # invoke the #use task instead.
+    def start(sync = nil)
+      begin
+        puts "classpath #{Java.classpath.inspect}"
+        port = URI.parse(url).port
+        puts "Starting Jetty at http://localhost:#{port}" if verbose
+        Java.load
+        jetty = Java.org.apache.buildr.JettyWrapper.new(port)
+        sync << "Started" if sync
+        sleep # Forever
+      rescue Interrupt # Stopped from console
+      rescue Exception=>error
+        puts "#{error.class}: #{error.message}"
+      end
+      exit! # No at_exit
+    end
+
+    # :call-seq:
+    #    stop()
+    #
+    # Stops Jetty. Stops a server running in a separate process.
+    def stop()
+      uri = URI.parse(url)
+      begin
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request_post "/buildr/stop", ""
+        end
+      rescue Errno::ECONNREFUSED
+        # Expected if Jetty server not running.
+      rescue EOFError
+        # We get EOFError because Jetty is brutally killed.
+      end
+      puts "Jetty server stopped"
+    end
+
+    # :call-seq:
+    #   running?() => boolean
+    #
+    # Returns true if it finds a running Jetty server that supports the Buildr
+    # requests for deploying, stopping, etc.
+    def running?()
+      uri = URI.parse(url)
+      begin
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          response = http.request_get("/buildr/")
+          response.is_a?(Net::HTTPSuccess) && response.body =~ /Alive/
+        end
+      rescue Errno::ECONNREFUSED, Errno::EBADF 
+        false
+      end
+    end
+
+    # :call-seq:
+    #   deploy(url, webapp) => path
+    #
+    # Deploy a WAR in the specified URL.
+    def deploy(url, webapp)
+      use.invoke
+      uri = URI.parse(url)
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        response = http.request_post("/buildr/deploy", "webapp=#{webapp}&path=#{uri.path}")
+        if Net::HTTPOK === response && response.body =~ /Deployed/
+          path = response.body.split[1]
+          puts "Deployed #{webapp}, context path #{uri.path}" if Rake.application.options.trace
+          path
+        else
+          fail "Deployment failed: #{response}"
+        end
+      end
+    end
+
+    # :call-seq:
+    #   undeploy(url) => boolean
+    #
+    # Undeploys a WAR from the specified URL.
+    def undeploy(url)
+      use.invoke
+      uri = URI.parse(url)
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        response = http.request_post("/buildr/undeploy", "path=#{uri.path}")
+        if Net::HTTPOK === response && response.body =~ /Undeployed/
+          true
+        else
+          fail "Deployment failed: #{response}"
+        end
+      end
+    end
+
+    # :call-seq:
+    #   setup(*prereqs) => task
+    #   setup(*prereqs) { |task| .. } => task
+    #
+    # This task executes when Jetty is first used in the build. You can use it to
+    # deploy artifacts into Jetty.
+    def setup(*prereqs, &block)
+      @setup.enhance prereqs, &block
+    end
+
+    # :call-seq:
+    #   teardown(*prereqs) => task
+    #   teardown(*prereqs) { |task| .. } => task
+    #
+    # This task executes when the build is done. You can use it to undeploy artifacts
+    # previously deployed into Jetty.
+    def teardown(*prereqs, &block)
+      @teardown.enhance prereqs, &block
+    end
+
+    # :call-seq:
+    #   use(*prereqs) => task
+    #   use(*prereqs) { |task| .. } => task
+    #
+    # If you intend to use Jetty, invoke this task. It will start a new instance of
+    # Jetty and close it when the build is done. However, if you already have a server
+    # running in the background (e.g. jetty:start), it will use that server and will
+    # not close it down.
+    def use(*prereqs, &block)
+      @use.enhance prereqs, &block
+    end
+
+  protected
+
+    # If you want to start Jetty inside the build, call this method instead of #start.
+    # It will spawn a separate process that will run Jetty, and will stop Jetty when
+    # the build ends. However, if you already started Jetty from the console (with
+    # take jetty:start), it will use the existing instance without shutting it down.
+    def fire()
+      unless running?
+        sync = Queue.new
+        Thread.new { start sync }
+        # Wait for Jetty to fire up before doing anything else.
+        sync.pop == "Started" or fail "Jetty not started"
+        puts "Jetty started" if verbose
+        at_exit { stop }
+      end
+      @setup.invoke
+      at_exit { @teardown.invoke }
+    end
+
+  end
+
+  namespace "jetty" do
+    desc "Start an instance of Jetty running in the background"
+    task("start") { Jetty.instance.start }
+    desc "Stop an instance of Jetty running in the background"
+    task("stop") { Jetty.instance.stop }
+  end
+
+  # :call-seq:
+  #   jetty() => Jetty
+  #
+  # Returns a Jetty object. You can use this to discover the Jetty#use task,
+  # configure the Jetty#setup and Jetty#teardown tasks, deploy and undeploy to Jetty.
+  def jetty()
+    @jetty ||= Jetty.instance
+  end
+
+end

data/addon/buildr/nailgun.rb

@@ -0,0 +1,892 @@
+# 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 'benchmark'
+require 'jruby'
+require 'monitor'
+require 'ostruct'
+require 'rbconfig'
+require 'thread'
+require 'buildr/core/application_cli'
+
+module Buildr
+
+  #  See the nailgun_help method for documentation.
+  module Nailgun # :nodoc:
+    extend self
+    
+    VERSION = '0.7.1'
+    NAME = "nailgun-#{VERSION}"
+    URL = "http://downloads.sourceforge.net/nailgun/#{NAME}.zip"
+    ARTIFACT_SPEC = "com.martiansoftware:nailgun:jar:#{VERSION}"
+    BUILDR_PATHS = [File.expand_path('../', File.dirname(__FILE__)),
+                    File.expand_path('../../lib', File.dirname(__FILE__))]
+    
+    attr_accessor :artifact
+    attr_accessor :server, :port, :jruby_queue_size, :buildr_queue_size
+    attr_accessor :jruby_home, :home
+    
+    self.jruby_home = if PLATFORM =~ /java/
+                        Config::CONFIG['prefix']
+                      else
+                        ENV['JRUBY_HOME'] || File.join(ENV['HOME'], '.jruby')
+                      end
+    
+    self.home = ENV['NAILGUN_HOME'] || File.join(jruby_home, 'tool', 'nailgun')
+    self.server = 'localhost'
+    self.port = 2113
+    self.jruby_queue_size = 3
+    self.buildr_queue_size = 3
+
+    def namespace(&block)
+      if Object.const_defined?(:Rake)
+        Rake.application.in_namespace(:nailgun, &block)
+      end
+    end
+
+    def boot(&block)
+      if block
+        @boot = block
+      else
+        @boot.call
+      end
+    end
+
+    module Application
+      def nailgun_help
+        "  " + <<-DESC.strip.gsub(/ *\n +/, "\n  ")
+          NailGun is a client, protocol, and server for running Java 
+          programs from the command line without incurring the JVM
+          startup overhead. Nailgun integration is currently available
+          only when running Buildr with JRuby.
+
+          Buildr provides a custom nailgun server, allowing you to 
+          start a single JVM and let buildr create a queue of runtimes.
+          These JRuby runtimes can be cached (indexed by buildfile path)
+          and are automatically reloaded when the buildfile has been modified.
+          Runtime caching allows you to execute tasks without
+          spending time creating the buildr environment. Some nailgun 
+          tasks have been provided to manage the cached runtimes.
+
+          To start the buildr server execute the following task:
+
+              nailgun:start
+
+          Server output will display a message when it becomes ready, you
+          will also see messages when the JRuby runtimes are being created,
+          or when a new buildr environment is being loaded on them.
+          After the runtime queues have been populated, you can start calling
+          buildr as you normally do, by invoking the $NAILGUN_HOME/ng binary:
+
+              # on another terminal, change directory to a project.
+              # if this project is the same nailgun:start was invoked on, it's 
+              # runtime has been cached, so no loading is performed unless 
+              # the buildfile has been modified. otherwise the buildfile 
+              # will be loaded on a previously loaded fresh-buildr runtime
+              # and it will be cached.
+              cd /some/buildr/project
+              ng nailgun:help                      # display nailgun help
+              ng nailgun:tasks                     # display overview of ng tasks
+              ng clean compile                # just invoke those two tasks
+
+             Configuration and Environment Variables.
+
+          Before starting the server, buildr will check if you have 
+          nailgun already installed by seeking the nailgun jar under
+
+              $NAILGUN_HOME
+
+          You can override this environment variable to tell buildr where
+          to find or where to install nailgun. If missing, NAILGUN_HOME
+          defaults to the $JRUBY_HOME/tool/nailgun directory. You can 
+          also specify the nailgun_home on your buildfile with the following
+          code:
+              
+              require 'buildr/nailgun'
+              Buildr::Nailgun.home = File.expand_path('~/.jruby/tool/nailgun')
+
+          Buildr will also check that the nailgun client binary (ng.exe for 
+          Windows systems, ng otherwise) is installed on NAILGUN_HOME. 
+          If no binary is found, buildr will download nailgun and 
+          compile+install it.
+          
+          
+          The buildr server binds itself to localhost, port 2113. You can 
+          override this on your buildfile, by placing the following code:
+
+              require 'buildr/nailgun'
+              Buildr::Nailgun.server = '127.0.0.1'
+              Buildr::Nailgun.port = 2233
+
+          If you provided custom host/port settings you need
+          to tell the nailgun client where to connect to:
+
+              ng --nailgun-server 127.0.0.1 --nailgun-port 2233 nailgun:tasks
+
+          The buildr server starts a BuildrFactory responsible for providing
+          a pool of JRuby runtimes configured and ready for task execution. 
+          This BuildrFactory consists of two queues: One of pure JRuby runtimes
+          with almost nothing loaded, and another of Buildr runtimes (consumed
+          from the first queue) with the Buildr runtime preloaded but without
+          any project definition. The jruby queue is used for sandboxing code
+          like running GetoptLong, but most importantly its the place where 
+          buildr runtimes begin life, to be later added on the buildr queue.
+          By default both queues are of size 3, you can customize this with:
+
+              require 'buildr/nailgun'
+              Buildr::Nailgun.jruby_queue_size = 4 # JRuby creation is fast!
+              Buildr::Nailgun.buildr_queue_size = 5 # loading buildr takes longer
+
+          The buildr_queue_size is of particular importance if you expect to 
+          reload lots of buildfiles.
+ 
+          Execute nailgun:tasks get an overview of available nailgun tasks.
+          
+        DESC
+      end
+      
+      def nailgun_tasks
+        tasks = {}
+        tasks['nailgun:help'] = 'Display nailgun help'
+        tasks['nailgun:start'] = 'Start the Nailgun server.'
+        tasks['nailgun:stop'] = 'Stop the Nailgun server.'
+        tasks['nailgun:tasks'] = 'Display this message'
+        tasks['nailgun:list'] = <<-DESC
+                 Display a list of builfile paths having an associated
+                 buildr runtime. Having a cached runtime reduces buidlr
+                 execution time.
+
+                 If buildr finds the current buildfile on this list, 
+                 no file loading will be performed, only execution of 
+                 specified tasks on the previously loaded environment. 
+                 However if the cached runtime is out of date (buildfile
+                 has been modified) the runtime will be reloaded.
+
+                 This feature becomes handy when performing development
+                 cycle: edit -> compile -> test -> report. 
+
+                 This task exits inmediatly after printing the file list.
+            DESC
+        tasks['nailgun:clear'] = <<-DESC
+                 Remove all cached buildr runtimes and exit
+            DESC
+        tasks['nailgun:load'] = <<-DESC
+                 Add or update a cached runtime.
+                 
+                 Use this task to create a cached buildr runtime for a 
+                 buildfile.
+            DESC
+        tasks['nailgun:delete'] = <<-DESC
+                 Delete cached runtime for a buildfile and exit.
+            DESC
+        tasks['nailgun:once [tasks]'] = <<-DESC
+                 Ignore cached runtime and perform tasks on a newly 
+                 created environment. This new runtime is dropped right
+                 after buildr completion.
+            DESC
+        
+        out = ""
+        out << "\nNailgun tasks:\n"
+        tasks.each_pair do |task, desc|
+          out << "\n"
+          out << sprintf("  %20-s\n", [task].flatten.join(' | '))
+          out << sprintf("      %s\n", desc.strip.gsub(/ *\n +/, "\n      "))
+        end
+        out
+      end
+      
+      def buildfile(dir = nil, candidates = nil)
+        dir ||= Dir.pwd
+        candidates ||= @rakefiles.dup
+        Util.find_buildfile(dir, candidates, options.nosearch)
+      end
+      
+      def clear_invoked
+        tasks.each do |task|
+          is_project = Project.instance_variable_get(:@projects).key?(task.name)
+          task.instance_variable_set(:@already_invoked, false) unless is_project
+        end
+      end
+
+      if Buildr.const_defined?(:Application)
+        class Buildr::Application
+          include Nailgun::Application
+          public :requires
+        end
+      end
+    end
+    
+    module ContextRunner
+      extend self
+      
+      def parse_options(ctx, opts)
+        opts.requires = []
+        Buildr.const_set(:VERSION, ctx.server.runtime.object.const_get(:Buildr)::VERSION)
+  
+        obj = OpenStruct.new(:ctx => ctx, :opts => opts)
+        class << obj
+          include Buildr::CommandLineInterface
+          
+          def help
+            super
+            puts 
+            puts 'To get a summary of Nailgun features use'
+            puts '  nailgun:help'
+          end
+
+          def do_option(opt, value)
+            case opt
+            when '--help'
+              help
+              opts.exit = true
+            when '--version'
+              puts version
+              opts.exit = true
+            when '--environment'
+              ctx.env['BUILDR_ENV'] = value
+            when '--buildfile'
+              opts.buildfile = value
+            when '--require'
+              opts.requires << value
+            when '--nosearch'
+              opts.nosearch = true
+            end
+          end
+        end
+        
+        ARGV.replace(ctx.argv)
+        obj.parse_options
+      end
+      
+      def run(ctx)
+        ARGV.replace(ctx.argv)
+        Dir.chdir(ctx.pwd)
+        ctx.env.each { |k, v| ENV[k.to_s] = v.to_s }
+        Buildr::Application.module_eval do
+          include Nailgun::Application
+        end
+        task 'nailgun:load' do
+          puts "Buildfile #{Rake.application.buildfile} loaded"
+        end
+        if ctx.fresh
+          run_fresh(ctx)
+        else
+          run_local(ctx)
+        end
+      end
+      
+      private
+      
+      def run_fresh(ctx)
+        Project.clear
+        old_app = Rake.application
+        Rake.application = Buildr::Application.new
+        Rake.application.instance_eval do
+          @tasks = old_app.instance_variable_get(:@tasks)
+          @rules = old_app.instance_variable_get(:@rules)
+          run
+        end
+      end
+
+      def run_local(ctx)
+        Rake.application.instance_eval do
+          verbose(nil)
+          options.trace = false
+          parse_options
+          collect_tasks
+          clear_invoked
+          top_level_tasks.delete('buildr:initialize')
+          Util.benchmark { top_level } 
+        end
+      end
+    end
+
+    module Util
+      extend self
+
+      def find_buildfile(pwd, candidates, nosearch=false)
+        candidates = [candidates].flatten
+        buildfile = candidates.find { |c| File.file?(File.expand_path(c, pwd)) }
+        return File.expand_path(buildfile, pwd) if buildfile
+        return nil if nosearch
+        updir = File.dirname(pwd)
+        return nil if File.expand_path(updir) == File.expand_path(pwd)
+        find_buildfile(updir, candidates)
+      end
+      
+      def benchmark(action = ['Completed'], verbose = true)
+        result = nil
+        times = Benchmark.measure do
+          result = yield(action)
+        end
+        if verbose
+          real = []
+          real << ("%ih" % (times.real / 3600)) if times.real >= 3600
+          real << ("%im" % ((times.real / 60) % 60)) if times.real >= 60
+          real << ("%.3fs" % (times.real % 60))
+          puts "#{[action].flatten.join(' ')} in #{real.join}"
+        end
+        result
+      end
+
+      def on_runtime(runtime, *args, &block)
+        raise_error = lambda do |cls, msg, trace|
+          raise RuntimeError.new(cls + ": "+ msg.to_s).tap { |e| e.set_backtrace(trace.map(&:to_s)) }
+        end
+        executor = runtime.object.const_get(:Module).new do
+          extend self
+          def runtime_exec(*args, &prc)
+            define_method(:runtime_exec, &prc)
+            runtime_exec(*args)
+          rescue => e
+            [:error, e.class.name, e.message, e.backtrace]
+          end
+        end
+        result = executor.runtime_exec(*args, &block)
+        raise_error.call(*result[1..-1]) if result.kind_of?(Array) && result.first == :error
+        result
+      end
+    end # module Util
+
+    boot do
+      
+      class ::ConcreteJavaProxy
+        def self.jclass(name = nil)
+          name ||= self.java_class.name
+          Nailgun::Util.class_for_name(name)
+        end
+        
+        def self.jnew(*args)
+          objs = []
+          classes = args.map do |a|
+            case a
+            when nil
+              obj << nil
+              nil
+            when Hash
+              objs << a.keys.first
+              cls = a.values.first
+              cls = Nailgun::Util.proxy_class(cls) if String == cls
+              cls
+            else
+              objs << a
+              a.java_class
+            end
+          end
+          classes = classes.to_java(java.lang.Class)
+          ctor = jclass.getDeclaredConstructor(classes)
+          ctor.setAccessible(true)
+          ctor.newInstance(objs.to_java(java.lang.Object))
+        end
+      end
+
+      module Util
+        def class_for_name(name)
+          java.lang.Class.forName(name)
+        end
+        
+        def add_to_sysloader(path)
+          sysloader = java.lang.ClassLoader.system_class_loader
+          add_url_method = class_for_name('java.net.URLClassLoader').
+            getDeclaredMethod('addURL', [java.net.URL].to_java(java.lang.Class))
+          add_url_method.accessible = true
+          add_url_method.invoke(sysloader, [java.io.File.new(path.to_s).
+                                            toURL].to_java(java.net.URL))
+        end
+        add_to_sysloader Nailgun.artifact
+        
+        def proxy_class(name)
+          JavaUtilities.get_proxy_class(name)
+        end
+
+        import org.jruby.RubyIO 
+        def set_stdio(runtime, dev)
+          set_global = lambda do |global, constant, stream|
+            runtime.global_variables.set(global, stream)
+            runtime.object.send(:remove_const, constant)
+            runtime.object.send(:const_set, constant, stream)
+          end
+          stdin  = runtime.global_variables.get('$stdin')
+          stdout = runtime.global_variables.get('$stdout')
+          stderr = runtime.global_variables.get('$stderr')
+          input  = RubyIO.jnew(runtime, dev.in => java.io.InputStream)
+          output = RubyIO.jnew(runtime, dev.out => java.io.OutputStream)
+          error = RubyIO.jnew(runtime, dev.err => java.io.OutputStream)
+          # stdin.reopen(input, 'r') # not working on jruby, :(
+          set_global.call('$stdin', 'STDIN', input)
+          stdout.reopen(output, 'w')
+          stderr.reopen(error, 'w')
+        end
+
+        def redirect_stdio(runtime, nail)
+          result = nil
+          begin 
+            set_stdio(runtime, nail)
+            result = yield
+          ensure
+            set_stdio(runtime, java.lang.System)
+          end
+          result
+        end
+      end
+
+      class Buildfile
+        attr_reader :path, :requires, :loaded_time
+        attr_accessor :runtime
+        
+        def initialize(path, *requires)
+          @path = File.expand_path(path)
+          @requires = requires.dup
+        end
+
+        def loaded!
+          @loaded_time = Time.now
+        end
+
+        def last_modification
+          File.timestamp(path)
+        end
+        
+        def should_be_loaded?
+          (loaded_time || Rake::EARLY) < last_modification
+        end
+        
+        def to_s
+          buff = path.dup
+          buff << sprintf("\n  %-25s %s", "Last Modified:", last_modification)
+          unless requires.empty?
+            buff << sprintf("\n  %-25s %s", "Requires:", requires.join(" ")) 
+          end
+          if should_be_loaded?
+            buff << sprintf("\n  %-25s %s", "Needs reload, last was:", loaded_time)
+          else
+            buff << sprintf("\n  %-25s %s", "Loaded at:", loaded_time)
+          end
+          buff << sprintf("\n  %-25s %s", "Runtime:", runtime)
+          buff
+        end        
+      end
+      
+      class BuildrNail 
+        include org.apache.buildr.BuildrNail
+        Main = Util.proxy_class 'org.apache.buildr.BuildrNail$Main'
+
+        attr_reader :buildfile
+        
+        def initialize
+          buildfile = Buildfile.new(Rake.application.buildfile,
+                                    *Rake.application.requires)
+          buildfile.loaded!
+          buildfile.runtime = JRuby.runtime
+          @buildfiles = { buildfile.path => buildfile }
+        end
+
+        def main(nail)
+          Thread.exclusive { Thread.current.priority = 100; run(nail) }
+        end
+
+        private
+        def run(nail)
+          nail.assert_loopback_client
+          nail.out.println "Using #{nail.getNGServer}"
+          ctx = context_from_nail(nail)
+          
+          case ctx.action
+          when :start
+            nail.out.println "Cannot start nailgun when running as client"
+            return nail.exit(0)
+          when :stop
+            puts "Stopping #{nail.getNGServer}"
+            nail.out.println "Stopping #{nail.getNGServer}"
+            return nail.getNGServer.shutdown(true)
+          when :list
+            if @buildfiles.empty?
+              nail.out.println "No defined runtimes"
+            else
+              nail.out.println "Defined runtimes:"
+              @buildfiles.each_value { |f| nail.out.println "- #{f}" }
+            end
+            return nail.exit(0)
+          when :clear
+            @buildfiles.clear
+            nail.out.println "Cleared all runtimes"
+            return nail.exit(0)
+          when :tasks
+            nail.out.println ""
+            nail.out.println Rake.application.nailgun_tasks
+            return nail.exit(0)
+          when :help
+            nail.out.println ""
+            nail.out.println Rake.application.nailgun_help
+            return nail.exit(0)
+          end
+          
+          opts = OpenStruct.new
+          
+          runtime = ctx.runtime
+          #Util.set_stdio(runtime, nail)
+          runtime.object.const_get(:Buildr)::Nailgun::ContextRunner.parse_options(ctx, opts)
+          return nail.exit(0) if opts.exit
+
+          candidates = Buildr::Application::DEFAULT_BUILDFILES
+          candidates = [opts.buildfile] if opts.buildfile
+          
+          path = Util.find_buildfile(ctx.pwd, candidates, opts.nosearch) ||
+            File.expand_path(candidates.first, ctx.pwd)
+          
+          if ctx.action == :delete
+            nail.out.println "Deleting runtime for #{path}"
+            @buildfiles.delete(path)
+            return nail.exit(0)
+          end
+
+          puts "Getting buildr runtime for #{path}"
+          buildfile = @buildfiles[path] || Buildfile.new(path, *opts.requires)
+          
+          save = buildfile.should_be_loaded? || ctx.action == :load
+          
+          runtime = buildfile.runtime
+
+          if save || ctx.action == :once
+            ctx.argv.unshift 'nailgun:load'
+            ctx.fresh = true
+            runtime = ctx.buildr
+            if save
+              buildfile.runtime = runtime
+              buildfile.loaded!
+              @buildfiles[buildfile.path] = buildfile
+            end
+          end
+
+          Util.redirect_stdio(runtime, nail) do
+            runtime.object.send :puts
+            runtime.object.const_get(:Buildr)::Nailgun::ContextRunner.run(ctx)
+          end
+        end
+        
+        def context_from_nail(nail)
+          ctx = OpenStruct.new
+          ctx.pwd = nail.getWorkingDirectory
+          ctx.env = nail.env
+          ctx.argv = [nail.command] + nail.args.map(&:to_s)
+          ctx.server = nail.getNGServer
+          def ctx.runtime; @runtime ||= server.buildr_factory.runtime; end
+          def ctx.buildr; @buildr ||= server.buildr_factory.obtain; end
+          actions = {
+            :load   => %w{ nailgun:load },
+            :delete => %w{ nailgun:delete },
+            :clear  => %w{ nailgun:clear },
+            :list   => %w{ nailgun:list },
+            :start  => %w{ nailgun:boot nailgun:start },
+            :stop   => %w{ nailgun:stop },
+            :once   => %w{ nailgun:once },
+            :tasks  => %w{ nailgun:tasks },
+            :help   => %w{ nailgun:help help:nailgun },
+          }
+          action = actions.find { |k,v| k if v.any? { |t| ctx.argv.delete(t) } }
+          ctx.action = action.first if action
+          ctx
+        end
+        
+      end # class BuildrNail
+
+      class BuildrFactory
+        
+        attr_accessor :buildrs_size, :runtimes_size
+        
+        def initialize(buildrs_size = 1, runtimes_size = nil)
+          runtimes_size ||= buildrs_size
+          @buildrs_size = buildrs_size < 1 ? 1 : buildrs_size
+          @runtimes_size = runtimes_size < 1 ? 1 : runtimes_size
+
+          @buildrs = [].extend(MonitorMixin)
+          @buildrs_ready = @buildrs.new_cond
+          @buildrs_needed = @buildrs.new_cond
+                    
+          @buildrs_creators = [].extend(MonitorMixin)
+
+          @runtimes = [].extend(MonitorMixin)
+          @runtimes_ready = @runtimes.new_cond
+          @runtimes_needed = @runtimes.new_cond
+          
+          @runtimes_creators = [].extend(MonitorMixin)
+        end
+        
+        def obtain
+          get(:buildr)
+        end
+
+        def runtime
+          get(:runtime)
+        end
+
+        def start
+          debug "Starting Buildr runtime factory"
+          @runtime_creator = Thread.new { loop { create :runtime } }
+          @runtime_creator.priority = -2
+          @buildr_creator = Thread.new { loop { create :buildr } }
+          @buildr_creator.priority = 1
+        end
+
+        def stop
+          @buildr_creator.kill if @buildr_creator
+          @runtime_creator.kill if @runtime_creator
+        end
+
+        private
+        def debug(*msg)
+          puts *msg if Rake.application.options.trace
+        end
+
+        def get(thing)
+          collection = instance_variable_get("@#{thing}s")
+          needs = instance_variable_get("@#{thing}s_needed")
+          ready = instance_variable_get("@#{thing}s_ready")
+          result = nil
+          collection.synchronize do 
+            if collection.empty?
+              debug "no #{thing} available, ask to create more"
+              needs.broadcast
+              debug "should be creating #{thing}"
+              ready.wait_while { collection.empty? }
+            end
+            debug "Getting my #{thing}"
+            result = collection.shift
+            debug "would need more #{thing}s"
+            needs.broadcast
+            debug "got my #{thing}: #{result.inspect}"
+            Thread.pass
+          end
+          debug "returning #{result.inspect}"
+          result
+        end
+
+        def create(thing, *args, &prc)
+          creator = needed(thing)
+          collection = instance_variable_get("@#{thing}s")
+          ready = instance_variable_get("@#{thing}s_ready")
+          needs = instance_variable_get("@#{thing}s_needed")
+          unless creator
+            collection.synchronize do
+              debug "awake those wanting a #{thing}"
+              ready.broadcast
+              Thread.pass
+              debug "wait until more #{thing}s are needed"
+              # needs.wait(1); return
+              needs.wait_until { creator = needed(thing) }
+            end
+          end
+          debug "About to create #{thing} # #{creator}"
+          method = "create_#{thing}"
+          creators = instance_variable_get("@#{thing}s_creators")
+          debug "registering creator for #{thing} #{creator}"
+          creators.synchronize { creators << creator }
+          result = send(method, creator, *args, &prc)
+          debug "created #{thing}[#{creator}] => #{result.inspect}"
+          creators.synchronize do 
+            debug "unregistering creator for #{thing} #{creator}"
+            creators.delete(creator)
+            collection.synchronize do
+              debug "adding object on queue for #{thing} #{creator}"
+              collection << result
+            end
+          end
+        rescue => e
+          puts "#{e.backtrace.shift}: #{e.message}"
+          e.backtrace.each { |i| puts "\tfrom #{i}" }
+        end
+        
+        def needed(thing)
+          collection = instance_variable_get("@#{thing}s")
+          creators = instance_variable_get("@#{thing}s_creators")
+          size = instance_variable_get("@#{thing}s_size")
+          collection.synchronize do
+            count = collection.size
+            if count < size
+              count += creators.synchronize { creators.size }
+            end
+            count if count < size
+          end
+        end
+
+        def create_runtime(creator)
+          debug "Creating runtime[#{creator}]"
+          Util.benchmark do |header|
+            runtime = org.jruby.Ruby.newInstance
+            runtime.global_variables.set('$nailgun_server', JRuby.reference($nailgun_server))
+            BUILDR_PATHS.each { |path| runtime.load_service.load_path.unshift path }
+            runtime.load_service.require 'buildr/nailgun'
+            header.replace ["Created runtime[#{creator}]", runtime]
+            runtime
+          end
+        end
+
+        def create_buildr(creator)
+          debug "Obtaining runtime to load buildr[#{creator}] on it"
+          runtime = get(:runtime)
+          debug "Loading buildr[#{creator}] on #{runtime} ..."
+          Util.benchmark ["Loaded buildr[#{creator}] on #{runtime}"] do
+            load_service = runtime.load_service
+            load_service.require 'rubygems'
+            load_service.require 'buildr'
+          end
+          runtime
+        end
+        
+      end # BuildrFactory
+      
+      class BuildrServer < com.martiansoftware.nailgun.NGServer
+        
+        attr_reader :buildr_factory
+
+        def initialize(host = 'localhost', port = 2113, buildr_factory = nil)
+          super(java.net.InetAddress.get_by_name(host), port)
+          @buildr_factory = buildr_factory
+          @host, @port = host, port
+        end
+
+        def runtime
+          JRuby.runtime
+        end
+
+        def start_server
+          self.allow_nails_by_class_name = false
+
+          BuildrNail::Main.nail = BuildrNail.new
+          self.default_nail_class = BuildrNail::Main
+          buildr_factory.start
+          
+          @thread = java.lang.Thread.new(self)
+          @thread.setName(to_s)
+          @thread.start
+          
+          sleep 1 while getPort == 0
+          puts "#{self} Started."
+        end
+
+        def stop_server
+          buildr_factory.stop
+          @thread.kill
+        end
+
+        def to_s
+          "BuildrServer(" <<
+            [Rake.application.version, @host, @port].join(", ") <<
+            ")"
+        end
+      end # class BuildrServer
+
+    end # Nailgun boot
+    
+    namespace do
+      tmp = lambda { |*files| File.join(Dir.tmpdir, "nailgun", *files) }
+      dist_zip = Buildr.download(tmp[NAME + ".zip"] => URL)
+      dist_dir = Buildr.unzip(tmp[NAME] => dist_zip)
+      
+      if File.exist?(File.join(home, NAME + ".jar"))
+        ng_jar = file(File.join(home, NAME + ".jar"))
+      else
+        ng_jar = file(tmp[NAME, NAME, NAME+".jar"] => dist_dir)
+      end
+      
+      self.artifact = Buildr.artifact(ARTIFACT_SPEC).from(ng_jar)
+      
+      compiled_bin = tmp[NAME, NAME, "ng"+Config::CONFIG['EXEEXT']]
+      compiled_bin = file(compiled_bin => dist_dir.target) do |task|
+        unless task.to_s.pathmap('%x') == '.exe'
+          Dir.chdir(task.to_s.pathmap('%d')) do
+            puts "Compiling #{task.to_s}"
+            system('make', task.to_s.pathmap('%f')) or
+              fail "Nailgun binary compilation failed."
+          end
+        end
+      end
+
+      installed_bin = file(File.join(home, 
+          compiled_bin.to_s.pathmap('%f')) => compiled_bin) do |task|
+        mkpath task.to_s.pathmap('%d'), :verbose => false
+        cp compiled_bin.to_s, task.to_s, :verbose => false
+      end
+
+      task :boot => artifact do |task|
+        if $nailgun_server
+          raise "Already nunning on Nailgun server: #{$nailgun_server}"
+        end
+        tasks = Rake.application.instance_eval { @top_level_tasks.dup }
+        tasks.delete_if do |t| 
+          t =~ /^(buildr:initialize|(ng|nailgun):.+)$/
+        end
+        unless tasks.empty?
+          raise "Don't specify more targets when starting Nailgun server"
+        end
+        boot
+      end
+      
+      task :start => [installed_bin, :boot] do
+        factory = BuildrFactory.new(buildr_queue_size, jruby_queue_size)
+        $nailgun_server = BuildrServer.new(server, port, factory)
+        puts "Starting #{$nailgun_server}"
+        $nailgun_server.start_server
+
+        is_win = Buildr::Util.win_os?
+        bin_path = File.expand_path(installed_bin.to_s.pathmap("%d"))
+        bin_name = installed_bin.to_s.pathmap("%f")
+
+        puts <<-NOTICE
+
+        Buildr server has been started, you may need to update your PATH
+        variable in order to execute the #{bin_name} binary.
+
+          #{ is_win ?
+             "> set NAILGUN_HOME=#{bin_path}" :
+             "$ export NAILGUN_HOME=#{bin_path}"
+           }
+          #{ is_win ?
+             "> set PATH=%NAILGUN_HOME%;%PATH%" :
+             "$ export PATH=${NAILGUN_HOME}:${PATH}"
+           }
+           
+        Runtime for #{Rake.application.buildfile} has been cached, this 
+        means you can open a terminal inside 
+
+              #{Rake.application.buildfile.pathmap("%d")}
+
+        Invoke tasks by executing the #{bin_name} program, it takes the
+        same parameters you normally use for ``buildr''. 
+
+        To display Nailgun related help, execute the command:
+            ``#{bin_name} nailgun:help''
+
+        To get an overview of Nailgun tasks, execute the command:
+            ``#{bin_name} nailgun:tasks''
+
+        NOTICE
+      end
+
+      task :help do 
+        puts Rake.application.nailgun_help
+      end
+
+      task :tasks do 
+        puts Rake.application.nailgun_tasks
+      end
+      
+    end # namespace :nailgun
+    
+  end # module Nailgun
+
+end
+