autoproj 1.10.2 → 1.11.0.b1

data/lib/autoproj/configuration.rb

@@ -0,0 +1,161 @@
+module Autoproj
+    # Class that does the handling of configuration options as well as
+    # loading/saving on disk
+    class Configuration
+        # Set of currently known options
+        #
+        # These are the values that are going to be saved on disk. Use
+        # {override} to change a value without changing the saved configuration
+        # file.
+        attr_reader :config
+        # Set of overriden option values that won't get written to file
+        attr_reader :overrides
+        # Set of options that have been declared with {declare}
+        attr_reader :declared_options
+        # The options that have already been shown to the user
+        attr_reader :displayed_options
+
+        def initialize
+            @config = Hash.new
+            @overrides = Hash.new
+            @declared_options = Hash.new
+            @displayed_options = Hash.new
+        end
+
+        # Deletes the current value for an option
+        #
+        # The user will be asked for a new value next time the option is needed
+        #
+        # @param [String] the option name
+        # @return the deleted value
+        def reset(name)
+            config.delete(name)
+        end
+
+        # Sets a configuration option
+        #
+        # @param [String] key the option name
+        # @param [Object] value the option value
+        # @param [Boolean] user_validated if true, autoproj will not ask the
+        #   user about this value next time it is needed. Otherwise, it will be
+        #   asked about it, the new value being used as default
+        def set(key, value, user_validated = false)
+            config[key] = [value, user_validated]
+        end
+
+        # Override a known option value
+        #
+        # The new value will not be saved to disk, unlike with {set}
+        def override(option_name, value)
+            overrides[option_name] = value
+        end
+
+        # Tests whether a value is set for the given option name
+        #
+        # @return [Boolean]
+        def has_value_for?(name)
+            config.has_key?(name) || overrides.has_key?(name)
+        end
+
+        # Get the value for a given option
+        def get(key)
+            if overrides.has_key?(key)
+                return overrides[key]
+            end
+
+            value, validated = config[key]
+            if value.nil? || (declared?(key) && !validated)
+                value = configure(key)
+            else
+                if declared?(key) && (displayed_options[key] != value)
+                    doc = declared_options[key].short_doc
+                    if doc[-1, 1] != "?"
+                        doc = "#{doc}:"
+                    end
+                    Autoproj.message "  #{doc} #{value}"
+                    displayed_options[key] = value
+                end
+                value
+            end
+        end
+
+        # Returns the option's name-value pairs for the options that do not
+        # require user input
+        def validated_values
+            config.inject(Hash.new) do |h, (k, v)|
+                h[k] =
+                    if overrides.has_key?(k) then overrides[k]
+                    elsif v.last || !declared?(k) then v.first
+                    end
+                h
+            end
+        end
+
+        # Declare an option
+        #
+        # This declares a given option, thus allowing to ask the user about it
+        #
+        # @param [String] name the option name
+        # @param [String] type the option type (can be 'boolean' or 'string')
+        # @option options [String] :short_doc the one-line documentation string
+        #   that is displayed when the user does not have to be queried. It
+        #   defaults to the first line of :doc if not given
+        # @option options [String] :doc the full option documentation. It is
+        #   displayed to the user when he is explicitly asked about the option's
+        #   value
+        # @option options [Object] :default the default value this option should
+        #   take
+        # @option options [Array] :possible_values list of possible values (only
+        #   if the option type is 'string')
+        # @option options [Boolean] :lowercase (false) whether the user's input
+        #   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)
+            declared_options[name] = BuildOption.new(name, type, options, validator)
+        end
+
+        # Checks if an option exists
+        # @return [Boolean]
+        def declared?(name)
+            declared_options.has_key?(name)
+        end
+
+        # Configures a given option by asking the user about its desired value
+        #
+        # @return [Object] the new option value
+        # @raise ConfigError if the option is not declared
+        def configure(option_name)
+            if opt = declared_options[option_name]
+                if current_value = config[option_name]
+                    current_value = current_value.first
+                end
+                value = opt.ask(current_value)
+                config[option_name] = [value, true]
+                displayed_options[option_name] = value
+                value
+            else
+                raise ConfigError.new, "undeclared option '#{option_name}'"
+            end
+        end
+
+        def load(path, reconfigure = false)
+            if h = YAML.load(File.read(path))
+                h.each do |key, value|
+                    set(key, value, !reconfigure)
+                end
+            end
+        end
+
+        def save(path)
+            File.open(path, "w") do |io|
+                h = Hash.new
+                config.each do |key, value|
+                    h[key] = value.first
+                end
+
+                io.write YAML.dump(h)
+            end
+        end
+    end
+end

