autobuild 1.9.6 → 1.10.0.b1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d32aea62919186daa0c848f227876a196a27f7a
-  data.tar.gz: 41f822118c0087c991b84924d4192fdd3d3f835e
+  metadata.gz: e42c625c20b8bfbb4fc824fc40a9b2a41f5d6bb6
+  data.tar.gz: c35720c6c894d3fb3337bafb17424b72c9b1e9e1
 SHA512:
-  metadata.gz: 1285b76ff9092c239da7995261277a61e866396f590d62f86f0283298362db87bb0dfd587491a10eb92f2955f92cfc7196caad560875e792980d9caa842a244b
-  data.tar.gz: bf5c0c9728d0a47d78fb205f87acce329042a1c83ca03842debbb480a4b1898bfe02b5d61aa4eba4ea1bd64b6cf0255a60f5567031e6164f5c492821420235e0
+  metadata.gz: 728e7d5f5a968767e5d5bea8368bfda85c2601b6d66647f8d2f52ae7fe26019f1ef361ce3b0d9cf43b49e4ee71eb6c794c7b146eeb72c01543b495f83caefa2a
+  data.tar.gz: bc5181729cf2196ab580d175efcf411e0a79f9d3abc02e06280dda2bc15f595e0e8fa40b54cdcba1c11b6cec38ed316067f5de30d642049fdfb82785814ae340

data/Manifest.txt

@@ -18,6 +18,7 @@ lib/autobuild/import/hg.rb
 lib/autobuild/import/svn.rb
 lib/autobuild/import/tar.rb
 lib/autobuild/importer.rb
+lib/autobuild/mail_reporter.rb
 lib/autobuild/package.rb
 lib/autobuild/packages/autotools.rb
 lib/autobuild/packages/cmake.rb

data/Rakefile

@@ -15,7 +15,7 @@ Utilrb::Rake.hoe do
 
         self.extra_deps <<
             ['rake', '>= 0.9.0'] <<
-            ['utilrb', '~> 2.0.0'] <<
+            ['utilrb', '>= 1.6.0'] <<
             ['highline', '>= 0']
 
         self.test_globs = ['test/suite.rb']

data/lib/autobuild.rb

@@ -8,14 +8,6 @@ module Autobuild
     LIB_DIR = File.expand_path(File.dirname(__FILE__))
 end
 
-begin
-    require 'rmail'
-    require 'rmail/serialize'
-    Autobuild::HAS_RMAIL = true
-rescue LoadError
-    Autobuild::HAS_RMAIL = false
-end
-
 require 'net/smtp'
 require 'socket'
 require 'etc'
@@ -32,6 +24,7 @@ require 'autobuild/environment'
 require 'autobuild/exceptions'
 require 'autobuild/pkgconfig'
 require 'autobuild/reporting'
+require 'autobuild/mail_reporter'
 require 'autobuild/subcommand'
 require 'autobuild/timestamps'
 require 'autobuild/parallel'

data/lib/autobuild/configurable.rb

@@ -52,7 +52,6 @@ module Autobuild
         @builddir = 'build'
         
         def builddir=(new)
-            raise ConfigException.new(self), "absolute builddirs are not supported" if (Pathname.new(new).absolute?)
             raise ConfigException.new(self), "builddir must be non-empty" if new.empty?
             @builddir = new
         end

data/lib/autobuild/environment.rb

@@ -1,12 +1,8 @@
 require 'set'
 require 'rbconfig'
+require 'utilrb/hash/map_value'
 
 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
@@ -19,18 +15,13 @@ module Autobuild
 
     @freebsd = RbConfig::CONFIG["host_os"].include?('freebsd') 
     def self.freebsd?
-	@freebsd
+        @freebsd
     end
 
     def self.bsd?
-	@freebsd || @macos #can be extended to some other OSes liek NetBSD
+        @freebsd || @macos #can be extended to some other OSes liek NetBSD
     end
 
