autoproj 2.0.0.rc37 → 2.0.0.rc38

data/lib/autoproj/version.rb

@@ -1,3 +1,3 @@
 module Autoproj
-    VERSION = "2.0.0.rc37"
+    VERSION = "2.0.0.rc38"
 end

data/lib/autoproj/workspace.rb

@@ -15,20 +15,25 @@ class Workspace < Ops::Loader
 
         attr_reader :loader
 
-        def os_package_resolver; manifest.os_package_resolver end
+        attr_reader :os_package_resolver
         attr_reader :os_package_installer
 
-        def initialize(root_dir)
+        def initialize(root_dir,
+                       os_package_resolver: OSPackageResolver.new,
+                       package_managers: OSPackageInstaller::PACKAGE_MANAGERS)
             @root_dir = root_dir
 
             @loader = loader
             @env = Environment.new
+            env.prepare(root_dir)
             env.source_before(File.join(dot_autoproj_dir, 'env.sh'))
-            @manifest = Manifest.new
-            @config = Configuration.new
 
-            @os_package_installer = OSPackageInstaller.new(self, os_package_resolver)
-            env.prepare(root_dir)
+            @os_package_resolver = os_package_resolver
+            @manifest = Manifest.new(self, os_package_resolver: os_package_resolver)
+            @config = Configuration.new(config_file_path)
+
+            @os_package_installer = OSPackageInstaller.new(
+                self, os_package_resolver, package_managers: package_managers)
             super(root_dir)
         end
 
@@ -48,8 +53,8 @@ def self.autoproj_current_root
         #
         # @return [Workspace]
         # @raise (see from_dir)
-        def self.from_pwd
-            from_dir(Dir.pwd)
+        def self.from_pwd(**workspace_options)
+            from_dir(Dir.pwd, **workspace_options)
         end
 
         # Returns the workspace a directory is part of
@@ -58,9 +63,9 @@ def self.from_pwd
         # @raise [MismatchingWorkspace] if the currently loaded env.sh
         #   and the one from +dir+ mismatch
         # @raise [NotWorkspace] if dir is not within an autoproj workspace
-        def self.from_dir(dir)
+        def self.from_dir(dir, **workspace_options)
             if path = Autoproj.find_workspace_dir(dir)
-                Workspace.new(path)
+                Workspace.new(path, **workspace_options)
             elsif Autoproj.find_v1_workspace_dir(dir)
                 raise OutdatedWorkspace, "#{dir} looks like a v1 workspace, run autoproj upgrade before continuing"
             else
@@ -68,9 +73,9 @@ def self.from_dir(dir)
             end
         end
 
-        def self.from_environment
+        def self.from_environment(**workspace_options)
             if path = Autoproj.find_workspace_dir
-                from_dir(path)
+                from_dir(path, **workspace_options)
             elsif Autoproj.find_v1_workspace_dir(dir = Autoproj.default_find_base_dir)
                 raise OutdatedWorkspace, "#{dir} looks like a v1 workspace, run autoproj upgrade before continuing"
             elsif envvar = ENV['AUTOPROJ_CURRENT_ROOT']
@@ -94,8 +99,8 @@ def self.in_autoproj_project?(path)
         # @raise MismatchingWorkspace if the workspace pointed by
         # AUTOPROJ_CURRENT_ROOT does not match the one containing the current
         # directory
-        def self.default
-            ws = from_environment
+        def self.default(**workspace_options)
+            ws = from_environment(**workspace_options)
             if (from_pwd = Autoproj.find_workspace_dir(Dir.pwd)) && (from_pwd != ws.root_dir)
                 raise MismatchingWorkspace, "the current environment points to #{ws.root_dir}, but you are in #{from_pwd}, make sure you are loading the right #{ENV_FILENAME} script !"
             end
@@ -125,7 +130,7 @@ def dot_autoproj_dir
 
         # The installation manifest
         def installation_manifest_path
-            InstallationManifest.path_for_root(root_dir)
+            InstallationManifest.path_for_workspace_root(root_dir)
         end
 
         # The path to the workspace configuration file
@@ -196,11 +201,15 @@ def load_config(reconfigure = false)
                         type: 'local', url: config_dir)
                 end
                 os_package_resolver.prefer_indep_over_os_packages = config.prefer_indep_over_os_packages?
-                OSPackageResolver.operating_system ||= config.get('operating_system', nil)
+                os_package_resolver.operating_system ||= config.get('operating_system', nil)
             end
             @config
         end
 
