Struct Tool

pub struct Tool {
    pub backend: Option<Backend>,
    pub id: Id,
    pub locator: Option<PluginLocator>,
    pub metadata: ToolMetadata,
    pub plugin: Arc<PluginContainer>,
    pub proto: Arc<ProtoEnvironment>,
    pub version: Option<VersionSpec>,
    pub inventory: Inventory,
    pub product: Product,
    /* private fields */
}

Fields

backend: Option<Backend>

id: Id

locator: Option<PluginLocator>

metadata: ToolMetadata

plugin: Arc<PluginContainer>

proto: Arc<ProtoEnvironment>

version: Option<VersionSpec>

inventory: Inventory

product: Product

Implementations

impl Tool

pub fn is_installed(&self) -> bool

Return true if the tool has been installed. This is less accurate than is_setup, as it only checks for the existence of the inventory directory.

pub async fn verify_checksum( &self, checksum_file: &Path, download_file: &Path, checksum_public_key: Option<&str>, ) -> Result<bool>

Verify the downloaded file using the checksum strategy for the tool. Common strategies are SHA256 and MD5.

pub async fn build_from_source( &self, install_dir: &Path, temp_dir: &Path, options: InstallOptions, ) -> Result<()>

Build the tool from source using a set of requirements and instructions into the ~/.proto/tools/<version> folder.

pub async fn install_from_prebuilt( &self, install_dir: &Path, temp_dir: &Path, options: InstallOptions, ) -> Result<()>

Download the tool (as an archive) from its distribution registry into the ~/.proto/tools/<version> folder, and optionally verify checksums.

pub async fn install(&mut self, options: InstallOptions) -> Result<bool>

Install a tool into proto, either by downloading and unpacking a pre-built archive, or by using a native installation method.

pub async fn uninstall(&self) -> Result<bool>

Uninstall the tool by deleting the current install directory.

impl Tool

pub async fn generate_shims(&mut self, force: bool) -> Result<()>

Create shim files for the current tool if they are missing or out of date. If find only is enabled, will only check if they exist, and not create.

pub async fn symlink_bins(&mut self, force: bool) -> Result<()>

Symlink all primary and secondary binaries for the current tool.

impl Tool

pub async fn resolve_primary_exe_location( &self, ) -> Result<Option<ExecutableLocation>>

Return location information for the primary executable within the tool directory.

pub async fn resolve_secondary_exe_locations( &self, ) -> Result<Vec<ExecutableLocation>>

Return location information for all secondary executables within the tool directory.

pub async fn resolve_bin_locations( &mut self, include_all_versions: bool, ) -> Result<Vec<ExecutableLocation>>

Return a list of all binaries that get created in ~/.proto/bin. The list will contain the executable config, and an absolute path to the binaries final location.

pub async fn resolve_bin_locations_with_manager( &mut self, bin_manager: BinManager, include_all_versions: bool, ) -> Result<Vec<ExecutableLocation>>

pub async fn resolve_shim_locations(&self) -> Result<Vec<ExecutableLocation>>

Return a list of all shims that get created in ~/.proto/shims. The list will contain the executable config, and an absolute path to the shims final location.

pub fn get_exe_file(&self) -> Option<&Path>

Return an absolute path to the primary executable file, after it has been located.

pub async fn locate_exe_file(&mut self) -> Result<PathBuf>

Locate the primary executable from the tool directory.

pub fn get_exes_dir(&self) -> Option<&Path>

Return an absolute path to the primary executables directory (first in the list), after it has been located.

pub fn get_exes_dirs(&self) -> &[PathBuf]

Return an absolute path to all executable directories, after they have been located.

pub async fn locate_exes_dirs(&mut self) -> Result<Vec<PathBuf>>

Locate the directory that local executables are installed to.

pub fn get_globals_dir(&self) -> Option<&Path>

Return an absolute path to the globals directory, after it has been located.

pub async fn locate_globals_dir(&mut self) -> Result<Option<PathBuf>>

Return an absolute path to the globals directory that actually exists and contains files (binaries).

pub fn get_globals_dirs(&self) -> &[PathBuf]

Return an absolute path to all globals directories, after they have been located.

pub async fn locate_globals_dirs(&mut self) -> Result<Vec<PathBuf>>

Locate the directories that global packages are installed to. Will expand environment variables, and filter out invalid paths.

pub fn get_globals_prefix(&self) -> Option<&str>

Return the globals prefix, after it has been located.

