Handling paths in Rust

2021-06-21T00:00:00+00:00

Rust</a> is a very interesting language for system utility creation, a field where file & path manipulation is quite a basic & expected feature, especially in modern programming

In this post, we’ll explore rust</a>’s path manipulation facilities.

First stage: discovery & denial 🔗</a></h2>

The documentation tells us that std::path</code></a> is what we should use.

From the docs, here’s an example:

use </span>std</span>::</span>path</span>::</span>Path</span>;
</span>use </span>std</span>::</span>ffi</span>::</span>OsStr</span>;
</span>
</span>let</span> path </span>= </span>Path</span>::</span>new(</span>"/tmp/foo/bar.txt"</span>)</span>;
</span>
</span>let</span> parent </span>=</span> path</span>.</span>parent</span>()</span>;
</span>assert_eq!(parent</span>, </span>Some</span>(Path</span>::</span>new(</span>"/tmp/foo"</span>)))</span>;
</span>
</span>let</span> file_stem </span>=</span> path</span>.</span>file_stem</span>()</span>;
</span>assert_eq!(file_stem</span>, </span>Some</span>(OsStr</span>::</span>new(</span>"bar"</span>)))</span>;
</span>
</span>let</span> extension </span>=</span> path</span>.</span>extension</span>()</span>;
</span>assert_eq!(extension</span>, </span>Some</span>(OsStr</span>::</span>new(</span>"txt"</span>)))</span>;
</span></code></pre>
Indeed, using a rust Path</code> is convenient: non need to call fs::metadata(&str)</code> to get the files’ metadata!</p>
Things get complicated when we start to need to display this Path</code>, as would be useful in the case of application logs.</p>
Here’s some code, written on rust playground</a>:</p>
fn </span>main</span>() {
</span>    </span>use </span>std</span>::</span>path</span>::</span>Path</span>;
</span>    
</span>    </span>let</span> path</span>: </span>&</span>Path </span>= </span>Path</span>::</span>new(</span>"/tmp/foo/bar.txt"</span>)</span>;
</span>    println!(</span>"je suis le path </span>{}</span>!"</span>,</span> path)</span>;
</span>}
</span></code></pre>
This code can’t be compiled, tells us the compiler, with the following message:</p>
   Compiling playground v0.0.1 (/playground)
</span>error[E0277]: `Path` doesn't implement `std::fmt::Display`
</span> --> src/lib.rs:5:37
</span>  |
</span>5 |     println!("je suis le path {}!", path);
</span>  |                                     ^^^^ `Path` cannot be formatted with the default formatter.
</span>  |
</span>  = help: the trait `std::fmt::Display` is not implemented for `Path`
</span>  = note: required by `std::fmt::Display::fmt`
</span>  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
</span>
</span>error: aborting due to previous error
</span></code></pre>
Indeed, if &Path</code> doesn’t implement Display</code></a>, we won’t be able to use it as-is.</p>
Stage 2: negociation🔗</a></h2>
Maybe we could convert it to &str</code>? The to_str(&self)</code> method returns an Option<&str></code>. Not ideal, but we could try to expect</code> or unwrap</code> it:</p>
fn </span>main</span>() {
</span>    </span>use </span>std</span>::</span>path</span>::</span>Path</span>;
</span>    </span>let</span> path </span>= </span>Path</span>::</span>new(</span>"/tmp/foo/bar.txt"</span>)</span>;
</span>    println!(</span>"i am path </span>{}</span>!"</span>,</span> path</span>.</span>to_str</span>()</span>.</span>expect</span>(</span>"got None on path.to_str()"</span>))</span>;
</span>}
</span></code></pre>
   Compiling playground v0.0.1 (/playground)
</span>    Finished dev [unoptimized + debuginfo] target(s) in 1.76s
</span></code></pre>
It works! Great! But why does &Path::to_str()</code> return an Option</code> ?</p>
From the docs</a>:</p>

