autoproj 2.0.0.b1 → 2.0.0.b2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1e302cab6677a8cb13970ecc83bd4df3b88be03
-  data.tar.gz: 5e4a7dfe45bbeab8e593c941990d30dd0c78d913
+  metadata.gz: c2c8af79b50be1a3374d16bb769a5f8ca0015638
+  data.tar.gz: 355d629ec40fca2793098e454aee5a71e745a2f3
 SHA512:
-  metadata.gz: f2238a795517a8bfa3261f8e8a2a14a1e1be30d90fbb56469cb6634520a5aed280bb1746c511fe1db7443725142d9f8a1a39a67422432977787dae61b6f02446
-  data.tar.gz: e02d859e9a811a1bd09bb1ac30e69d0c5ee3425ae28e1f704e938217b53c01bd4042d927ea54b9d24e9a3af0690c89c3d24cbc25cff5df7bff938c63bbf683d7
+  metadata.gz: c0c2f5ea2df76ec3ac590a0fd9c4bd7d9b7f48c9c1812b1e371ebb736d533d36fc0a534dd93e1328fea9f6753b30e1eec798ee5280c2ba7f3c1ae5cf4f867bef
+  data.tar.gz: 83a685f81470eab8d5be0b4ec400b997568c2d91f83987bf42bf655b75a5c4032b1a688a19e4b3fdee570ce9219adcc8b2087606aa07ec2a1b8d6f60d9d76349

data/Rakefile

@@ -20,7 +20,8 @@ Utilrb::Rake.hoe do
             extra_deps << 
                 ['autobuild',   '~> 1.9', '>= 1.9.0'] <<
                 ['utilrb', '~> 2.0', '>= 2.0.0'] <<
-                ['highline', '~> 1.7', '>= 1.7.0']
+                ['highline', '~> 1.7', '>= 1.7.0'] <<
+                ['thor', '~> 0.19.0', '>= 0.19.1']
         end
     end
 end

data/bin/autoproj_bootstrap

@@ -273,7 +273,6 @@ module Autoproj
                     if doc[-1, 1] != "?"
                         doc = "#{doc}:"
                     end
-                    Autoproj.message "  #{doc} #{value}"
                     displayed_options[key] = value
                 end
                 value

data/lib/autoproj/cli/bootstrap.rb

@@ -33,7 +33,7 @@ module Autoproj
                 return args, options
             end
             
-            def restart_if_needed
+            def restart_if_needed(ws)
                 # Check if the .autoprojrc changed the PATH and therefore which autoproj script
                 # should be executed ... and restart if it did
                 autoproj_path = Autobuild.find_in_path('autoproj')
@@ -71,9 +71,13 @@ module Autoproj
 
             def run(buildconf_info, options)
                 ws = Workspace.new(root_dir)
+                if config_path = options[:seed_config]
+                    FileUtils.cp config_path, File.join(ws.config_dir, 'config.yml')
+                end
+
                 ws.setup
                 install_autoproj_gem_in_new_root(ws)
-                restart_if_needed
+                restart_if_needed(ws)
 
                 switcher = Ops::MainConfigSwitcher.new(ws)
                 begin

data/lib/autoproj/cli/build.rb

@@ -10,7 +10,7 @@ module Autoproj
                     selected_packages = ['.']
                 end
 
-                if !options.has_key?(:deps)
+                if options[:deps].nil?
                     options[:deps] = 
                         !(options[:rebuild] || options[:force])
                 end
@@ -25,7 +25,13 @@ module Autoproj
                 Autobuild.ignore_errors = options[:keep_going]
 
                 command_line_selection, source_packages, osdep_packages =
-                    super(selected_packages, options.merge(checkout_only: true))
+                    super(selected_packages, options.merge(checkout_only: true, apply_post_install: false))
+
+                # Disable all packages that are not selected
+                ws.manifest.each_autobuild_package do |pkg|
+                    next if source_packages.include?(pkg.name)
+                    pkg.disable
+                end
 
                 ops = Ops::Build.new(ws.manifest)
                 if build_options[:rebuild] || build_options[:force]
