autoproj 1.13.7 → 2.0.0.b1

data/lib/autoproj/cli/main_test.rb

@@ -0,0 +1,57 @@
+module Autoproj
+    module CLI
+        class MainTest < Thor
+            default_command 'exec'
+            
+            desc 'enable [PACKAGES]', 'enable tests for the given packages (or for all packages if none are given)'
+            option :deps, 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
+                    cli = Test.new
+                    args = cli.validate_options(packages, options)
+                    cli.enable(*args)
+                end
+            end
+
+            desc 'disable [PACKAGES]', 'disable tests for the given packages (or for all packages if none are given)'
+            option :deps, default: false,
+                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
+                    cli = Test.new
+                    args = cli.validate_options(packages, options)
+                    cli.disable(*args)
+                end
+            end
+
+            desc 'list [PACKAGES]', 'show test enable/disable status for the given packages (or all packages if none are given)'
+            option :deps, default: false,
+                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
+                    cli = Test.new
+                    args = cli.validate_options(packages, options)
+                    cli.list(*args)
+                end
+            end
+
+            desc 'exec [PACKAGES]', 'execute the tests for the given packages, or all if no packages are given on the command line'
+            option :deps, default: false,
+                desc: 'controls whether to execute the tests of the dependencies of the packages given on the command line (the default is not)'
+            def exec(*packages)
+                require 'autoproj/cli/test'
+                Autoproj.report do
+                    cli = Test.new
+                    args = cli.validate_options(packages, options)
+                    cli.run(*args)
+                end
+            end
+        end
+    end
+end
+
+

data/lib/autoproj/cli/osdeps.rb

@@ -0,0 +1,30 @@
+require 'autoproj/cli/inspection_tool'
+
+module Autoproj
+    module CLI
+        class OSDeps < InspectionTool
+            def validate_options(package_names, options = Hash.new)
+                package_names, options = super
+
+                initialize_and_load
+                if package_names.empty?
+                    package_names = ws.manifest.default_packages(false)
+                end
+
+                return package_names, options
+            end
+
+            def run(user_selection, options = Hash.new)
+                _, osdep_packages, resolved_selection, _ =
+                    finalize_setup(user_selection,
+                                   recursive: false,
+                                   ignore_non_imported_packages: true)
+
+                ws.osdeps.install(
+                    osdep_packages,
+                    install_only: !options[:update])
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/query.rb

@@ -0,0 +1,43 @@
+require 'autoproj'
+require 'autoproj/cli/inspection_tool'
+
+module Autoproj
+    module CLI
+        class Query < InspectionTool
+            def run(query_string, options = Hash.new)
+                initialize_and_load
+                finalize_setup([])
+                query = Autoproj::Query.parse_query(query_string.first)
+
+                packages =
+                    if options[:search_all]
+                        ws.manifest.packages.to_a
+                    else
+                        ws.manifest.all_selected_packages.map do |pkg_name|
+                            [pkg_name, ws.manifest.packages[pkg_name]]
+                        end
+                    end
+
+                matches = packages.map do |name, pkg_def|
+                    if priority = query.match(pkg_def)
+                        [priority, name]
+                    end
+                end.compact
+
+                fields = Hash.new
+                matches = matches.sort
+                matches.each do |priority, name|
+                    pkg = ws.manifest.find_autobuild_package(name)
+                    fields['SRCDIR'] = pkg.srcdir
+                    fields['PREFIX'] = pkg.prefix
+                    fields['NAME'] = name
+                    fields['PRIORITY'] = priority
+
+                    value = Autoproj.expand(options[:format] || "$NAME", fields)
+                    puts value
+                end
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/reconfigure.rb

@@ -0,0 +1,19 @@
+require 'autoproj/cli/base'
+module Autoproj
+    module CLI
+        class Reconfigure < Base
+            def run(args, options = Hash.new)
+                ws.setup
+                ws.config.reconfigure!
+                options.each do |k, v|
+                    ws.config.set k, v, true
+                end
+                ws.load_package_sets
+                ws.setup_all_package_directories
+                ws.finalize_package_setup
+                ws.config.save
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/reset.rb

