shell.nix

@@ -5,7 +5,6 @@ pkgs.mkShell {
     cargo
     rustc
     rustfmt
-    gdb
   ];
 
   RUST_BACKTRACE = 1;

src/bin/common/argument_parsing.rs

@@ -1,41 +0,0 @@
-pub struct Arguments {
-    pub hexadecimal: bool,
-    pub mode: u8,
-    pub program_name: String,
-    pub reverse_characters: bool,
-    pub value_to_convert: String,
-}
-
-pub fn parse_direction(args: &mut impl Iterator<Item = String>, opts: &Arguments, current_arg: String) -> Result<u8, String>{
-    let mut rvalue = opts.mode;
-    let direction = match args.next() {
-        None => return Err(format!("argument for {} was not provided", current_arg)),
-        Some(e) => e,
-    };
-    match direction.as_str() {
-        "row"            => { rvalue &= !(1 << 1) ; rvalue &= !(1 << 2); }
-        "row-reverse"    => { rvalue |= 1 << 1    ; rvalue &= !(1 << 2); }
-        "column"         => { rvalue &= !(1 << 1) ; rvalue |= 1 << 2   ; }
-        "column-reverse" => { rvalue |= 1 << 1    ; rvalue |= 1 << 2   ; }
-        _ => return Err(
-            format!("invalid direction \"{}\" provided for {}", direction, current_arg)
-        )
-    };
-    return Ok(rvalue);
-}
-
-pub fn parse_wrap(args: &mut impl Iterator<Item = String>, opts: &Arguments, current_arg: String) -> Result<u8, String>{
-    let mut rvalue = opts.mode;
-    let wrap = match args.next() {
-        None => return Err(format!("argument for {} was not provided", current_arg)),
-        Some(e) => e,
-    };
-    match wrap.as_str() {
-        "normal"  => rvalue &= !(1 << 0),
-        "reverse" => rvalue |= 1 << 0,
-        _ => return Err(
-            format!("invalid wrap \"{}\" provided for {}", wrap, current_arg)
-        )
-    };
-    return Ok(rvalue);
-}

src/bin/common/mod.rs

@@ -1 +0,0 @@
-pub mod argument_parsing;

src/bin/convert_from_baillie.rs

@@ -1,105 +0,0 @@
-use std::{env, process::exit};
-
-use binary_braillie::binary_braillie_to_bytes;
-
-mod common;
-use common::argument_parsing;
-
-fn main() {
-    let args = parse_args();
-    if args.value_to_convert.len() <= 0 {
-        print!("{}: No input specified!", args.program_name)
-    }
-    let decoded_ = binary_braillie_to_bytes(
-        if !args.reverse_characters {
-            args.value_to_convert
-        } else {
-            args.value_to_convert.chars().rev().collect()
-        },
-        args.mode.try_into().unwrap()
-    );
-
-    let decoded = match decoded_ {
-        Ok(e) => e,
-        Err(()) => {
-            print!("{}: Invalid input provided", args.program_name);
-            exit(128);
-        }
-    };
-
-    if args.hexadecimal {
-        print!("{}", hex::encode(decoded));
-    } else {
-        print!("{}", match String::from_utf8(decoded) {
-            Ok(e) => e,
-            Err(e) => {
-                print!("{}: decoded string is invalid: {}", args.program_name, e.utf8_error());
-                exit(130);
-            }
-        });
-    }
-}
-
-fn parse_args() -> argument_parsing::Arguments {
-    let mut args = env::args().peekable();
-    let mut rvalue = argument_parsing::Arguments {
-        hexadecimal: false,
-        mode: 0,
-        program_name: args.next().unwrap_or(String::from("t2br")),
-        reverse_characters: false,
-        value_to_convert: String::new()
-    };
-    let program_name = &rvalue.program_name;
-
-    while args.peek() != None {
-        let arg = args.next().unwrap();
-        if arg == "--help"
-        || arg == "-h"
-        || arg == "-?"
-        {
-            print_help(rvalue.program_name);
-            exit(1);
-        }
-        else if arg == "--hex" {
-            rvalue.hexadecimal = true;
-        }
-        else if arg == "--direction" {
-            match argument_parsing::parse_direction(&mut args, &rvalue, arg) {
-                Ok(e) => rvalue.mode = e,
-                Err(e) => {
-                    print!("{}: {}", program_name, e);
-                    exit(64);
-                }
-            }
-        }
-        else if arg == "--wrap" {
-            match argument_parsing::parse_wrap(&mut args, &rvalue, arg) {
-                Ok(e) => rvalue.mode = e,
-                Err(e) => {
-                    print!("{}: {}", program_name, e);
-                    exit(65);
-                }
-            }
-        }
-        else if arg == "-r"
-        || arg == "--reverse" {
-            rvalue.reverse_characters = true;
-        }
-        else {
-            rvalue.value_to_convert.push_str(&arg);
-        }
-    }
-    return rvalue;
-}
-
-fn print_help(program_name: String) {
-    print!("Usage: {program_name} [options] <input>\n");
-    print!("Convert binary represented in braillie characters to readable text\n\n");
-    print!("  --hex               convert to hexadecimal instead of text\n\n");
-    print!("  --direction [mode]  direction of bits per character\n");
-    print!("                      possible values: row, row-reverse, column, column-reverse\n\n");
-    print!("  --wrap [mode]       direction of bits wrapping per character\n");
-    print!("                      possible values: normal, reverse\n\n");
-    print!("  -r, --reverse       reverse outputted characters\n\n");
-    print!("  -h, -?, --help      display this help and exit");
-}

