autoproj 2.0.0.rc37 → 2.0.0.rc38

data/lib/autoproj/cli/locate.rb

@@ -1,113 +1,170 @@
-require 'autoproj/cli/base'
+require 'autoproj/cli/inspection_tool'
 
 module Autoproj
     module CLI
-        class Locate < Base
+        # Deal with locating a package source or build directory in an existing
+        # workspace
+        #
+        # It is based on a installation manifest file, a YAML file generated to
+        # list that information and thus avoid loading the Autoproj
+        # configuration (which takes fairly long).
+        class Locate < InspectionTool
             class NotFound < RuntimeError; end
             class AmbiguousSelection < RuntimeError; end
 
-            attr_reader :installation_manifest
-
-            def initialize(ws = nil)
-                super
-                self.ws.load_config
-
-                path = InstallationManifest.path_for_root(self.ws.root_dir)
-                if !File.file?(path)
-                    raise ConfigError, "the installation manifest is not present, please run autoproj envsh to generate it"
+            attr_reader :packages
+            attr_reader :package_sets
+
+            # Create the locate CLI interface
+            #
+            # @param [Workspace] ws the workspace we're working on
+            # @param [InstallationManifest,nil] installation_manifest the
+            #     manifest. If nil, loads the whole autoproj configuration and
+            #     rebuilds the manifest
+            def initialize(ws = Workspace.default, installation_manifest: try_loading_installation_manifest(ws))
+                super(ws)
+                ws.load_config
+
+                if installation_manifest
+                    update_from_installation_manifest(installation_manifest)
                 end
+            end
 
-                @installation_manifest = Autoproj::InstallationManifest.new(path)
-                installation_manifest.load
+            def update_from_installation_manifest(installation_manifest)
+                @packages = installation_manifest.each_package.to_a
+                @package_sets = installation_manifest.each_package_set.to_a
             end
 
-            def validate_options(selected, options)
-                selected, options = super
-                return selected.first, options
+            # Load the installation manifest
+            def try_loading_installation_manifest(ws = self.ws)
+                Autoproj::InstallationManifest.from_workspace_root(ws.root_dir)
+            rescue ConfigError
             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
+            # Find a package set that matches a given selection
+            #
+            # @param [String] selection a string that is matched against the
+            #   package set name and its various directories. Directories are
+            #   matched against the full path and must end with /
+            # @return [PackageSet,nil]
+            def find_package_set(selection)
+                package_sets.find do |pkg_set|
+                    name = pkg_set.name
+                    name == selection ||
+                        selection.start_with?("#{pkg_set.raw_local_dir}/") ||
+                        selection.start_with?("#{pkg_set.user_local_dir}/")
                 end
             end
 
-            def run(selection, options = Hash.new)
-                if !selection
-                    if options[:build]
-                        puts ws.prefix_dir
-                    else
-                        puts ws.root_dir
+            def find_packages(selection)
+                selection_rx = Regexp.new(Regexp.quote(selection))
+                candidates = []
+                packages.each do |pkg|
+                    name = pkg.name
+                    if name == selection || selection.start_with?("#{pkg.srcdir}/")
+                        return [pkg]
+                    elsif pkg.respond_to?(:builddir) && pkg.builddir && selection.start_with?("#{pkg.builddir}/")
+                        return [pkg]
+                    elsif name =~ selection_rx
+                        candidates << pkg
                     end
-                    return
                 end
+                return candidates
+            end
 
-                if File.directory?(selection)
-                    selection = File.expand_path(selection)
-                end
+            def find_packages_with_directory_shortnames(selection)
+                *directories, basename = *selection.split('/')
+                dirname_rx = directories.
+                    map { |d| "#{Regexp.quote(d)}\\w*" }.
+                    join("/")
+
+                rx        = Regexp.new("#{dirname_rx}/#{Regexp.quote(basename)}")
+                rx_strict = Regexp.new("#{dirname_rx}/#{Regexp.quote(basename)}$")
 
-                selection_rx = Regexp.new(Regexp.quote(selection))
                 candidates = []
-                installation_manifest.each do |pkg|
+                candidates_strict = []
+                packages.each do |pkg|
                     name = pkg.name