pub fn to_str(&self) -> Option<&str></code></p>
Yields a &str</code> slice if the Path</code> is valid unicode.</p>
This conversion may entail doing a check for UTF-8 validity. Note that validation is performed 
because non-UTF-8 strings are perfectly valid for some OS, like Windows.</p>
</blockquote>
Oh. So, if i want to make this code run on windows, I will panic!</code> each time i’ll try to print a &Path</code>. Very much uncool.</p>
Stage 3: Anger🔗</a></h2>
While reading &Path</code> and PathBuf</code>’s documentation, we quickly realise they are a thinly veiled wrapper around OsStr</code>, an abstraction around string representation on the platform.</p>
What purpose is there to use &Path</code> if we must implement a complex error handling logic on some simple paths?! Would be not be bettor off to simply use &str</code> and write path manipulation functions according to the target arch?!
Isn’t it what is supposed to accomplish std::path</code>?!</p>
Moreover, let’s consider the following snippet:</p>
let</span> p</span>: </span>&</span>Path </span>= </span>Path</span>::</span>new(</span>"/tmp"</span>)</span>;
</span>let</span> s</span>: </span>&str =</span> p</span>.</span>join</span>(</span>"myfile.txt"</span>)</span>.</span>to_str</span>()</span>.</span>expect</span>(</span>"fuck windows"</span>)</span>;
</span></code></pre>
Stage 4: Depression🔗</a></h2>
Why would so simple & common operations be so complicated in a modern language?</p>
Why wouldn’t the standart library offer convenient conversion methods?</p>
A precise and correct computer science as promises rust</a> is not compatible with ease of use.</p>
There is no hope, no futur, and we must accept our lot to reinvent the wheel at each new cycle of creation and suffer in silence, as Sisyphus and its boulder.</p>
Stage 5: Acceptance🔗</a></h2>

Struct std::path::Display</code>🔗</a></h3>
pub struct Display<'a> { /* fields omitted */ }</code></p>
Helper struct for safely printing paths with format!</code> and {}</code>.</p>
A Path</code> might contain non-Unicode data. This struct implements the Display</code> trait in a way that 
mitigates that. It is created by the display method on Path</code>. This may perform lossy conversion, depending on the platform. If you would like an implementation which escapes the path please use Debug</code> instead.</p>
Examples🔗</a></h4>
use </span>std</span>::</span>path</span>::</span>Path</span>;
</span>let</span> path </span>= </span>Path</span>::</span>new(</span>"/tmp/foo.rs"</span>)</span>;
</span>println!(</span>"</span>{}</span>"</span>,</span> path</span>.</span>display</span>())</span>;
</span></code></pre>
– std::path::Display</a></p>
</blockquote>
fn </span>main</span>() {
</span>    </span>use </span>std</span>::</span>path</span>::</span>Path</span>;
</span>    
</span>    </span>let</span> path </span>= </span>Path</span>::</span>new(</span>"/tmp/foo/bar.txt"</span>)</span>;
</span>    println!(</span>"I am path </span>{}</span>!"</span>,</span> path</span>.</span>display</span>())</span>;
</span>    </span>let</span> s</span>: </span>String </span>=</span> path</span>.</span>display</span>()</span>.</span>to_string</span>()</span>;
</span>    println!(</span>"I am string </span>{}</span>!"</span>,</span> s)</span>;
</span>}
</span></code></pre>
   Compiling playground v0.0.1 (/playground)
</span>    Finished dev [unoptimized + debuginfo] target(s) in 2.05s
</span>     Running `target/debug/playground`
</span>I am path /tmp/foo/bar.txt!
</span>I am string /tmp/foo/bar.txt!
</span></code></pre>
Oh.</p>


    tip</p>
    
I am fully aware of the “un-rust-ness” of the code here, I just wanted to let off some steam and have a laugh!</p>
</div>
</div>

The Slow Gulls - rust

Handling paths in Rust