-    SYSTEM_ENV = Hash.new
-    ORIGINAL_ENV = Hash.new
-    ENV.each do |k, v|
-        ORIGINAL_ENV[k] = v
-    end
     SHELL_VAR_EXPANSION =
         if windows? then "%%%s%%"
         else "$%s"
@@ -68,15 +59,13 @@ module Autobuild
         else 'so'
         end
 
+    ORIGINAL_ENV = Hash.new
+    ENV.each do |k, v|
+        ORIGINAL_ENV[k] = v
+    end
 
-    class << self
-        # List of the environment that should be set before calling a subcommand
-        #
-        # It is a map from environment variable name to the corresponding value.
-        # If the value is an array, it is joined using the operating system's
-        # path separator (File::PATH_SEPARATOR)
-        attr_reader :environment
-
+    # Manager class for environment variables
+    class Environment
         # In generated environment update shell files, indicates whether an
         # environment variable should be overriden by the shell script, or
         # simply updated
@@ -90,415 +79,630 @@ module Autobuild
         #
         #   export VARNAME=new_value:new_value
         attr_reader :inherited_environment
-    end
+        # List of the environment that should be set before calling a subcommand
+        #
+        # It is a map from environment variable name to the corresponding value.
+        # If the value is an array, it is joined using the operating system's
+        # path separator (File::PATH_SEPARATOR)
+        attr_reader :environment
+        attr_reader :source_after
+        attr_reader :source_before
+
+        attr_reader :inherited_variables
+
+        attr_reader :resolved_env
+        attr_reader :system_env
+        attr_reader :original_env
+
+        def initialize
+            @inherited_environment = Hash.new
+            @environment = Hash.new
+            @source_before = Set.new
+            @source_after = Set.new
+            @inherit = true
+            @inherited_variables = Set.new
+
+            @system_env = Hash.new
+            @original_env = ORIGINAL_ENV.dup
+            @resolved_env = Hash.new
+            ENV.each do |k, v|
+                resolved_env[k] = v
+            end
+        end
 
-    # 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 |env_key|
-                env_reset(env_key)
+        def initialize_copy(old)
+            super
+            @inherited_environment = @inherited_environment.
+                map_value { |k, v| v.dup }
+            @environment = @environment.
+                map_value { |k, v| v.dup }
+            @source_before = @source_before.dup
+            @source_after = @source_after.dup
+            @inherited_variables = @inherited_variables.dup
+
+            @system_env = @system_env.
+                map_value { |k, v| v.dup }
+            @original_env = @original_env.
+                map_value { |k, v| v.dup }
+            @resolved_env = @resolved_env.
+                map_value { |k, v| v.dup }
+        end
+
+        def [](name)
+            resolved_env[name]
+        end
+
+        # Resets the value of +name+ to its original value. If it is inherited from
+        # the 
+        def reset(name = nil)
+            if name
+                environment.delete(name)
+                inherited_environment.delete(name)
+                init_from_env(name)
+            else
+                environment.keys.each do |env_key|
+                    reset(env_key)
+                end
             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.keys.each do |env_key|
-                env_clear(env_key)
+        # Unsets any value on the environment variable +name+, including inherited
+        # value.
+        #
+        # In a bourne shell, this would be equivalent to doing
+        #   
+        #   unset name
+        #
+        def clear(name = nil)
+            if name
+                environment[name] = nil
+                inherited_environment[name] = nil
+                update_var(name)
+            else
+                environment.keys.each do |env_key|
+                    clear(env_key)
+                end
             end
         end
-    end
 
-    # Set a new environment variable
-    def self.env_set(name, *values)
-        environment.delete(name)
-        env_add(name, *values)
-    end
+        # Set a new environment variable
+        def set(name, *values)
+            environment.delete(name)
+            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.
-    #
-    # @param [String,nil] name the environment variable that we want to check
-    #   for inheritance. If nil, the global setting is returned.
-    #
-    # @see env_inherit env_inherit=
-    def self.env_inherit?(name = nil)
-        if @env_inherit
-            if name 
-                @env_inherited_variables.include?(name)
-            else true
+        # 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.
+        #
+        # @param [String,nil] name the environment variable that we want to check
+        #   for inheritance. If nil, the global setting is returned.
+        #
+        # @see env_inherit env_inherit=
+        def inherit?(name = nil)
+            if @inherit
+                if name 
+                    @inherited_variables.include?(name)
+                else true
+                end
             end
         end
