autoproj 2.0.0.rc37 → 2.0.0.rc38

data/lib/autoproj/cli/osdeps.rb

@@ -6,8 +6,7 @@ class OSDeps < InspectionTool
             def run(user_selection, options = Hash.new)
                 initialize_and_load
                 _, osdep_packages, resolved_selection, _ =
-                    finalize_setup(user_selection,
-                                   ignore_non_imported_packages: true)
+                    finalize_setup(user_selection)
 
                 options = Kernel.validate_options options,
                     update: true,

data/lib/autoproj/cli/patcher.rb

@@ -0,0 +1,21 @@
+require 'autoproj/cli/inspection_tool'
+module Autoproj
+    module CLI
+        # Interface to patch/unpatch a package
+        class Patcher < InspectionTool
+            def run(packages, patch: true)
+                initialize_and_load
+                packages, _ = finalize_setup(packages, recursive: false, non_imported_packages: nil)
+                packages.each do |package_name|
+                    pkg = ws.manifest.package_definition_by_name(package_name)
+                    if patch
+                        pkg.autobuild.importer.patch(pkg.autobuild)
+                    else
+                        pkg.autobuild.importer.patch(pkg.autobuild, [])
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/query.rb

@@ -4,62 +4,55 @@
 module Autoproj
     module CLI
         class Query < InspectionTool
-            def run(query_string, options = Hash.new)
-                initialize_and_load
-                all_selected_packages, * =
-                    finalize_setup([], ignore_non_imported_packages: true)
-                all_selected_packages = all_selected_packages.to_set
-
-                query =
-                    if !query_string.empty?
-                        Autoproj::Query.parse_query(query_string.first)
+            def find_all_matches(query, packages)
+                matches = packages.map do |pkg|
+                    if priority = query.match(pkg)
+                        [priority, pkg]
                     end
+                end.compact
+                matches.sort_by { |priority, pkg| [priority, pkg.name] }
+            end
 
-                if options[:search_all]
-                    packages = ws.manifest.packages.to_a
+            def run(query_string, format: '$NAME', search_all: false, only_present: false)
+                initialize_and_load
+                all_selected_packages, * = finalize_setup([], non_imported_packages: :return)
+                if search_all
+                    packages = ws.manifest.each_package_definition.to_a
                 else
                     packages = all_selected_packages.map do |pkg_name|
-                        [pkg_name, ws.manifest.find_package(pkg_name)]
+                        ws.manifest.find_package_definition(pkg_name)
                     end
-                    packages += ws.manifest.all_selected_packages.map do |pkg_name|
-                        if !all_selected_packages.include?(pkg_name)
-                            [pkg_name, ws.manifest.find_package(pkg_name)]
-                        end
-                    end.compact
                 end
-
-                if options[:only_present]
-                    packages = packages.find_all do |_, pkg|
+                if only_present
+                    packages = packages.find_all do |pkg|
                         File.directory?(pkg.autobuild.srcdir)
                     end
                 end
 
-                if !query
-                    matches = packages.map { |name, _| [0, name] }
+                if query_string.empty?
+                    query = Autoproj::Query.all
                 else
-                    matches = packages.map do |name, pkg_def|
-                        if priority = query.match(pkg_def)
-                            [priority, name]
-                        end
-                    end.compact
+                    query = Autoproj::Query.parse_query(query_string.first)
                 end
+                matches = find_all_matches(query, packages)
 
-                fields = Hash.new
-                matches = matches.sort
-                matches.each do |priority, name|
-                    pkg_def = ws.manifest.find_package(name)
-                    pkg = ws.manifest.find_autobuild_package(name)
-                    fields['SRCDIR'] = pkg.srcdir
-                    fields['PREFIX'] = pkg.prefix
-                    fields['NAME'] = name
-                    fields['PRIORITY'] = priority
-                    fields['URL'] = (pkg_def.vcs.url if pkg_def.vcs)
-                    fields['PRESENT'] = File.directory?(pkg.srcdir)
-
-                    value = Autoproj.expand(options[:format] || "$NAME", fields)
-                    puts value
+                matches.each do |priority, pkg_def|
+                    puts format_package(format, priority, pkg_def)
                 end
             end