@@ -64,6 +70,7 @@ module Autoproj
                 Autobuild.do_build = true
                 ops.build_packages(source_packages)
                 Autobuild.apply(source_packages, "autoproj-build", ['install'])
+                ws.apply_post_install
             end
         end
     end

data/lib/autoproj/cli/cache.rb

@@ -18,12 +18,14 @@ module Autoproj
 
             def run(cache_dir, options = Hash.new)
                 options = Kernel.validate_options options,
-                    keep_going: false
+                    keep_going: false,
+                    checkout_only: false
 
                 initialize_and_load
+                finalize_setup
 
                 cache_op = Autoproj::Ops::Cache.new(cache_dir, ws.manifest)
-                cache_op.create_or_update(options[:keep_going])
+                cache_op.create_or_update(options)
             end
         end
     end

data/lib/autoproj/cli/envsh.rb

@@ -14,7 +14,7 @@ module Autoproj
 
                 options = Kernel.validate_options options,
                     shell_helpers: ws.config.shell_helpers?
-                ws.env.export_env_sh(shell_helpers: options[:shell_helpers])
+                ws.export_env_sh(shell_helpers: options[:shell_helpers])
             end
         end
     end

data/lib/autoproj/cli/inspection_tool.rb

@@ -48,6 +48,7 @@ module Autoproj
                     source_packages, osdep_packages, resolved_selection =
                         resolve_selection(ws.manifest, packages, options)
                     ws.finalize_setup
+                    ws.apply_post_install
                     ws.export_installation_manifest
                     return source_packages, osdep_packages, resolved_selection, config_selected
                 end

data/lib/autoproj/cli/locate.rb

@@ -11,6 +11,7 @@ module Autoproj
 
             def initialize(ws = nil)
                 super
+                self.ws.load_config
 
                 @installation_manifest = Autoproj::InstallationManifest.new(self.ws.root_dir)
                 if !File.file?(installation_manifest.default_manifest_path)
@@ -24,22 +25,41 @@ module Autoproj
                 return selected.first, options
             end
 
+            def result_value(pkg, options)
+                if options[:build]
+                    if pkg.builddir
+                        pkg.builddir
+                    else
+                        raise ConfigError, "#{pkg.name} does not have a build directory"
+                    end
+                else
+                    pkg.srcdir
+                end
+            end
+
             def run(selection, options = Hash.new)
                 if !selection
-                    puts ws.root_dir
+                    if options[:build]
+                        puts ws.prefix_dir
+                    else
+                        puts ws.root_dir
+                    end
                     return
                 end
 
+                if File.directory?(selection)
+                    selection = File.expand_path(selection)
+                end
+
                 selection_rx = Regexp.new(Regexp.quote(selection))
                 candidates = []
                 installation_manifest.each do |pkg|
                     name = pkg.name
-                    srcdir = pkg.srcdir
-                    if name == selection
-                        puts srcdir
+                    if name == selection || pkg.srcdir == selection
+                        puts result_value(pkg, options)
                         return
                     elsif name =~ selection_rx
-                        candidates << srcdir
+                        candidates << pkg
                     end
                 end
 
@@ -59,12 +79,11 @@ module Autoproj
                     candidates_strict = []
                     installation_manifest.each do |pkg|
                         name = pkg.name
-                        srcdir = pkg.srcdir
                         if name =~ rx
-                            candidates << srcdir
+                            candidates << pkg
                         end
                         if name =~ rx_strict
-                            candidates_strict << srcdir
+                            candidates_strict << pkg
                         end
                     end
 
@@ -76,7 +95,7 @@ module Autoproj
                 if candidates.size > 1
                     # If there is more than one candidate, check if there are some that are not
                     # present on disk
-                    present = candidates.find_all { |dir| File.directory?(dir) }
+                    present = candidates.find_all { |pkg| File.directory?(pkg.srcdir) }
                     if present.size == 1
                         candidates = present
                     end