-    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.
-    #
-    # @see env_inherit? env_inherit
-    def self.env_inherit=(value)
-        @env_inherit = value
-        inherited_environment.keys.each do |env_name|
-            env_init_from_env(env_name)
+        # 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.
+        #
+        # @see inherit? inherit
+        def inherit=(value)
+            @inherit = value
+            inherited_environment.keys.each do |env_name|
+                init_from_env(env_name)
+            end
         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.
-    #
-    # @return [Boolean] true if environment inheritance is globally enabled and
-    #   false otherwise. This is controlled by {env_inherit=}
-    #
-    # @see env_inherit? env_inherit=
-    def self.env_inherit(*names)
-        flag =
-            if !names.last.respond_to?(:to_str)
-                names.pop
-            else true
-            end
-        
-        if flag
-            @env_inherited_variables |= names
-            names.each do |env_name|
-                env_init_from_env(env_name)
-            end
-        else
-            names.each do |n|
-                if @env_inherited_variables.include?(n)
-                    @env_inherited_variables.delete(n)
-                    env_init_from_env(n)
+        # 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.
+        #
+        # @return [Boolean] true if environment inheritance is globally enabled and
+        #   false otherwise. This is controlled by {env_inherit=}
+        #
+        # @see env_inherit? env_inherit=
+        def inherit(*names)
+            flag =
+                if !names.last.respond_to?(:to_str)
+                    names.pop
+                else true
+                end
+            
+            if flag
+                @inherited_variables |= names
+                names.each do |env_name|
+                    init_from_env(env_name)
+                end
+            else
+                names.each do |n|
+                    if @inherited_variables.include?(n)
+                        @inherited_variables.delete(n)
+                        init_from_env(n)
+                    end
                 end
             end
-        end
 
-        @env_inherit
-    end
+            @inherit
+        end
 
-    def self.env_init_from_env(name)
-        if env_inherit?(name) && (parent_env = ORIGINAL_ENV[name])
-            inherited_environment[name] = parent_env.split(File::PATH_SEPARATOR)
-        else
-            inherited_environment[name] = Array.new
+        def init_from_env(name)
+            if inherit?(name) && (parent_env = original_env[name])
+                inherited_environment[name] = parent_env.split(File::PATH_SEPARATOR)
+            else
+                inherited_environment[name] = Array.new
+            end
+            update_var(name)
         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)
+        def 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
-    end
 
-    # Adds a new value to an environment variable
-    def self.env_add(name, *values)
-        set = if environment.has_key?(name)
-                  environment[name]
-              end
+        # Adds a new value to an environment variable
+        def add(name, *values)
+            values = values.map { |v| expand(v) }
 
-        if !inherited_environment.has_key?(name)
-            env_init_from_env(name)
-        end
+            set = if environment.has_key?(name)
+                      environment[name]
+                  end
 
-        if !set
-            set = Array.new
-        elsif !set.respond_to?(:to_ary)
-            set = [set]
+            if !inherited_environment.has_key?(name)
+                init_from_env(name)
+            end
+
+            if !set
+                set = Array.new
+            elsif !set.respond_to?(:to_ary)
+                set = [set]
+            end
+
+            values.concat(set)
+            @environment[name] = values
+            update_var(name)
         end
 
