PlexSheep
/
numf
Archived
generated from PlexSheep/rs-base
1
1
Fork 0
Code Issues 2 Pull Requests 1 Actions Packages Projects Releases 8 Wiki Activity

Compare commits

base: PlexSheep:master
Branches Tags
PlexSheep:master
PlexSheep:devel
PlexSheep:feat/guess-format
PlexSheep:v0.4.1
PlexSheep:v0.4.0
PlexSheep:v0.3.3
PlexSheep:v0.3.2
PlexSheep:v0.3.1
PlexSheep:v0.3.0
PlexSheep:v0.2.0
PlexSheep:v0.1.0
..
compare: PlexSheep:v0.3.1
Branches Tags
PlexSheep:master
PlexSheep:devel
PlexSheep:feat/guess-format
PlexSheep:v0.4.1
PlexSheep:v0.4.0
PlexSheep:v0.3.3
PlexSheep:v0.3.2
PlexSheep:v0.3.1
PlexSheep:v0.3.0
PlexSheep:v0.2.0
PlexSheep:v0.1.0

No commits in common. "master" and "v0.3.1" have entirely different histories.
master ... v0.3.1

11 changed files with 204 additions and 629 deletions
Show Stats Expand all files Collapse all files

46
.gitea/workflows/cargo.yaml Normal file
View File

@ -0,0 +1,46 @@
name: cargo devel CI
on:
push:
branches:
- '**'
# - '!master'
jobs:
format:
name: cargo CI
permissions:
# Give the default GITHUB_TOKEN write permission to commit and push the
# added or changed files to the repository.
contents: write
steps:
- name: get repo
uses: actions/checkout@v4
- name: install rust
uses: https://github.com/dtolnay/rust-toolchain@stable
- name: install additional rust things
run: |
rustup component add rustfmt
rustup component add clippy
- name: config custom registry
run: |
mkdir -p ~/.cargo/
echo "" > ~/.cargo/config.toml
echo "[registry]" >> ~/.cargo/config.toml
echo 'cscherr = "cscherr"' >> ~/.cargo/config.toml
echo '[registries.cscherr]' >> ~/.cargo/config.toml
echo 'index = "https://git.cscherr.de/PlexSheep/_cargo-index.git"' >> ~/.cargo/config.toml
cat ~/.cargo/config.toml
- name: cargo clippy check
run: cargo clippy --all-features --all-targets --workspace
- name: cargo clippy fix
run: cargo clippy --fix --all-features --all-targets --workspace
- name: cargo fmt
run: cargo fmt --all
- name: cargo test
run: cargo test --all-features --all-targets --workspace && cargo test --all-features --workspace --doc
- name: commit back to repository
uses: https://github.com/stefanzweifel/git-auto-commit-action@v5
with:
# Optional. Commit message for the created commit.
# Defaults to "Apply automatic changes"
commit_message: automatic cargo CI changes

7
.github/dependabot.yaml vendored
View File

@ -1,7 +0,0 @@
version: 2
updates:
- package-ecosystem: "github-actions"
directory: "/"
# Check for updates every Monday
schedule:
interval: "weekly"

12
.github/workflows/cargo.yaml vendored
View File

@ -1,16 +1,10 @@
name: Rust CI name: cargo devel CI
on: on:
pull_request:
branches:
- '**'
push: push:
branches: branches:
- '**' - '**'
# - '!master' # - '!master'
env:
CARGO_TERM_COLOR: always
jobs: jobs:
CI: CI:
runs-on: ubuntu-latest runs-on: ubuntu-latest
@ -44,10 +38,10 @@ jobs:
- name: cargo fmt - name: cargo fmt
run: cargo fmt --all run: cargo fmt --all
- name: cargo test - name: cargo test
run: cargo test --all-features --all-targets --workspace run: cargo test --all-features --all-targets --workspace && cargo test --all-features --workspace --doc
- name: commit back to repository - name: commit back to repository
uses: stefanzweifel/git-auto-commit-action@v5 uses: stefanzweifel/git-auto-commit-action@v5
with: with:
# Optional. Commit message for the created commit. # Optional. Commit message for the created commit.
# Defaults to "Apply automatic changes" # Defaults to "Apply automatic changes"
commit_message: "ci: automatic Rust CI changes" commit_message: automatic cargo CI changes

54
.github/workflows/release.yaml vendored
View File

@ -1,54 +0,0 @@
name: Release-plz
permissions:
pull-requests: write
contents: write
on:
push:
branches:
- master
- main
jobs:
# Release unpublished packages.
release-plz-release:
name: Release-plz release
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Install Rust toolchain
uses: dtolnay/rust-toolchain@stable
- name: Run release-plz
uses: MarcoIeni/release-plz-action@v0.5
with:
command: release
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
# Create a PR with the new versions and changelog, preparing the next release.
release-plz-pr:
name: Release-plz PR
runs-on: ubuntu-latest
concurrency:
group: release-plz-${{ github.ref }}
cancel-in-progress: false
steps:
- name: Checkout repository
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Install Rust toolchain
uses: dtolnay/rust-toolchain@stable
- name: Run release-plz
uses: MarcoIeni/release-plz-action@v0.5
with:
command: release-pr
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

7
Cargo.toml
View File

@ -1,6 +1,6 @@
[package] [package]
name = "numf" name = "numf"
version = "0.4.1" version = "0.3.1"
edition = "2021" edition = "2021"
publish = true publish = true
authors = ["Christoph J. Scherr <software@cscherr.de>"] authors = ["Christoph J. Scherr <software@cscherr.de>"]
@ -16,7 +16,8 @@ categories = ["command-line-utilities", "encoding"]
[dependencies] [dependencies]
anyhow = "1.0.83" anyhow = "1.0.83"
clap = { version = "4.5.4", features = ["derive"] } clap = { version = "4.5.4", features = ["derive"] }
clap-num = "1.1.1"
fast32 = "1.0.2" fast32 = "1.0.2"
libpt = { version = "0.6.0", features = ["bintols", "log", "cli"] } libpt = { version = "0.5.1", features = ["bintols"]}
num = "0.4.3" num = "0.4.3"
rand = "0.8.5"

46
README.md
View File

