Struct WineConfig

pub struct WineConfig { /* private fields */ }

The main conversion struct: create one of these to do conversions.

Tracks the WINEPREFIX and the drive letter mappings so they don’t have to be recomputed every time you convert a path.

Implementations

impl WineConfig

pub fn from_env() -> Result<Self, WinePathError>

Determine the wine prefix from the environment.

Examples found in repository

examples/winepath.rs (line 31)

fn main() {
    let mut action = Action::ToUnix;
    let mut path = None;

    if let Some(arg) = std::env::args().nth(1) {
        match arg.as_str() {
            "-u" => action = Action::ToUnix,
            "-w" => action = Action::ToWindows,
            _ => path = Some(arg),
        }
    } else {
        panic!("usage: winepath [OPTION] [PATH]")
    };

    let path = if let Some(path) = path {
        path
    } else if let Some(path) = std::env::args().nth(2) {
        path
    } else {
        panic!("usage: winepath [OPTION] [PATH]");
    };

    let config = WineConfig::from_env().unwrap();
    println!(
        "{}",
        match action {
            Action::ToUnix => config
                .to_native_path(path)
                .unwrap()
                .to_string_lossy()
                .to_string(),
            Action::ToWindows => {
                let path = std::fs::canonicalize(path).unwrap();
                config.to_wine_path(path).unwrap().to_string()
            }
        }
    )
}

pub fn from_prefix(path: impl Into<PathBuf>) -> Self

Create a config assuming that the given path is a valid WINEPREFIX.

Note that this is not validated, and you will end up with empty drive mappings if it is not actually a wine prefix.

You can manually validate if a directory is Wine-y enough by doing:

use std::path::Path;
fn is_wineprefix_like(some_path: &Path) -> bool {
    some_path.join("dosdevices").is_dir()
}

pub fn prefix(&self) -> &Path

Get the current wine prefix.

pub fn to_wine_path( &self, path: impl AsRef<Path>, ) -> Result<WinePath, WinePathError>

Convert a native file path to a Wine path.

use winepath::WineConfig;
let config = WineConfig::from_env().unwrap();
let path = config.to_wine_path("/home/username/.wine/drive_c/Program Files/CoolApp/start.exe").unwrap();
assert_eq!(path.to_string(), r"c:\Program Files\CoolApp\start.exe");
let path = config.to_wine_path("/home/username/some-path/some-file").unwrap();
assert_eq!(path.to_string(), r"z:\home\username\some-path\some-file");

Examples found in repository

examples/winepath.rs (line 42)

fn main() {
    let mut action = Action::ToUnix;
    let mut path = None;

    if let Some(arg) = std::env::args().nth(1) {
        match arg.as_str() {
            "-u" => action = Action::ToUnix,
            "-w" => action = Action::ToWindows,
            _ => path = Some(arg),
        }
    } else {
        panic!("usage: winepath [OPTION] [PATH]")
    };

    let path = if let Some(path) = path {
        path
    } else if let Some(path) = std::env::args().nth(2) {
        path
    } else {
        panic!("usage: winepath [OPTION] [PATH]");
    };

    let config = WineConfig::from_env().unwrap();
    println!(
        "{}",
        match action {
            Action::ToUnix => config
                .to_native_path(path)
                .unwrap()
                .to_string_lossy()
                .to_string(),
            Action::ToWindows => {
                let path = std::fs::canonicalize(path).unwrap();
                config.to_wine_path(path).unwrap().to_string()
            }
        }
    )
}

pub fn to_native_path( &self, path: impl Into<WinePath>, ) -> Result<PathBuf, WinePathError>

Convert a Wine path to a native file path.

use winepath::WineConfig;
use std::path::PathBuf;
let config = WineConfig::from_env().unwrap();
let path = config.to_native_path(r"c:\Program Files\CoolApp\start.exe").unwrap();
assert_eq!(path, PathBuf::from("/home/username/.wine/drive_c/Program Files/CoolApp/start.exe"));
let path = config.to_native_path(r"z:\home\username\some-path\some-file").unwrap();
assert_eq!(path, PathBuf::from("/home/username/some-path/some-file"));

Examples found in repository

examples/winepath.rs (line 36)

fn main() {
    let mut action = Action::ToUnix;
    let mut path = None;

    if let Some(arg) = std::env::args().nth(1) {
        match arg.as_str() {
            "-u" => action = Action::ToUnix,
            "-w" => action = Action::ToWindows,
            _ => path = Some(arg),
        }
    } else {
        panic!("usage: winepath [OPTION] [PATH]")
    };

    let path = if let Some(path) = path {
        path
    } else if let Some(path) = std::env::args().nth(2) {
        path
    } else {
        panic!("usage: winepath [OPTION] [PATH]");
    };

    let config = WineConfig::from_env().unwrap();
    println!(
        "{}",
        match action {
            Action::ToUnix => config
                .to_native_path(path)
                .unwrap()
                .to_string_lossy()
                .to_string(),
            Action::ToWindows => {
                let path = std::fs::canonicalize(path).unwrap();
                config.to_wine_path(path).unwrap().to_string()
            }
        }
    )
}

Trait Implementations

impl Debug for WineConfig

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

Formats the value using the given formatter.