+        def save_config
+            config.save(config_file_path)
+        end
+
         def load_manifest
             if File.exist?(manifest_file_path)
                 manifest.load(manifest_file_path)
@@ -213,7 +222,7 @@ def autodetect_operating_system(force: false)
                     Autobuild.progress_start :operating_system_autodetection,
                         "autodetecting the operating system"
                     names, versions = OSPackageResolver.autodetect_operating_system
-                    OSPackageResolver.operating_system = [names, versions]
+                    os_package_resolver.operating_system = [names, versions]
                     Autobuild.progress :operating_system_autodetection,
                         "operating system: #{(names - ['default']).join(",")} - #{(versions - ['default']).join(",")}"
                 ensure
@@ -266,7 +275,6 @@ def setup
             if cache_dir = config.importer_cache_dir
                 Autobuild::Importer.default_cache_dirs = cache_dir
             end
-            env.prepare(root_dir)
             setup_os_package_installer
             install_ruby_shims
         end
@@ -317,20 +325,23 @@ def update_autoproj(restart_on_update: true)
 
             gemfile  = File.join(dot_autoproj_dir, 'Gemfile')
             binstubs = File.join(dot_autoproj_dir, 'bin')
-            old_autoproj_path = PackageManagers::BundlerManager.bundle_gem_path(
-                self, 'autoproj', gemfile: gemfile)
+            if restart_on_update
+                old_autoproj_path = PackageManagers::BundlerManager.bundle_gem_path(
+                    self, 'autoproj', gemfile: gemfile)
+            end
             begin
                 PackageManagers::BundlerManager.run_bundler_install(
                     self, gemfile, binstubs: binstubs)
             ensure
                 Ops::Install.rewrite_shims(binstubs, config.ruby_executable, gemfile, config.gems_gem_home)
             end
-            new_autoproj_path = PackageManagers::BundlerManager.bundle_gem_path(
-                self, 'autoproj', gemfile: gemfile)
-
+            if restart_on_update
+                new_autoproj_path = PackageManagers::BundlerManager.bundle_gem_path(
+                    self, 'autoproj', gemfile: gemfile)
+            end
 
             # First things first, see if we need to update ourselves
-            if (new_autoproj_path != old_autoproj_path) && restart_on_update
+            if new_autoproj_path != old_autoproj_path
                 puts
                 Autoproj.message "autoproj has been updated, restarting"
                 puts
@@ -414,8 +425,11 @@ def load_autoprojrc
         #
         # @return [void]
         def load_osdeps_from_package_sets
-            manifest.each_osdeps_file do |pkg_set, file|
-                os_package_resolver.merge(pkg_set.load_osdeps(file))
+            manifest.each_package_set do |pkg_set|
+                pkg_set.each_osdeps_file do |file|
+                    file_osdeps = pkg_set.load_osdeps(file, operating_system: os_package_resolver.operating_system)
+                    os_package_resolver.merge(file_osdeps)
+                end
             end
         end
 
@@ -457,8 +471,10 @@ def load_package_sets(options = Hash.new)
                 Autoproj.message("and use 'autoproj switch-config' to change the remote source for", :bold)
                 Autoproj.message("autoproj's main build configuration", :bold)
             end
-            manifest.each_autobuild_file do |source, name|
-                import_autobuild_file source, name
+            manifest.each_package_set do |pkg_set|
+                pkg_set.each_autobuild_file do |path|
+                    import_autobuild_file pkg_set, path
+                end
             end
 
             # Now, load the package's importer configurations (from the various
@@ -485,7 +501,7 @@ def load_package_sets(options = Hash.new)
                 handler, _srcdir = Autoproj.package_handler_for(full_path)
                 if handler
                     Autoproj.message "  auto-adding #{pkg_or_set} #{"in #{layout_level} " if layout_level != "/"}using the #{handler.gsub(/_package/, '')} package handler"
-                    in_package_set(manifest.local_package_set, manifest.file) do
+                    in_package_set(manifest.main_package_set, manifest.file) do
                         send(handler, pkg_or_set)
                     end
                 else
@@ -516,11 +532,11 @@ def mark_unavailable_osdeps_as_excluded
 
                 case os_package_resolver.availability_of(osdep_name)
                 when OSPackageResolver::UNKNOWN_OS
