Buildr 0.17.0

data/lib/java/eclipse.rb

@@ -0,0 +1,78 @@
+require "pathname"
+
+module Buildr
+
+  # Global task "eclipse" generates artifacts for all projects.
+  desc "Generate Eclipse artifacts for all projects"
+  Project.local_task task("eclipse")
+
+  Project.on_define do |project|
+    eclipse = project.recursive_task("eclipse")
+
+    project.enhance do |project|
+
+      # We need paths relative to the top project's base directory.
+      root_path = lambda { |p| f = lambda { |p| p.parent ? f[p.parent] : p.base_dir } ; f[p] }[project]
+      # We're guessing the Rakefile is there, but keep in mind it might not exist
+      # (most test cases don't create it).
+      rakefile = File.expand_path(Rake.application.rakefile, root_path) if Rake.application.rakefile
+
+      # Only for projects that are Eclipse packagable.
+      if project.packages.detect { |pkg| pkg.type =~ /(jar)|(war)|(rar)|(mar)|(aar)/ }
+        eclipse.enhance [ file(project.path_to(".classpath")), file(project.path_to(".project")) ]
+
+        # The only thing we need to look for is a change in the Rakefile.
+        file(project.path_to(".classpath")=>rakefile) do |task|
+          puts "Writing #{task.name}" if verbose
+          
+          # Find a path relative to the project's root directory.
+          relative = lambda { |path| Pathname.new(path).relative_path_from(Pathname.new(project.path_to)).to_s }
+
+          File.open(task.name, "w") do |file|
+            xml = Builder::XmlMarkup.new(:target=>file, :indent=>2)
+            xml.classpath do
+              # Internal: projects that create artifacts we find on the classpath.
+              # External: other artifacts, typically from the local repository.
+              internal, external = project.compile.classpath.map(&:to_s).
+                map { |path| projects.detect { |prj| prj.packages.detect { |pkg| pkg.to_s == path } } || path }.
+                partition { |path| path.is_a?(Project) }
+              # Collect all the classpaths, key is the kind, value is
+              # string or array (or anything responding to to_a).
+              { :src    => project.compile.sources.map { |src| relative[src] },
+                :output => relative[project.path_to(:java_target_dir)],
+                :con    => "org.eclipse.jdt.launching.JRE_CONTAINER",
+                :lib    => external.map(&:to_s)
+              }.each do |kind, paths|
+                paths.to_a.each { |path| xml.classpathentry :kind=>kind, :path=>path }
+              end
+              internal.map(&:name).uniq.each do |prj_name|
+                xml.classpathentry :kind=>"src", :combineaccessrules=>"false", :path=>"/#{prj_name}"
+              end
+            end
+          end
+        end
+
+        # The only thing we need to look for is a change in the Rakefile.
+        file(project.path_to(".project")=>rakefile) do |task|
+          puts "Writing #{task.name}" if verbose
+          File.open(task.name, "w") do |file|
+            xml = Builder::XmlMarkup.new(:target=>file, :indent=>2)
+            xml.projectDescription do
+              xml.name project.name
+              xml.projects
+              xml.buildSpec do
+                xml.buildCommand do
+                  xml.name "org.eclipse.jdt.core.javabuilder"
+                end
+              end
+              xml.natures do
+                xml.nature "org.eclipse.jdt.core.javanature"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+end # module Buildr

data/lib/java/java.rb

