autobuild 1.6.5 → 1.7.0.rc1

data/Rakefile

@@ -10,8 +10,8 @@ Utilrb::Rake.hoe do
         self.email = %q{rock-dev@dfki.de}
 
         self.extra_deps <<
-            ['rake', '>= 0.9.0'] <<
-            ['utilrb', '>= 1.6.0'] <<
+            ['rake', '>= 0.7.0'] <<
+            ['utilrb', '>= 1.3.3'] <<
             ['highline', '>= 0']
     end
     Rake.clear_tasks(/publish_docs/, /default/)

data/lib/autobuild/configurable.rb

@@ -78,7 +78,7 @@ module Autobuild
         end
 
         def prepare
-            Autobuild.source_tree srcdir do |pkg|
+            source_tree srcdir do |pkg|
                 pkg.exclude << Regexp.new("^#{Regexp.quote(builddir)}")
                 pkg.exclude << Regexp.new("^#{Regexp.quote(doc_dir)}") if doc_dir
             end

data/lib/autobuild/environment.rb

@@ -1,10 +1,51 @@
 require 'set'
+require 'rbconfig'
+
 module Autobuild
     @inherited_environment = Hash.new
     @environment = Hash.new
     @env_source_before = Set.new
     @env_source_after = Set.new
 
+    @windows = RbConfig::CONFIG["host_os"] =~%r!(msdos|mswin|djgpp|mingw|[Ww]indows)!
+    def self.windows?
+        @windows
+    end
+
+    @macos =  RbConfig::CONFIG["host_os"] = ~%r!([Dd]arwin)!
+    def self.macos?
+        @macos
+    end
+
+    ORIGINAL_ENV = Hash.new
+    ENV.each do |k, v|
+        ORIGINAL_ENV[k] = v
+    end
+    ENV_LIST_SEPARATOR =
+        if windows? then ';'
+        else ':'
+        end
+    SHELL_VAR_EXPANSION =
+        if windows? then "%%%s%%"
+        else "$%s"
+        end
+    SHELL_SET_COMMAND =
+        if windows? then "set %s=%s"
+        else "%s=%s"
+        end
+    SHELL_UNSET_COMMAND =
+        if windows? then "unset %s"
+        else "unset %s"
+        end
+    SHELL_EXPORT_COMMAND =
+        if windows? then "set %s"
+        else "export %s"
+        end
+    SHELL_SOURCE_SCRIPT =
+        if windows? then "%s"
+        else ". \"%s\""
+        end
+	
     class << self
         # List of the environment that should be set before calling a subcommand
         #
@@ -35,24 +76,100 @@ module Autobuild
         attr_reader :env_source_after
     end
 
-    # Removes any settings related to the environment varialbe +name+, or for
-    # all environment variables if no name is given
+    # Resets the value of +name+ to its original value. If it is inherited from
+    # the 
+    def self.env_reset(name = nil)
+        if name
+            environment.delete(name)
+            inherited_environment.delete(name)
+            env_init_from_env(name)
+        else
+            environment.keys.each do |name|
+                env_reset(name)
+            end
+        end
+    end
+
+    # Unsets any value on the environment variable +name+, including inherited
+    # value.
+    #
+    # In a bourne shell, this would be equivalent to doing
+    #   
+    #   unset name
+    #
     def self.env_clear(name = nil)
         if name
             environment[name] = nil
             inherited_environment[name] = nil
+            env_update_var(name)
         else
-            environment.clear
-            inherited_environment.clear
+            environment.keys.each do |name|
+                env_clear(name)
+            end
         end
     end
 
     # Set a new environment variable
     def self.env_set(name, *values)
-        env_clear(name)
+        env_reset(name)
         env_add(name, *values)
     end
 