+
+            def format_package(format, priority, package)
+                autobuild_package = package.autobuild
+                fields = Hash.new
+                fields['SRCDIR']   = autobuild_package.srcdir
+                fields['BUILDDIR'] = autobuild_package.builddir
+                fields['PREFIX']   = autobuild_package.prefix
+                fields['NAME']     = package.name
+                fields['PRIORITY'] = priority
+                fields['URL']      = (package.vcs.url if package.vcs)
+                fields['PRESENT']  = File.directory?(autobuild_package.srcdir)
+                Autoproj.expand(format, fields)
+            end
         end
     end
 end

data/lib/autoproj/cli/show.rb

@@ -4,31 +4,89 @@
 module Autoproj
     module CLI
         class Show < InspectionTool
-            def run(user_selection, options = Hash.new)
-                options = Kernel.validate_options options,
-                    mainline: false, env: false
-
-                initialize_and_load(mainline: options.delete(:mainline))
+            def run(user_selection, short: false, recursive: false, mainline: false, env: false)
+                initialize_and_load(mainline: mainline)
                 default_packages = ws.manifest.default_packages
 
-                source_packages, osdep_packages, * =
-                    finalize_setup(user_selection,
-                                   recursive: false,
-                                   ignore_non_imported_packages: true)
+                # Filter out selections that match package set names
+                package_set_names, user_selection = user_selection.partition do |name|
+                    ws.manifest.find_package_set(name)
+                end
+
+                if !user_selection.empty? || package_set_names.empty?
+                    source_packages, osdep_packages, * =
+                        finalize_setup(user_selection, recursive: recursive, non_imported_packages: :return)
+                else
+                    source_packages, osdep_packages = Array.new, Array.new
+                end
 
-                if source_packages.empty? && osdep_packages.empty?
-                    Autoproj.error "no packages or OS packages match #{user_selection.join(" ")}"
+                if package_set_names.empty? && source_packages.empty? && osdep_packages.empty?
+                    Autoproj.error "no package set, packages or OS packages match #{user_selection.join(" ")}"
                     return
+                elsif !source_packages.empty? || !osdep_packages.empty?
+                    load_all_available_package_manifests
+                    revdeps = ws.manifest.compute_revdeps
+                end
+
+                package_set_names = package_set_names.sort
+                source_packages   = source_packages.sort
+                osdep_packages    = osdep_packages.sort
+
+                if short
+                    package_set_names.each do |name|
+                        puts "pkg_set #{name}"
+                    end
+                    source_packages.each do |name|
+                        puts "pkg     #{name}"
+                    end
+                    osdep_packages.each do |name|
+                        puts "osdep   #{name}"
+                    end
+                else
+                    package_set_names.each do |pkg_set_name|
+                        display_package_set(pkg_set_name)
+                    end
+                    source_packages.each do |pkg_name|
+                        display_source_package(pkg_name, default_packages, revdeps, env: env)
+                    end
+                    osdep_packages.each do |pkg_name|
+                        display_osdep_package(pkg_name, default_packages, revdeps)
+                    end
+                end
+            end
+
+            def display_package_set(name, package_per_line: 8)
+                puts Autoproj.color("package set #{name}", :bold)
+                pkg_set = ws.manifest.find_package_set(name)
+                if !File.directory?(pkg_set.raw_local_dir)
+                    puts Autobuild.color("  this package set is not checked out", :magenta)
+                end
+                if overrides_key = pkg_set.vcs.overrides_key
+                    puts "  overrides key: pkg_set:#{overrides_key}"
                 end
-                load_all_available_package_manifests
-                revdeps = ws.manifest.compute_revdeps
+                if pkg_set.raw_local_dir != pkg_set.user_local_dir
+                    puts "  checkout dir: #{pkg_set.raw_local_dir}"
+                    puts "  symlinked to: #{pkg_set.user_local_dir}"
+                else
+                    puts "  path: #{pkg_set.raw_local_dir}"
+                end
+
+                puts "  version control information:"
+                display_vcs(pkg_set.vcs)
 
-                source_packages.each do |pkg_name|
-                    display_source_package(pkg_name, default_packages, revdeps, env: options[:env])
+                metapackage = ws.manifest.find_metapackage(name)
+                size = metapackage.size
+                if size == 0
+                    puts "  does not have any packages"
+                else
+                    puts "  refers to #{metapackage.size} package#{'s' if metapackage.size > 1}"
                 end
-                osdep_packages.each do |pkg_name|
-                    display_osdep_package(pkg_name, default_packages, revdeps)
+                names = metapackage.each_package.map(&:name).sort
+                package_lines = names.each_slice(package_per_line).map do |*line_names|
+                    line_names.join(", ")
                 end