data/lib/autoproj/gitorious.rb

@@ -24,33 +24,44 @@ module Autoproj
             :git_url  => "git://#{base_url}",
             :http_url => "https://git.#{base_url}",
             :ssh_url  => "git@#{base_url}:",
-            :fallback_to_http => true
+            :fallback_to_http => true,
+            :default => 'git,ssh'
 
         gitorious_long_doc = [
-            "Access method to import data from #{base_url} (git, http or ssh)",
-            "Use 'ssh' only if you have an account there. Note that",
-            "ssh will always be used to push to the repositories, this is",
-            "only to get data from the server. Therefore, we advise to use",
-            "'git' as it is faster than ssh and better than http"]
+            "How should I interact with #{base_url} (git, http or ssh)",
+            "If you give two values, comma-separated, the first one will be",
+            "used for pulling and the second one for pushing"]
+
+        access_methods = Hash[
+            'git' => 'git,ssh',
+            'ssh' => 'ssh,ssh',
+            'http' => 'http,http']
 
         configuration_option name, 'string',
-            :default => "git",
-            :values => ["http", "ssh"],
+            :default => options[:default],
             :doc => gitorious_long_doc do |value|
+                if value =~ /,/
+                    value.split(',').each do |method|
+                        if !access_methods.has_key?(method)
+                            raise Autoproj::InputError, "#{method} is not a known access method"
+                        end
+                    end
+                elsif !access_methods.has_key?(value)
+                    raise Autoproj::InputError, "#{value} is not a known access method"
+                end
 
-            value
-        end
+                value
+            end
 
         access_mode = Autoproj.user_config(name)
-        if access_mode == "git"
-            Autoproj.change_option("#{name}_ROOT", options[:git_url])
-            Autoproj.change_option("#{name}_PUSH_ROOT", options[:ssh_url])
-        elsif access_mode == "http"
-            Autoproj.change_option("#{name}_ROOT", options[:http_url])
-            Autoproj.change_option("#{name}_PUSH_ROOT", options[:http_url])
-        elsif access_mode == "ssh"
-            Autoproj.change_option("#{name}_ROOT", options[:ssh_url])
-            Autoproj.change_option("#{name}_PUSH_ROOT", options[:ssh_url])
+        access_mode = access_methods[access_mode] || access_mode
+        pull, push = access_mode.split(',')
+        [[pull, "_ROOT"], [push, "_PUSH_ROOT"]].each do |method, var_suffix|
+            url = if method == "git" then options[:git_url]
+                  elsif method == "http" then options[:http_url]
+                  elsif method == "ssh" then options[:ssh_url]
+                  end
+            Autoproj.change_option("#{name}#{var_suffix}", url)
         end
 
         Autoproj.add_source_handler name.downcase do |url, vcs_options|
@@ -68,5 +79,5 @@ module Autoproj
 end
 
 Autoproj.gitorious_server_configuration('GITORIOUS', 'gitorious.org')
-Autoproj.gitorious_server_configuration('GITHUB', 'github.com', :http_url => 'https://github.com')
+Autoproj.gitorious_server_configuration('GITHUB', 'github.com', :http_url => 'https://github.com', :default => 'http,ssh')
 