src/bin/convert_to_braillie.rs

@@ -3,9 +3,6 @@ use std::process::exit;
 
 use binary_braillie::to_binary_braillie;
 
-mod common;
-use common::argument_parsing;
-
 fn main() {
     let args = parse_args();
     if args.value_to_convert.len() <= 0 {
@@ -27,11 +24,17 @@ fn main() {
     print!("{}", to_binary_braillie(&value, value.len(), args.mode.try_into().unwrap()))
 }
 
+struct Arguments {
+    pub hexadecimal: bool,
+    pub mode: u8,
+    pub program_name: String,
+    pub reverse_characters: bool,
+    pub value_to_convert: String,
+}
 
-
+fn parse_args() -> Arguments {
-fn parse_args() -> argument_parsing::Arguments {
     let mut args = env::args().peekable();
-    let mut rvalue = argument_parsing::Arguments {
+    let mut rvalue = Arguments {
         hexadecimal: false,
         mode: 0,
         program_name: args.next().unwrap_or(String::from("t2br")),
@@ -54,19 +57,31 @@ fn parse_args() -> argument_parsing::Arguments {
             rvalue.hexadecimal = true;
         }
         else if arg == "--direction" {
-            match argument_parsing::parse_direction(&mut args, &rvalue, arg) {
+            let direction = args.next().unwrap_or_else(|| {
-                Ok(e) => rvalue.mode = e,
+                println!("{}: argument for {} was not provided", program_name, arg);
-                Err(e) => {
-                    print!("{}: {}", program_name, e);
                 exit(64);
+            });
+            match direction.as_str() {
+                "row"            => { rvalue.mode &= !(1 << 1) ; rvalue.mode &= !(1 << 2); }
+                "row-reverse"    => { rvalue.mode |= 1 << 1    ; rvalue.mode &= !(1 << 2); }
+                "column"         => { rvalue.mode &= !(1 << 1) ; rvalue.mode |= 1 << 2   ; }
+                "column-reverse" => { rvalue.mode |= 1 << 1    ; rvalue.mode |= 1 << 2   ; }
+                _ => {
+                    println!("{}: invalid direction \"{}\" provided", program_name, direction);
+                    exit(65);
                 }
             }
         }
         else if arg == "--wrap" {
-            match argument_parsing::parse_wrap(&mut args, &rvalue, arg) {
+            let wrap = args.next().unwrap_or_else(|| {
-                Ok(e) => rvalue.mode = e,
+                println!("{}: argument for {} was not provided", program_name, arg);
-                Err(e) => {
+                exit(64);
-                    print!("{}: {}", program_name, e);
+            });
+            match wrap.as_str() {
+                "normal" => rvalue.mode &= !(1 << 0),
+                "reverse" => rvalue.mode |= 1 << 0,
+                _ => {
+                    println!("{}: invalid wrap \"{}\" provided", program_name, wrap);
                     exit(65);
                 }
             }

src/lib.rs

@@ -81,49 +81,9 @@ pub fn to_binary_braillie_str(input: impl AsRef<str>, mode: EncodeOrientation) -
     return to_binary_braillie(input.as_ref().as_bytes(), input.as_ref().len(), mode);
 }
 
-pub fn binary_braillie_char_to_index(input: char, mode: EncodeOrientation) -> Result<u8, ()>{
-    if !(0x2800 <= input as u32 && input as u32 <= 0x28ff) { return Err(()) }
-    let mapping = MAPPINGS[mode as usize];
-    let _index: u8 = (input as u32 - 0x2800) as u8;
-    return Ok(
-        ((_index >> mapping[7]) & 1) << 0
-      | ((_index >> mapping[6]) & 1) << 1
-      | ((_index >> mapping[5]) & 1) << 2
-      | ((_index >> mapping[4]) & 1) << 3
-      | ((_index >> mapping[3]) & 1) << 4
-      | ((_index >> mapping[2]) & 1) << 5
-      | ((_index >> mapping[1]) & 1) << 6
-      | ((_index >> mapping[0]) & 1) << 7
-    );
-}
-
-pub fn binary_braillie_to_bytes(
-    input: impl AsRef<str>,
-    mode: EncodeOrientation
-) -> Result<Vec<u8>, ()> {
-    let mut rvalue: Vec<u8> = Vec::with_capacity(input.as_ref().chars().count());
-    for char in input.as_ref().chars() {
-        rvalue.push(match binary_braillie_char_to_index(char, mode) {
-            Ok(e) => e,
-            Err(e) => return Err(e),
-        })
-    }
-    return Ok(rvalue);
-}
-
-pub fn binary_braillie_to_str(input: impl AsRef<str>, mode: EncodeOrientation) -> Result<String, ()> {
-    let bytes = match binary_braillie_to_bytes(input, mode) {
-        Ok(e) => e,
-        Err(e) => return Err(e)
-    };
-    return match String::from_utf8(bytes) {
-        Ok(e) => Ok(e),
-        Err(_e) => Err(())
-    }
-}
 
 #[cfg(test)]
-mod test_lib_to_braillie {
+mod test_lib {
     use crate::{index_to_braillie_char, to_binary_braillie_str, EncodeOrientation};
 
     #[test]
@@ -186,79 +146,3 @@ mod test_lib_to_braillie {
         );
     }
 }
-
-#[cfg(test)]
-mod test_lib_from_braillie {
-    use crate::{binary_braillie_char_to_index, EncodeOrientation};
-
-    #[test]
-    fn check_characters_out_of_range() {
-        for i in 0..0x10ffff {
-            if 0x2800 <= i && i <= 0x28ff { continue; };
-            let char = match char::from_u32(i) {
-                Some(c) => c,
-                // Continue for invalid characters
-                None => continue,
-            };
-            binary_braillie_char_to_index(char, EncodeOrientation::Rows)
-              .expect_err("Expected error for invalid char");
-        }
-    }
-
-    #[test]
-    fn check_characters_in_range() {
-        for _char in 0x2800..0x28ff {
-            let char = char::from_u32(_char).unwrap();
-            binary_braillie_char_to_index(char, EncodeOrientation::Rows)
-              .expect("Expected no error");
-        }
-    }
-}
-
-#[cfg(test)]
-mod test_lib_all {
-    use crate::{
-        binary_braillie_char_to_index,
-        binary_braillie_to_bytes,
-        index_to_braillie_char,
-        to_binary_braillie,
-        EncodeOrientation
-    };
-
-    #[test]
-    fn check_coding_multiple() {
-        for i in 0x00..0xff {
-            let mut as_char = index_to_braillie_char(
-                i,
-                EncodeOrientation::Rows
-            );
-            for _ in 0..10 {
-                let as_index = binary_braillie_char_to_index(
-                    as_char,
-                    EncodeOrientation::Rows
-                ).unwrap();
-                assert_eq!(as_index, i);
-                as_char = index_to_braillie_char(as_index, EncodeOrientation::Rows)
-            }
-        }
-    }
-
-    #[test]
-    fn check_coding_multiple_bytes() {
-        for i in 0x00..0xff {
-            let mut as_str = index_to_braillie_char(i, EncodeOrientation::Rows).to_string();
-            for _ in 0..10 {
-                let as_bytes = binary_braillie_to_bytes(
-                    as_str,
-                    EncodeOrientation::Rows
-                ).unwrap();
-                assert_eq!(i, as_bytes[0]);
-                as_str = to_binary_braillie(
-                    &as_bytes,
-                    as_bytes.len(),
-                    EncodeOrientation::Rows
-                ).to_string()
-            }
-        }
-    }
-}