autoproj 1.13.7 → 2.0.0.b1

data/lib/autoproj/cli/switch_config.rb

@@ -0,0 +1,28 @@
+require 'autoproj'
+require 'autoproj/cli/base'
+require 'autoproj/ops/main_config_switcher'
+require 'autoproj/ops/configuration'
+
+module Autoproj
+    module CLI
+        class SwitchConfig < Base
+            def run(args, options = Hash.new)
+                if Dir.pwd.start_with?(ws.remotes_dir) || Dir.pwd.start_with?(ws.config_dir)
+                    raise ConfigError, "you cannot run autoproj switch-config from autoproj's configuration directory or one of its subdirectories"
+                end
+
+                # We must switch to the root dir first, as it is required by the
+                # configuration switch code. This is acceptable as long as we
+                # quit just after the switch
+                switcher = Ops::MainConfigSwitcher.new(ws)
+                if switcher.switch_config(*args)
+                    manifest = Manifest.load(File.join(ws.config_dir, 'manifest'))
+                    update = Ops::Configuration.new(ws, ws.loader)
+                    update.update_configuration
+                    ws.config.save
+                end
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/tag.rb

@@ -1,38 +1,12 @@
-require 'autoproj/cli'
+require 'autoproj'
 require 'autoproj/cli/versions'
+require 'autoproj/ops/snapshot'
+require 'autoproj/cli/base'
+
 module Autoproj
     module CLI
-        class Tag
-            include Ops::Tools
-
-            attr_reader :manifest
-
-            def initialize(manifest)
-                @manifest = manifest
-            end
-
-            def parse_options(args)
-                options = Hash[package_sets: true, keep_going: false]
-                parser = OptionParser.new do |opt|
-                    opt.on '--[no-]package-sets', 'commit the package set state as well (enabled by default)' do |flag|
-                        options[:package_sets] = flag
-                    end
-                    opt.on '-k', '--keep-going', "ignore packages that can't be snapshotted (the default is to terminate with an error)" do
-                        options[:keep_going] = true
-                    end
-                    opt.on '-m MESSAGE', '--message=MESSAGE', String, "the message to use for the new commit (defaults to mentioning the tag creation)" do |message|
-                        options[:message] = message
-                    end
-                end
-                common_options(parser)
-                remaining = parser.parse(args)
-                if remaining.size > 1
-                    raise InvalidArguments, "expected only the tag name as argument"
-                end
-                return remaining.first, options
-            end
-
-            def run(tag_name, options)
+        class Tag < Base
+            def run(tag_name, *user_selection, options = Hash.new)
                 pkg = manifest.main_package_set.create_autobuild_package
                 importer = pkg.importer
                 if !importer || !importer.kind_of?(Autobuild::Git)
@@ -40,7 +14,7 @@ module Autoproj
                 end
 
                 versions_file = File.join(
-                    OVERRIDES_DIR,
+                    Workspace::OVERRIDES_DIR,
                     Versions::DEFAULT_VERSIONS_FILE_BASENAME)
 
                 if tag_name.nil?
@@ -65,9 +39,9 @@ module Autoproj
                 message = options[:message] ||
                     "autoproj created tag #{tag_name}"
                 commit_id = Ops::Snapshot.create_commit(pkg, versions_file, message) do |io|
-                    versions = CLI::Versions.new(manifest)
+                    versions = CLI::Versions.new(ws)
                     Autoproj.message "creating versions file, this may take a while"