data/lib/autoproj/installation_manifest.rb

@@ -3,13 +3,19 @@ module Autoproj
     class InstallationManifest
         Package = Struct.new :name, :srcdir, :prefix
 
+        DEFAULT_MANIFEST_NAME = ".autoproj-installation-manifest"
+
         attr_reader :path
         attr_reader :packages
         def initialize(path)
             @path = path
         end
 
-        def load(path)
+        def default_manifest_path
+            File.join(path, DEFAULT_MANIFEST_NAME)
+        end
+            
+        def load(path = default_manifest_path)
             @packages = CSV.read(path).map do |row|
                 Package.new(*row)
             end

data/lib/autoproj/manifest.rb

@@ -28,37 +28,18 @@ module Autoproj
     # The Manifest class represents the information included in the main
     # manifest file, and allows to manipulate it
     class Manifest
-        # Data structure used to use autobuild importers without a package, to
-        # import configuration data.
-        #
-        # It has to match the interface of Autobuild::Package that is relevant
-        # for importers
-        class FakePackage < Autobuild::Package
-            attr_reader :srcdir
-            attr_reader :importer
-
-            # Used by the autobuild importers
-            attr_accessor :updated
-
-            def initialize(text_name, srcdir, importer = nil)
-                super(text_name)
-                @srcdir = srcdir
-                @importer = importer
-                @@packages.delete(text_name)
-            end
-
-            def import
-                importer.import(self,Manifest.only_local_updates)
-            end
-
-            def add_stat(*args)
-            end
-        end
-
         # 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}
+        # can do it as well
+        #
+        # @return [Array<PackageSet>]
+        attr_writer :package_sets
+
         # Returns true if +pkg_name+ has been explicitely selected
         def explicitly_selected_package?(pkg_name)
             explicit_selection && explicit_selection.include?(pkg_name)
@@ -130,16 +111,16 @@ module Autoproj
 
         attr_reader :metapackages
 
-        class << self
-            #Set to true if this manifest should only do local updates through the Autobuild::Importer
-            attr_accessor :only_local_updates
-        end
+        # The VCS object for the main configuration itself
+        attr_reader :vcs
 
 	def initialize
             @file = nil
 	    @data = Hash.new
             @packages = Hash.new
             @package_manifests = Hash.new
+            @package_sets = []
+
             @automatic_exclusions = Hash.new
             @constants_definitions = Hash.new
             @disabled_imports = Set.new
@@ -149,7 +130,6 @@ module Autoproj
             @ignored_os_dependencies = Set.new
             @reused_installations = Array.new
             @ignored_packages = Set.new
-            Manifest::only_local_updates = false
 
             @constant_definitions = Hash.new
             if Autoproj.has_config_key?('manifest_source')
@@ -252,7 +232,7 @@ module Autoproj
         # 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(:each_source_file, source_name)
+                return enum_for(__method__, source_name)
             end
 
             # This looks very inefficient, but it is because source names are
@@ -261,7 +241,7 @@ module Autoproj
             #
             # And honestly I don't think someone will have 20 000 package sets
             done_something = false
-            each_package_set(false) do |source| 
+            each_package_set do |source| 
                 next if source_name && source.name != source_name
                 done_something = true
 
@@ -278,10 +258,10 @@ module Autoproj
         # Yields each osdeps definition files that are present in our sources
         def each_osdeps_file
             if !block_given?
-                return enum_for(:each_source_file)
+                return enum_for(__method__)
             end
 
-            each_package_set(false) do |source|
+            each_package_set do |source|
 		Dir.glob(File.join(source.local_dir, "*.osdeps")).each do |file|
 		    yield(source, file)
 		end
@@ -293,130 +273,62 @@ module Autoproj
             each_remote_source(false).any? { true }
         end
 