-        values.concat(set)
-        @environment[name] = values
-        env_update_var(name)
-    end
+        # Returns an environment variable value
+        #
+        # @param [String] name the environment variable name
+        # @option options [Symbol] inheritance_mode (:expand) controls how
+        #   environment variable inheritance should be done. If :expand, the current
+        #   envvar value is inserted in the generated value. If :keep, the name of
+        #   the envvar is inserted (as e.g. $NAME). If :ignore, inheritance is
+        #   disabled in the generated value. Not that this applies only for the
+        #   environment variables for which inheritance has been enabled with
+        #   {#inherit}, other variables always behave as if :ignore was selected.
+        # @return [nil,Array<String>] either nil if this environment variable is not
+        #   set, or an array of values. How the values should be joined to form the
+        #   actual value is OS-specific, and not handled by this method
+        def value(name, options = Hash.new)
+            # For backward compatibility only
+            if !options.respond_to?(:to_hash)
+                if options
+                    options = Hash[:inheritance_mode => :expand]
+                else
+                    options = Hash[:inheritance_mode => :keep]
+                end
+            end
+            options = Kernel.validate_options options,
+                inheritance_mode: :expand
+            inheritance_mode = options[:inheritance_mode]
 
-    # Returns an environment variable value
-    #
-    # @param [String] name the environment variable name
-    # @option options [Symbol] inheritance_mode (:expand) controls how
-    #   environment variable inheritance should be done. If :expand, the current
-    #   envvar value is inserted in the generated value. If :keep, the name of
-    #   the envvar is inserted (as e.g. $NAME). If :ignore, inheritance is
-    #   disabled in the generated value. Not that this applies only for the
-    #   environment variables for which inheritance has been enabled with
-    #   #env_inherit, other variables always behave as if :ignore was selected.
-    # @return [nil,Array<String>] either nil if this environment variable is not
-    #   set, or an array of values. How the values should be joined to form the
-    #   actual value is OS-specific, and not handled by this method
-    def self.env_value(name, options = Hash.new)
-        # For backward compatibility only
-        if !options.respond_to?(:to_hash)
-            if options
-                options = Hash[:inheritance_mode => :expand]
+            if !environment[name] && !inherited_environment[name] && !system_env[name]
+                nil
             else
-                options = Hash[:inheritance_mode => :keep]
-            end
-        end
-        options = Kernel.validate_options options,
-            inheritance_mode: :expand
-        inheritance_mode = options[:inheritance_mode]
-
-        if !environment[name] && !inherited_environment[name] && !SYSTEM_ENV[name]
-            nil
-        else
-            inherited =
-                if inheritance_mode == :expand
-                    inherited_environment[name] || []
-                elsif inheritance_mode == :keep && env_inherit?(name)
-                    ["$#{name}"]
-                else []
-                end
+                inherited =
+                    if inheritance_mode == :expand
+                        inherited_environment[name] || []
+                    elsif inheritance_mode == :keep && inherit?(name)
+                        ["$#{name}"]
+                    else []
+                    end
 
 
-            value = []
-            [environment[name], inherited, SYSTEM_ENV[name]].each do |paths|
-                (paths || []).each do |p|
-                    if !value.include?(p)
-                        value << p
+                value = []
+                [environment[name], inherited, system_env[name]].each do |paths|
+                    (paths || []).each do |p|
+                        if !value.include?(p)
+                            value << p
+                        end
                     end
                 end
+                value
             end
-            value
-        end
-    end
-
-    def self.env_update_var(name)
-        if value = env_value(name)
-            ENV[name] = value.join(File::PATH_SEPARATOR)
-        else
-            ENV.delete(name)
         end
-    end
-
-    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
+        def update_var(name)
+            if value = value(name)
+                resolved_env[name] = value.join(File::PATH_SEPARATOR)
+            else
+                resolved_env.delete(name)
             end
         end
-    end
 
-    def self.env_remove_path(name, *paths)
-        paths.each do |p|
-            environment[name].delete(p)
+        def set_path(name, *paths)
+            clear(name)
+            add_path(name, *paths)
         end
-        env_update_var(name)
-    end
 
-    def self.env_push_path(name, *values)
-        if current = environment.delete(name)
-            current = current.dup
-            env_add_path(name, *values)
-            env_add_path(name, *current)
-        else
-            env_add_path(name, *values)
-        end
-    end
+        def add_path(name, *paths)
+            paths = paths.map { |p| expand(p) }
 
