Struct Fixture 

pub struct Fixture { /* private fields */ }

A declaration of what a directory must contain, built with chained calls.

use shellgame::engine::fixture::Fixture;

let fixture = Fixture::new()
    .dirs(["alpha", "gamma/deep/a/b/c"])
    .file("alpha/inside.txt", "first step")
    .file_mode("run.sh", "#!/bin/sh\n", 0o755)
    .dir_mode("locked", 0o550)
    .clean(["scratch"]);
assert!(!fixture.is_empty());

Implementations

impl Fixture

pub fn new() -> Self

An empty fixture.

pub fn dir(self, path: impl Into<String>) -> Self

Declare a directory (and its parents). Its mode becomes 0o755.

pub fn dirs<I, S>(self, paths: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Declare several directories.

pub fn file(self, path: impl Into<String>, content: impl Into<Content>) -> Self

Declare a file that is rewritten on every apply. Its mode becomes 0o644.

pub fn file_mode( self, path: impl Into<String>, content: impl Into<Content>, mode: u32, ) -> Self

Declare a file with an explicit mode (0..=0o7777).

pub fn keep_file( self, path: impl Into<String>, content: impl Into<Content>, ) -> Self

Declare a file that is only written when missing: a regular file already there is kept, content, mode and all (unless a mode is declared). Section fixtures use this for files the player is expected to have edited.

pub fn dir_mode(self, path: impl Into<String>, mode: u32) -> Self

Declare a directory with an explicit mode (0..=0o7777). Modes are applied after everything else, deepest directory first.

pub fn clean<I, S>(self, paths: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Remove these paths (files, directory trees or symlinks) before anything is created.

pub fn merge(self, other: Fixture) -> Self

Add everything other declares after what this fixture declares.

pub fn is_empty(&self) -> bool

True when nothing is declared.

pub fn dir_paths(&self) -> &[String]

The declared directories, as written.

pub fn file_entries(&self) -> impl Iterator<Item = (&str, &Content)>

The declared files with their content, as written.

pub fn clean_paths(&self) -> &[String]

The declared cleanup paths, as written.

pub fn dir_mode_entries(&self) -> impl Iterator<Item = (&str, u32)>

The declared directory modes, as written.

pub fn declared_paths(&self) -> impl Iterator<Item = &str>

Every path this fixture declares, as written.

pub fn problems(&self) -> Vec<FixtureError>

Everything wrong with the declarations themselves (bad paths, modes out of range, declarations that target the root), without touching the filesystem.

pub fn apply(&self, root: &Path) -> Result<(), FixtureError>

Make root match this fixture; see the module documentation for the repair rules and the explicit-mode guarantee.

The root is created when missing and repaired when its owner permissions were taken away; either way it ends 0o755. A root that is a symlink is refused. Nothing is applied when the declarations are invalid.

Trait Implementations

impl Clone for Fixture

fn clone(&self) -> Fixture

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Fixture

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

Formats the value using the given formatter.

impl Default for Fixture

fn default() -> Fixture

Returns the “default value” for a type.