-        # True if calling update_remote_sources will actually do anything
-        def should_update_remote_sources
-            if Autobuild.do_update
-                return true
-            end
-
-            each_remote_source(false) do |source|
-                if !File.directory?(source.local_dir)
-                    return true
-                end
-            end
-            false
-        end
-
         # Like #each_package_set, but filters out local package sets
-        def each_remote_package_set(load_description = true)
-            if !block_given?
-                enum_for(:each_remote_package_set, load_description)
-            else
-                each_package_set(load_description) do |source|
-                    if !source.local?
-                        yield(source)
-                    end
-                end
-            end
-        end
-
-        def each_remote_source(*args, &block)
-            each_remote_package_set(*args, &block)
-        end
-
-        # Helper method for #each_package_set
-        def enumerate_package_set(pkg_set, explicit_sets, all_sets) # :nodoc:
-            if @disabled_imports.include?(pkg_set.name)
-                pkg_set.auto_imports = false
-            end
-
-            result = []
-            if pkg_set.auto_imports?
-                pkg_set.each_imported_set do |imported_set|
-                    if explicit_sets.any? { |src| src.vcs == imported_set.vcs } ||
-                        all_sets.any? { |src| src.vcs == imported_set.vcs }
-                        next
-                    end
+        def each_remote_package_set
+            return enum_for(__method__) if !block_given?
 
-                    all_sets << imported_set
-                    result.concat(enumerate_package_set(imported_set, explicit_sets, all_sets))
+            each_package_set do |pkg_set|
+                if !pkg_set.local?
+                    yield(pkg_set)
                 end
             end
-            result << pkg_set
-            result
         end
 
-        # call-seq:
-        #   each_package_set { |pkg_set| ... }
+        # Enumerates the version control information for all the package sets
+        # listed directly in the manifest file
         #
-        # Lists all package sets defined in this manifest, by yielding a
-        # PackageSet object that describes it.
-        def each_package_set(load_description = true, &block)
-            if !block_given?
-                return enum_for(:each_package_set, load_description)
-            end
-
-            if @package_sets
-                if load_description
-                    @package_sets.each do |src|
-                        if !src.source_definition
-                            src.load_description_file
-                        end
-                    end
-                end
-                return @package_sets.each(&block)
-            end
-
-	    explicit_sets = (data['package_sets'] || []).map do |spec|
+        # @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
-                    PackageSet.from_spec(self, spec, load_description)
+                    yield(*PackageSet.resolve_definition(self, spec))
                 end
             end
-
-            all_sets = Array.new
-            explicit_sets.each do |pkg_set|
-                all_sets.concat(enumerate_package_set(pkg_set, explicit_sets, all_sets + [pkg_set]))
-            end
-
-            # Now load the local source 
-            local = LocalPackageSet.new(self)
-            if load_description
-                local.load_description_file
-            else
-                local.load_minimal
-            end
-            if !load_description || !local.empty?
-                all_sets << local
-            end
-            
-            if load_description
-                all_sets.each(&:load_description_file)
-            else
-                all_sets.each(&:load_minimal)
-            end
-            all_sets.each(&block)
+            nil
         end
 
-        # DEPRECATED. For backward-compatibility only
+        # Lists all package sets defined in this manifest, including the package
+        # sets that are auto-imported
         #
-        # use #each_package_set instead
-        def each_source(*args, &block)
-            each_package_set(*args, &block)
+        # Note that this can be called only after the package sets got loaded
+        # with {load_package_sets}
+        #
+        # @yieldparam [PackageSet]
+        def each_package_set(&block)
+            @package_sets.each(&block)
+        end
+
+        # Load the package set information
+        def load_and_update_package_sets
+            Ops::Configuration.new(self, Ops.loader).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) }
         end
 