-    # Require that generated environment variable scripts source the given shell
-    # script
-    def self.env_source_file(file)
-        env_source_after(file)
-    end
-
-    # @overload env_source_before
-    #   List of scripts that should be sourced at the top of env.sh
-    #
-    #   @return [Array<String>] a list of paths that should be sourced at the
-    #     beginning of the shell script generated by {export_env_sh}
-    #
-    # @overload env_source_before(path)
-    #   @param [String] path a path that should be added to env_source_before
-    #
-    def self.env_source_before(file = nil)
-        if file
-            @env_source_before << file
-        end
-    end
+            oldpath = (environment[name] ||= Array.new)
+            paths.reverse.each do |path|
+                path = path.to_str
+                next if oldpath.include?(path)
 
-    # @overload env_source_after
-    #   List of scripts that should be sourced at the end of env.sh
-    #
-    #   @return [Array<String>] a list of paths that should be sourced at the
-    #     end of the shell script generated by {export_env_sh}
-    #
-    # @overload env_source_after(path)
-    #   @param [String] path a path that should be added to env_source_after
-    #
-    def self.env_source_after(file = nil)
-        if file
-            @env_source_after << file
+                add(name, path)
+                oldpath << path
+                if name == 'RUBYLIB'
+                    $LOAD_PATH.unshift path
+                end
+            end
         end
-    end
 
-    # Generates a shell script that sets the environment variable listed in
-    # Autobuild.environment, following the inheritance setting listed in
-    # Autobuild.inherited_environment.
-    #
-    # 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 SHELL_SOURCE_SCRIPT % path
+        def remove_path(name, *paths)
+            paths.each do |p|
+                environment[name].delete(p)
+            end
+            update_var(name)
         end
 
-        variables = []
-        Autobuild.environment.each do |name, _|
-            variables << name
-            value_with_inheritance = env_value(name, inheritance_mode: :keep)
-            value_without_inheritance = env_value(name, inheritance_mode: :ignore)
-
-            if !value_with_inheritance
-                shell_line = SHELL_UNSET_COMMAND % [name]
-            elsif value_with_inheritance == value_without_inheritance # no inheritance
-                shell_line = SHELL_SET_COMMAND % [name, value_with_inheritance.join(File::PATH_SEPARATOR)]
+        def push_path(name, *values)
+            if current = environment.delete(name)
+                current = current.dup
+                add_path(name, *values)
+                add_path(name, *current)
             else
-                shell_line = SHELL_CONDITIONAL_SET_COMMAND % [name, value_with_inheritance.join(File::PATH_SEPARATOR), value_without_inheritance.join(File::PATH_SEPARATOR)]
+                add_path(name, *values)
             end
-            io.puts shell_line
         end
-        variables.each do |var|
-            io.puts SHELL_EXPORT_COMMAND % [var]
-        end
-        @env_source_after.each do |path|
-            io.puts SHELL_SOURCE_SCRIPT % [path]
+
+        # @overload source_before
+        #   List of scripts that should be sourced at the top of env.sh
+        #
+        #   @return [Array<String>] a list of paths that should be sourced at the
+        #     beginning of the shell script generated by {export_env_sh}
+        #
+        # @overload source_before(path)
+        #   @param [String] path a path that should be added to source_before
+        #
+        def source_before(file = nil)
+            if file
+                @source_before << file
+            end
         end
-    end
 
-    # DEPRECATED: use env_add_path instead
-    def self.pathvar(path, varname)
-        if File.directory?(path)
-            if block_given?
-                return unless yield(path)
+        # @overload source_after
+        #   List of scripts that should be sourced at the end of env.sh
+        #
+        #   @return [Array<String>] a list of paths that should be sourced at the
+        #     end of the shell script generated by {export_env_sh}
+        #
+        # @overload source_after(path)
+        #   @param [String] path a path that should be added to source_after
+        #
+        def source_after(file = nil)
+            if file
+                @source_after << file
             end
