feat: support for reading from stdin

Author: uetchy

Cargo.lock

@@ -1,14 +1,13 @@
 [package]
 name = "binyl"
-description = "A bitwise UTF-8 inspection tool"
+description = "A bitwise UTF-8 string inspection tool"
 version = "0.1.0"
 authors = ["Yasuaki Uechi <[email protected]>"]
-edition = "2018"
-license = "Apache-2.0"
+edition = "2021"
 license-file = "LICENSE"
 repository = "https://github.com/uetchy/binyl"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-colored = "1.9.3"
+colored = "2.0.0"

Cargo.toml

@@ -1,17 +1,22 @@
 # binyl
 
-A bitwise UTF-8 inspection tool written in Rust.
+A bitwise UTF-8 string inspection tool written in Rust.
 
 ![Screenshot](https://github.com/uetchy/binyl/blob/master/.github/ss.png?raw=true)
 
 ## Installation
 
-```
+```bash
 cargo install binyl
 ```
 
 ## Usage
 
-```
-binyl <file to inspect>
+```bash
+binyl <file/to/inspect>
+
+# or
+
+echo わたしはネコ🐈 | binyl
+cat some.file | binyl
 ```

README.md

@@ -4,15 +4,23 @@ use std::process;
 
 fn main() {
     let args: Vec<String> = env::args().collect();
-    let filename = match args.get(1) {
-        Some(f) => f,
+
+    parse_string(match args.get(1) {
+        // read from file
+        Some(filename) => std::fs::read_to_string(filename).unwrap(),
+
+        // read from stdin
         None => {
-            println!("No arg provided");
-            process::exit(1);
+            let mut line = String::new();
+            std::io::stdin().read_line(&mut line).unwrap();
+            line
         }
-    };
-    let content = std::fs::read_to_string(filename).unwrap();
+    })
+}
+
+fn parse_string(content: String) {
     let mut bytes = content.bytes();
+
     while let Some(b) = bytes.next() {
         if b & 0x80 == 0 {
             // if MSB is 0, is is ASCII.
@@ -23,42 +31,66 @@ fn main() {
                 std::str::from_utf8(&[b])
                     .unwrap()
                     .replace("\x0a", "↵")
-                    .replace("\x20", "<space>"),
+                    .replace("\x20", "<space>")
+                    .bold(),
                 b
             );
         } else {
             let nb = (!b).leading_zeros();
-            let bin_str = format!("{:08b}", b);
-            let (first_bin, second_bin) = bin_str.split_at(nb as usize + 1);
+            let (first, last) = split_octet(b, nb);
+
             print!("{} ", "├".bright_black());
-            print!("{}{}", first_bin.magenta(), second_bin.green(),);
-            let mut v: Vec<u8> = Vec::new();
+            print!(
+                "{}{}",
+                format!("{:04b}", first).magenta(),
+                format!("{:04b}", last).green(),
+            );
+
+            let mut v: Vec<u8> = vec![];
             let mut f: u32 = 0;
             let base = 6 * (nb - 1);
 
             v.push(b);
 
             f |= (b as u32 & (u32::pow(2, 7 - nb) - 1)) << base;
+
             for i in 0..(nb - 1) {
                 let next_byte = bytes.next().unwrap();
+
                 // if first 2 MSB are not '10', it's illegal sequence.
                 if next_byte & 0xC0 != 0x80 {
                     println!("Illegal byte");
                     process::exit(1);
                 }
-                let bin_str = format!("{:08b}", next_byte);
-                let (first_bin, second_bin) = bin_str.split_at(2);
-                print!("{}{}", first_bin.bright_black(), second_bin.green());
+
+                let (first, last) = split_octet(next_byte, 2);
+
+                print!(
+                    "{}{}",
+                    format!("{:02b}", first).bright_black(),
+                    format!("{:06b}", last).green()
+                );
+
                 f |= (next_byte as u32 & 0x3f) << base - (i + 1) * 6;
                 v.push(next_byte);
             }
+
             println!(
                 " ({} bytes) = {} {} (U+{:04X})",
                 nb,
                 format!("{:0b}", f).cyan(),
-                std::str::from_utf8(&v[..]).unwrap().bold(),
+                std::str::from_utf8(&v[..])
+                    .unwrap_or("[INVALID CODE]")
+                    .bold(),
                 f
             );
         }
     }
 }
+
+fn split_octet(octet: u8, separate_at: u32) -> (u8, u8) {
+    let mask = u8::pow(2, separate_at) - 1;
+    let first = (octet & !mask) >> (8 - separate_at);
+    let last = octet & mask;
+    (first, last)
+}