Merge branch 'hru' (closes #33)

.editorconfig

@@ -12,6 +12,3 @@ indent_size = 2
 
 [*.sh]
 indent_size = 2
-
-[configure]
-indent_size = 2

Makefile

@@ -17,7 +17,7 @@ CC=cc
 RUSTC=rustc
 
 .PHONY: all
-all: dj false fop intcmp rpn scrut str strcmp true
+all: dj false fop hru intcmp rpn scrut str strcmp true
 
 build:
 	# keep build/include until bindgen(1) has stdin support
@@ -54,7 +54,7 @@ build/o/libsysexits.rlib: build
 		| $(RUSTC) $(RUSTFLAGS) --crate-type lib -o build/o/libsysexits.rlib -
 
 build/o/libgetopt.rlib: src/getopt-rs/lib.rs
-	$(RUSTC) $(RUSTCFLAGS) --crate-type=lib --crate-name=getopt \
+	$(RUSTC) $(RUSTFLAGS) --crate-type=lib --crate-name=getopt \
 		-o build/o/libgetopt.rlib src/getopt-rs/lib.rs
 
 .PHONY: dj
@@ -74,6 +74,13 @@ build/bin/fop: src/fop.rs build build/o/libgetopt.rlib build/o/libsysexits.rlib
 		--extern sysexits=build/o/libsysexits.rlib \
 		-o $@ src/fop.rs
 
+.PHONY: hru
+hru: build/bin/hru
+build/bin/hru: src/hru.rs build build/o/libgetopt.rlib build/o/libsysexits.rlib
+	$(RUSTC) $(RUSTFLAGS) --extern getopt=build/o/libgetopt.rlib \
+		--extern sysexits=build/o/libsysexits.rlib \
+		-o $@ src/hru.rs
+
 .PHONY: intcmp
 intcmp: build/bin/intcmp
 build/bin/intcmp: src/intcmp.c build

docs/hru.1

@@ -0,0 +1,57 @@
+.\" Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+.\"
+.\" This work is licensed under CC BY-SA 4.0. To see a copy of this license,
+.\" visit <http://creativecommons.org/licenses/by-sa/4.0/>.
+
+.TH rpn 1
+
+.SH NAME
+
+hru \(en human readable units
+
+.SH SYNOPSIS
+
+hru
+
+.SH DESCRIPTION
+
+Hru reads byte counts in the form of whole numbers from the standard input and
+writes to the standard output the same number converted one of the units of data
+defined by the International System of Units.
+
+The program will convert the byte count to the highest unit possible where the
+value is greater than one.
+
+.SH DIAGNOSTICS
+
+If encountering non-integer characters in the standard input, hru will exit with
+the appropriate error code as defined by sysexits.h(3) and print an error
+message.
+
+.SH RATIONALE
+
+The GNU project’s ls(1) implementation contains a human-readable option (-h)
+that, when specified, makes the tool print size information in a format more
+immediately readable. This functionality is useful not only in the context of
+ls(1) so the decision was made to split it into a new tool. The original
+functionality in GNU’s ls(1) can be emulated with fop(1) combined with this
+program.
+
+.SH STANDARDS
+
+Hru follows the standard unit prefixes as specified by the Bureau International
+des Poids et Mesures (BIPM) in the ninth edition of The International System of
+Units (SI).
+
+.SH AUTHOR
+
+Written by Emma Tebibyte <emma@tebibyte.media>.
+
+.SH COPYRIGHT
+
+Copyright (c) 2024 Emma Tebibyte. License AGPLv3+: GNU AGPL version 3 or later
+<https://gnu.org/licenses/agpl.html>.
+
+.SH SEE ALSO
+
+GNU ls(1), The International System of Units (SI) 9th Edition

docs/scrut.1

@@ -0,0 +1,93 @@
+.\" Copyright (c) 2024 DTB <trinity@trinity.moe>
+.\"
+.\" This work is licensed under CC BY-SA 4.0. To see a copy of this license,
+.\" visit <http://creativecommons.org/licenses/by-sa/4.0/>.
+
+.TH scrut 1
+
+.SH NAME
+
+scrut \(en scrutinize file properties
+
+.SH SYNOPSIS
+
+scrut
+.RB ( -bcdefgkprsuwxLS )
+.RB [ file... ]
+
+.SH DESCRIPTION
+
+Scrut determines if given files comply with the opted requirements.
+
+.SH OPTIONS
+
+.B -b
+requires the given files to exist and be block special files.
+.PP
+.B -c
+requires the given files to exist and be character special files.
+.PP
+.B -d
+requires the given files to exist and be directories.
+.PP
+.B -e
+requires the given files to exist, and is redundant to any other option.
+.PP
+.B -e
+requires the given files to exist and be regular files.
+.PP
+.B -g
+requires the given files to exist and have their set group ID flags set.
+.PP
+.B -k
+requires the given files to exist and have their sticky bit set.
+.PP
+.B -p
+requires the given files to exist and be named pipes.
+.PP
+.B -r
+requires the given files to exist and be readable.
+.PP
+.B -u
+requires the given files to exist and have their set user ID flags set.
+.PP
+.B -w
+requires the given files to exist and be writable.
+.PP
+.B -x
+requires the given files to exist and be executable.
+.PP
+.B -L
+requires the given files to exist and be symbolic links.
+.PP
+.B -S
+requires the given files to exist and be sockets.
+
+.SH EXIT STATUS
+
+Scrut prints a debug message and exits unsuccessfully with the appropriate
+sysexits.h(3) error code if invoked incorrectly. Scrut exits successfully if
+the given files comply with their requirements and unsuccessfully otherwise.
+
+.SH STANDARDS
+
+Scrut is nearly compatible with POSIX's test utility though it is narrower in
+scope. Notably, the
+.B -h
+option is now invalid and therefore shows usage information instead of being an
+alias to the modern
+.B -L
+option.
+
+.SH AUTHOR
+
+Written by DTB <trinity@trinity.moe>.
+
+.SH COPYRIGHT
+
+Copyright © 2024 DTB. License AGPLv3+: GNU AGPL version 3 or later
+<https://gnu.org/licenses/agpl.html>.
+
+.SH SEE ALSO
+
+access(3p), lstat(3p), test(1p)

src/fop.rs

@@ -18,7 +18,7 @@
 
 use std::{
 	env::args,
-	io::{ Read, stdin, Write },
+	io::{ Read, stdin, stdout, Write },
 	process::{ Command, exit, Stdio },
 };
 
@@ -26,7 +26,7 @@ extern crate sysexits;
 extern crate getopt;
 
 use getopt::{ Opt, Parser };
-use sysexits::{ EX_DATAERR, EX_USAGE };
+use sysexits::{ EX_DATAERR, EX_IOERR, EX_UNAVAILABLE, EX_USAGE };
 
 fn main() {
 	let argv = args().collect::<Vec<String>>();
@@ -54,43 +54,65 @@ fn main() {
 		exit(EX_USAGE);
 	});
 
-	let index = argv[index_arg].parse::<usize>().unwrap_or_else(|_| {
-		eprintln!("{}: {}: Not an integer.", argv[0], argv[1]);
+	let index = argv[index_arg].parse::<usize>().unwrap_or_else(|e| {
+		eprintln!("{}: {}: {}.", argv[0], argv[1], e);
 		exit(EX_DATAERR);
 	});
 
 	let mut buf = String::new();
-	stdin().read_to_string(&mut buf).unwrap();
+	let _ = stdin().read_to_string(&mut buf);
 	let mut fields = buf.split(d).collect::<Vec<&str>>();
 
-	let opts = argv.iter().clone().skip(command_arg + 1).collect::<Vec<&String>>();
+	let opts = argv
+		.iter()
+		.clone()
+		.skip(command_arg + 1)
+		.collect::<Vec<&String>>();
 
 	let mut spawned = Command::new(argv.get(command_arg).unwrap())
 		.args(opts)
 		.stdin(Stdio::piped())
 		.stdout(Stdio::piped())
 		.spawn()
-		.unwrap();
+		.unwrap_or_else( |e| {
+			eprintln!("{}: {}: {}.", argv[0], argv[command_arg], e);
+			exit(EX_UNAVAILABLE);
+		});
 
 	let field = fields.get(index).unwrap_or_else(|| {
 		eprintln!(
 			"{}: {}: No such index in input.",
 			argv[0],
-			index.to_string()
+			index.to_string(),
 		);
 		exit(EX_DATAERR);
 	});
 
 	if let Some(mut child_stdin) = spawned.stdin.take() {
-		child_stdin.write_all(field.as_bytes()).unwrap();
+		let _ = child_stdin.write_all(field.as_bytes());
 		drop(child_stdin);
 	}
 
-	let output = spawned.wait_with_output().unwrap();
+	let output = spawned.wait_with_output().unwrap_or_else(|e| {
+		eprintln!("{}: {}: {}.", argv[0], argv[command_arg], e);
+		exit(EX_IOERR);
+	});
 
-	let new_field = String::from_utf8(output.stdout).unwrap();
+	let mut replace = output.stdout.clone();
+
+	if replace.pop() != Some(b'\n') { replace = output.stdout; }
+
+	let new_field = String::from_utf8(replace).unwrap_or_else(|e| {
+		eprintln!("{}: {}: {}.", argv[0], argv[command_arg], e);
+		exit(EX_IOERR);
+	});
 
 	fields[index] = &new_field;
 
-	print!("{}", fields.join(&d.to_string()));
+	stdout().write_all(
+		fields.join(&d.to_string()).as_bytes()
+	).unwrap_or_else(|e|{
+		eprintln!("{}: {}.", argv[0], e);
+		exit(EX_IOERR);
+	});
 }

src/hru.rs

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+
+use std::{
+	cmp::Ordering,
+	env::args,
+	io::{ stdin, stdout, Write },
+	process::{ ExitCode, exit },
+};
+
+extern crate sysexits;
+
+use sysexits::{ EX_DATAERR, EX_IOERR, EX_SOFTWARE };
+
+const LIST: [(u32, &str); 10] = [
+	(3, "k"),
+	(6, "M"),
+	(9, "G"),
+	(12, "T"),
+	(15, "P"),
+	(18, "E"),
+	(21, "Z"),
+	(24, "Y"),
+	(27, "R"),
+	(30, "Q")
+];
+
+fn convert(input: u128) -> Result<(f64, (u32, &'static str)), String> {
+
+	let mut out = (input as f64, (0_u32, ""));
+	if input < 1000 { return Ok(out); }
+
+	for (n, p) in LIST {
+		let c = match 10_u128.checked_pow(n) {
+			Some(c) => c,
+			None => {
+				return Err(format!("10^{}: Integer overflow.", n.to_string()));
+			},
+		};
+
+		match c.cmp(&input) {
+			Ordering::Less => {
+				out = (input as f64 / c as f64, (n, p));
+			},
+			Ordering::Equal => {
+				return Ok((input as f64 / c as f64, (n, p)));
+			},
+			Ordering::Greater => {},
+		};
+	}
+
+	Ok(out)
+}
+
+fn main() -> ExitCode {
+	let argv = args().collect::<Vec<String>>();
+	let mut buf = String::new();
+	while let Ok(_) = stdin().read_line(&mut buf) {
+		if buf.is_empty() { return ExitCode::SUCCESS; }
+
+		let n: u128 = match buf.trim().parse() {
+			Ok(f) => {
+				buf.clear();
+				f
+			},
+			Err(err) => {
+				eprintln!("{}: {}.", argv[0], err);
+				return ExitCode::from(EX_DATAERR as u8);
+			},
+		};
+
+		let (number, prefix) = match convert(n) {
+			Ok(x) => x,
+			Err(err) => {
+				eprintln!("{}: {}.", argv[0], err);
+				return ExitCode::from(EX_SOFTWARE as u8);
+			},
+		};
+
+		let si_prefix = format!("{}B", prefix.1);
+
+		let out = ((number * 10.0).round() / 10.0).to_string();
+
+		stdout().write_all(format!("{} {}\n", out, si_prefix).as_bytes())
+			.unwrap_or_else(|e| {
+				eprintln!("{}: {}.", argv[0], e);
+				exit(EX_IOERR);
+			});
+	}
+
+	ExitCode::SUCCESS
+}