autoproj 1.13.7 → 2.0.0.b1

data/lib/autoproj/cli.rb

@@ -1,3 +1,4 @@
+require 'autobuild'
 module Autoproj
     module CLI
         class InvalidArguments < Autobuild::Exception

data/lib/autoproj/cli/base.rb

@@ -0,0 +1,155 @@
+require 'autoproj'
+require 'autoproj/autobuild'
+
+module Autoproj
+    module CLI
+        class Base
+            include Ops::Tools
+
+            attr_reader :ws
+
+            def initialize(ws = nil)
+                @ws = (ws || Workspace.from_environment)
+            end
+
+            # Normalizes the arguments given by the user on the command line
+            #
+            # This converts relative paths to full paths, and removes mentions
+            # of the configuration directory (as it is handled separately in
+            # autoproj)
+            #
+            # @return [(Array<String>,Boolean)] the normalized arguments that
+            #   could e.g. be passed to {#resolve_selection}, as well as whether
+            #   the config directory was selected or not
+            def normalize_command_line_package_selection(selection)
+                selection = selection.map do |name|
+                    if File.directory?(name)
+                        File.expand_path(name) + "/"
+                    else
+                        name
+                    end
+                end
+
+                config_selected = false
+                selection.delete_if do |name|
+                    if name =~ /^#{Regexp.quote(ws.config_dir)}(?:#{File::SEPARATOR}|$)/ ||
+                        name =~ /^#{Regexp.quote(ws.remotes_dir)}(?:#{File::SEPARATOR}|$)/
+                        config_selected = true
+                    elsif (ws.config_dir + File::SEPARATOR) =~ /^#{Regexp.quote(name)}/
+                        config_selected = true
+                        false
+                    end
+                end
+
+                return selection, config_selected
+            end
+
+            def resolve_user_selection(selected_packages, options = Hash.new)
+                if selected_packages.empty?
+                    return ws.manifest.default_packages
+                end
+                selected_packages = selected_packages.to_set
+
+                selected_packages, nonresolved = ws.manifest.
+                    expand_package_selection(selected_packages, options)
+
+                # Try to auto-add stuff if nonresolved
+                nonresolved.delete_if do |sel|
+                    next if !File.directory?(sel)
+                    while sel != '/'
+                        handler, srcdir = Autoproj.package_handler_for(sel)
+                        if handler
+                            Autoproj.message "  auto-adding #{srcdir} using the #{handler.gsub(/_package/, '')} package handler"
+                            srcdir = File.expand_path(srcdir)
+                            relative_to_root = Pathname.new(srcdir).relative_path_from(Pathname.new(ws.root_dir))
+                            pkg = ws.in_package_set(ws.manifest.main_package_set, ws.manifest.file) do
+                                send(handler, relative_to_root.to_s)
+                            end
+                            ws.setup_package_directories(pkg)
+                            selected_packages.select(sel, pkg.name, weak: true)
+                            break(true)
+                        end
+
+                        sel = File.dirname(sel)
+                    end
+                end
+
+                if Autoproj.verbose
+                    Autoproj.message "will install #{selected_packages.packages.to_a.sort.join(", ")}"
+                end
+                return selected_packages, nonresolved
+            end
+
+            def resolve_selection(manifest, user_selection, options = Hash.new)
+                options = Kernel.validate_options options,
+                    checkout_only: true,
+                    only_local: false,
+                    recursive: true,
+                    ignore_non_imported_packages: false
+
+                resolved_selection, _ = 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)
+
+                ops = Ops::Import.new(ws)
+                source_packages, osdep_packages = ops.import_packages(
+                    resolved_selection,
+                    checkout_only: options[:checkout_only],
+                    only_local: options[:only_local],
+                    recursive: options[:recursive],
+                    warn_about_ignored_packages: false)
+
+                return source_packages, osdep_packages, resolved_selection
+            end
+
+            def validate_user_selection(user_selection, resolved_selection)
+                not_matched = user_selection.find_all do |pkg_name|
+                    !resolved_selection.has_match_for?(pkg_name)
+                end
+                if !not_matched.empty?
+                    raise ConfigError.new, "autoproj: wrong package selection on command line, cannot find a match for #{not_matched.to_a.sort.join(", ")}"
+                end
+            end
+
+            def validate_options(args, options)
+                self.class.validate_options(args, options)
+            end
+
+            def self.validate_options(args, options)
+                options, remaining = filter_options options,
+                    silent: false,
+                    verbose: false,
+                    debug: false,
+                    color: true,
+                    progress: true
+
+                Autoproj.silent = options[:silent]
+                if options[:verbose]
+                    Autoproj.verbose  = true
+                    Autobuild.verbose = true
+                    Rake.application.options.trace = false
+                    Autobuild.debug = false
+                end
+
+                if options[:debug]
+                    Autoproj.verbose  = true
+                    Autobuild.verbose = true
+                    Rake.application.options.trace = true
+                    Autobuild.debug = true
+                end
+
+                Autobuild.color = options[:color]
+
+                Autobuild.progress_display_enabled = options[:progress]
+                return args, remaining
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/bootstrap.rb

