autoproj 1.13.7 → 2.0.0.b1

data/lib/autoproj/ops/loader.rb

@@ -1,15 +1,21 @@
 module Autoproj
     module Ops
     class Loader
+        # The path w.r.t. which we should resolve relative paths
+        #
+        # @return [String]
+        attr_reader :root_dir
         # @return [Array<String>] information about what is being loaded
         attr_reader :file_stack
 
-        def initialize
+        def initialize(root_dir)
+            @root_dir = root_dir
             @file_stack = Array.new
+            @loaded_autobuild_files = Set.new
         end
 
         def in_package_set(pkg_set, path)
-            @file_stack.push([pkg_set, File.expand_path(path).gsub(/^#{Regexp.quote(Autoproj.root_dir)}\//, '')])
+            @file_stack.push([pkg_set, File.expand_path(path).gsub(/^#{Regexp.quote(root_dir)}\//, '')])
             yield
         ensure
             @file_stack.pop
@@ -61,7 +67,7 @@ module Autoproj
         # @param [Array<String>] path
         def load(pkg_set, *path)
             path = File.join(*path)
-            in_package_set(pkg_set, File.expand_path(path).gsub(/^#{Regexp.quote(Autoproj.root_dir)}\//, '')) do
+            in_package_set(pkg_set, File.expand_path(path).gsub(/^#{Regexp.quote(root_dir)}\//, '')) do
                 begin
                     Kernel.load path
                 rescue Interrupt
@@ -83,14 +89,18 @@ module Autoproj
                 load(pkg_set, *path)
             end
         end
+
+        def import_autobuild_file(package_set, path)
+            return if @loaded_autobuild_files.include?(path)
+            load(package_set, path)
+            @loaded_autobuild_files << path
+        end
     end
 
-    # Singleton object that maintains the loading state
-    #
-    # Note that it is here hopefully temporarily. All the Ops classes should
-    # have their loader object given at construction time
+    # @deprecated use Autoproj.workspace, or better make sure all ops classes
+    #   get their own workspace object as argument
     def self.loader
-        @loader ||= Loader.new
+        Autoproj.workspace
     end
     end
 end

data/lib/autoproj/ops/main_config_switcher.rb

@@ -3,10 +3,10 @@ module Autoproj
         # Operations that modify the source of the main configuration (bootstrap
         # and switch-config)
         class MainConfigSwitcher
-            attr_reader :root_dir
+            attr_reader :ws
 
-            def initialize(root_dir)
-                @root_dir = root_dir
+            def initialize(ws)
+                @ws = ws
             end
 
             # Set of directory entries that are expected to be present in the
@@ -25,7 +25,8 @@ module Autoproj
                 return if ENV['AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR'] == '1'
 
                 require 'set'
-                curdir_entries = Dir.entries('.').to_set - EXPECTED_ROOT_ENTRIES
+                curdir_entries = Dir.entries(ws.root_dir).map { |p| File.basename(p) }.to_set - 
+                    EXPECTED_ROOT_ENTRIES
                 return if curdir_entries.empty?
 
                 while true
@@ -52,14 +53,14 @@ module Autoproj
             # bootstrap
             #
             # AUTOPROJ_CURRENT_ROOT must be set to either the new root
-            # ({root_dir}) or a root that we are reusing
+            # ({ws.root_dir}) or a root that we are reusing
             #
             # @param [Array<String>] reuse set of autoproj roots that are being reused
             # @raise ConfigError
             def validate_autoproj_current_root(reuse)
                 if current_root = ENV['AUTOPROJ_CURRENT_ROOT']
                     # Allow having a current root only if it is being reused
-                    if (current_root != root_dir) && !reuse.include?(current_root)
+                    if (current_root != ws.root_dir) && !reuse.include?(current_root)
                         Autoproj.error "the env.sh from #{ENV['AUTOPROJ_CURRENT_ROOT']} seem to already be sourced"
                         Autoproj.error "start a new shell and try to bootstrap again"
                         Autoproj.error ""
@@ -70,56 +71,31 @@ module Autoproj
                 end
             end
 
-            def handle_bootstrap_options(args)
-                reuse = []
-                parser = OptionParser.new do |opt|
-                    opt.on '--reuse [DIR]', "reuse the given autoproj installation (can be given multiple times). If given without arguments, reuse the currently active install (#{ENV['AUTOPROJ_CURRENT_ROOT']})" do |path|
-                        path ||= ENV['AUTOPROJ_CURRENT_ROOT']
-
-                        path = File.expand_path(path)
-                        if !File.directory?(path) || !File.directory?(File.join(path, 'autoproj'))
-                            raise ConfigError.new, "#{path} does not look like an autoproj installation"
-                        end
-                        reuse << path
-                    end
-                end
-                Tools.common_options(parser)
-                args = parser.parse(args)
-                return args, reuse
-            end
-
             MAIN_CONFIGURATION_TEMPLATE = File.expand_path(File.join("..", "..", "..", "samples", 'autoproj'), File.dirname(__FILE__))
 
-            def bootstrap(*args)
-                check_root_dir_empty
-                args, reuse = handle_bootstrap_options(args)
-                validate_autoproj_current_root(reuse)
-
-                Autoproj.root_dir = root_dir
-                Autobuild.prefix  = Autoproj.build_dir
-                Autobuild.srcdir  = Autoproj.root_dir
-                Autobuild.logdir = File.join(Autobuild.prefix, 'log')
+            def bootstrap(buildconf_info, options = Hash.new)
+                options = validate_options options,
+                    reuse: Array.new
 
-                manifest = Autoproj.manifest = Manifest.new
-                Tools.load_autoprojrc
-                Autoproj.prepare_environment
+                check_root_dir_empty
+                validate_autoproj_current_root(options[:reuse])
 
-                Autoproj::OSDependencies.define_osdeps_mode_option
-                manifest.osdeps.load_default
-                manifest.osdeps.osdeps_mode
+                ws.config.validate_ruby_executable
 
-                CmdLine.update_myself :force => true, :restart_on_update => false
-                Autoproj.change_option 'reused_autoproj_installations', reuse, true
-                Autoproj.export_env_sh
+                PackageManagers::GemManager.with_prerelease(ws.config.use_prerelease?) do
+                    ws.osdeps.install(%w{autobuild autoproj})
+                end
+                ws.config.set 'reused_autoproj_installations', options[:reuse], true
+                ws.env.export_env_sh(nil, shell_helpers: ws.config.shell_helpers?)
 
                 # If we are not getting the installation setup from a VCS, copy the template
                 # files
-                if args.empty? || args.size == 1
+                if buildconf_info.empty? || buildconf_info.size == 1
                     FileUtils.cp_r MAIN_CONFIGURATION_TEMPLATE, "autoproj"
                 end
 
-                if args.size == 1 # the user asks us to download a manifest
-                    manifest_url = args.first
+                if buildconf_info.size == 1 # the user asks us to download a manifest
+                    manifest_url = buildconf_info.first
                     Autoproj.message("autoproj: downloading manifest file #{manifest_url}", :bold)
                     manifest_data =
                         begin open(manifest_url) { |file| file.read }
@@ -133,20 +109,17 @@ module Autoproj
                         io.write(manifest_data)
                     end
 
-                elsif args.size >= 2 # is a VCS definition for the manifest itself ...
-                    type, url, *options = *args
+                elsif buildconf_info.size >= 2 # is a VCS definition for the manifest itself ...
+                    type, url, *options = *buildconf_info
                     url = VCSDefinition.to_absolute_url(url, Dir.pwd)
                     do_switch_config(false, type, url, *options)
                 end
-                Autoproj.save_config
+                ws.env.export_env_sh(nil, shell_helpers: ws.config.shell_helpers?)
+                ws.config.save
             end
 
             def switch_config(*args)
-                Autoproj.load_config
-                if Autoproj.has_config_key?('manifest_source')
-                    vcs = VCSDefinition.from_raw(Autoproj.user_config('manifest_source'))
-                end
-
+                vcs = ws.config.get('manifest_source', nil)
                 if args.first =~ /^(\w+)=/
                     # First argument is an option string, we are simply setting the
                     # options without changing the type/url
@@ -159,17 +132,14 @@ module Autoproj
                 url = VCSDefinition.to_absolute_url(url)
 
                 if vcs && (vcs.type == type && vcs.url == url)
-                    # Don't need to do much: simply change the options and save the config
-                    # file, the VCS handler will take care of the actual switching
-                    vcs_def = Autoproj.user_config('manifest_source')
                     options.each do |opt|
                         opt_name, opt_value = opt.split('=')
-                        vcs_def[opt_name] = opt_value
+                        vcs[opt_name] = opt_value
                     end
                     # Validate the VCS definition, but save the hash as-is
-                    VCSDefinition.from_raw(vcs_def)
-                    Autoproj.change_option "manifest_source", vcs_def.dup, true
-                    Autoproj.save_config
+                    VCSDefinition.from_raw(vcs)
+                    ws.config.set "manifest_source", vcs.dup, true
+                    ws.config.save
                     true
 
                 else
@@ -180,13 +150,13 @@ module Autoproj
 
                     return if !opt.ask(nil)
 
-                    Dir.chdir(Autoproj.root_dir) do
-                        do_switch_config(true, type, url, *options)
-                    end
+                    do_switch_config(true, type, url, *options)
                     false
                 end
+                ws.config.save
             end
 
+            # @api private
             def do_switch_config(delete_current, type, url, *options)
                 vcs_def = Hash.new
                 vcs_def[:type] = type
@@ -203,13 +173,10 @@ module Autoproj
                 vcs = VCSDefinition.from_raw(vcs_def)
 
                 # Install the OS dependencies required for this VCS
-                Autoproj::OSDependencies.define_osdeps_mode_option
-                osdeps = Autoproj::OSDependencies.load_default
-                osdeps.osdeps_mode
-                osdeps.install([vcs.type])
+                ws.osdeps.install([vcs.type])
 
                 # Now check out the actual configuration
-                config_dir = File.join(Dir.pwd, "autoproj")
+                config_dir = File.join(ws.root_dir, "autoproj")
                 if delete_current
                     # Find a backup name for it
                     backup_base_name = backup_name = "#{config_dir}.bak"
@@ -221,14 +188,19 @@ module Autoproj
                         
                     FileUtils.mv config_dir, backup_name
                 end
-                Ops::Configuration.update_configuration_repository(
+
+                ops = Ops::Configuration.new(ws)
+                ops.update_configuration_repository(
                     vcs,
                     "autoproj main configuration",
                     config_dir)
 
-                # If the new tree has a configuration file, load it and set
+                # If the new tree has a configuration file, load it but override
+                # the already known parameters once it is loaded
+                current_config = ws.config
                 # manifest_source
-                Autoproj.load_config
+                ws.load_config
+                ws.config.merge(current_config)
 
                 # And now save the options: note that we keep the current option set even
                 # though we switched configuration. This is not a problem as undefined
@@ -243,8 +215,8 @@ module Autoproj
                 # Validate the option hash, just in case
                 VCSDefinition.from_raw(vcs_def)
                 # Save the new options
-                Autoproj.change_option "manifest_source", vcs_def.dup, true
-                Autoproj.save_config
+                ws.config.set "manifest_source", vcs_def.dup, true
+                ws.config.save
 
             rescue Exception => e
                 Autoproj.error "switching configuration failed: #{e.message}"

data/lib/autoproj/ops/snapshot.rb

@@ -165,25 +165,21 @@ module Autoproj
             pkg
         end
 
-        def import_state_log_ref
+        def self.import_state_log_ref
             "refs/autoproj"
         end
 
         DEFAULT_VERSIONS_FILE_BASENAME = "50-versions.yml"
 
         def import_state_log_file
-            File.join(OVERRIDES_DIR, DEFAULT_VERSIONS_FILE_BASENAME)
+            File.join(Workspace::OVERRIDES_DIR, DEFAULT_VERSIONS_FILE_BASENAME)
         end
 
         def current_import_state
             main = import_state_log_package
             # Try to resolve the log ref, and extract the version file from it
             begin
-                #package importer might be nil during bootstrapping
-                if main.importer.nil?
-                    return Array.new
-                end
-                yaml = main.importer.show(main, import_state_log_ref, import_state_log_file)
+                yaml = main.importer.show(main, self.class.import_state_log_ref, import_state_log_file)
                 YAML.load(yaml) || Array.new
             rescue Autobuild::PackageException
                 Array.new
@@ -191,7 +187,6 @@ module Autoproj
         end
 
         def update_package_import_state(name, packages)
-            return if import_state_log_package.importer.nil? #We cannot create states for packages without a importer
             current_versions = current_import_state
             if current_versions.empty?
                 # Do a full snapshot this time only
@@ -211,13 +206,13 @@ module Autoproj
             main = import_state_log_package
             git_dir = main.importer.git_dir(main, false)
             # Ensure that our ref is being logged
-            FileUtils.touch File.join(git_dir, 'logs', *import_state_log_ref.split("/"))
+            FileUtils.touch File.join(git_dir, 'logs', *self.class.import_state_log_ref.split("/"))
             # Create the commit with the versions info
             commit_id = Snapshot.create_commit(main, import_state_log_file, name) do |io|
                 YAML.dump(versions, io)
             end
             # And save it in our reflog
-            main.importer.run_git_bare(main, "update-ref", '-m', name, import_state_log_ref, commit_id)
+            main.importer.run_git_bare(main, "update-ref", '-m', name, self.class.import_state_log_ref, commit_id)
         end
 
         # Create a git commit in which a file contains provided content

data/lib/autoproj/ops/tools.rb

@@ -48,26 +48,20 @@ module Autoproj
         end
 
         def load_autoprojrc
-            # Load the user-wide autoproj RC file
-            home_dir =
-                begin Dir.home
-                rescue ArgumentError
-                end
-
-            if home_dir
-                rcfile = File.join(home_dir, '.autoprojrc')
-                if File.file?(rcfile)
-                    Kernel.load rcfile
-                end
-            end
+            Autoproj.warn_deprecated __method__, "use workspace.load_autoprojrc instead"
+            Autoproj.workspace.load_autoprojrc
         end
 
-        def load_main_initrb(manifest = Autoproj.manifest)
-            local_source = LocalPackageSet.new(manifest)
-            Autoproj.load_if_present(local_source, local_source.local_dir, "init.rb")
+        def load_main_initrb(*args)
+            Autoproj.warn_deprecated __method__, "use workspace.load_main_initrb instead"
+            Autoproj.workspace.load_main_initrb
         end
 
         def common_options(parser)
+            parser.on '--silent' do
+                Autoproj.silent = true
+            end
+
             parser.on '--verbose' do
                 Autoproj.verbose  = true
                 Autobuild.verbose = true
@@ -83,7 +77,7 @@ module Autoproj
             end
 
             parser.on("--[no-]color", "enable or disable color in status messages (enabled by default)") do |flag|
-                Autoproj::CmdLine.color = flag
+                Autoproj.color = flag
                 Autobuild.color = flag
             end
 
@@ -92,34 +86,6 @@ module Autoproj
             end
         end
 
-        def resolve_selection(user_selection, options = Hash.new)
-            options = Kernel.validate_options options,
-                recursive: true,
-                ignore_non_imported_packages: false
-
-            resolved_selection = CmdLine.
-                resolve_user_selection(user_selection, filter: false)
-            if options[:ignore_non_imported_packages]
-                manifest.each_autobuild_package do |pkg|
-                    if !File.directory?(pkg.srcdir)
-                        manifest.ignore_package(pkg.name)
-                    end
-                end
-            end
-            resolved_selection.filter_excluded_and_ignored_packages(manifest)
-
-            packages =
-                if options[:recursive]
-                    CmdLine.import_packages(
-                        resolved_selection,
-                        warn_about_ignored_packages: false)
-                else
-                    resolved_selection.to_a
-                end
-
-            packages
-        end
-
         extend Tools
     end
     end

data/lib/autoproj/options.rb

@@ -1,54 +1,83 @@
 module Autoproj
     # @deprecated use config.override instead
     def self.override_option(option_name, value)
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
         config.override(option_name, value)
     end
     # @deprecated use config.reset instead
     def self.reset_option(key)
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
         config.reset(key)
     end
     # @deprecated use config.set(key, value, user_validated) instead
     def self.change_option(key, value, user_validated = false)
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
         config.set(key, value, user_validated)
     end
     # @deprecated use config.validated_values instead
     def self.option_set
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
         config.validated_values
     end
     # @deprecated use config.get(key) instead
     def self.user_config(key)
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
         config.get(key)
     end
     # @deprecated use config.declare(name, type, options, &validator) instead
     def self.configuration_option(name, type, options, &validator)
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
         config.declare(name, type, options, &validator)
     end
     # @deprecated use config.declared?(name, type, options, &validator) instead
     def self.declared_option?(name)
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
         config.declared?(name)
     end
     # @deprecated use config.configure(option_name) instead
     def self.configure(option_name)
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
         config.configure(option_name)
     end
     # @deprecated use config.has_value_for?(name)
     def self.has_config_key?(name)
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
         config.has_value_for?(name)
     end
+    # @deprecated use config.shell_helpers? instead
+    def self.shell_helpers?
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
+        config.shell_helpers?
+    end
+    # @deprecated use config.shell_helpers= instead
+    def self.shell_helpers=(flag)
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
+        config.shell_helpers = flag
+    end
 
     def self.save_config
-        config.save(File.join(Autoproj.config_dir, "config.yml"))
+        Autoproj.warn "#{__method__} is deprecated, use the API on Autoproj.config (from Autoproj::Configuration) instead"
+        caller.each { |bt| Autoproj.warn "  #{bt}" }
+        config.save
     end
 
     def self.config
-        @config ||= Configuration.new
+        workspace.config
     end
 
     def self.load_config
-        config_file = File.join(Autoproj.config_dir, "config.yml")
-        if File.exists?(config_file)
-            config.load(config_file, reconfigure?)
-        end
+        workspace.load_config
     end
 
     class << self