buildr 1.3.3 → 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

@@ -14,225 +14,9 @@
 # the License.
 
 
-require 'buildr/java'
-
-
-module Buildr
-
-  # Provides the <code>emma:html</code> and <code>emma:xml</code> tasks.
-  # Require explicitly using <code>require "buildr/emma"</code>.
-  #
-  # You can generate emma reports for a single project 
-  # using the project name as prefix:
-  #
-  #   project_name:emma:html
-  #
-  # You can also specify which classes to include/exclude from instrumentation by 
-  # passing a class name regexp to the <code>emma.include</code> or 
-  # <code>emma.exclude</code> methods. 
-  # 
-  #   define 'someModule' do 
-  #      emma.include 'some.package.*'
-  #      emma.exclude 'some.foo.util.SimpleUtil'
-  #   end
-  module Emma
-
-    class << self
-
-      REQUIRES = ['emma:emma_ant:jar:2.0.5312', 'emma:emma:jar:2.0.5312'] unless const_defined?('REQUIRES')
-
-      def requires()
-        @requires ||= Buildr.artifacts(REQUIRES).each(&:invoke).map(&:to_s)
-      end
-
-      def report_to format=nil
-        File.expand_path('reports/emma')
-      end
-
-      def data_file()
-        File.join(report_to, 'coverage.es')
-      end
-
-      def ant
-          Buildr.ant 'emma' do |ant|
-            ant.taskdef :classpath=>requires.join(File::PATH_SEPARATOR), :resource=>'emma_ant.properties'
-            ant.emma :verbosity=>(Buildr.application.options.trace ? 'verbose' : 'warning') do
-              yield ant
-            end
-          end
-      end
-    end
-    
-    class EmmaConfig # :nodoc:
-      
-      def initialize(project)
-        @project = project
-      end
-      
-      attr_reader :project
-      private :project
-
-      attr_writer :metadata_file, :coverage_file, :instrumented_dir, :report_dir
-      
-      def coverage_file
-        @coverage_file ||= File.join(report_dir, 'coverage.ec')
-      end
-
-      def metadata_file
-        @metadata_file ||= File.join(report_dir, 'coverage.em')
-      end
-
-      def instrumented_dir
-        @instrumented_dir ||= project.path_to(:target, :instrumented, :classes)
-      end
-
-      def report_dir
-        @report_dir ||= project.path_to(:reports, :emma)
-      end
-      
-      def report_to format
-        report_dir
-      end
-
-      # :call-seq:
-      #   project.emma.include(*classPatterns)
-      #
-      def include(*classPatterns)
-        includes.push(*classPatterns)
-        self
-      end
-      
-      def includes
-        @includeClasses ||= []
-      end
-
-      # :call-seq:
-      #   project.emma.exclude(*classPatterns)
-      #
-      def exclude(*classPatterns)
-        excludes.push(*classPatterns)
-        self
-      end
-
-      def excludes
-        @excludeClasses ||= []
-      end
-
-      def sources
-        project.compile.sources
-      end
-    end
-
-    module EmmaExtension # :nodoc:
-      include Buildr::Extension
-
-      def emma
-        @emma_config ||= EmmaConfig.new(self)
-      end
-
-      after_define do |project|
-        emma = project.emma
-        
-        namespace 'emma' 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(emma.instrumented_dir => project.compile.target) do |task|
-              unless project.compile.sources.empty?
-                info "Instrumenting classes with emma metadata file #{emma.metadata_file}"
-                Emma.ant do |ant|
-                  ant.instr :instrpath=>project.compile.target.to_s, :destdir=>task.to_s, :metadatafile=>emma.metadata_file do
-                    ant.filter :includes=>emma.includes.join(', ') unless emma.includes.empty?
-                    ant.filter :excludes=>emma.excludes.join(', ') unless emma.excludes.empty?
-                  end
-                end
-                touch task.to_s, :verbose=>false
-              end
-            end
-            
-            task 'instrument' => instrumented
-            
-            # We now have two target directories with bytecode.
-            project.test.dependencies.unshift emma.instrumented_dir
-            project.test.with Emma.requires
-            project.test.options[:properties]["emma.coverage.out.file"] = emma.coverage_file
-            
-            [:xml, :html].each do |format|
-              task format => ['instrument', 'test'] do
-                missing_required_files = [emma.metadata_file, emma.coverage_file].reject { |f| File.exist?(f) }
-                if missing_required_files.empty?
-                  info "Creating test coverage reports in #{emma.report_dir}"
-                  mkdir_p emma.report_dir, :verbose=>false
-                  Emma.ant do |ant|
-                    ant.report do
-                      ant.infileset :file=>emma.metadata_file
-                      ant.infileset :file=>emma.coverage_file
-                      ant.send format, :outfile=>File.join(emma.report_to(format),"coverage.#{format}")
-                      ant.sourcepath do
-                        emma.sources.flatten.each do |src|
-                          ant.dirset(:dir=>src.to_s) if File.exist?(src.to_s)
-                        end
-                      end
-                    end
-                  end
-                else
-                  info "No test coverage report for #{project}. Missing: #{missing_required_files.join(', ')}"
-                end
-              end
-            end
-          end
-        end
-
-        project.clean do
-          rm_rf [emma.report_dir, emma.coverage_file, emma.metadata_file, emma.instrumented_dir], :verbose=>false
-        end
-        
-      end
-      
-    end
-
-    class Buildr::Project
-      include EmmaExtension
-    end
-
-    namespace "emma" do
-
-      Project.local_task('instrument') { |name| "Instrumenting #{name}" }
-      
-      [:xml, :html].each do |format|
-        desc "Run the test cases and produce code coverage reports in #{format}"
-        task format => ['instrument', 'test'] do
-          info "Creating test coverage reports in #{format}"
-          mkdir_p report_to(format), :verbose=>false
-          Emma.ant do |ant|
-            ant.merge :outfile=>data_file do
-              Buildr.projects.each do |project|
-                [project.emma.metadata_file, project.emma.coverage_file].each do |data_file|
-                  ant.fileset :file=>data_file if File.exist?(data_file)
-                end
-              end
-            end
-            ant.report do
-              ant.infileset :file=>data_file
-              ant.send format, :outfile=>File.join(report_to(format), "coverage.#{format}")
-              ant.sourcepath do
-                Buildr.projects.map(&:emma).map(&:sources).flatten.map(&:to_s).each do |src|
-                  ant.dirset :dir=>src if File.exist?(src)
-                end    
-              end
-            end
-          end
-        end
-      end
-      
-      task :clean do
-        rm_rf [report_to, data_file], :verbose=>false
-      end
-      end
-
-    task :clean do
-      task('emma:clean').invoke if Dir.pwd == Rake.application.original_dir
-    end
-
-  end
+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