-        # Save the currently known package sets. After this call,
-        # #each_package_set will always return the same set regardless of
-        # changes on the manifest's data structures
-        def cache_package_sets
-            @package_sets = each_package_set(false).to_a
-            @package_sets.each do |pkg_set|
-                @metapackages[pkg_set.name] ||= Metapackage.new(pkg_set.name)
-                @metapackages["#{pkg_set.name}.all"] ||= Metapackage.new("#{pkg_set.name}.all")
-            end
+        # Registers a new package set
+        def register_package_set(pkg_set)
+            metapackage(pkg_set.name)
+            metapackage("#{pkg_set.name}.all")
+            @package_sets << pkg_set
         end
 
         # Register a new package
@@ -430,26 +342,48 @@ module Autoproj
             @metapackages["#{pkg.package_set.name}.all"].add(pkg.autobuild)
         end
 
+        # Returns the package set that defines a package
+        #
+        # @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
         end
 
+        # @deprecated use {definition_package_set} instead
         def definition_source(package_name)
             definition_package_set(package_name)
         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
         end
 
+        def find_package(name)
+            packages[name]
+        end
+
         def package(name)
             packages[name]
         end
 
-        # Lists all defined packages as PackageDefinition objects
+        # Lists all defined packages
+        #
+        # @yieldparam [PackageDefinition] pkg
         def each_package_definition(&block)
             if !block_given?
                 return enum_for(:each_package_definition)
@@ -457,216 +391,53 @@ module Autoproj
             packages.each_value(&block)
         end
 
-        # Lists all defined autobuild packages as instances of
-        # Autobuild::Package and its subclasses
+        # Lists the autobuild objects for all defined packages
+        #
+        # @yieldparam [Autobuild::Package] pkg
         def each_autobuild_package
-            if !block_given?
-                return enum_for(:each_package)
-            end
+            return enum_for(__method__) if !block_given?
             packages.each_value { |pkg| yield(pkg.autobuild) }
         end
 
-        # DEPRECATED: use either #each_autobuild_package and
-        # #each_package_definition
-        def each_package(&block)
-            each_autobuild_package(&block)
-        end
-
-        # The VCS object for the main configuration itself
-        attr_reader :vcs
-
-        def each_configuration_source
-            if !block_given?
-                return enum_for(:each_configuration_source)
-            end
-
-            if vcs
-                yield(vcs, "autoproj main configuration", Autoproj.config_dir)
-            end
-
-            each_remote_source(false) do |source|
-                yield(source.vcs, source.name || source.vcs.url, source.local_dir)
-            end
-            self
-        end
-
-        # Creates an autobuild package whose job is to allow the import of a
-        # specific repository into a given directory.
-        #
-        # +vcs+ is the VCSDefinition file describing the repository, +text_name+
-        # the name used when displaying the import progress, +pkg_name+ the
-        # internal name used to represent the package and +into+ the directory
-        # in which the package should be checked out.
+        # @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)
-            importer     = vcs.create_autobuild_importer
-            return if !importer # updates have been disabled by using the 'none' type
-
-            FakePackage.new(text_name, into, importer)
-
-        rescue Autobuild::ConfigException => e
-            raise ConfigError.new, "cannot import #{name}: #{e.message}", e.backtrace
-        end
-
-        # Imports or updates a source (remote or otherwise).
-        #
-        # See create_autobuild_package for informations about the arguments.
-        def self.update_package_set(vcs, text_name, into)
-            fake_package = create_autobuild_package(vcs, text_name, into)
-            if other_root = CmdLine.update_from
-                # Define a package in the installation manifest that points to
-                # the desired folder in other_root
-                relative_path = Pathname.new(into).
-                    relative_path_from(Pathname.new(Autoproj.root_dir)).to_s
-                other_dir = File.join(other_root.path, relative_path)
-                if File.directory?(other_dir)
-                    other_root.packages.unshift(
-                        InstallationManifest::Package.new(fake_package.name, other_dir, File.join(other_dir, 'install')))
-                end
-
-                # Then move the importer there if possible
-                if fake_package.importer.respond_to?(:pick_from_autoproj_root)
-                    if !fake_package.importer.pick_from_autoproj_root(fake_package, other_root)
-                        fake_package.update = false
-                    end
-                else
-                    fake_package.update = false
-                end
-            end
-            fake_package.import
-
-        rescue Autobuild::ConfigException => e
-            raise ConfigError.new, "cannot import #{name}: #{e.message}", e.backtrace
-        end
-
-        # Updates the main autoproj configuration
-        def update_yourself
-            Manifest.update_package_set(vcs, "autoproj main configuration", Autoproj.config_dir)
-        end
-
-        def update_remote_set(pkg_set, remotes_symlinks_dir = nil)
-            Manifest.update_package_set(
-                pkg_set.vcs,
-                pkg_set.name,
-                pkg_set.raw_local_dir)
-
-            if remotes_symlinks_dir
-                pkg_set.load_minimal
-                symlink_dest = File.join(remotes_symlinks_dir, pkg_set.name)
-
-                # Check if the current symlink is valid, and recreate it if it
-                # is not
-                if File.symlink?(symlink_dest)
-                    dest = File.readlink(symlink_dest)
-                    if dest != pkg_set.raw_local_dir
-                        FileUtils.rm_f symlink_dest
-                        Autoproj.create_symlink(pkg_set.raw_local_dir, symlink_dest)
-                    end
-                else
-                    FileUtils.rm_f symlink_dest
-                    Autoproj.create_symlink(pkg_set.raw_local_dir, symlink_dest)
-                end
-
-                symlink_dest
-            end
+            Ops::Tools.create_autobuild_package(vcs, text_name, into)
         end
 