-                    if name == selection || pkg.srcdir == selection
-                        puts result_value(pkg, options)
-                        return
-                    elsif name =~ selection_rx || selection.start_with?(pkg.srcdir) || (selection.start_with?(pkg.builddir) if pkg.builddir)
+                    if name =~ rx
                         candidates << pkg
                     end
+                    if name =~ rx_strict
+                        candidates_strict << pkg
+                    end
                 end
 
-                if candidates.empty?
-                    # Try harder. Match directory prefixes
-                    directories = selection.split('/')
-                    rx = directories.
-                        map { |d| "#{Regexp.quote(d)}\\w*" }.
-                        join("/")
-                    rx = Regexp.new(rx)
-
-                    rx_strict = directories[0..-2].
-                        map { |d| "#{Regexp.quote(d)}\\w*" }.
-                        join("/")
-                    rx_strict = Regexp.new("#{rx_strict}/#{Regexp.quote(directories.last)}$")
-
-                    candidates_strict = []
-                    installation_manifest.each do |pkg|
-                        name = pkg.name
-                        if name =~ rx
-                            candidates << pkg
-                        end
-                        if name =~ rx_strict
-                            candidates_strict << pkg
-                        end
+                if candidates.size > 1 && candidates_strict.size == 1
+                    candidates_strict
+                else
+                    candidates
+                end
+            end
+
+            def initialize_from_workspace
+                initialize_and_load
+                finalize_setup # this exports the manifest
+
+                @packages = ws.manifest.each_autobuild_package.to_a
+                @package_sets = ws.manifest.each_package_set.to_a
+            end
+
+            def run(selections, cache: !!packages, build: false, prefix: false)
+                if !cache
+                    initialize_from_workspace
+                end
+
+                if selections.empty?
+                    if prefix || build
+                        puts ws.prefix_dir
+                    else
+                        puts ws.root_dir
                     end
+                end
 
-                    if candidates.size > 1 && candidates_strict.size == 1
-                        candidates = candidates_strict
+                selections.each do |string|
+                    if File.directory?(string)
+                        string = "#{File.expand_path(string)}/"
                     end
+                    puts location_of(string, build: build, prefix: prefix)
+                end
+            end
+
+            def location_of(selection, prefix: false, build: false)
+                if pkg_set = find_package_set(selection)
+                    return pkg_set.user_local_dir
                 end
 
-                if candidates.size > 1
+                matching_packages = find_packages(selection)
+                if matching_packages.empty?
+                    matching_packages = find_packages_with_directory_shortnames(selection)
+                end
+
+                if matching_packages.size > 1
                     # If there is more than one candidate, check if there are some that are not
                     # present on disk
-                    present = candidates.find_all { |pkg| File.directory?(pkg.srcdir) }
+                    present = matching_packages.find_all { |pkg| File.directory?(pkg.srcdir) }
                     if present.size == 1
-                        candidates = present
+                        matching_packages = present
                     end
                 end
 
-                if candidates.empty?
-                    raise ArgumentError, "cannot find #{selection} in the current autoproj installation"
-                elsif candidates.size > 1
-                    raise ArgumentError, "multiple packages match #{selection} in the current autoproj installation: #{candidates.map(&:name).sort.join(", ")}"
+                if matching_packages.empty?
+                    raise NotFound, "cannot find '#{selection}' in the current autoproj installation"
+                elsif matching_packages.size > 1
+                    raise AmbiguousSelection, "multiple packages match '#{selection}' in the current autoproj installation: #{matching_packages.map(&:name).sort.join(", ")}"
                 else
-                    puts result_value(candidates.first, options)
+                    pkg = matching_packages.first
+                    if prefix
+                        pkg.prefix
+                    elsif build
+                        if pkg.respond_to?(:builddir) && pkg.builddir
+                            pkg.builddir
+                        else
+                            raise ArgumentError, "#{pkg.name} does not have a build directory"
+                        end
+                    else
+                        pkg.srcdir
+                    end
                 end
             end
         end

data/lib/autoproj/cli/main.rb

@@ -1,6 +1,7 @@
 require 'thor'
 require 'tty/color'
 require 'autoproj/cli/main_test'
+require 'autoproj/cli/main_plugin'
 
 module Autoproj
     module CLI
@@ -27,7 +28,7 @@ class Main < Thor
                 default: TTY::Color.color?
 
             no_commands do
