first commit

Author: dorianmeric

.gitignore

@@ -0,0 +1 @@
+target

Cargo.lock

@@ -0,0 +1,22 @@
+[package]
+name = "sortn"
+version = "1.0.0"
+authors = ["Dorian Meric"]
+repository = "https://github.com/dorianmeric/sortn"
+license = "MIT"
+description = "natural sort CLI"
+readme = "README.md"
+edition = "2024"
+
+[dependencies]
+clap = { version = "4.5.54", features = ["derive"] }
+natord = "1.0.9"
+
+[profile.release]
+lto = true
+codegen-units = 1
+panic = "abort"
+
+[[bin]]
+name = "sortn"
+path = "src/main.rs"

Cargo.toml

@@ -0,0 +1,95 @@
+# sortn
+
+`sortn` is a fast, command-line utility written in Rust that performs **natural sorting** on input lines. Unlike standard lexicographical sorting—which would sort "file10.txt" before "file2.txt"—`sortn` treats multi-digit numbers as single numeric values, resulting in a more human-friendly order (1, 2, 10).
+
+## Features
+
+* **Natural Ordering**: Correctly handles numeric sequences within strings.
+* **Case Insensitivity**: Optional flag (`-i`) to ignore character casing during comparison.
+* **Reverse Sort**: Quickly invert the sorting order with the `-r` flag.
+* **Modern CLI**: Built with **Clap v4**, providing a clean interface and automatic help generation.
+
+## Installation
+
+Ensure you have the Rust toolchain installed.
+
+1. Clone this repository.
+2. Build the release binary:
+```bash
+cargo build --release
+
+```
+
+
+3. Move the binary to your path:
+```bash
+cp target/release/sortn /usr/local/bin/
+
+```
+
+
+
+## Usage
+
+`sortn` reads from standard input (`stdin`) and writes the sorted result to standard output (`stdout`).
+
+### Basic Sorting
+
+```bash
+$ cat files.txt
+file10.txt
+file2.txt
+file1.txt
+
+$ cat files.txt | sortn
+file1.txt
+file2.txt
+file10.txt
+
+```
+
+### Reverse Order (`-r`)
+
+```bash
+$ cat files.txt | sortn -r
+file10.txt
+file2.txt
+file1.txt
+
+```
+
+### Case-Insensitive (`-i`)
+
+```bash
+$ echo -e "B\na\nC" | sortn -i
+a
+B
+C
+
+```
+
+## Options
+
+| Flag | Long Flag | Description |
+| --- | --- | --- |
+| `-r` | `--reverse` | Sort in reverse order. |
+| `-i` | `--ignore-case` | Perform case-insensitive natural sorting. |
+| `-h` | `--help` | Print help information. |
+| `-V` | `--version` | Print version information. |
+
+## Comparison with GNU `sort`
+
+While the standard GNU `sort` utility includes a `-V` (`--version-sort`) flag that achieves similar results, `sortn` offers several distinctions:
+
+* **Simplicity**: `sortn` is a focused, lightweight tool specifically designed for natural sorting without the overhead of the dozens of flags found in GNU `sort`.
+* **Performance**: Written in Rust and utilizing the `natord` crate, `sortn` provides highly competitive performance for in-memory sorting tasks.
+* **Memory Usage**: Currently, `sortn` loads all input lines into memory to perform a global sort. For extremely large datasets that exceed available RAM, GNU `sort` (which uses disk-based merging) may be more suitable.
+
+## Performance Benchmarks
+
+`sortn` is optimized for speed by:
+
+1. **Locking I/O**: Accessing `stdin` and `stdout` through locked buffers to minimize system call overhead.
+2. **Efficient Comparison**: Using the `natord` crate which is optimized for natural string comparison without unnecessary allocations.
+3. **Zero-Cost Abstractions**: Leveraging Rust's ownership model to manage string data efficiently during the sort process.
+

README.md

@@ -0,0 +1,65 @@
+use clap::Parser;
+use std::io::{self, BufRead, Write};
+
+/// A utility to perform natural sorting on input lines.
+#[derive(Parser, Debug)]
+#[command(
+    name = "sortn",
+    version,
+    about = "Sorts lines naturally (e.g., '2' before '10')",
+    long_about = None
+)]
+struct Args {
+    /// Sort in reverse order
+    #[arg(short, long)]
+    reverse: bool,
+
+    /// Case-insensitive sorting
+    #[arg(short, long)]
+    ignore_case: bool,
+}
+
+fn main() {
+    let args = Args::parse();
+
+    let stdin = io::stdin();
+    let stdout = io::stdout();
+    
+    // 1. Collect all lines into memory as Strings
+    // Natural sorting requires string comparison. We collect them into a Vec
+    // so we can perform the sort operation on the whole collection.
+    let mut lines: Vec<String> = stdin
+        .lock()
+        .lines()
+        .map(|l| l.expect("Failed to read line from stdin"))
+        .collect();
+
+    // 2. Perform natural sort
+    // We use the natord crate for "natural" alphanumeric ordering.
+    lines.sort_by(|a, b| {
+        let cmp = if args.ignore_case {
+            // Compare lowercase versions for case-insensitivity
+            natord::compare(&a.to_lowercase(), &b.to_lowercase())
+        } else {
+            natord::compare(a, b)
+        };
+
+        if args.reverse {
+            cmp.reverse()
+        } else {
+            cmp
+        }
+    });
+
+    // 3. Output the sorted lines
+    let mut out = stdout.lock();
+    for line in lines {
+        if let Err(e) = writeln!(out, "{}", line) {
+            // Handle broken pipes (e.g., when piping to `head`) gracefully
+            if e.kind() == io::ErrorKind::BrokenPipe {
+                break;
+            }
+            panic!("Failed to write output: {}", e);
+        }
+    }
+}