-                    manifest.add_exclusion(osdep_name, "this operating system is unknown to autoproj")
+                    manifest.exclude_package(osdep_name, "this operating system is unknown to autoproj")
                 when OSPackageResolver::WRONG_OS
-                    manifest.add_exclusion(osdep_name, "there are definitions for it, but not for this operating system")
+                    manifest.exclude_package(osdep_name, "there are definitions for it, but not for this operating system")
                 when OSPackageResolver::NONEXISTENT
-                    manifest.add_exclusion(osdep_name, "it is marked as unavailable for this operating system")
+                    manifest.exclude_package(osdep_name, "it is marked as unavailable for this operating system")
                 end
             end
         end
@@ -538,14 +554,14 @@ def setup_all_package_directories
             manifest.reused_installations.each do |imported_manifest|
                 imported_manifest.each do |imported_pkg|
                     imported_packages << imported_pkg.name
-                    if pkg = manifest.find_package(imported_pkg.name)
+                    if pkg = manifest.find_package_definition(imported_pkg.name)
                         pkg.autobuild.srcdir = imported_pkg.srcdir
                         pkg.autobuild.prefix = imported_pkg.prefix
                     end
                 end
             end
 
-            manifest.packages.each_value do |pkg_def|
+            manifest.each_package_definition do |pkg_def|
                 pkg = pkg_def.autobuild
                 next if imported_packages.include?(pkg_def.name)
                 setup_package_directories(pkg)
@@ -604,7 +620,7 @@ def finalize_package_setup
             set_as_main_workspace
             # Now call the blocks that the user defined in the autobuild files. We do it
             # now so that the various package directories are properly setup
-            manifest.packages.each_value do |pkg|
+            manifest.each_package_definition do |pkg|
                 pkg.user_blocks.each do |blk|
                     blk[pkg.autobuild]
                 end
@@ -617,8 +633,9 @@ def finalize_package_setup
                 end
             end
 
+            main_package_set = manifest.main_package_set
             Dir.glob(File.join( overrides_dir, "*.rb" ) ).sort.each do |file|
-                load file
+                load main_package_set, file
             end
         end
 
@@ -628,13 +645,8 @@ def finalize_package_setup
         # have been properly set up (a.k.a. after package import)
         def finalize_setup
             # Finally, disable all ignored packages on the autobuild side
-            manifest.each_ignored_package do |pkg_name|
-                pkg = manifest.find_autobuild_package(pkg_name)
-                if !pkg
-                    Autoproj.warn "ignore line #{pkg_name} does not match anything"
-                else
-                    pkg.disable
-                end
+            manifest.each_ignored_package do |pkg|
+                pkg.disable
             end
 
             # We now have processed the process setup blocks. All configuration
@@ -652,20 +664,18 @@ def all_present_packages
         #
         # @param [Array<String>] package_names the name of the packages that
         #   should be updated
-        def export_installation_manifest(package_names = all_present_packages)
+        def export_installation_manifest
+            selected_packages = manifest.all_selected_source_packages
             install_manifest = InstallationManifest.new(installation_manifest_path)
-            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)
+            manifest.each_package_set do |pkg_set|
+                next if pkg_set.main?
+                install_manifest.add_package_set(pkg_set)
+            end
+            selected_packages.each do |pkg_name|
+                pkg = manifest.package_definition_by_name(pkg_name)
+                install_manifest.add_package(pkg)
             end
             # And save
             install_manifest.save
@@ -674,9 +684,8 @@ def export_installation_manifest(package_names = all_present_packages)
         # Export the workspace's env.sh file
         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)
-                pkg.apply_env(env)
+            manifest.all_selected_source_packages.each do |pkg|
+                pkg.autobuild.apply_env(env)
             end
             env.export_env_sh(shell_helpers: shell_helpers)
         end
@@ -685,33 +694,60 @@ def pristine_os_packages(packages, options = Hash.new)
             os_package_installer.pristine(packages, options)
         end
 
-        # Restores the OS dependencies required by the given packages to
-        # pristine conditions
+        # Returns the list of all OS packages required by the state of the
+        # workspace
         #
