autoproj 1.13.7 → 2.0.0.b1

data/lib/autoproj/exceptions.rb

@@ -0,0 +1,50 @@
+module Autoproj
+    class ConfigError < RuntimeError
+        attr_accessor :file
+        def initialize(file = nil)
+            super
+            @file = file
+        end
+    end
+    class InternalError < RuntimeError; end
+
+    # Exception raised when trying to resolve a package name and it failed
+    class PackageNotFound < ConfigError
+    end
+
+    class InputError < RuntimeError; end
+
+    # Exception raised when a caller requires to use an excluded package
+    class ExcludedPackage < ConfigError
+        attr_reader :name
+        def initialize(name)
+            @name = name
+        end
+    end
+
+    # Exception raised when an unknown package is encountered
+    class UnknownPackage < ConfigError
+        attr_reader :name
+        def initialize(name)
+            @name = name
+        end
+    end
+
+    class MissingOSDep < ConfigError; end
+
+    # Exception raised by
+    # PackageSelection#filter_excluded_and_ignored_packages when a given
+    # selection is completely excluded
+    class ExcludedSelection < ConfigError
+        attr_reader :selection
+        def initialize(selection)
+            @selection = selection
+        end
+    end
+
+    class UserError < RuntimeError; end
+
+    class WorkspaceAlreadyCreated < RuntimeError; end
+end
+
+

data/lib/autoproj/gitorious.rb

@@ -26,8 +26,10 @@ module Autoproj
             :ssh_url  => "git@#{base_url}:",
             :fallback_to_http => true,
             :default => 'http,ssh',