@ -1,15 +1,5 @@
# numf # numf
![Project badge](https://img.shields.io/badge/language-Rust-blue.svg)
![Crates.io License](https://img.shields.io/crates/l/numf)
![GitHub Release](https://img.shields.io/github/v/release/PlexSheep/numf)
![GitHub language count](https://img.shields.io/github/languages/count/PlexSheep/numf)
[![Rust CI](https://github.com/PlexSheep/numf/actions/workflows/cargo.yaml/badge.svg)](https://github.com/PlexSheep/numf/actions/workflows/cargo.yaml)
* [GitHub](https://github.com/PlexSheep/numf)
* [crates.io](https://crates.io/crates/numf)
* [docs.rs](https://docs.rs/numf/latest/numf/)
`numf` is a number formatter. It formats the numbers provided to it. `numf` is a number formatter. It formats the numbers provided to it.
Current formats are: Current formats are:
@ -20,11 +10,9 @@ Current formats are:
- Decimal - Decimal
- Base32 - Base32
- Base64 - Base64
- Raw
`numf` also has the option of prepending a prefix for the formats, such as `numf` also has the option of prepending a prefix for each format, such as
`0x` for hexadecimal. Numbers may also be provided from the stdin. See `--help` `0x` for hexadecimal.
flag for more information.
## Example ## Example
@ -33,34 +21,4 @@ $ numf -xp 1337 505 0xaabb
0x539 0x539
0x1F9 0x1F9
0xAABB 0xAABB
$ numf -a 505 | hedxump -C
00000000 01 f9 |..|
00000002
$ numf -a 505 | numf
1F9
$ numf -a 505 | numf -d
505
$ numf -a 505 | numf -b
111111001
$ echo -ne "\x20\xff\xb4" | numf -xpP
0x20FFB4
$ echo -ne "\x20\xff\xb4" | numf -d
2162612
$ base64='aGVsbG8gd29ybGQuCg==' ; echo "0s$base64" | numf -d
8271117963529473544792763018762
$ base64='aGVsbG8gd29ybGQuCg==' ; echo "0s$base64" | numf -s
aGVsbG8gd29ybGQuCg==
$ echo "0b100100101010" | numf -d
2346
$ echo "0b100100101010" | numf -bPp
0b0000100100101010
```
## Installing
### Cargo
`numf` is on [crates.io](https://crates.io).
```
cargo install numf
``` ```

2
scripts/release.sh
View File

@ -4,7 +4,7 @@ NEW_VERSION=$(cat Cargo.toml | rg '^\s*version\s*=\s*"([^"]*)"\s*$' -or '$1')
GIT_COMMIT_SHA=$(git rev-parse HEAD) GIT_COMMIT_SHA=$(git rev-parse HEAD)
REPO=${PWD##*/} # name of cwd REPO=${PWD##*/} # name of cwd
BODY=" BODY="
$(git log $(git describe --tags --abbrev=0)..HEAD --pretty="- %s" --oneline --no-decorate) $(git log $(git describe --tags --abbrev=0)..HEAD --pretty="- %s" --oneline --decorate)
" "
USER=PlexSheep USER=PlexSheep
git tag "v$NEW_VERSION" || echo "could not tag" git tag "v$NEW_VERSION" || echo "could not tag"

419
src/format.rs
View File

@ -1,97 +1,26 @@
//! This module implements the actual formatting in [numf](crate). #![allow(dead_code)] // this is exported to lib.rs
//!
//! You can use it in your own program to convert numbers to formats.
//!
//! # Example
//!
//! The following example shows how to use numf to format your integers.
//!
//! ```
//! use numf::format::{Format, FormatOptions};
//!
//! let mut options = FormatOptions::default();
//! options.set_prefix(true);
//! options.set_padding(true);
//!
//! assert_eq!(Format::Hex.format_str(0x1337, &options), "0x1337");
//! assert_eq!(Format::Base32.format_str(0x41414242, &options), "032sIFAUEQQ=");
//! assert_eq!(Format::Base64.format_str(0x41414242, &options), "0sQUFCQg==");
//! // sometimes you might need the raw bytes instead of a String
//! assert_eq!(Format::Raw.format(0x1337, &options), vec![0x00, 0x13, 0x37]);
//! assert_eq!(Format::Hex.format(0x1337, &options), vec![48, 120, 49, 51, 51, 55]);
//!
//! options.set_prefix(false);
//! options.set_padding(false);
//!
//! assert_eq!(Format::Hex.format_str(0x1337, &options), "1337");
//! assert_eq!(Format::Base32.format_str(0x41414242, &options), "IFAUEQQ=");
//! assert_eq!(Format::Base64.format_str(0x41414242, &options), "QUFCQg==");
//!
//! assert_eq!(Format::Raw.format(0x1337, &options), vec![0x13, 0x37]);
//! assert_eq!(Format::Hex.format(0x1337, &options), vec![49, 51, 51, 55]);
//! ```
#![allow(dead_code)]
use std::fmt::Display;
// this is exported to lib.rs
use anyhow::anyhow; use anyhow::anyhow;
use clap::{ArgGroup, Parser}; use clap::{ArgGroup, Parser};
use libpt::bintols::{join, split}; use libpt::bintols::{join, split};
use libpt::cli::args::VerbosityLevel;
use libpt::log::{debug, trace};
/// The number type [numf](crate) uses
pub type NumberType = u128; pub type NumberType = u128;
/// Describes a format for numbers /// formats supported by numf
/// #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
/// [Format] can be used to convert unsigned integers into a textual or other representation. See
/// [Format::format_str] for more. It is also possible to parse the various represenations to
/// a rust integer, see [numf_parser_str] for that.
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, Default)]
pub enum Format { pub enum Format {
Dec, Dec,
#[default]
Hex, Hex,
Bin, Bin,
Octal, Octal,
Base64, Base64,
Base32, Base32,
/// Write raw data, not text
Raw,
} }
impl Display for Format { /// Describes what the formatter should do
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{self:?}")
}
}
/// Describes what the formatter should do exactly
/// ///
/// Use [Self::default] to get a basic variant or create a object yourself. /// Use [Self::default] to get a basic variant or create a object yourself.
/// ///
/// This struct can be parsed with [clap] derive. /// This struct can be parsed with [clap] derive.
///
/// # Example
///
/// ```
/// use numf::format::{Format, FormatOptions};
/// let mut options = FormatOptions::default();
///
/// assert_eq!(Format::Bin.format_str(256, &options), "100000000");
/// assert_eq!(Format::Hex.format_str(256, &options), "100");
/// assert_eq!(Format::Base64.format_str(256, &options), "AQA=");
///
/// options.set_prefix(true);
/// options.set_padding(true);
///
/// assert_eq!(Format::Bin.format_str(256, &options), "0b0000000100000000");
/// assert_eq!(Format::Hex.format_str(256, &options), "0x0100");
/// assert_eq!(Format::Base64.format_str(256, &options), "0sAQA=");
///
/// ```
#[derive(Parser, Debug, Clone, PartialEq, Eq, Hash)] #[derive(Parser, Debug, Clone, PartialEq, Eq, Hash)]
#[clap(author, version, about, long_about = None)] #[clap(author, version, about, long_about = None)]
#[command( #[command(
@ -109,7 +38,7 @@ Author: {author-with-newline}
)] )]
#[clap(group( #[clap(group(
ArgGroup::new("format") ArgGroup::new("format")
.args(&["hex", "bin", "oct", "dec", "base64", "base32", "raw"]), .args(&["hex", "bin", "oct", "dec", "base64", "base32"]),
))] ))]
pub struct FormatOptions { pub struct FormatOptions {
#[arg(short, long)] #[arg(short, long)]
@ -121,7 +50,7 @@ pub struct FormatOptions {
/// For example, `0b1100` will be `0b00001100` with this. /// For example, `0b1100` will be `0b00001100` with this.
/// This does not apply to all formats, only hexadecimal and binary. /// This does not apply to all formats, only hexadecimal and binary.
padding: bool, padding: bool,
#[arg(short = 'x', long)] #[arg(short = 'x', long, default_value_t = true)]
/// format to hexadecimal /// format to hexadecimal
hex: bool, hex: bool,
#[arg(short, long)] #[arg(short, long)]
@ -136,51 +65,30 @@ pub struct FormatOptions {
#[arg(short = 's', long)] #[arg(short = 's', long)]
/// format to base64 /// format to base64
base64: bool, base64: bool,
#[arg(short = 'a', long)]
/// format raw, no text
raw: bool,
#[arg(short = 'r', long, default_value_t = 0, value_parser=numf_parser_str::<NumberType>)]
/// output random numbers
///
/// Add a user defined amount of cryptographically pseudorandom numbers to the number list.
rand: NumberType,
#[arg(long, default_value_t = NumberType::MAX, value_parser=numf_parser_str::<NumberType>)]
/// max for the random numbers
///
/// Generated numbers will not be lower than this. Only has an effect with --rand set.
rand_max: NumberType,
#[arg(short = 'z', long)] #[arg(short = 'z', long)]
/// format to base32 /// format to base32
base32: bool, base32: bool,
#[clap(value_parser=numf_parser_str::<NumberType>, required=false)] #[clap(value_parser=numf_parser::<NumberType>, required=false)]
/// numbers that should be formatted /// at least one number that should be formatted
/// ///
/// Any of the [Formats](Format::format) are supported, but the prefixes are needed for formats /// Any of the [Formats](Format::format) are supported, but the prefixes are needed for formats
/// other than decimal. /// other than decimal.
/// ///
/// Formats: /// Formats:
/// ///
/// * '0x' - Hexadecimal /// - '0x' - Hexadecimal
/// - '0b' - Binary
/// - '0o' - Octal
/// - '0s' - Base64
/// - '032s' - Base32
/// ///
/// * '0b' - Binary /// The numbers may be left empty at first, if numbers are provided with the stdin.
///
/// * '0o' - Octal
///
/// * '0s' - Base64
///
/// * '032s' - Base32
///
/// The numbers may be left empty at first, if numbers are provided from the stdin.
numbers: Vec<NumberType>, numbers: Vec<NumberType>,
#[command(flatten)]
pub(crate) verbosity: VerbosityLevel,
} }
impl FormatOptions { impl FormatOptions {
/// get the format that the user has configured /// get the format that the user has configured
pub fn format(&self) -> Format { pub fn format(&self) -> Format {
trace!("self.hex: {}", self.hex);
if self.oct { if self.oct {
Format::Octal Format::Octal
} else if self.bin { } else if self.bin {
@ -193,12 +101,8 @@ impl FormatOptions {
Format::Base32 Format::Base32
} else if self.hex { } else if self.hex {
Format::Hex Format::Hex
} else if self.raw {
Format::Raw
} else { } else {
// none was explicitly selected unreachable!()
debug!("no mode was explicitly selected, going with the default");
Format::default()
} }
} }
@ -209,11 +113,9 @@ impl FormatOptions {
self.dec = false; self.dec = false;
self.hex = false; self.hex = false;
self.base64 = false; self.base64 = false;
self.raw = false;
self.base32 = false; self.base32 = false;
match format { match format {
Format::Bin => self.bin = true, Format::Bin => self.bin = true,
Format::Raw => self.raw = true,
Format::Hex => self.hex = true, Format::Hex => self.hex = true,
Format::Octal => self.oct = true, Format::Octal => self.oct = true,
Format::Base64 => self.base64 = true, Format::Base64 => self.base64 = true,
@ -256,26 +158,6 @@ impl FormatOptions {
pub fn push_number(&mut self, value: NumberType) { pub fn push_number(&mut self, value: NumberType) {
self.numbers.push(value) self.numbers.push(value)
} }
/// get rand
pub fn rand(&self) -> NumberType {
self.rand
}
/// set amount of extra random numbers manually
pub fn set_rand(&mut self, rand: NumberType) {
self.rand = rand;
}
/// get highes allowed random value
pub fn rand_max(&self) -> NumberType {
self.rand_max
}
/// set highes allowed random value
pub fn set_rand_max(&mut self, rand_max: NumberType) {
self.rand_max = rand_max;
}
} }
impl Default for FormatOptions { impl Default for FormatOptions {
@ -284,184 +166,74 @@ impl Default for FormatOptions {
padding: false, padding: false,
prefix: false, prefix: false,
oct: false, oct: false,
hex: false, hex: true,
bin: false, bin: false,
raw: false,
base32: false, base32: false,
base64: false, base64: false,
dec: false, dec: false,
numbers: vec![], numbers: vec![],
rand: 0,
rand_max: NumberType::MAX,
verbosity: VerbosityLevel::default(),
} }
} }
} }
impl Format { impl Format {
/// Get the perfix for that [Format] as [Vec<u8>]. /// Get the perfix for that [Format]
/// pub fn prefix(&self) -> String {
/// # Example
///
/// ```
/// # use numf::format::Format;
/// assert_eq!(Format::Bin.prefix_str(), "0b");
/// assert_eq!(Format::Dec.prefix_str(), "0d");
/// assert_eq!(Format::Hex.prefix_str(), "0x");
/// assert_eq!(Format::Octal.prefix_str(), "0o");
/// assert_eq!(Format::Base64.prefix_str(), "0s");
/// assert_eq!(Format::Base32.prefix_str(), "032s");
/// assert_eq!(Format::Raw.prefix_str(), "\x00");
/// ```
pub fn prefix_str(&self) -> String {
String::from_utf8_lossy(&self.prefix()).to_string()
}
/// Get the perfix for that [Format] as [Vec<u8>].
///
/// # Example
///
/// ```
/// # use numf::format::Format;
/// assert_eq!(Format::Bin.prefix(), b"0b");
/// assert_eq!(Format::Dec.prefix(), b"0d");
/// assert_eq!(Format::Hex.prefix(), b"0x");
/// assert_eq!(Format::Octal.prefix(), b"0o");
/// assert_eq!(Format::Base64.prefix(), b"0s");
/// assert_eq!(Format::Base32.prefix(), b"032s");
/// assert_eq!(Format::Raw.prefix(), vec![0x00]);
/// ```
pub fn prefix(&self) -> Vec<u8> {
match self { match self {
// apperently used nowhere, sometimes 0 is used as a prefix but I // apperently used nowhere, sometimes 0 is used as a prefix but I
// think this makes it more clear that this is decimal // think this makes it more clear that this is decimal
Format::Dec => b"0d".to_vec(), Format::Dec => "0d",
Format::Raw => [0x00].to_vec(),
// very common // very common
Format::Hex => b"0x".to_vec(), Format::Hex => "0x",
// very common // very common
Format::Bin => b"0b".to_vec(), Format::Bin => "0b",
// somewhat common // somewhat common
Format::Octal => b"0o".to_vec(), Format::Octal => "0o",
// perl and a few other programs seem to use this too // perl and a few other programs seem to use this too
Format::Base64 => b"0s".to_vec(), Format::Base64 => "0s",
// no idea, I made this up // no idea, I made this up
Format::Base32 => b"032s".to_vec(), Format::Base32 => "032s",
} }
.to_string()
} }
/// format a number with a [Format] and [FormatOptions] to a [String] /// format a number with a [Format] and [FormatOptions]
/// pub fn format(&self, num: NumberType, options: &FormatOptions) -> String {
/// If you need raw byte outputs, use [Format::format] instead. let mut buf = String::new();
///
/// # Example
///
/// ```
/// use numf::format::{Format, FormatOptions};
/// let mut options = FormatOptions::default();
///
/// assert_eq!(Format::Bin.format_str(256, &options), "100000000");
/// assert_eq!(Format::Hex.format_str(256, &options), "100");
/// assert_eq!(Format::Base64.format_str(256, &options), "AQA=");
///
/// options.set_prefix(true);
/// options.set_padding(true);
///
/// assert_eq!(Format::Bin.format_str(256, &options), "0b0000000100000000");
/// assert_eq!(Format::Hex.format_str(256, &options), "0x0100");
/// assert_eq!(Format::Base64.format_str(256, &options), "0sAQA=");
///
/// ```
pub fn format_str(&self, num: NumberType, options: &FormatOptions) -> String {
String::from_utf8_lossy(&self.format(num, options)).to_string()
}
/// format a number with a [Format] and [FormatOptions] to a byte vector [Vec<u8>]
///
/// If you need [String] outputs, use [Format::format_str] instead.
///
/// # Example
///
/// ```
/// use numf::format::{Format, FormatOptions};
/// let mut options = FormatOptions::default();
///
/// assert_eq!(Format::Bin.format(256, &options), b"100000000");
/// assert_eq!(Format::Hex.format(256, &options), b"100");
/// assert_eq!(Format::Hex.format(256, &options), [49, 48, 48]);
/// assert_eq!(Format::Base64.format(256, &options), b"AQA=");
/// assert_eq!(Format::Raw.format(256, &options), [1, 0]);
///
/// options.set_prefix(true);
/// options.set_padding(true);
///
/// assert_eq!(Format::Bin.format(256, &options), b"0b0000000100000000");
/// assert_eq!(Format::Hex.format(256, &options), b"0x0100");
/// assert_eq!(Format::Hex.format(256, &options), [48, 120, 48, 49, 48, 48]);
/// assert_eq!(Format::Base64.format(256, &options), b"0sAQA=");
/// assert_eq!(Format::Raw.format(256, &options), [0, 1, 0]);
/// assert_eq!(Format::Raw.format(255, &options), [0, 255]);
/// assert_eq!(Format::Raw.format(32000, &options), [0, 125, 0]);
///
/// ```
pub fn format(&self, num: NumberType, options: &FormatOptions) -> Vec<u8> {
debug!("formatting mode: {self}");
let mut buf: Vec<u8> = Vec::new();
if options.prefix() { if options.prefix() {
buf.append(&mut self.prefix()); buf += &self.prefix();
debug!("prefix the buffer: {buf:X?}");
} }
match self { match self {
Format::Hex => { Format::Hex => {
if options.padding() { if options.padding() {
let tmp = &format!("{num:X}"); let tmp = &format!("{num:X}");
let tmp1 = &("0".repeat((2 - tmp.len() % 2) % 2) + tmp); buf += &("0".repeat((2 - tmp.len() % 2) % 2) + tmp);
buf.append(&mut tmp1.as_bytes().to_owned());
} else { } else {
buf.append(&mut format!("{num:X}").as_bytes().to_owned()); buf += &format!("{num:X}");
} }
} }
Format::Bin => { Format::Bin => {
if options.padding() { if options.padding() {
let tmp = &format!("{num:b}"); let tmp = &format!("{num:b}");
let tmp1 = &("0".repeat((8 - tmp.len() % 8) % 8) + tmp); buf += &("0".repeat((8 - tmp.len() % 8) % 8) + tmp);
buf.append(&mut tmp1.as_bytes().to_owned());
} else { } else {
buf.append(&mut format!("{num:b}").as_bytes().to_owned()); buf += &format!("{num:b}");
} }
} }
Format::Octal => buf.append(&mut format!("{num:o}").as_bytes().to_owned()), Format::Octal => buf += &format!("{num:o}"),
Format::Dec => buf.append(&mut format!("{num}").as_bytes().to_owned()), Format::Dec => buf += &format!("{num}"),
Format::Base64 => buf.append( Format::Base64 => buf += &fast32::base64::RFC4648.encode(&split::unsigned_to_vec(num)),
&mut fast32::base64::RFC4648 Format::Base32 => buf += &fast32::base32::RFC4648.encode(&split::unsigned_to_vec(num)),
.encode(&split::unsigned_to_vec(num))
.as_bytes()
.to_owned(),
),
Format::Base32 => buf.append(
&mut fast32::base32::RFC4648
.encode(&split::unsigned_to_vec(num))
.as_bytes()
.to_owned(),
),
// Format::Raw => buf.append(&mut split::unsigned_to_vec(num)),
Format::Raw => buf.append(&mut split::unsigned_to_vec(num)),
} }
buf buf
} }
} }
/// Converts a &[str] into an unsigned integer value (like [u128]), according to one of the [Formats](Format) /// Validates an unsigned integer value that can be one of [Format](format::Format).
/// ///
/// The number is assumed to be base-10 by default, it is parsed as a different /// The number is assumed to be base-10 by default, it is parsed as a different
/// [Format] if the number is prefixed with the [prefix](FormatOptions::prefix), /// [Format](format::Format) if the number is prefixed with the [prefix](format::FormatOptions::prefix),
/// for that [Format]. So if the user inputs `0b1100` then this is parsed as /// case sensitive. So if the user inputs `0b1100` then this is parsed as
/// [Binary](Format::Bin) and so on. /// [Binary](format::Format::Bin) and so on.
///
/// If you also want to parse raw inputs, use [numf_parser].
///
/// # Returns
///
/// This parser will only output unsigned integers, it cannot be used with signed integers.
/// ///
/// # Example /// # Example
/// ///
@ -471,17 +243,17 @@ impl Format {
/// ///
/// ``` /// ```
/// use clap::Parser; /// use clap::Parser;
/// use numf::format::numf_parser_str; /// use numf::format::numf_parser;
/// ///
/// #[derive(Parser)] /// #[derive(Parser)]
/// struct Args { /// struct Args {
/// #[clap(short, long, value_parser=numf_parser_str::<u128>)] /// #[clap(short, long, value_parser=numf_parser::<u128>)]
/// address: u128, /// address: u128,
/// } /// }
/// let args = Args::parse_from(&["", "-a", "0x10"]); /// let args = Args::parse_from(&["", "-a", "0x10"]);
/// assert_eq!(args.address, 16); /// assert_eq!(args.address, 16);
/// ``` /// ```
pub fn numf_parser_str<T>(s: &str) -> anyhow::Result<T> pub fn numf_parser<T>(s: &str) -> anyhow::Result<T>
where where
T: std::str::FromStr + std::convert::TryFrom<u128>, T: std::str::FromStr + std::convert::TryFrom<u128>,
<T as std::str::FromStr>::Err: std::fmt::Display, <T as std::str::FromStr>::Err: std::fmt::Display,
@ -495,68 +267,10 @@ where
<T as std::convert::TryFrom<u128>>::Error: std::marker::Sync, <T as std::convert::TryFrom<u128>>::Error: std::marker::Sync,
<T as std::convert::TryFrom<u128>>::Error: 'static, <T as std::convert::TryFrom<u128>>::Error: 'static,
{ {
numf_parser(s.as_bytes()) if s.starts_with(&Format::Dec.prefix()) || s.parse::<T>().is_ok() {
} let s = match s.strip_prefix(&Format::Dec.prefix()) {
/// Converts any data (as bytes) into an unsigned integer value `T` (like [u128]), according to one of the [Formats](Format)
///
/// If you only want to parse text data, use [numf_parser_str] instead.
///
/// The parser will first try to convert the data to a [String].
///
/// Then, the number is assumed to be base-10 by default, it is parsed as a different
/// [Format] if the number is prefixed with the [prefix](FormatOptions::prefix),
/// for that [Format]. So if the user inputs `0b1100` then this is parsed as
/// [Binary](Format::Bin) and so on.
///
/// If none of the text [Formats](Format) matches, the data will be assumed to be raw and converted
/// to the ingeger type directly.
///
/// # Errors
///
/// If no text [Format] matches and the data is too long for the integer `T`.
///
/// # Returns
///
/// This parser will only output unsigned integers, it cannot be used with signed integers.
///
/// # Example
///
/// ```
/// use numf::format::numf_parser;
///
/// let data = &[0x15, 0x92, 0xff];
/// let result: u64 = 0x1592ff;
/// assert_eq!(result, numf_parser(data).unwrap());
///
/// let data = b"0x1337";
/// let result: u64 = 0x1337;
/// assert_eq!(result, numf_parser(data).unwrap());
///
/// let data = b"0b110011";
/// let result: u64 = 0b110011;
/// assert_eq!(result, numf_parser(data).unwrap());
/// ```
pub fn numf_parser<T>(data: &[u8]) -> anyhow::Result<T>
where
T: std::str::FromStr + std::convert::TryFrom<u128>,
<T as std::str::FromStr>::Err: std::fmt::Display,
T: num::Num,
<T as num::Num>::FromStrRadixErr: std::fmt::Display,
<T as std::str::FromStr>::Err: std::fmt::Debug,
u128: std::convert::From<T>,
<T as std::str::FromStr>::Err: std::error::Error,
<T as std::convert::TryFrom<u128>>::Error: std::error::Error,
<T as std::convert::TryFrom<u128>>::Error: std::marker::Send,
<T as std::convert::TryFrom<u128>>::Error: std::marker::Sync,
<T as std::convert::TryFrom<u128>>::Error: 'static,
{
let data_as_text = String::from_utf8_lossy(data).to_string();
if data_as_text.starts_with(&Format::Dec.prefix_str()) || data_as_text.parse::<T>().is_ok() {
let s = match data_as_text.strip_prefix(&Format::Dec.prefix_str()) {
Some(sr) => sr, Some(sr) => sr,
None => &data_as_text, None => s,
}; };
match s.parse() { match s.parse() {
Ok(r) => Ok(r), Ok(r) => Ok(r),
@ -565,10 +279,10 @@ where
Err(anyhow!(e)) Err(anyhow!(e))
} }
} }
} else if data_as_text.starts_with(&Format::Hex.prefix_str()) { } else if s.starts_with(&Format::Hex.prefix()) {
let s = match data_as_text.strip_prefix(&Format::Hex.prefix_str()) { let s = match s.strip_prefix(&Format::Hex.prefix()) {
Some(sr) => sr, Some(sr) => sr,
None => &data_as_text, None => s,
}; };
match T::from_str_radix(s, 16) { match T::from_str_radix(s, 16) {
Ok(r) => Ok(r), Ok(r) => Ok(r),
@ -577,10 +291,10 @@ where
Err(anyhow!(e)) Err(anyhow!(e))
} }
} }
} else if data_as_text.starts_with(&Format::Octal.prefix_str()) { } else if s.starts_with(&Format::Octal.prefix()) {
let s = match data_as_text.strip_prefix(&Format::Octal.prefix_str()) { let s = match s.strip_prefix(&Format::Octal.prefix()) {
Some(sr) => sr, Some(sr) => sr,
None => &data_as_text, None => s,
}; };
match T::from_str_radix(s, 8) { match T::from_str_radix(s, 8) {
Ok(r) => Ok(r), Ok(r) => Ok(r),
@ -589,10 +303,10 @@ where
Err(anyhow!(e)) Err(anyhow!(e))
} }
} }
} else if data_as_text.starts_with(&Format::Bin.prefix_str()) { } else if s.starts_with(&Format::Bin.prefix()) {
let s = match data_as_text.strip_prefix(&Format::Bin.prefix_str()) { let s = match s.strip_prefix(&Format::Bin.prefix()) {
Some(sr) => sr, Some(sr) => sr,
None => &data_as_text, None => s,
}; };
match T::from_str_radix(s, 2) { match T::from_str_radix(s, 2) {
Ok(r) => Ok(r), Ok(r) => Ok(r),
@ -601,10 +315,10 @@ where
Err(anyhow!(e)) Err(anyhow!(e))
} }
} }
} else if data_as_text.starts_with(&Format::Base64.prefix_str()) { } else if s.starts_with(&Format::Base64.prefix()) {
let s = match data_as_text.strip_prefix(&Format::Base64.prefix_str()) { let s = match s.strip_prefix(&Format::Base64.prefix()) {
Some(sr) => sr, Some(sr) => sr,
None => &data_as_text, None => s,
}; };
match fast32::base64::RFC4648.decode_str(s) { match fast32::base64::RFC4648.decode_str(s) {
Ok(r) => Ok(join::array_to_unsigned::<T>(&r)?), Ok(r) => Ok(join::array_to_unsigned::<T>(&r)?),
@ -613,10 +327,10 @@ where
Err(anyhow!(e)) Err(anyhow!(e))
} }
} }
} else if data_as_text.starts_with(&Format::Base32.prefix_str()) { } else if s.starts_with(&Format::Base32.prefix()) {
let s = match data_as_text.strip_prefix(&Format::Base32.prefix_str()) { let s = match s.strip_prefix(&Format::Base32.prefix()) {
Some(sr) => sr, Some(sr) => sr,
None => &data_as_text, None => s,
}; };
match fast32::base32::RFC4648.decode_str(s) { match fast32::base32::RFC4648.decode_str(s) {
Ok(r) => Ok(join::array_to_unsigned::<T>(&r)?), Ok(r) => Ok(join::array_to_unsigned::<T>(&r)?),
@ -626,12 +340,7 @@ where
} }
} }
} else { } else {
// what could go wrong with interpreting everything else as raw number input let e = "could not determine the format of the value".to_string();
let s: Vec<u8> = if data.len() > 2 && data[0] == 0x00 { Err(anyhow!(e))
data.iter().skip(1).map(ToOwned::to_owned).collect()
} else {
data.as_ref().to_vec()
};
Ok(join::array_to_unsigned(&s)?)
} }
} }