@@ -87,7 +106,7 @@ module Autoproj
                 elsif candidates.size > 1
                     raise ArgumentError, "multiple packages match #{selection} in the current autoproj installation: #{candidates.join(", ")}"
                 else
-                    puts candidates.first
+                    puts result_value(candidates.first, options)
                 end
             end
         end

data/lib/autoproj/cli/main.rb

@@ -41,6 +41,9 @@ module Autoproj
             option :reuse,
                 banner: 'DIR',
                 desc: 'reuse packages already built within the DIR autoproj workspace in this installation, if DIR is not given, reuses the installation whose env.sh is currently sourced'
+            option :seed_config,
+                banner: 'SEED_CONFIG',
+                desc: "a configuration file used to seed the bootstrap's configuration"
             def bootstrap(*args)
                 run_autoproj_cli(:bootstrap, :Bootstrap, Hash[], *args)
             end
@@ -116,6 +119,8 @@ module Autoproj
             desc 'cache CACHE_DIR', 'create or update a cache directory that can be given to AUTOBUILD_CACHE_DIR'
             option :keep_going, aliases: :k,
                 desc: 'do not stop on errors'
+            option :checkout_only, aliases: :c, type: :boolean, default: false,
+                desc: "only checkout packages, do not update already-cached ones"
             def cache(cache_dir)
                 run_autoproj_cli(:cache, :Cache, Hash[], cache_dir)
             end
@@ -128,6 +133,8 @@ module Autoproj
             end
 
             desc 'locate [PACKAGE]', 'return the path to the given package, or the path to the root if no packages are given on the command line'
+            option :build, aliases: :b, type: :boolean,
+                desc: "outputs the package's build directory instead of its source directory"
             def locate(package = nil)
                 run_autoproj_cli(:locate, :Locate, Hash[], *Array(package))
             end

data/lib/autoproj/cli/update.rb

@@ -32,12 +32,15 @@ module Autoproj
                 selected_packages, config_selected =
                     normalize_command_line_package_selection(selected_packages)
 
+                if options[:apply_post_install].nil?
+                    options[:apply_post_install] = true
+                end
+
                 if options[:config].nil?
                     options[:config] = selected_packages.empty? || config_selected
                 end
 
                 ws.setup
-                ws.install_ruby_shims
 
                 # Do that AFTER we have properly setup ws.osdeps as to avoid
                 # unnecessarily redetecting the operating system
@@ -112,15 +115,17 @@ module Autoproj
                                     ignore_errors: options[:keep_going])
 
                 ws.finalize_setup
-                load_all_available_package_manifests
+                if options[:apply_post_install]
+                    ws.apply_post_install
+                end
                 ws.export_installation_manifest
 
                 if options[:osdeps] && !osdep_packages.empty?
                     ws.osdeps.install(osdep_packages, osdeps_options)
                 end
 
-                ws.env.export_env_sh
-                Autoproj.message "autoproj: updated #{ws.root_dir}/#{Autoproj::ENV_FILENAME}", :green
+                ws.export_env_sh(source_packages)
+                Autoproj.message "  updated #{ws.root_dir}/#{Autoproj::ENV_FILENAME}", :green
 
                 return command_line_selection, source_packages, osdep_packages
             end

data/lib/autoproj/cli/versions.rb

@@ -14,7 +14,7 @@ module Autoproj
 
             def validate_options(packages, options = Hash.new)
                 packages, options = super
-                if options.has_key?(:save)
+                if options[:save].nil?
                     options[:save] = case options[:save]
                                      when '.'
                                          nil

data/lib/autoproj/configuration.rb

@@ -77,7 +77,6 @@ module Autoproj
                     if doc[-1, 1] != "?"
                         doc = "#{doc}:"
                     end
-                    Autoproj.message "  #{doc} #{value}"
                     displayed_options[key] = value
                 end
                 value

