Struct proto_core::Tool

pub struct Tool {

    pub id: Id,
    pub manifest: ToolManifest,
    pub metadata: ToolMetadataOutput,
    pub locator: Option<PluginLocator>,
    pub plugin: Arc<PluginContainer>,
    pub proto: Arc<ProtoEnvironment>,
    pub version: Option<VersionSpec>,
    pub on_created_bins: Emitter<CreatedBinariesEvent>,
    pub on_created_shims: Emitter<CreatedShimsEvent>,
    pub on_installing: Emitter<InstallingEvent>,
    pub on_installed: Emitter<InstalledEvent>,
    pub on_installed_global: Emitter<InstalledGlobalEvent>,
    pub on_resolved_version: Emitter<ResolvedVersionEvent>,
    pub on_uninstalling: Emitter<UninstallingEvent>,
    pub on_uninstalled: Emitter<UninstalledEvent>,
    pub on_uninstalled_global: Emitter<UninstalledGlobalEvent>,
    /* private fields */
}

Fields

id: Id

manifest: ToolManifest

metadata: ToolMetadataOutput

locator: Option<PluginLocator>

plugin: Arc<PluginContainer>

proto: Arc<ProtoEnvironment>

version: Option<VersionSpec>

on_created_bins: Emitter<CreatedBinariesEvent>

on_created_shims: Emitter<CreatedShimsEvent>

on_installing: Emitter<InstallingEvent>

on_installed: Emitter<InstalledEvent>

on_installed_global: Emitter<InstalledGlobalEvent>

on_resolved_version: Emitter<ResolvedVersionEvent>

on_uninstalling: Emitter<UninstallingEvent>

on_uninstalled: Emitter<UninstalledEvent>

on_uninstalled_global: Emitter<UninstalledGlobalEvent>

Implementations

impl Tool

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

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

pub 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_tool_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 disable_progress_bars(&self) -> bool

Disable progress bars when installing or uninstalling the tool.

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 fn register_tool(&mut self) -> Result<()>

Register the tool by loading initial metadata and persisting it.

pub fn run_hook<I>(&self, hook: &str, input: impl FnOnce() -> I) -> Result<()>

where I: Debug + Serialize,

Run a hook with the provided name and input.

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

Sync the local tool manifest with changes from the plugin.

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_version( &mut self, initial_version: &UnresolvedVersionSpec, short_circuit: bool ) -> Result<()>

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

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 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) -> Result<()>

pub async fn install_from_prebuilt(&self, install_dir: &Path) -> 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, _build: bool) -> 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 install_global(&self, dependency: &str) -> Result<bool>

Install a global dependency/package for the tool.

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

Uninstall the tool by deleting the current install directory.

pub async fn uninstall_global(&self, dependency: &str) -> Result<bool>

Uninstall a global dependency/package from the tool.

impl Tool

pub async fn create_executables( &mut self, force_shims: bool, force_bins: bool ) -> Result<()>

Create all executables for the current tool.

• Locate the primary binary to execute.
• Generate shims to ~/.proto/shims.
• Symlink bins to ~/.proto/bin.

pub fn get_exe_path(&self) -> Result<&Path>

Return an absolute path to the executable file for the tool.

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

Return an absolute path to the globals directory in which packages are installed to.

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

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

pub fn get_bin_locations(&self) -> 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 fn get_exe_location(&self) -> Result<Option<ExecutableLocation>>

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

pub fn get_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 async fn locate_executable(&mut self) -> Result<()>

Locate the primary executable from the tool directory.

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

Locate the directory that global packages are installed to.

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 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( &mut self, initial_version: &UnresolvedVersionSpec, build_from_source: bool ) -> 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.