ittayd-buildr 1.3.4

data/addon/buildr/drb.rb

@@ -0,0 +1,281 @@
+# 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 'delegate'
+require 'drb/drb'
+
+
+module Buildr
+
+  # This addon allows you start a DRb server hosting a buildfile, so that
+  # you can later invoke tasks on it without having to load
+  # the complete buildr runtime again.
+  # 
+  # Usage:
+  #   
+  #   buildr -r buildr/drb drb:start
+  #
+  # Once the server has been started you can invoke tasks using a simple script:
+  # 
+  #   #!/usr/bin/env ruby
+  #   require 'rubygems'
+  #   require 'buildr/drb'
+  #   Buildr::DRbApplication.run
+  #
+  # Save this script as 'dbuildr', make it executable and use it to invoke tasks.
+  #
+  #   dbuildr clean compile
+  #
+  # The dbuildr script will run as the server if there isn't one already running.
+  # Subsequent calls to dbuildr will act as the client and invoke the tasks you
+  # provide in the server.
+  # If the buildfile has been modified it will be reloaded on the BuildrServer.
+  #
+  # JRuby users can use a nailgun client to invoke tasks as fast as possible
+  # without having to incur JVM startup time.
+  # See the documentation for buildr/nailgun.
+  module DRbApplication
+    
+    port = ENV['DRB_PORT'] || 2111
+    PORT = port.to_i
+
+    class SavedTask #:nodoc:
+      
+      def initialize(original)
+        @original = original.clone
+        @prerequisites = original.prerequisites.clone if original.respond_to?(:prerequisites)
+        @actions = original.actions.clone if original.respond_to?(:actions)
+      end
+      
+      def name
+        @original.name
+      end
+
+      def actions
+        @actions ||= []
+      end
+
+      def prerequisites
+        @prerequisites ||= []
+      end
+      
+      def define!
+        @original.class.send(:define_task, @original.name => prerequisites).tap do |task|
+          task.comment = @original.comment
+          actions.each { |action| task.enhance &action }
+        end
+      end
+    end # SavedTask
+
+    class Snapshot #:nodoc:
+      
+      attr_accessor :projects, :tasks, :rules, :layout, :options
+      
+      # save the tasks,rules,layout defined by buildr
+      def initialize
+        @rules = Buildr.application.instance_eval { @rules || [] }.clone
+        @options = Buildr.application.options.clone
+        @options.rakelib ||= ['tasks']
+        @layout = Layout.default.clone
+        @projects = Project.instance_eval { @projects || {} }.clone
+        @tasks = Buildr.application.tasks.inject({}) do |hash, original|
+          unless projects.key? original.name # don't save project definitions
+            hash.update original.name => SavedTask.new(original)
+          end
+          hash
+        end
+      end
+      
+    end # Snapshot
+
+    class << self
+      
+      attr_accessor :original, :snapshot
+
+      def run
+        begin
+          client = connect
+        rescue DRb::DRbConnError => e
+          run_server!
+        else
+          run_client(client)
+        end
+      end
+
+      def client_uri
+        "druby://:#{PORT + 1}"
+      end
+
+      def remote_run(cfg)
+        with_config(cfg) { Buildr.application.remote_run(self) }
+      rescue => e
+        cfg[:err].puts e.message
+        e.backtrace.each { |b| cfg[:err].puts "\tfrom #{b}" }
+        raise e
+      end
+
+      def save_snapshot(app)
+        if app.instance_eval { @rakefile }
+          @snapshot = self::Snapshot.new
+          app.buildfile_reloaded!
+        end
+      end
+
+    private
+
+      def server_uri
+        "druby://:#{PORT}"
+      end
+      
+      def connect
+        buildr = DRbObject.new(nil, server_uri)
+        uri = buildr.client_uri # obtain our uri from the server
+        DRb.start_service(uri)
+        buildr
+      end
+
+      def run_client(client)
+        client.remote_run :dir => Dir.pwd, :argv => ARGV,
+                          :in  => $stdin, :out => $stdout, :err => $stderr
+      end
+
+      def setup
+        unless original
+          # Create the stdio delegator that can be cached (eg by fileutils)
+          delegate_stdio
+
+          # Lazily load buildr the first time it's needed
+          require 'buildr'
+          
+          # Save the tasks,rules,layout defined by buildr
+          # before loading any project
+          @original = self::Snapshot.new
+
+          Buildr.application.extend self
+          save_snapshot(Buildr.application)
+        end
+      end
+
+      def run_server
+        setup
+        DRb.start_service(server_uri, self)
+        puts "#{self} waiting on #{server_uri}"
+      end
+
+      def run_server!
+        setup
+        if RUBY_PLATFORM[/java/]
+          require 'buildr/nailgun'
+          Buildr.application['nailgun:drb'].invoke
+        else
+          run_server
+          DRb.thread.join
+        end
+      end
+
+      def delegate_stdio
+        $stdin  = SimpleDelegator.new($stdin)
+        $stdout = SimpleDelegator.new($stdout)
+        $stderr = SimpleDelegator.new($stderr)
+      end
+      
+      def with_config(remote)
+        @invoked = true
+        set = lambda do |env|
+          ARGV.replace env[:argv]
+          $stdin.__setobj__(env[:in])
+          $stdout.__setobj__(env[:out])
+          $stderr.__setobj__(env[:err])
+          Buildr.application.instance_variable_set :@original_dir, env[:dir]
+        end
+        original = { 
+          :dir => Buildr.application.instance_variable_get(:@original_dir), 
+          :argv => ARGV,
+          :in => $stdin.__getobj__,
+          :out => $stdout.__getobj__,
+          :err => $stderr.__getobj__
+        }
+        begin
+          set[remote]
+          yield
+        ensure
+          set[original]
+        end
+      end
+
+    end # class << DRbApplication
+
+    def remote_run(server)
+      @options = server.original.options.clone
+      init 'Distributed Buildr'
+      if @rakefile
+        if buildfile_needs_reload?
+          reload_buildfile(server, server.original)
+        else
+          clear_invoked_tasks(server.snapshot || server.original)
+        end
+      else
+        reload_buildfile(server, server.original)
+      end
+      top_level
+    end
+
+    def buildfile_reloaded!
+      @last_loaded = buildfile.timestamp if @rakefile
+    end
+
+  private
+    
+    def buildfile_needs_reload?
+      !@last_loaded || @last_loaded < buildfile.timestamp
+    end
+
+    def reload_buildfile(server, snapshot)
+      clear_for_reload(snapshot)
+      load_buildfile
+      server.save_snapshot(self)
+    end
+
+    def clear_for_reload(snapshot)
+      Project.clear
+      @tasks = {}
+      @rules = snapshot.rules.clone
+      snapshot.tasks.each_pair { |name, saved| saved.define! }
+      Layout.default = snapshot.layout.clone
+    end
+
+    def clear_invoked_tasks(snapshot)
+      @rules = snapshot.rules.clone
+      (@tasks.keys - snapshot.projects.keys).each do |name|
+        if saved = snapshot.tasks[name]
+          # reenable this task, restoring its actions/prereqs
+          task = @tasks[name]
+          task.reenable
+          task.prerequisites.replace saved.prerequisites.clone
+          task.actions.replace saved.actions.clone
+        else
+          # tasks generated at runtime, drop it
+          @tasks.delete(name)
+        end
+      end
+    end
+
+    task('drb:start') { run_server! } if Buildr.respond_to?(:application)
+    
+  end # DRbApplication
+
+end
+

data/addon/buildr/emma.rb

@@ -0,0 +1,22 @@
+# 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.
+
+
+if Buildr::VERSION < '1.5'
+  Buildr.application.deprecated "'buildr/emma', use 'buildr/java/emma' instead"
+  require 'buildr/java/emma'
+else
+  raise "#{__FILE__} should be removed since its use is deprecated since version 1.3.4"
+end

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