From 91a3bb36435d1f3bfbca7b2f950a9ac877202bf2 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Fri, 3 Apr 2026 19:47:37 +0100 Subject: [PATCH 01/20] added PKGBUILD file for installation --- pkg/PKGBUILD | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 pkg/PKGBUILD diff --git a/pkg/PKGBUILD b/pkg/PKGBUILD new file mode 100644 index 0000000..0f2faf6 --- /dev/null +++ b/pkg/PKGBUILD @@ -0,0 +1,24 @@ +# Maintainer: jaiden brooke +pkgname=dolltool +pkgver=1.3.0 +pkgrel=1 +pkgdesc="A simple dollcode encoder, decoder, and generator inside your terminal" +url=https://git.gay/ika4422/dolltool +arch=('x86_64' 'aarch64') +license=('GPL-3.0-or-later') +depends=('glibc' 'libgcc') +makedepends=('rust' 'cargo') +source=("$pkgname-$pkgver.tar.gz::https://git.gay/ika4422/dolltool/archive/v$pkgver.tar.gz") +sha256sums=('195c60071637980cb9163bfd8c54b00ebb4dde5306fdfc977ea0eb855679fac5') + +build() { + cd "$srcdir/../.." + cargo build --release +} + +package() { + cd "$srcdir/../.." + + install -Dm755 "target/release/dolltool" "$pkgdir/usr/bin/dolltool" + install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE" +} From 192daf589d326b335620211319cef40577b5d084 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Tue, 7 Apr 2026 23:25:03 +0100 Subject: [PATCH 02/20] modified installation instructions to include the AUR package and pkgbuild for users on arch linux --- README.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/README.md b/README.md index a20a31b..eea2c29 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,14 @@ This project was inspired by [noe](https://noe.sh/) and its [dollcode transcoder ## Installation +### Arch Linux + +You can install this package from the AUR with the package name `dolltool`, or +alternatively by cloning the repository and using `makepkg -si` inside the `pkg/` +directory. + +### Other + Clone the repository then `cd` into the directory and run: ```bash From 32734cc91c9797baf9ae221db4997c6c55df5491 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Wed, 8 Apr 2026 12:12:21 +0100 Subject: [PATCH 03/20] fixed args to only execute one set if multiple sets are passed --- Cargo.lock | 4 ++-- src/main.rs | 14 ++++++-------- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 660235d..141615e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -340,9 +340,9 @@ checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba" [[package]] name = "semver" -version = "1.0.27" +version = "1.0.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" [[package]] name = "serde" diff --git a/src/main.rs b/src/main.rs index df40802..cb2c9d6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -68,6 +68,11 @@ struct Args { fn main() { let args = Args::parse(); + if args.license { + println!("{}", include_str!("../LICENSE")); + process::exit(1); + } + if let Some(pattern) = args.generate { for _ in 0..args.count { let generated = generate_from_pattern(&pattern, args.upper); @@ -95,9 +100,7 @@ fn main() { } } } - } - - if let Some(input) = args.encode { + } else if let Some(input) = args.encode { let encode_as_text = args.text || input.parse::().is_err(); if encode_as_text { @@ -149,9 +152,4 @@ fn main() { } } } - - if args.license { - println!("{}", include_str!("../LICENSE")); - process::exit(1); - } } From 0d9519c0dbf111e54163b392252bb83a9c6febcd Mon Sep 17 00:00:00 2001 From: ika4422 Date: Wed, 8 Apr 2026 12:34:32 +0100 Subject: [PATCH 04/20] added uppercase variations for letter and alphanumeric generation symbols and removed --upper flag --- README.md | 2 ++ src/main.rs | 16 ++++++---------- src/pattern_gen.rs | 23 ++++++++++++----------- 3 files changed, 20 insertions(+), 21 deletions(-) diff --git a/README.md b/README.md index eea2c29..27392cd 100644 --- a/README.md +++ b/README.md @@ -77,7 +77,9 @@ Generates random codes based on a user-defined pattern: - `n`: Number (0-9) - `l`: Letter (a-z) +- `L`: Uppercase Letter (A-Z) - `a`: Alphanumeric (0-9, a-z) +- `A`: Uppercase Alphanumeric (0-9, a-z) ```bash $ dolltool -g "nn-lll" -c 3 diff --git a/src/main.rs b/src/main.rs index cb2c9d6..edcad97 100644 --- a/src/main.rs +++ b/src/main.rs @@ -40,26 +40,22 @@ struct Args { /// Decodes the following dollcode into an integer or text decode: Option, - #[arg(short, long, default_value_t = false)] - /// Specifies the encoding/decoding method as text, not as an integer - text: bool, - #[arg(short, long)] - /// Generates codes from a user-defined pattern (n = number; l = letter; a = alphanumeric) + /// Generates codes from a user-defined pattern (n = number; l = letter; L = uppercase letter; a = alphanumeric; A = uppercase alphanumeric) generate: Option, #[arg(short, long, default_value_t = 1)] /// Specifies how many codes to generate count: usize, - #[arg(short, long, default_value_t = false)] - /// Outputs generated letters as uppercase as opposed to lowercase - upper: bool, - #[arg(long, default_value_t = false)] /// Will generate codes without encoding it into dollcode no_doll: bool, + #[arg(short, long, default_value_t = false)] + /// Specifies the encoding/decoding method as text, not as an integer + text: bool, + #[arg(long)] /// Display the license for dolltool license: bool, @@ -75,7 +71,7 @@ fn main() { if let Some(pattern) = args.generate { for _ in 0..args.count { - let generated = generate_from_pattern(&pattern, args.upper); + let generated = generate_from_pattern(&pattern); if args.no_doll { println!("{}", generated); diff --git a/src/pattern_gen.rs b/src/pattern_gen.rs index ef419ad..397ff6e 100644 --- a/src/pattern_gen.rs +++ b/src/pattern_gen.rs @@ -1,6 +1,6 @@ use rand::RngExt; -pub fn generate_from_pattern(pattern: &str, upper: bool) -> String { +pub fn generate_from_pattern(pattern: &str) -> String { let mut rng = rand::rng(); let mut output = String::new(); @@ -9,18 +9,19 @@ pub fn generate_from_pattern(pattern: &str, upper: bool) -> String { 'n' => output.push(rng.random_range('0'..='9')), 'l' => { let letter = rng.random_range('a'..='z'); - output.push(if upper { - letter.to_ascii_uppercase() - } else { - letter - }); + output.push(letter); + } + 'L' => { + let letter = rng.random_range('A'..='Z'); + output.push(letter); } 'a' => { - let pool = if upper { - "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" - } else { - "0123456789abcdefghijklmnopqrstuvwxyz" - }; + let pool = "0123456789abcdefghijklmnopqrstuvwxyz"; + let idx = rng.random_range(0..pool.len()); + output.push(pool.chars().nth(idx).unwrap()); + } + 'A' => { + let pool = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; let idx = rng.random_range(0..pool.len()); output.push(pool.chars().nth(idx).unwrap()); } From e0d66a31f0d8b5cb2aef03990219e5221e605970 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Wed, 8 Apr 2026 12:51:24 +0100 Subject: [PATCH 05/20] optimized pattern generation code --- src/pattern_gen.rs | 47 +++++++++++++++++++++++----------------------- 1 file changed, 24 insertions(+), 23 deletions(-) diff --git a/src/pattern_gen.rs b/src/pattern_gen.rs index 397ff6e..23344d5 100644 --- a/src/pattern_gen.rs +++ b/src/pattern_gen.rs @@ -1,32 +1,33 @@ use rand::RngExt; +const DIGITS: &[u8] = b"0123456789"; +const LETTERS_LOWER: &[u8] = b"abcdefghijklmnopqrstuvwxyz"; +const LETTERS_UPPER: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"; +const ALNUM_LOWER: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz"; +const ALNUM_UPPER: &[u8] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + +fn pick(rng: &mut impl rand::Rng, pool: &[u8]) -> char { + pool[rng.random_range(0..pool.len())] as char +} + pub fn generate_from_pattern(pattern: &str) -> String { let mut rng = rand::rng(); - let mut output = String::new(); + let mut output = String::with_capacity(pattern.len()); for c in pattern.chars() { - match c { - 'n' => output.push(rng.random_range('0'..='9')), - 'l' => { - let letter = rng.random_range('a'..='z'); - output.push(letter); - } - 'L' => { - let letter = rng.random_range('A'..='Z'); - output.push(letter); - } - 'a' => { - let pool = "0123456789abcdefghijklmnopqrstuvwxyz"; - let idx = rng.random_range(0..pool.len()); - output.push(pool.chars().nth(idx).unwrap()); - } - 'A' => { - let pool = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; - let idx = rng.random_range(0..pool.len()); - output.push(pool.chars().nth(idx).unwrap()); - } - _ => output.push(c), - } + let pool = match c { + 'n' => Some(DIGITS), + 'l' => Some(LETTERS_LOWER), + 'L' => Some(LETTERS_UPPER), + 'a' => Some(ALNUM_LOWER), + 'A' => Some(ALNUM_UPPER), + _ => None, + }; + + output.push(match pool { + Some(p) => pick(&mut rng, p), + None => c, + }); } output } From 7af9a92785b74260b94c58caa4f499f823d845b5 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Wed, 8 Apr 2026 13:13:49 +0100 Subject: [PATCH 06/20] added mixed upper and lower case letters and alphanumeric pools --- src/pattern_gen.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/pattern_gen.rs b/src/pattern_gen.rs index 23344d5..e12d96d 100644 --- a/src/pattern_gen.rs +++ b/src/pattern_gen.rs @@ -3,8 +3,10 @@ use rand::RngExt; const DIGITS: &[u8] = b"0123456789"; const LETTERS_LOWER: &[u8] = b"abcdefghijklmnopqrstuvwxyz"; const LETTERS_UPPER: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"; +const LETTERS_MIXED: &[u8] = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; const ALNUM_LOWER: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz"; const ALNUM_UPPER: &[u8] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; +const ALNUM_MIXED: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; fn pick(rng: &mut impl rand::Rng, pool: &[u8]) -> char { pool[rng.random_range(0..pool.len())] as char @@ -19,8 +21,10 @@ pub fn generate_from_pattern(pattern: &str) -> String { 'n' => Some(DIGITS), 'l' => Some(LETTERS_LOWER), 'L' => Some(LETTERS_UPPER), + 'm' => Some(LETTERS_MIXED), 'a' => Some(ALNUM_LOWER), 'A' => Some(ALNUM_UPPER), + 'x' => Some(ALNUM_MIXED), _ => None, }; From f9a479f4b5270adde0bf00526bdf8831c4a028f9 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Wed, 8 Apr 2026 13:29:43 +0100 Subject: [PATCH 07/20] added pattern tokens help argument --- src/main.rs | 13 +++++++++++-- src/pattern_gen.rs | 11 +++++++++++ 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/src/main.rs b/src/main.rs index edcad97..219e3f1 100644 --- a/src/main.rs +++ b/src/main.rs @@ -41,7 +41,7 @@ struct Args { decode: Option, #[arg(short, long)] - /// Generates codes from a user-defined pattern (n = number; l = letter; L = uppercase letter; a = alphanumeric; A = uppercase alphanumeric) + /// Generates codes from a user-defined pattern (see --tokens for token list) generate: Option, #[arg(short, long, default_value_t = 1)] @@ -53,9 +53,13 @@ struct Args { no_doll: bool, #[arg(short, long, default_value_t = false)] - /// Specifies the encoding/decoding method as text, not as an integer + /// Specifies the encoding/decoding method as text, instead of an integer text: bool, + #[arg(long, default_value_t = false)] + /// List all available pattern tokens + tokens: bool, + #[arg(long)] /// Display the license for dolltool license: bool, @@ -69,6 +73,11 @@ fn main() { process::exit(1); } + if args.tokens { + println!("{}", pattern_gen::TOKEN_HELP); + process::exit(0); + } + if let Some(pattern) = args.generate { for _ in 0..args.count { let generated = generate_from_pattern(&pattern); diff --git a/src/pattern_gen.rs b/src/pattern_gen.rs index e12d96d..d6c2c9d 100644 --- a/src/pattern_gen.rs +++ b/src/pattern_gen.rs @@ -8,6 +8,17 @@ const ALNUM_LOWER: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz"; const ALNUM_UPPER: &[u8] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; const ALNUM_MIXED: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; +pub const TOKEN_HELP: &str = "\ +Pattern Tokens: + n digit (0-9) + l letter lower (a-z) + L letter upper (A-Z) + m letter mixed (a-z, A-Z) + a alnum lower (0-9, a-z) + A alnum upper (0-9, A-Z) + x alnum mixed (0-9, a-z, A-Z) + * any other character is used literally"; + fn pick(rng: &mut impl rand::Rng, pool: &[u8]) -> char { pool[rng.random_range(0..pool.len())] as char } From 96bacd47bfd9bc0aa5595ffad927f951d0d67728 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Wed, 8 Apr 2026 21:41:26 +0100 Subject: [PATCH 08/20] added argument to change integer base --- src/main.rs | 13 +++++++++---- src/pattern_gen.rs | 15 +++++++++++++++ 2 files changed, 24 insertions(+), 4 deletions(-) diff --git a/src/main.rs b/src/main.rs index 219e3f1..80143b4 100644 --- a/src/main.rs +++ b/src/main.rs @@ -48,6 +48,10 @@ struct Args { /// Specifies how many codes to generate count: usize, + #[arg(short, long, default_value_t = 10)] + /// Input/output base for integers (2, 8, 10, 16) + base: u32, + #[arg(long, default_value_t = false)] /// Will generate codes without encoding it into dollcode no_doll: bool, @@ -88,7 +92,7 @@ fn main() { let as_num = if args.text { None } else { - BigUint::parse_bytes(generated.as_bytes(), 10) + BigUint::parse_bytes(generated.as_bytes(), args.base) }; match as_num { @@ -106,7 +110,8 @@ fn main() { } } } else if let Some(input) = args.encode { - let encode_as_text = args.text || input.parse::().is_err(); + let encode_as_text = + args.text || BigUint::parse_bytes(input.as_bytes(), args.base).is_none(); if encode_as_text { let result: Vec = input @@ -115,7 +120,7 @@ fn main() { .collect(); println!("{}", result.join(" ")); } else { - let num = input.parse::().unwrap(); + let num = BigUint::parse_bytes(input.as_bytes(), args.base).unwrap(); match to_dollcode(num) { Ok(code) => println!("{}", code), @@ -149,7 +154,7 @@ fn main() { println!("{}", decoded_chars); } else { match from_dollcode(&input) { - Ok(val) => println!("{}", val), + Ok(val) => println!("{}", val.to_str_radix(args.base)), Err(e) => { eprintln!("Error: {}", e); process::exit(1); diff --git a/src/pattern_gen.rs b/src/pattern_gen.rs index d6c2c9d..efe42d3 100644 --- a/src/pattern_gen.rs +++ b/src/pattern_gen.rs @@ -7,6 +7,11 @@ const LETTERS_MIXED: &[u8] = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVW const ALNUM_LOWER: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz"; const ALNUM_UPPER: &[u8] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; const ALNUM_MIXED: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; +const DIGITS_BINARY: &[u8] = b"01"; +const DIGITS_OCTAL: &[u8] = b"01234567"; +const DIGITS_HEX_LOWER: &[u8] = b"0123456789abcdef"; +const DIGITS_HEX_UPPER: &[u8] = b"0123456789ABCDEF"; +const DIGITS_HEX_MIXED: &[u8] = b"0123456789abcdefABCDEF"; pub const TOKEN_HELP: &str = "\ Pattern Tokens: @@ -17,6 +22,11 @@ Pattern Tokens: a alnum lower (0-9, a-z) A alnum upper (0-9, A-Z) x alnum mixed (0-9, a-z, A-Z) + b binary digit (0-1) + o octal digit (0-7) + h hex lower (0-f) + H hex upper (0-F) + X hex mixed (0-9, a-f, A-F) * any other character is used literally"; fn pick(rng: &mut impl rand::Rng, pool: &[u8]) -> char { @@ -36,6 +46,11 @@ pub fn generate_from_pattern(pattern: &str) -> String { 'a' => Some(ALNUM_LOWER), 'A' => Some(ALNUM_UPPER), 'x' => Some(ALNUM_MIXED), + 'b' => Some(DIGITS_BINARY), + 'o' => Some(DIGITS_OCTAL), + 'h' => Some(DIGITS_HEX_LOWER), + 'H' => Some(DIGITS_HEX_UPPER), + 'X' => Some(DIGITS_HEX_MIXED), _ => None, }; From 6abc1ee35dee1f417cad07aaf3a05d1354b11f6f Mon Sep 17 00:00:00 2001 From: ika4422 Date: Wed, 8 Apr 2026 21:42:49 +0100 Subject: [PATCH 09/20] incremented minor version counter to v1.4.0 --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index d8c2305..0eeb7be 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] license = "GPL-3.0-or-later" name = "dolltool" -version = "1.3.0" +version = "1.4.0" authors = ["ika4422"] description = "A simple dollcode encoder, decoder, and generator inside your terminal :3" edition = "2024" From 654aafe120248759e407dec978477cd1ac8685da Mon Sep 17 00:00:00 2001 From: ika4422 Date: Wed, 8 Apr 2026 21:50:45 +0100 Subject: [PATCH 10/20] updated PKGBUILD for v1.4.0 --- pkg/PKGBUILD | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/PKGBUILD b/pkg/PKGBUILD index 0f2faf6..6c906a9 100644 --- a/pkg/PKGBUILD +++ b/pkg/PKGBUILD @@ -1,6 +1,6 @@ # Maintainer: jaiden brooke pkgname=dolltool -pkgver=1.3.0 +pkgver=1.4.0 pkgrel=1 pkgdesc="A simple dollcode encoder, decoder, and generator inside your terminal" url=https://git.gay/ika4422/dolltool @@ -9,7 +9,7 @@ license=('GPL-3.0-or-later') depends=('glibc' 'libgcc') makedepends=('rust' 'cargo') source=("$pkgname-$pkgver.tar.gz::https://git.gay/ika4422/dolltool/archive/v$pkgver.tar.gz") -sha256sums=('195c60071637980cb9163bfd8c54b00ebb4dde5306fdfc977ea0eb855679fac5') +sha256sums=('d536e6b3d93ce85cc48780565f1ac461a424bf0deff64fc95d474af5bdee29ec') build() { cd "$srcdir/../.." From a38fb7aa9d0ed17e1f9cd9b7a6d1947d8e808e82 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Fri, 10 Apr 2026 20:17:10 +0100 Subject: [PATCH 11/20] updated pattern tokens in readme --- Cargo.lock | 2 +- README.md | 18 +++++++++++++----- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 141615e..0f96371 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -144,7 +144,7 @@ dependencies = [ [[package]] name = "dolltool" -version = "1.3.0" +version = "1.4.0" dependencies = [ "clap", "num-bigint", diff --git a/README.md b/README.md index 27392cd..3b0478c 100644 --- a/README.md +++ b/README.md @@ -75,11 +75,19 @@ hello world :3 Generates random codes based on a user-defined pattern: -- `n`: Number (0-9) -- `l`: Letter (a-z) -- `L`: Uppercase Letter (A-Z) -- `a`: Alphanumeric (0-9, a-z) -- `A`: Uppercase Alphanumeric (0-9, a-z) +- `n`: Digit (0-9) +- `l`: Letter Lowercase (a-z) +- `L`: Letter Uppercase (A-Z) +- `m`: Letter Mixed (a-z, A-Z) +- `a`: Alphanumeric Lowercase (0-9, a-z) +- `A`: Alphanumeric Uppercase (0-9, A-Z) +- `x`: Alphanumeric Mixed (0-9, a-z, A-Z) +- `b`: Binary Digit (0-1) +- `o`: Octal Digit (0-7) +- `h`: Hex Lowercase (0-f) +- `H`: Hex Uppercase (0-F) +- `X`: Hex Mixed (0-9, a-f, A-F) +- `*`: any other character is used literally ```bash $ dolltool -g "nn-lll" -c 3 From 2c11db2d285eccecba3ed7a3cc8a864249e698f1 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Mon, 13 Apr 2026 08:46:12 +0100 Subject: [PATCH 12/20] implemented count for pattern generation tokens --- src/pattern_gen.rs | 51 +++++++++++++++++++++++++++++++++++++--------- 1 file changed, 41 insertions(+), 10 deletions(-) diff --git a/src/pattern_gen.rs b/src/pattern_gen.rs index efe42d3..b8e6dd4 100644 --- a/src/pattern_gen.rs +++ b/src/pattern_gen.rs @@ -29,15 +29,12 @@ Pattern Tokens: X hex mixed (0-9, a-f, A-F) * any other character is used literally"; -fn pick(rng: &mut impl rand::Rng, pool: &[u8]) -> char { - pool[rng.random_range(0..pool.len())] as char -} - pub fn generate_from_pattern(pattern: &str) -> String { let mut rng = rand::rng(); - let mut output = String::with_capacity(pattern.len()); + let tokens = parse_pattern(pattern); + let mut output = String::with_capacity(tokens.iter().map(|(_, n)| n).sum()); - for c in pattern.chars() { + for (c, count) in tokens { let pool = match c { 'n' => Some(DIGITS), 'l' => Some(LETTERS_LOWER), @@ -54,10 +51,44 @@ pub fn generate_from_pattern(pattern: &str) -> String { _ => None, }; - output.push(match pool { - Some(p) => pick(&mut rng, p), - None => c, - }); + for _ in 0..count { + output.push(match pool { + Some(p) => pick(&mut rng, p), + None => c, + }); + } } output } + +fn pick(rng: &mut impl rand::Rng, pool: &[u8]) -> char { + pool[rng.random_range(0..pool.len())] as char +} + +fn parse_pattern(pattern: &str) -> Vec<(char, usize)> { + let mut tokens = Vec::new(); + let mut chars = pattern.chars().peekable(); + + while let Some(c) = chars.next() { + if chars.peek() == Some(&'{') { + chars.next(); + + let digits: String = chars.by_ref().take_while(|&x| x != '}').collect(); + + match digits.parse::() { + Ok(n) if n > 0 => tokens.push((c, n)), + _ => { + tokens.push((c, 1)); + + for d in digits.chars() { + tokens.push((d, 1)); + } + } + } + } else { + tokens.push((c, 1)); + } + } + + tokens +} From aeb3cfb71eea251915c3c671538a410a12d96da9 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Mon, 13 Apr 2026 09:14:01 +0100 Subject: [PATCH 13/20] fixed pattern generation to not throw error if zero value is generated --- src/main.rs | 44 +++++++++++++++++++++++++++----------------- 1 file changed, 27 insertions(+), 17 deletions(-) diff --git a/src/main.rs b/src/main.rs index 80143b4..00b26aa 100644 --- a/src/main.rs +++ b/src/main.rs @@ -83,29 +83,39 @@ fn main() { } if let Some(pattern) = args.generate { - for _ in 0..args.count { + let mut generated_count = 0; + + while generated_count < args.count { let generated = generate_from_pattern(&pattern); if args.no_doll { println!("{}", generated); - } else { - let as_num = if args.text { - None - } else { - BigUint::parse_bytes(generated.as_bytes(), args.base) - }; + generated_count += 1; + continue; + } - match as_num { - Some(num) => { - println!("{} :: {}", generated, to_dollcode(num).unwrap()); - } - None => { - let doll: Vec = generated - .chars() - .map(|c| to_dollcode(BigUint::from(c as u64)).unwrap()) - .collect(); - println!("{} :: {}", generated, doll.join(" ")); + let num = if args.text { + None + } else { + BigUint::parse_bytes(generated.as_bytes(), args.base) + }; + + match num { + Some(num) => match to_dollcode(num) { + Ok(code) => { + println!("{} :: {}", generated, code); + generated_count += 1; } + Err(_) => continue, + }, + None => { + let doll: Vec = generated + .chars() + .map(|c| to_dollcode(BigUint::from(c as u64)).unwrap()) + .collect(); + + println!("{} :: {}", generated, doll.join(" ")); + generated_count += 1; } } } From 5ac61418a9ff90d32175010167d54a75622ec91d Mon Sep 17 00:00:00 2001 From: ika4422 Date: Mon, 13 Apr 2026 09:50:10 +0100 Subject: [PATCH 14/20] extracted logic from main module into separate modules --- src/commands.rs | 103 +++++++++++++++++++++++++++++++++++ src/main.rs | 140 +++--------------------------------------------- src/models.rs | 41 ++++++++++++++ 3 files changed, 151 insertions(+), 133 deletions(-) create mode 100644 src/commands.rs create mode 100644 src/models.rs diff --git a/src/commands.rs b/src/commands.rs new file mode 100644 index 0000000..9ecfec3 --- /dev/null +++ b/src/commands.rs @@ -0,0 +1,103 @@ +use std::process; + +use num_bigint::BigUint; +use num_traits::ToPrimitive; + +use crate::{ + dollcode::{from_dollcode, to_dollcode}, + pattern_gen::generate_from_pattern, +}; + +pub fn run_generate(pattern: &str, count: usize, base: u32, no_doll: bool, text: bool) { + let mut generated_count = 0; + + while generated_count < count { + let generated = generate_from_pattern(pattern); + + if no_doll { + println!("{}", generated); + generated_count += 1; + continue; + } + + let num = if text { + None + } else { + BigUint::parse_bytes(generated.as_bytes(), base) + }; + + match num { + Some(num) => match to_dollcode(num) { + Ok(code) => { + println!("{} :: {}", generated, code); + generated_count += 1; + } + Err(_) => continue, + }, + None => { + let doll: Vec = generated + .chars() + .map(|c| to_dollcode(BigUint::from(c as u64)).unwrap()) + .collect(); + + println!("{} :: {}", generated, doll.join(" ")); + generated_count += 1; + } + } + } +} + +pub fn run_encode(input: &str, base: u32, text: bool) { + let encode_as_text = text || BigUint::parse_bytes(input.as_bytes(), base).is_none(); + + if encode_as_text { + let result: Vec = input + .chars() + .map(|c| to_dollcode(BigUint::from(c as u64)).unwrap()) + .collect(); + println!("{}", result.join(" ")); + } else { + let num = BigUint::parse_bytes(input.as_bytes(), base).unwrap(); + + match to_dollcode(num) { + Ok(code) => println!("{}", code), + Err(e) => { + eprintln!("Error: {}", e); + process::exit(1); + } + } + } +} + +pub fn run_decode(input: &str, base: u32, text: bool) { + let decode_as_text = text || input.split_whitespace().count() > 1; + + if decode_as_text { + let mut decoded_chars = String::new(); + + for part in input.split_whitespace() { + match from_dollcode(part) { + Ok(val) => { + if let Some(u) = val.to_u32() { + decoded_chars.push(char::from_u32(u).unwrap_or('?')); + } else { + decoded_chars.push('?'); + } + } + Err(e) => { + eprintln!("Error: {}", e); + process::exit(1); + } + } + } + println!("{}", decoded_chars); + } else { + match from_dollcode(input) { + Ok(val) => println!("{}", val.to_str_radix(base)), + Err(e) => { + eprintln!("Error: {}", e); + process::exit(1); + } + } + } +} diff --git a/src/main.rs b/src/main.rs index 00b26aa..b129c88 100644 --- a/src/main.rs +++ b/src/main.rs @@ -15,66 +15,23 @@ * along with this program. If not, see . */ +mod commands; mod dollcode; +mod models; mod pattern_gen; use std::process; use clap::Parser; -use num_bigint::BigUint; -use num_traits::ToPrimitive; -use crate::{ - dollcode::{from_dollcode, to_dollcode}, - pattern_gen::generate_from_pattern, -}; - -#[derive(Parser, Debug)] -#[command(author, version, about)] -struct Args { - #[arg(short, long)] - /// Encodes the following integer or text into dollcode - encode: Option, - - #[arg(short, long)] - /// Decodes the following dollcode into an integer or text - decode: Option, - - #[arg(short, long)] - /// Generates codes from a user-defined pattern (see --tokens for token list) - generate: Option, - - #[arg(short, long, default_value_t = 1)] - /// Specifies how many codes to generate - count: usize, - - #[arg(short, long, default_value_t = 10)] - /// Input/output base for integers (2, 8, 10, 16) - base: u32, - - #[arg(long, default_value_t = false)] - /// Will generate codes without encoding it into dollcode - no_doll: bool, - - #[arg(short, long, default_value_t = false)] - /// Specifies the encoding/decoding method as text, instead of an integer - text: bool, - - #[arg(long, default_value_t = false)] - /// List all available pattern tokens - tokens: bool, - - #[arg(long)] - /// Display the license for dolltool - license: bool, -} +use crate::models::Args; fn main() { let args = Args::parse(); if args.license { println!("{}", include_str!("../LICENSE")); - process::exit(1); + process::exit(0); } if args.tokens { @@ -83,93 +40,10 @@ fn main() { } if let Some(pattern) = args.generate { - let mut generated_count = 0; - - while generated_count < args.count { - let generated = generate_from_pattern(&pattern); - - if args.no_doll { - println!("{}", generated); - generated_count += 1; - continue; - } - - let num = if args.text { - None - } else { - BigUint::parse_bytes(generated.as_bytes(), args.base) - }; - - match num { - Some(num) => match to_dollcode(num) { - Ok(code) => { - println!("{} :: {}", generated, code); - generated_count += 1; - } - Err(_) => continue, - }, - None => { - let doll: Vec = generated - .chars() - .map(|c| to_dollcode(BigUint::from(c as u64)).unwrap()) - .collect(); - - println!("{} :: {}", generated, doll.join(" ")); - generated_count += 1; - } - } - } + commands::run_generate(&pattern, args.count, args.base, args.no_doll, args.text); } else if let Some(input) = args.encode { - let encode_as_text = - args.text || BigUint::parse_bytes(input.as_bytes(), args.base).is_none(); - - if encode_as_text { - let result: Vec = input - .chars() - .map(|c| to_dollcode(BigUint::from(c as u64)).unwrap()) - .collect(); - println!("{}", result.join(" ")); - } else { - let num = BigUint::parse_bytes(input.as_bytes(), args.base).unwrap(); - - match to_dollcode(num) { - Ok(code) => println!("{}", code), - Err(e) => { - eprintln!("Error: {}", e); - process::exit(1); - } - } - } + commands::run_encode(&input, args.base, args.text); } else if let Some(input) = args.decode { - let decode_as_text = args.text || input.split_whitespace().count() > 1; - - if decode_as_text { - let mut decoded_chars = String::new(); - - for part in input.split_whitespace() { - match from_dollcode(part) { - Ok(val) => { - if let Some(u) = val.to_u32() { - decoded_chars.push(char::from_u32(u).unwrap_or('?')); - } else { - decoded_chars.push('?'); - } - } - Err(e) => { - eprintln!("Error: {}", e); - process::exit(1); - } - } - } - println!("{}", decoded_chars); - } else { - match from_dollcode(&input) { - Ok(val) => println!("{}", val.to_str_radix(args.base)), - Err(e) => { - eprintln!("Error: {}", e); - process::exit(1); - } - } - } + commands::run_decode(&input, args.base, args.text); } } diff --git a/src/models.rs b/src/models.rs new file mode 100644 index 0000000..cdafb70 --- /dev/null +++ b/src/models.rs @@ -0,0 +1,41 @@ +use clap::Parser; + +#[derive(Parser, Debug)] +#[command(author, version, about)] +pub struct Args { + #[arg(short, long)] + /// Encodes the following integer or text into dollcode + pub encode: Option, + + #[arg(short, long)] + /// Decodes the following dollcode into an integer or text + pub decode: Option, + + #[arg(short, long)] + /// Generates codes from a user-defined pattern (see --tokens for token list) + pub generate: Option, + + #[arg(short, long, default_value_t = 1)] + /// Specifies how many codes to generate + pub count: usize, + + #[arg(short, long, default_value_t = 10)] + /// Input/output base for integers (2, 8, 10, 16) + pub base: u32, + + #[arg(long, default_value_t = false)] + /// Will generate codes without encoding it into dollcode + pub no_doll: bool, + + #[arg(short, long, default_value_t = false)] + /// Specifies the encoding/decoding method as text, instead of an integer + pub text: bool, + + #[arg(long, default_value_t = false)] + /// List all available pattern tokens + pub tokens: bool, + + #[arg(long)] + /// Display the license for dolltool + pub license: bool, +} From b68815c29c7d0a58188c3a312f716c3caa73d7c6 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Mon, 13 Apr 2026 10:56:37 +0100 Subject: [PATCH 15/20] added value names for args and implemented string conversion for bases --- src/main.rs | 12 ++++++-- src/models.rs | 84 ++++++++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 86 insertions(+), 10 deletions(-) diff --git a/src/main.rs b/src/main.rs index b129c88..cb2a4e4 100644 --- a/src/main.rs +++ b/src/main.rs @@ -40,10 +40,16 @@ fn main() { } if let Some(pattern) = args.generate { - commands::run_generate(&pattern, args.count, args.base, args.no_doll, args.text); + commands::run_generate( + &pattern, + args.count, + args.base.radix(), + args.no_doll, + args.text, + ); } else if let Some(input) = args.encode { - commands::run_encode(&input, args.base, args.text); + commands::run_encode(&input, args.base.radix(), args.text); } else if let Some(input) = args.decode { - commands::run_decode(&input, args.base, args.text); + commands::run_decode(&input, args.base.radix(), args.text); } } diff --git a/src/models.rs b/src/models.rs index cdafb70..43cfe07 100644 --- a/src/models.rs +++ b/src/models.rs @@ -3,25 +3,25 @@ use clap::Parser; #[derive(Parser, Debug)] #[command(author, version, about)] pub struct Args { - #[arg(short, long)] + #[arg(short, long, value_name = "INPUT")] /// Encodes the following integer or text into dollcode pub encode: Option, - #[arg(short, long)] + #[arg(short, long, value_name = "DOLLCODE")] /// Decodes the following dollcode into an integer or text pub decode: Option, - #[arg(short, long)] + #[arg(short, long, value_name = "PATTERN")] /// Generates codes from a user-defined pattern (see --tokens for token list) pub generate: Option, - #[arg(short, long, default_value_t = 1)] + #[arg(short, long, default_value_t = 1, value_name = "N")] /// Specifies how many codes to generate pub count: usize, - #[arg(short, long, default_value_t = 10)] - /// Input/output base for integers (2, 8, 10, 16) - pub base: u32, + #[arg(short, long, default_value_t = Base(10))] + /// Input/output base for integers (2-36, or bin/oct/dec/hex/..) + pub base: Base, #[arg(long, default_value_t = false)] /// Will generate codes without encoding it into dollcode @@ -39,3 +39,73 @@ pub struct Args { /// Display the license for dolltool pub license: bool, } + +#[derive(Debug, Clone, Copy)] +pub struct Base(u32); + +impl Base { + pub fn radix(self) -> u32 { + self.0 + } +} + +impl std::str::FromStr for Base { + type Err = String; + + fn from_str(s: &str) -> Result { + // c'tu inutile? ouais + // chu-tu une grosse nerd? ouais aussi + let radix = match s { + "bin" | "binary" => 2, + "ter" | "ternary" | "trinary" => 3, + "quat" | "quaternary" => 4, + "quin" | "quinary" => 5, + "sen" | "senary" => 6, + "sep" | "septenary" => 7, + "oct" | "octal" => 8, + "non" | "nonary" => 9, + "dec" | "denary" | "decimal" => 10, + "und" | "undecimal" => 11, + "duo" | "duodecimal" | "dozenal" => 12, + "tridecimal" => 13, + "tetradecimal" => 14, + "pentadecimal" => 15, + "hex" | "hexadecimal" => 16, + "heptadecimal" => 17, + "octodecimal" => 18, + "nonadecimal" | "enneadecimal" => 19, + "vig" | "vigesimal" => 20, + "unvigesimal" => 21, + "duovigesimal" => 22, + "trivigesimal" => 23, + "tetravigesimal" => 24, + "pentavigesimal" => 25, + "hexavigesimal" => 26, + "heptavigesimal" => 27, + "octovigesimal" => 28, + "nonavigesimal" => 29, + "trigesimal" => 30, + "untrigesimal" => 31, + "dtg" | "duotrigesimal" => 32, + "tritrigesimal" => 33, + "tetratrigesimal" => 34, + "pentatrigesimal" => 35, + "htg" | "hexatrigesimal" => 36, + _ => s + .parse::() + .map_err(|_| format!("'{}' is not a valid base", s))?, + }; + + if (2..=32).contains(&radix) { + Ok(Base(radix)) + } else { + Err(format!("base must be between 2 and 36, got {}", radix)) + } + } +} + +impl std::fmt::Display for Base { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.0) + } +} From ca1e27a84eca4ffd6746c99977ab781094d75a20 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Mon, 13 Apr 2026 11:34:55 +0100 Subject: [PATCH 16/20] implmented a decode to all standard bases flag --- src/commands.rs | 13 +++++++++++-- src/main.rs | 2 +- src/models.rs | 4 ++++ 3 files changed, 16 insertions(+), 3 deletions(-) diff --git a/src/commands.rs b/src/commands.rs index 9ecfec3..7397db8 100644 --- a/src/commands.rs +++ b/src/commands.rs @@ -69,7 +69,7 @@ pub fn run_encode(input: &str, base: u32, text: bool) { } } -pub fn run_decode(input: &str, base: u32, text: bool) { +pub fn run_decode(input: &str, base: u32, text: bool, all_bases: bool) { let decode_as_text = text || input.split_whitespace().count() > 1; if decode_as_text { @@ -93,7 +93,16 @@ pub fn run_decode(input: &str, base: u32, text: bool) { println!("{}", decoded_chars); } else { match from_dollcode(input) { - Ok(val) => println!("{}", val.to_str_radix(base)), + Ok(val) => { + if all_bases { + println!("bin :: {}", val.to_str_radix(2)); + println!("oct :: {}", val.to_str_radix(8)); + println!("dec :: {}", val.to_str_radix(10)); + println!("hex :: {}", val.to_str_radix(16)); + } else { + println!("{}", val.to_str_radix(base)); + } + } Err(e) => { eprintln!("Error: {}", e); process::exit(1); diff --git a/src/main.rs b/src/main.rs index cb2a4e4..862230d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -50,6 +50,6 @@ fn main() { } else if let Some(input) = args.encode { commands::run_encode(&input, args.base.radix(), args.text); } else if let Some(input) = args.decode { - commands::run_decode(&input, args.base.radix(), args.text); + commands::run_decode(&input, args.base.radix(), args.text, args.all_bases); } } diff --git a/src/models.rs b/src/models.rs index 43cfe07..5424653 100644 --- a/src/models.rs +++ b/src/models.rs @@ -23,6 +23,10 @@ pub struct Args { /// Input/output base for integers (2-36, or bin/oct/dec/hex/..) pub base: Base, + #[arg(long, default_value_t = false)] + /// Output result in binary, octal, decimal and hex + pub all_bases: bool, + #[arg(long, default_value_t = false)] /// Will generate codes without encoding it into dollcode pub no_doll: bool, From 6c644d1256c337711f136be4da967fe709822ab1 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Mon, 13 Apr 2026 11:38:47 +0100 Subject: [PATCH 17/20] fixed maximum radix value from 32 to 36 --- src/models.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/models.rs b/src/models.rs index 5424653..e117baf 100644 --- a/src/models.rs +++ b/src/models.rs @@ -100,7 +100,7 @@ impl std::str::FromStr for Base { .map_err(|_| format!("'{}' is not a valid base", s))?, }; - if (2..=32).contains(&radix) { + if (2..=36).contains(&radix) { Ok(Base(radix)) } else { Err(format!("base must be between 2 and 36, got {}", radix)) From f428ac59e0d44d1848add8b8dbf7d849c62d1912 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Mon, 13 Apr 2026 13:13:53 +0100 Subject: [PATCH 18/20] added pattern token which changes character set depending on radix --- src/commands.rs | 2 +- src/pattern_gen.rs | 6 +++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/commands.rs b/src/commands.rs index 7397db8..771b9b1 100644 --- a/src/commands.rs +++ b/src/commands.rs @@ -12,7 +12,7 @@ pub fn run_generate(pattern: &str, count: usize, base: u32, no_doll: bool, text: let mut generated_count = 0; while generated_count < count { - let generated = generate_from_pattern(pattern); + let generated = generate_from_pattern(pattern, base); if no_doll { println!("{}", generated); diff --git a/src/pattern_gen.rs b/src/pattern_gen.rs index b8e6dd4..c189db2 100644 --- a/src/pattern_gen.rs +++ b/src/pattern_gen.rs @@ -27,13 +27,16 @@ Pattern Tokens: h hex lower (0-f) H hex upper (0-F) X hex mixed (0-9, a-f, A-F) + r radix digit (0 to base-1, depends on --base) * any other character is used literally"; -pub fn generate_from_pattern(pattern: &str) -> String { +pub fn generate_from_pattern(pattern: &str, base: u32) -> String { let mut rng = rand::rng(); let tokens = parse_pattern(pattern); let mut output = String::with_capacity(tokens.iter().map(|(_, n)| n).sum()); + let base_digits = &ALNUM_LOWER[..base as usize]; + for (c, count) in tokens { let pool = match c { 'n' => Some(DIGITS), @@ -48,6 +51,7 @@ pub fn generate_from_pattern(pattern: &str) -> String { 'h' => Some(DIGITS_HEX_LOWER), 'H' => Some(DIGITS_HEX_UPPER), 'X' => Some(DIGITS_HEX_MIXED), + 'r' => Some(base_digits), _ => None, }; From 29a68bc047e08281e9cf55a45c48d3455c645bb1 Mon Sep 17 00:00:00 2001 From: ika4422 Date: Mon, 13 Apr 2026 18:15:29 +0100 Subject: [PATCH 19/20] reworked pattern generation again to remove individual tokens for upper and mixed capitalization --- src/pattern_gen.rs | 195 +++++++++++++++++++++++++++++---------------- 1 file changed, 127 insertions(+), 68 deletions(-) diff --git a/src/pattern_gen.rs b/src/pattern_gen.rs index c189db2..00cc66e 100644 --- a/src/pattern_gen.rs +++ b/src/pattern_gen.rs @@ -1,65 +1,73 @@ use rand::RngExt; -const DIGITS: &[u8] = b"0123456789"; -const LETTERS_LOWER: &[u8] = b"abcdefghijklmnopqrstuvwxyz"; -const LETTERS_UPPER: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"; -const LETTERS_MIXED: &[u8] = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; -const ALNUM_LOWER: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz"; -const ALNUM_UPPER: &[u8] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; -const ALNUM_MIXED: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; -const DIGITS_BINARY: &[u8] = b"01"; -const DIGITS_OCTAL: &[u8] = b"01234567"; -const DIGITS_HEX_LOWER: &[u8] = b"0123456789abcdef"; -const DIGITS_HEX_UPPER: &[u8] = b"0123456789ABCDEF"; -const DIGITS_HEX_MIXED: &[u8] = b"0123456789abcdefABCDEF"; - pub const TOKEN_HELP: &str = "\ -Pattern Tokens: - n digit (0-9) - l letter lower (a-z) - L letter upper (A-Z) - m letter mixed (a-z, A-Z) - a alnum lower (0-9, a-z) - A alnum upper (0-9, A-Z) - x alnum mixed (0-9, a-z, A-Z) - b binary digit (0-1) - o octal digit (0-7) - h hex lower (0-f) - H hex upper (0-F) - X hex mixed (0-9, a-f, A-F) - r radix digit (0 to base-1, depends on --base) - * any other character is used literally"; +Cased Tokens: + l[^~] letter (a-z / A-Z / both) + a[^~] alphanumeric (0-9; a-z / A-Z / both) + h[^~] hex digit (0-9; a-f / A-F / both) + r[^~] radix digit (0 to base-1, depends on --base) + +Fixed Tokens: + n / d digit (0-9) + b binary (0-1) + o octal (0-7) + +Repition: + t{N} repeat token t exactly N times (e.g. a{4}, h^{8}) + +* any other character is taken literally"; + +const DIGITS: &[u8] = b"0123456789"; +const LETTERS: &[u8] = b"abcdefghijklmnopqrstuvwxyz"; +const ALNUM: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz"; +const BINARY: &[u8] = b"01"; +const OCTAL: &[u8] = b"01234567"; +const HEX: &[u8] = b"0123456789abcdef"; + +#[derive(Debug, Clone, Copy, PartialEq)] +enum Case { + Lower, + Upper, + Mixed, +} + +#[derive(Debug, Clone, Copy)] +enum Token { + Digit, + Letter(Case), + Alnum(Case), + Binary, + Octal, + Hex(Case), + Radix(Case), + Literal(char), +} + +#[derive(Debug, Clone)] +struct PatternToken { + token: Token, + count: usize, +} pub fn generate_from_pattern(pattern: &str, base: u32) -> String { let mut rng = rand::rng(); let tokens = parse_pattern(pattern); - let mut output = String::with_capacity(tokens.iter().map(|(_, n)| n).sum()); + let mut output = String::with_capacity(tokens.iter().map(|t| t.count).sum()); + let radix_pool = &ALNUM[..base as usize]; - let base_digits = &ALNUM_LOWER[..base as usize]; - - for (c, count) in tokens { - let pool = match c { - 'n' => Some(DIGITS), - 'l' => Some(LETTERS_LOWER), - 'L' => Some(LETTERS_UPPER), - 'm' => Some(LETTERS_MIXED), - 'a' => Some(ALNUM_LOWER), - 'A' => Some(ALNUM_UPPER), - 'x' => Some(ALNUM_MIXED), - 'b' => Some(DIGITS_BINARY), - 'o' => Some(DIGITS_OCTAL), - 'h' => Some(DIGITS_HEX_LOWER), - 'H' => Some(DIGITS_HEX_UPPER), - 'X' => Some(DIGITS_HEX_MIXED), - 'r' => Some(base_digits), - _ => None, - }; - - for _ in 0..count { - output.push(match pool { - Some(p) => pick(&mut rng, p), - None => c, - }); + for pt in tokens { + for _ in 0..pt.count { + let ch = match pt.token { + Token::Digit => pick(&mut rng, DIGITS), + Token::Binary => pick(&mut rng, BINARY), + Token::Octal => pick(&mut rng, OCTAL), + Token::Letter(case) => pick_cased(&mut rng, LETTERS, case), + Token::Alnum(case) => pick_cased(&mut rng, ALNUM, case), + Token::Hex(case) => pick_cased(&mut rng, HEX, case), + Token::Radix(case) => pick_cased(&mut rng, radix_pool, case), + Token::Literal(c) => c, + }; + output.push(ch); } } output @@ -69,28 +77,79 @@ fn pick(rng: &mut impl rand::Rng, pool: &[u8]) -> char { pool[rng.random_range(0..pool.len())] as char } -fn parse_pattern(pattern: &str) -> Vec<(char, usize)> { +fn pick_cased(rng: &mut impl rand::Rng, pool: &[u8], case: Case) -> char { + let ch = pick(rng, pool); + + match case { + Case::Lower => ch, + Case::Upper => ch.to_ascii_uppercase(), + Case::Mixed => { + if rng.random::() { + ch.to_ascii_uppercase() + } else { + ch + } + } + } +} + +fn parse_case(chars: &mut std::iter::Peekable>) -> Case { + match chars.peek() { + Some(&'^') => { + chars.next(); + Case::Upper + } + Some(&'~') => { + chars.next(); + Case::Mixed + } + _ => Case::Lower, + } +} + +fn parse_pattern(pattern: &str) -> Vec { let mut tokens = Vec::new(); let mut chars = pattern.chars().peekable(); while let Some(c) = chars.next() { - if chars.peek() == Some(&'{') { + let case = if matches!(c, 'l' | 'a' | 'h' | 'r') { + parse_case(&mut chars) + } else { + Case::Lower + }; + + let (count, spill) = if chars.peek() == Some(&'{') { chars.next(); + let inner: String = chars.by_ref().take_while(|&x| x != '}').collect(); - let digits: String = chars.by_ref().take_while(|&x| x != '}').collect(); - - match digits.parse::() { - Ok(n) if n > 0 => tokens.push((c, n)), - _ => { - tokens.push((c, 1)); - - for d in digits.chars() { - tokens.push((d, 1)); - } - } + match inner.parse::() { + Ok(n) if n > 0 => (n, None), + _ => (1, Some(inner)), } } else { - tokens.push((c, 1)); + (1, None) + }; + + let token = match c { + 'n' | 'd' => Token::Digit, + 'b' => Token::Binary, + 'o' => Token::Octal, + 'l' => Token::Letter(case), + 'a' => Token::Alnum(case), + 'h' => Token::Hex(case), + 'r' => Token::Radix(case), + _ => Token::Literal(c), + }; + + tokens.push(PatternToken { token, count }); + + if let Some(spill) = spill { + for sc in spill.chars() { + tokens.push(PatternToken { + token: Token::Literal(sc), + count: 1, + }); + } } } From 03f35f0b355e7a1065d677caf2bde922a0613ecf Mon Sep 17 00:00:00 2001 From: Doll154621 <154621@softkittypa.ws> Date: Mon, 27 Jul 2026 21:20:57 +1000 Subject: [PATCH 20/20] Add Nix flake. :3 --- .gitignore | 2 ++ flake.nix | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 75 insertions(+) create mode 100644 flake.nix diff --git a/.gitignore b/.gitignore index f5064dd..c744ab9 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,5 @@ pkg/*.pkg.tar.zst pkg/*.tar.gz pkg/pkg/ pkg/src/ +result/ +flake.lock diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..96520ea --- /dev/null +++ b/flake.nix @@ -0,0 +1,73 @@ +{ + description = "A simple dollcode encoder, decoder, and generator inside your terminal :3"; + + inputs = { + nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable"; + crane.url = "github:ipetkov/crane"; + flake-utils.url = "github:numtide/flake-utils"; + }; + + outputs = { self, nixpkgs, crane, flake-utils }: + flake-utils.lib.eachDefaultSystem (system: + let + pkgs = import nixpkgs { inherit system; }; + + craneLib = crane.mkLib pkgs; + + # Common build inputs / env shared across derivations. + # crane's default cargo source filter drops LICENSE, but main.rs does + # `include_str!("../LICENSE")`, so we keep it alongside cargo sources. + commonArgs = { + src = pkgs.lib.cleanSourceWith { + src = ./.; + filter = path: type: + craneLib.filterCargoSources path type + || baseNameOf path == "LICENSE"; + }; + strictDeps = true; + }; + + # Build *just* the dependencies so they can be cached and reused + # across source changes. (Edition 2024 needs Rust >= 1.85, which + # nixpkgs-unstable ships by default.) + cargoArtifacts = craneLib.buildDepsOnly commonArgs; + + dolltool = craneLib.buildPackage (commonArgs // { + inherit cargoArtifacts; + doCheck = true; + }); + in + { + packages = { + default = dolltool; + inherit dolltool; + }; + + apps.default = flake-utils.lib.mkApp { + drv = dolltool; + name = "dolltool"; + }; + + devShells.default = pkgs.mkShell { + inputsFrom = [ dolltool ]; + packages = with pkgs; [ + rustc + cargo + cargo-edit + rustfmt + clippy + ]; + }; + + checks = { + inherit dolltool; + clippy = craneLib.cargoClippy (commonArgs // { + inherit cargoArtifacts; + cargoClippyExtraArgs = "--all-targets -- --deny warnings"; + }); + fmt = craneLib.cargoFmt (commonArgs // { + inherit cargoArtifacts; + }); + }; + }); +} \ No newline at end of file