@@ -0,0 +1,114 @@
+module Buildr
+  module Java
+
+    JAVA_OPTIONS = [ :verbose, :noop, :cp, :classpath, :name, :java_args ]
+
+    def self.java(*args)
+      options = Hash === args.last ? args.pop : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, *JAVA_OPTIONS
+
+      name = options[:name] || "java #{args.first}"
+      cmd_args = []
+      classpath = classpath_from(options)
+      cmd_args << "-cp" << classpath.join(File::PATH_SEPARATOR) unless classpath.empty?
+      cmd_args += options[:java_args].flatten if options[:java_args]
+      cmd_args += args.flatten.compact
+      cmd_args << { :verbose=>options[:verbose] }
+      unless options[:noop]
+        puts "Running #{name}" if verbose
+        sh(path_to_bin("java"), *cmd_args) { |ok, res| fail "Failed to execute #{name}, see errors above" unless ok }
+      end
+    end
+
+    def self.apt(*args)
+      options = Hash === args.last ? args.pop : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, :verbose, :noop, :compile, :source, :output, :cp, :classpath
+
+      files = args.collect { |arg| File.directory?(arg) ? FileList[File.join(arg, "**", "*.java")] : arg }.flatten
+      args = [ options[:verbose] ? "-verbose" : "-nowarn" ]
+      if options[:compile]
+        args << "-d" << options[:output]
+      else
+        args << "-nocompile" << "-s" << options[:output]
+      end
+      args << "-source" << options[:source] if options[:source]
+      classpath = classpath_from(options)
+      args << "-cp" << classpath.join(File::PATH_SEPARATOR) unless classpath.empty?
+      args += files
+      args << { :verbose=>options[:verbose] }
+      unless options[:noop]
+        puts "Running apt" if verbose
+        sh(path_to_bin("apt"), *args) { |ok, res| fail "Failed to execute apt, see errors above" unless ok }
+      end
+    end
+
+    class AptTask < Rake::FileTask
+
+      def initialize(*args)
+        super
+        enhance do |task|
+          Java.apt *task.prerequisites + [options.merge(:output=>task.name)]
+        end
+      end
+
+      def options()
+        @options ||= {}
+      end
+
+      def using(options)
+        self.options.merge!(options)
+        self
+      end
+
+    end
+
+    def self.apt_task(args)
+      output = args.keys.first
+      files = args.values.first.collect { |f| File.directory?(f) ? FileList[f + "/**/*.java"] : f }.flatten
+      AptTask.define_task(output=>files)  
+    end
+
+    def self.javac(*args)
+      options = Hash === args.last ? args.pop : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, :verbose, :noop, :cp, :classpath, :sourcepath, :output, :javac_args, :name
+
+      files = args.flatten.each { |f| f.invoke if f.respond_to?(:invoke) }.map(&:to_s).
+        collect { |arg| File.directory?(arg) ? FileList[File.join(arg, "**", "*.java")] : arg }.flatten
+      name = options[:name] || Dir.pwd
+
+      cmd_args = []
+      classpath = classpath_from(options)
+      #classpath += options[:output] if options[:output]
+      cmd_args << "-cp" << classpath.join(File::PATH_SEPARATOR) unless classpath.empty?
+      cmd_args << "-sourcepath" << options[:sourcepath].join(File::PATH_SEPARATOR) if options[:sourcepath]
+      cmd_args << "-d" << options[:output] if options[:output]
+      cmd_args += options[:javac_args].flatten if options[:javac_args]
+      cmd_args += files
+      cmd_args << { :verbose=>options[:verbose] }
+      unless options[:noop] || files.empty?
+        puts "Compiling #{files.size} source files in #{name}" if verbose
+        sh(path_to_bin("javac"), *cmd_args) { |ok, res| fail "Failed to compile, see errors above" unless ok }
+      end
+    end
+
+  protected
+
+    def self.path_to_bin(name)
+      ENV["JAVA_HOME"] ? File.join(ENV["JAVA_HOME"], "bin", name) : name
+    end
+
+    def self.classpath_from(options)
+      classpath = (options[:classpath] || []).collect | (options[:cp] || []).collect
+      artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.map(&:to_s)
+    end
+
+  end
+
+  def java(*args)
+    Java.java(*args)
+  end
+
+end

data/lib/java/javacc.rb