-        # Updates all the remote sources in ROOT_DIR/.remotes, as well as the
-        # symbolic links in ROOT_DIR/autoproj/remotes
-        def update_remote_package_sets
-            remotes_symlinks_dir = File.join(Autoproj.config_dir, 'remotes')
-            FileUtils.mkdir_p remotes_symlinks_dir
-
-            # Iterate on the remote sources, without loading the source.yml
-            # file (we're not ready for that yet)
-            #
-            # Do it iteratively to properly take imports into account, but we
-            # first unconditionally update all the existing sets to properly
-            # handle imports that have been removed
-            updated_sets     = Hash.new
-            known_remotes = []
-            each_remote_package_set(false) do |pkg_set|
-                next if !pkg_set.explicit?
-                if pkg_set.present?
-                    known_remotes << update_remote_set(pkg_set, remotes_symlinks_dir)
-                    updated_sets[pkg_set.repository_id] = pkg_set
-                end
-            end
-
-            old_updated_sets = nil
-            while old_updated_sets != updated_sets
-                old_updated_sets = updated_sets.dup
-                each_remote_package_set(false) do |pkg_set|
-                    next if updated_sets.has_key?(pkg_set.repository_id)
-
-                    if !pkg_set.explicit?
-                        Autoproj.message "  #{pkg_set.imported_from.name}: auto-importing #{pkg_set.name}"
-                    end
-                    known_remotes << update_remote_set(pkg_set, remotes_symlinks_dir)
-                    updated_sets[pkg_set.repository_id] = pkg_set
-                end
-            end
-
-            # Check for directories in ROOT_DIR/.remotes that do not map to a
-            # source repository, and remove them
-            Dir.glob(File.join(Autoproj.remotes_dir, '*')).each do |dir|
-                dir = File.expand_path(dir)
-                if File.directory?(dir) && !updated_sets.values.find { |pkg| pkg.raw_local_dir == dir }
-                    FileUtils.rm_rf dir
-                end
-            end
-
-            # Now remove obsolete symlinks
-            Dir.glob(File.join(remotes_symlinks_dir, '*')).each do |file|
-                if File.symlink?(file) && !known_remotes.include?(file)
-                    FileUtils.rm_f file
-                end
-            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)
         end
 
