zeck 3.0.1

A Rust library for compressing and decompressing data using the Zeckendorf representation algorithm
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! Generate random test data files
//!
//! This tool generates random test data files in the `generated_data/` directory.
//!
//! Building and running the tool:
//! `cargo build --release --bin zeck-generate-data --features development_tools`
//! `cargo run --release --bin zeck-generate-data --features development_tools -- <size_in_bytes> [filename]`
//!
//! # Examples
//!
//! Generate a file with default name:
//! ```bash
//! cargo run --release --bin zeck-generate-data --features development_tools -- 1024
//! ```
//!
//! Generate a file with custom name:
//! ```bash
//! cargo run --release --bin zeck-generate-data --features development_tools -- 1024 my_file.bin
//! ```

use rand::RngCore;
use std::env;
use std::fs;
use std::io::Write;
use std::path::Path;

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() < 2 {
        eprintln!("Usage: {} <size_in_bytes> [filename]", args[0]);
        eprintln!("  size_in_bytes: The size of the file to generate in bytes");
        eprintln!("  filename: Optional filename (default: random_data_<size>_bytes.bin)");
        std::process::exit(1);
    }

    let size_str = &args[1];
    let size = match size_str.parse::<usize>() {
        Ok(s) => s,
        Err(_) => {
            eprintln!(
                "Error: '{size_str}' is not a valid size. Please provide a positive integer."
            );
            std::process::exit(1);
        }
    };

    if size == 0 {
        eprintln!("Error: Size must be greater than 0");
        std::process::exit(1);
    }

    let maybe_filename = args.get(2);
    let filename = if let Some(name) = maybe_filename {
        name.clone()
    } else {
        format!("random_data_{size}_bytes.bin")
    };

    // Create the generated_data directory if it doesn't exist
    let output_dir = Path::new("generated_data");
    if let Err(e) = fs::create_dir_all(output_dir) {
        eprintln!("Error: Failed to create directory 'generated_data': {e}");
        std::process::exit(1);
    }

    // Generate random data
    let mut rng = rand::rng();
    let mut data = vec![0u8; size];
    rng.fill_bytes(&mut data);

    // Write the file
    let file_path = output_dir.join(&filename);
    let mut file = match fs::File::create(&file_path) {
        Ok(f) => f,
        Err(e) => {
            eprintln!(
                "Error: Failed to create file '{}': {e}",
                file_path.display()
            );
            std::process::exit(1);
        }
    };

    if let Err(e) = file.write_all(&data) {
        eprintln!(
            "Error: Failed to write data to file '{}': {e}",
            file_path.display()
        );
        std::process::exit(1);
    }

    println!(
        "Successfully generated file: {} ({size} bytes)",
        file_path.display()
    );
}