+    @env_inherit = true
+    @env_inherited_variables = Set.new
+
+    # Returns true if the given environment variable must not be reset by the
+    # env.sh script, but that new values should simply be prepended to it.
+    #
+    # See Autoproj.env_inherit
+    def self.env_inherit?(name)
+        @env_inherit && @env_inherited_variables.include?(name)
+    end
+
+    # If true (the default), the environment variables that are marked as
+    # inherited will be inherited from the global environment (during the
+    # build as well as in the generated env.sh files)
+    #
+    # Otherwise, only the environment that is explicitely set in autobuild
+    # will be passed on to subcommands, and saved in the environment
+    # scripts.
+    def self.env_inherit=(value)
+        @env_inherit = value
+        inherited_environment.keys.each do |env_name|
+            env_init_from_env(env_name)
+        end
+    end
+
+    # Declare that the given environment variable must not be reset by the
+    # env.sh script, but that new values should simply be prepended to it.
+    #
+    # See Autoproj.env_inherit?
+    def self.env_inherit(*names)
+        @env_inherited_variables |= names
+        names.each do |env_name|
+            env_init_from_env(env_name)
+        end
+    end
+
+    def self.env_init_from_env(name)
+        if env_inherit?(name) && (parent_env = ORIGINAL_ENV[name])
+            inherited_environment[name] = parent_env.split(ENV_LIST_SEPARATOR)
+        else
+            inherited_environment[name] = Array.new
+        end
+        env_update_var(name)
+    end
+
+    def self.env_push(name, *values)
+        if current = environment[name]
+            current = current.dup
+            env_set(name, *values)
+            env_add(name, *current)
+        else
+            env_add(name, *values)
+        end
+    end
+
     # Adds a new value to an environment variable
     def self.env_add(name, *values)
         set = if environment.has_key?(name)
@@ -60,11 +177,7 @@ module Autobuild
               end
 
         if !inherited_environment.has_key?(name)
-            if parent_env = ENV[name]
-                inherited_environment[name] = parent_env.split(':')
-            else
-                inherited_environment[name] = Array.new
-            end
+            env_init_from_env(name)
         end
 
         if !set
@@ -75,22 +188,38 @@ module Autobuild
 
         values.concat(set)
         @environment[name] = values
+        env_update_var(name)
+    end
 
-        inherited = inherited_environment[name] || Array.new
-        ENV[name] = (values + inherited).join(":")
+    def self.env_update_var(name)
+        if !environment[name] && !inherited_environment[name]
+            ENV.delete(name)
+        else
+            ENV[name] = ((environment[name] || []) + (inherited_environment[name] || [])).join(ENV_LIST_SEPARATOR)
+        end
     end
 
-    def self.env_add_path(name, path, *paths)
-        oldpath = environment[name]
-        if !oldpath || !oldpath.include?(path)
+    def self.env_add_path(name, *paths)
+        oldpath = environment[name] || Array.new
+        paths.reverse.each do |path|
+            next if oldpath.include?(path)
+
             env_add(name, path)
+            oldpath << path
             if name == 'RUBYLIB'
                 $LOAD_PATH.unshift path
             end
         end
+    end
 
-        if !paths.empty?
-            env_add_path(name, *paths)
+    def self.env_push_path(name, *values)
+        if current = environment[name]
+            current = current.dup
+            env_clear(name)
+            env_add_path(name, *values)
+            env_add_path(name, *current)
+        else
+            env_add_path(name, *values)
         end
     end
 
@@ -119,27 +248,31 @@ module Autobuild
     # It also sources the files added by Autobuild.env_source_file
     def self.export_env_sh(io)
         @env_source_before.each do |path|
-            io.puts ". \"#{path}\""
+            io.puts SHELL_SOURCE_SCRIPT % path
         end
 
         variables = []
         Autobuild.environment.each do |name, value|
             variables << name
-            shell_line = "#{name}=#{value.join(":")}"
-            if Autoproj.env_inherit?(name)
+            if value
+                shell_line = SHELL_SET_COMMAND % [name, value.join(ENV_LIST_SEPARATOR)]
+            else
+                shell_line = SHELL_UNSET_COMMAND % [name]
+            end
+            if env_inherit?(name)
                 if value.empty?
                     next
                 else