-        # DEPRECATED. For backward-compatibility only
-        def update_remote_sources(*args, &block)
-            update_remote_package_sets(*args, &block)
+        # @deprecated use Ops::Configuration.update_remote_package_set
+        def update_remote_set(vcs, only_local = false)
+            Ops::Configuration.update_remote_package_set(vcs, only_local)
         end
 
-        def importer_definition_for(package_name, package_source = nil)
-            if !package_source
-                package_source = packages.values.
-                    find { |pkg| pkg.autobuild.name == package_name }.
-                    package_set
-            end
-
-            sources = each_package_set.to_a.dup
+        # Compute the VCS definition for a given package
+        #
+        # @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
+        # @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)
+            return if !vcs
 
-            # Remove sources listed before the package source
-            while !sources.empty? && sources[0].name != package_source.name
-                sources.shift
-            end
-            package_source = sources.shift
-            if !package_source
-                raise InternalError, "cannot find the package set that defines #{package_name}"
+            # 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
             end
+            package_sets.shift
 
-            # Get the version control information from the package source. There
-            # must be one
-            vcs_spec, raw = Autoproj.in_file package_source.source_file do
-                package_source.version_control_field(package_name, 'version_control')
+            # Then apply the overrides
+            package_sets.inject(vcs) do |updated_vcs, pkg_set|
+                pkg_set.overrides_for(package_name, updated_vcs)
             end
-            return if !vcs_spec
-
-            sources.each do |src|
-                overrides_spec, raw_additional = src.version_control_field(package_name, 'overrides', false)
-                raw = raw.concat(raw_additional)
-                if overrides_spec
-                    vcs_spec = Autoproj.in_file src.source_file do
-                        begin
-                            VCSDefinition.update_raw_vcs_spec(vcs_spec, overrides_spec)
-                        rescue ConfigError => e
-                            raise ConfigError.new, "invalid resulting VCS specification in the overrides section for package #{package_name}: #{e.message}"
-                        end
-                    end
-                end
-            end
-            VCSDefinition.from_raw(vcs_spec, raw)
         end
 
         # Sets up the package importers based on the information listed in
@@ -700,10 +471,18 @@ module Autoproj
             end
         end
 
+        # Checks if there is a package with a given name
+        #
+        # @param [String] name
+        # @return [Boolean]
+        def has_package?(name)
+            packages.has_key?(name)
+        end
+
         # Returns true if +name+ is the name of a package set known to this
         # autoproj installation
         def has_package_set?(name)
-            each_package_set(false).find { |set| set.name == name }
+            each_package_set.find { |set| set.name == name }
         end
 
         # Returns the PackageSet object for the given package set, or raises
@@ -1046,7 +825,7 @@ module Autoproj
         # Returns the package directory for the given package name
         def whereis(package_name)
             Autoproj.in_file(self.file) do
-                set_name = definition_source(package_name).name
+                set_name = definition_package_set(package_name).name
                 actual_layout = normalized_layout
                 return actual_layout[package_name] || actual_layout[set_name] || '/'
             end
@@ -1325,11 +1104,10 @@ module Autoproj
             end
 
             manifest = InstallationManifest.new(dir)
-            manifest_file = File.join(dir,  ".autoproj-installation-manifest")
-            if !File.file?(manifest_file)
+            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.load(manifest_file)
+            manifest.load
             @reused_installations << manifest
             manifest.each do |pkg|
                 ignore_package pkg.name
@@ -1360,6 +1138,10 @@ module Autoproj
         # @return [OSDependencies]
         # @see load_osdeps_from_package_sets
         attr_accessor :osdeps
+
+        # The configuration file
+        # @return [Configuration]
+        attr_accessor :config
     end
 
     # Load the osdeps files contained in {manifest} into {osdeps}