-        # This is usually called as a rebuild step to make sure that all these
-        # packages are updated to whatever required the rebuild
-        def pristine_os_packages_for(packages)
-            required_os_packages, package_os_deps =
-                manifest.list_os_packages(packages)
-            required_os_packages =
-                manifest.filter_os_packages(required_os_packages, package_os_deps)
-            pristine_os_packages(required_os_packages)
-        end
-
-        def install_os_packages(packages, options = Hash.new)
-            os_package_installer.install(packages, options)
+        # @return [Array<String>] the list of OS packages that can be fed to
+        #   {OSPackageManager#install}
+        def all_os_packages(import_missing: false, parallel: config.parallel_import_level)
+            if import_missing
+                ops = Autoproj::Ops::Import.new(self)
+                _, all_os_packages =
+                    ops.import_packages(manifest.default_packages,
+                                    checkout_only: true, only_local: true, reset: false,
+                                    recursive: true, ignore_errors: true, parallel: parallel,
+                                    retry_count: 0)
+                all_os_packages
+            else
+                result = Set.new
+                manifest.all_selected_source_packages.each do |source_package|
+                    result.merge(source_package.autobuild.os_packages)
+                end
+                result
+            end
         end
 
-        # Installs the OS dependencies that are required by the given packages
-        def install_os_packages_for(packages, options = Hash.new)
-            required_os_packages, package_os_deps =
-                manifest.list_os_packages(packages)
-            required_os_packages =
-                manifest.filter_os_packages(required_os_packages, package_os_deps)
-            install_os_packages(required_os_packages, options)
+        def install_os_packages(packages, all: all_os_packages, **options)
+            os_package_installer.install(packages, all: all, **options)
         end
 
-        # Register a package on this workspace
+        # Define and register an autobuild package on this workspace
+        #
+        # @param [Symbol] package_type a package-creation method on {Autobuild},
+        #   e.g. :cmake
+        # @param [String] package_name the package name
+        # @param [PackageSet] package_set the package set into which this
+        #   package is defined
+        # @param [String,nil] file the path to the file that defines this
+        #   package (used for error reporting)
+        # @param [Proc,nil] block a setup block that should be called to
+        #   configure the package
+        # @return [PackageDefinition]
+        def define_package(package_type, package_name, block = nil, package_set = manifest.main_package_set, file = nil)
+            autobuild_package = Autobuild.send(package_type, package_name)
+            register_package(autobuild_package, block, package_set, file)
+        end
+
+        # Register an autobuild package on this workspace
+        #
+        # @param [Autobuild::Package] package
+        # @param [PackageSet] package_set the package set into which this
+        #   package is defined
+        # @param [String,nil] file the path to the file that defines this
+        #   package (used for error reporting)
+        # @param [Proc,nil] block a setup block that should be called to
+        #   configure the package
+        # @return [PackageDefinition]
         def register_package(package, block = nil, package_set = manifest.main_package_set, file = nil)
             pkg = manifest.register_package(package, block, package_set, file)
             pkg.autobuild.ws = self

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: autoproj
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc37
+  version: 2.0.0.rc38
 platform: ruby
 authors:
 - Sylvain Joyeux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-02 00:00:00.000000000 Z
+date: 2016-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -198,6 +198,11 @@ files:
 - bin/autoproj_install.in
 - lib/autoproj.rb
 - lib/autoproj/autobuild.rb
+- lib/autoproj/autobuild_extensions/archive_importer.rb
+- lib/autoproj/autobuild_extensions/dsl.rb
+- lib/autoproj/autobuild_extensions/git.rb
+- lib/autoproj/autobuild_extensions/package.rb
+- lib/autoproj/autobuild_extensions/svn.rb
 - lib/autoproj/base.rb
 - lib/autoproj/build_option.rb
 - lib/autoproj/cli.rb
@@ -213,8 +218,10 @@ files:
 - lib/autoproj/cli/locate.rb
 - lib/autoproj/cli/log.rb
 - lib/autoproj/cli/main.rb
+- lib/autoproj/cli/main_plugin.rb
 - lib/autoproj/cli/main_test.rb
 - lib/autoproj/cli/osdeps.rb
+- lib/autoproj/cli/patcher.rb
 - lib/autoproj/cli/query.rb
 - lib/autoproj/cli/reconfigure.rb
 - lib/autoproj/cli/reset.rb
@@ -234,6 +241,7 @@ files:
 - lib/autoproj/git_server_configuration.rb
 - lib/autoproj/gitorious.rb
 - lib/autoproj/installation_manifest.rb
+- lib/autoproj/local_package_set.rb
 - lib/autoproj/manifest.rb
 - lib/autoproj/metapackage.rb
 - lib/autoproj/ops/build.rb