-                    shell_line << ":$#{name}"
+                    shell_line << "#{ENV_LIST_SEPARATOR}$#{name}"
                 end
             end
             io.puts shell_line
         end
         variables.each do |var|
-            io.puts "export #{var}"
+            io.puts SHELL_EXPORT_COMMAND % [var]
         end
         @env_source_after.each do |path|
-            io.puts ". \"#{path}\""
+            io.puts SHELL_SOURCE_SCRIPT % [path]
         end
     end
 

data/lib/autobuild/import/archive.rb

@@ -2,6 +2,15 @@ require 'autobuild/importer'
 require 'open-uri'
 require 'fileutils'
 
+WINDOWS = RbConfig::CONFIG["host_os"] =~%r!(msdos|mswin|djgpp|mingw|[Ww]indows)! 
+if WINDOWS 
+	require 'net/http' 
+	require 'net/https'
+	require 'rubygems/package'
+	require 'zlib'
+end
+
+
 module Autobuild
     class ArchiveImporter < Importer
 	# The tarball is not compressed
@@ -36,6 +45,47 @@ module Autobuild
 
         def update_cached_file?; @options[:update_cached_file] end
 
+		
+	def get_url_on_windows(url, filename)
+		uri = URI(url)		
+		STDOUT.puts("Host: #{uri.host} Port: #{uri.port} url: #{url}")
+		
+		http = Net::HTTP.new(uri.host,uri.port)
+		http.use_ssl = true if uri.port == 443
+		http.verify_mode = OpenSSL::SSL::VERIFY_NONE  #Unsure, critical?, Review this
+		resp = http.get(uri.request_uri)
+		
+		if resp.code == "301" or resp.code == "302"
+			get_url_on_windows(resp.header['location'],filename)
+		else
+			if(resp.message != 'OK')
+				raise "Could not get File from url \"#{url}\", got response #{resp.message} (#{resp.code})"
+			end
+			open(filename, "wb") do |file|
+				file.write(resp.body)
+			end
+		end
+	end
+	
+	def extract_tar_on_windows(filename,target)
+	
+		Gem::Package::TarReader.new(Zlib::GzipReader.open(filename)).each do |entry|
+			newname = File.join(target,entry.full_name.slice(entry.full_name.index('/'),entry.full_name.size))
+			if(entry.directory?)
+				FileUtils.mkdir_p(newname)
+			end
+			if(entry.file?)
+				dir = newname.slice(0,newname.rindex('/'))
+				if(!File.directory?(dir))
+					FileUtils.mkdir_p(dir)
+				end
+				open(newname, "wb") do |file|
+					file.write(entry.read)
+				end
+			end
+		end
+	end
+	
 	# Updates the downloaded file in cache only if it is needed
         def update_cache(package)
             do_update = false
@@ -73,7 +123,11 @@ module Autobuild
             if do_update
                 FileUtils.mkdir_p(cachedir)
                 begin
-                    Subprocess.run(package, :import, Autobuild.tool('wget'), '-q', '-P', cachedir, @url, '-O', "#{cachefile}.partial")
+					if(WINDOWS)
+						get_url_on_windows(@url, "#{cachefile}.partial")
+					else
+						Subprocess.run(package, :import, Autobuild.tool('wget'), '-q', '-P', cachedir, @url, '-O', "#{cachefile}.partial")
+					end
                 rescue Exception
                     FileUtils.rm_f "#{cachefile}.partial"
                     raise
@@ -172,13 +226,18 @@ module Autobuild
                 if !@options[:no_subdirectory]
                     cmd << '--strip-components=1'
                 end
-                Subprocess.run(package, :import, Autobuild.tool('tar'), *cmd)
+				
+				if(WINDOWS)
+					extract_tar_on_windows(cachefile,package.srcdir)
+				else
+					Subprocess.run(package, :import, Autobuild.tool('tar'), *cmd)
+				end
             end
 
         rescue OpenURI::HTTPError
             raise Autobuild::Exception.new(package.name, :import)
         rescue SubcommandFailed