-            :disabled_methods => []
-            
+            :disabled_methods => [],
+            config: Autoproj.config
+
+        config = options.delete(:config)
         disabled_methods = Array(options[:disabled_methods])
 
         access_methods = Hash[
@@ -58,17 +60,17 @@ module Autoproj
             value
         end
 
-        configuration_option name, 'string',
+        config.declare name, 'string',
             :default => options[:default],
             :doc => gitorious_long_doc, &validator
 
-        access_mode = Autoproj.config.get(name)
+        access_mode = config.get(name)
         begin
             validator[access_mode]
         rescue Autoproj::InputError => e
             Autoproj.warn e.message
-            Autoproj.config.reset(name)
-            access_mode = Autoproj.config.get(name)
+            config.reset(name)
+            access_mode = config.get(name)
         end
         access_mode = access_methods[access_mode] || access_mode
         pull, push = access_mode.split(',')
@@ -77,7 +79,7 @@ module Autoproj
                   elsif method == "http" then options[:http_url]
                   elsif method == "ssh" then options[:ssh_url]
                   end
-            Autoproj.change_option("#{name}#{var_suffix}", url)
+            config.set("#{name}#{var_suffix}", url)
         end
 
         Autoproj.add_source_handler name.downcase do |url, vcs_options|
@@ -87,8 +89,8 @@ module Autoproj
             if url !~ /^\//
                 url = "/#{url}"
             end
-            pull_base_url = Autoproj.user_config("#{name}_ROOT")
-            push_base_url = Autoproj.user_config("#{name}_PUSH_ROOT")
+            pull_base_url = config.get("#{name}_ROOT")
+            push_base_url = config.get("#{name}_PUSH_ROOT")
             Hash[type: 'git',
                  url: "#{pull_base_url}#{url}",
                  push_to: "#{push_base_url}#{url}",

data/lib/autoproj/manifest.rb

@@ -7,31 +7,9 @@ require 'rexml/document'
 require 'win32/dir' if RbConfig::CONFIG["host_os"] =~%r!(msdos|mswin|djgpp|mingw|[Ww]indows)! 
 
 module Autoproj
-    @build_system_dependencies = Set.new
-
-    # Declare OS packages that are required to import and build the packages
-    #
-    # It is used by autoproj itself to install the importers and/or the build
-    # systems for the packages.
-    def self.add_build_system_dependency(*names)
-        @build_system_dependencies |= names.to_set
-    end
-
-    class << self
-        # Returns the set of OS packages that are needed to build and/or import
-        # the packages
-        #
-        # See Autoproj.add_build_system_dependency
-        attr_reader :build_system_dependencies
-    end
-
     # The Manifest class represents the information included in the main
     # manifest file, and allows to manipulate it
     class Manifest
-        # The set of packages that are selected by the user, either through the
-        # manifest file or through the command line, as a set of package names
-        attr_accessor :explicit_selection
-
         # Set the package sets that are available on this manifest
         #
         # This is set externally at loading time. {load_and_update_package_sets}
@@ -40,12 +18,6 @@ module Autoproj
         # @return [Array<PackageSet>]
         attr_writer :package_sets
 
-        # Returns true if +pkg_name+ has been explicitely selected, either by
-        # the command line or through the layout
-        def explicitly_selected_package?(pkg_name)
-            explicit_selection && explicit_selection.include?(pkg_name)
-        end
-
         # Loads the manifest file located at +file+ and returns the Manifest
         # instance that represents it
 	def self.load(file)
@@ -138,10 +110,7 @@ module Autoproj
             @manifest_exclusions = Set.new
 
             @constant_definitions = Hash.new
-            if Autoproj.has_config_key?('manifest_source')
-                @vcs = VCSDefinition.from_raw(Autoproj.user_config('manifest_source'))
-            end
-            @package_sets << LocalPackageSet.new(self, vcs)
+            @package_sets << LocalPackageSet.new(self)
 	end
 
 
@@ -167,16 +136,17 @@ module Autoproj
             end
         end
 
+        # Enumerates the package names of all ignored packages
+        def each_excluded_package
+            each_autobuild_package do |pkg|
+                yield(pkg) if excluded?(pkg.name)
+            end
+        end
+
         # Enumerates the package names of all ignored packages
         def each_ignored_package
-            ignored_packages.each do |l|
-                if pkg_set = metapackages[l]
-                    pkg_set.each_package do |pkg|
-                        yield(pkg.name)
-                    end
-                else
-                    yield(l)
-                end
+            each_autobuild_package do |pkg|
+                yield(pkg) if ignored?(pkg.name)
             end
         end
 
@@ -346,7 +316,9 @@ module Autoproj
 
         # Load the package set information
         def load_and_update_package_sets
-            Ops::Configuration.new(self, Ops.loader).load_and_update_package_sets
+            Autoproj.warn_deprecated __method__,
+                "use Ops::Configuration instead"
+            Ops::Configuration.new(Autoproj.workspace).load_and_update_package_sets
         end
 
         # Returns a package set that is used by autoproj for its own purposes
@@ -403,22 +375,26 @@ module Autoproj
             end
         end
 
-        def find_package_definition(name)
-            packages[name]
-        end
-
         def find_package(name)
-            packages[name]
+            if name.respond_to?(:name)
+                name = name.name
+            end
+
+            packages[name.to_str]
         end
 
         def find_autobuild_package(name)
-            if pkg = packages[name]
+            if name.respond_to?(:name)
+                name = name.name
+            end
+
+            if pkg = packages[name.to_str]
                 pkg.autobuild
             end
         end
 
         def package(name)
-            packages[name]
+            find_package(name)
         end
 
         # @deprecated use {each_autobuild_package} instead
@@ -449,16 +425,19 @@ module Autoproj
         # @deprecated use Ops::Tools.create_autobuild_package or include
         #   Ops::Tools into your class to get it as instance method
         def self.create_autobuild_package(vcs, text_name, into)
+            Autoproj.warn_deprecated __method__, "use Ops::Tools.create_autobuild_package instead"
             Ops::Tools.create_autobuild_package(vcs, text_name, into)
         end
 
         # @deprecated use Ops::Configuration#update_main_configuration
         def update_yourself(only_local = false)
-            Ops::Configuration.new(self, Ops.loader).update_main_configuration(only_local)
+            Autoproj.warn_deprecated __method__, "use Ops::Configuration instead"
+            Ops::Configuration.new(Autoproj.workspace).update_main_configuration(only_local)
         end
 
         # @deprecated use Ops::Configuration.update_remote_package_set
         def update_remote_set(vcs, only_local = false)
+            Autoproj.warn_deprecated __method__, "use Ops::Configuration instead"
             Ops::Configuration.update_remote_package_set(vcs, only_local)
         end
 
@@ -469,21 +448,34 @@ module Autoproj
         #   given package, defaults to the package's definition source (as
         #   returned by {definition_package_set}) if not given
         # @return [VCSDefinition] the VCS definition object
-        def importer_definition_for(package_name, package_source = definition_package_set(package_name))
-            vcs = package_source.importer_definition_for(package_name)
+        def importer_definition_for(package_name, package_set = definition_package_set(package_name),
+                                    options = Hash.new)
+            options = validate_options options, mainline: nil
+            mainline = 
+                if options[:mainline] == true
+                    package_set
+                else
+                    options[:mainline]
+                end
+
+            vcs = package_set.importer_definition_for(package_name)
             return if !vcs
 
             # Get the sets that come *after* the one that defines the package to
             # apply the overrides
             package_sets = each_package_set.to_a.dup
-            while !package_sets.empty? && package_sets.first != package_source
-                package_sets.shift
+            while !package_sets.empty? && package_sets.first != package_set
+                set = package_sets.shift
+                return vcs if set == mainline
             end
-            package_sets.shift
+            set = package_sets.shift
+            return vcs if set == mainline
 
             # Then apply the overrides
             package_sets.inject(vcs) do |updated_vcs, pkg_set|
-                pkg_set.overrides_for(package_name, updated_vcs)
+                updated_vcs = pkg_set.overrides_for(package_name, updated_vcs)
+                return updated_vcs if pkg_set == mainline
+                updated_vcs
             end
         end
 
@@ -503,13 +495,13 @@ module Autoproj
         #  * S1 must have a VCS line for P
         #  * S0 can have a VCS line for P, which would override the one defined
         #    by S1
-        def load_importers
+        def load_importers(options = Hash.new)
             packages.each_value do |pkg|
-                vcs = importer_definition_for(pkg.autobuild.name, pkg.package_set) ||
+                vcs = importer_definition_for(pkg.autobuild.name, pkg.package_set, options) ||
                     pkg.package_set.default_importer
 
+
                 if vcs
-                    Autoproj.add_build_system_dependency vcs.type
                     pkg.vcs = vcs
                     pkg.autobuild.importer = vcs.create_autobuild_importer
                 else
@@ -535,7 +527,7 @@ module Autoproj
         # Returns the PackageSet object for the given package set, or raises
         # ArgumentError if none exists with that name
         def package_set(name)
-            set = each_package_set(false).find { |set| set.name == name }
+            set = each_package_set.find { |set| set.name == name }
             if !set
                 raise ArgumentError, "no package set called #{name} exists"
             end
@@ -546,14 +538,6 @@ module Autoproj
             each_package_set.find(&:main?)
         end
 
-        # Exception raised when a caller requires to use an excluded package
-        class ExcludedPackage < ConfigError
-            attr_reader :name
-            def initialize(name)
-                @name = name
-            end
-        end
-
         # Resolves the given +name+, where +name+ can either be the name of a
         # source or the name of a package.
         #
@@ -562,18 +546,20 @@ module Autoproj
         #   [type, package_name]
         #
         # where +type+ can either be :package or :osdeps (as symbols)
-        #
-        # The returned array can be empty if +name+ is an ignored package
-        def resolve_package_name(name, options = Hash.new)
+        def resolve_package_name(name)
             if pkg_set = find_metapackage(name)
                 pkg_names = pkg_set.each_package.map(&:name)
             else
-                pkg_names = [name]
+                pkg_names = [name.to_str]
             end
 
             result = []
             pkg_names.each do |pkg|
-                result.concat(resolve_single_package_name(pkg, options))
+                begin
+                    result.concat(resolve_single_package_name(pkg))
+                rescue PackageNotFound
+                    raise PackageNotFound, "cannot resolve #{pkg}: it is not a package, not a metapackage and not an osdep"
+                end
             end
             result
         end
@@ -591,7 +577,7 @@ module Autoproj
                 next if result.include?(pkg_name)
                 result << pkg_name
 
-                pkg = Autobuild::Package[pkg_name]
+                pkg = find_autobuild_package(pkg_name)
                 pkg.dependencies.each do |dep_name|
                     queue << dep_name
                 end
@@ -604,83 +590,62 @@ module Autoproj
         #
         # This is a helper method for #resolve_package_name. Do not use
         # directly
-        def resolve_single_package_name(name, options = Hash.new) # :nodoc:
-            options = Kernel.validate_options options, :filter => true
-
-            explicit_selection  = explicitly_selected_package?(name)
-	    osdeps_availability = osdeps.availability_of(name)
-            available_as_source = Autobuild::Package[name]
-
-            osdeps_overrides = Autoproj.manifest.osdeps_overrides[name]
-            if osdeps_overrides
-                source_packages    = osdeps_overrides[:packages].dup
-                force_source_usage = osdeps_overrides[:force]
-                begin
-                    source_packages = source_packages.inject([]) do |result, src_pkg_name|
-                        result.concat(resolve_package_name(src_pkg_name))
-                    end.uniq
-                    available_as_source = true
-                rescue ExcludedPackage
-                    force_source_usage = false
-                    available_as_source = false
-                end
-
-                if source_packages.empty?
-                    source_packages << [:package, name]
-                end
+        #
+        # @return [nil,Array] either nil if there is no such osdep, or a list of
+        #   (type, package_name) pairs where type is either :package or :osdep and
+        #   package_name the corresponding package name
+        def resolve_single_package_name(name)
+            resolve_package_name_as_osdep(name)
+        rescue PackageNotFound => osdep_error
+            begin
+                resolve_package_name_as_source_package(name)
+            rescue PackageNotFound
+                raise PackageNotFound, "#{osdep_error} and it cannot be resolved as a source package"
             end
+        end
 
-            if force_source_usage
-                return source_packages
-            elsif !explicit_selection 
-                if osdeps_availability == Autoproj::OSDependencies::AVAILABLE
-                    return [[:osdeps, name]]
-                elsif osdeps_availability == Autoproj::OSDependencies::IGNORE
-                    return []
-                end
-
-                if osdeps_availability == Autoproj::OSDependencies::UNKNOWN_OS
-                    # If we can't handle that OS, but other OSes have a
-                    # definition for it, we assume that it can be installed as
-                    # an external package. However, if it is also available as a
-                    # source package, prompt the user
-                    if !available_as_source || explicit_osdeps_selection(name)
-                        return [[:osdeps, name]]
-                    end
-                end
-
-                # No source, no osdeps.
-                # If the package is ignored by the manifest, just return empty.
-                # Otherwise, generate a proper error message
-                # Call osdeps again, but this time to get
-                # a proper error message.
-                if !available_as_source
-                    if ignored?(name)
-                        return []
-                    end
-                    begin
-                        osdeps.resolve_os_dependencies([name].to_set)
-                    rescue Autoproj::ConfigError => e
-                        if osdeps_availability != Autoproj::OSDependencies::NO_PACKAGE && !osdeps.os_package_handler.enabled?
-                            if !@ignored_os_dependencies.include?(name)
-                                Autoproj.warn "some package depends on the #{name} osdep: #{e.message}"
-                                Autoproj.warn "this osdeps dependency is simply ignored as you asked autoproj to not install osdeps packages"
-                                @ignored_os_dependencies << name
-                            end
-                            # We are not asked to install OS packages, just ignore
-                            return []
-                        end
-                        raise
-                    end
-                    # Should never reach further than that
-                end
-            elsif !available_as_source
-                raise ConfigError, "cannot resolve #{name}: it is not a package, not a metapackage and not an osdeps"
-            end
-            if source_packages
-                return source_packages
+        def resolve_package_name_as_source_package(name)
+            if pkg = find_autobuild_package(name)
+                return [[:package, pkg.name]]
             else
-                return [[:package, name]]
+                raise PackageNotFound, "cannot resolve #{name}: it is neither a package nor an osdep"
+            end
+        end
+
+        # @api private
+        #
+        # Resolve a potential osdep name, either as the osdep itself, or as
+        # source packages that are used as osdep override
+        #
+        # @return [nil,Array] either nil if there is no such osdep, or a list of
+        #   (type, package_name) pairs where type is either :package or :osdep and
+        #   package_name the corresponding package name
+        def resolve_package_name_as_osdep(name)
+	    osdeps_availability = osdeps.availability_of(name)
+            if osdeps_availability == Autoproj::OSDependencies::NO_PACKAGE
+                raise PackageNotFound, "cannot resolve #{name}: it is not an osdep"
+            end
+
+            # There is an osdep definition for this package, check the
+            # overrides
+            osdeps_available =
+                (osdeps_availability == OSDependencies::AVAILABLE) ||
+                (osdeps_availability == OSDependencies::IGNORE)
+            osdeps_overrides = self.osdeps_overrides[name]
+            if osdeps_overrides && (!osdeps_available || osdeps_overrides[:force])
+                source_packages = osdeps_overrides[:packages].inject([]) do |result, src_pkg_name|
+                    result.concat(resolve_package_name_as_source_package(src_pkg_name))
+                end.uniq
+            elsif !osdeps_available && (pkg = find_autobuild_package(name))
+                return [[:package, pkg.name]]
+            elsif osdeps_available
+                return [[:osdeps, name]]
+            elsif osdeps_availability == OSDependencies::WRONG_OS
+                raise PackageNotFound, "#{name} is an osdep, but it is not available for this operating system"
+            elsif osdeps_availability == OSDependencies::UNKNOWN_OS
+                raise PackageNotFound, "#{name} is an osdep, but the local operating system is unavailable"
+            elsif osdeps_availability == OSDependencies::NONEXISTENT
+                raise PackageNotFound, "#{name} is an osdep, but it is explicitely marked as 'nonexistent' for this operating system"
             end
         end
 
@@ -688,7 +653,7 @@ module Autoproj
         # the first case, we return all packages defined by that source. In the
         # latter case, we return the singleton array [name]
         def resolve_package_set(name)
-            if Autobuild::Package[name]
+            if find_autobuild_package(name)
                 [name]
             else
                 pkg_set = find_metapackage(name)
@@ -721,7 +686,7 @@ module Autoproj
             packages.each do |pkg_name|
                 package_names = resolve_package_set(pkg_name)
                 package_names.each do |pkg_name|
-                    meta.add(Autobuild::Package[pkg_name])
+                    meta.add(find_autobuild_package(pkg_name))
                 end
             end
 
@@ -752,7 +717,7 @@ module Autoproj
                                end
 
 
-                        result.select(pkg_or_set, resolve_package_set(pkg_or_set), weak)
+                        result.select(pkg_or_set, resolve_package_set(pkg_or_set), weak: weak)
                     rescue UnknownPackage => e
                         raise e, "#{e.name}, which is selected in the layout, is unknown: #{e.message}", e.backtrace
                     end
@@ -787,7 +752,7 @@ module Autoproj
 
         # Returns all defined package names, minus the excluded and ignored ones
         def all_package_names
-            Autobuild::Package.each.map { |name, _| name }.to_set
+            each_autobuild_package.map(&:name)
         end
 
         # Returns all the packages that can be built in this installation
@@ -808,7 +773,7 @@ module Autoproj
         # If it is false, the method will simply return false on non-defined
         # packages 
         def package_enabled?(name, validate = true)
-            if !Autobuild::Package[name] && !osdeps.has?(name)
+            if !find_autobuild_package(name) && !osdeps.has?(name)
                 if validate
                     raise ArgumentError, "package #{name} does not exist"
                 end
@@ -835,9 +800,9 @@ module Autoproj
         # Returns the set of packages that are selected by the layout
         def all_selected_packages(validate = true)
             result = Set.new
-            root = default_packages(validate).packages.to_set
+            root = default_packages(validate).source_packages.to_set
             root.each do |pkg_name|
-                Autobuild::Package[pkg_name].all_dependencies(result)
+                find_autobuild_package(pkg_name).all_dependencies(result)
             end
             result | root
         end
@@ -971,7 +936,7 @@ module Autoproj
             required_os_packages = Set.new
             package_os_deps = Hash.new { |h, k| h[k] = Array.new }
             packages.each do |pkg_name|
-                pkg = Autobuild::Package[pkg_name]
+                pkg = find_autobuild_package(pkg_name)
                 if !pkg
                     raise InternalError, "internal error: #{pkg_name} is not a package"
                 end
@@ -1013,11 +978,11 @@ module Autoproj
         end
 
         # Installs the OS dependencies that are required by the given packages
-        def install_os_dependencies(packages)
+        def install_os_dependencies(packages, options = Hash.new)
             required_os_packages, package_os_deps = list_os_dependencies(packages)
             required_os_packages =
                 filter_os_dependencies(required_os_packages, package_os_deps)
-            osdeps.install(required_os_packages)
+            osdeps.install(required_os_packages, options)
         end
 
         # The set of overrides added with #add_osdeps_overrides
@@ -1038,10 +1003,12 @@ module Autoproj
         # The :force option allows to force the usage of the source package(s),
         # regardless of the availability of the osdeps package.
         def add_osdeps_overrides(osdeps_name, options)
-            options = Kernel.validate_options options, :package => nil, :packages => [], :force => false
+            options = Kernel.validate_options options, package: osdeps_name, packages: [], force: false
             if pkg = options.delete(:package)
                 options[:packages] << pkg
             end
+            packages = options[:packages]
+            packages.each { |pkg_name| resolve_package_name(pkg_name) }
             @osdeps_overrides[osdeps_name.to_s] = options
         end
 
@@ -1051,95 +1018,99 @@ module Autoproj
             @osdeps_overrides.delete(osdeps_name.to_s)
         end
 
-        # Exception raised when an unknown package is encountered
-        class UnknownPackage < ConfigError
-            attr_reader :name
-            def initialize(name)
-                @name = name
+        PackageSelection = Autoproj::PackageSelection
+
+        # @api private
+        #
+        # Helper for {#expand_package_selection}
+        def update_selection(selection, user_selection_string, name, weak)
+            source_packages, osdeps = Array.new, Array.new
+            resolve_package_name(name).each do |type, resolved_name|
+                if type == :package
+                    source_packages << resolved_name
+                else
+                    osdeps << resolved_name
+                end
+            end
+            if !source_packages.empty?
+                selection.select(user_selection_string, source_packages, osdep: false, weak: weak)
+            end
+            if !osdeps.empty?
+                selection.select(user_selection_string, osdeps, osdep: true, weak: weak)
             end
         end
 
-        PackageSelection = Autoproj::PackageSelection
-
-        # Package selection can be done in three ways:
-        #  * as a subdirectory in the layout
-        #  * as a on-disk directory
-        #  * as a package name
+        # Normalizes package selection strings into a PackageSelection object
         #
-        # This method converts the first two directories into the third one
+        # @param [Array<String>] selection the package selection strings. For
+        #   source packages, it can either be the package name, a package set
+        #   name, or a prefix of the package's source directory. For osdeps, it
+        #   has to be the plain package name
+        # @return [PackageSelection, Array<String>]
         def expand_package_selection(selection, options = Hash.new)
             options = Kernel.validate_options options, filter: true
-
             result = PackageSelection.new
 
-            # All the packages that are available on this installation
-            all_layout_packages = self.all_selected_packages
-
             # First, remove packages that are directly referenced by name or by
-            # package set names
+            # package set names. When it comes to packages (NOT package sets),
+            # we prefer the ones selected in the layout
+            all_selected_packages = self.all_selected_packages
+            candidates = all_selected_packages.to_a +
+                each_metapackage.map { |metapkg| [metapkg.name, metapkg.weak_dependencies?] }
             selection.each do |sel|
                 match_pkg_name = Regexp.new(Regexp.quote(sel))
-
-                packages = all_layout_packages.
-                    find_all { |pkg_name| pkg_name =~ match_pkg_name }.
-                    to_set
-                if !packages.empty?
-                    result.select(sel, packages, true)
-                end
-
-                each_metapackage do |pkg|
-                    if pkg.name =~ match_pkg_name
-                        packages = resolve_package_set(pkg.name).to_set
-                        packages = (packages & all_layout_packages)
-                        result.select(sel, packages, pkg.weak_dependencies?)
-                    end
+                candidates.each do |name, weak|
+                    next if name !~ match_pkg_name
+                    update_selection(result, sel, name, true)
                 end
             end
 
-            pending_selections = Hash.new
-
-            # Finally, check for package source directories
-            all_packages = self.all_package_names
-            all_osdeps_packages = osdeps.all_package_names
+            pending_selections = Hash.new { |h, k| h[k] = Array.new }
 
+            # Finally, check for partial matches
+            all_source_package_names = self.all_package_names
+            all_osdeps_package_names = osdeps.all_package_names
             selection.each do |sel|
                 match_pkg_name = Regexp.new(Regexp.quote(sel))
-                matching_packages = all_packages.map do |pkg_name|
-                    pkg = Autobuild::Package[pkg_name]
+                all_matches = Array.new
+                all_source_package_names.each do |pkg_name|
+                    pkg = find_autobuild_package(pkg_name)
                     if pkg_name =~ match_pkg_name ||
                         "#{sel}/" =~ Regexp.new("^#{Regexp.quote(pkg.srcdir)}/") ||
                         pkg.srcdir =~ Regexp.new("^#{Regexp.quote(sel)}")
-                        [pkg_name, (pkg_name == sel || pkg.srcdir == sel)]
+                        all_matches << [pkg_name, (pkg_name == sel || pkg.srcdir == sel)]
                     end
-                end.compact
-                matching_osdeps_packages = all_osdeps_packages.find_all do |pkg_name|
+                end
+                all_osdeps_package_names.each do |pkg_name|
                     if pkg_name =~ match_pkg_name
-                        [pkg_name, pkg_name == sel]
+                        all_matches << [pkg_name, pkg_name == sel]
                     end
-                end.compact
+                end
 
-                (matching_packages + matching_osdeps_packages).to_set.each do |pkg_name, exact_match|
-                    # Check-out packages that are not in the manifest only
+                all_matches.each do |pkg_name, exact_match|
+                    # Select packages that are not in the manifest only
                     # if they are explicitely selected. However, we do store
                     # them as "possible resolutions" for the user selection,
                     # and add them if -- at the end of the method -- nothing
                     # has been found for this particular selection
-                    if !all_layout_packages.include?(pkg_name) && !exact_match
-                        pending_selections[sel] = pkg_name
-                        next
+                    if !all_selected_packages.include?(pkg_name) && !exact_match
+                        pending_selections[sel] << pkg_name
+                    else
+                        update_selection(result, sel, pkg_name, true)
                     end
-
-                    result.select(sel, pkg_name, true)
                 end
             end
 
             if options[:filter]
                 result.filter_excluded_and_ignored_packages(self)
             end
+
             nonresolved = selection - result.matches.keys
             nonresolved.delete_if do |sel|
-                if pkg_name = pending_selections[sel]
-                    result.select(sel, pkg_name, true)
+                if pending = pending_selections.fetch(sel, nil)
+                    pending.each do |name|
+                        update_selection(result, sel, name, true)
+                    end
                     true
                 end
             end
@@ -1218,34 +1189,31 @@ module Autoproj
         end
     end
 
-    class << self
-        # The singleton manifest object that represents the current build
-        # configuration
-        #
-        # @return [Manifest]
-        attr_accessor :manifest
+    def self.manifest
+        Autoproj.warn_deprecated(
+            __method__, "use workspace.manifest instead")
 
-        # The known osdeps definitions
-        #
-        # @return [OSDependencies]
-        # @see load_osdeps_from_package_sets
-        def osdeps
-            manifest.osdeps
-        end
+        workspace.manifest
+    end
 
-        def osdeps=(osdeps)
-            raise ArgumentError, "cannot set the osdeps object explicitely anymore. Use osdeps.clear and osdeps.merge"
-        end
+    def self.osdeps
+        Autoproj.warn_deprecated(
+            __method__, "use workspace.osdeps instead")
+
+        workspace.osdeps
+    end
+
+    def self.config
+        Autoproj.warn_deprecated(
+            __method__, "use workspace.config instead")
 
-        # The configuration file
-        # @return [Configuration]
-        attr_accessor :config
+        workspace.config
     end
 
     # Load the osdeps files contained in {manifest} into {osdeps}
     def self.load_osdeps_from_package_sets
-        manifest.load_osdeps_from_package_sets(osdeps)
-        osdeps
+        workspace.load_osdeps_from_package_sets(osdeps)
+        workspace.osdeps
     end
 
     def self.add_osdeps_overrides(*args, &block)