~ajk/bsr: Run cargo fmt - sourcehut git

3 files changed, 86 insertions(+), 49 deletions(-)

M src/bitstream.rs
M src/lib.rs
M src/main.rs

M src/bitstream.rs => src/bitstream.rs +53 -30

@@ 8,7 8,7 @@ pub struct Header {
     pub part_name: String,
     pub design_date: String,
     pub design_time: String,
-    pub bitstream_length: u32
+    pub bitstream_length: u32,
 }
 
 // See http://www.fpga-faq.com/FAQ_Pages/0026_Tell_me_about_bit_files.htm.


@@ 18,7 18,7 @@ enum Tag {
     PartName = 0x62,
     DesignDate = 0x63,
     DesignTime = 0x64,
-    Bitstream = 0x65
+    Bitstream = 0x65,
 }
 
 pub fn read_header<R: Read>(reader: &mut R) -> io::Result<Header> {


@@ 78,13 78,20 @@ pub fn read_header<R: Read>(reader: &mut R) -> io::Result<Header> {
         return invalid_data("expected bitstream tag");
     }
 
-    let bitstream_length = read_u32(reader).or_else(|_| invalid_data("error reading bitstream length"))?;
+    let bitstream_length =
+        read_u32(reader).or_else(|_| invalid_data("error reading bitstream length"))?;
 
     if bitstream_length % 4 != 0 {
         return invalid_data("bitstream length must be multiple of 4");
     }
 
-    Ok(Header { design_name, part_name, design_date, design_time, bitstream_length })
+    Ok(Header {
+        design_name,
+        part_name,
+        design_date,
+        design_time,
+        bitstream_length,
+    })
 }
 
 #[cfg(test)]