+                puts "    " + package_lines.join(",\n    ")
+
             end
 
             def display_source_package(pkg_name, default_packages, revdeps, options = Hash.new)
@@ -39,24 +97,53 @@ def display_source_package(pkg_name, default_packages, revdeps, options = Hash.n
                 end
                 puts "  source definition"
                 ws.manifest.load_package_manifest(pkg_name)
-                vcs = ws.manifest.find_package(pkg_name).vcs
+                vcs = ws.manifest.find_package_definition(pkg_name).vcs
+
+                display_vcs(vcs)
+                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(", ")}"
+                if options[:env]
+                    puts "  environment"
+                    pkg.resolved_env.sort_by(&:first).each do |name, v|
+                        values = v.split(File::PATH_SEPARATOR)
+                        if values.size == 1
+                            puts "    #{name}: #{values.first}"
+                        else
+                            puts "    #{name}:"
+                            values.each do |single_v|
+                                puts "      #{single_v}"
+                            end
+                        end
+                    end
+                end
+            end
 
+            def display_vcs(vcs)
                 fragments = []
-                if !vcs
+                if vcs.none?
                     fragments << ["has no VCS definition", []]
-                elsif vcs.raw
+                else
                     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
+                    vcs.raw.each do |entry|
+                        entry_name =
+                            if entry.package_set && entry.file
+                                "#{entry.package_set.name} (#{entry.file})"
+                            elsif entry.package_set
+                                "#{entry.package_set.name}"
+                            elsif entry.file
+                                "#{entry.file}"
+                            end
 
                         title = if first
-                                    "first match: in #{pkg_set}"
-                                else "overriden in #{pkg_set}"
+                                    "first match: in #{entry_name}"
+                                else "overriden in #{entry_name}"
                                 end
                         first = false
-                        fragments << [title, vcs_to_array(vcs_info)]
+                        fragments << [title, vcs_to_array(entry.vcs)]
                     end
                 end
                 fragments.each do |title, elements|
@@ -71,26 +158,6 @@ def display_source_package(pkg_name, default_packages, revdeps, options = Hash.n
                         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(", ")}"
-                if options[:env]
-                    puts "  environment"
-                    pkg.resolved_env.sort_by(&:first).each do |name, v|
-                        values = v.split(File::PATH_SEPARATOR)
-                        if values.size == 1
-                            puts "    #{name}: #{values.first}"
-                        else
-                            puts "    #{name}:"
-                            values.each do |single_v|
-                                puts "      #{single_v}"
-                            end
-                        end
-                    end
-                end
             end
 
             def display_osdep_package(pkg_name, default_packages, revdeps)
@@ -160,7 +227,9 @@ def find_selection_path(from, to)
                 end
 
                 all_paths = Array.new
-                ws.manifest.resolve_package_set(from).each do |pkg_name|
+                ws.manifest.resolve_package_name(from).each do |pkg_type, pkg_name|
+                    next if pkg_type != :package
+
                     path = if pkg_name == from then []
                            else [pkg_name]
                            end
@@ -201,15 +270,15 @@ def vcs_to_array(vcs)
                     url = vcs.url
                 end
 
-                value = []
+                fields = []
                 if type
-                    value << ['type', type]
+                    fields << ['type', type]
                 end
                 if url
-                    value << ['url', url]
+                    fields << ['url', url]
                 end
-                value = value.concat(options.to_a.sort_by { |k, _| k.to_s })
-                value.map do |key, value|
+                fields = fields.concat(options.to_a.sort_by { |k, _| k.to_s })
+                fields.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

data/lib/autoproj/cli/status.rb

@@ -5,8 +5,8 @@ module CLI
         class Status < InspectionTool
             def validate_options(packages, options)
                 packages, options = super
-                if options[:dep].nil? && packages.empty?
-                    options[:dep] = true
+                if options[:deps].nil? && packages.empty?
+                    options[:deps] = true
                 end
                 return packages, options
             end
@@ -15,8 +15,7 @@ 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)
+                    recursive: options[:deps])
 
                 if options[:config].nil?
                     options[:config] = user_selection.empty? || config_selected
@@ -42,7 +41,7 @@ def run(user_selection, options = Hash.new)
 
                 Autoproj.message("autoproj: displaying status of packages", :bold)
                 packages = packages.sort.map do |pkg_name|
-                    ws.manifest.find_package(pkg_name)
+                    ws.manifest.find_package_definition(pkg_name)
                 end
                 display_status(packages, parallel: options[:parallel], snapshot: options[:snapshot], only_local: options[:only_local])
             end

