autobuild 1.7.10 → 1.7.11.rc1

data/lib/autobuild/packages/dummy.rb

@@ -12,7 +12,7 @@ module Autobuild
             super
         end
 
-        def import
+        def import(only_local=false)
         end
 
         def prepare

data/lib/autobuild/packages/genom.rb

@@ -17,7 +17,7 @@ module Autobuild
 	    use :autogen => 'autogen'
         end
 
-	def import
+        def import(only_local=false)
 	    super
 	    get_provides
 	end

data/lib/autobuild/packages/orogen.rb

@@ -177,7 +177,7 @@ module Autobuild
             FileUtils.rm_f genstamp 
         end
 
-        def import
+        def import(only_local=false)
             super
         end
 

data/lib/autobuild/packages/ruby.rb

@@ -0,0 +1,109 @@
+module Autobuild
+    class Ruby < ImporterPackage
+        # The Rake task that is used to set up the package. Defaults to "default".
+        # Set to nil to disable setup altogether
+        attr_accessor :rake_setup_task
+        # The Rake task that is used to generate documentation. Defaults to "doc".
+        # Set to nil to disable documentation generation
+        attr_accessor :rake_doc_task
+        # The Rake task that is used to run tests. Defaults to "test".
+        # Set to nil to disable tests for this package
+        attr_accessor :rake_test_task
+        # The Rake task that is used to run cleanup. Defaults to "clean".
+        # Set to nil to disable tests for this package
+        attr_accessor :rake_clean_task
+
+        def initialize(*args)
+            self.rake_setup_task = "default"
+            self.rake_doc_task   = "redocs"
+            self.rake_clean_task   = "clean"
+            self.rake_test_task  = "test"
+
+            super
+            exclude << /\.so$/
+            exclude << /Makefile$/
+            exclude << /mkmf.log$/
+            exclude << /\.o$/
+            exclude << /doc$/
+        end
+
+        def with_doc
+            doc_task do
+                progress_start "generating documentation for %s", :done_message => 'generated documentation for %s' do
+                    Autobuild::Subprocess.run self, 'doc',
+                        Autobuild.tool_in_path('ruby'), '-S', Autobuild.tool('rake'), rake_doc_task,
+                        :working_directory => srcdir
+                end
+            end
+        end
+
+        def with_tests
+            test_utility.task do
+                progress_start "running tests for %s", :done_message => 'tests passed for %s' do
+                    Autobuild::Subprocess.run self, 'test',
+                        Autobuild.tool_in_path('ruby'), '-S', Autobuild.tool('rake'), rake_test_task,
+                        :working_directory => srcdir
+                end
+            end
+        end
+
+        def install
+            progress_start "setting up Ruby package %s", :done_message => 'set up Ruby package %s' do
+                Autobuild.update_environment srcdir
+                # Add lib/ unconditionally, as we know that it is a ruby package.
+                # update_environment will add it only if there is a .rb file in the directory
+                libdir = File.join(srcdir, 'lib')
+                if File.directory?(libdir)
+                    Autobuild.env_add_path 'RUBYLIB', libdir
+                end
+
+                if rake_setup_task && File.file?(File.join(srcdir, 'Rakefile'))
+                    Autobuild::Subprocess.run self, 'post-install',
+                        Autobuild.tool_in_path('ruby'), '-S', Autobuild.tool('rake'), rake_setup_task,
+                        :working_directory => srcdir
+                end
+            end
+            super
+        end
+
+        def prepare_for_forced_build # :nodoc:
+            super
+            %w{ext tmp}.each do |extdir|
+                if File.directory?(extdir)
+                    Find.find(extdir) do |file|
+                        next if file !~ /\<Makefile\>|\<CMakeCache.txt\>$/
+                        FileUtils.rm_rf file
+                    end
+                end
+            end
+        end
+
+        def prepare_for_rebuild # :nodoc:
+            super
+            if rake_clean_task && File.file?(File.join(srcdir, 'Rakefile'))
+                begin
+                    Autobuild::Subprocess.run self, 'clean',
+                        Autobuild.tool_in_path('ruby'), '-S', Autobuild.tool('rake'), rake_clean_task,
+                        :working_directory => srcdir
+                rescue Autobuild::SubcommandFailed => e
+                    warn "%s: cleaning failed. If this package does not need a clean target,"
+                    warn "%s: set pkg.rake_clean_task = nil in the package definition."
+                    warn "%s: see #{e.logfile} for more details"
+                end
+            end
+        end
+
+        def update_environment
+            Autobuild.update_environment srcdir
+            libdir = File.join(srcdir, 'lib')
+            if File.directory?(libdir)
+                Autobuild.env_add_path 'RUBYLIB', libdir
+            end
+        end
+    end
+
+    def self.ruby(spec, &proc)
+        Ruby.new(spec, &proc)
+    end
+end
+