data/lib/autoproj/installation_manifest.rb

@@ -1,7 +1,7 @@
 module Autoproj
     # Manifest of installed packages imported from another autoproj installation
     class InstallationManifest
-        Package = Struct.new :name, :srcdir, :prefix
+        Package = Struct.new :name, :srcdir, :prefix, :builddir, :dependencies
 
         DEFAULT_MANIFEST_NAME = ".autoproj-installation-manifest"
 
@@ -9,15 +9,59 @@ module Autoproj
         attr_reader :packages
         def initialize(path)
             @path = path
+            @packages = Hash.new
         end
 
         def default_manifest_path
             File.join(path, DEFAULT_MANIFEST_NAME)
         end
+
+        def exist?
+            File.exist?(default_manifest_path)
+        end
+
+        def [](name)
+            packages[name]
+        end
+
+        def []=(name, pkg)
+            packages[name] = pkg
+        end
+
+        def delete_if
+            packages.delete_if { |_, pkg| yield(pkg) }
+        end
             
         def load(path = default_manifest_path)
-            @packages = CSV.read(path).map do |row|
-                Package.new(*row)
+            @packages = Hash.new
+            raw = YAML.load(File.open(path))
+            if raw.respond_to?(:to_str) # old CSV-based format
+                CSV.read(path).map do |row|
+                    name, srcdir, prefix, builddir = *row
+                    builddir = nil if builddir && builddir.empty?
+                    packages[name] = Package.new(name, srcdir, prefix, builddir, [])
+                end
+                save(path)
+            else
+                raw.each do |entry|
+                    pkg = Package.new(
+                        entry['name'], entry['srcdir'], entry['prefix'],
+                        entry['builddir'], entry['dependencies'])
+                    packages[pkg.name] = pkg
+                end
+            end
+        end
+
+        def save(path = default_manifest_path)
+            File.open(path, 'w') do |io|
+                marshalled_packages = packages.values.map do |v|
+                    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)
             end
         end
 
@@ -26,17 +70,17 @@ module Autoproj
         end
 
         def [](name)
-            packages.find { |pkg| pkg.name == name }
+            packages.each_value.find { |pkg| pkg.name == name }
         end
 
         def self.from_root(root_dir)
             manifest = InstallationManifest.new(root_dir)
-            manifest_file = File.join(root_dir,  ".autoproj-installation-manifest")
-            if !File.file?(manifest_file)
-                raise ConfigError.new, "no .autoproj-installation-manifest file exists in #{root_dir}. You should probably rerun autoproj envsh in that folder first"
+            if !manifest.exist?
+                raise ConfigError.new, "no #{DEFAULT_MANIFEST_NAME} file exists in #{root_dir}. You should probably rerun autoproj envsh in that folder first"
             end
-            manifest.load(manifest_file)
+            manifest.load
             manifest
         end
     end
 end
+

data/lib/autoproj/ops/cache.rb

@@ -27,8 +27,12 @@ module Autoproj
                 File.join(cache_dir, 'git')
             end
 
-            def cache_git(pkg)
+            def cache_git(pkg, options = Hash.new)
                 pkg.importdir = File.join(git_cache_dir, pkg.name)
+                if options[:checkout_only] && File.directory?(pkg.importdir)
+                    return
+                end
+
                 pkg.importer.local_branch = nil
                 pkg.importer.remote_branch = nil
                 pkg.importer.remote_name = 'autobuild'
@@ -56,7 +60,13 @@ module Autoproj
                 end
             end
 
-            def create_or_update(keep_going = false)
+            def create_or_update(options = Hash.new)
+                options = Kernel.validate_options options,
+                    keep_going: false,
+                    checkout_only: false
+                keep_going = options[:keep_going]
+                checkout_only = options[:checkout_only]
+
                 FileUtils.mkdir_p cache_dir
 
                 packages = manifest.each_autobuild_package.
@@ -64,11 +74,12 @@ module Autoproj
                 total = packages.size
                 Autoproj.message "Handling #{total} packages"
                 packages.each_with_index do |pkg, i|