@@ -0,0 +1,119 @@
+require 'autoproj'
+require 'autoproj/cli/base'
+require 'autoproj/ops/tools'
+require 'autoproj/ops/main_config_switcher'
+
+module Autoproj
+    module CLI
+        class Bootstrap
+            include Ops::Tools
+
+            attr_reader :root_dir
+
+            def initialize(root_dir = Dir.pwd)
+                if File.exists?(File.join(root_dir, 'autoproj', "manifest"))
+                    raise ConfigError, "this installation is already bootstrapped. Remove the autoproj directory if it is not the case"
+                end
+                @root_dir = root_dir
+            end
+
+            def validate_options(args, options)
+                args, options = Base.validate_options(args, options)
+                if path = options[:reuse]
+                    if path == 'reuse'
+                        path = ENV['AUTOPROJ_CURRENT_ROOT']
+                    end
+
+                    path = File.expand_path(path)
+                    if !File.directory?(path) || !File.directory?(File.join(path, 'autoproj'))
+                        raise ArgumentError, "#{path} does not look like an autoproj installation"
+                    end
+                    options[:reuse] = [path]
+                end
+                return args, options
+            end
+            
+            def restart_if_needed
+                # 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')
+                if $0 != autoproj_path
+                    puts "your .autoprojrc file changed PATH in a way that requires the restart of autoproj"
+
+                    if ENV['AUTOPROJ_RESTARTING']
+                        puts "infinite loop detected, will not restart this time"
+                    else
+                        require 'rbconfig'
+                        ws.config.save
+                        exec(ws.config.ruby_executable, autoproj_path, *ARGV)
+                    end
+                end
+            end
+
+            def install_autoproj_gem_in_new_root(ws)
+                # Install the autoproj/autobuild gem explicitely in the new
+                # root.
+                original_env =
+                    Hash['GEM_HOME' => Gem.paths.home,
+                         'GEM_PATH' => Gem.paths.path]
+
+                begin
+                    Gem.paths =
+                        Hash['GEM_HOME' => File.join(root_dir, '.gems'),
+                             'GEM_PATH' => []]
+                    PackageManagers::GemManager.with_prerelease(ws.config.use_prerelease?) do
+                        ws.osdeps.install(%w{autobuild autoproj})
+                    end
+                ensure
+                    Gem.paths = original_env
+                end
+            end
+
+            def run(buildconf_info, options)
+                ws = Workspace.new(root_dir)
+                ws.setup
+                install_autoproj_gem_in_new_root(ws)
+                restart_if_needed
+
+                switcher = Ops::MainConfigSwitcher.new(ws)
+                begin
+                    switcher.bootstrap(buildconf_info, options)
+
+                    STDERR.puts <<-EOTEXT
+
+
+#{Autoproj.color('autoproj bootstrap successfully finished', :green, :bold)}
+
+#{Autoproj.color('To further use autoproj and the installed software', :bold)}, you
+must add the following line at the bottom of your .bashrc:
+source #{root_dir}/#{Autoproj::ENV_FILENAME}
+
+WARNING: autoproj will not work until your restart all
+your consoles, or run the following in them:
+$ source #{root_dir}/#{Autoproj::ENV_FILENAME}
+
+#{Autoproj.color('To import and build the packages', :bold)}, you can now run
+aup
+amake
+
+The resulting software is installed in
+#{root_dir}/install
+
+                    EOTEXT
+
+                rescue RuntimeError
+                    STDERR.puts <<-EOTEXT
+#{Autoproj.color('autoproj bootstrap failed', :red, :bold)}
+To retry, first source the #{Autoproj::ENV_FILENAME} script with
+source #{root_dir}/#{Autoproj::ENV_FILENAME}
+and then re-run autoproj bootstrap
+autoproj bootstrap '#{ARGV.join("'")}'
+                    EOTEXT
+
+                    raise
+                end
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/build.rb