-            env_add_path(varname, path)
         end
-    end
 
-    def self.each_env_search_path(prefix, patterns)
-        arch_names = self.arch_names
-        arch_size  = self.arch_size
-        
-        seen = Set.new
-        patterns.each do |base_path|
-            paths = []
-            if base_path =~ /ARCHSIZE/
-                base_path = base_path.gsub('ARCHSIZE', arch_size.to_s)
-            end
-            if base_path =~ /ARCH/
-                arch_names.each do |arch|
-                    paths << base_path.gsub('ARCH', arch)
+        # Generates a shell script that sets the environment variable listed in
+        # Autobuild.environment, following the inheritance setting listed in
+        # Autobuild.inherited_environment.
+        #
+        # It also sources the files added by source_file
+        def export_env_sh(io)
+            @source_before.each do |path|
+                io.puts SHELL_SOURCE_SCRIPT % path
+            end
+
+            variables = []
+            environment.each do |name, _|
+                variables << name
+                value_with_inheritance = value(name, inheritance_mode: :keep)
+                value_without_inheritance = value(name, inheritance_mode: :ignore)
+
+                if !value_with_inheritance
+                    shell_line = SHELL_UNSET_COMMAND % [name]
+                elsif value_with_inheritance == value_without_inheritance # no inheritance
+                    shell_line = SHELL_SET_COMMAND % [name, value_with_inheritance.join(File::PATH_SEPARATOR)]
+                else
+                    shell_line = SHELL_CONDITIONAL_SET_COMMAND % [name, value_with_inheritance.join(File::PATH_SEPARATOR), value_without_inheritance.join(File::PATH_SEPARATOR)]
                 end
-            else
-                paths << base_path
+                io.puts shell_line
             end
-            paths.each do |p|
-                p = File.join(prefix, *p.split('/'))
-                if !seen.include?(p) && File.directory?(p)
-                    yield(p)
-                    seen << p
+            variables.each do |var|
+                io.puts SHELL_EXPORT_COMMAND % [var]
+            end
+            @source_after.each do |path|
+                io.puts SHELL_SOURCE_SCRIPT % [path]
+            end
+        end
+
+        # DEPRECATED: use add_path instead
+        def self.pathvar(path, varname)
+            if File.directory?(path)
+                if block_given?
+                    return unless yield(path)
                 end
+                add_path(varname, path)
             end
         end
-    end
 
-    def self.arch_size
-        if @arch_size
-            return @arch_size
+        def each_env_search_path(prefix, patterns)
+            arch_names = self.arch_names
+            arch_size  = self.arch_size
+            
+            seen = Set.new
+            patterns.each do |base_path|
+                paths = []
+                if base_path =~ /ARCHSIZE/
+                    base_path = base_path.gsub('ARCHSIZE', arch_size.to_s)
+                end
+                if base_path =~ /ARCH/
+                    arch_names.each do |arch|
+                        paths << base_path.gsub('ARCH', arch)
+                    end
+                else
+                    paths << base_path
+                end
+                paths.each do |p|
+                    p = File.join(prefix, *p.split('/'))
+                    if !seen.include?(p) && File.directory?(p)
+                        yield(p)
+                        seen << p
+                    end
+                end
+            end
         end
 
-        @arch_size =
-            if RbConfig::CONFIG['host_cpu'] =~ /64/
-                64
-            else 32
+        def arch_size
+            if @arch_size
+                return @arch_size
             end
-    end
 
-    def self.arch_names
-        if @arch_names
-            return @arch_names
-        end
+            if File.file?('/usr/bin/dpkg-architecture')
+                cmdline = ['/usr/bin/dpkg-architecture']
+                if target_arch
+                    cmdline << "-T" << target_arch
+                end
+                arch = `#{cmdline.join(" ")}`.split.grep(/DEB_TARGET_ARCH_BITS/).first
+                if arch
+                    @arch_size = Integer(arch.chomp.split('=').last)
+                end
+            end
 