@@ -1,37 +1,10 @@
 require 'autoproj/cli'
+require 'autoproj/cli/update'
 require 'autoproj/cli/versions'
 
 module Autoproj
     module CLI
-        class Reset
-            include Ops::Tools
-
-            attr_reader :manifest
-
-            def initialize(manifest)
-                @manifest = manifest
-            end
-
-            def parse_options(args)
-                options = Hash[]
-                parser = OptionParser.new do |opt|
-                    opt.banner = ["autoproj reset COMMIT_ID", "resets the current autoproj installation to the state saved in the given commit ID"].join("\n")
-                    opt.on "--freeze", "freezes the project at the requested version" do
-                        options[:freeze] = true
-                    end
-                end
-                common_options(parser)
-                remaining = parser.parse(args)
-                if remaining.empty?
-                    puts parser
-                    raise InvalidArguments, "expected a reference (tag or log ID) as argument and got nothing"
-                elsif remaining.size > 1
-                    puts parser
-                    raise InvalidArguments, "expected only the tag name as argument"
-                end
-                return remaining.first, options
-            end
-
+        class Reset < InspectionTool
             def run(ref_name, options)
                 pkg = manifest.main_package_set.create_autobuild_package
                 importer = pkg.importer
@@ -48,7 +21,7 @@ module Autoproj
 
                 # Checkout the version file
                 versions_file = File.join(
-                    OVERRIDES_DIR,
+                    Workspace::OVERRIDES_DIR,
                     Versions::DEFAULT_VERSIONS_FILE_BASENAME)
                 begin
                     file_data = importer.show(pkg, ref_name, versions_file)
@@ -58,11 +31,13 @@ module Autoproj
                         FileUtils.rm_f old_versions_path
                         FileUtils.cp versions_path, old_versions_path
                     end
-                    FileUtils.mkdir_p File.join(Autoproj.config_dir, OVERRIDES_DIR)
+                    FileUtils.mkdir_p File.join(Autoproj.config_dir, Workspace::OVERRIDES_DIR)
                     File.open(versions_path, 'w') do |io|
                         io.write file_data
                     end
-                    system("autoproj", "update", '--reset')
+
+                    update = CLI::Update.new
+                    run_args = update.run([], reset: true)
 
                 ensure
                     if !options[:freeze]

data/lib/autoproj/cli/show.rb

