autoproj 2.0.0.rc37 → 2.0.0.rc38

data/lib/autoproj/cli/versions.rb

@@ -31,8 +31,7 @@ def run(user_selection, options)
                 initialize_and_load
                 packages, *, config_selected =
                     finalize_setup(user_selection,
-                                   recursive: options[:deps],
-                                   ignore_non_imported_packages: true)
+                                   recursive: options[:deps])
                 
                 ops = Ops::Snapshot.new(ws.manifest, ignore_errors: options[:keep_going])
                 

data/lib/autoproj/configuration.rb

@@ -115,7 +115,7 @@ def validated_values
         #   should be converted to lowercase before it gets validated / saved.
         # @option options [Boolean] :uppercase (false) whether the user's input
         #   should be converted to uppercase before it gets validated / saved.
-        def declare(name, type, options, &validator)
+        def declare(name, type, **options, &validator)
             declared_options[name] = BuildOption.new(name, type, options, validator)
         end
 

data/lib/autoproj/environment.rb

@@ -8,18 +8,13 @@ class Environment < Autobuild::Environment
         attr_reader :root_dir
 
         def prepare(root_dir)
-            super()
-
             @root_dir = root_dir
             set 'AUTOPROJ_CURRENT_ROOT', root_dir
+            super()
         end
 
         def filter_original_env(name, env)
-            env.find_all { |p| !Workspace.in_autoproj_project?(p) }
-        end
-
-        def expand(value)
-            Autoproj.expand_environment(value)
+            Autoproj.filter_out_paths_in_workspace(env)
         end
 
         def export_env_sh(subdir = nil, options = Hash.new)

data/lib/autoproj/exceptions.rb

@@ -12,6 +12,11 @@ class InternalError < RuntimeError; end
     class PackageNotFound < ConfigError
     end
 
+    class UnregisteredPackage < ArgumentError
+    end
+
+    class InvalidPackageManifest < RuntimeError; end
+
     class InputError < RuntimeError; end
 
     # Exception raised when a caller requires to use an excluded package