-                def run_autoproj_cli(filename, classname, report_options, *args)
+                def run_autoproj_cli(filename, classname, report_options, *args, **extra_options)
                     require "autoproj/cli/#{filename}"
                     Autoproj.report(Hash[silent: !options[:debug], debug: options[:debug]].merge(report_options)) do
                         options = self.options.dup
@@ -37,7 +38,7 @@ def run_autoproj_cli(filename, classname, report_options, *args)
                             options[:only_local] = options.delete('local')
                         end
                         cli = CLI.const_get(classname).new
-                        run_args = cli.validate_options(args, options)
+                        run_args = cli.validate_options(args, options.merge(extra_options))
                         cli.run(*run_args)
                     end
                 end
@@ -54,7 +55,7 @@ def bootstrap(*args)
                 if !File.directory?(File.join(Dir.pwd, '.autoproj'))
                     require 'autoproj/ops/install'
                     ops = Autoproj::Ops::Install.new(Dir.pwd)
-                    remaining = ops.parse_options(args)
+                    ops.parse_options(args)
                     ops.run
                     exec Gem.ruby, $0, 'bootstrap', *args
                 end
@@ -75,6 +76,9 @@ def envsh
                 desc: "use the VCS information as 'versions --no-local' would detect it instead of the one in the configuration"
             option :parallel, aliases: :p, type: :numeric,
                 desc: 'maximum number of parallel jobs'
+            option :deps, type: :boolean,
+                desc: 'whether only the status of the given packages should be displayed, or of their dependencies as well',
+                default: true
             def status(*packages)
                 run_autoproj_cli(:status, :Status, Hash[], *packages)
             end
@@ -163,10 +167,14 @@ def clean(*packages)
             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 :cache, type: :boolean,
+                desc: 'controls whether the resolution should be done by loading the whole configuration (false, slow) or through a cache file (the default)'
+            option :prefix, aliases: :p, type: :boolean,
+                desc: "outputs the package's prefix directory instead of its source directory"
             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))
+            def locate(*packages)
+                run_autoproj_cli(:locate, :Locate, Hash[], *packages)
             end
 
             desc 'reconfigure', 'pass through all configuration questions'
@@ -184,6 +192,9 @@ def reconfigure
                 desc: "compare to the given baseline. if 'true', the comparison will ignore any override, otherwise it will take into account overrides only up to the given package set"
             option :env, type: :boolean,
                 desc: "display the package's own environment", default: false
+            option :short, desc: 'display a package summary with one package line'
+            option :recursive, desc: 'display the package and their dependencies (the default is to only display selected packages)',
+                type: :boolean, default: false
             def show(*packages)
                 run_autoproj_cli(:show, :Show, Hash[], *packages)
             end
@@ -335,6 +346,21 @@ def install_stage2(root_dir, *vars)
                 end
                 ops.stage2(*vars)
             end
+
+            desc 'plugin', 'interface to manage autoproj plugins'
+            subcommand 'plugin', MainPlugin
+
+            desc 'patch', 'applies patches necessary for the selected package',
+                hide: true
+            def patch(*packages)
+                run_autoproj_cli(:patcher, :Patcher, Hash[], *packages, patch: true)
+            end
+
+            desc 'unpatch', 'remove any patch applied on the selected package',
+                hide: true
+            def unpatch(*packages)
+                run_autoproj_cli(:patcher, :Patcher, Hash[], *packages, patch: false)
+            end
         end
     end
 end

data/lib/autoproj/cli/main_plugin.rb

