assaf-buildr 1.3.3 → 1.3.4

data/CHANGELOG

@@ -1,3 +1,30 @@
+1.3.4 (Pending)
+* Added:  BUILDR-159 Improved 'check' to accept both tar and tgz archives.
+* Added:  BUILDR-164 New 'artifacts:sources' task to download source code
+          for artifact jars.
+* Change: Introduced new options from Rake 0.8.3: -I (libdir), -R (rakelib),
+          --rules, --no-search, --silent.
+* Changed: Upgraded to Rubyforge 1.0.1.
+* Change: BUILDR-147 Upgraded to use Rake 0.8.3.
+* Change: BUILDR-166 Upgraded to use RSpec 1.1.11.
+* Change: BUILDR-171 Eclipse task generates meta-data files for projects with
+          test source code but no main source code. 
+* Change: BUILDR-177 Moved cobertura and emma extensions to lib directory.
+* Change: BUILDR-187 Source code attachment for Eclipse .classpath.
+* Change: BUILDR-188 Source code attachment for IDEA .iml file (Marko Sibakov).
+* Fixed:  Removed double complete/fail messages showing up on console.
+* Fixed:  BUILDR-158 Nailgun is now a delegate for buildr/drb (a pure-ruby dRuby server)
+* Fixed:  BUILDR-170 ArtifactNamespace#method_missing has a condition that is never true.
+* Fixed:  BUILDR-172 Scala compiler not loaded by default.
+* Fixed:  BUILDR-175 Fail to find child project when calling project method inside project definition.
+* Fixed:  BUILDR-192 TestNG report results are overwritten (Alexis Midon).
+* Fixed:  BUILDR-193 TestNG uses project name for suite name (not valid file
+          name on Windows).
+* Fixed: BUILDR-194 Buildr always adds 'Manifest-Version' to generated manifest file.
+* Fixed: BUILDR-198 Filter#run always calls mkpath with :verbose.
+* Fixed: BUILDR-199 ArchiveTask#needed uses 'each' with no effect (Ittay Dror).
+* Fixed: BUILDR-201 Sample project is not valid (Alexis Midon).
+
 1.3.3 (2008-10-08)
 * Added:  JtestR support. Implemented pending jtestr specs.
 * Added:  Growl notifications (OS X only).

data/Rakefile

@@ -28,7 +28,9 @@ end
 desc 'Compile Java libraries used by Buildr'
 task 'compile' do
   puts 'Compiling Java libraries ...'
-  sh File.expand_path('_buildr'), '--buildfile=buildr.buildfile', 'compile'
+  args = File.expand_path('_buildr'), '--buildfile=buildr.buildfile', 'compile'
+  args << '--trace' if Rake.application.options.trace
+  sh *args
   puts 'OK'
 end
 file Rake::GemPackageTask.new(spec).package_dir=>'compile'
@@ -59,4 +61,4 @@ task 'stage:check' do
   # run dependency checks with JRuby. (Also, good opportunity to upgrade other
   # platform's dependencies)
   sh RUBY_PLATFORM =~ /java/ ? 'ruby' : 'jruby -S rake setup dependency'
-end
+end

data/_buildr

@@ -14,25 +14,15 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
+
 # Run buildr from source, specifically for testing stuff without doing a rake install.
-# The _BUILDR_RB environment variable can be used to set the path to the ruby/jruby executable.
-# For example to use jruby:
-#   export _BUILDR_RB=/path/to/jruby
 
-start = Time.now
 require 'rubygems'
 $LOAD_PATH << File.join(File.dirname(__FILE__), 'lib') << File.join(File.dirname(__FILE__), 'addon')
 spec = Gem::Specification.load(File.join(File.dirname(__FILE__), 'buildr.gemspec'))
 spec.dependencies.each do |dep|
   gem dep.name, dep.version_requirements.to_s
 end
+
 require 'buildr'
 Buildr.application.run
-if verbose
-  elapsed = Time.now - start
-  real = []
-  real << ("%ih" % (elapsed / 3600)) if elapsed >= 3600
-  real << ("%im" % ((elapsed / 60) % 60)) if elapsed >= 60
-  real << ("%.3fs" % (elapsed % 60))
-  puts $terminal.color("Completed in #{real.join}", :green)
-end