@@ -0,0 +1,88 @@
+module Buildr
+
+  module JavaCC
+
+    JAVACC = "net.java.dev.javacc:javacc:jar:4.0"
+    JJTREE = "net.java.dev.javacc:javacc:jar:4.0"
+
+    def self.javacc(*args)
+      options = Hash === args.last ? args.pop.clone : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, *Java::JAVA_OPTIONS + [:output]
+
+      (options[:classpath] ||= []) << JAVACC
+      java_args = ["javacc"]
+      java_args << "-OUTPUT_DIRECTORY=#{options[:output]}" if options[:output]
+      java_args += args.collect { |f| File.directory?(f) ? FileList[f + "/**/*.jj"] : f }.flatten
+      java_args << options.reject { |k, v| !Java::JAVA_OPTIONS.include?(k) }
+      Java.java(*java_args)
+    end
+
+    class JavaCCTask < Rake::FileTask
+
+      def initialize(*args)
+        super
+        enhance do |task|
+          JavaCC.javacc *(task.prerequisites + [task.options.merge(:output=>task.name)])
+        end
+      end
+
+      def options()
+        @options ||= {}
+      end
+
+      def using(options)
+        self.options.merge!(options)
+        self
+      end
+
+    end
+
+    def self.javacc_task(args)
+      output = args.keys.first
+      files = args.values.first.collect { |f| File.directory?(f) ? FileList[f + "/**/*.jj"] : f }.flatten
+      JavaCCTask.define_task(output=>files)  
+    end
+
+    def self.jjtree(*args)
+      options = Hash === args.last ? args.pop.clone : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, *Java::JAVA_OPTIONS + [:output, :build_node_files]
+
+      (options[:classpath] ||= []) << JJTREE
+      java_args = ["jjtree"]
+      java_args << "-OUTPUT_DIRECTORY=#{options[:output]}" if options[:output]
+      java_args << "-BUILD_NODE_FILES=#{options[:build_node_files]}" if options.has_key?(:build_node_files)
+      java_args += args.collect { |f| File.directory?(f) ? FileList[f + "/**/*.jjt"] : f }.flatten
+      java_args << options.reject { |k, v| !Java::JAVA_OPTIONS.include?(k) }
+      Java.java(*java_args)
+    end
+
+    class JJTreeTask < Rake::FileTask
+
+      def initialize(*args)
+        super
+        enhance do |task|
+          JavaCC.jjtree *(task.prerequisites + [task.options.merge(:output=>task.name)])
+        end
+      end
+
+      def options()
+        @options ||= {}
+      end
+
+      def using(options)
+        self.options.merge!(options)
+        self
+      end
+
+    end
+
+    def self.jjtree_task(args)
+      output = args.keys.first
+      files = args.values.first.collect { |f| File.directory?(f) ? FileList[f + "/**/*.jjt"] : f }.flatten
+      JJTreeTask.define_task(output=>files)
+    end
+
+  end
+end

data/lib/java/jetty.rb

@@ -0,0 +1,118 @@
+require 'net/http'
+
+module Buildr
+
+  module Jetty
+
+    VERSION = "6.1.1"
+
+    REQUIRES = [ "org.mortbay.jetty:jetty:jar:#{VERSION}",
+      "org.mortbay.jetty:jetty-util:jar:#{VERSION}",
+      "org.mortbay.jetty:servlet-api-2.5:jar:#{VERSION}",
+      "log4j:log4j:jar:1.2.13",
+      "commons-logging:commons-logging:jar:1.1"
+    ]
+
+    OPTIONS = [ :classpath, :war_path, :context_path, :noop, :base_url, :process_alias ]
+
+    def self.bounce(options)
+      fu_check_options options, *OPTIONS
+      options[:classpath] ||= []
+      
+      begin
+        verbose { puts "Bouncing webapp #{options[:war_path]}" }
+        res = jetty_call('/bounce', :post, options)
+        verbose { puts "done." }
+      rescue Errno::ECONNREFUSED => e
+        puts "Web server not found, spawning it."
+        runtool options.merge(:class=>"JettyWrapper",
+                              :args=>[ options[:war_path], options[:context_path] ],
+                              :classpath=>options[:classpath] + ['buildr/lib/java/jetty'])
+      end
+
+      case res
+      when Net::HTTPNotFound
+        fail "A web server seems to be already running without Buildr deployment hooks."
+      when Net::HTTPInternalServerError
+        fail "Server error occured when redeploying the WAR, see the web server logs."
+      end
+    end
+
+    def self.jetty_call(rel_url, get_post, options)
+      base_url = URI.parse((options[:base_url] || 'http://localhost:8080/buildr') + rel_url)
+      req = get_post == :post ? Net::HTTP::Post.new(base_url.path) : Net::HTTP::Get.new(base_url.path)
+      res = Net::HTTP.start(base_url.host, base_url.port) {|http| http.request(req) }
+    end
+
+  protected
+
+    def self.runtool(options)
+      classpath = REQUIRES + (options[:classpath] || []).collect | (options[:cp] || []).collect
+      classpath = artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.map(&:to_s)
+      cmd_args = ["-cp", classpath.join(File::PATH_SEPARATOR)]
+      cmd_args << options[:class]
+      cmd_args += options[:args]
+      unless options[:noop]
+        verbose { puts "Starting web server and mounting webapp #{options[:war_path]}" }
+        if fork.nil?
+          STDOUT.reopen File.new("stdout.log", "w")
+          STDERR.reopen File.new("stderr.log", "w")
+          exec(([Java.path_to_bin("java")] + cmd_args).join(' '))
+        end
+      end
+    end
+    
+    class JettyTask < Rake::Task
+      def initialize(*args)
+        super
+        enhance do |task|
+          Jetty.bounce task.options
+        end
+      end
+
+      def options()
+        @options ||= {}
+      end
+
+      def using(options)
+        self.options.merge!(options)
+        self
+      end
+    end
+  end
+
+  class Project
+    def webserve(&block)
+      task "jetty:shutdown" do
+        begin
+          res = Jetty.jetty_call('/stop', :put, @webserve_task.options)
+          verbose { puts "Response #{res}" }
+        rescue Exception => e
+          if (e.class == Errno::ECONNREFUSED)
+            puts "Jetty server couldn't be contacted, nothing done."
+          elsif (e.class == EOFError)
+            puts "Shutdown successful."
+          else
+            puts "Unexpected error: #{e.class}"
+          end
+        end
+      end
+      returning(@webserve_task ||= Jetty::JettyTask.define_task("jetty:bounce")) do |task|
+        task.enhance &block if block
+      end
+    end
+  end
+  
+end
+
+module FileUtils
+  class Entry_
+    alias original_cp copy
+    def copy(dest)
+      unless path['.svn']
+        original_cp(dest)
+      end
+    end
+  end
+end
+

data/lib/java/jetty/JettyWrapper.java

@@ -0,0 +1,107 @@
+import org.mortbay.jetty.Server;
+import org.mortbay.jetty.Request;
+import org.mortbay.jetty.Handler;
+import org.mortbay.jetty.handler.AbstractHandler;
+import org.mortbay.jetty.handler.ContextHandler;
+import org.mortbay.jetty.handler.ContextHandlerCollection;
+import org.mortbay.jetty.webapp.WebAppContext;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.ServletException;
+import java.io.IOException;
+
+/**
+ * @author Matthieu Riou <mriou at apache dot org>
+ */
+public class JettyWrapper {
+
+    private Server _server;
+    private WebAppContext _webAppHandler;
+    private ContextHandlerCollection _handlerColl;
+    private String _webAppDir;
+    private String _contextPath;
+
+    public JettyWrapper(String webAppDir, String contextPath) {
+        _server = new Server(8080);
+        _webAppDir = webAppDir;
+        _contextPath = contextPath;
+
+        // Adding handler for the war to deploy
+        _webAppHandler = new WebAppContext(_webAppDir, _contextPath);
+        _webAppHandler.setConfigurationClasses(new String[] {
+                "org.mortbay.jetty.webapp.WebInfConfiguration",
+                "org.mortbay.jetty.webapp.WebXmlConfiguration"});
+
+        // Adding the buildr handler to control our server lifecycle
+        ContextHandler context = new ContextHandler();
+        context.setContextPath("/buildr");
+        Handler handler = new BuildrHandler();
+        context.setHandler(handler);
+
+        _handlerColl = new ContextHandlerCollection();
+        _handlerColl.setHandlers(new Handler[] {_webAppHandler, context});
+
+        _server.addHandler(_handlerColl);
+    }
+
+    public void start() {
+        try {
+            _server.start();
+            _server.join();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void main(String[] args) {
+        if (args.length != 2) {
+            System.out.println("Please provide the webapp directory and the context path.");
+        }
+        String webAppDir = args[0];
+        String contextPath = args[1];
+        JettyWrapper jetwrap = new JettyWrapper(webAppDir, contextPath);
+        jetwrap.start();
+    }
+
+    private class BuildrHandler extends AbstractHandler {
+
+        public void handle(String string, HttpServletRequest request,
+                           HttpServletResponse response, int i) throws IOException, ServletException {
+            response.setContentType("text/html");
+            if (request.getPathInfo().equals("/bounce")) {
+                try {
+                    _webAppHandler.stop();
+                    _handlerColl.removeHandler(_webAppHandler);
+                    _webAppHandler = new WebAppContext(_webAppDir, _contextPath);
+                    _webAppHandler.setConfigurationClasses(new String[] {
+                            "org.mortbay.jetty.webapp.WebInfConfiguration",
+                            "org.mortbay.jetty.webapp.WebXmlConfiguration"});
+                    _handlerColl.addHandler(_webAppHandler);
+                    _webAppHandler.start();
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                    response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+                    ((Request)request).setHandled(true);
+                    return;
+                }
+            } else if (request.getPathInfo().equals("/stop")) {
+                try {
+                    _server.stop();
+                    _server.destroy();
+                    // Brute force
+                    System.exit(0);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            } else if (request.getPathInfo().equals("/war")) {
+		response.getWriter().println(_webAppHandler.getTempDirectory());
+		((Request)request).setHandled(true);
+		return;
+	    }
+            response.getWriter().println("OK " + request.getPathInfo());
+            ((Request)request).setHandled(true);
+        }
+
+    }
+}