assaf-buildr 1.3.3

data/addon/buildr/hibernate.rb

@@ -0,0 +1,142 @@
+# 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 Hibernate Doclet and schema export tasks. Require explicitly using <code>require "buildr/hibernate"</code>.
+  module Hibernate
+
+    REQUIRES = Buildr.struct(
+      :collections  => "commons-collections:commons-collections:jar:3.1",
+      :logging      => "commons-logging:commons-logging:jar:1.0.3",
+      :dom4j        => "dom4j:dom4j:jar:1.6.1",
+      :hibernate    => "org.hibernate:hibernate:jar:3.1.2",
+      :xdoclet      => Buildr.group("xdoclet", "xdoclet-xdoclet-module", "xdoclet-hibernate-module",
+                         # :under=>"xdoclet", :version=>"1.2.3") + ["xdoclet:xjavadoc:jar:1.1-j5"]
+                         :under=>"xdoclet", :version=>"1.2.3") + ["xdoclet:xjavadoc:jar:1.1"]
+    )
+
+    class << self
+      include Buildr::Ant
+
+      # :call-seq:
+      #    doclet(options) => AntProject
+      #
+      # Uses XDoclet to generate HBM files form annotated source files.
+      # Options include:
+      # * :sources -- Directory (or directories) containing source files.
+      # * :target -- The target directory.
+      # * :excludetags -- Tags to exclude (see HibernateDocletTask)
+      #
+      # For example:
+      #  doclet :sources=>compile.sources, :target=>compile.target, :excludedtags=>"@version,@author,@todo"
+      def doclet(options)
+        options[:sources].each { |src| file(src).invoke }
+        ant "hibernatedoclet" do |ant|
+          ant.taskdef :name=>"hibernatedoclet", :classname=>"xdoclet.modules.hibernate.HibernateDocletTask", :classpath=>requires
+          ant.hibernatedoclet :destdir=>options[:target].to_s, :excludedtags=>options[:excludedtags], :force=>"true" do
+            ant.hibernate :version=>"3.0"
+            options[:sources].map(&:to_s).each do |source|
+              ant.fileset :dir=>source.to_s, :includes=>"**/*.java"
+            end
+          end
+        end
+      end
+
+      # :call-seq:
+      #   schemaexport(properties) { ... } => AntProject
+      #
+      # Runs the Hibernate SchemaExportTask with the specified properties. For example:
+      #   Buildr::Hibernate.schemaexport(:properties=>properties.to_s, :quiet=>"yes", :text=>"yes", :delimiter=>";",
+      #     :drop=>"no", :create=>"yes", :output=>target) do
+      #     fileset :dir=>source.to_s, :includes=>"**/*.hbm.xml"
+      #   end
+      def schemaexport(options = nil)
+        ant "schemaexport" do |ant|
+          ant.taskdef :name=>"schemaexport", :classname=>"org.hibernate.tool.hbm2ddl.SchemaExportTask", :classpath=>requires
+          ant.schemaexport(options) { yield ant if block_given? } if options
+        end
+      end
+
+    protected
+
+      # This will download all the required artifacts before returning a classpath, and we want to do this only once.
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES.to_a).each(&:invoke).map(&:to_s).join(File::PATH_SEPARATOR)
+      end
+
+    end
+
+    # :call-seq:
+    #   hibernate_doclet(options?) => task
+    #
+    # Runs the hibernate doclet on the source files and creates HBM files in the target directory.
+    # By default runs on all source files, but you can limit it to a given package using the :package
+    # options. You can also pass other options to the doclet task.
+    #
+    # For example:
+    #   resources hibernate_doclet(:package=>"org.apache.ode.store.hib", :excludedtags=>"@version,@author,@todo")
+    def hibernate_doclet(options = {})
+      if options[:package]
+        depends = compile.sources.map { |src| FileList[File.join(src.to_s, options[:package].gsub(".", "/"), "*.java")] }.flatten
+      else
+        depends = compile.sources.map { |src| FileList[File.join(src.to_s, "**/*.java")] }.flatten
+      end
+      file("target/hbm.timestamp"=>depends) do |task|
+        Hibernate.doclet({ :sources=>compile.sources, :target=>compile.target }.merge(options))
+        write task.name
+      end
+    end
+
+    # :call-seq:
+    #   hibernate_schemaexport(path) => task
+    #   hibernate_schemaexport(path) { |task, ant| .. } => task
+    #
+    # Returns an new file task with an accessor (ant) to an AntProject that defines the schemaexport task.
+    # If called with a block, the task will yield to the block passing both itself and the Ant project.
+    #
+    # See #schemaexport.
+    #
+    # For example:
+    #   hibernate_schemaexport "derby.sql" do |task, ant|
+    #     ant.schemaexport :properties=>"derby.properties", :output=>task.name,
+    #       :delimiter=>";", :drop=>"no", :create=>"yes" do
+    #       fileset(:dir=>compile.sources.first) { include :name=>"**/*.hbm.xml" } }
+    #     end
+    #   end
+    def hibernate_schemaexport(args, &block)
+      path, arg_names, deps = Rake.application.resolve_args([args])
+      unless Rake::Task.task_defined?(path)
+        class << file(path) ; attr_accessor :ant ; end
+        file(path).enhance { |task| task.ant = Hibernate.schemaexport }
+      end
+      if block
+        file(path).enhance(deps) { |task| block.call task, task.ant }
+      else
+        file(path).enhance deps
+      end
+    end
+
+  end
+
+  class Project
+    include Hibernate
+  end
+
+end

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"
+    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