-            FileUtils.rm_f cachefile
+			FileUtils.rm_f cachefile
             raise
         end
     end

data/lib/autobuild/importer.rb

@@ -87,12 +87,28 @@ class Importer
     end
 
     def patches
-        if @options[:patches].respond_to?(:to_ary)
-            @options[:patches]
-        elsif !@options[:patches]
-            []
+        patches =
+            if @options[:patches].respond_to?(:to_ary)
+                @options[:patches]
+            elsif !@options[:patches]
+                []
+            else
+                [[@options[:patches], 0]]
+            end
+
+        if patches.size == 2 && patches[0].respond_to?(:to_str) && patches[1].respond_to?(:to_int)
+            patches = [patches]
         else
-            [@options[:patches]]
+            patches.map do |obj|
+                if obj.respond_to?(:to_str)
+                    [obj, 0]
+                elsif obj.respond_to?(:to_ary)
+                    obj
+                else
+                    raise Arguments, "wrong patch specification #{obj.inspect}"
+                    obj
+                end
+            end
         end
     end
 
@@ -139,7 +155,7 @@ class Importer
             package.message "update failed in #{package.srcdir}, retrying (#{retry_count}/#{self.retry_count})"
             retry
         ensure
-            package.progress_done
+            package.progress_done "updated %s"
         end
 
         patch(package)
@@ -151,7 +167,7 @@ class Importer
     end
 
     def perform_checkout(package)
-        package.progress_start "checking out %s" do
+        package.progress_start "checking out %s", :done_message => 'checked out %s' do
             retry_count = 0
             begin
                 checkout(package)
@@ -226,23 +242,35 @@ class Importer
         File.join(package.srcdir, "patches-autobuild-stamp")
     end
 
-    def call_patch(package, reverse, file)
+    def call_patch(package, reverse, file, patch_level)
         patch = Autobuild.tool('patch')
         Dir.chdir(package.srcdir) do
-            Subprocess.run(package, :patch, patch, '-p0', (reverse ? '-R' : nil), '--forward', :input => file)
+            Subprocess.run(package, :patch, patch, "-p#{patch_level}", (reverse ? '-R' : nil), '--forward', :input => file)
         end
     end
 
-    def apply(package, path);   call_patch(package, false, path) end
-    def unapply(package, path); call_patch(package, true, path)   end
+    def apply(package, path, patch_level = 0);   call_patch(package, false, path, patch_level) end
+    def unapply(package, path, patch_level = 0); call_patch(package, true, path, patch_level)   end
 
     def currently_applied_patches(package)
         patches_file = patchlist(package)
         if !File.exists?(patches_file) then []
         else
+            current_patches = []
             File.open(patches_file) do |f| 
-                f.readlines.collect { |path| path.rstrip } 
+                f.readlines.each do |line|
+                    line = line.rstrip
+                    if line =~ /^(.*)\s+(\d+)$/
+                        path = $1
+                        level = Integer($2)
+                    else
+                        path = line
+                        level = 0
+                    end
+                    current_patches << [path, level]
+                end
             end
+            current_patches
         end
     end
 
@@ -268,17 +296,18 @@ class Importer
             end
 
             while p = cur_patches.last
-                unapply(package, p) 
+                p, level = *p
+                unapply(package, p, level)
                 cur_patches.pop
             end
 
-            patches.to_a.each do |p| 
-                apply(package, p) 
-                cur_patches << p
+            patches.to_a.each do |p, level|
+                apply(package, p, level)
+                cur_patches << [p, level]
 	    end
         ensure
             File.open(patchlist(package), 'w+') do |f|
-                f.write(cur_patches.join("\n"))
+                f.write(cur_patches.map { |p, l| "#{p} #{l}" }.join("\n"))
             end
         end