-                    versions.run(Array.new,
+                    versions.run(user_selection,
                                  package_sets: options[:package_sets],
                                  output_file: io.path,
                                  replace: true,

data/lib/autoproj/cli/test.rb

@@ -1,67 +1,48 @@
-require 'autoproj/ops/tools'
+require 'autoproj/cli/inspection_tool'
 
 module Autoproj
     module CLI
-        class Test
-            include Ops::Tools
-
-            attr_reader :manifest
-
-            def initialize(manifest)
-                @manifest = manifest
-            end
-
-            def parse_options(args)
-                Autoproj.load_config
-
-                modified_config = false
-                mode = nil
-                options = Hash.new
-                option_parser = OptionParser.new do |opt|
-                    opt.on '--enable[=PACKAGE,PACKAGE]', Array, 'enable tests for all packages or for specific packages (does not run the tests)' do |packages|
-                        if !packages
-                            Autoproj.config.utility_enable_all('test')
-                        else
-                            Autoproj.config.utility_enable_for('test', *packages)
-                        end
-                        modified_config = true
-                    end
-                    opt.on '--disable[=PACKAGE,PACKAGE]', Array, 'disable tests for all packages or for specific packages (does not run the tests)' do |packages|
-                        if !packages
-                            Autoproj.config.utility_disable_all('test')
-                        else
-                            Autoproj.config.utility_disable_for('test', *packages)
-                        end
-                        modified_config = true
-                    end
-                    opt.on '--list', 'list the test availability and enabled/disabled state information' do
-                        mode = 'list'
-                    end
-                    opt.on '--[no-]recursion', '(do not) run or list the tests of the dependencies of the packages given on the command line (the default is false)' do |flag|
-                        options[:recursive] = flag
-                    end
-                end
-
-                user_selection = option_parser.parse(ARGV)
-                if !mode && !(modified_config && user_selection.empty?)
-                    mode = 'run'
+        class Test < InspectionTool
+            def enable(user_selection, options = Hash.new)
+                if user_selection.empty?
+                    ws.load_config
+                    ws.config.utility_enable_all('test')
+                else
+                    initialize_and_load
+                    selection, _ = finalize_setup(
+                        user_selection,
+                        recursive: options[:deps],
+                        ignore_non_imported_packages: true)
+                    ws.config.utility_enable('test', *selection)
                 end
+                ws.config.save
+            end
 
-                if modified_config
-                    Autoproj.save_config
+            def disable(user_selection, options = Hash.new)
+                if user_selection.empty?
+                    ws.load_config
+                    ws.config.utility_disable_all('test')
+                else
+                    initialize_and_load
+                    selection, _ = finalize_setup(
+                        user_selection,
+                        recursive: options[:deps],
+                        ignore_non_imported_packages: true)
+                    ws.config.utility_disable('test', *selection)
                 end
-                return mode, user_selection, options
+                ws.config.save
             end
 
             def list(user_selection, options = Hash.new)
-                resolved_selection = resolve_selection(
+                initialize_and_load
+                resolved_selection, _ = finalize_setup(
                     user_selection,
-                    recursive: options[:recursive],
+                    recursive: options[:dep],
                     ignore_non_imported_packages: true)
 
                 lines = Array.new
                 resolved_selection.each do |pkg_name|
-                    pkg = manifest.find_package(pkg_name).autobuild
+                    pkg = ws.manifest.find_package(pkg_name).autobuild
                     lines << [pkg.name, pkg.test_utility.enabled?, pkg.test_utility.available?]
                 end
                 lines = lines.sort_by { |name, _| name }
@@ -74,11 +55,9 @@ module Autoproj
             end
 
             def run(user_selection, options = Hash.new)
-                packages = resolve_selection(
-                    user_selection,
-                    recursive: options[:recursive],
-                    ignore_non_imported_packages: true)
-                # This calls #prepare, which is required to run build_packages
+                initialize_and_load
+                packages, _ = finalize_setup(user_selection)
+
                 packages.each do |pkg|
                     Autobuild::Package[pkg].disable_phases('import', 'prepare', 'install')
                 end

data/lib/autoproj/cli/update.rb

@@ -0,0 +1,158 @@
+require 'autoproj/cli'
+require 'autoproj/cli/base'
+require 'autoproj/ops/import'
+
+module Autoproj
+    module CLI
+        class Update < Base
+            def validate_options(packages, options)
+                packages, options = super
+
+                if !options[:osdeps]
+                    options[:osdeps_mode] = Array.new
+                end
+
+                if from = options[:from]
+                    options[:from] = Autoproj::InstallationManifest.from_root(options[:from])
+                end
+                ws.osdeps.filter_uptodate_packages = options[:osdeps_filter_uptodate]
+
+                if options[:aup] && !options[:all] && packages.empty?
+                    packages = ['.']
+                end
+
+                if options[:autoproj].nil?
+                    options[:autoproj] = packages.empty?
+                end
+
+                return packages, options
+            end
+
+            def run(selected_packages, options)
+                selected_packages, config_selected =
+                    normalize_command_line_package_selection(selected_packages)
+
+                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
+                if options[:osdeps]
+                    ws.config.set(
+                        'operating_system',
+                        Autoproj::OSDependencies.operating_system(:force => true),
+                        true)
+                end
+
+                if options[:autoproj]
+                    ws.update_autoproj
+                end
+
+                ws.load_package_sets(
+                    only_local: options[:local],
+                    checkout_only: !options[:config] || options[:checkout_only],
+                    ignore_errors: options[:keep_going])
+                if selected_packages.empty? && config_selected
+                    return
+                end
+
+                ws.setup_all_package_directories
+                # Call resolve_user_selection once to auto-add packages
+                resolve_user_selection(selected_packages)
+                # Now we can finalize and re-resolve the selection since the
+                # overrides.rb files might have changed it
+                ws.finalize_package_setup
+                # Finally, filter out exclusions
+                resolved_selected_packages, _ =
+                    resolve_user_selection(selected_packages)
+                validate_user_selection(selected_packages, resolved_selected_packages)
+
+                if !selected_packages.empty?
+                    command_line_selection = resolved_selected_packages.dup
+                else
+                    command_line_selection = Array.new
+                end
+                selected_packages = resolved_selected_packages
+
+                if other_root = options[:from]
+                    setup_update_from(other_root)
+                end
+
+                osdeps_options = Hash[install_only: options[:checkout_only]]
+                if options[:osdeps_mode]
+                    osdeps_options[:osdeps_mode] = options[:osdeps_mode]
+                end
+
+                if options[:osdeps]
+                    # Install the osdeps for the version control
+                    vcs_to_install = Set.new
+                    selected_packages.each_source_package_name do |pkg_name|
+                        if pkg = ws.manifest.find_package(pkg_name)
+                            if pkg.vcs
+                                vcs_to_install << pkg.vcs.type
+                            end
+                        else
+                            raise "cannot find package #{pkg_name}"
+                        end
+                    end
+                    ws.osdeps.install(vcs_to_install, osdeps_options)
+                end
+
+                ops = Autoproj::Ops::Import.new(ws)
+                source_packages, osdep_packages = 
+                    ops.import_packages(selected_packages,
+                                    checkout_only: options[:checkout_only],
+                                    only_local: options[:local],
+                                    reset: options[:reset],
+                                    recursive: options[:deps],
+                                    ignore_errors: options[:keep_going])
+
+                ws.finalize_setup
+                load_all_available_package_manifests
+                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
+
+                return command_line_selection, source_packages, osdep_packages
+            end
+
+            def load_all_available_package_manifests
+                # Load the manifest for packages that are already present on the
+                # file system
+                ws.manifest.packages.each_value do |pkg|
+                    if File.directory?(pkg.autobuild.srcdir)
+                        begin
+                            ws.manifest.load_package_manifest(pkg.autobuild.name)
+                        rescue Interrupt
+                            raise
+                        rescue Exception => e
+                            Autoproj.warn "cannot load package manifest for #{pkg.autobuild.name}: #{e.message}"
+                        end
+                    end
+                end
+            end
+
+            def setup_update_from(other_root)
+                manifest.each_autobuild_package do |pkg|
+                    if pkg.importer.respond_to?(:pick_from_autoproj_root)
+                        if !pkg.importer.pick_from_autoproj_root(pkg, other_root)
+                            pkg.update = false
+                        end
+                    else
+                        pkg.update = false
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/versions.rb

@@ -1,91 +1,54 @@
 require 'autoproj'
-require 'autoproj/cmdline'
+require 'autoproj/cli/inspection_tool'
 require 'autoproj/ops/tools'
 require 'autoproj/ops/snapshot'
 
 module Autoproj
     module CLI
-        class Versions
-            include Ops::Tools
-
+        class Versions < InspectionTool
             DEFAULT_VERSIONS_FILE_BASENAME = Ops::Snapshot::DEFAULT_VERSIONS_FILE_BASENAME
 
             def default_versions_file
                 File.join( Autoproj.overrides_dir, DEFAULT_VERSIONS_FILE_BASENAME )
             end
 
-            attr_reader :manifest
-
-            def initialize(manifest)
-                @manifest = manifest
-            end
-
-            def resolve_selection( user_selection )
-                resolved_selection = CmdLine.
-                    resolve_user_selection(user_selection, :filter => false)
-                resolved_selection.filter_excluded_and_ignored_packages(manifest)
-                # This calls #prepare, which is required to run build_packages
-                packages = CmdLine.import_packages(resolved_selection)
-
-                # Remove non-existing packages
-                packages.each do |pkg|
-                    if !File.directory?(manifest.package(pkg).autobuild.srcdir)
-                        raise ConfigError, "cannot commit #{pkg} as it is not checked out"
-                    end
+            def validate_options(packages, options = Hash.new)
+                packages, options = super
+                if options.has_key?(:save)
+                    options[:save] = case options[:save]
+                                     when '.'
+                                         nil
+                                     when true
+                                         default_versions_file
+                                     else
+                                         options[:save].to_str
+                                     end
                 end
-                packages
-            end
-
-
-            def parse_options(args)
-                options = Hash.new
-                parser = OptionParser.new do |opt|
-                    opt.on '--[no-]package-sets', 'commit the package set state as well (default if no packages are selected)' do |flag|
-                        options[:package_sets] = flag
-                    end
-                    opt.on '--replace', String, 'if the file given to --save exists, replace it instead of updating it' do
-                        options[:replace] = true
-                    end
-                    opt.on '-k', '--keep-going', "ignore packages that can't be snapshotted (the default is to terminate with an error)" do
-                        options[:keep_going] = true
-                    end
-                    opt.on '--save[=FILE]', String, "the file into which the versions should be saved (if no file is given, defaults to #{default_versions_file})" do |file|
-                        options[:output_file] =
-                            if file == '-'
-                                nil
-                            elsif !file
-                                default_versions_file
-                            else
-                                file
-                            end
-                    end
-                end
-                common_options(parser)
-                remaining = parser.parse(args)
-                return remaining, options
+                return packages, options
             end
 
             def run(user_selection, options)
-                do_package_sets = options[:package_sets]
-                if do_package_sets.nil? && user_selection.empty?
-                    do_package_sets = true
+                initialize_and_load
+                packages, *, config_selected =
+                    finalize_setup(user_selection,
+                                   ignore_non_imported_packages: true)
+
+                if (config_selected || user_selection.empty?) && (options[:package_sets] != false)
+                    options[:package_sets] = true
                 end
 
-                CmdLine.report(silent: true) do
-                    packages = resolve_selection user_selection
-                    ops = Ops::Snapshot.new(manifest, keep_going: options[:keep_going])
+                ops = Ops::Snapshot.new(ws.manifest, keep_going: options[:keep_going])
 
-                    versions = Array.new
-                    if do_package_sets
-                        versions += ops.snapshot_package_sets
-                    end
-                    versions += ops.snapshot_packages(packages)
-                    if output_file = options[:output_file]
-                        ops.save_versions(versions, output_file, replace: options[:replace])
-                    else
-                        versions = ops.sort_versions(versions)
-                        puts YAML.dump(versions)
-                    end
+                versions = Array.new
+                if options[:package_sets]
+                    versions += ops.snapshot_package_sets
+                end
+                versions += ops.snapshot_packages(packages)
+                if output_file = options[:save]
+                    ops.save_versions(versions, output_file, replace: options[:replace])
+                else
+                    versions = ops.sort_versions(versions)
+                    puts YAML.dump(versions)
                 end
             end
         end