User Directories and Preferred Applications

Recipe	Crates	Categories
dirs
directories
Open a file or URL using the program configured on your System

Get platform-specific locations for configuration, cache, and other data.

dirs

dirs⮳ is a low-level library that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows, macOS and Redox by leveraging the mechanisms defined by the XDG base/user directory specifications on Linux, the Known Folder API on Windows, and the Standard Directory guidelines on macOS.

//! The `dirs` crate provides a convenient way to get paths to
//! standard directories on the file system.

fn main() {
    // Get the home directory.
    if let Some(home_dir) = dirs::home_dir() {
        println!("Home directory: {:?}", home_dir);
    } else {
        println!("Home directory could not be found.");
    }

    // Get the configuration directory.
    if let Some(config_dir) = dirs::config_dir() {
        println!("Configuration directory: {:?}", config_dir);
    } else {
        println!("Configuration directory could not be found.");
    }

    // Get the data directory.
    if let Some(data_dir) = dirs::data_dir() {
        println!("Data directory: {:?}", data_dir);
    } else {
        println!("Data directory could not be found.");
    }

    // Get the cache directory.
    if let Some(cache_dir) = dirs::cache_dir() {
        println!("Cache directory: {:?}", cache_dir);
    } else {
        println!("Cache directory could not be found.");
    }

    // Get the executable directory.
    if let Some(exec_dir) = dirs::executable_dir() {
        println!("Executable directory: {:?}", exec_dir);
    } else {
        println!("Executable directory could not be found.");
    }
}

directories

directories⮳ is a mid-level library that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows and macOS by leveraging the mechanisms defined by the XDG base/user directory specifications on Linux, the Known Folder API on Windows, and the Standard Directory guidelines on macOS.

directories⮳ is a higher-level library than dirs⮳ and can also compute paths for applications.

//! This example demonstrates how to use the `directories` crate to find the
//! user's data and config directories.

use std::path::PathBuf;

use anyhow::Result;
use anyhow::anyhow;
use directories::ProjectDirs;

/// Returns the user's data directory.
pub fn get_data_dir() -> Result<PathBuf> {
    let directory = if let Ok(s) = std::env::var("APP_DATA_DIR") {
        PathBuf::from(s)
    } else if let Some(proj_dirs) =
        ProjectDirs::from("com", "Foo Corp", "Bar App")
    {
        proj_dirs.data_local_dir().to_path_buf()
    } else {
        return Err(anyhow!("Unable to find the data directory"));
    };
    Ok(directory)
}

/// Returns the user's config directory.
pub fn get_config_dir() -> Result<PathBuf> {
    let directory = if let Ok(s) = std::env::var("APP_CONFIG_DIR") {
        PathBuf::from(s)
    } else if let Some(proj_dirs) =
        ProjectDirs::from("com", "Foo Corp", "Bar App")
    {
        proj_dirs.config_local_dir().to_path_buf()
    } else {
        return Err(anyhow!("Unable to find the config directory"));
    };
    Ok(directory)
}

fn main() {
    println!("{:?}", get_data_dir());
    println!("{:?}", get_config_dir());
}

Open a file or URL using the program configured on your System

open⮳ opens a path or URL using the program configured on the system.

//! Demonstrates how to use the `open` crate to open files and URLs using the
//! default program associated with the file type.

fn main() {
    //  The `that` function attempts to open the specified path with the
    // appropriate application. If an error occurs during the opening
    // process, it will be printed to the standard error stream.
    if let Err(e) = open::that("example.txt") {
        eprintln!("Failed to open file: {}", e);
    }

    // Open a URL using the default web browser.
    if let Err(e) = open::that("https://www.rust-lang.org") {
        eprintln!("Failed to open URL: {}", e);
    }
    // OR: open::with("http://rust-lang.org", "firefox")?;

    // Depending on the platform and system configuration, launchers can block.
    // If you want to be sure they don't, use `that_in_background()` or
    // `that_detached` instead.

    // Get the commands that would be used to try to open the specified path.
    // This is useful for understanding how the `open` crate would handle a
    // given path. The commands are printed to the standard output stream.
    let path = "http://rust-lang.org";
    open::commands(path)
        .iter()
        .for_each(|x| println!("{:?}", x));
}