+                    next if pkg.srcdir != pkg.importdir # No need to process this one, it is uses another package's import
                     begin
                         case pkg.importer
                         when Autobuild::Git
                             Autoproj.message "  [#{i}/#{total}] caching #{pkg.name} (git)"
-                            cache_git(pkg)
+                            cache_git(pkg, checkout_only: checkout_only)
                         when Autobuild::ArchiveImporter
                             Autoproj.message "  [#{i}/#{total}] caching #{pkg.name} (archive)"
                             cache_archive(pkg)

data/lib/autoproj/ops/import.rb

@@ -62,22 +62,19 @@ module Autoproj
                 end
                 new_packages
             end
-
-            def import_packages(selection, options = Hash.new)
+            
+            # Import all packages from the given selection, and their
+            # dependencies
+            def import_selected_packages(selection, updated_packages, options = Hash.new)
                 options, import_options = Kernel.filter_options options,
-                    warn_about_ignored_packages: true,
-                    warn_about_excluded_packages: true,
                     recursive: true
 
                 manifest = ws.manifest
 
-                updated_packages = Array.new
                 selected_packages = selection.each_source_package_name.map do |pkg_name|
                     manifest.find_autobuild_package(pkg_name)
                 end.to_set
 
-                # The set of all packages that are currently selected by +selection+
-                all_processed_packages = Set.new
                 # The reverse dependencies for the package tree. It is discovered as
                 # we go on with the import
                 #
@@ -86,6 +83,8 @@ module Autoproj
                 # package exclusion (and that does not affect optional dependencies)
                 reverse_dependencies = Hash.new { |h, k| h[k] = Set.new }
 
+                # The set of all packages that are currently selected by +selection+
+                all_processed_packages = Set.new
                 package_queue = selected_packages.to_a.sort_by(&:name)
                 while !package_queue.empty?
                     pkg = package_queue.shift
@@ -137,34 +136,41 @@ module Autoproj
                     Autoproj.each_post_import_block(pkg) do |block|
                         block.call(pkg)
                     end
-                    pkg.update_environment
 
                     new_packages = import_next_step(pkg, reverse_dependencies)
 
                     # Excluded dependencies might have caused the package to be
                     # excluded as well ... do not add any dependency to the
                     # processing queue if it is the case
-                    if !manifest.excluded?(pkg.name) && options[:recursive]
+                    if manifest.excluded?(pkg.name)
+                        selection.filter_excluded_and_ignored_packages(manifest)
+                    elsif options[:recursive]
                         package_queue.concat(new_packages.sort_by(&:name))
                     end
-
-                    # Verify that everything is still OK with the new
-                    # exclusions/ignores
-                    selection.filter_excluded_and_ignored_packages(manifest)
                 end
+                all_processed_packages
+            end
+            
+            def finalize_package_load(processed_packages)
+                manifest = ws.manifest
 
-                # Now run optional dependency resolution. This is done now, as
-                # some optional dependencies might have been excluded during the
-                # resolution process above
-                all_enabled_sources, all_enabled_osdeps =
-                    Set.new, selection.each_osdep_package_name.to_set
-                package_queue = selection.each_source_package_name.to_a
+                all = Set.new
+                package_queue = manifest.all_layout_packages(false).each_source_package_name.to_a
                 while !package_queue.empty?
                     pkg_name = package_queue.shift
-                    next if all_enabled_sources.include?(pkg_name)
-                    all_enabled_sources << pkg_name
+                    next if all.include?(pkg_name)
+                    all << pkg_name
+
+                    next if manifest.ignored?(pkg_name) || manifest.excluded?(pkg_name)
 
                     pkg = manifest.find_autobuild_package(pkg_name)
