Struct proto_node::NodeLanguage

pub struct NodeLanguage {
    pub base_dir: PathBuf,
    pub bin_path: Option<PathBuf>,
    pub shim_path: Option<PathBuf>,
    pub temp_dir: PathBuf,
    pub version: Option<String>,
    /* private fields */
}

Fields

base_dir: PathBuf

bin_path: Option<PathBuf>

shim_path: Option<PathBuf>

temp_dir: PathBuf

version: Option<String>

Implementations

impl NodeLanguage

pub fn new<P: AsRef<Proto>>(proto: P) -> Self

Trait Implementations

impl Debug for NodeLanguage

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

Formats the value using the given formatter.

impl Describable<'_> for NodeLanguage

fn get_id(&self) -> &str

Return an identifier for the tool. Will also be used in variables, file names, and more.

fn get_name(&self) -> String

Return a human readable name of the tool.

impl Detector<'_> for NodeLanguage

fn detect_version_from<'life0, 'life1, 'async_trait>( &'life0 self, working_dir: &'life1 Path ) -> Pin<Box<dyn Future<Output = Result<Option<String>, ProtoError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Attempt to detect an applicable version from the provided working directory.

impl Downloadable<'_> for NodeLanguage

fn get_download_path(&self) -> Result<PathBuf, ProtoError>

Return an absolute file path to the downloaded file. This may not exist, as the path is composed ahead of time. This is typically ~/.proto/temp/<file>.

fn get_download_url(&self) -> Result<String, ProtoError>

Return a URL to download the tool’s archive from a registry.

fn download<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, to_file: &'life1 Path, from_url: Option<&'life2 str> ) -> Pin<Box<dyn Future<Output = Result<bool, ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: 'async_trait,

Download the tool (as an archive) from its distribution registry into the ~/.proto/temp folder and return an absolute file path. A custom URL that points to the downloadable archive can be provided as the 2nd argument.

impl Executable<'_> for NodeLanguage

fn find_bin_path<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<(), ProtoError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Find the absolute file path to the tool’s binary that will be executed. This happens after a tool has been downloaded and installed.

fn get_bin_path(&self) -> Result<&Path, ProtoError>

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

fn get_globals_bin_dir(&self) -> Result<Option<PathBuf>, ProtoError>

Return an absolute file path to the directory containing all globally installed packages.

impl Installable<'_> for NodeLanguage

fn get_archive_prefix(&self) -> Result<Option<String>, ProtoError>

Return a prefix that will be removed from all paths when unpacking an archive and copying the files.

fn get_install_dir(&self) -> Result<PathBuf, ProtoError>

Return an absolute file path to the directory containing the installed tool. This is typically ~/.proto/tools/<tool>/<version>.

fn install<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, install_dir: &'life1 Path, download_path: &'life2 Path ) -> Pin<Box<dyn Future<Output = Result<bool, ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: 'async_trait,

Run any installation steps after downloading and verifying the tool. This is typically unzipping an archive, and running any installers/binaries.

fn should_unpack(&self) -> bool

Whether or not the downloaded file should be unpacked before installing.

fn uninstall<'life0, 'life1, 'async_trait>( &'life0 self, install_dir: &'life1 Path ) -> Pin<Box<dyn Future<Output = Result<bool, ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Uninstall the tool by deleting the install directory.

impl Resolvable<'_> for NodeLanguage

fn get_resolved_version(&self) -> &str

Return the resolved version.

fn load_version_manifest<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<VersionManifest, ProtoError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Load the upstream version and release manifest.

fn resolve_version<'life0, 'life1, 'async_trait>( &'life0 mut self, initial_version: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<String, ProtoError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

fn set_version(&mut self, version: &str)

Explicitly set the resolved version.

fn get_default_version(&self) -> Option<&str>

Return the version to be used as the global default.

impl Shimable<'_> for NodeLanguage

fn create_shims<'life0, 'async_trait>( &'life0 mut self, find_only: bool ) -> Pin<Box<dyn Future<Output = Result<(), ProtoError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Create one or many shims in the root of the tool’s install directory.

fn get_shim_path(&self) -> Option<&Path>

Return an absolute path to the shim file if utilizing shims.

impl Tool<'_> for NodeLanguage

fn as_any(&self) -> &dyn Any

fn get_manifest(&self) -> Result<&Manifest, ProtoError>

fn get_manifest_mut(&mut self) -> Result<&mut Manifest, ProtoError>

fn get_tool_dir(&self) -> &Path

fn get_manifest_path(&self) -> PathBuf

fn before_setup<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<(), ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: 'async_trait,

fn setup<'life0, 'life1, 'async_trait>( &'life0 mut self, initial_version: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<bool, ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn setup_shims<'life0, 'async_trait>( &'life0 mut self, force: bool ) -> Pin<Box<dyn Future<Output = Result<(), ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: 'async_trait,

fn is_setup<'life0, 'life1, 'async_trait>( &'life0 mut self, initial_version: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<bool, ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn after_setup<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<(), ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: 'async_trait,

fn cleanup<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<(), ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: 'async_trait,

fn before_teardown<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<(), ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: 'async_trait,

fn teardown<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<bool, ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: 'async_trait,

fn after_teardown<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<(), ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: 'async_trait,

impl Verifiable<'_> for NodeLanguage

fn get_checksum_path(&self) -> Result<PathBuf, ProtoError>

Return an absolute file path to the checksum file. This may not exist, as the path is composed ahead of time. This is typically ~/.proto/temp/<file>.

fn get_checksum_url(&self) -> Result<Option<String>, ProtoError>

Return a URL to download the tool’s checksum manifest from a registry.

fn verify_checksum<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, checksum_file: &'life1 Path, download_file: &'life2 Path ) -> Pin<Box<dyn Future<Output = Result<bool, ProtoError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn download_checksum<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, to_file: &'life1 Path, from_url: Option<&'life2 str> ) -> Pin<Box<dyn Future<Output = Result<bool, ProtoError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: 'async_trait,

If applicable, download all files necessary for verifying checksums.