pub async fn locate_globals_prefix(&mut self) -> Result<Option<String>>

Return a string that all globals are prefixed with. Will be used for filtering and listing.

impl Tool

pub async fn load_version_resolver( &self, initial_version: &UnresolvedVersionSpec, ) -> Result<VersionResolver<'_>>

Load available versions to install and return a resolver instance. To reduce network overhead, results will be cached for 24 hours.

pub async fn resolve_backend(&mut self, backend: Option<Backend>) -> Result<()>

Given a custom backend, resolve and register it to acquire necessary files.

pub async fn resolve_version_with_spec( &mut self, spec: &ToolSpec, short_circuit: bool, ) -> Result<VersionSpec>

pub async fn resolve_version( &mut self, initial_version: &UnresolvedVersionSpec, short_circuit: bool, ) -> Result<VersionSpec>

Given an initial version, resolve it to a fully qualifed and semantic version (or alias) according to the tool’s ecosystem.

pub async fn resolve_version_candidate( &self, resolver: &VersionResolver<'_>, initial_candidate: &UnresolvedVersionSpec, with_manifest: bool, ) -> Result<VersionSpec>

pub async fn detect_version_from( &self, current_dir: &Path, ) -> Result<Option<(UnresolvedVersionSpec, PathBuf)>>

Attempt to detect an applicable version from the provided directory.

impl Tool

pub async fn is_setup_with_spec(&mut self, spec: &ToolSpec) -> Result<bool>

pub async fn is_setup( &mut self, initial_version: &UnresolvedVersionSpec, ) -> Result<bool>

Return true if the tool has been setup (installed and binaries are located).

pub async fn setup_with_spec( &mut self, spec: &ToolSpec, options: InstallOptions, ) -> Result<bool>

pub async fn setup( &mut self, initial_version: &UnresolvedVersionSpec, options: InstallOptions, ) -> Result<bool>

Setup the tool by resolving a semantic version, installing the tool, locating binaries, creating shims, and more.

pub async fn teardown(&mut self) -> Result<bool>

Teardown the tool by uninstalling the current version, removing the version from the manifest, and cleaning up temporary files. Return true if the teardown occurred.

pub async fn cleanup(&mut self) -> Result<()>

Delete temporary files and downloads for the current version.

impl Tool

pub async fn new( id: Id, proto: Arc<ProtoEnvironment>, plugin: Arc<PluginContainer>, ) -> Result<Self>

pub async fn load<I: AsRef<Id> + Debug, P: AsRef<ProtoEnvironment>>( id: I, proto: P, wasm: Wasm, ) -> Result<Self>

pub async fn load_from_manifest<I: AsRef<Id>, P: AsRef<ProtoEnvironment>>( id: I, proto: P, manifest: PluginManifest, ) -> Result<Self>

pub fn create_plugin_manifest<P: AsRef<ProtoEnvironment>>( proto: P, wasm: Wasm, ) -> Result<PluginManifest>

pub fn disable_caching(&mut self)

Disable internal caching when applicable.

pub fn get_env_var_prefix(&self) -> String

Return the prefix for environment variable names.

pub fn get_inventory_dir(&self) -> PathBuf

Return an absolute path to the tool’s inventory directory. The inventory houses installed versions, the manifest, and more.

pub fn get_name(&self) -> &str

Return a human readable name for the tool.

pub fn get_resolved_version(&self) -> VersionSpec

Return the resolved version or “latest”.

pub fn get_temp_dir(&self) -> PathBuf

Return an absolute path to a temp directory solely for this tool.

pub fn get_product_dir(&self) -> PathBuf

Return an absolute path to the tool’s install directory for the currently resolved version.

pub fn set_version(&mut self, version: VersionSpec)

Explicitly set the version to use.

pub fn from_virtual_path(&self, path: &Path) -> PathBuf

Convert a virtual path to a real path.

pub fn to_virtual_path(&self, path: &Path) -> VirtualPath

Convert a real path to a virtual path.

impl Tool

pub fn create_context(&self) -> ToolContext

Return contextual information to pass to WASM plugin functions.

pub async fn register_tool(&mut self) -> Result<()>

Register the tool by loading initial metadata and persisting it.

pub async fn register_backend(&mut self) -> Result<()>

Register the backend by acquiring necessary source files.

pub async fn sync_manifest(&mut self) -> Result<()>

Sync the local tool manifest with changes from the plugin.

Trait Implementations

impl Debug for Tool

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.