class Autoproj::Workspace

Constants

BUILD_REPORT_BASENAME
IMPORT_REPORT_BASENAME
OVERRIDES_DIR
RegisteredWorkspace

Attributes

config[RW]
env[R]
loader[R]
manifest[R]

The installation manifest

@return [Manifest]

os_package_installer[R]
os_package_resolver[R]
os_repository_installer[R]
os_repository_resolver[R]
osdep_suffixes[R]

Suffixes that should be considered when loading osdep files

{#ruby_version_keyword} is automatically added there in {#setup}

root_dir[R]

The workspace root as a string

New code should prefer {#root_path}

root_path[R]

The workspace root

This should be used rather than {#root_dir} in new code

ruby_version_keyword[RW]

The keyword used to represent the current ruby version.

It is e.g. ruby21 for ruby 2.1.

It is initialized to the local ruby version in {#initialize}. If one intends to override it, one must do it before {#setup} gets called

This is aliased to ‘ruby’ in the osdep system, so one that depends on ruby should only refer to ‘ruby’ unless a specific version is requested.

It is also used as an osdep suffix when loading osdep files (i.e. the osdep system will attempt to load ‘.osdep-ruby21` files on ruby 2.1 in addition to the plain .osdep files.

@return [String]

Public Class Methods

autoproj_current_root() click to toggle source

Returns the root of the current autoproj workspace

@return [String,nil] the root path, or nil if one did not yet source

the workspace's env.sh
# File lib/autoproj/workspace.rb, line 87
def self.autoproj_current_root
    if (env = ENV["AUTOPROJ_CURRENT_ROOT"])
        env unless env.empty?
    end
end
default(**workspace_options) click to toggle source

Returns the default workspace

It uses the AUTOPROJ_CURRENT_ROOT environment variable if available, falling back to the current directory

@raise MismatchingWorkspace if the workspace pointed by AUTOPROJ_CURRENT_ROOT does not match the one containing the current directory

# File lib/autoproj/workspace.rb, line 147
def self.default(**workspace_options)
    ws = from_environment(**workspace_options)
    from_pwd = Autoproj.find_workspace_dir(Dir.pwd)
    if from_pwd && (from_pwd != ws.root_dir)
        raise MismatchingWorkspace,
              "the current environment points to "\
              "#{ws.root_dir}, but you are in #{from_pwd}, make sure you "\
              "are loading the right #{ENV_FILENAME} script !"
    end
    ws
end
find_path(xdg_var, xdg_path, home_path) click to toggle source
# File lib/autoproj/workspace.rb, line 553
def self.find_path(xdg_var, xdg_path, home_path)
    home_dir = begin Dir.home
    rescue ArgumentError
        return
    end

    xdg_path  = File.join(XDG[xdg_var].to_path, "autoproj", xdg_path)
    home_path = File.join(home_dir, home_path)

    if File.exist?(xdg_path)
        xdg_path
    elsif File.exist?(home_path)
        home_path
    else
        xdg_path
    end
end
find_user_cache_path(xdg_path, home_path = xdg_path) click to toggle source
# File lib/autoproj/workspace.rb, line 583
def self.find_user_cache_path(xdg_path, home_path = xdg_path)
    find_path("CACHE_HOME", xdg_path, File.join(".autoproj", home_path))
end
find_user_config_path(xdg_path, home_path = xdg_path) click to toggle source
# File lib/autoproj/workspace.rb, line 571
def self.find_user_config_path(xdg_path, home_path = xdg_path)
    find_path("CONFIG_HOME", xdg_path, home_path)
end
find_user_data_path(xdg_path, home_path = xdg_path) click to toggle source
# File lib/autoproj/workspace.rb, line 579
def self.find_user_data_path(xdg_path, home_path = xdg_path)
    find_path("DATA_HOME", xdg_path, File.join(".autoproj", home_path))
end
from_dir(dir, **workspace_options) click to toggle source

Returns the workspace a directory is part of

@return [Workspace] @raise [MismatchingWorkspace] if the currently loaded env.sh

and the one from +dir+ mismatch

@raise [NotWorkspace] if dir is not within an autoproj workspace

# File lib/autoproj/workspace.rb, line 107
def self.from_dir(dir, **workspace_options)
    if (path = Autoproj.find_workspace_dir(dir))
        Workspace.new(path, **workspace_options)
    elsif Autoproj.find_v1_workspace_dir(dir)
        raise OutdatedWorkspace, "#{dir} looks like a v1 workspace, "\
                                 "run autoproj upgrade before continuing"
    else
        raise NotWorkspace, "not in a Autoproj installation"
    end
end
from_environment(**workspace_options) click to toggle source
# File lib/autoproj/workspace.rb, line 118
def self.from_environment(**workspace_options)
    if (path = Autoproj.find_workspace_dir)
        from_dir(path, **workspace_options)
    elsif Autoproj.find_v1_workspace_dir(dir = Autoproj.default_find_base_dir)
        raise OutdatedWorkspace, "#{dir} looks like a v1 workspace, "\
                                 "run autoproj upgrade before continuing"
    elsif (envvar = ENV["AUTOPROJ_CURRENT_ROOT"])
        raise NotWorkspace, "AUTOPROJ_CURRENT_ROOT is currently set "\
                            "to #{envvar}, but that is not an Autoproj workspace"
    else
        raise NotWorkspace, "not in an Autoproj installation, "\
                            "and no env.sh has been loaded so far"
    end
end
from_pwd(**workspace_options) click to toggle source

Returns the workspace the current directory is part of

@return [Workspace] @raise (see from_dir)

# File lib/autoproj/workspace.rb, line 97
def self.from_pwd(**workspace_options)
    from_dir(Dir.pwd, **workspace_options)
end
in_autoproj_project?(path) click to toggle source

Tests whether the given path is under a directory tree managed by autoproj

# File lib/autoproj/workspace.rb, line 135
def self.in_autoproj_project?(path)
    Autoproj.find_workspace_dir(path)
end
new(root_dir, os_package_resolver: OSPackageResolver.new, package_managers: OSPackageInstaller::PACKAGE_MANAGERS, os_repository_resolver: OSRepositoryResolver.new( operating_system: os_package_resolver.operating_system ), os_repository_installer: OSRepositoryInstaller.new(self)) click to toggle source
Calls superclass method Autoproj::Ops::Loader::new
# File lib/autoproj/workspace.rb, line 54
def initialize(root_dir,
    os_package_resolver: OSPackageResolver.new,
    package_managers: OSPackageInstaller::PACKAGE_MANAGERS,
    os_repository_resolver: OSRepositoryResolver.new(
        operating_system: os_package_resolver.operating_system
    ),
    os_repository_installer: OSRepositoryInstaller.new(self))
    @root_dir = root_dir
    @root_path = Pathname.new(root_dir)
    @ruby_version_keyword = "ruby#{RUBY_VERSION.split('.')[0, 2].join('')}"
    @osdep_suffixes = Array.new

    @loader = loader
    @env = Environment.new
    env.prepare(root_dir)
    env.source_before(File.join(dot_autoproj_dir, "env.sh"))

    @os_repository_resolver = os_repository_resolver
    @os_repository_installer = os_repository_installer
    @os_package_resolver = os_package_resolver
    @manifest = Manifest.new(self, os_package_resolver: os_package_resolver)
    @config = Configuration.new(config_file_path)

    @os_package_installer = OSPackageInstaller.new(
        self, os_package_resolver, package_managers: package_managers
    )
    super(root_dir)
end
rcfile_path() click to toggle source
# File lib/autoproj/workspace.rb, line 575
def self.rcfile_path
    find_user_config_path("rc", ".autoprojrc")
end
registered_workspaces() click to toggle source
# File lib/autoproj/workspace.rb, line 589
def self.registered_workspaces
    path = find_user_data_path("workspaces.yml")
    if File.file?(path)
        yaml = (YAML.safe_load(File.read(path)) || [])
        fields = RegisteredWorkspace.members.map(&:to_s)
        yaml.map do |h|
            values = h.values_at(*fields)
            RegisteredWorkspace.new(*values)
        end.compact
    else
        []
    end
end
save_registered_workspaces(workspaces) click to toggle source
# File lib/autoproj/workspace.rb, line 603
def self.save_registered_workspaces(workspaces)
    workspaces = workspaces.map do |w|
        Hash["root_dir" => w.root_dir,
             "prefix_dir" => w.prefix_dir,
             "build_dir" => w.build_dir]
    end

    path = find_user_data_path("workspaces.yml")
    FileUtils.mkdir_p(File.dirname(path))
    Ops.atomic_write(path) do |io|
        io.write YAML.dump(workspaces)
    end
end

Public Instance Methods

all_os_packages(import_missing: false, parallel: config.parallel_import_level) click to toggle source

Returns the list of all OS packages required by the state of the workspace

@return [Array<String>] the list of OS packages that can be fed to

{OSPackageManager#install}
# File lib/autoproj/workspace.rb, line 860
def all_os_packages(import_missing: false, parallel: config.parallel_import_level)
    if import_missing
        ops = Autoproj::Ops::Import.new(self)
        _, all_os_packages =
            ops.import_packages(
                manifest.default_packages,
                checkout_only: true, only_local: true, reset: false,
                recursive: true, keep_going: true, parallel: parallel,
                retry_count: 0
            )
        all_os_packages
    else
        manifest.all_selected_osdep_packages
    end
end
all_present_packages() click to toggle source
# File lib/autoproj/workspace.rb, line 775
def all_present_packages
    manifest.each_autobuild_package
            .find_all { |pkg| File.directory?(pkg.srcdir) }
            .map(&:name)
end
autodetect_operating_system(force: false) click to toggle source
# File lib/autoproj/workspace.rb, line 310
def autodetect_operating_system(force: false)
    if force || !os_package_resolver.operating_system
        begin
            Autobuild.progress_start(
                :operating_system_autodetection,
                "autodetecting the operating system"
            )
            names, versions = OSPackageResolver.autodetect_operating_system
            os_package_resolver.operating_system = [names, versions]
            os_repository_resolver.operating_system = [names, versions]
            Autobuild.progress(
                :operating_system_autodetection,
                "operating system: #{(names - ['default']).join(',')} -"\
                " #{(versions - ['default']).join(',')}"
            )
        ensure
            Autobuild.progress_done :operating_system_autodetection
        end
        config.set("operating_system", os_package_resolver.operating_system, true)
    end
end
build_dir() click to toggle source

(see Configuration#build_dir)

# File lib/autoproj/workspace.rb, line 213
def build_dir
    config.build_dir
end
build_dir=(path) click to toggle source

Change {#build_dir}

# File lib/autoproj/workspace.rb, line 218
def build_dir=(path)
    config.set "build", path, true
end
build_report_path() click to toggle source

The full path to the build report

@return [String]

# File lib/autoproj/workspace.rb, line 263
def build_report_path
    File.join(log_dir, BUILD_REPORT_BASENAME)
end
clear_main_workspace() click to toggle source
# File lib/autoproj/workspace.rb, line 537
def clear_main_workspace
    Autoproj.workspace = nil
    Autoproj.root_dir = nil
    Autobuild.env = nil
end
compute_builddir(pkg) click to toggle source
# File lib/autoproj/workspace.rb, line 725
def compute_builddir(pkg)
    # If we're given an absolute build dir, we have to append the
    # package name to it to make it unique
    if Pathname.new(build_dir).absolute?
        File.join(build_dir, pkg.name)
    else
        build_dir
    end
end
config_dir() click to toggle source

Returns the configuration directory for this autoproj installation.

@return [String]

# File lib/autoproj/workspace.rb, line 171
def config_dir
    File.join(root_dir, "autoproj")
end
config_file_path() click to toggle source

The path to the workspace configuration file

# File lib/autoproj/workspace.rb, line 187
def config_file_path
    File.join(dot_autoproj_dir, "config.yml")
end
define_package(package_type, package_name, block = nil, package_set = manifest.main_package_set, file = nil) click to toggle source

Define and register an autobuild package on this workspace

@param [Symbol] package_type a package-creation method on {Autobuild},

e.g. :cmake

@param [String] package_name the package name @param [PackageSet] package_set the package set into which this

package is defined

@param [String,nil] file the path to the file that defines this

package (used for error reporting)

@param [Proc,nil] block a setup block that should be called to

configure the package

@return [PackageDefinition]

# File lib/autoproj/workspace.rb, line 898
def define_package(package_type, package_name, block = nil,
    package_set = manifest.main_package_set, file = nil)
    autobuild_package = Autobuild.send(package_type, package_name)
    register_package(autobuild_package, block, package_set, file)
end
dot_autoproj_dir() click to toggle source

The directory under which autoproj saves all its internal configuration and files

# File lib/autoproj/workspace.rb, line 177
def dot_autoproj_dir
    File.join(root_dir, ".autoproj")
end
export_env_sh(_package_names = nil, shell_helpers: true) click to toggle source

Export the workspace’s env.sh file

@return [Boolean] true if the environment has been changed, false otherwise

# File lib/autoproj/workspace.rb, line 822
def export_env_sh(_package_names = nil, shell_helpers: true)
    full_env = self.full_env
    changed = save_cached_env(full_env)
    full_env.export_env_sh(shell_helpers: shell_helpers)

    build_dir = Pathname(self.build_dir)
    full_env.each_env_filename do |_, filename|
        basename = File.basename(filename)
        File.open(File.join(prefix_dir, basename), "w") do |io|
            io.puts "source \"#{filename}\""
        end
        if build_dir.absolute?
            build_dir.mkpath
            (build_dir + basename).open("w") do |io|
                io.puts "source \"#{filename}\""
            end
        end
    end
    changed
end
export_installation_manifest() click to toggle source

Update this workspace’s installation manifest

@param [Array<String>] package_names the name of the packages that

should be updated
# File lib/autoproj/workspace.rb, line 806
def export_installation_manifest
    installation_manifest.save
end
finalize_package_setup() click to toggle source

Finalizes the configuration loading

This must be done before before we run any dependency-sensitive operation (e.g. import)

# File lib/autoproj/workspace.rb, line 739
def finalize_package_setup
    set_as_main_workspace
    # Now call the blocks that the user defined in the autobuild files. We do it
    # now so that the various package directories are properly setup
    manifest.each_package_definition do |pkg|
        pkg.user_blocks.each do |blk|
            blk[pkg.autobuild]
        end
        pkg.setup = true
    end

    manifest.each_package_set do |source|
        if source.local_dir
            load_if_present(source, source.local_dir, "overrides.rb")
        end
    end

    main_package_set = manifest.main_package_set
    Dir.glob(File.join(overrides_dir, "*.rb")).sort.each do |file|
        load main_package_set, file
    end
end
finalize_setup(read_only: false) click to toggle source

Finalizes the complete setup

This must be done after all ignores/excludes and package selection have been properly set up (a.k.a. after package import)

# File lib/autoproj/workspace.rb, line 766
def finalize_setup(read_only: false)
    # Finally, disable all ignored packages on the autobuild side
    manifest.each_ignored_package(&:disable)

    # We now have processed the process setup blocks. All configuration
    # should be done and we can save the configuration data.
    config.save unless read_only
end
full_env() click to toggle source

The environment as initialized by all selected packages

# File lib/autoproj/workspace.rb, line 811
def full_env
    env = self.env.dup
    manifest.all_selected_source_packages.each do |pkg|
        pkg.autobuild.apply_env(env)
    end
    env
end
import_report_path() click to toggle source

The full path to the update report

@return [String]

# File lib/autoproj/workspace.rb, line 254
def import_report_path
    File.join(log_dir, IMPORT_REPORT_BASENAME)
end
install_os_packages(packages, all: all_os_packages, **options) click to toggle source
# File lib/autoproj/workspace.rb, line 876
def install_os_packages(packages, all: all_os_packages, **options)
    os_package_installer.install(packages, all: all, **options)
end
install_os_repositories() click to toggle source
# File lib/autoproj/workspace.rb, line 880
def install_os_repositories
    return unless os_package_installer.osdeps_mode.include?("os")

    os_repository_installer.install_os_repositories
end
install_ruby_shims() click to toggle source
# File lib/autoproj/workspace.rb, line 402
def install_ruby_shims
    install_suffix = ""
    if (match = /ruby(.*)$/.match(RbConfig::CONFIG["RUBY_INSTALL_NAME"]))
        install_suffix = match[1]
    end

    bindir = File.join(prefix_dir, "bin")
    FileUtils.mkdir_p bindir
    env.add "PATH", bindir

    Ops.atomic_write(File.join(bindir, "ruby")) do |io|
        io.puts "#! /bin/sh"
        io.puts "exec #{config.ruby_executable} \"$@\""
    end
    FileUtils.chmod 0o755, File.join(bindir, "ruby")

    %w[gem irb testrb].each do |name|
        # Look for the corresponding gem program
        prg_name = "#{name}#{install_suffix}"
        if File.file?(prg_path = File.join(RbConfig::CONFIG["bindir"], prg_name))
            Ops.atomic_write(File.join(bindir, name)) do |io|
                io.puts "#! #{config.ruby_executable}"
                io.puts "exec \"#{prg_path}\", *ARGV"
            end
            FileUtils.chmod 0o755, File.join(bindir, name)
        end
    end
end
installation_manifest() click to toggle source

Generate a {InstallationManifest} with the currently known information

@return [InstallationManifest]

# File lib/autoproj/workspace.rb, line 784
def installation_manifest
    selected_packages = manifest.all_selected_source_packages
    install_manifest = InstallationManifest.new(installation_manifest_path)

    # Update the new entries
    manifest.each_package_set do |pkg_set|
        next if pkg_set.main?

        install_manifest.add_package_set(pkg_set)
    end
    selected_packages.each do |pkg_name|
        pkg = manifest.package_definition_by_name(pkg_name)
        install_manifest.add_package(pkg)
    end
    # And save
    install_manifest
end
installation_manifest_path() click to toggle source

The installation manifest

# File lib/autoproj/workspace.rb, line 182
def installation_manifest_path
    InstallationManifest.path_for_workspace_root(root_dir)
end
load(*args) click to toggle source
Calls superclass method Autoproj::Ops::Loader#load
# File lib/autoproj/workspace.rb, line 159
def load(*args)
    set_as_main_workspace
    flag = Autoproj.warn_deprecated_level
    Autoproj.warn_deprecated_level = 1
    super
ensure
    Autoproj.warn_deprecated_level = flag
end
load_all_available_package_manifests() click to toggle source
# File lib/autoproj/workspace.rb, line 667
def load_all_available_package_manifests
    manifest.load_all_available_package_manifests
end
load_autoprojrc() click to toggle source

Loads the .autoprojrc file

This is included in {setup}

# File lib/autoproj/workspace.rb, line 636
def load_autoprojrc
    set_as_main_workspace
    rcfile = Workspace.rcfile_path
    Kernel.load(rcfile) if File.file?(rcfile)
end
load_cached_env() click to toggle source
# File lib/autoproj/workspace.rb, line 847
def load_cached_env
    Ops.load_cached_env(root_dir)
end
load_config(reconfigure = false) click to toggle source

Load the configuration for this workspace from config_file_path

@param [Boolean] reset Set to true to replace the configuration object,

set to false to load into the existing

@return [Configuration] configuration object

# File lib/autoproj/workspace.rb, line 280
def load_config(reconfigure = false)
    if File.file?(config_file_path)
        config.reset
        config.load(path: config_file_path, reconfigure: reconfigure)
        manifest.vcs =
            if (raw_vcs = config.get("manifest_source", nil))
                VCSDefinition.from_raw(raw_vcs)
            else
                local_vcs = { type: "local", url: config_dir }
                VCSDefinition.from_raw(local_vcs)
            end

        if config.source_dir && Pathname.new(config.source_dir).absolute?
            raise ConfigError, "source dir path configuration must be relative"
        end

        os_package_resolver.prefer_indep_over_os_packages =
            config.prefer_indep_over_os_packages?
        os_package_resolver.operating_system ||=
            config.get("operating_system", nil)
        os_repository_resolver.operating_system ||=
            config.get("operating_system", nil)
    end
    @config
end
load_main_initrb() click to toggle source

Loads autoproj/init.rb

This is included in {setup}

# File lib/autoproj/workspace.rb, line 546
def load_main_initrb
    set_as_main_workspace

    local_source = manifest.main_package_set
    load_if_present(local_source, config_dir, "init.rb")
end
load_package_sets(only_local: false, checkout_only: true, reconfigure: false, keep_going: false, mainline: nil, reset: false, retry_count: nil) click to toggle source
# File lib/autoproj/workspace.rb, line 642
def load_package_sets(only_local: false,
    checkout_only: true,
    reconfigure: false,
    keep_going: false,
    mainline: nil,
    reset: false,
    retry_count: nil)
    return unless File.file?(manifest_file_path) # empty install, just return

    Ops::Configuration.new(self)
                      .load_package_sets(only_local: only_local,
                                         checkout_only: checkout_only,
                                         keep_going: keep_going,
                                         reset: reset,
                                         retry_count: retry_count,
                                         mainline: mainline)
end
load_packages(selection = manifest.default_packages(false), options = {}) click to toggle source
# File lib/autoproj/workspace.rb, line 660
def load_packages(selection = manifest.default_packages(false), options = {})
    options = Hash[warn_about_ignored_packages: true, checkout_only: true]
              .merge(options)
    ops = Ops::Import.new(self)
    ops.import_packages(selection, options)
end
log_dir() click to toggle source
# File lib/autoproj/workspace.rb, line 236
def log_dir
    File.join(prefix_dir, "log")
end
manifest_file_path() click to toggle source

The path to the workspace’s manifest file

# File lib/autoproj/workspace.rb, line 192
def manifest_file_path
    File.join(root_dir, "autoproj", config.get("manifest_name", "manifest"))
end
migrate_bundler_and_autoproj_gem_layout() click to toggle source
# File lib/autoproj/workspace.rb, line 506
def migrate_bundler_and_autoproj_gem_layout
    if File.directory?(File.join(dot_autoproj_dir, "autoproj"))
        config_path = File.join(dot_autoproj_dir, "config.yml")
        config = YAML.safe_load(File.read(config_path))
        return if config["gems_install_path"]
    else
        return
    end

    Autoproj.silent = false
    Autoproj.warn "The way bundler and autoproj are installed changed"
    Autoproj.warn "You must download"
    Autoproj.warn "   https://raw.githubusercontent.com/rock-core/autoproj/master/bin/autoproj_install"
    Autoproj.warn "and run it at the root of this workspace"
    exit 2
end
operating_system() click to toggle source
# File lib/autoproj/workspace.rb, line 332
def operating_system
    os_package_resolver.operating_system
end
overrides_dir() click to toggle source

Returns the directory containing overrides files

@return [String]

# File lib/autoproj/workspace.rb, line 245
def overrides_dir
    File.join(config_dir, OVERRIDES_DIR)
end
prefix_dir() click to toggle source

(see Configuration#prefix_dir)

# File lib/autoproj/workspace.rb, line 203
def prefix_dir
    File.expand_path(config.prefix_dir, root_dir)
end
prefix_dir=(path) click to toggle source

Change {prefix_dir}

# File lib/autoproj/workspace.rb, line 208
def prefix_dir=(path)
    config.prefix_dir = path
end
pristine_os_packages(packages, options = Hash.new) click to toggle source
# File lib/autoproj/workspace.rb, line 851
def pristine_os_packages(packages, options = Hash.new)
    os_package_installer.pristine(packages, options)
end
register_package(package, block = nil, package_set = manifest.main_package_set, file = nil) click to toggle source

Register an autobuild package on this workspace

@param [Autobuild::Package] package @param [PackageSet] package_set the package set into which this

package is defined

@param [String,nil] file the path to the file that defines this

package (used for error reporting)

@param [Proc,nil] block a setup block that should be called to

configure the package

@return [PackageDefinition]

# File lib/autoproj/workspace.rb, line 914
def register_package(package, block = nil,
    package_set = manifest.main_package_set, file = nil)
    pkg = manifest.register_package(package, block, package_set, file)
    pkg.autobuild.ws = self
    pkg
end
register_workspace() click to toggle source
# File lib/autoproj/workspace.rb, line 617
def register_workspace
    current_workspaces = Workspace.registered_workspaces
    existing = current_workspaces.find { |w| w.root_dir == root_dir }
    if existing
        if existing.prefix_dir == prefix_dir && existing.build_dir == build_dir
            return
        end

        existing.prefix_dir = prefix_dir
        existing.build_dir  = build_dir
    else
        current_workspaces << self
    end
    Workspace.save_registered_workspaces(current_workspaces)
end
remotes_dir() click to toggle source

Return the directory in which remote package set definition should be checked out

# File lib/autoproj/workspace.rb, line 198
def remotes_dir
    File.join(dot_autoproj_dir, "remotes")
end
rewrite_shims() click to toggle source
# File lib/autoproj/workspace.rb, line 431
def rewrite_shims
    gemfile  = File.join(dot_autoproj_dir, "Gemfile")
    binstubs = File.join(dot_autoproj_dir, "bin")
    Ops::Install.rewrite_shims(binstubs, config.ruby_executable,
                               root_dir, gemfile, config.gems_gem_home)
end
run(*args, &block) click to toggle source
# File lib/autoproj/workspace.rb, line 494
def run(*args, &block)
    options =
        if args.last.kind_of?(Hash)
            args.pop
        else
            Hash.new
        end
    options_env = options.fetch(:env, Hash.new)
    options[:env] = env.resolved_env.merge(options_env)
    Autobuild::Subprocess.run(*args, options, &block)
end
save_cached_env(env = full_env) click to toggle source
# File lib/autoproj/workspace.rb, line 843
def save_cached_env(env = full_env)
    Ops.save_cached_env(root_dir, env)
end
save_config() click to toggle source
# File lib/autoproj/workspace.rb, line 306
def save_config
    config.save(config_file_path)
end
set_as_main_workspace() { || ... } click to toggle source
# File lib/autoproj/workspace.rb, line 523
def set_as_main_workspace
    Autoproj.workspace = self
    Autoproj.root_dir = root_dir
    Autobuild.env = env

    if block_given?
        begin
            yield
        ensure
            clear_main_workspace
        end
    end
end
setup(load_global_configuration: true, read_only: false) click to toggle source

Perform initial configuration load and workspace setup

@param [Boolean] load_global_configuration if true, load the global

autoprojrc file if it exists. Otherwise, ignore it.
# File lib/autoproj/workspace.rb, line 358
def setup(load_global_configuration: true, read_only: false)
    setup_ruby_version_handling
    migrate_bundler_and_autoproj_gem_layout
    load_config
    unless read_only
        register_workspace
        rewrite_shims
    end
    autodetect_operating_system
    config.validate_ruby_executable
    Autobuild.programs["ruby"] = config.ruby_executable
    config.apply_autobuild_configuration
    load_autoprojrc if load_global_configuration
    load_main_initrb
    config.each_reused_autoproj_installation do |p|
        manifest.reuse(p)
    end
    manifest.load(manifest_file_path) if File.exist?(manifest_file_path)

    Autobuild.prefix = prefix_dir
    unless read_only
        FileUtils.mkdir_p File.join(prefix_dir, ".autoproj")
        Ops.atomic_write(File.join(prefix_dir, ".autoproj", "config.yml")) do |io|
            io.puts "workspace: \"#{root_dir}\""
        end
    end

    Autobuild.srcdir = source_dir
    Autobuild.logdir = log_dir
    if (cache_dir = config.importer_cache_dir)
        Autobuild::Importer.default_cache_dirs = cache_dir
        os_package_installer.each_manager_with_name do |name, manager|
            next unless manager.respond_to?(:cache_dir=)

            manager_cache_path = File.join(cache_dir, "package_managers", name)
            if File.directory?(manager_cache_path)
                manager.cache_dir = manager_cache_path
            end
        end
    end
    setup_os_package_installer
    install_ruby_shims unless read_only
end
setup_all_package_directories() click to toggle source
# File lib/autoproj/workspace.rb, line 671
def setup_all_package_directories
    # Override the package directories from our reused installations
    imported_packages = Set.new
    manifest.reused_installations.each do |imported_manifest|
        imported_manifest.each do |imported_pkg|
            imported_packages << imported_pkg.name
            if (pkg = manifest.find_package_definition(imported_pkg.name))
                pkg.autobuild.srcdir = imported_pkg.srcdir
                pkg.autobuild.prefix = imported_pkg.prefix
            end
        end
    end

    manifest.each_package_definition do |pkg_def|
        pkg = pkg_def.autobuild
        next if imported_packages.include?(pkg_def.name)

        setup_package_directories(pkg)
    end
end
setup_os_package_installer() click to toggle source
# File lib/autoproj/workspace.rb, line 340
def setup_os_package_installer
    autodetect_operating_system
    os_package_installer.each_manager(&:initialize_environment)
    os_package_resolver.load_default
    os_package_installer.define_osdeps_mode_option
    os_package_installer.osdeps_mode
    os_package_installer.configure_manager
end
setup_package_directories(pkg) click to toggle source
# File lib/autoproj/workspace.rb, line 692
def setup_package_directories(pkg)
    pkg_name = pkg.name

    layout =
        if config.randomize_layout?
            Digest::SHA256.hexdigest(pkg_name)[0, 12]
        else
            manifest.whereis(pkg_name)
        end

    srcdir =
        if (target = manifest.moved_packages[pkg_name])
            File.join(layout, target)
        else
            File.join(layout, pkg_name)
        end

    prefixdir =
        if config.separate_prefixes?
            pkg_name
        else
            layout
        end

    pkg = manifest.find_autobuild_package(pkg_name)
    pkg.srcdir = File.join(source_dir, srcdir)
    pkg.builddir = compute_builddir(pkg) if pkg.respond_to?(:builddir)

    pkg.prefix = File.join(prefix_dir, prefixdir)
    pkg.doc_target_dir = File.join(prefix_dir, "doc", pkg_name)
    pkg.logdir = File.join(pkg.prefix, "log")
end
setup_ruby_version_handling() click to toggle source
# File lib/autoproj/workspace.rb, line 349
def setup_ruby_version_handling
    os_package_resolver.add_aliases("ruby" => ruby_version_keyword)
    osdep_suffixes << ruby_version_keyword
end
source_dir() click to toggle source

(see Configuration#source_dir)

# File lib/autoproj/workspace.rb, line 223
def source_dir
    if config.source_dir
        File.expand_path(config.source_dir, root_dir)
    else
        root_dir
    end
end
source_dir=(path) click to toggle source

Change {#source_dir}

# File lib/autoproj/workspace.rb, line 232
def source_dir=(path)
    config.set "source", path, true
end
supported_operating_system?() click to toggle source
# File lib/autoproj/workspace.rb, line 336
def supported_operating_system?
    os_package_resolver.supported_operating_system?
end
update_autoproj(restart_on_update: true) click to toggle source
# File lib/autoproj/workspace.rb, line 450
def update_autoproj(restart_on_update: true)
    config.validate_ruby_executable

    # This is a guard to avoid infinite recursion in case the user is
    # running autoproj osdeps --force
    return if ENV["AUTOPROJ_RESTARTING"] == "1"

    gemfile  = File.join(dot_autoproj_dir, "Gemfile")
    binstubs = File.join(dot_autoproj_dir, "bin")
    if restart_on_update
        old_autoproj_path = PackageManagers::BundlerManager.bundle_gem_path(
            self, "autoproj", gemfile: gemfile
        )
    end
    begin
        Autoproj.message "  updating autoproj"
        PackageManagers::BundlerManager.run_bundler_install(
            self, gemfile, binstubs: binstubs
        )
    ensure
        rewrite_shims
    end
    if restart_on_update
        new_autoproj_path = PackageManagers::BundlerManager.bundle_gem_path(
            self, "autoproj", gemfile: gemfile
        )
    end

    # First things first, see if we need to update ourselves
    if new_autoproj_path != old_autoproj_path
        puts
        Autoproj.message "autoproj has been updated, restarting"
        puts

        # We updated autobuild or autoproj themselves ... Restart !
        #
        # ...But first save the configuration (!)
        config.save
        ENV["AUTOPROJ_RESTARTING"] = "1"
        require "rbconfig"
        exec(config.ruby_executable, $PROGRAM_NAME, *ARGV)
    end
end
update_bundler() click to toggle source
# File lib/autoproj/workspace.rb, line 438
def update_bundler
    require "autoproj/ops/install"
    gem_program = Ops::Install.guess_gem_program
    install = Ops::Install.new(root_dir)
    Autoproj.message "  updating bundler"
    install.install_bundler(
        gem_program,
        version: config.bundler_version,
        silent: true
    )
end
utility_report_path(name) click to toggle source

The full path to the report generated by the given utility

@return [String]

# File lib/autoproj/workspace.rb, line 270
def utility_report_path(name)
    File.join(log_dir, "#{name}_report.json")
end
which(cmd, _path_entries: nil) click to toggle source

Find the given executable file in PATH

If ‘cmd` is an absolute path, it will either return it or raise if `cmd` is not executable. Otherwise, looks for an executable named `cmd` in PATH and returns it, or raises if it cannot be found. The exception contains a more detailed reason for failure

@param [String] cmd @return [String] the resolved program @raise [ExecutableNotFound] if an executable file named ‘cmd` cannot

be found
# File lib/autoproj/workspace.rb, line 933
def which(cmd, _path_entries: nil)
    Ops.which(cmd, path_entries: -> { full_env.value("PATH") || Array.new })
end