9
src/lib.rs
View File

@ -1,17 +1,10 @@
//! Format numbers //! Format numbers
//! //!
//! This crate contains several utility functions for formatting numbers //! This crate contains several utility functions for formatting numbers
//! into other systems, such as converting decimal numbers to hexadecimal //! into other systems, such as converting decimal numbers to hexadecimal.
//! , and back.
//! //!
//! See [format::Format] for supported formats. //! See [format::Format] for supported formats.
//! //!
//! Note that this crate is primarily intended to be used as a executable. //! Note that this crate is primarily intended to be used as a executable.
//!
//! Highlights:
//! * [format::numf_parser]
//! * [format::numf_parser_str]
//! * [format::Format::format]
//! * [format::Format::format_str]
pub mod format; pub mod format;

70
src/main.rs
View File

@ -1,54 +1,38 @@
use std::io::{IsTerminal, Read, Write}; //! # numf
//!
//! This binary should just take any amount of numbers and print them out formatted to some other
//! system.
use std::io::{IsTerminal, Read};
use std::process::exit; use std::process::exit;
use clap::{CommandFactory, Parser}; use clap::{CommandFactory, Parser};
use numf::format::numf_parser_str;
mod format; mod format;
use crate::format::{numf_parser, Format};
use format::*; use format::*;
use libpt::log::{debug, error}; use numf::format::numf_parser;
fn main() -> anyhow::Result<()> { fn main() {
// try to read from stdin first, appending the numbers we read to the FormatOptions // try to read from stdin first, appending the numbers we read to the FormatOptions
let mut options = FormatOptions::parse(); let mut options = FormatOptions::parse();
let _logger = libpt::log::Logger::builder()
.set_level(options.verbosity.level())
.display_time(false)
.build()
.map_err(|e| {
error!("could not initialize logger: {e}");
});
debug!("logger active");
let mut stdin_nums = Vec::new(); let mut stdin_nums = Vec::new();
let stdin = std::io::stdin(); let stdin = std::io::stdin();
// only accept numbers from stdin if the stdin is not an interactive terminal
if !stdin.is_terminal() { if !stdin.is_terminal() {
match stdin.lock().read_to_end(&mut stdin_nums) { match stdin.lock().read_to_end(&mut stdin_nums) {
Ok(_) => { Ok(_) => {
let whole: String = match String::from_utf8(stdin_nums.clone()) { let whole: String = match String::from_utf8(stdin_nums) {
Ok(r) => r, Ok(r) => r,
Err(_) => { Err(e) => {
let number = match numf_parser(&stdin_nums) { eprintln!("stdin for this program only accepts text: {e:#?}");
Ok(n) => n, exit(1);
Err(e) => {
eprintln!("{}", FormatOptions::command().render_usage());
error!("could raw inputs from stdin as numbers: {e:#?}");
exit(2);
}
};
options.push_number(number);
String::new()
} }
}; };
let split = whole.split_whitespace(); let split = whole.split_whitespace();
for s in split { for s in split {
let number = match numf_parser_str(s) { let number = match numf_parser(s) {
Ok(n) => n, Ok(n) => n,
Err(e) => { Err(e) => {
eprintln!("{}", FormatOptions::command().render_usage()); eprintln!("could not parse number from stdin: {e:#?}");
error!("could not parse number from stdin: {e:#?}");
exit(2); exit(2);
} }
}; };
@ -56,41 +40,23 @@ fn main() -> anyhow::Result<()> {
} }
} }
Err(e) => { Err(e) => {
eprintln!("{}", FormatOptions::command().render_usage()); eprintln!("could not read from stdin: {e:#?}");
error!("could not read from stdin: {e:#?}");
exit(2); exit(2);
} }
}; };
} }
// add random numbers to the number list, according to how many are requested
if options.rand() > 0 {
use rand::prelude::*;
let mut rand = rand::rngs::OsRng;
for _i in 0..options.rand() {
options.push_number(rand.gen_range(0..options.rand_max()));
}
}
// exit with error if no numbers are to be formatted
if options.numbers().is_empty() { if options.numbers().is_empty() {
eprintln!("{}", FormatOptions::command().render_usage()); format!("{}", FormatOptions::command().render_usage());
error!("no numbers have been provided");
exit(1); exit(1);
} }
let mut out: Vec<Vec<u8>> = Vec::new(); let mut out: Vec<String> = Vec::new();
for num in options.numbers() { for num in options.numbers() {
out.push(options.format().format(*num, &options)); out.push(options.format().format(*num, &options));
} }
for o in out { for o in out {
let mut stdout = std::io::stdout(); println!("{o}")
stdout.write_all(&o)?;
if options.format() != Format::Raw {
stdout.write_all(b"\n")?;
}
stdout.flush()?;
} }
Ok(())
} }

161
tests/format.rs
View File

@ -3,47 +3,44 @@ use numf::format::*;
#[test] #[test]
fn format() { fn format() {
let options = FormatOptions::default(); let options = FormatOptions::default();
assert_eq!(Format::Dec.format_str(1337, &options), "1337"); assert_eq!(Format::Dec.format(1337, &options), "1337");
assert_eq!( assert_eq!(
Format::Dec.format_str(u128::MAX, &options), Format::Dec.format(u128::MAX, &options),
format!("{}", u128::MAX) format!("{}", u128::MAX)
); );
assert_eq!(Format::Hex.format_str(0x1337, &options), "1337"); assert_eq!(Format::Hex.format(0x1337, &options), "1337");
assert_eq!( assert_eq!(
Format::Hex.format_str(u128::MAX, &options), Format::Hex.format(u128::MAX, &options),
format!("{:X}", u128::MAX) format!("{:X}", u128::MAX)
); );
assert_eq!( assert_eq!(
Format::Bin.format_str(0b1010001001010010010100111, &options), Format::Bin.format(0b1010001001010010010100111, &options),
"1010001001010010010100111" "1010001001010010010100111"
); );
assert_eq!( assert_eq!(
Format::Bin.format_str(u128::MAX, &options), Format::Bin.format(u128::MAX, &options),
format!("{:b}", u128::MAX) format!("{:b}", u128::MAX)
); );
assert_eq!(Format::Octal.format_str(0o13377331, &options), "13377331"); assert_eq!(Format::Octal.format(0o13377331, &options), "13377331");
assert_eq!( assert_eq!(
Format::Octal.format_str(u128::MAX, &options), Format::Octal.format(u128::MAX, &options),
format!("{:o}", u128::MAX) format!("{:o}", u128::MAX)
); );
assert_eq!(Format::Base32.format_str(0x41414242, &options), "IFAUEQQ="); assert_eq!(Format::Base32.format(0x41414242, &options), "IFAUEQQ=");
assert_eq!( assert_eq!(
Format::Base32.format_str(0x4141414141414141, &options), Format::Base32.format(0x4141414141414141, &options),
"IFAUCQKBIFAUC===" "IFAUCQKBIFAUC==="
); );
assert_eq!(Format::Base64.format_str(0x41414242, &options), "QUFCQg=="); assert_eq!(Format::Base64.format(0x41414242, &options), "QUFCQg==");
assert_eq!( assert_eq!(
Format::Base64.format_str(0x4141414141414141, &options), Format::Base64.format(0x4141414141414141, &options),
"QUFBQUFBQUE=" "QUFBQUFBQUE="
); );
assert_eq!(Format::Raw.format(0x1337, &options), vec![0x13, 0x37]);
assert_eq!(Format::Raw.format(0x0, &options), vec![0x0]);
} }
#[test] #[test]
@ -51,52 +48,49 @@ fn format_padding() {
let mut options = FormatOptions::default(); let mut options = FormatOptions::default();
options.set_padding(true); options.set_padding(true);
assert_eq!(Format::Dec.format_str(1337, &options), "1337"); assert_eq!(Format::Dec.format(1337, &options), "1337");
assert_eq!( assert_eq!(
Format::Dec.format_str(u128::MAX, &options), Format::Dec.format(u128::MAX, &options),
format!("{}", u128::MAX) format!("{}", u128::MAX)
); );
assert_eq!(Format::Hex.format_str(0xFFF, &options), "0FFF"); assert_eq!(Format::Hex.format(0xFFF, &options), "0FFF");
assert_eq!(Format::Hex.format_str(0xFFFF, &options), "FFFF"); assert_eq!(Format::Hex.format(0xFFFF, &options), "FFFF");
assert_eq!( assert_eq!(
Format::Hex.format_str(u128::MAX, &options), Format::Hex.format(u128::MAX, &options),
format!("{:X}", u128::MAX) format!("{:X}", u128::MAX)
); );
assert_eq!( assert_eq!(
Format::Bin.format_str(0b11110000_00001111, &options), Format::Bin.format(0b11110000_00001111, &options),
"1111000000001111" "1111000000001111"
); );
assert_eq!( assert_eq!(
Format::Bin.format_str(0b110000_00001111, &options), Format::Bin.format(0b110000_00001111, &options),
"0011000000001111" "0011000000001111"
); );
assert_eq!( assert_eq!(
Format::Bin.format_str(u128::MAX, &options), Format::Bin.format(u128::MAX, &options),
format!("{:b}", u128::MAX) format!("{:b}", u128::MAX)
); );
assert_eq!(Format::Octal.format_str(0o13377331, &options), "13377331"); assert_eq!(Format::Octal.format(0o13377331, &options), "13377331");
assert_eq!( assert_eq!(
Format::Octal.format_str(u128::MAX, &options), Format::Octal.format(u128::MAX, &options),
format!("{:o}", u128::MAX) format!("{:o}", u128::MAX)
); );
assert_eq!(Format::Base32.format_str(0x41414242, &options), "IFAUEQQ="); assert_eq!(Format::Base32.format(0x41414242, &options), "IFAUEQQ=");
assert_eq!( assert_eq!(
Format::Base32.format_str(0x4141414141414141, &options), Format::Base32.format(0x4141414141414141, &options),
"IFAUCQKBIFAUC===" "IFAUCQKBIFAUC==="
); );
assert_eq!(Format::Base64.format_str(0x41414242, &options), "QUFCQg=="); assert_eq!(Format::Base64.format(0x41414242, &options), "QUFCQg==");
assert_eq!( assert_eq!(
Format::Base64.format_str(0x4141414141414141, &options), Format::Base64.format(0x4141414141414141, &options),
"QUFBQUFBQUE=" "QUFBQUFBQUE="
); );
assert_eq!(Format::Raw.format(0x1337, &options), vec![0x13, 0x37]);
assert_eq!(Format::Raw.format(0x0, &options), vec![0x0]);
} }
#[test] #[test]
@ -104,53 +98,44 @@ fn format_prefix() {
let mut options = FormatOptions::default(); let mut options = FormatOptions::default();
options.set_prefix(true); options.set_prefix(true);
assert_eq!(Format::Dec.format_str(1337, &options), "0d1337"); assert_eq!(Format::Dec.format(1337, &options), "0d1337");
assert_eq!( assert_eq!(
Format::Dec.format_str(u128::MAX, &options), Format::Dec.format(u128::MAX, &options),
format!("0d{}", u128::MAX) format!("0d{}", u128::MAX)
); );
assert_eq!(Format::Hex.format_str(0x1337, &options), "0x1337"); assert_eq!(Format::Hex.format(0x1337, &options), "0x1337");
assert_eq!( assert_eq!(
Format::Hex.format_str(u128::MAX, &options), Format::Hex.format(u128::MAX, &options),
format!("0x{:X}", u128::MAX) format!("0x{:X}", u128::MAX)
); );
assert_eq!( assert_eq!(
Format::Bin.format_str(0b1010001001010010010100111, &options), Format::Bin.format(0b1010001001010010010100111, &options),
"0b1010001001010010010100111" "0b1010001001010010010100111"
); );
assert_eq!( assert_eq!(
Format::Bin.format_str(u128::MAX, &options), Format::Bin.format(u128::MAX, &options),
format!("0b{:b}", u128::MAX) format!("0b{:b}", u128::MAX)
); );
assert_eq!(Format::Octal.format_str(0o13377331, &options), "0o13377331"); assert_eq!(Format::Octal.format(0o13377331, &options), "0o13377331");
assert_eq!( assert_eq!(
Format::Octal.format_str(u128::MAX, &options), Format::Octal.format(u128::MAX, &options),
format!("0o{:o}", u128::MAX) format!("0o{:o}", u128::MAX)
); );
assert_eq!(Format::Base32.format(0x41414242, &options), "032sIFAUEQQ=");
assert_eq!( assert_eq!(
Format::Base32.format_str(0x41414242, &options), Format::Base32.format(0x4141414141414141, &options),
"032sIFAUEQQ="
);
assert_eq!(
Format::Base32.format_str(0x4141414141414141, &options),
"032sIFAUCQKBIFAUC===" "032sIFAUCQKBIFAUC==="
); );
assert_eq!(Format::Base64.format(0x41414242, &options), "0sQUFCQg==");
assert_eq!( assert_eq!(
Format::Base64.format_str(0x41414242, &options), Format::Base64.format(0x4141414141414141, &options),
"0sQUFCQg=="
);
assert_eq!(
Format::Base64.format_str(0x4141414141414141, &options),
"0sQUFBQUFBQUE=" "0sQUFBQUFBQUE="
); );
assert_eq!(Format::Raw.format(0x1337, &options), vec![0x0, 0x13, 0x37]);
assert_eq!(Format::Raw.format(0x0, &options), vec![0x0, 0x0]);
} }
#[test] #[test]
@ -159,58 +144,49 @@ fn format_padded_prefix() {
options.set_prefix(true); options.set_prefix(true);
options.set_padding(true); options.set_padding(true);
assert_eq!(Format::Dec.format_str(1337, &options), "0d1337"); assert_eq!(Format::Dec.format(1337, &options), "0d1337");
assert_eq!( assert_eq!(
Format::Dec.format_str(u128::MAX, &options), Format::Dec.format(u128::MAX, &options),
format!("0d{}", u128::MAX) format!("0d{}", u128::MAX)
); );
assert_eq!(Format::Hex.format_str(0xFFF, &options), "0x0FFF"); assert_eq!(Format::Hex.format(0xFFF, &options), "0x0FFF");
assert_eq!(Format::Hex.format_str(0xFFFF, &options), "0xFFFF"); assert_eq!(Format::Hex.format(0xFFFF, &options), "0xFFFF");
assert_eq!( assert_eq!(
Format::Hex.format_str(u128::MAX, &options), Format::Hex.format(u128::MAX, &options),
format!("0x{:X}", u128::MAX) format!("0x{:X}", u128::MAX)
); );
assert_eq!( assert_eq!(
Format::Bin.format_str(0b11110000_00001111, &options), Format::Bin.format(0b11110000_00001111, &options),
"0b1111000000001111" "0b1111000000001111"
); );
assert_eq!( assert_eq!(
Format::Bin.format_str(0b110000_00001111, &options), Format::Bin.format(0b110000_00001111, &options),
"0b0011000000001111" "0b0011000000001111"
); );
assert_eq!( assert_eq!(
Format::Bin.format_str(u128::MAX, &options), Format::Bin.format(u128::MAX, &options),
format!("0b{:b}", u128::MAX) format!("0b{:b}", u128::MAX)
); );
assert_eq!(Format::Octal.format_str(0o13377331, &options), "0o13377331"); assert_eq!(Format::Octal.format(0o13377331, &options), "0o13377331");
assert_eq!( assert_eq!(
Format::Octal.format_str(u128::MAX, &options), Format::Octal.format(u128::MAX, &options),
format!("0o{:o}", u128::MAX) format!("0o{:o}", u128::MAX)
); );
assert_eq!(Format::Base32.format(0x41414242, &options), "032sIFAUEQQ=");
assert_eq!( assert_eq!(
Format::Base32.format_str(0x41414242, &options), Format::Base32.format(0x4141414141414141, &options),
"032sIFAUEQQ="
);
assert_eq!(
Format::Base32.format_str(0x4141414141414141, &options),
"032sIFAUCQKBIFAUC===" "032sIFAUCQKBIFAUC==="
); );
assert_eq!(Format::Base64.format(0x41414242, &options), "0sQUFCQg==");
assert_eq!( assert_eq!(
Format::Base64.format_str(0x41414242, &options), Format::Base64.format(0x4141414141414141, &options),
"0sQUFCQg=="
);
assert_eq!(
Format::Base64.format_str(0x4141414141414141, &options),
"0sQUFBQUFBQUE=" "0sQUFBQUFBQUE="
); );
assert_eq!(Format::Raw.format(0x1337, &options), vec![0x0, 0x13, 0x37]);
assert_eq!(Format::Raw.format(0x0, &options), vec![0x0, 0x0]);
} }
#[test] #[test]
@ -221,52 +197,45 @@ fn set_format_checker() {
assert_eq!(options.format(), Format::Base32); assert_eq!(options.format(), Format::Base32);
options.set_format(Format::Base64); options.set_format(Format::Base64);
assert_eq!(options.format(), Format::Base64); assert_eq!(options.format(), Format::Base64);
options.set_format(Format::Raw);
assert_eq!(options.format(), Format::Raw);
} }
#[test] #[test]
fn parser_dec() { fn parser_dec() {
assert_eq!(numf_parser_str::<u32>("1337").unwrap(), 1337); assert_eq!(numf_parser::<u32>("1337").unwrap(), 1337);
assert_eq!(numf_parser_str::<u32>("0d1337").unwrap(), 1337); assert_eq!(numf_parser::<u32>("0d1337").unwrap(), 1337);
} }
#[test] #[test]
fn parser_bin() { fn parser_bin() {
assert_eq!(numf_parser_str::<u32>("0b11001").unwrap(), 0b11001); assert_eq!(numf_parser::<u32>("0b11001").unwrap(), 0b11001);
assert_eq!(numf_parser_str::<u32>("0b11001").unwrap(), 0b11001); assert_eq!(numf_parser::<u32>("0b11001").unwrap(), 0b11001);
} }
#[test] #[test]
fn parser_hex() { fn parser_hex() {
assert_eq!(numf_parser_str::<u32>("0xdeadbeef").unwrap(), 0xdeadbeef); assert_eq!(numf_parser::<u32>("0xdeadbeef").unwrap(), 0xdeadbeef);
} }
#[test] #[test]
fn parser_oct() { fn parser_oct() {
assert_eq!(numf_parser_str::<u32>("0o771171").unwrap(), 0o771171); assert_eq!(numf_parser::<u32>("0o771171").unwrap(), 0o771171);
} }
#[test] #[test]
fn parser_b64() { fn parser_b64() {
assert_eq!(numf_parser_str::<u32>("0sQUFCQg==").unwrap(), 0x41414242); assert_eq!(numf_parser::<u32>("0sQUFCQg==").unwrap(), 0x41414242);
} }
#[test] #[test]
fn parser_b32() { fn parser_b32() {
assert_eq!(numf_parser_str::<u32>("032sIFAUEQQ=").unwrap(), 0x41414242); assert_eq!(numf_parser::<u32>("032sIFAUEQQ=").unwrap(), 0x41414242);
}
#[test]
fn parser_raw() {
assert_eq!(numf_parser_str::<u32>("\x00\x50\x60").unwrap(), 0x5060);
} }
#[test] #[test]
fn parser_generics() { fn parser_generics() {
assert_eq!(numf_parser_str::<u8>("55").unwrap(), 55); assert_eq!(numf_parser::<u8>("55").unwrap(), 55);
assert_eq!(numf_parser_str::<u16>("55").unwrap(), 55); assert_eq!(numf_parser::<u16>("55").unwrap(), 55);
assert_eq!(numf_parser_str::<u32>("55").unwrap(), 55); assert_eq!(numf_parser::<u32>("55").unwrap(), 55);
assert_eq!(numf_parser_str::<u64>("55").unwrap(), 55); assert_eq!(numf_parser::<u64>("55").unwrap(), 55);
assert_eq!(numf_parser_str::<u128>("55").unwrap(), 55); assert_eq!(numf_parser::<u128>("55").unwrap(), 55);
} }