@@ -0,0 +1,219 @@
+require 'autoproj'
+require 'autoproj/cli/inspection_tool'
+
+module Autoproj
+    module CLI
+        class Show < InspectionTool
+            def run(user_selection, options = Hash.new)
+                options = Kernel.validate_options options,
+                    mainline: false
+
+                initialize_and_load(mainline: options.delete(:mainline))
+                default_packages = ws.manifest.default_packages
+
+                source_packages, osdep_packages, * =
+                    finalize_setup(user_selection,
+                                   recursive: false,
+                                   ignore_non_imported_packages: true)
+
+                if source_packages.empty? && osdep_packages.empty?
+                    Autoproj.error "no packages or OS packages match #{user_selection.join(" ")}"
+                    return
+                end
+                load_all_available_package_manifests
+                revdeps = ws.manifest.compute_revdeps
+
+                source_packages.each do |pkg_name|
+                    display_source_package(pkg_name, default_packages, revdeps)
+                end
+                osdep_packages.each do |pkg_name|
+                    display_osdep_package(pkg_name, default_packages, revdeps)
+                end
+            end
+
+            def display_source_package(pkg_name, default_packages, revdeps)
+                puts Autoproj.color("source package #{pkg_name}", :bold)
+                pkg = ws.manifest.find_autobuild_package(pkg_name)
+                if !File.directory?(pkg.srcdir)
+                    puts Autobuild.color("  this package is not checked out yet, the dependency information will probably be incomplete", :magenta)
+                end
+                puts "  source definition"
+                ws.manifest.load_package_manifest(pkg_name)
+                vcs = ws.manifest.find_package(pkg_name).vcs
+
+                fragments = []
+                if !vcs
+                    fragments << ["has no VCS definition", []]
+                elsif vcs.raw
+                    first = true
+                    fragments << [nil, vcs_to_array(vcs)]
+                    vcs.raw.each do |pkg_set, vcs_info|
+                        pkg_set = if pkg_set then pkg_set.name
+                                  end
+
+                        title = if first
+                                    "first match: in #{pkg_set}"
+                                else "overriden in #{pkg_set}"
+                                end
+                        first = false
+                        fragments << [title, vcs_to_array(vcs_info)]
+                    end
+                end
+                fragments.each do |title, elements|
+                    if title
+                        puts "    #{title}"
+                        elements.each do |key, value|
+                            puts "      #{key}: #{value}"
+                        end
+                    else
+                        elements.each do |key, value|
+                            puts "    #{key}: #{value}"
+                        end
+                    end
+                end
+
+                display_common_information(pkg_name, default_packages, revdeps)
+
+                puts "  directly depends on: #{pkg.dependencies.sort.join(", ")}"
+                puts "  optionally depends on: #{pkg.optional_dependencies.sort.join(", ")}"
+                puts "  dependencies on OS packages: #{pkg.os_packages.sort.join(", ")}"
+            end
+
+            def display_osdep_package(pkg_name, default_packages, revdeps)
+                puts Autoproj.color("the osdep '#{pkg_name}'", :bold)
+                ws.osdeps.resolve_os_dependencies([pkg_name]).each do |manager, packages|
+                    puts "  #{manager.names.first}: #{packages.map { |*subnames| subnames.join(" ") }.join(", ")}"
+                end
+
+                display_common_information(pkg_name, default_packages, revdeps)
+            end
+
+            def display_common_information(pkg_name, default_packages, revdeps)
+                if default_packages.include?(pkg_name)
+                    layout_selection = default_packages.selection[pkg_name]
+                    if layout_selection.include?(pkg_name) && layout_selection.size == 1
+                        puts "  is directly selected by the manifest"
+                    else
+                        layout_selection = layout_selection.dup
+                        layout_selection.delete(pkg_name)
+                        puts "  is directly selected by the manifest via #{layout_selection.to_a.join(", ")}"
+                    end
+                else
+                    puts "  is not directly selected by the manifest"
+                end
+                if ws.manifest.ignored?(pkg_name)
+                    puts "  is ignored"
+                end
+                if ws.manifest.excluded?(pkg_name)
+                    puts "  is excluded: #{Autoproj.manifest.exclusion_reason(pkg_name)}"
+                end
+
+                pkg_revdeps = revdeps[pkg_name].to_a
+                all_revdeps = compute_all_revdeps(pkg_revdeps, revdeps)
+                if pkg_revdeps.empty?
+                    puts "  no reverse dependencies"
+                else
+                    puts "  direct reverse dependencies: #{pkg_revdeps.sort.join(", ")}"
+                    puts "  recursive reverse dependencies: #{all_revdeps.sort.join(", ")}"
+                end
+
+                selections = Set.new
+                all_revdeps = all_revdeps.to_a.sort
+                all_revdeps.each do |revdep_parent_name|
+                    if default_packages.include?(revdep_parent_name)
+                        selections |= default_packages.selection[revdep_parent_name]
+                    end
+                end
+
+                if !selections.empty?
+                    puts "  selected by way of"
+                    selections.each do |root_pkg|
+                        paths = find_selection_path(root_pkg, pkg_name)
+                        if paths.empty?
+                            puts "    FAILED"
+                        else
+                            paths.sort.uniq.each do |p|
+                                puts "    #{p.join(">")}"
+                            end
+                        end
+                    end
+                end
+            end
+
+            def find_selection_path(from, to)
+                if from == to
+                    return [[from]]
+                end
+
+                all_paths = Array.new
+                ws.manifest.resolve_package_set(from).each do |pkg_name|
+                    path = if pkg_name == from then []
+                           else [pkg_name]
+                           end
+
+                    pkg = ws.manifest.find_autobuild_package(pkg_name)
+                    pkg.dependencies.each do |dep_pkg_name|
+                        if result = find_selection_path(dep_pkg_name, to)
+                            all_paths.concat(result.map { |p| path + p })
+                        end
+                    end
+                    if pkg.os_packages.include?(to)
+                        all_paths << (path + [to])
+                    end
+                end
+
+                # Now filter common trailing subpaths
+                all_paths = all_paths.sort_by(&:size)
+                filtered_paths = Array.new
+                while !all_paths.empty?
+                    path = all_paths.shift
+                    filtered_paths << path
+                    size = path.size
+                    all_paths.delete_if do |p|
+                        p[-size..-1] == path
+                    end
+                end
+                filtered_paths.map { |p| [from] + p }
+            end
+
+            def vcs_to_array(vcs)
+                if vcs.kind_of?(Hash)
+                    options = vcs.dup
+                    type = options.delete('type')
+                    url  = options.delete('url')
+                else 
+                    options = vcs.options
+                    type = vcs.type
+                    url = vcs.url
+                end
+
+                value = []
+                if type
+                    value << ['type', type]
+                end
+                if url
+                    value << ['url', url]
+                end
+                value = value.concat(options.to_a.sort_by { |k, _| k.to_s })
+                value.map do |key, value|
+                    if value.respond_to?(:to_str) && File.file?(value) && value =~ /^\//
+                        value = Pathname.new(value).relative_path_from(Pathname.new(Autoproj.root_dir))
+                    end
+                    [key, value]
+                end
+            end
+
+            def compute_all_revdeps(pkg_revdeps, revdeps)
+                pkg_revdeps = pkg_revdeps.dup
+                all_revdeps = Array.new
+                while !pkg_revdeps.empty?
+                    parent_name = pkg_revdeps.shift
+                    next if all_revdeps.include?(parent_name)
+                    all_revdeps << parent_name
+                    pkg_revdeps.concat(revdeps[parent_name].to_a)
+                end
+                all_revdeps
+            end
+        end
+    end
+end