data/lib/autobuild/parallel.rb

@@ -62,6 +62,10 @@ module Autobuild
         end
 
         def discover_dependencies(all_tasks, reverse_dependencies, t)
+            if t.already_invoked?
+                return 
+            end
+
             return if all_tasks.include?(t) # already discovered or being discovered
             all_tasks << t
 
@@ -79,15 +83,19 @@ module Autobuild
             attr_reader :queue
             attr_reader :priorities
 
-            def initialize(reverse_dependencies, initial_queue = Array.new)
+            def initialize(reverse_dependencies)
                 @reverse_dependencies = reverse_dependencies
                 @processed = Set.new
                 @active_packages = Set.new
                 @priorities = Hash.new
                 @started_packages = Hash.new
                 @queue = Hash.new
-                initial_queue.each do |t|
-                    queue[t] = 1
+            end
+
+            def push(task, base_priority = 1)
+                if task.respond_to?(:package)
+                    queue[task] = started_packages[task.package] || base_priority
+                else queue[task] = base_priority
                 end
             end
 
@@ -111,17 +119,20 @@ module Autobuild
                 end
             end
 
+            def ready?(task)
+                task.prerequisite_tasks.all? do |t|
+                    t.already_invoked?
+                end
+            end
+
             def process_finished_task(task)
                 if task.respond_to?(:package)
                     active_packages.delete(task.package)
                 end
                 processed << task
                 reverse_dependencies[task].each do |candidate|
-                    if !processed.include?(candidate) && candidate.prerequisite_tasks.all? { |t| processed.include?(t) }
-                        if candidate.respond_to?(:package)
-                            queue[candidate] = started_packages[candidate.package] || priorities[task]
-                        else queue[candidate] = priorities[task]
-                        end
+                    if !candidate.already_invoked? && ready?(candidate)
+                        push(candidate, priorities[task])
                     end
                 end
             end
@@ -139,7 +150,15 @@ module Autobuild
             required_tasks.each do |t|
                 discover_dependencies(tasks, reverse_dependencies, t)
             end
-            roots = tasks.find_all { |t| t.prerequisite_tasks.empty? }.to_set
+            # The queue is the set of tasks for which all prerequisites have
+            # been successfully executed (or where not needed). I.e. it is the
+            # set of tasks that can be queued for execution.
+            state = ProcessingState.new(reverse_dependencies)
+            tasks.each do |t|
+                if state.ready?(t)
+                    state.push(t)
+                end
+            end
             
             # Build a reverse dependency graph (i.e. a mapping from a task to
             # the tasks that depend on it)
@@ -148,10 +167,6 @@ module Autobuild
             # topological sort since we would then have to scan all tasks each
             # time for tasks that have no currently running prerequisites
 
-            # The queue is the set of tasks for which all prerequisites have
-            # been successfully executed (or where not needed). I.e. it is the
-            # set of tasks that can be queued for execution.
-            state = ProcessingState.new(reverse_dependencies, roots.to_a)
             while true
                 pending_task = state.pop
                 if !pending_task
@@ -172,7 +187,8 @@ module Autobuild
                     Worker.execute_task(pending_task)
                     state.process_finished_task(pending_task)
                     next
-                elsif pending_task.instance_variable_get(:@already_invoked) || !pending_task.needed?
+                elsif pending_task.already_invoked? || !pending_task.needed?
+                    pending_task.already_invoked = true
                     state.process_finished_task(pending_task)
                     next
                 end
@@ -197,10 +213,33 @@ module Autobuild
                 worker.queue(pending_task)
             end
 
