class Autoproj::CLI::Utility

Attributes

utility_name[R]

Public Class Methods

new(ws, name: nil, report_path: nil) click to toggle source
Calls superclass method Autoproj::CLI::Base::new
# File lib/autoproj/cli/utility.rb, line 6
def initialize(ws, name: nil, report_path: nil)
    @utility_name = name
    @report_path = report_path
    super(ws)
end

Public Instance Methods

apply_to_packages(packages, parallel: ws.config.parallel_build_level) click to toggle source
# File lib/autoproj/cli/utility.rb, line 102
def apply_to_packages(packages, parallel: ws.config.parallel_build_level)
    if @report_path
        reporting = Ops::PhaseReporting.new(
            @utility_name, @report_path,
            method(:package_metadata)
        )
    end

    reporting&.initialize_incremental_report
    Autobuild.apply(
        packages.map(&:name), "autoproj-#{@utility_name}",
        [@utility_name], parallel: parallel
    ) do |pkg, phase|
        reporting&.report_incremental(pkg) if phase == utility_name
    end
ensure
    reporting&.create_report(packages.map(&:autobuild))
end
default(enabled) click to toggle source
# File lib/autoproj/cli/utility.rb, line 14
def default(enabled)
    ws.load_config
    ws.config.utility_default(utility_name, enabled)
    ws.config.save
end
disable(user_selection, options = {}) click to toggle source
# File lib/autoproj/cli/utility.rb, line 36
def disable(user_selection, options = {})
    if user_selection.empty?
        ws.load_config
        ws.config.utility_disable_all(utility_name)
    else
        initialize_and_load
        selection, = finalize_setup(
            user_selection,
            recursive: options[:deps],
            non_imported_packages: :return
        )
        ws.config.utility_disable(utility_name, *selection)
    end
    ws.config.save
end
enable(user_selection, options = {}) click to toggle source
# File lib/autoproj/cli/utility.rb, line 20
def enable(user_selection, options = {})
    if user_selection.empty?
        ws.load_config
        ws.config.utility_enable_all(utility_name)
    else
        initialize_and_load
        selection, = finalize_setup(
            user_selection,
            recursive: options[:deps],
            non_imported_packages: :return
        )
        ws.config.utility_enable(utility_name, *selection)
    end
    ws.config.save
end
list(user_selection, options = {}) click to toggle source
# File lib/autoproj/cli/utility.rb, line 52
def list(user_selection, options = {})
    initialize_and_load
    resolved_selection, = finalize_setup(
        user_selection,
        recursive: options[:deps],
        non_imported_packages: :return
    )

    lines = []
    resolved_selection.each do |pkg_name|
        pkg = ws.manifest.find_package_definition(pkg_name).autobuild
        lines << [
            pkg.name,
            pkg.send("#{utility_name}_utility").enabled?,
            pkg.send("#{utility_name}_utility").available?
        ]
    end
    lines = lines.sort_by { |name, _| name }
    w     = lines.map { |name, _| name.length }.max
    out_format = "%-#{w}s %-7s %-9s"
    puts format(out_format, "Package Name", "Enabled", "Available")
    lines.each do |name, enabled, available|
        puts(format(out_format, name, (!!enabled).to_s, (!!available).to_s)) # rubocop:disable Style/DoubleNegation
    end
end
package_metadata(autobuild_package) click to toggle source
# File lib/autoproj/cli/utility.rb, line 121
def package_metadata(autobuild_package)
    # rubocop:disable Style/DoubleNegation
    u = autobuild_package.utility(@utility_name)
    {
        "source_dir" => u.source_dir,
        "target_dir" => u.target_dir,
        "available" => !!u.available?,
        "enabled" => !!u.enabled?,
        "invoked" => !!u.invoked?,
        "success" => !!u.success?,
        "installed" => !!u.installed?
    }
    # rubocop:enable Style/DoubleNegation
end
run(user_selection, options = {}) click to toggle source
# File lib/autoproj/cli/utility.rb, line 78
def run(user_selection, options = {})
    options[:parallel] ||= ws.config.parallel_build_level
    initialize_and_load

    user_selection, = normalize_command_line_package_selection(user_selection)
    package_names, _, resolved_selection = finalize_setup(
        user_selection,
        recursive: user_selection.empty? || options[:deps]
    )

    validate_user_selection(user_selection, resolved_selection)
    if package_names.empty?
        raise CLIInvalidArguments, "autoproj: the provided package "\
                                   "is not selected for build"
    end
    return if package_names.empty?

    packages = package_names.map do |pkg_name|
        ws.manifest.find_package_definition(pkg_name)
    end

    apply_to_packages(packages, parallel: options[:parallel])
end