@@ -0,0 +1,72 @@
+require 'autoproj/cli/update'
+require 'autoproj/ops/build'
+
+module Autoproj
+    module CLI
+        class Build < Update
+            def validate_options(selected_packages, options)
+                selected_packages, options = super
+                if options[:amake] && selected_packages.empty? && !options[:all]
+                    selected_packages = ['.']
+                end
+
+                if !options.has_key?(:deps)
+                    options[:deps] = 
+                        !(options[:rebuild] || options[:force])
+                end
+                return selected_packages, options
+            end
+
+            def run(selected_packages, options)
+                build_options, options = filter_options options,
+                    force: false,
+                    rebuild: false
+
+                Autobuild.ignore_errors = options[:keep_going]
+
+                command_line_selection, source_packages, osdep_packages =
+                    super(selected_packages, options.merge(checkout_only: true))
+
+                ops = Ops::Build.new(ws.manifest)
+                if build_options[:rebuild] || build_options[:force]
+                    packages_to_rebuild =
+                        if options[:deps] || command_line_selection.empty?
+                            source_packages
+                        else command_line_selection
+                        end
+
+                    if command_line_selection.empty?
+                        # If we don't have an explicit package selection, we want to
+                        # make sure that the user really wants this
+                        mode_name = if build_options[:rebuild] then 'rebuild'
+                                    else 'force-build'
+                                    end
+                        opt = BuildOption.new("", "boolean", {:doc => "this is going to trigger a #{mode_name} of all packages. Is that really what you want ?"}, nil)
+                        if !opt.ask(false)
+                            raise Interrupt
+                        end
+                        if build_options[:rebuild]
+                            if options[:osdeps]
+                                ws.osdeps.reinstall
+                            end
+                            ops.rebuild_all
+                        else
+                            ops.force_build_all
+                        end
+                    elsif build_options[:rebuild]
+                        ops.rebuild_packages(packages_to_rebuild, source_packages)
+                    else
+                        ops.force_build_packages(packages_to_rebuild, source_packages)
+                    end
+                    return
+                end
+
+                Autobuild.do_build = true
+                ops.build_packages(source_packages)
+                Autobuild.apply(source_packages, "autoproj-build", ['install'])
+            end
+        end
+    end
+end
+
+

data/lib/autoproj/cli/cache.rb

@@ -0,0 +1,31 @@
+require 'autoproj/cli/inspection_tool'
+require 'autoproj/ops/cache'
+
+module Autoproj
+    module CLI
+        class Cache < InspectionTool
+            def validate_options(argv, options = Hash.new)
+                argv, options = super
+
+                if argv.empty?
+                    raise ArgumentError, "expected one cache directory as argument"
+                elsif argv.size > 1
+                    raise ArgumentError, "expected one cache directory as argument"
+                end
+
+                return File.expand_path(argv.first, ws.root_dir), options
+            end
+
+            def run(cache_dir, options = Hash.new)
+                options = Kernel.validate_options options,
+                    keep_going: false
+
+                initialize_and_load
+
+                cache_op = Autoproj::Ops::Cache.new(cache_dir, ws.manifest)
+                cache_op.create_or_update(options[:keep_going])
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/clean.rb

@@ -0,0 +1,37 @@
+require 'autoproj/cli/inspection_tool'
+
+module Autoproj
+    module CLI
+        class Clean < InspectionTool
+            def validate_options(packages, options)
+                packages, options = super
+                if packages.empty? && !options[:all]
+                    opt = BuildOption.new("", "boolean", {:doc => "this is going to clean all packages. Is that really what you want ?"}, nil)
+                    if !opt.ask(false)
+                        raise Interrupt
+                    end
+                end
+                return packages, options
+            end
+
+            def run(selection, options = Hash.new)
+                initialize_and_load
+                packages, _ = normalize_command_line_package_selection(selection)
+                source_packages, * = resolve_selection(
+                    ws.manifest,
+                    selection,
+                    recursive: false,
+                    ignore_non_imported_packages: true)
+                if packages.empty?
+                    raise ArgumentError, "no packages or OS packages match #{selection.join(" ")}"
+                end
+
+                source_packages.each do |pkg_name|
+                    ws.manifest.find_autobuild_package(pkg_name).
+                        prepare_for_rebuild
+                end
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/commit.rb

@@ -0,0 +1,41 @@
+require 'autoproj'
+require 'autoproj/cli/versions'
+require 'autoproj/ops/snapshot'
+require 'autoproj/cli/base'
+
+module Autoproj
+    module CLI
+        class Commit < InspectionTool
+            def run(*user_selection, options = Hash.new)
+                pkg = manifest.main_package_set.create_autobuild_package
+                importer = pkg.importer
+                if !importer || !importer.kind_of?(Autobuild::Git)
+                    raise ConfigError, "cannot use autoproj tag if the main configuration is not managed by git"
+                end
+
+                versions_file = File.join(
+                    ws.config_dir,
+                    Workspace::OVERRIDES_DIR,
+                    Versions::DEFAULT_VERSIONS_FILE_BASENAME)
+
+                initialize_and_load
+
+                versions = CLI::Versions.new(ws)
+                Autoproj.message "creating versions file, this may take a while"
+                versions.run(user_selection,
+                             save: File.join(ws.config_dir, versions_file),
+                             package_sets: options[:package_sets],
+                             output_file: io.path,
+                             replace: true,
+                             keep_going: options[:keep_going])
+
+                importer.run_git(pkg, 'add', versions_file)
+                message = options[:message] ||
+                    "autoproj created tag #{tag_name}"
+
+                importer.run_git(pkg, 'commit', '-m', message)
+            end
+        end
+    end
+end
+