-            if state.processed.size != tasks.size
-                with_cycle = tasks.to_set
-                raise "cycle in task graph: #{with_cycle.map(&:name).sort.join(", ")}"
+            not_processed = tasks.find_all { |t| !t.already_invoked? }
+            if !not_processed.empty?
+                cycle = resolve_cycle(not_processed)
+                raise "cycle in task graph: #{cycle.map(&:name).sort.join(", ")}"
+            end
+        end
+
+        def resolve_cycle(tasks)
+            chain = []
+            next_task = tasks.first
+            while true
+                task = next_task
+                chain << task
+                tasks.delete(next_task)
+                next_task = task.prerequisite_tasks.find do |dep_task|
+                    if chain.include?(dep_task)
+                        reject = chain.take_while { |t| t != dep_task }
+                        return chain[reject.size..-1]
+                    elsif tasks.include?(dep_task)
+                        true
+                    end
+                end
+                if !next_task
+                    raise "something fishy while resolving a cycle in #{tasks.map(&:name).join(", ")}. Some of these packages might have added new dependencies during the task resolution, which is forbidden"
+                end
             end
+            chain
         end
 
         class Worker

data/lib/autobuild/rake_task_extension.rb

@@ -0,0 +1,19 @@
+module Autobuild
+    module RakeTaskExtension
+        def already_invoked?
+            !!@already_invoked
+        end
+
+        def already_invoked=(value)
+            @already_invoked = value
+        end
+
+        def disable!
+            @already_invoked = true
+            def self.needed?; false end
+        end
+    end
+end
+class Rake::Task
+    include Autobuild::RakeTaskExtension
+end

data/lib/autobuild/reporting.rb

@@ -1,20 +1,3 @@
-begin
-    require 'rmail'
-    require 'rmail/serialize'
-    Autobuild::HAS_RMAIL = true
-rescue LoadError
-    Autobuild::HAS_RMAIL = false
-end
-
-require 'net/smtp'
-require 'socket'
-require 'etc'
-require 'find'
-
-require 'autobuild/config'
-require 'autobuild/exceptions'
-require 'thread'
-
 module Autobuild
     class << self
         attr_reader :display_lock
@@ -66,9 +49,11 @@ module Autobuild
             else 0
             end
 
-        puts "\r#{msg}#{" " * [size - msg.size, 0].max}"
-        if @last_progress_msg
-            print "#{@last_progress_msg}"
+        if !silent?
+            puts "\r#{msg}#{" " * [size - msg.size, 0].max}"
+            if @last_progress_msg
+                print "#{@last_progress_msg}"
+            end
         end
     end
 

data/lib/autobuild/subcommand.rb

@@ -71,11 +71,6 @@ module Autobuild
             return @processor_count
         end
 		
-		#No parralel build on windows yet, since CPU detection is not easy do able
-		if(RbConfig::CONFIG["host_os"] =~%r!(msdos|mswin|djgpp|mingw|[Ww]indows)!)
-			return 1
-		end
-
         if File.file?('/proc/cpuinfo')
             cpuinfo = File.readlines('/proc/cpuinfo')
             physical_ids, core_count, processor_ids = [], [], []
@@ -98,7 +93,7 @@ module Autobuild
                 while (id = physical_ids.shift)
                     info[id] = core_count.shift
                 end
-                @processor_count = info.inject(&:+)
+                @processor_count = info.compact.inject(&:+)
             else
                 @processor_count = processor_ids.size
             end
@@ -116,6 +111,11 @@ module Autobuild
         if !@processor_count
             # Hug... What kind of system is it ?
             Autobuild.message "INFO: cannot autodetect the number of CPUs on this sytem"
+            Autobuild.message "INFO: turning parallel builds off"
+            Autobuild.message "INFO: you can manually set the number of parallel build processes to N"
+            Autobuild.message "INFO: (and therefore turn this message off)"
+            Autobuild.message "INFO: with"
+            Autobuild.message "    Autobuild.parallel_build_level = N"
             @processor_count = 1
         end
 

data/lib/autobuild/timestamps.rb

@@ -1,11 +1,6 @@
-require 'autobuild/config'
-require 'find'
-require 'rake/tasklib'
-require 'fileutils'
-
-STAMPFILE = "autobuild-stamp"
-
 module Autobuild
+    STAMPFILE = "autobuild-stamp"
+
     class << self
         # The set of global ignores for SourceTreeTask
         #

data/lib/autobuild/utility.rb