+                    if !processed_packages.include?(pkg.name)
+                        manifest.load_package_manifest(pkg.name)
+                        Autoproj.each_post_import_block(pkg) do |block|
+                            block.call(pkg)
+                        end
+                    end
+
                     packages, osdeps = pkg.partition_optional_dependencies
                     packages.each do |pkg_name|
                         if !manifest.ignored?(pkg_name) && !manifest.excluded?(pkg_name)
@@ -172,19 +178,29 @@ module Autoproj
                         end
                     end
                     pkg.os_packages.merge(osdeps)
-                    all_enabled_osdeps |= pkg.os_packages
-
-                    pkg.prepare if !pkg.disabled?
+                    pkg.prepare
                     Rake::Task["#{pkg.name}-prepare"].instance_variable_set(:@already_invoked, true)
-
-                    if options[:recursive]
-                        package_queue.concat(pkg.dependencies)
-                    end
+                    pkg.update_environment
+                    package_queue.concat(pkg.dependencies)
                 end
+                all
+            end
 
-                if Autoproj.verbose
-                    Autoproj.message "autoproj: finished importing packages"
-                end
+            def import_packages(selection, options = Hash.new)
+                options, import_options = Kernel.filter_options options,
+                    warn_about_ignored_packages: true,
+                    warn_about_excluded_packages: true,
+                    recursive: true
+
+                manifest = ws.manifest
+
+                updated_packages = Array.new
+                all_processed_packages = import_selected_packages(
+                    selection, updated_packages, import_options.merge(recursive: options[:recursive]))
+                finalize_package_load(all_processed_packages)
+
+                all_enabled_osdeps = selection.each_osdep_package_name.to_set
+                all_enabled_sources = all_processed_packages
 
                 if options[:warn_about_excluded_packages]
                     selection.exclusions.each do |sel, pkg_names|

data/lib/autoproj/version.rb

@@ -1,3 +1,3 @@
 module Autoproj
-    VERSION = "2.0.0.b1"
+    VERSION = "2.0.0.b2"
 end

data/lib/autoproj/workspace.rb

@@ -173,6 +173,8 @@ module Autoproj
             Autoproj::OSDependencies.define_osdeps_mode_option(config)
             osdeps.load_default
             osdeps.osdeps_mode
+
+            install_ruby_shims
         end
 
         def install_ruby_shims
@@ -220,7 +222,7 @@ module Autoproj
             did_update =
                 begin
                     saved_flag = PackageManagers::GemManager.with_prerelease
-                    PackageManagers::GemManager.with_prerelease = Autoproj.config.use_prerelease?
+                    PackageManagers::GemManager.with_prerelease = config.use_prerelease?
                     osdeps.install(%w{autobuild autoproj})
                 ensure
                     PackageManagers::GemManager.with_prerelease = saved_flag
@@ -346,7 +348,7 @@ module Autoproj
                 next if manifest.has_package_set?(pkg_or_set)
 
                 # This is not known. Check if we can auto-add it
-                full_path = File.expand_path(File.join(Autoproj.root_dir, layout_level, pkg_or_set))
+                full_path = File.expand_path(File.join(root_dir, layout_level, pkg_or_set))
                 next if !File.directory?(full_path)
 
                 handler, srcdir = Autoproj.package_handler_for(full_path)
@@ -446,19 +448,23 @@ module Autoproj
             pkg = manifest.find_autobuild_package(pkg_name)
             pkg.srcdir = File.join(root_dir, srcdir)
             if pkg.respond_to?(:builddir)
-                # If we're given an absolute build dir, we have to append the
-                # package name to it to make it unique
-                if Pathname.new(build_dir).absolute?
-                    pkg.builddir = File.join(build_dir, pkg_name)
-                else
-                    pkg.builddir = build_dir
-                end
+                pkg.builddir = compute_builddir(pkg)
             end
 
             pkg.prefix = File.join(prefix_dir, prefixdir)
             pkg.doc_target_dir = File.join(prefix_dir, 'doc', pkg_name)
             pkg.logdir = File.join(pkg.prefix, "log")
         end