-        result = Set.new
-        if File.file?('/usr/bin/dpkg-architecture')
-            arch = `/usr/bin/dpkg-architecture`.split.grep(/DEB_BUILD_MULTIARCH/).first
-            if arch
-                result << arch.chomp.split('=').last
+            if !@arch_size
+                @arch_size =
+                    if RbConfig::CONFIG['host_cpu'] =~ /64/
+                        64
+                    else 32
+                    end
             end
+            @arch_size
         end
-        @arch_names = result
-    end
 
-    # Updates the environment when a new prefix has been added
-    def self.update_environment(newprefix, includes = nil)
-        if !includes || includes.include?('PATH')
-            if File.directory?("#{newprefix}/bin")
-                env_add_path('PATH', "#{newprefix}/bin")
-            end
+        def target_arch=(archname)
+            @target_arch = archname
+            @arch_size, @arch_names = nil
         end
 
-        if !includes || includes.include?('PKG_CONFIG_PATH')
-            pkg_config_search = ['lib/pkgconfig', 'lib/ARCH/pkgconfig', 'libARCHSIZE/pkgconfig']
-            each_env_search_path(newprefix, pkg_config_search) do |path|
-                env_add_path('PKG_CONFIG_PATH', path)
-            end
+        def target_arch
+            @target_arch
         end
 
-        if !includes || includes.include?(LIBRARY_PATH)
-            ld_library_search = ['lib', 'lib/ARCH', 'libARCHSIZE']
-            each_env_search_path(newprefix, ld_library_search) do |path|
-                if !Dir.glob(File.join(path, "lib*.#{LIBRARY_SUFFIX}")).empty?
-                    env_add_path(LIBRARY_PATH, path)
+        def arch_names
+            if @arch_names
+                return @arch_names
+            end
+
+            result = Set.new
+            if File.file?('/usr/bin/dpkg-architecture')
+                cmdline = ['/usr/bin/dpkg-architecture']
+                if target_arch
+                    cmdline << "-T" << target_arch
+                end
+                arch = `#{cmdline.join(" ")}`.split.grep(/DEB_TARGET_MULTIARCH/).first
+                if arch
+                    result << arch.chomp.split('=').last
                 end
             end
+            @arch_names = result
         end
 
-        # Validate the new rubylib path
-        if !includes || includes.include?('RUBYLIB')
-            new_rubylib = "#{newprefix}/lib"
-            if File.directory?(new_rubylib) && !File.directory?(File.join(new_rubylib, "ruby")) && !Dir["#{new_rubylib}/**/*.rb"].empty?
-                env_add_path('RUBYLIB', new_rubylib)
+        def update_environment(newprefix, includes = nil)
+            add_prefix(newprefix, includes)
+        end
+
+        # Updates the environment when a new prefix has been added
+        def add_prefix(newprefix, includes = nil)
+            if !includes || includes.include?('PATH')
+                if File.directory?("#{newprefix}/bin")
+                    add_path('PATH', "#{newprefix}/bin")
+                end
+            end
+
+            if !includes || includes.include?('PKG_CONFIG_PATH')
+                pkg_config_search = ['lib/pkgconfig', 'lib/ARCH/pkgconfig', 'libARCHSIZE/pkgconfig']
+                each_env_search_path(newprefix, pkg_config_search) do |path|
+                    add_path('PKG_CONFIG_PATH', path)
+                end
             end
 