data/lib/autoproj/cli/tag.rb

@@ -9,7 +9,7 @@ class Tag < Base
             def run(arguments, options = Hash.new)
                 tag_name, *user_selection = *arguments
                 ws.load_config
-                main_package_set = LocalPackageSet.new(ws.manifest, ws.config_dir)
+                main_package_set = LocalPackageSet.new(ws)
 
                 pkg = main_package_set.create_autobuild_package
                 importer = pkg.importer

data/lib/autoproj/cli/test.rb

@@ -12,7 +12,7 @@ def enable(user_selection, options = Hash.new)
                     selection, _ = finalize_setup(
                         user_selection,
                         recursive: options[:deps],
-                        ignore_non_imported_packages: true)
+                        non_imported_packages: :return)
                     ws.config.utility_enable('test', *selection)
                 end
                 ws.config.save
@@ -27,7 +27,7 @@ def disable(user_selection, options = Hash.new)
                     selection, _ = finalize_setup(
                         user_selection,
                         recursive: options[:deps],
-                        ignore_non_imported_packages: true)
+                        non_imported_packages: :return)
                     ws.config.utility_disable('test', *selection)
                 end
                 ws.config.save
@@ -37,12 +37,12 @@ def list(user_selection, options = Hash.new)
                 initialize_and_load
                 resolved_selection, _ = finalize_setup(
                     user_selection,
-                    recursive: options[:dep],
-                    ignore_non_imported_packages: true)
+                    recursive: options[:deps],
+                    non_imported_packages: :return)
 
                 lines = Array.new
                 resolved_selection.each do |pkg_name|
-                    pkg = ws.manifest.find_package(pkg_name).autobuild
+                    pkg = ws.manifest.find_package_definition(pkg_name).autobuild
                     lines << [pkg.name, pkg.test_utility.enabled?, pkg.test_utility.available?]
                 end
                 lines = lines.sort_by { |name, _| name }
@@ -56,7 +56,8 @@ def list(user_selection, options = Hash.new)
 
             def run(user_selection, options = Hash.new)
                 initialize_and_load
-                packages, _ = finalize_setup(user_selection)
+                packages, _ = finalize_setup(user_selection,
+                                             recursive: options[:deps])
 
                 packages.each do |pkg|
                     Autobuild::Package[pkg].disable_phases('import', 'prepare', 'install')

data/lib/autoproj/cli/update.rb

@@ -13,7 +13,7 @@ def validate_options(packages, options)
                 end
 
                 if from = options[:from]
-                    options[:from] = Autoproj::InstallationManifest.from_root(options[:from])
+                    options[:from] = Autoproj::InstallationManifest.from_workspace_root(options[:from])
                 end
                 ws.os_package_installer.filter_uptodate_packages = options[:osdeps_filter_uptodate]
 
@@ -109,21 +109,6 @@ def run(selected_packages, options)
                     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.install_os_packages(vcs_to_install, osdeps_options)
-                end
-
                 ops = Autoproj::Ops::Import.new(ws)
                 source_packages, osdep_packages = 
                     ops.import_packages(selected_packages,
@@ -133,13 +118,14 @@ def run(selected_packages, options)
                                     recursive: options[:deps],
                                     ignore_errors: options[:keep_going],
                                     parallel: parallel,
-                                    retry_count: options[:retry_count])
+                                    retry_count: options[:retry_count],
+                                    install_vcs_packages: (osdeps_options if options[:osdeps]))
 
                 ws.finalize_setup
                 ws.export_installation_manifest
 
                 if options[:osdeps] && !osdep_packages.empty?
-                    ws.install_os_packages(osdep_packages, osdeps_options)
+                    ws.install_os_packages(osdep_packages, **osdeps_options)
                 end
 
                 ws.export_env_sh(source_packages)
@@ -151,14 +137,14 @@ def run(selected_packages, options)
             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)
+                ws.manifest.each_autobuild_package do |pkg|
+                    if pkg.checked_out?
                         begin
-                            ws.manifest.load_package_manifest(pkg.autobuild.name)
+                            ws.manifest.load_package_manifest(pkg.name)
                         rescue Interrupt
                             raise
                         rescue Exception => e
-                            Autoproj.warn "cannot load package manifest for #{pkg.autobuild.name}: #{e.message}"
+                            Autoproj.warn "cannot load package manifest for #{pkg.name}: #{e.message}"
                         end
                     end
                 end