@@ 94,20 101,25 @@ mod read_header_tests {
     #[test]
     fn test_valid_header() {
         let buffer: [u8; 144] = [
-            0x00, 0x09, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x00, 0x00, 0x01, 0x61, 0x00, 0x32,
-            0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x5f, 0x31, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72,
-            0x3b, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x3d, 0x30, 0x58, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
-            0x46, 0x46, 0x3b, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x32, 0x30, 0x32, 0x30, 0x2e,
-            0x31, 0x00, 0x62, 0x00, 0x0c, 0x37, 0x7a, 0x30, 0x32, 0x30, 0x63, 0x6c, 0x67, 0x34, 0x30, 0x30,
-            0x00, 0x63, 0x00, 0x0b, 0x32, 0x30, 0x32, 0x30, 0x2f, 0x31, 0x32, 0x2f, 0x32, 0x33, 0x00, 0x64,
-            0x00, 0x09, 0x30, 0x33, 0x3a, 0x30, 0x33, 0x3a, 0x35, 0x30, 0x00, 0x65, 0x00, 0x3d, 0xba, 0xfc,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0x00, 0x00, 0x00, 0xbb, 0x11, 0x22, 0x00, 0x44, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+            0x00, 0x09, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x00, 0x00, 0x01, 0x61,
+            0x00, 0x32, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x5f, 0x31, 0x5f, 0x77, 0x72, 0x61,
+            0x70, 0x70, 0x65, 0x72, 0x3b, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x3d, 0x30, 0x58,
+            0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x3b, 0x56, 0x65, 0x72, 0x73, 0x69,
+            0x6f, 0x6e, 0x3d, 0x32, 0x30, 0x32, 0x30, 0x2e, 0x31, 0x00, 0x62, 0x00, 0x0c, 0x37,
+            0x7a, 0x30, 0x32, 0x30, 0x63, 0x6c, 0x67, 0x34, 0x30, 0x30, 0x00, 0x63, 0x00, 0x0b,
+            0x32, 0x30, 0x32, 0x30, 0x2f, 0x31, 0x32, 0x2f, 0x32, 0x33, 0x00, 0x64, 0x00, 0x09,
+            0x30, 0x33, 0x3a, 0x30, 0x33, 0x3a, 0x35, 0x30, 0x00, 0x65, 0x00, 0x3d, 0xba, 0xfc,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0xbb, 0x11, 0x22, 0x00, 0x44, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff,
         ];
 
         let header = read_header(&mut buffer.as_ref()).unwrap();
 
-        assert_eq!(header.design_name, "design_1_wrapper;UserID=0XFFFFFFFF;Version=2020.1");
+        assert_eq!(
+            header.design_name,
+            "design_1_wrapper;UserID=0XFFFFFFFF;Version=2020.1"
+        );
         assert_eq!(header.part_name, "7z020clg400");
         assert_eq!(header.design_date, "2020/12/23");
         assert_eq!(header.design_time, "03:03:50");


@@ 124,11 136,12 @@ mod read_header_tests {
     #[test]
     fn test_invalid_header() {
         let buffer: [u8; 74] = [
-            0x00, 0x09, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x00, 0x00, 0x01, 0x61, 0x00, 0x32,
-            0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x5f, 0x31, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72,
-            0x3b, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x3d, 0x30, 0x58, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
-            0x46, 0x46, 0x3b, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x32, 0x30, 0x32, 0x30, 0x2e,
-            0x31, 0x00, 0x62, 0x00, 0x0c, 0x37, 0x7a, 0x30, 0x32, 0x30
+            0x00, 0x09, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x00, 0x00, 0x01, 0x61,
+            0x00, 0x32, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x5f, 0x31, 0x5f, 0x77, 0x72, 0x61,
+            0x70, 0x70, 0x65, 0x72, 0x3b, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x3d, 0x30, 0x58,
+            0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x3b, 0x56, 0x65, 0x72, 0x73, 0x69,
+            0x6f, 0x6e, 0x3d, 0x32, 0x30, 0x32, 0x30, 0x2e, 0x31, 0x00, 0x62, 0x00, 0x0c, 0x37,
+            0x7a, 0x30, 0x32, 0x30,
         ];
 
         assert!(read_header(&mut buffer.as_ref()).is_err());


@@ 138,14 151,18 @@ mod read_header_tests {
 pub struct Bitstream<R> {
     reader: R,
     length: usize,
-    counter: usize
+    counter: usize,
 }
 
 impl<R> Bitstream<R> {
     pub fn new(reader: R, header: &Header) -> Bitstream<R> {
         let length = (header.bitstream_length / 4) as usize;
 
-        Bitstream { reader, length, counter: 0 }
+        Bitstream {
+            reader,
+            length,
+            counter: 0,
+        }
     }
 }
 


@@ 186,7 203,8 @@ mod bitstream_tests {
     #[test]
     fn test_valid() {
         let buffer: [u8; 16] = [
-            0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04
+            0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+            0x00, 0x04,
         ];
 
         let header = Header {


@@ 194,18 212,21 @@ mod bitstream_tests {
             part_name: "part".to_string(),
             design_date: "date".to_string(),
             design_time: "time".to_string(),
-            bitstream_length: 16
+            bitstream_length: 16,
         };
 
         let bitstream = Bitstream::new(buffer.as_ref(), &header);
 
-        assert_eq!(bitstream.collect::<Result<Vec<_>, _>>().unwrap(), [1, 2, 3, 4]);
+        assert_eq!(
+            bitstream.collect::<Result<Vec<_>, _>>().unwrap(),
+            [1, 2, 3, 4]
+        );
     }
 
     #[test]
     fn test_invalid() {
         let buffer: [u8; 12] = [
-            0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03
+            0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
         ];
 
         let header = Header {


@@ 213,7 234,7 @@ mod bitstream_tests {
             part_name: "part".to_string(),
             design_date: "date".to_string(),
             design_time: "time".to_string(),
-            bitstream_length: 16
+            bitstream_length: 16,
         };
 
         let bitstream = Bitstream::new(buffer.as_ref(), &header);


@@ 224,7 245,8 @@ mod bitstream_tests {
     #[test]
     fn test_len() {
         let buffer: [u8; 16] = [
-            0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04
+            0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+            0x00, 0x04,
         ];
 
         let header = Header {


@@ 232,7 254,7 @@ mod bitstream_tests {
             part_name: "part".to_string(),
             design_date: "date".to_string(),
             design_time: "time".to_string(),
-            bitstream_length: 16
+            bitstream_length: 16,
         };
 
         let mut bitstream = Bitstream::new(buffer.as_ref(), &header);


@@ 282,11 304,12 @@ fn read_string<R: Read>(reader: &mut R) -> io::Result<String> {
 
     reader.read_exact(&mut buffer)?;
 
-    if buffer[length-1] != 0x00 {
+    if buffer[length - 1] != 0x00 {
         return invalid_data("expected NULL terminated string");
     }
 
-    String::from_utf8(buffer[..length-1].to_vec()).or_else(|_| invalid_data("expected valid string"))
+    String::from_utf8(buffer[..length - 1].to_vec())
+        .or_else(|_| invalid_data("expected valid string"))
 }
 
 fn invalid_data<T>(message: &str) -> io::Result<T> {

M src/lib.rs => src/lib.rs +18 -6

@@ 3,9 3,13 @@ use std::io::prelude::*;
 
 pub mod bitstream;
 
-use bitstream::{read_header, Header, Bitstream};
+use bitstream::{read_header, Bitstream, Header};
 
-pub fn run<R: BufRead>(input: &mut R, should_show_info: bool, should_convert: bool) -> io::Result<()> {
+pub fn run<R: BufRead>(
+    input: &mut R,
+    should_show_info: bool,
+    should_convert: bool,
+) -> io::Result<()> {
     let header = read_header(input)?;
 
     if should_show_info {


@@ 30,11 34,19 @@ pub fn run<R: BufRead>(input: &mut R, should_show_info: bool, should_convert: bo
 }
 
 fn format_header(header: &Header) -> String {
-    format!("design = {}\npart = {}\ndate = {}\ntime = {}\nbitstream length = {}",
-            header.design_name, header.part_name, header.design_date,
-            header.design_time, header.bitstream_length)
+    format!(
+        "design = {}\npart = {}\ndate = {}\ntime = {}\nbitstream length = {}",
+        header.design_name,
+        header.part_name,
+        header.design_date,
+        header.design_time,
+        header.bitstream_length
+    )
 }
 
-fn convert_bitstream<R: Read, W: Write>(writer: &mut W, bitstream: &mut Bitstream<R>) -> io::Result<()> {
+fn convert_bitstream<R: Read, W: Write>(
+    writer: &mut W,
+    bitstream: &mut Bitstream<R>,
+) -> io::Result<()> {
     bitstream.try_for_each(|w1| w1.and_then(|w2| writer.write_all(&w2.to_le_bytes())))
 }

M src/main.rs => src/main.rs +15 -13

@@ 1,7 1,7 @@
+use std::fs::File;
 use std::io;
 use std::io::prelude::*;
 use std::io::BufReader;
-use std::fs::File;
 use std::process;
 
 use clap::{App, Arg};


@@ 11,7 11,7 @@ fn main() {
 
     let input: Box<dyn Read> = match path.as_str() {
         "-" => Box::new(io::stdin()),
-        _ => Box::new(File::open(path).expect("error opening bitstream"))
+        _ => Box::new(File::open(path).expect("error opening bitstream")),
     };
 
     let mut input = BufReader::new(input);


@@ 26,17 26,19 @@ fn main() {
 
 fn parse_args() -> (String, bool, bool) {
     let matches = App::new("bsr")
-        .arg(Arg::with_name("show_info")
-             .short("i")
-             .conflicts_with("only_show_info")
-             .help("Show bitstream info"))
-        .arg(Arg::with_name("only_show_info")
-             .short("I")
-             .conflicts_with("show_info")
-             .help("Only show bitstream info, do not convert"))
-        .arg(Arg::with_name("path")
-             .required(false)
-             .index(1))
+        .arg(
+            Arg::with_name("show_info")
+                .short("i")
+                .conflicts_with("only_show_info")
+                .help("Show bitstream info"),
+        )
+        .arg(
+            Arg::with_name("only_show_info")
+                .short("I")
+                .conflicts_with("show_info")
+                .help("Only show bitstream info, do not convert"),
+        )
+        .arg(Arg::with_name("path").required(false).index(1))
         .get_matches();
 
     let path = matches.value_of("path").unwrap_or("-");