data/addon/buildr/cobertura.rb

@@ -14,223 +14,9 @@
 # the License.
 
 
-require 'buildr/java'
-
-
-module Buildr
-
-  # Provides the <code>cobertura:html</code> and <code>cobertura:xml</code> tasks.
-  # Require explicitly using <code>require "buildr/cobertura"</code>.
-  #
-  # You can generate cobertura reports for a single project 
-  # using the project name as prefix:
-  #
-  #   project_name:cobertura:html
-  #
-  # You can also specify which classes to include/exclude from instrumentation by 
-  # passing a class name regexp to the <code>cobertura.include</code> or 
-  # <code>cobertura.exclude</code> methods. 
-  # 
-  #   define 'someModule' do 
-  #      cobertura.include 'some.package.*'
-  #      cobertura.include /some.(foo|bar).*/
-  #      cobertura.exclude 'some.foo.util.SimpleUtil'
-  #      cobertura.exclude /*.Const(ants)?/i
-  #   end
-  module Cobertura
-
-    class << self
-
-      REQUIRES = ["net.sourceforge.cobertura:cobertura:jar:1.9", "log4j:log4j:jar:1.2.9",
-        "asm:asm:jar:2.2.1", "asm:asm-tree:jar:2.2.1", "oro:oro:jar:2.0.8"] unless const_defined?('REQUIRES')
-
-      def requires()
-        @requires ||= Buildr.artifacts(REQUIRES).each(&:invoke).map(&:to_s)
-      end
-
-      def report_to(file = nil)
-        File.expand_path(File.join(*["reports/cobertura", file.to_s].compact))
-      end
-
-      def data_file()
-        File.expand_path("reports/cobertura.ser")
-      end
-
-    end
-    
-    class CoberturaConfig # :nodoc:
-      
-      def initialize(project)
-        @project = project
-      end
-      
-      attr_reader :project
-      private :project
-
-      attr_writer :data_file, :instrumented_dir, :report_dir
-      
-      def data_file
-        @data_file ||= project.path_to(:reports, 'cobertura.ser')
-      end
-
-      def instrumented_dir
-        @instrumented_dir ||= project.path_to(:target, :instrumented, :classes)
-      end
-
-      def report_dir
-        @report_dir ||= project.path_to(:reports, :cobertura)
-      end
-
-      def report_to(file = nil)
-        File.expand_path(File.join(*[report_dir, file.to_s].compact))
-      end
-
-      # :call-seq:
-      #   project.cobertura.include(*classPatterns)
-      #
-      def include(*classPatterns)
-        includes.push(*classPatterns.map { |p| String === p ? Regexp.new(p) : p })
-        self
-      end
-      
-      def includes
-        @includeClasses ||= []
-      end
-
-      # :call-seq:
-      #   project.cobertura.exclude(*classPatterns)
-      #
-      def exclude(*classPatterns)
-        excludes.push(*classPatterns.map { |p| String === p ? Regexp.new(p) : p })
-        self
-      end
-
-      def excludes
-        @excludeClasses ||= []
-      end
-
-      def sources
-        project.compile.sources
-      end
-    end
-
-    module CoberturaExtension # :nodoc:
-      include Buildr::Extension
-
-      def cobertura
-        @cobertura_config ||= CoberturaConfig.new(self)
-      end
-
-      after_define do |project|
-        cobertura = project.cobertura
-        
-        namespace 'cobertura' do
-          unless project.compile.target.nil?
-            # Instrumented bytecode goes in a different directory. This task creates before running the test
-            # cases and monitors for changes in the generate bytecode.
-            instrumented = project.file(cobertura.instrumented_dir => project.compile.target) do |task|
-              mkdir_p task.to_s, :verbose => false
-              unless project.compile.sources.empty?
-                info "Instrumenting classes with cobertura data file #{cobertura.data_file}"
-                Buildr.ant "cobertura" do |ant|
-                  ant.taskdef :classpath=>Cobertura.requires.join(File::PATH_SEPARATOR), :resource=>"tasks.properties"
-                  ant.send "cobertura-instrument", :todir=>task.to_s, :datafile=>cobertura.data_file do
-                    includes, excludes = cobertura.includes, cobertura.excludes
-                    
-                    classes_dir = project.compile.target.to_s
-                    if includes.empty? && excludes.empty? 
-                      ant.fileset :dir => classes_dir do 
-                        ant.include :name => "**/*.class"
-                      end
-                    else
-                      includes = [//] if includes.empty?
-                      Dir.glob(File.join(classes_dir, "**/*.class")) do |cls|
-                        cls_name = cls.gsub(/#{classes_dir}\/?|\.class$/, '').gsub('/', '.')
-                        if includes.any? { |p| p === cls_name } && !excludes.any? { |p| p === cls_name }
-                          ant.fileset :file => cls
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-              touch task.to_s, :verbose=>false
-            end
-            
-            task 'instrument' => instrumented
-            
-            # We now have two target directories with bytecode. It would make sense to remove compile.target
-            # and add instrumented instead, but apparently Cobertura only creates some of the classes, so
-            # we need both directories and instrumented must come first.
-            project.test.dependencies.unshift cobertura.instrumented_dir
-            project.test.with Cobertura.requires
-            project.test.options[:properties]["net.sourceforge.cobertura.datafile"] = cobertura.data_file
-            
-            [:xml, :html].each do |format|
-              task format => ['instrument', 'test'] do 
-                info "Creating test coverage reports in #{cobertura.report_to(format)}"
-                Buildr.ant "cobertura" do |ant|
-                  ant.taskdef :classpath=>Cobertura.requires.join(File::PATH_SEPARATOR), :resource=>"tasks.properties"
-                  ant.send "cobertura-report", :format=>format, 
-                    :destdir=>cobertura.report_to(format), :datafile=>cobertura.data_file do
-                    cobertura.sources.flatten.each do |src|
-                      ant.fileset(:dir=>src.to_s) if File.exist?(src.to_s)
-                    end
-                  end
-                end
-              end
-            end
-          end
-          
-        end
-
-        project.clean do
-          rm_rf [cobertura.report_to, cobertura.data_file, cobertura.instrumented_dir], :verbose=>false
-        end
-        
-      end
-      
-    end
-
-    class Buildr::Project
-      include CoberturaExtension
-    end
-
-    namespace "cobertura" do
-
-      task "instrument" do
-        Buildr.projects.each do |project|
-          project.cobertura.data_file = data_file
-          project.test.options[:properties]["net.sourceforge.cobertura.datafile"] = data_file
-          instrument_task ="#{project.name}:cobertura:instrument"
-          task(instrument_task).invoke if Rake::Task.task_defined?(instrument_task)
-        end
-      end
-      
-      [:xml, :html].each do |format|
-        report_target = report_to(format)
-        desc "Run the test cases and produce code coverage reports in #{report_target}"
-        task format => ["instrument", "test"] do
-          info "Creating test coverage reports in #{report_target}"
-          Buildr.ant "cobertura" do |ant|
-            ant.taskdef :classpath=>requires.join(File::PATH_SEPARATOR), :resource=>"tasks.properties"
-            ant.send "cobertura-report", :destdir=>report_target, :format=>format, :datafile=>data_file do
-              Buildr.projects.map(&:cobertura).map(&:sources).flatten.each do |src|
-                ant.fileset :dir=>src.to_s if File.exist?(src.to_s)
-              end
-            end
-          end
-        end
-      end
-      
-      task "clean" do
-        rm_rf [report_to, data_file], :verbose=>false
-      end
-    end
-
-    task "clean" do
-      task("cobertura:clean").invoke if Dir.pwd == Rake.application.original_dir
-    end
-
-  end
+if Buildr::VERSION < '1.5'
+  Buildr.application.deprecated "'buildr/cobertura', use 'buildr/java/cobertura' instead"
+  require 'buildr/java/cobertura'
+else
+  raise "#{__FILE__} should be removed since its use is deprecated since version 1.3.4"
 end

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
+