+        
+        def compute_builddir(pkg)
+            # If we're given an absolute build dir, we have to append the
+            # package name to it to make it unique
+            if Pathname.new(build_dir).absolute?
+                File.join(build_dir, pkg.name)
+            else
+                build_dir
+            end
+        end
 
         # Finalizes the configuration loading
         #
@@ -479,7 +485,7 @@ module Autoproj
                 load_if_present(source, source.local_dir, "overrides.rb")
             end
 
-            Dir.glob(File.join( Autoproj.overrides_dir, "*.rb" ) ).sort.each do |file|
+            Dir.glob(File.join( overrides_dir, "*.rb" ) ).sort.each do |file|
                 load file
             end
         end
@@ -499,37 +505,54 @@ module Autoproj
                 end
             end
 
-            setup_environment_from_packages
-
             # We now have processed the process setup blocks. All configuration
             # should be done and we can save the configuration data.
             config.save
         end
 
-        def setup_environment_from_packages
-            set_as_main_workspace
-            manifest.reused_installations.each do |reused_manifest|
-                reused_manifest.each do |pkg|
-                    # The reused installations might have packages we do not
-                    # know about, just ignore them
-                    if pkg = manifest.find_autobuild_package(pkg)
-                        pkg.update_environment
-                    end
-                end
+        def all_present_packages
+            manifest.each_autobuild_package.
+                find_all { |pkg| File.directory?(pkg.srcdir) }.
+                map(&:name)
+        end
+
+        def export_installation_manifest(package_names = all_present_packages)
+            install_manifest = InstallationManifest.new(root_dir)
+            if install_manifest.exist?
+                install_manifest.load
+            end
+            # Delete obsolete entries
+            install_manifest.delete_if do |pkg|
+                !manifest.find_autobuild_package(pkg.name) ||
+                    !File.directory?(pkg.srcdir)
             end
+            # Update the new entries
+            package_names.each do |pkg_name|
+                install_manifest[pkg_name] =
+                    manifest.find_autobuild_package(pkg_name)
+            end
+            # And save
+            install_manifest.save
+        end
 
-            # Make sure that we have the environment of all selected packages
-            manifest.all_selected_packages(false).each do |pkg_name|
-                manifest.find_autobuild_package(pkg_name).update_environment
+        def export_env_sh(package_names = all_present_packages, shell_helpers: true)
+            env = self.env.dup
+            manifest.all_selected_packages.each do |pkg_name|
+                pkg = manifest.find_autobuild_package(pkg_name)
+                if File.directory?(pkg.srcdir) && !pkg.applied_post_install?
+                    pkg.apply_post_install
+                end
+
+                pkg.apply_env(env)
             end
+            env.export_env_sh(shell_helpers: shell_helpers)
         end
 
-        def export_installation_manifest
-            File.open(File.join(root_dir, ".autoproj-installation-manifest"), 'w') do |io|
-                manifest.all_selected_packages(false).each do |pkg_name|
-                    if pkg = manifest.find_autobuild_package(pkg_name)
-                        io.puts "#{pkg_name},#{pkg.srcdir},#{pkg.prefix}"
-                    end
+        def apply_post_install
+            manifest.all_selected_packages.each do |pkg_name|
+                pkg = manifest.find_autobuild_package(pkg_name)
+                if File.directory?(pkg.srcdir) && !pkg.applied_post_install?
+                    pkg.apply_post_install
                 end
             end
         end

data/shell/autoproj_sh

@@ -1,6 +1,6 @@
 acd() {
     local pkg_path
-    pkg_path=$(autoproj locate $1)
+    pkg_path=$(autoproj locate "$@")
 
     if [ $? != 0 ]; then
       return 1

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: autoproj
 version: !ruby/object:Gem::Version
-  version: 2.0.0.b1
+  version: 2.0.0.b2
 platform: ruby
 authors:
 - Rock Core Developers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-17 00:00:00.000000000 Z
+date: 2015-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: autobuild
@@ -70,6 +70,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.0
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.19.1
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement