buildr 0.21.0 → 0.22.0

data/CHANGELOG

@@ -1,3 +1,20 @@
+0.22 (4/26/2007)
+* Added: Calling projects(:in=>foo) returns only the sub-projects defined in foo.
+* Added: _() as shortcut for path_to().
+* Added: You can pass properties to java by setting the :properties options.
+* Added: JUnit task has a way of setting options (options accessor and using method), which for now supports passing properties to java.
+* Added: You can now use the struct method to create a Struct for structoring your multiple artifacts.
+* Changed: Use rake artifacts to download all artifacts not already in the local repository, and also download modified artifacts (*cough*snapshots*cough*)
+* Changed: Transport.download now uses timestamp on the destination file and If-Modified-Since header to skip downloads of unmodified files.
+* Changed: Downloading artifact sets the time stamp from the repository.
+* Changed: Use buildr.rake in the project's directory and your home directory, instead of buildr.rb.
+* Changed: filter method accepts one argument, the source directory. Use filter(src).into(target).
+* Changed: Running Javac/Apt/Javadoc in process.
+* Changed: Using Ant for OpenJPA enhancer and XMLBeans schema compiler.
+* Changed: Jetty, JavaCC, OpenJPA and XMLBeans are no longer included by default. You need to require them explicitly, e.g. require "buildr/jetty".
+* Removed: Tasks no longer use a base directory, always map paths directly using file, path_to or _().
+* Fixed: The artifacts task no longer downloads POMs for artifacts created by the Rakefile.
+
 0.21 (4/20/2007)
 * Added: Methods to read and write a file (shortcut for File.read/File.open.write).
 * Changed: Filter task now takes a source directory and target directory, and copies all included (sans excluded) files between the two.

data/lib/buildr.rb

@@ -30,16 +30,24 @@ end
 
 
 module Buildr
-  VERSION = "0.21.0"
+  VERSION = "0.22.0"
 end
 
-
-File.expand_path(__DIR__).tap do |here|
-  $LOAD_PATH.unshift here
-  Dir[File.expand_path("*/*.rb", __DIR__)].each { |file| require file.sub("#{here}/", "") }
+$LOAD_PATH.unshift __DIR__
+["core", "tasks", "java"].each do |dir|
+  Dir[File.join(__DIR__, dir, "*.rb")].map { |file| File.basename(file) }.each { |file| require "#{dir}/#{file}" }
 end
 
-include Buildr
+
+# 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 Rakefile object (self) has access to all the Buildr methods and constants.
+class << self ; include Buildr ; end
+class Object ; Buildr.constants.each { |c| const_set c, Buildr.const_get(c) unless const_defined?(c) } ; end
+# Project has visibility to everything in the Buildr namespace. (See above for constants)
+class Project ; include Buildr ; end
+
 
 # The greate method_missing/Object extend bug requires us to load
 # XMLBuilder after we're done enhancing Object.
@@ -51,7 +59,13 @@ module Buildr
 end
 
 # Load the settings files.
-[ File.expand_path("buildr.rb", ENV["HOME"]), File.expand_path("buildr.rb") ].each { |file| require file if File.exist?(file) }
+[ File.expand_path("buildr.rake", ENV["HOME"] || "~"), File.expand_path("buildr.rake") ].each { |file| load file if File.exist?(file) }
+[ File.expand_path("buildr.rb", ENV["HOME"] || "~"), File.expand_path("buildr.rb") ].each do |file|
+  if File.exist?(file)
+    warn "Please use #{file.ext('rake')} instead of #{file}"
+    require file
+  end
+end
 
 #Load local tasks that can be used in the Rakefile.
 Dir["#{Dir.pwd}/tasks/*.rake"].each do |file|

data/lib/buildr/javacc.rb

@@ -0,0 +1,69 @@
+require "java/java"
+
+module Buildr
+  module JavaCC
+
+    REQUIRES = [ "net.java.dev.javacc:javacc:jar:4.0", "net.java.dev.javacc:javacc:jar:4.0" ]
+
+    class << self
+
+      def 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] ||= []) << REQUIRES
+        java_args = ["javacc"]
+        java_args << "-OUTPUT_DIRECTORY=#{options[:output]}" if options[:output]
+        java_args += args.flatten.map(&:to_s).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
+
+      def 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] ||= []) << REQUIRES
+        java_args = ["jjtree"]
+        java_args << "-OUTPUT_DIRECTORY=#{options[:output]}" if options[:output]
+        java_args << "-BUILD_NODE_FILES=#{options[:build_node_files] || false}"
+        java_args += args.flatten.map(&:to_s).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
+
+    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/lib/{java → buildr}/jetty.rb

@@ -2,6 +2,7 @@ require "uri"
 require "net/http"
 require "core/project"
 require "java/artifact"
+require "java/java"
 
 module Buildr
 
@@ -38,9 +39,14 @@ module Buildr
 
     # Artifacts required to run Jetty.
     REQUIRES = [ "org.mortbay.jetty:jetty:jar:6.1.1", "org.mortbay.jetty:jetty-util:jar:6.1.1",
-                 "org.mortbay.jetty:server-api-2.5:jar:6.1.1", "log4j:log4j:jar:1.2.13",
+                 "org.mortbay.jetty:servlet-api-2.5:jar:6.1.1", "log4j:log4j:jar:1.2.13",
                  "commons-logging:commons-logging:jar:1.1" ]
 
+    Java.rjb.onload do
+      Java.rjb.classpath << REQUIRES
+      Java.rjb.classpath << File.join(__DIR__, "jetty")
+    end
+
     # Default URL for Jetty.
     URL = "http://localhost:8080"
 
@@ -65,8 +71,6 @@ module Buildr
     # invoke the #use task instead.
     def start(pipe = nil)
       begin
-        Java.rjb.classpath += REQUIRES
-        Java.rjb.classpath << File.join(__DIR__, "jetty")
         Java.rjb do
           port = URI.parse(url).port
           puts "Starting Jetty at http://localhost:#{port}"
@@ -78,6 +82,8 @@ module Buildr
           sleep # Forever
         end
       rescue Interrupt # Stopped from console
+      rescue Exception=>error
+        puts "#{error.class}: #{error.message}"
       end
       exit! # No at_exit
     end

data/lib/{java → buildr}/jetty/JettyWrapper.java

@@ -18,22 +18,10 @@ import java.util.HashMap;
 public class JettyWrapper {
 
     private Server _server;
-    private WebAppContext _webAppHandler;
     private ContextHandlerCollection _handlerColl;
-    private String _webAppDir;
-    private String _contextPath;
 
-    public JettyWrapper(int port/*String webAppDir, String contextPath*/) throws Exception {
+    public JettyWrapper(int port) throws Exception {
         _server = new Server(port);
-        //_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");
@@ -41,30 +29,20 @@ public class JettyWrapper {
         context.setHandler(handler);
 
         _handlerColl = new ContextHandlerCollection();
-        _handlerColl.setHandlers(new Handler[] {/*_webAppHandler,*/ context});
+        _handlerColl.setHandlers(new Handler[] {context});
 
         _server.addHandler(_handlerColl);
         _server.start();
     }
 
-    public void start() {
+/*
+    public void join() {
         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 {
@@ -99,14 +77,6 @@ public class JettyWrapper {
                     _handlerColl.addHandler(context);
                     context.start();
                     _apps.put(path, context);
-                    //_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();
                     response.getWriter().println("Deployed");
                     response.getWriter().println(context.getTempDirectory());
                     ((Request)request).setHandled(true);
@@ -143,11 +113,7 @@ public class JettyWrapper {
                 } 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);
         }

data/lib/buildr/openjpa.rb

@@ -0,0 +1,74 @@
+require "java/java"
+
+module Buildr
+  module OpenJPA
+
+    VERSION = "0.9.7-incubating-SNAPSHOT"
+
+    REQUIRES = [ "org.apache.openjpa:openjpa-all:jar:#{VERSION}",
+      "commons-collections:commons-collections:jar:3.1",
+      "commons-dbcp:commons-dbcp:jar:1.2.1", 
+      "commons-lang:commons-lang:jar:2.1",
+      "commons-pool:commons-pool:jar:1.2",
+      "javax.persistence:persistence-api:jar:1.0",
+      "org.apache.geronimo.specs:geronimo-j2ee-connector_1.5_spec:jar:1.0",
+      "org.apache.geronimo.specs:geronimo-jta_1.0.1B_spec:jar:1.0",
+      "net.sourceforge.serp:serp:jar:1.11.0" ]
+
+    class << self
+
+      def enhance(options)
+        fu_check_options options, :classpath, :properties, :output
+        artifacts = Buildr.artifacts(options[:classpath] || []).each { |a| a.invoke }.map(&:to_s) + [options[:output].to_s]
+        properties = file(options[:properties]).tap { |task| task.invoke }.to_s
+
+        Ant.executable("openjpa") do |ant|
+          ant.taskdef :name=>"enhancer", :classname=>"org.apache.openjpa.ant.PCEnhancerTask",
+            :classpath=>requires.join(File::PATH_SEPARATOR)
+          ant.enhancer :directory=>options[:output].to_s do
+            config :propertiesFile=>properties
+            classpath :path=>artifacts.join(File::PATH_SEPARATOR)
+          end
+        end
+      end
+
+      def mapping_tool(options)
+        fu_check_options options, :classpath, :properties, :sql, :action
+        Java.java "org.apache.openjpa.jdbc.meta.MappingTool", "-p", options[:properties].to_s, "-sql", options[:sql],
+          "-sa", options[:action], :classpath=>Buildr.artifacts(options[:classpath], requires), :name=>"Mapping Tool"
+=begin
+        # Hopefully this will work in a future release.
+        artifacts = Buildr.artifacts(options[:classpath] || []).each{ |a| a.invoke }.map(&:to_s) + requires
+        properties = file(options[:properties]).tap { |task| task.invoke }.to_s
+
+        Ant.executable("openjpa") do |ant|
+          ant.taskdef :name=>"mapping", :classname=>"org.apache.openjpa.jdbc.ant.MappingToolTask",
+            :classpath=>requires.join(File::PATH_SEPARATOR)
+          ant.mapping :schemaAction=>options[:action], :sqlFile=>options[:sql].to_s do
+            config :propertiesFile=>properties
+            classpath :path=>artifacts.join(File::PATH_SEPARATOR)
+          end
+        end
+=end
+      end
+
+    private
+
+      def requires()
+        @required ||= Buildr.artifacts(REQUIRES).each { |artifact| artifact.invoke }.map(&:to_s)
+      end
+
+    end
+
+    def open_jpa_enhance(options = nil)
+      jpa_options = { :output=>compile.target, :classpath=>compile.classpath,
+                      :properties=>path_to("src/main/resources/META-INF/persistence.xml") }
+      OpenJPA.enhance jpa_options.merge(options || {})
+    end
+
+  end
+
+  class Project
+    include OpenJPA
+  end
+end

data/lib/buildr/xmlbeans.rb

@@ -0,0 +1,61 @@
+require "java/java"
+require "java/ant"
+
+module Buildr
+  module XMLBeans
+
+    REQUIRES = [ "xmlbeans:xbean:jar:2.2.0", "stax:stax-api:jar:1.0" ]
+
+    class << self
+
+      def compile(*args)
+        options = Hash === args.last ? args.pop : {}
+        options[:verbose] ||= Rake.application.options.trace || false
+        fu_check_options options, :verbose, :noop, :javasource, :jar, :compile, :output, :xsb
+        puts "Running XMLBeans schema compiler" if verbose
+        Ant.executable("xmlbeans") do |ant|
+          ant.taskdef :name=>"xmlbeans", :classname=>"org.apache.xmlbeans.impl.tool.XMLBean",
+            :classpath=>requires.join(File::PATH_SEPARATOR)
+          ant.xmlbeans :srconly=>"true", :srcgendir=>options[:output].to_s, :classgendir=>options[:output].to_s, 
+            :javasource=>options[:javasource] do
+            args.flatten.each { |file| fileset File.directory?(file) ? { :dir=>file } : { :file=>file } }
+          end
+        end
+        # Touch paths to let other tasks know there's an update.
+        touch options[:output].to_s, :verbose=>false
+      end
+
+    private
+
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES).each { |artifact| artifact.invoke }.map(&:to_s)
+      end
+    
+    end
+
+    def compile_xml_beans(*args)
+      # Generate sources and add them to the compile task.
+      generated = file(path_to("target/generated/xmlbeans")=>FileList[args.flatten]) do |task|
+        XMLBeans.compile task.prerequisites, :output=>task.name,
+          :javasource=>compile.options.source, :xsb=>compile.target
+      end
+      compile.from(generated).with(JAVAX.stream, XMLBEANS)
+      # Once compiled, we need to copy the generated XSB/XSD and one (magical?) class file
+      # into the target directory, or the rest is useless.
+      compile do |task|
+        verbose(false) do
+          base = Pathname.new(generated.to_s)
+          FileList["#{base}/**/*.{class,xsb,xsd}"].each do |file|
+            target = File.join(compile.target.to_s, Pathname.new(file).relative_path_from(base))
+            mkpath File.dirname(target) ; cp file, target
+          end
+        end
+      end
+    end
+
+  end
+
+  class Project
+    include XMLBeans
+  end
+end

data/lib/core/common.rb

@@ -4,6 +4,23 @@ require "core/transports"
 
 module Buildr
 
+  # :call-seq:
+  #   struct(hash) => Struct
+  #
+  # Convenience method for creating an anonymous Struct.
+  #
+  # For example:
+  #   COMMONS             = struct(
+  #     :collections      =>"commons-collections:commons-collections:jar:3.1",
+  #     :lang             =>"commons-lang:commons-lang:jar:2.1",
+  #     :logging          =>"commons-logging:commons-logging:jar:1.0.3",
+  #   )
+  #
+  #   compile.with COMMONS.logging
+  def struct(hash)
+    Struct.new(nil, *hash.keys).new(*hash.values)  
+  end
+
   # :call-seq:
   #   write(name, content)
   #   write(name) { ... }
@@ -239,7 +256,7 @@ module Buildr
   end
 
   # :call-seq:
-  #   filter(target=>source) => Filter
+  #   filter(source) => Filter
   #
   # Creates a filter that will copy files from the source directory into the target directory.
   # You can extend the filter to modify files by mapping <tt>${key}</tt> into values in each
@@ -248,13 +265,12 @@ module Buildr
   # A filter is not a task, you must call the Filter#run method to execute it.
   #
   # For example, to copy all files from one directory to another:
-  #   filter("target/classes"=>"src/files")
+  #   filter("src/files").into("target/classes").run
   # To include only the text files, and replace each instance of <tt>${build}</tt> with the current
   # date/time:
-  #   filter("target/classes"=>"src/files").include("*.txt").using("build"=>Time.now)
-  def filter(args)
-    target, source = Rake.application.resolve_args(args)
-    Filter.new.into(target).tap { |filter| filter.from(source) if source }
+  #   filter("src/files").into("target/classes").include("*.txt").using("build"=>Time.now).run
+  def filter(source)
+    Filter.new.from(source)
   end
 
 end