@@ -0,0 +1,164 @@
+module Autobuild
+    # Utilities are post-build things that can be executed on packages
+    #
+    # Canonical examples are documentation generation and tests
+    class Utility
+        # This utility's name
+        attr_reader :name
+        # @return [Package] the package on which this utility object acts
+        attr_reader :package
+        # @return [String,nil] the reference directory for {#source_dir=}. If
+        #   nil, will use the package's source directory
+        attr_accessor :source_ref_dir
+
+        def initialize(name, package)
+            @name = name
+            @package = package
+            @enabled = true
+            @source_ref_dir = nil
+        end
+
+        # Directory in which the utility will generate some files The
+        # interpretation of relative directories is package-specific. The
+        # default implementation interpret them as relative to the source
+        # directory. Set {#source_ref_dir=}
+        #
+        # @return [String,nil] the target directory, or nil if this utility does
+        #   not need any special source directory
+        attr_writer :source_dir
+
+        # Absolute path to where this utulity should output its results. Returns nil if
+        # {source_dir} has not been set.
+        def source_dir
+            if @source_dir
+                File.expand_path(@source_dir, source_ref_dir || package.srcdir)
+            end
+        end
+
+        # Directory in which the utility would install some files.
+        # If it is relative, it is interpreted as relative to the utility's
+        # prefix directory (Autobuild.#{name}_prefix)
+        #
+        # @return [String,nil] the target directory, or nil if this utility does
+        #   not install anything
+        attr_writer :target_dir
+
+        # Absolute path to where the utility product files have to be installed.
+        # Returns nil if {target_dir} is not set.
+        #
+        # @return [String,nil]
+        def target_dir
+            if @target_dir
+                File.expand_path(@target_dir, File.expand_path(Autobuild.send("#{name}_prefix") || name,  package.prefix))
+            end
+        end
+
+        # Defines the task code for this utility. The given block is called and
+        # then the utility byproducts get installed (if any).
+        #
+        # The block is invoked in the package's source directory
+        #
+        # In general, specific package types define a meaningful #with_XXX
+        # method that call this method internally
+        #
+        # @return [Rake::Task]
+        def task(&block)
+            return if @task
+            @task = package.task task_name do
+                # This flag allows to disable this utility's task
+                # once {task} has been called
+                if enabled?
+                    @installed = false
+                    catch(:disabled) do
+                        package.isolate_errors { call_task_block(&block) }
+                    end
+                end
+            end
+
+            package.task name => task_name 
+            @task
+        end
+
+        def call_task_block
+            yield if block_given?
+
+            # Allow the user to install manually in the task
+            # block
+            if !@installed && target_dir
+                install
+            end
+
+        rescue Interrupt
+            raise
+        rescue ::Exception => e
+            if Autobuild.send("pass_#{name}_errors")
+                raise
+            else
+                package.warn "%s: failed to call #{name}"
+                if e.kind_of?(SubcommandFailed)
+                    package.warn "%s: see #{e.logfile} for more details"
+                else
+                    package.warn "%s: #{e.message}"
+                end
+            end
+        end
+
+        # True if this utility would do something, and false otherwise
+        #
+        # This will return true only if a task has been by calling {task} _and_
+        # the utility has not been explicitly disabled by setting the {enabled}
+        # attribute to false
+        def enabled?
+            if !@enabled
+                return false
+            else
+                return source_dir && @task
+            end
+        end
+
+        # Allows to force {enabled?} to return false, regardless of whether
+        # {task} has been called or not
+        #
+        # This is mainly used for package types that have an e.g. documentation
+        # task by default, so that some packages can disable it.
+        attr_writer :enabled
+
+        def install
+            if !File.directory?(source_dir)
+                raise "#{source_dir} was expected to be a directory, but it is not. Check the package's #{name} generation. The generated #{name} products should be in #{source_dir}"
+            end
+
+            target_dir  = self.target_dir
+            source_dir  = self.source_dir
+            FileUtils.rm_rf   target_dir
+            FileUtils.mkdir_p File.dirname(target_dir)
+            FileUtils.cp_r    source_dir, target_dir
+
+            @installed = true
+        end
+
+        # Can be called in the block given to {task} to announce that the
+        # utility is to be disabled for that package. This is mainly used
+        # when a runtime check is necessary to know if a package can run
+        # this utility or not.
+        def disabled
+            throw :disabled
+        end
+
+        # The name of the Rake task
+        #
+        # @return [String]
+        def task_name
+            "#{package.name}-#{name}"
+        end
+
+        # True if the underlying package already has a task generated by this
+        # utility
+        #
+        # @return [Boolean]
+        def has_task?
+            !!Rake.application.lookup(task_name)
+        end
+    end
+end
+