@@ -22,16 +27,13 @@ def initialize(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 when finding unexpected objects in a YAML file
+    #
+    # E.g. having a hash instead of an array
+    class InvalidYAMLFormatting < ConfigError; end
+
     # Exception raised by
     # PackageSelection#filter_excluded_and_ignored_packages when a given
     # selection is completely excluded

data/lib/autoproj/find_workspace.rb

@@ -21,19 +21,13 @@ def self.find_prefix_dir(base_dir = default_find_base_dir)
         find_v2_prefix_dir(base_dir)
     end
 
-    # @private
-    #
-    # Finds an autoproj "root directory" that contains a given directory. It
-    # can either be the root of a workspace or the root of an install
+    # Find a workspace configuration file in the parent tree of a given
     # directory
     #
-    # @param [String] base_dir the start of the search
-    # @param [String] config_field_name the name of a field in the root's
-    #   configuration file, that should be returned instead of the root
-    #   itself
-    # @return [String,nil] the root of the workspace directory, or nil if
-    #   there's none
-    def self.find_v2_root_dir(base_dir, config_field_name)
+    # @param [String] base_dir the directory to start from
+    # @return [(String,Hash),nil] the root path, and the configuration, or nil
+    #   if base_dir is not part of a workspace
+    def self.find_v2_workspace_config(base_dir)
         path = Pathname.new(base_dir).expand_path
         while !path.root?
             if (path + ".autoproj" + "config.yml").exist?
@@ -47,8 +41,24 @@ def self.find_v2_root_dir(base_dir, config_field_name)
         end
 
         config_path = path + ".autoproj" + "config.yml"
+        return path.to_s, (YAML.load(config_path.read) || Hash.new)
+    end
 
-        config = YAML.load(config_path.read) || Hash.new
+    # @private
+    #
+    # Finds an autoproj "root directory" that contains a given directory. It
+    # can either be the root of a workspace or the root of an install
+    # directory
+    #
+    # @param [String] base_dir the start of the search
+    # @param [String] config_field_name the name of a field in the root's
+    #   configuration file, that should be returned instead of the root
+    #   itself
+    # @return [String,nil] the root of the workspace directory, or nil if
+    #   there's none
+    def self.find_v2_root_dir(base_dir, config_field_name)
+        path, config = find_v2_workspace_config(base_dir)
+        return if !path
         result = config[config_field_name] || path.to_s
         result = File.expand_path(result, path.to_s)
         if result == path.to_s
@@ -62,6 +72,30 @@ def self.find_v2_root_dir(base_dir, config_field_name)
         resolved
     end
 
+    # Filters in the given list of paths the paths that are within a workspace
+    def self.filter_out_paths_in_workspace(paths)
+        known_valid_dirs = Set.new
+        known_workspace_dirs = Array.new
+        paths.find_all do |p|
+            if !File.directory?(p)
+                true
+            elsif known_workspace_dirs.any? { |ws_root| "#{p}/".start_with?(ws_root) }
+                false
+            else
+                ws_path, ws_config = find_v2_workspace_config(p)
+                if ws_path
+                    known_workspace_dirs << "#{ws_path}/"
+                    if ws_dir = ws_config['workspace']
+                        known_workspace_dirs << "#{ws_dir}/"
+                    end
+                    false
+                else
+                    true
+                end
+            end
+        end
+    end
+
     # {#find_workspace_dir} for v2 workspaces
     def self.find_v2_workspace_dir(base_dir = default_find_base_dir)
         find_v2_root_dir(base_dir, 'workspace')

data/lib/autoproj/installation_manifest.rb

@@ -2,31 +2,35 @@ module Autoproj
     # Manifest of installed packages imported from another autoproj installation
     class InstallationManifest
         Package = Struct.new :name, :srcdir, :prefix, :builddir, :dependencies
+        PackageSet = Struct.new :name, :raw_local_dir, :user_local_dir
 
         attr_reader :path
         attr_reader :packages
+        attr_reader :package_sets
         def initialize(path)
             @path = path
             @packages = Hash.new
+            @package_sets = Hash.new
         end
 
         def exist?
             File.exist?(path)
         end
 
-        # Returns information about a given package
-        #
-        # @return [Package]
-        def [](name)
-            packages[name]
+        def add_package(pkg)
+            packages[pkg.name] = pkg
         end
 
-        def []=(name, pkg)
-            packages[name] = pkg
+        def add_package_set(pkg_set)
+            package_sets[pkg_set.name] = pkg_set
         end
 
-        def delete_if
-            packages.delete_if { |_, pkg| yield(pkg) }
+        def each_package_set(&block)
+            package_sets.each_value(&block)
+        end
+            
+        def each_package(&block)
+            packages.each_value(&block)
         end
             
         def load
@@ -41,10 +45,16 @@ def load
                 save(path)
             else
                 raw.each do |entry|
-                    pkg = Package.new(
-                        entry['name'], entry['srcdir'], entry['prefix'],
-                        entry['builddir'], entry['dependencies'])
-                    packages[pkg.name] = pkg
+                    if entry['package_set']
+                        pkg_set = PackageSet.new(
+                            entry['package_set'], entry['raw_local_dir'], entry['user_local_dir'])
+                        package_sets[pkg_set.name] = pkg_set
+                    else
+                        pkg = Package.new(
+                            entry['name'], entry['srcdir'], entry['prefix'],
+                            entry['builddir'], entry['dependencies'])
+                        packages[pkg.name] = pkg
+                    end
                 end
             end
         end
@@ -52,35 +62,34 @@ def load
         # Save the installation manifest
         def save(path = self.path)
             File.open(path, 'w') do |io|
-                marshalled_packages = packages.values.map do |v|
+                marshalled_package_sets = each_package_set.map do |v|
+                    Hash['package_set' => v.name,
+                         'raw_local_dir' => v.raw_local_dir,
+                         'user_local_dir' => v.user_local_dir]
+                end
+                marshalled_packages = each_package.map do |v|
+                    v = v.autobuild
                     Hash['name' => v.name,
                          'srcdir' => v.srcdir,
                          'builddir' => (v.builddir if v.respond_to?(:builddir)),
                          'prefix' => v.prefix,
                          'dependencies' => v.dependencies]
                 end
-                YAML.dump(marshalled_packages, io)
+                YAML.dump(marshalled_package_sets + marshalled_packages, io)
             end
         end
 
-        # Enumerate the packages from this manifest
-        #
-        # @yieldparam [Package]
-        def each(&block)
-            packages.each_value(&block)
-        end
-
         # Returns the default Autoproj installation manifest path for a given
         # autoproj workspace root
         #
         # @param [String] root_dir
         # @return [String]
-        def self.path_for_root(root_dir)
+        def self.path_for_workspace_root(root_dir)
             File.join(root_dir, '.autoproj', 'installation-manifest')
         end
 
-        def self.from_root(root_dir)
-            path = path_for_root(root_dir)
+        def self.from_workspace_root(root_dir)
+            path = path_for_workspace_root(root_dir)
             manifest = InstallationManifest.new(path)
             if !manifest.exist?
                 raise ConfigError.new, "no #{path} file found. You should probably rerun autoproj envsh in that folder first"

data/lib/autoproj/local_package_set.rb

@@ -0,0 +1,86 @@
+module Autoproj
+    # Specialization of the PackageSet class to handle the "master" package set
+    # in autoproj/
+    class LocalPackageSet < PackageSet
+        def initialize(ws, local_dir: ws.config_dir)
+            super(ws, VCSDefinition.none, name: 'main configuration', raw_local_dir: local_dir)
+            @local_dir = local_dir
+        end
+
+        def vcs
+            ws.manifest.vcs
+        end
+
+        def main?
+            true
+        end
+
+        def local?
+            true
+        end
+
+        def local_dir
+            raw_local_dir
+        end
+
+        def manifest_path
+            manifest.file
+        end
+
+        def overrides_file_path
+            if d = local_dir
+                File.join(d, "overrides.yml")
+            end
+        end
+
+        def source_file
+            overrides_file_path
+        end
+
+        # Reimplemented from {PackageSet#load_description_file} to remove the
+        # name validation
+        def load_description_file
+            source_definition = raw_description_file
+            parse_source_definition(source_definition)
+        end
+
+        # Load the files in overrides.d in addition to the overrides: field in
+        # the yaml file
+        def load_overrides(source_definition)
+            files = Dir.glob(File.join( ws.overrides_dir, "*.yml" ) ).sort
+            overrides = files.map do |file|
+                source_data = Autoproj.in_file(file, Autoproj::YAML_LOAD_ERROR) do
+                    YAML.load(File.read(file)) || Array.new
+                end
+                source_data =
+                    if source_data.respond_to?(:to_ary)
+                        source_data
+                    else source_data['overrides'] || Hash.new
+                    end
+                [file, source_data]
+            end
+            overrides + super
+        end
+
+        def raw_description_file
+            description = Hash[
+                'imports' => Array.new,
+                'version_control' => Array.new,
+                'overrides' => Array.new]
+            if File.file?(overrides_file_path)
+                overrides_data = Autoproj.in_file(overrides_file_path, Autoproj::YAML_LOAD_ERROR) do
+                    YAML.load(File.read(overrides_file_path)) || Hash.new
+                end
+                description = description.merge(overrides_data)
+            end
+
+            manifest_data = Autoproj.in_file(manifest_path, Autoproj::YAML_LOAD_ERROR) do
+                YAML.load(File.read(manifest_path)) || Hash.new
+            end
+            description['imports'] = description['imports'].
+                concat(manifest_data['package_sets'] || Array.new)
+            description['name'] = name
+            description
+        end
+    end
+end

data/lib/autoproj/manifest.rb

@@ -2,7 +2,6 @@
 require 'csv'
 require 'utilrb/kernel/options'
 require 'set'
-require 'rexml/document'
 
 require 'win32/dir' if RbConfig::CONFIG["host_os"] =~%r!(msdos|mswin|djgpp|mingw|[Ww]indows)! 
 
@@ -26,6 +25,29 @@ def self.load(file)
             manifest
 	end
 
+        # A normalized version of the layout as represented in the manifest file
+        #
+        # It is a mapping from a selection name into the layout level it is
+        # defined in. For instance:
+        #
+        #     layout:
+        #     - subdir:
+        #       - pkg/in/subdir
+        #     - pkg/in/root
+        #
+        # Would be normalized as
+        #
+        #     'pkg/in/subdir' => '/subdir/',
+        #     'pkg/in/root' => '/'
+        #
+        # Note that these are only strings. There is no normalization against
+        # package names or metapackages.
+        #
+        # This is computed by {#compute_normalized_layout}
+        #
+        # @return [Hash]
+        attr_reader :normalized_layout
+
         # Load the manifest data contained in +file+
         def load(file)
             if !File.exist?(file)
@@ -37,21 +59,76 @@ def load(file)
             end
 
             @file = file
+            initialize_from_hash(data)
+        end
+
+        # @api private
+        #
+        # Initialize the manifest from a hash, as loaded from a manifest file
+        def initialize_from_hash(data)
             @data = data
             @ignored_packages |= (data['ignored_packages'] || Set.new).to_set
+            @ignored_packages |= (data['ignore_packages'] || Set.new).to_set
+            invalidate_ignored_package_names
             @manifest_exclusions |= (data['exclude_packages'] || Set.new).to_set
 
-            @normalized_layout = Hash.new
+            normalized_layout = Hash.new
             compute_normalized_layout(
                 normalized_layout,
                 '/',
                 data['layout'] || Hash.new)
+            @normalized_layout = normalized_layout
+            @has_layout = !!data['layout']
 
             if data['constants']
                 @constant_definitions = Autoproj.resolve_constant_definitions(data['constants'])
             end
         end
 
+        # Make an empty layout
+        #
+        # Unless the default layout (that you can get with {#remove_layout}), this
+        # means that no package is selected by default
+        def clear_layout
+            @has_layout = true
+            normalized_layout.clear
+        end
+
+        # Remove the layout
+        #
+        # Unlike {#clear_layout}, this means that all defined source packages
+        # will be selected by default
+        def remove_layout
+            @has_layout = false
+            normalized_layout.clear
+        end
+
+        # Add a package into the layout
+        def add_package_to_layout(package)
+            package_name = validate_package_name_argument(package)
+            @has_layout = true
+            normalized_layout[package_name] = '/'
+        end
+
+        # Add a package into the layout
+        def add_package_set_to_layout(package_set)
+            validate_package_set_in_self(package_set)
+            add_metapackage_to_layout(package_set.metapackage)
+        end
+
+        # Add a metapackage into the layout
+        def add_metapackage_to_layout(metapackage)
+            validate_metapackage_in_self(metapackage)
+            @has_layout = true
+            normalized_layout[metapackage.name] = '/'
+        end
+
+        # Add a constant definition, used when resolving $CONSTANT in loaded
+        # files
+        def add_constant_definition(key, value)
+            constant_definitions[key] = value
+        end
+
         # The manifest data as a Hash
         attr_reader :data
 
@@ -59,9 +136,6 @@ def load(file)
         # [Autobuild::Package, package_set, file] tuple
         attr_reader :packages
 
-        # A mapping from package names into PackageManifest objects
-        attr_reader :package_manifests
-
         # The path to the manifest file that has been loaded
         attr_reader :file
 
@@ -80,15 +154,6 @@ def accept_unavailable_osdeps?; !!@accept_unavailable_osdeps end
         # Sets {#accept_unavailable_osdeps?}
         def accept_unavailable_osdeps=(flag); @accept_unavailable_osdeps = flag end
 
-        # True if osdeps should be handled in update and build, or left to the
-        # osdeps command
-        def auto_osdeps?
-            if data.has_key?('auto_osdeps')
-                !!data['auto_osdeps']
-            else true
-            end
-        end
-
         attr_reader :constant_definitions
 
         attr_reader :metapackages
@@ -101,17 +166,24 @@ def auto_osdeps?
         # The definition of all OS packages available on this installation
         attr_reader :os_package_resolver
 
-	def initialize
+        # Whether there is a layout specified
+        #
+        # This is used to disambiguate between an empty layout (which would
+        # build nothing) and no layout at all
+        attr_predicate :has_layout?
+
+        def initialize(ws, os_package_resolver: OSPackageResolver.new)
+            @ws = ws
             @file = nil
 	    @data = Hash.new
+            @has_layout = false
+            @normalized_layout = Hash.new
             @packages = Hash.new
-            @package_manifests = Hash.new
             @package_sets = []
-            @os_package_resolver = OSPackageResolver.new
+            @os_package_resolver = os_package_resolver
 
             @automatic_exclusions = Hash.new
             @constants_definitions = Hash.new
-            @disabled_imports = Set.new
             @moved_packages = Hash.new
             @osdeps_overrides = Hash.new
             @metapackages = Hash.new
@@ -122,75 +194,172 @@ def initialize
             @accept_unavailable_osdeps = false
 
             @constant_definitions = Hash.new
-            @package_sets << LocalPackageSet.new(self)
+            @package_sets << LocalPackageSet.new(ws)
 	end
 
+        # @api private
+        #
+        # Validate that the given metapackage object is defined in self
+        def validate_metapackage_in_self(metapackage)
+            if find_metapackage(metapackage.name) != metapackage
+                raise UnregisteredPackage, "#{metapackage.name} is not registered on #{self}"
+            end
+        end
+
+        # @api private
+        #
+        # Validate that the given package object is defined in self
+        def validate_package_in_self(package)
+            if !package.respond_to?(:autobuild)
+                raise ArgumentError, "expected a PackageDefinition object but got an Autobuild package"
+            elsif find_package_definition(package.name) != package
+                raise UnregisteredPackage, "#{package.name} is not registered on #{self}"
+            end
+        end
+
+        # @api private
+        #
+        # Massage an argument that should be interpreted as a package name
+        def validate_package_name_argument(package, require_existing: true)
+            if package.respond_to?(:name)
+                validate_package_in_self(package)
+                package.name
+            else
+                package = package.to_str
+                if require_existing && !has_package?(package)
+                    raise PackageNotFound, "no package named #{package} in #{self}"
+                end
+                package
+            end
+        end
+
+        # @api private
+        #
+        # Validate that the given package object is defined in self
+        def validate_package_set_in_self(package_set)
+            if find_package_set(package.name) != package_set
+                raise UnregisteredPackageSet, "#{package_set.name} is not registered on #{self}"
+            end
+        end
 
         # Call this method to ignore a specific package. It must not be used in
         # init.rb, as the manifest is not yet loaded then
-        def ignore_package(package_name)
-            @ignored_packages << package_name.to_str
+        def ignore_package(package)
+            invalidate_ignored_package_names
+            @ignored_packages << validate_package_name_argument(package, require_existing: false)
         end
 
         # True if the given package should not be built, with the packages that
         # depend on him have this dependency met.
         #
         # This is useful if the packages are already installed on this system.
-        def ignored?(package_name)
-            ignored_packages.any? do |l|
-                if package_name == l
-                    true
-                elsif (pkg_set = metapackages[l]) && pkg_set.include?(package_name)
-                    true
-                else
-                    false
-                end
+        def ignored?(package)
+            package_name = validate_package_name_argument(package)
+            cache_ignored_package_names.include?(package_name)
+        end
+
+        # @api private
+        #
+        # The list of packages that are ignored
+        #
+        # Do not use directly, use {#ignored?} instead
+        def cache_ignored_package_names
+            if @ignored_package_names
+                return @ignored_package_names
             end
+
+            @ignored_package_names = each_package_definition.find_all do |pkg|
+                ignored_packages.any? do |l|
+                    (pkg.name == l) || 
+                        ((pkg_set = metapackages[l]) && pkg_set.include?(pkg))
+                end
+            end.map(&:name).to_set
+        end
+
+        # @api private
+        #
+        # Invalidate the cache computed by {#cache_ignored_package_names}
+        def invalidate_ignored_package_names
+            @ignored_package_names = nil
         end
 
         # Enumerates the package names of all ignored packages
-        def each_excluded_package
-            each_autobuild_package do |pkg|
-                yield(pkg) if excluded?(pkg.name)
+        #
+        # @yieldparam [Autobuild::Package]
+        def each_ignored_package
+            return enum_for(__method__) if !block_given?
+            cache_ignored_package_names.each do |pkg_name|
+                yield(find_autobuild_package(pkg_name))
+            end
+        end
+
+        # Removes all registered ignored packages
+        def clear_ignored
+            invalidate_ignored_package_names
+            ignored_packages.clear
+        end
+
+        # True if the given package should not be built and its dependencies
+        # should be considered as met.
+        #
+        # This is useful to avoid building packages that are of no use for the
+        # user.
+        def excluded?(package_name)
+            package_name = validate_package_name_argument(package_name)
+
+            if excluded_in_manifest?(package_name)
+                true
+            elsif automatic_exclusions.any? { |pkg_name, | pkg_name == package_name }
+                true
+            else
+                false
             end
         end
 
         # Enumerates the package names of all ignored packages
-        def each_ignored_package
+        def each_excluded_package
+            return enum_for(__method__) if !block_given?
             each_autobuild_package do |pkg|
-                yield(pkg) if ignored?(pkg.name)
+                yield(pkg) if excluded?(pkg.name)
             end
         end
 
         # Removes all registered exclusions
         def clear_exclusions
             automatic_exclusions.clear
-            data['exclude_packages'].clear
-        end
-
-        # Removes all registered ignored packages
-        def clear_ignored
-            ignored_packages.clear
+            manifest_exclusions.clear
         end
 
         # The set of package names that are listed in the excluded_packages
         # section of the manifest
-        def manifest_exclusions
-            @manifest_exclusions
-        end
+        attr_reader :manifest_exclusions
 
-        # A package_name => reason map of the exclusions added with #add_exclusion.
+        # A package_name => reason map of the exclusions added with {#exclude_package}
         # Exclusions listed in the manifest file are returned by #manifest_exclusions
         attr_reader :automatic_exclusions
 
+        # @deprecated use {#exclude_package} instead
+        def add_exclusion(package_name, reason)
+            Autoproj.warn_deprecated __method__, "use #exclude_package instead"
+            exclude_package(package_name, reason)
+        end
+
         # Exclude +package_name+ from the build. +reason+ is a string describing
         # why the package is to be excluded.
-        def add_exclusion(package_name, reason)
-            automatic_exclusions[package_name] = reason
+        def exclude_package(package_name, reason)
+            package = validate_package_name_argument(package_name, require_existing: false)
+            if meta = find_metapackage(package)
+                meta.each_package do |pkg|
+                    automatic_exclusions[pkg.name] = "#{meta.name} is an excluded metapackage, and it includes #{pkg.name}: #{reason}"
+                end
+            else
+                automatic_exclusions[package] = reason
+            end
         end
 
         # Tests whether the given package is excluded in the manifest
         def excluded_in_manifest?(package_name)
+            package_name = validate_package_name_argument(package_name)
             manifest_exclusions.any? do |matcher|
                 if (pkg_set = metapackages[matcher]) && pkg_set.include?(package_name)
                     true
@@ -207,11 +376,15 @@ def excluded_in_manifest?(package_name)
         # exclude_packages section of the manifest, or because they are
         # disabled on this particular operating system.
         def exclusion_reason(package_name)
-            if excluded_in_manifest?(package_name)
-                "#{package_name} is listed in the exclude_packages section of the manifest"
-            else
-                automatic_exclusions[package_name]
+            package_name = validate_package_name_argument(package_name)
+            manifest_exclusions.any? do |matcher|
+                if (pkg_set = metapackages[matcher]) && pkg_set.include?(package_name)
+                    return "#{pkg_set.name} is a metapackage listed in the exclude_packages section of the manifest, and it includes #{package_name}"
+                elsif Regexp.new(matcher) === package_name
+                    return "#{package_name} is listed in the exclude_packages section of the manifest"
+                end
             end
+            automatic_exclusions[package_name]
         end
 
         # Returns true if the given package name has been explicitely added to
@@ -224,65 +397,9 @@ def explicitely_selected_in_layout?(package_name)
             normalized_layout.has_key?(package_name)
         end
 
-        # True if the given package should not be built and its dependencies
-        # should be considered as met.
-        #
-        # This is useful to avoid building packages that are of no use for the
-        # user.
-        def excluded?(package_name)
-            package_name = package_name.to_str
-
-            if excluded_in_manifest?(package_name)
-                true
-            elsif automatic_exclusions.any? { |pkg_name, | pkg_name == package_name }
-                true
-            else
-                false
-            end
-        end
-
-        # Lists the autobuild files that are in the package sets we know of
-	def each_autobuild_file(source_name = nil, &block)
-            if !block_given?
-                return enum_for(__method__, source_name)
-            end
-
-            # This looks very inefficient, but it is because source names are
-            # contained in source.yml and we must therefore load that file to
-            # check the package set name ...
-            #
-            # And honestly I don't think someone will have 20 000 package sets
-            done_something = false
-            each_package_set do |source| 
-                next if source_name && source.name != source_name
-                done_something = true
-
-                Dir.glob(File.join(source.local_dir, "*.autobuild")).sort.each do |file|
-                    yield(source, file)
-                end
-            end
-
-            if source_name && !done_something
-                raise ConfigError.new(file), "in #{file}: package set '#{source_name}' does not exist"
-            end
-	end
-
-        # Yields each osdeps definition files that are present in our sources
-        def each_osdeps_file
-            if !block_given?
-                return enum_for(__method__)
-            end
-
-            each_package_set do |source|
-		Dir.glob(File.join(source.local_dir, "*.osdeps")).each do |file|
-		    yield(source, file)
-		end
-            end
-        end
-
         # True if some of the sources are remote sources
-        def has_remote_sources?
-            each_remote_source(false).any? { true }
+        def has_remote_package_sets?
+            each_remote_package_set.any? { true }
         end
 
         # Like #each_package_set, but filters out local package sets
@@ -296,25 +413,6 @@ def each_remote_package_set
             end
         end
 
-        # Enumerates the version control information for all the package sets
-        # listed directly in the manifest file
-        #
-        # @yieldparam [VCSDefinition] vcs the package set VCS object
-        # @yieldparam [Hash] options additional import options
-        # @options options [Boolean] :auto_update (true) if true, the set of
-        #   package sets declared as imports in package set's source.yml file
-        #   will be auto-imported by autoproj, otherwise they won't
-        # @return [nil]
-        def each_raw_explicit_package_set
-            return enum_for(__method__) if !block_given?
-            (data['package_sets'] || []).map do |spec|
-                Autoproj.in_file(self.file) do
-                    yield(*PackageSet.resolve_definition(self, spec))
-                end
-            end
-            nil
-        end
-
         # Lists all package sets defined in this manifest, including the package
         # sets that are auto-imported
         #
@@ -326,20 +424,16 @@ def each_package_set(&block)
             @package_sets.each(&block)
         end
 
-        # Load the package set information
-        def 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
-        def local_package_set
-            each_package_set.find { |s| s.kind_of?(LocalPackageSet) }
+        # Reset the list of package sets
+        def reset_package_sets
+            @package_sets.clear
         end
 
         # Registers a new package set
+        #
+        # @param [PackageSet] pkg_set the package set object
         def register_package_set(pkg_set)
+            invalidate_ignored_package_names
             metapackage(pkg_set.name)
             metapackage("#{pkg_set.name}.all")
             @package_sets << pkg_set
@@ -353,6 +447,7 @@ def register_package_set(pkg_set)
         # @param [String] file the file in which the package is defined
         # @return [PackageDefinition]
         def register_package(package, block = nil, package_set = main_package_set, file = nil)
+            invalidate_ignored_package_names
             pkg = PackageDefinition.new(package, package_set, file)
             if block
                 pkg.add_setup_block(block)
@@ -363,52 +458,43 @@ def register_package(package, block = nil, package_set = main_package_set, file
             pkg
         end
 
-        # Returns the package set that defines a package
+        # The autoproj description of a package by its name
         #
-        # @param [String] package_name the package name
-        # @return [PackageSet] the package set
-        # @raise ArgumentError if package_name is not the name of a known
-        #   package
-        def definition_package_set(package_name)
-            if pkg_def = @packages[package_name]
-                pkg_def.package_set
-            else raise ArgumentError, "no package called #{package_name}"
-            end
+        # @param [String,#name] name the package name
+        # @return [PackageDefinition,nil]
+        def find_package_definition(name)
+            packages[validate_package_name_argument(name, require_existing: false)]
         end
 
-        # @deprecated use {definition_package_set} instead
-        def definition_source(package_name)
-            definition_package_set(package_name)
+        # @deprecated use {#find_package_definition}(pkg_name).package_set
+        # instead
+        def definition_source(name)
+            Autoproj.warn_deprecated __method__, "use #package_definition_by_name(name).package_set instead"
+            package_definition_by_name(name).package_set
         end
 
-        # Returns the full path to the file that defines a package
-        #
-        # @param [String] package_name the package name
-        # @return [String] the package set
-        # @raise ArgumentError if package_name is not the name of a known
-        #   package
-        def definition_file(package_name)
-            if pkg_def = @packages[package_name]
-                pkg_def.file
-            else raise ArgumentError, "no package called #{package_name}"
-            end
+        # @deprecated use {#find_package_definition}(pkg_name).package_set
+        # instead
+        def definition_package_set(name)
+            Autoproj.warn_deprecated __method__, "use #package_definition_by_name(name).package_set instead"
+            package_definition_by_name(name).package_set
         end
 
         # @deprecated use {#find_package_definition} instead
-        def find_package(name)
+        def package(name)
+            Autoproj.warn_deprecated "Manifest#package is deprecated, use #package_definition_by_name instead"
             find_package_definition(name)
         end
 
-        # The autoproj description of a package by its name
+        # Resolve a package definition by name
         #
-        # @param [String,#name] name the package name
-        # @return [PackageDefinition,nil]
-        def find_package_definition(name)
-            if name.respond_to?(:name)
-                name = name.name
+        # Unlike {#find_package_definition}, raise if the package does not exist
+        def package_definition_by_name(name)
+            if pkg = find_package_definition(name)
+                pkg
+            else
+                raise ArgumentError, "no package defined named '#{name}'"
             end
-
-            packages[name.to_str]
         end
 
         # The autobuild description of a package by its name
@@ -416,23 +502,11 @@ def find_package_definition(name)
         # @param [String,#name] name the package name
         # @return [Autobuild::Package,nil]
         def find_autobuild_package(name)
-            if pkg = find_package(name)
+            if pkg = find_package_definition(name)
                 pkg.autobuild
             end
         end
 
-        # @deprecated use {#find_package} instead
-        def package(name)
-            find_package(name)
-        end
-
-        # @deprecated use {each_autobuild_package} instead
-        def each_package(&block)
-            Autoproj.warn "Manifest#each_package is deprecated, use each_autobuild_package instead"
-            Autoproj.warn "  " + caller.join("\n  ")
-            each_autobuild_package(&block)
-        end
-
         # Lists all defined packages
         #
         # @yieldparam [PackageDefinition] pkg
@@ -449,58 +523,41 @@ def each_autobuild_package
             each_package_definition { |pkg| yield(pkg.autobuild) }
         end
 
-        # @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)
-            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
-
-        # Compute the VCS definition for a given package
+        # @overload importer_definition_for(package, mainline: nil, require_existing: true, package_set: nil)
         #
-        # @param [String] package_name the name of the package to be resolved
-        # @param [PackageSet,nil] package_source the package set that defines the
-        #   given package, defaults to the package's definition source (as
-        #   returned by {definition_package_set}) if not given
+        # @param [PackageDefinition] package the name of the package to be resolved
+        # @param [PackageSet,nil] mainline the reference package set for which
+        #   we want to compute the importer definition. Pass package.package_set
+        #   if you want to avoid applying any override
         # @return [VCSDefinition] the VCS definition object
-        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
+        def importer_definition_for(package, _package_set = nil, mainline: nil, require_existing: true, package_set: nil)
+            if _package_set
+                Autoproj.warn_deprecated "calling #importer_definition_for with the package set as second argument is deprecated, use the package_set: keyword argument instead"
+                require_existing = false
+            end
+            package_name = validate_package_name_argument(package, require_existing: require_existing)
+            package_set = _package_set || package_set || package.package_set
+            mainline = if mainline == true
+                           package_set
+                       else mainline
+                       end
 
-            vcs = package_set.importer_definition_for(package_name)
-            return if !vcs
+            # package_name is already validated, do not re-validate
+            vcs = package_set.importer_definition_for(package_name, require_existing: false)
 
-            # 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_set
-                set = package_sets.shift
-                return vcs if set == mainline
+            index = package_sets.find_index(package_set)
+            if !index
+                raise RuntimeError, "found inconsistency: package #{package_name} is not in a package set of #{self}"
+            end
+
+            if package_sets[0, index + 1].include?(mainline)
+                return vcs
             end
-            set = package_sets.shift
-            return vcs if set == mainline
 
             # Then apply the overrides
-            package_sets.inject(vcs) do |updated_vcs, pkg_set|
-                updated_vcs = pkg_set.overrides_for(package_name, updated_vcs)
+            package_sets[(index + 1)..-1].inject(vcs) do |updated_vcs, pkg_set|
+                updated_vcs = pkg_set.overrides_for(package_name, updated_vcs, require_existing: false)
                 return updated_vcs if pkg_set == mainline
                 updated_vcs
             end
@@ -522,45 +579,59 @@ def importer_definition_for(package_name, package_set = definition_package_set(p
         #  * 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(options = Hash.new)
+        def load_importers(mainline: nil)
             packages.each_value do |pkg|
-                vcs = importer_definition_for(pkg.autobuild.name, pkg.package_set, options) ||
-                    pkg.package_set.default_importer
-
+                package_mainline =
+                    if mainline == true
+                        pkg.package_set
+                    else mainline
+                    end
+                vcs = importer_definition_for(pkg, mainline: package_mainline)
 
-                if vcs
-                    pkg.vcs = vcs
-                    pkg.autobuild.importer = vcs.create_autobuild_importer
-                else
-                    raise ConfigError.new, "source #{pkg.package_set.name} defines #{pkg.autobuild.name}, but does not provide a version control definition for it"
+                if vcs.none?
+                    if pkg.package_set.importer_definition_for(pkg).none?
+                        if (pkg.package_set != main_package_set) || !File.exist?(pkg.autobuild.srcdir)
+                            raise ConfigError.new, "package set #{pkg.package_set.name} defines the package '#{pkg.name}', but does not provide a version control definition for it"
+                        end
+                    end
                 end
+
+                pkg.vcs = vcs
+                pkg.autobuild.importer = vcs.create_autobuild_importer
             end
         end
 
         # Checks if there is a package with a given name
         #
-        # @param [String] name
+        # @param [String] name the name of a source or osdep package
         # @return [Boolean]
         def has_package?(name)
-            packages.has_key?(name)
+            packages.has_key?(name) || os_package_resolver.include?(name)
         end
 
-        # Returns true if +name+ is the name of a package set known to this
-        # autoproj installation
+        # Checks if there is a package set with a given name
         def has_package_set?(name)
+            !!find_package_set(name)
+        end
+
+        # Returns a package set from its name
+        def find_package_set(name)
             each_package_set.find { |set| set.name == name }
         end
 
-        # Returns the PackageSet object for the given package set, or raises
-        # ArgumentError if none exists with that name
+        # The PackageSet object for the given package set
+        #
+        # @return [PackageSet] the package set
+        # @raise [ArgumentError] if none exists with that name
         def package_set(name)
-            set = each_package_set.find { |set| set.name == name }
-            if !set
+            if set = find_package_set(name)
+                set
+            else
                 raise ArgumentError, "no package set called #{name} exists"
             end
-            set
         end
 
+        # The root package set, which represents the workspace itself
         def main_package_set
             each_package_set.find(&:main?)
         end
@@ -572,7 +643,7 @@ def main_package_set
         # package set).
         #
         # @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
+        #   (type, package_name) pairs where type is either :package or :osdeps and
         #   package_name the corresponding package name
         # @raise [PackageNotFound] if the given package name cannot be resolved
         #   into a package. If {#accept_unavailable_osdeps?} is false (the
@@ -599,27 +670,6 @@ def resolve_package_name(name)
             result
         end
 
-        # Resolves all the source package dependencies for given packages
-        #
-        # @param [Set<String>] the set of package names of which we want to
-        #   discover the dependencies
-        # @return [Set<String>] the set of all package names that the packages designed
-        #   by root_names depend on
-        def resolve_packages_dependencies(*root_names)
-            result = Set.new
-            queue = root_names.dup
-            while pkg_name = queue.shift
-                next if result.include?(pkg_name)
-                result << pkg_name
-
-                pkg = find_autobuild_package(pkg_name)
-                pkg.dependencies.each do |dep_name|
-                    queue << dep_name
-                end
-            end
-            result
-        end
-
         # @api private
         #
         # Resolves a package name, where +name+ cannot be resolved as a
@@ -629,7 +679,7 @@ def resolve_packages_dependencies(*root_names)
         # directly
         #
         # @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
+        #   (type, package_name) pairs where type is either :package or :osdeps and
         #   package_name the corresponding package name
         def resolve_single_package_name(name)
             resolve_package_name_as_osdep(name)
@@ -695,28 +745,11 @@ def resolve_package_name_as_osdep(name)
             elsif osdeps_available || accept_unavailable_osdeps?
                 return [[:osdeps, name]]
             elsif osdeps_availability == OSPackageResolver::WRONG_OS
-                raise PackageNotFound, "#{name} is an osdep, but it is not available for this operating system"
+                raise PackageNotFound, "#{name} is an osdep, but it is not available for this operating system (#{os_package_resolver.operating_system})"
             elsif osdeps_availability == OSPackageResolver::UNKNOWN_OS
                 raise PackageNotFound, "#{name} is an osdep, but the local operating system is unavailable"
             elsif osdeps_availability == OSPackageResolver::NONEXISTENT
-                raise PackageNotFound, "#{name} is an osdep, but it is explicitely marked as 'nonexistent' for this operating system"
-            end
-        end
-
-        # +name+ can either be the name of a source or the name of a package. In
-        # 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 find_autobuild_package(name)
-                [name]
-            else
-                pkg_set = find_metapackage(name)
-                if !pkg_set
-                    raise UnknownPackage.new(name), "#{name} is neither a package nor a package set name. Packages in autoproj must be declared in an autobuild file."
-                end
-                pkg_set.each_package.
-                    map(&:name).
-                    find_all { |pkg_name| !os_package_resolver.has?(pkg_name) }
+                raise PackageNotFound, "#{name} is an osdep, but it is explicitely marked as 'nonexistent' for this operating system (#{os_package_resolver.operating_system})"
             end
         end
 
@@ -743,14 +776,19 @@ def find_metapackage(name)
         #
         def metapackage(name, *packages, &block)
             meta = (@metapackages[name.to_s] ||= Metapackage.new(name))
-            packages.each do |pkg|
-                if pkg.respond_to?(:to_str)
-                    package_names = resolve_package_set(pkg)
-                    package_names.each do |pkg_name|
-                        meta.add(find_autobuild_package(pkg_name))
+            packages.each do |arg|
+                if !arg.respond_to?(:to_str)
+                    meta.add(arg)
+                elsif pkg = find_autobuild_package(arg)
+                    meta.add(pkg)
+                elsif pkg_set = find_metapackage(arg)
+                    pkg_set.each_package do |pkg_in_set|
+                        meta.add(pkg_in_set)
                     end
+                elsif os_package_resolver.has?(arg)
+                    raise ArgumentError, "cannot specify the osdep #{arg} as an element of a metapackage"
                 else
-                    meta.add(pkg)
+                    raise PackageNotFound, "cannot find a package called #{arg}"
                 end
             end
 
@@ -771,7 +809,7 @@ def each_metapackage(&block)
         # Returns the packages selected in this manifest's layout
         #
         # @return [PackageSelection]
-        def layout_packages(validate)
+        def layout_packages(validate = true)
             result = PackageSelection.new
             Autoproj.in_file(self.file) do
                 normalized_layout.each_key do |pkg_or_set|
@@ -780,10 +818,11 @@ def layout_packages(validate)
                                    meta.weak_dependencies?
                                end
 
-
-                        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
+                        resolve_package_name(pkg_or_set).each do |pkg_type, pkg_name|
+                            result.select(pkg_or_set, pkg_name, osdep: (pkg_type == :osdeps), weak: weak)
+                        end
+                    rescue PackageNotFound => e
+                        raise e, "#{pkg_or_set}, which is selected in the layout, is unknown: #{e.message}", e.backtrace
                     end
                 end
             end
@@ -798,37 +837,17 @@ def layout_packages(validate)
             result
         end
 
-        # Enumerates the sublayouts defined in +layout_def+.
-        def each_sublayout(layout_def)
-            layout_def.each do |value|
-                if value.kind_of?(Hash)
-                    name, layout = value.find { true }
-                    yield(name, layout)
-                end
-            end
-        end
-
         # Returns the set of package names that are explicitely listed in the
         # layout, minus the excluded and ignored ones
         def all_layout_packages(validate = true)
             default_packages(validate)
         end
 
-        # Returns all defined package names, minus the excluded and ignored ones
+        # Returns all defined package names
         def all_package_names
             each_autobuild_package.map(&:name)
         end
 
-        # Returns all the packages that can be built in this installation
-        def all_packages
-            result = Set.new
-            each_package_set do |pkg_set|
-                result |= metapackage(pkg_set.name).packages.map(&:name).to_set
-            end
-            result.to_a.
-                find_all { |pkg_name| !os_package_resolver.has?(pkg_name) }
-        end
-
         # Returns true if +name+ is a valid package and is included in the build
         #
         # If +validate+ is true, the method will raise ArgumentError if the
@@ -837,14 +856,8 @@ def all_packages
         # If it is false, the method will simply return false on non-defined
         # packages 
         def package_enabled?(name, validate = true)
-            if !find_autobuild_package(name) && !os_package_resolver.has?(name)
-                if validate
-                    raise ArgumentError, "package #{name} does not exist"
-                end
-                return false
-            end
-
-            !excluded?(name)
+            Autoproj.warn_deprecated "#package_enabled? and #package_selected? were broken in autoproj v1, and there are usually other ways to get the same effect (as e.g. splitting package sets). Feel free to contact the autoproj developers if you have a use case that demands this functionality. For now, this method returns true for backward compatibility reasons."
+            true
         end
 
         # Returns true if +name+ is a valid package and is neither excluded from
@@ -856,48 +869,68 @@ def package_enabled?(name, validate = true)
         # If it is false, the method will simply return false on non-defined
         # packages 
         def package_selected?(name, validate = true)
-            if package_enabled?(name)
-                !ignored?(name)
+            Autoproj.warn_deprecated "#package_enabled? and #package_selected? were broken in autoproj v1, and there are usually other ways to get the same effect (as e.g. splitting package sets). Feel free to contact the autoproj developers if you have a use case that demands this functionality. For now, this method returns true for backward compatibility reasons."
+            true
+        end
+
+        # Returns the set of source packages that are selected by the layout
+        #
+        # @return [Array<PackageDefinition>]
+        def all_selected_source_packages(validate = true)
+            result = Set.new
+            selection = default_packages(validate)
+
+            root_sources = selection.each_source_package_name.to_set
+            root_sources.each do |pkg_name|
+                find_autobuild_package(pkg_name).all_dependencies(result)
+            end
+            result.merge(root_sources).map do |pkg_name|
+                find_package_definition(pkg_name)
             end
         end
 
         # Returns the set of packages that are selected by the layout
+        #
+        # Unless {#default_packages}, it returns both the selected packages and
+        # the dependencies (resolved recursively)
+        #
+        # @return [Array<String>] a list of source and osdep package names
         def all_selected_packages(validate = true)
             result = Set.new
-            root = default_packages(validate).source_packages.to_set
-            root.each do |pkg_name|
-                find_autobuild_package(pkg_name).all_dependencies(result)
+            selection = default_packages(validate)
+
+            root_sources = selection.each_source_package_name.to_set
+            root_sources.each do |pkg_name|
+                find_autobuild_package(pkg_name).all_dependencies_with_osdeps(result)
             end
-            result | root
+            result | root_sources | selection.each_osdep_package_name.to_set
         end
 
         # Returns the set of packages that should be built if the user does not
         # specify any on the command line
         def default_packages(validate = true)
-            if data['layout']
-                return layout_packages(validate)
+            if has_layout?
+                layout_packages(validate)
             else
                 result = PackageSelection.new
-                # No layout, all packages are selected
-                names = all_packages
-                names.delete_if { |pkg_name| excluded?(pkg_name) || ignored?(pkg_name) }
-                names.each do |pkg_name|
-                    result.select(pkg_name, pkg_name)
+                all_package_names.each do |pkg_name|
+                    package_type, package_name = resolve_single_package_name(pkg_name).first
+                    next if excluded?(package_name) || ignored?(package_name)
+                    result.select(package_name, package_name, osdep: (package_type == :osdeps))
                 end
                 result
             end
         end
 
-        # A mapping from names to layout placement, as found in the layout
-        # section of the manifest
-        attr_reader :normalized_layout
-
+        # @api private
+        #
+        # Compute a layout structure that is normalized
         def compute_normalized_layout(result, layout_level, layout_data)
             layout_data.each do |value|
                 if value.kind_of?(Hash)
                     subname, subdef = value.find { true }
                     if subdef
-                        normalized_layout(result, "#{layout_level}#{subname}/", subdef)
+                        compute_normalized_layout(result, "#{layout_level}#{subname}/", subdef)
                     end
                 else
                     result[value] = layout_level
@@ -906,19 +939,28 @@ def compute_normalized_layout(result, layout_level, layout_data)
             result
         end
 
-        # Returns the package directory for the given package name
+        # Returns the level of the layout into which of a certain package
+        # would be selected
+        #
+        # @return [String]
         def whereis(package_name)
-            Autoproj.in_file(self.file) do
-                set_name = definition_package_set(package_name).name
-                actual_layout = normalized_layout
-                return actual_layout[package_name] || actual_layout[set_name] || '/'
+            package_name = validate_package_name_argument(package_name)
+
+            matches = [package_name]
+            if source_package = find_package_definition(package_name)
+                each_metapackage do |meta|
+                    if meta.include?(source_package)
+                        matches << meta.name
+                    end
+                end
             end
-        end
 
-        def resolve_optional_dependencies
-            packages.each_value do |pkg|
-                pkg.autobuild.resolve_optional_dependencies
+            matches.each do |name|
+                if place = normalized_layout[name]
+                    return place
+                end
             end
+            '/'
         end
 
         # Loads the package's manifest.xml file for the current package
@@ -927,37 +969,31 @@ def resolve_optional_dependencies
         # warning. This will later be changed into an error.
         def load_package_manifest(pkg)
             if pkg.respond_to?(:to_str)
-                pkg = packages.values.
-                    find { |p| p.autobuild.name == pkg }
+                pkg_definition = find_package_definition(pkg)
+                if !pkg_definition
+                    raise ArgumentError, "#{pkg} is not a known package in #{self}"
+                end
+                pkg = pkg_definition
             end
-            package, package_set, file = pkg.autobuild, pkg.package_set, pkg.file
+            package, package_set = pkg.autobuild, pkg.package_set
 
-            if !pkg
-                raise ArgumentError, "package #{pkg} is not defined"
+            # Look for the package's manifest.xml, but fallback to a manifest in
+            # the package set if present
+            manifest_paths = [File.join(package.srcdir, "manifest.xml")]
+            if package_set.local_dir
+                manifest_paths << File.join(package_set.local_dir, "manifests", package.name + ".xml")
             end
-
-            manifest_paths =
-                [File.join(package_set.local_dir, "manifests", package.name + ".xml"), File.join(package.srcdir, "manifest.xml")]
             manifest_path = manifest_paths.find do |path|
-                File.directory?(File.dirname(path)) &&
-                    File.file?(path)
+                File.file?(path)
             end
 
-            manifest =
-                if !manifest_path
-                    if !pkg.autobuild.description
-                        Autoproj.warn "#{package.name} from #{package_set.name} does not have a manifest"
-                        PackageManifest.new(package)
-                    else
-                        pkg.autobuild.description
-                    end
-                else
-                    PackageManifest.load(package, manifest_path)
-                end
-
-            pkg.autobuild.description = manifest
-            package_manifests[package.name] = manifest
+            if manifest_path
+                pkg.autobuild.description = PackageManifest.load(package, manifest_path)
+            elsif pkg.autobuild.description.null?
+                Autoproj.warn "#{package.name} from #{package_set.name} does not have a manifest"
+            end
 
+            manifest = pkg.autobuild.description
             manifest.each_dependency(pkg.modes) do |name, is_optional|
                 begin
                     if is_optional
@@ -965,9 +1001,6 @@ def load_package_manifest(pkg)
                     else
                         package.depends_on name
                     end
-                rescue Autobuild::ConfigException => e
-                    raise ConfigError.new(manifest_path),
-                        "manifest #{manifest_path} of #{package.name} from #{package_set.name} lists '#{name}' as dependency, which is listed in the layout of #{file} but has no autobuild definition", e.backtrace
                 rescue ConfigError => e
                     raise ConfigError.new(manifest_path),
                         "manifest #{manifest_path} of #{package.name} from #{package_set.name} lists '#{name}' as dependency, but it is neither a normal package nor an osdeps package. osdeps reports: #{e.message}", e.backtrace
@@ -976,59 +1009,6 @@ def load_package_manifest(pkg)
             manifest
         end
 
-        # Loads the manifests for all packages known to this project.
-        #
-        # See #load_package_manifest
-        def load_package_manifests(selected_packages)
-            selected_packages.each(&:load_package_manifest)
-        end
-
-        # Disable all automatic imports from the given package set name
-        def disable_imports_from(pkg_set_name)
-            @disabled_imports << pkg_set_name
-        end
-
-        # call-seq:
-        #   list_os_packages(packages) => required_packages, ospkg_to_pkg
-        #
-        # Returns the set of dependencies required by the listed packages.
-        #
-        # +required_packages+ is the set of osdeps names that are required for
-        # +packages+ and +ospkg_to_pkg+ a mapping from the osdeps name to the
-        # set of packages that require this OS package.
-        def list_os_packages(packages)
-            required_os_packages = Set.new
-            package_os_deps = Hash.new { |h, k| h[k] = Array.new }
-            packages.each do |pkg_name|
-                pkg = find_autobuild_package(pkg_name)
-                if !pkg
-                    raise InternalError, "internal error: #{pkg_name} is not a package"
-                end
-
-                pkg.os_packages.each do |osdep_name|
-                    package_os_deps[osdep_name] << pkg_name
-                    required_os_packages << osdep_name
-                end
-            end
-
-            return required_os_packages, package_os_deps
-        end
-
-        def filter_os_packages(required_os_packages, package_os_deps)
-            required_os_packages.find_all do |pkg|
-                if excluded?(pkg)
-                    raise ConfigError.new, "the osdeps package #{pkg} is excluded from the build in #{file}. It is required by #{package_os_deps[pkg].join(", ")}"
-                end
-                if ignored?(pkg)
-                    if Autoproj.verbose
-                        Autoproj.message "ignoring osdeps package #{pkg}"
-                    end
-                    false
-                else true
-                end
-            end
-        end
-
         # The set of overrides added with #add_osdeps_overrides
         attr_reader :osdeps_overrides
 
@@ -1089,38 +1069,30 @@ def update_selection(selection, user_selection_string, name, weak)
         #   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
+        def expand_package_selection(selection, filter: true)
             result = PackageSelection.new
 
-            # First, remove packages that are directly referenced by name or by
-            # 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))
-                candidates.each do |name, weak|
-                    next if name !~ match_pkg_name
-                    update_selection(result, sel, name, true)
-                end
-            end
-
-            pending_selections = Hash.new { |h, k| h[k] = Array.new }
-
-            # Finally, check for partial matches
+            all_selected_packages = self.all_selected_packages.to_set
             all_source_package_names = self.all_package_names
             all_osdeps_package_names = os_package_resolver.all_package_names
             selection.each do |sel|
                 match_pkg_name = Regexp.new(Regexp.quote(sel))
                 all_matches = Array.new
+                each_metapackage do |meta_pkg|
+                    if meta_pkg.name =~ match_pkg_name
+                        all_matches << [meta_pkg.name, meta_pkg.name == sel]
+                    end
+                end
                 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)}")
-                        all_matches << [pkg_name, (pkg_name == sel || pkg.srcdir == sel)]
+                    if pkg.name =~ match_pkg_name
+                        all_matches << [pkg.name, pkg.name == sel]
+                    elsif "#{sel}/".start_with?("#{pkg.srcdir}/")
+                        all_matches << [pkg.name, true]
+                    elsif pkg.respond_to?(:builddir) && "#{sel}/".start_with?("#{pkg.builddir}/")
+                        all_matches << [pkg.name, true]
+                    elsif pkg.srcdir.start_with?(sel) && all_selected_packages.include?(pkg.name)
+                        all_matches << [pkg.name, false]
                     end
                 end
                 all_osdeps_package_names.each do |pkg_name|
@@ -1129,34 +1101,28 @@ def expand_package_selection(selection, options = Hash.new)
                     end
                 end
 
-                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_selected_packages.include?(pkg_name) && !exact_match
-                        pending_selections[sel] << pkg_name
-                    else
+                exact_matches, partial_matches =
+                    all_matches.partition { |_, exact_match| exact_match }
+                selected_partial_matches, not_selected_partial_matches =
+                    partial_matches.partition { |pkg_name, _| all_selected_packages.include?(pkg_name) }
+                if result.has_match_for?(sel)
+                    not_selected_partial_matches.clear
+                end
+
+                matches = [exact_matches, selected_partial_matches, not_selected_partial_matches].
+                    find { |m| !m.empty? }
+                if matches
+                    matches.each do |pkg_name, _|
                         update_selection(result, sel, pkg_name, true)
                     end
                 end
             end
 
-            if options[:filter]
+            if filter
                 result.filter_excluded_and_ignored_packages(self)
             end
 
             nonresolved = selection - result.matches.keys
-            nonresolved.delete_if do |sel|
-                if pending = pending_selections.fetch(sel, nil)
-                    pending.each do |name|
-                        update_selection(result, sel, name, true)
-                    end
-                    true
-                end
-            end
-
             return result, nonresolved
         end
 
@@ -1197,38 +1163,20 @@ def compute_revdeps
             result
         end
 
-        # @deprecated use Autoproj.config.each_reused_autoproj_installation
-        def each_reused_autoproj_installation
-            Autoproj.config.each_reused_autoproj_installation(&proc)
-        end
-
-        def reuse(*dir)
-            dir = File.expand_path(File.join(*dir), Autoproj.root_dir)
-            if reused_installations.any? { |mnf| mnf.path == dir }
+        # Declare that we should reuse the autoproj installation present at the
+        # given path
+        def reuse(workspace_root)
+            if reused_installations.any? { |mnf| mnf.path == workspace_root }
                 return
             end
 
-            manifest = InstallationManifest.new(dir)
-            if !File.file?(manifest.default_manifest_path)
-                raise ConfigError.new, "while setting up reuse of #{dir}, the .autoproj-installation-manifest file does not exist. You should probably rerun autoproj envsh in that folder first"
-            end
+            manifest = InstallationManifest.from_workspace_root(workspace_root)
             manifest.load
             @reused_installations << manifest
             manifest.each do |pkg|
                 ignore_package pkg.name
             end
         end
-
-        # Load OS dependency information contained in our registered package
-        # sets into the provided osdep object
-        #
-        # @param [OSPackageResolver] osdeps the osdep handling object
-        # @return [void]
-        def load_osdeps_from_package_sets(osdeps)
-            each_package_set do |pkg_set, file|
-                osdeps.merge(pkg_set.load_osdeps(file))
-            end
-        end
     end
 
     def self.manifest
@@ -1246,9 +1194,6 @@ def self.osdeps
     end
 
     def self.config
-        Autoproj.warn_deprecated(
-            __method__, "use workspace.config instead")
-
         workspace.config
     end