@@ -0,0 +1,79 @@
+module Autoproj
+    module CLI
+        class MainPlugin < Thor
+            namespace 'plugin'
+
+            no_commands do
+                def ws
+                    @ws ||= Workspace.from_pwd
+                end
+
+                def install_plugins
+                    ws.load_config
+                    ws.update_autoproj(restart_on_update: false)
+                end
+
+                def read_plugin_list
+                    ws.load_config
+                    ws.config.get('plugins', Hash.new)
+                end
+
+                def write_plugin_list(plugins)
+                    ws.load_config
+                    ws.config.set('plugins', plugins)
+                    ws.save_config
+                end
+            end
+
+            desc 'install NAME', 'install or upgrade an autoproj plugin'
+            option :version, desc: 'a gem version constraint',
+                type: 'string', default: '>= 0'
+            option :git, desc: 'checkout a git repository instead of downloading the gem',
+                type: 'string'
+            option :path, desc: 'use the plugin that is already present on this path',
+                type: 'string'
+            def install(name)
+                require 'autoproj'
+
+                gem_options = Hash.new
+                if options[:git] && options[:path]
+                    raise ArgumentError, "you can provide only one of --git or --path"
+                elsif options[:git]
+                    gem_options[:git] = options[:git]
+                elsif options[:path]
+                    gem_options[:path] = options[:path]
+                end
+
+                plugins = read_plugin_list
+                updated_plugins = plugins.merge(name => [options[:version], gem_options])
+                write_plugin_list(updated_plugins)
+                begin
+                    install_plugins
+                rescue Exception
+                    write_plugin_list(plugins)
+                    install_plugins
+                    raise
+                end
+            end
+
+            desc 'list', 'list installed plugins'
+            def list
+                require 'autoproj'
+                read_plugin_list.sort_by(&:first).each do |name, (version, options)|
+                    args = [version, *options.map { |k, v| "#{k}: \"#{v}\"" }]
+                    puts "#{name}: #{args.join(", ")}"
+                end
+            end
+
+            desc 'remove NAME', 'uninstall a plugin'
+            def remove(name)
+                require 'autoproj'
+                plugins = read_plugin_list
+                updated_plugins = plugins.dup
+                updated_plugins.delete(name)
+                write_plugin_list(updated_plugins)
+                install_plugins
+            end
+        end
+    end
+end

data/lib/autoproj/cli/main_test.rb

@@ -4,13 +4,21 @@ class MainTest < Thor
             namespace 'test'
 
             default_command 'exec'
+
+            no_commands do
+                def report(report_options = Hash.new)
+                    Autoproj.report(Hash[silent: !options[:debug], debug: options[:debug]].merge(report_options)) do
+                        yield
+                    end
+                end
+            end
             
             desc 'enable [PACKAGES]', 'enable tests for the given packages (or for all packages if none are given)'
             option :deps, type: :boolean, default: false,
                 desc: 'controls whether the dependencies of the packages given on the command line should be enabled as well (the default is not)'
             def enable(*packages)
                 require 'autoproj/cli/test'
-                Autoproj.report(silent: true) do
+                report(silent: true) do
                     cli = Test.new
                     args = cli.validate_options(packages, options)
                     cli.enable(*args)
@@ -22,7 +30,7 @@ def enable(*packages)
                 desc: 'controls whether the dependencies of the packages given on the command line should be disabled as well (the default is not)'
             def disable(*packages)
                 require 'autoproj/cli/test'
-                Autoproj.report(silent: true) do
+                report(silent: true) do
                     cli = Test.new
                     args = cli.validate_options(packages, options)
                     cli.disable(*args)
@@ -30,11 +38,11 @@ def disable(*packages)
             end
 
             desc 'list [PACKAGES]', 'show test enable/disable status for the given packages (or all packages if none are given)'
-            option :deps, type: :boolean, default: false,
+            option :deps, type: :boolean, default: true,
                 desc: 'controls whether the dependencies of the packages given on the command line should be disabled as well (the default is not)'
             def list(*packages)
                 require 'autoproj/cli/test'
-                Autoproj.report(silent: true) do
+                report(silent: true) do
                     cli = Test.new
                     args = cli.validate_options(packages, options)
                     cli.list(*args)
@@ -44,10 +52,16 @@ def list(*packages)
             desc 'exec [PACKAGES]', 'execute the tests for the given packages, or all if no packages are given on the command line'
             option :deps, type: :boolean, default: false,
                 desc: 'controls whether to execute the tests of the dependencies of the packages given on the command line (the default is not)'
+            option :fail, type: :boolean, default: true,
+                desc: 'return with a nonzero exit code if the test does not pass'
+            option :coverage, type: :boolean, default: false,
+                desc: 'whether code coverage should be generated if possible'
             def exec(*packages)
                 require 'autoproj/cli/test'
-                Autoproj.report do
+                report do
                     cli = Test.new
+                    Autobuild.pass_test_errors = options[:fail]
+                    Autobuild::TestUtility.coverage_enabled = options[:coverage]
                     args = cli.validate_options(packages, options)
                     cli.run(*args)
                 end