-            require 'rbconfig'
-            %w{rubylibdir archdir sitelibdir sitearchdir vendorlibdir vendorarchdir}.
-                map { |key| RbConfig::CONFIG[key] }.
-                map { |path| path.gsub(/.*lib(?:32|64)?\//, '\\1') }.
-                each do |subdir|
-                    if File.directory?("#{newprefix}/lib/#{subdir}")
-                        env_add_path("RUBYLIB", "#{newprefix}/lib/#{subdir}")
+            if !includes || includes.include?(LIBRARY_PATH)
+                ld_library_search = ['lib', 'lib/ARCH', 'libARCHSIZE']
+                each_env_search_path(newprefix, ld_library_search) do |path|
+                    if !Dir.glob(File.join(path, "lib*.#{LIBRARY_SUFFIX}")).empty?
+                        add_path(LIBRARY_PATH, path)
                     end
                 end
+            end
+
+            # Validate the new rubylib path
+            if !includes || includes.include?('RUBYLIB')
+                new_rubylib = "#{newprefix}/lib"
+                if File.directory?(new_rubylib) && !File.directory?(File.join(new_rubylib, "ruby")) && !Dir["#{new_rubylib}/**/*.rb"].empty?
+                    add_path('RUBYLIB', new_rubylib)
+                end
+
+                require 'rbconfig'
+                %w{rubylibdir archdir sitelibdir sitearchdir vendorlibdir vendorarchdir}.
+                    map { |key| RbConfig::CONFIG[key] }.
+                    map { |path| path.gsub(/.*lib(?:32|64)?\//, '\\1') }.
+                    each do |subdir|
+                        if File.directory?("#{newprefix}/lib/#{subdir}")
+                            add_path("RUBYLIB", "#{newprefix}/lib/#{subdir}")
+                        end
+                    end
+            end
+        end
+
+        def isolate
+            self.inherit = false
+            push_path 'PATH', '/usr/local/bin', '/usr/bin', '/bin'
+        end
+
+        def prepare
+            # Set up some important autobuild parameters
+            inherit 'PATH', 'PKG_CONFIG_PATH', 'RUBYLIB', \
+                'LD_LIBRARY_PATH', 'CMAKE_PREFIX_PATH', 'PYTHONPATH'
+        end
+
+        # Method called to filter the environment variables before they are set,
+        # for instance to expand variables
+        def expand(value)
+            value
         end
     end
+
+    def self.env=(env)
+        @env = env
+    end
+
+    def self.env
+        if !@env
+            @env = Environment.new
+            @env.prepare
+        end
+        @env
+    end
+
+    # @deprecated, use the API on {env} instead
+    def self.env_reset(name = nil)
+        env.reset(name)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_clear(name = nil)
+        env.clear(name)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_set(name, *values)
+        env.set(name, *values)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_inherit?(name = nil)
+        env.inherit?(name)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_inherit=(value)
+        env.inherit = value
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_inherit(*names)
+        env.inherit(*names)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_init_from_env(name)
+        env.init_from_env(name)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_push(name, *values)
+        env.push(name, *values)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_add(name, *values)
+        env.add(name, *values)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_value(name, options = Hash.new)
+        env.value(name, options)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_update_var(name)
+        env.update_var(name)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_add_path(name, *paths)
+        env.add_path(name, *paths)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_remove_path(name, *paths)
+        env.remove_path(name, *paths)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_push_path(name, *values)
+        env.push_path(name, *values)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_source_file(file)
+        env.source_after(file)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_source_before(file = nil)
+        env.source_before(file)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.env_source_after(file = nil)
+        env.source_after(file)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.export_env_sh(io)
+        env.export_env_sh(io)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.each_env_search_path(prefix, patterns)
+        env.each_env_search_path(prefix, patterns)
+    end
+    # @deprecated, use the API on {env} instead
+    def self.update_environment(newprefix, includes = nil)
+        env.update_environment(newprefix, includes)
+    end
+
+    # @deprecated use {Env#add_path} on {.env} instead
+    def self.pathvar(path, varname)
+        if File.directory?(path)
+            if block_given?
+                return unless yield(path)
+            end
+            env.add_path(varname, path)
+        end
+    end
+
+    def self.arch_size
+        Autobuild.warn 'Autobuild.arch_size is deprecated, use Autobuild.env.arch_size instead'
+        env.arch_size
+    end
+
+    def self.arch_names
+        Autobuild.warn 'Autobuild.arch_names is deprecated, use Autobuild.env.arch_names instead'
+        env.arch_names
+    end
 end