JustSoup321/dtmp - Change LRZO4TXD77ELZZPVN4NRWIDE22BHY6R7STI6RVWOJBIRSNRZX5VQC

create: clean up functions, add todos, and use tabs instead of spaces

Created by JustSoup321 on August 29, 2025

LRZO4TXD77ELZZPVN4NRWIDE22BHY6R7STI6RVWOJBIRSNRZX5VQC

Dependencies

In channels

main

Change contents

Replacement in src/main.rs at line 25 [3.442]

B:BD[3.1265] → [3.1265:1305]

fn main() {
    let cli = Cli::parse();

[3.1265]

[3.1305]

fn main() -> Result<(), Box<dyn std::error::Error>> {
	let cli = Cli::parse();

Replacement in src/main.rs at line 28 [3.442]

B:BD[3.1306] → [3.1306:1532]

    if cli.create {
        println!("Running create!");
        dtmp_lib::actions::create();
    }
    if cli.clean {
        todo!();
    }
    if cli.remove {
        todo!();
    }
    if cli.purge {
        todo!()
    }

[3.1306]

[3.1532]

	if cli.create {
		println!("Running create!");
		dtmp_lib::actions::create();
	}
	if cli.clean {
		todo!();
	}
	if cli.remove {
		todo!();
	}
	if cli.purge {
		todo!()
	}
	Ok(())

Replacement in src/cli.rs at line 22 [3.1566]

B:BD[3.2437] → [3.2437:2820]

    //
    // Actions
    //
    /// Create and adjust files and directories
    #[arg(long)]
    pub create: bool,
    /// Clean up files and directories
    #[arg(long)]
    pub clean: bool,
    /// Remove files and directories marked for removal
    #[arg(long)]
    pub remove: bool,
    /// Delete files and directories marked for creation
    #[arg(long)]
    pub purge: bool,

[3.2437]

[3.2820]

	//
	// Actions
	//
	/// Create and adjust files and directories
	#[arg(long)]
	pub create: bool,
	/// Clean up files and directories
	#[arg(long)]
	pub clean: bool,
	/// Remove files and directories marked for removal
	#[arg(long)]
	pub remove: bool,
	/// Delete files and directories marked for creation
	#[arg(long)]
	pub purge: bool,

Replacement in src/cli.rs at line 38 [3.1566]

B:BD[3.2821] → [3.2821:3140]

    //
    // Modifiers
    //
    /// Print operations instead of doing them
    #[arg(short, long)]
    pub dry_run: bool,
    /// Execute user configuration instead of system
    #[arg(short, long)]
    pub user: bool,
    /// Operate on another root filesystem
    #[arg(short, long)]
    pub root: Option<String>,

[3.2821]

[3.3140]

	//
	// Modifiers
	//
	/// Print operations instead of doing them
	#[arg(short, long)]
	pub dry_run: bool,
	/// Execute user configuration instead of system
	#[arg(short, long)]
	pub user: bool,
	/// Operate on another root filesystem
	#[arg(short, long)]
	pub root: Option<String>,

Replacement in src/cli.rs at line 54 [3.1566]

B:BD[3.3185] → [3.3185:3431]

    /// Create and adjust files and directories
    Create,
    /// Clean up files and directories
    Clean,
    /// Remove files and directories marked for removal
    Remove,
    /// Remove files and directories marked for creation
    Purge,

[3.3185]

[3.3431]

	/// Create and adjust files and directories
	Create,
	/// Clean up files and directories
	Clean,
	/// Remove files and directories marked for removal
	Remove,
	/// Remove files and directories marked for creation
	Purge,

Replacement in lib/parser.rs at line 20 [3.3485]
B:BD[3.3735] → [3.3735:3779]
```
    fs::File,
    io::{BufRead, BufReader},
```
[3.3735]
[3.3779]
```
	fs::File,
	io::{BufRead, BufReader},
```

Replacement in lib/parser.rs at line 26 [3.3485]

B:BD[3.3820] → [3.3820:3995]

    pub file_type: String,
    pub path: std::path::PathBuf,
    pub mode: String,
    pub user: String,
    pub group: String,
    pub age: String,
    pub argument: String,

[3.3820]

[3.3995]

	pub file_type: String,
	pub path: std::path::PathBuf,
	pub mode: String,
	pub user: String,
	pub group: String,
	pub age: String,
	pub argument: String,

Replacement in lib/parser.rs at line 36 [3.3485]
B:BD[3.4083] → [3.4083:4123]
```
    let mut return_config = Vec::new();
```
[3.4083]
[3.4123]
```
	let mut return_config = Vec::new();
```

Replacement in lib/parser.rs at line 38 [3.3485]

B:BD[3.4124] → [3.4124:4255]

B:BD[3.4255] → [2.263:968]

∅:D[2.968] → [3.4444:4462]

B:BD[3.4444] → [3.4444:4462]

B:BD[3.4871] → [3.4871:5114]

    let tmpfiles_config = read_config(config_path);
    match tmpfiles_config {
        Ok(cfg) => {
            for line in cfg {
                if line.len() >= 1 {
                    let line: Vec<&str> = line.iter().map(|item| item.as_str()).collect();
                    if line[0].chars().next().unwrap().to_string() == "#" {
                        continue;
                    }
                    return_config.push(Config {
                        file_type: String::from(line[0]),
                        path: line[1].into(),
                        mode: String::from(line[2]),
                        user: String::from(line[3]),
                        group: String::from(line[4]),
                        age: String::from(line[5]),
                        argument: String::from(line[6]),
                    });
                }
            }
        }
        Err(e) => {
            return Err(e);
        }
    }
    // for line in return_config {
    //     match sanity_check(line) {
    //         Err(e) => return Err(e)
    //     }
    // }
    Ok(return_config)

[3.4124]

[3.5114]

	let tmpfiles_config = read_config(config_path);
	match tmpfiles_config {
		Ok(cfg) => {
			for line in cfg {
				if line.len() >= 1 {
					let line: Vec<&str> = line.iter().map(|item| item.as_str()).collect();
					if line[0].chars().next().unwrap().to_string() == "#" {
						continue;
					}
					return_config.push(Config {
						file_type: String::from(line[0]),
						path: line[1].into(),
						mode: String::from(line[2]),
						user: String::from(line[3]),
						group: String::from(line[4]),
						age: String::from(line[5]),
						argument: String::from(line[6]),
					});
				}
			}
		}
		Err(e) => {
			return Err(e);
		}
	}
	// for line in return_config {
	//     match sanity_check(line) {
	//         Err(e) => return Err(e)
	//     }
	// }
	Ok(return_config)

Replacement in lib/parser.rs at line 72 [3.3485]

B:BD[3.5209] → [3.5209:5556]

    let mut return_vector = Vec::new();
    let file = File::open(config_path)?;
    for line in BufReader::new(file).lines().map_while(Result::ok) {
        let line: Vec<String> = line
            .split_whitespace()
            .map(|item| item.to_string())
            .collect();
        return_vector.push(line);
    }
    Ok(return_vector)

[3.5209]

[3.5556]

	let mut return_vector = Vec::new();
	let file = File::open(config_path)?;
	for line in BufReader::new(file).lines().map_while(Result::ok) {
		let line: Vec<String> = line
			.split_whitespace()
			.map(|item| item.to_string())
			.collect();
		return_vector.push(line);
	}
	Ok(return_vector)

Replacement in lib/fields.rs at line 20 [3.5879]

B:BD[3.6276] → [3.6276:6415]

    "f", "w", "d", "D", "e", "v", "q", "Q", "p", "p+", "L", "c", "b", "C", "x", "X", "r", "R", "z",
    "Z", "t", "T", "h", "H", "a", "A",

[3.6276]

[3.6415]

	"f", "w", "d", "D", "e", "v", "q", "Q", "p", "p+", "L", "c", "b", "C", "x", "X", "r", "R", "z",
	"Z", "t", "T", "h", "H", "a", "A",

Replacement in lib/fields.rs at line 31 [3.5879]

B:BD[3.6859] → [3.6859:7017]

    "%a", "%A", "%b", "%B", "%C", "%g", "%G", "%h", "%H", "%l", "%L", "%m", "%M", "%o", "%q", "%S",
    "%t", "%T", "%u", "%U", "%v", "%V", "%w", "%W", "%%",

[3.6859]

[3.7017]

	"%a", "%A", "%b", "%B", "%C", "%g", "%G", "%h", "%H", "%l", "%L", "%m", "%M", "%o", "%q", "%S",
	"%t", "%T", "%u", "%U", "%v", "%V", "%w", "%W", "%%",

Replacement in lib/fields.rs at line 36 [3.5879]

B:BD[3.7096] → [3.7096:7625]

    if VALID_TYPES.contains(
        &String::from(config_line[0])
            .chars()
            .next()
            .unwrap()
            .to_string()
            .as_str(),
    ) == false
    {
        return Err("0");
    }
    if String::from(config_line[1])
        .chars()
        .next()
        .unwrap()
        .to_string()
        != "/"
    {
        return Err("1");
    }
    if config_line[2].parse::<i32>().is_err() {
        if config_line[2] != "-" {
            return Err("2");
        }
    }
    Ok(())

[3.7096]

[3.7625]

	if VALID_TYPES.contains(
		&String::from(config_line[0])
			.chars()
			.next()
			.unwrap()
			.to_string()
			.as_str(),
	) == false
	{
		return Err("0");
	}
	if String::from(config_line[1])
		.chars()
		.next()
		.unwrap()
		.to_string()
		!= "/"
	{
		return Err("1");
	}
	if config_line[2].parse::<i32>().is_err() {
		if config_line[2] != "-" {
			return Err("2");
		}
	}
	Ok(())

Replacement in lib/actions.rs at line 18 [3.7663]

B:BD[2.998] → [2.998:1059]

    fs::{build_dir, build_file},
    parser::{self, Config},

[2.998]

[2.1059]

	fs::build_dir,
	parser::{self, Config},

Replacement in lib/actions.rs at line 23 [3.7663]

B:BD[2.1074] → [2.1074:1160]

    fs::{DirBuilder, OpenOptions},
    os::unix::fs::{DirBuilderExt, OpenOptionsExt},

[2.1074]

[2.1160]

	fs::{DirBuilder, OpenOptions},
	io::Write,
	os::unix::fs::{DirBuilderExt, OpenOptionsExt},

Replacement in lib/actions.rs at line 29 [3.7663]

B:BD[3.8009] → [3.8009:8043]

B:BD[3.8043] → [2.1164:1544]

∅:D[2.1544] → [3.8295:8340]

B:BD[3.8295] → [3.8295:8340]

B:BD[3.8340] → [2.1545:1563]

∅:D[2.1563] → [3.8400:8424]

B:BD[3.8400] → [3.8400:8424]

B:BD[3.8424] → [2.1564:1596]

∅:D[2.1596] → [3.8424:8430]

B:BD[3.8424] → [3.8424:8430]

B:BD[3.8430] → [2.1597:1602]

∅:D[2.1602] → [3.8472:8530]

B:BD[3.8472] → [3.8472:8530]

B:BD[3.8530] → [2.1603:3479]

∅:D[2.3479] → [3.9077:9095]

B:BD[3.9077] → [3.9077:9095]

B:BD[3.9095] → [2.3480:4268]

∅:D[2.4268] → [3.9095:9136]

B:BD[3.9095] → [3.9095:9136]

    let mut configs = Vec::new();
    let config_files = std::fs::read_dir("/usr/lib/tmpfiles.d");
    match config_files {
        Ok(config_list) => {
            for file in config_list {
                match file {
                    Ok(f) => match parser::parse(&f.path()) {
                        Ok(config) => configs.push(config),
                        Err(e) => return Err(e),
                    },
                    Err(e) => return Err(e),
                }
            }
        }
        Err(e) => return Err(e)
    }
    
    for config in &configs {
        for line in config {
            let mut mode: u32;
            match line.mode.as_str() {
                "0755" => mode = 0o755,
                "755" => mode = 0o755,
                "1755" => mode = 1755,
                "0644" => mode = 0o644,
                "644" => mode = 0o644,
                "1644" => mode = 1644,
                _ => todo!(),
            }
            match line.file_type.as_str() {
                "f" => {
                    match OpenOptions::new()
                        .create(true)
                        .mode(mode) // .mode(line.mode.parse::<u32>().unwrap())
                        .open(&line.path.as_os_str())
                    {
                        Ok(k) => println!("Created file: {:#?}", &line.path.as_os_str()),
                        Err(e) => {
                            println!(
                                "Failed to create {:#?} with reason {}!",
                                &line.path.as_os_str(),
                                e
                            );
                            println!("Mode: {}", line.mode.parse::<u32>().unwrap());
                            return Err(e);
                        }
                    }
                }
                "f+" => {
                    match OpenOptions::new()
                        .create(true)
                        .truncate(true)
                        .mode(mode)
                        .open(&line.path.as_os_str())
                    {
                        Ok(k) => println!(
                            "Created file: {:#?} with truncation",
                            &line.path.as_os_str()
                        ),
                        Err(e) => {
                            println!("Failed to create {:#?}!", &line.path.as_os_str());
                            return Err(e);
                        }
                    }
                }
                "d" => match build_dir(&line.path, mode) {
                    Ok(k) => println!(
                        "Created path {:#?} with mode {}",
                        &line.path.as_os_str(),
                        mode
                    ),
                    Err(e) => {
                        println!(
                            "Failed to create {:#?} with mode {} with error {}!",
                            &line.path.as_os_str(),
                            mode,
                            e
                        );
                        return Err(e.into());
                    }
                },
                _ => eprintln!(
                    "ERROR: File type \"{}\" is not implemented.",
                    line.file_type
                ),
            }
        }
    }
    Ok(())

[3.8009]

[3.9136]

	let mut configs = Vec::new();
	let config_files = std::fs::read_dir("/usr/lib/tmpfiles.d");
	match config_files {
		Ok(config_list) => {
			for file in config_list {
				match file {
					Ok(f) => match parser::parse(&f.path()) {
						Ok(config) => configs.push(config),
						Err(e) => return Err(e),
					},
					Err(e) => return Err(e),
				}
			}
		}
		Err(e) => return Err(e),
	}
	for config in &configs {
		for line in config {
			match line.file_type.as_str() {
				"f" => {
					match OpenOptions::new()
						.create(true)
						.append(true)
						.mode(u32::from_str_radix(&line.mode, 8).unwrap())
						.open(&line.path.as_os_str())
					{
						Ok(k) => continue,
						Err(e) => {
							println!(
								"Failed to create {:#?} with reason {}!",
								&line.path.as_os_str(),
								e
							);
							println!("Mode: {}", &line.mode);
							return Err(e);
						}
					}
				}
				"f+" => {
					match OpenOptions::new()
						.create(true)
						.append(true)
						.truncate(true)
						.mode(u32::from_str_radix(&line.mode, 8).unwrap())
						.open(&line.path.as_os_str())
					{
						Ok(k) => continue,
						Err(e) => {
							println!("Failed to create {:#?}!", &line.path.as_os_str());
							return Err(e);
						}
					}
				}
				"w" => {
					// TODO: Handle if there is a newline
					if !line.argument.contains("\n") {
						let mut file = std::fs::File::open(&line.path.as_os_str()).unwrap();
						match file.write_all(&line.argument.as_bytes()) {
							Ok(k) => continue,
							Err(e) => {
								println!("Failed to write to {:#?}!", &line.path.as_os_str());
								return Err(e);
							}
						}
					}
				}
				"w+" => {
					// TODO: Handle if there is not a newline
					if line.argument.contains("\n") {
						let mut file = std::fs::File::open(&line.path.as_os_str()).unwrap();
						match file.write_all(&line.argument.as_bytes()) {
							Ok(k) => continue,
							Err(e) => {
								println!("Failed to write to {:#?}!", &line.path.as_os_str());
								return Err(e);
							}
						}
					}
				}
				"d" => match build_dir(&line.path, u32::from_str_radix(&line.mode, 8).unwrap()) {
					Ok(k) => continue,
					Err(e) => {
						println!(
							"Failed to create {:#?} with mode {} with error {}!",
							&line.path.as_os_str(),
							&line.mode,
							e
						);
						return Err(e.into());
					}
				},
				// TODO: Handle deleting directory contents
				"D" => match build_dir(&line.path, u32::from_str_radix(&line.mode, 8).unwrap()) {
					Ok(k) => continue,
					Err(e) => {
						println!(
							"Failed to create {:#?} with mode {} with error {}!",
							&line.path.as_os_str(),
							&line.mode,
							e
						);
						return Err(e.into());
					}
				},
				"e" => todo!(),
				"v" => todo!(),
				"q" => todo!(),
				"Q" => todo!(),
				"p" => todo!(),
				"p+" => todo!(),
				"L" => todo!(),
				"L+" => todo!(),
				"L?" => todo!(),
				"c" => todo!(),
				"c+" => todo!(),
				"b" => todo!(),
				"b+" => todo!(),
				"C" => todo!(),
				"C+" => todo!(),
				"x" => todo!(),
				"X" => todo!(),
				"r" => todo!(),
				"R" => todo!(),
				"z" => todo!(),
				"Z" => todo!(),
				"t" => todo!(),
				"T" => todo!(),
				"h" => todo!(),
				"H" => todo!(),
				"a" => todo!(),
				"a+" => todo!(),
				"A" => todo!(),
				"A+" => todo!(),
				_ => eprintln!(
					"ERROR: File type \"{}\" is not implemented.",
					line.file_type
				),
			}
		}
	}
	Ok(())