data/lib/autoproj/cli/snapshot.rb

@@ -38,7 +38,7 @@ module Autoproj
                     versions = Versions.new(manifest)
                     versions_file = File.join(
                         target_dir,
-                        OVERRIDES_DIR,
+                        Workspace::OVERRIDES_DIR,
                         Versions::DEFAULT_VERSIONS_FILE_BASENAME)
 
                     versions.run([],

data/lib/autoproj/cli/status.rb

@@ -0,0 +1,149 @@
+require 'autoproj/cli/inspection_tool'
+
+module Autoproj
+    module CLI
+        class Status < InspectionTool
+            def validate_options(packages, options)
+                packages, options = super
+                if options[:dep].nil? && packages.empty?
+                    options[:dep] = true
+                end
+                return packages, options
+            end
+
+            def run(user_selection, options = Hash.new)
+                initialize_and_load(mainline: options[:mainline])
+                packages, *, config_selected = finalize_setup(
+                    user_selection,
+                    recursive: options[:dep],
+                    ignore_non_imported_packages: true)
+
+                if options[:config].nil?
+                    options[:config] = user_selection.empty? || config_selected
+                end
+
+                if packages.empty?
+                    Autoproj.error "no packages or OS packages match #{user_selection.join(" ")}"
+                    return
+                end
+
+                if options[:config]
+                    pkg_sets = ws.manifest.each_package_set.map(&:create_autobuild_package)
+                    if !pkg_sets.empty?
+                        Autoproj.message("autoproj: displaying status of configuration", :bold)
+                        display_status(pkg_sets, only_local: options[:only_local])
+                        STDERR.puts
+                    end
+                end
+
+                Autoproj.message("autoproj: displaying status of packages", :bold)
+                packages = packages.sort.map do |pkg_name|
+                    ws.manifest.find_autobuild_package(pkg_name)
+                end
+                display_status(packages, only_local: options[:only_local])
+            end
+
+            StatusResult = Struct.new :uncommitted, :local, :remote
+            def display_status(packages, options = Hash.new)
+                result = StatusResult.new
+
+                sync_packages = ""
+                packages.each do |pkg|
+                    lines = []
+
+                    pkg_name = pkg.autoproj_name
+
+                    if !pkg.importer
+                        lines << Autoproj.color("  is a local-only package (no VCS)", :bold, :red)
+                    elsif !pkg.importer.respond_to?(:status)
+                        lines << Autoproj.color("  the #{pkg.importer.class.name.gsub(/.*::/, '')} importer does not support status display", :bold, :red)
+                    elsif !File.directory?(pkg.srcdir)
+                        lines << Autoproj.color("  is not imported yet", :magenta)
+                    else
+                        status = begin pkg.importer.status(pkg, options[:only_local])
+                                 rescue Interrupt
+                                     raise
+                                 rescue Exception => e
+                                     lines << Autoproj.color("  failed to fetch status information (#{e})", :red)
+                                     nil
+                                 end
+
+                        if status
+                            if status.uncommitted_code
+                                lines << Autoproj.color("  contains uncommitted modifications", :red)
+                                result.uncommitted = true
+                            end
+
+                            case status.status
+                            when Autobuild::Importer::Status::UP_TO_DATE
+                                if !status.uncommitted_code
+                                    if sync_packages.size > 80
+                                        Autoproj.message "#{sync_packages},"
+                                        sync_packages = ""
+                                    end
+                                    msg = if sync_packages.empty?
+                                              pkg_name
+                                          else
+                                              ", #{pkg_name}"
+                                          end
+                                    STDERR.print msg
+                                    sync_packages = "#{sync_packages}#{msg}"
+                                    next
+                                else
+                                    lines << Autoproj.color("  local and remote are in sync", :green)
+                                end
+                            when Autobuild::Importer::Status::ADVANCED
+                                result.local = true
+                                lines << Autoproj.color("  local contains #{status.local_commits.size} commit that remote does not have:", :blue)
+                                status.local_commits.each do |line|
+                                    lines << Autoproj.color("    #{line}", :blue)
+                                end
+                            when Autobuild::Importer::Status::SIMPLE_UPDATE
+                                result.remote = true
+                                lines << Autoproj.color("  remote contains #{status.remote_commits.size} commit that local does not have:", :magenta)
+                                status.remote_commits.each do |line|
+                                    lines << Autoproj.color("    #{line}", :magenta)
+                                end
+                            when Autobuild::Importer::Status::NEEDS_MERGE
+                                result.local  = true
+                                result.remote = true
+                                lines << "  local and remote have diverged with respectively #{status.local_commits.size} and #{status.remote_commits.size} commits each"
+                                lines << Autoproj.color("  -- local commits --", :blue)
+                                status.local_commits.each do |line|
+                                    lines << Autoproj.color("   #{line}", :blue)
+                                end
+                                lines << Autoproj.color("  -- remote commits --", :magenta)
+                                status.remote_commits.each do |line|
+                                    lines << Autoproj.color("   #{line}", :magenta)
+                                end
+                            end
+                        end
+                    end
+
+                    if !sync_packages.empty?
+                        Autoproj.message("#{sync_packages}: #{Autoproj.color("local and remote are in sync", :green)}")
+                        sync_packages = ""
+                    end
+
+                    STDERR.print 
+
+                    if lines.size == 1
+                        Autoproj.message "#{pkg_name}: #{lines.first}"
+                    else
+                        Autoproj.message "#{pkg_name}:"
+                        lines.each do |l|
+                            Autoproj.message l
+                        end
+                    end
+                end
+                if !sync_packages.empty?
+                    Autoproj.message("#{sync_packages}: #{Autoproj.color("local and remote are in sync", :green)}")
+                    sync_packages = ""
+                end
+                return result
+            end
+
+        end
+    end
+end
+