Run cargo fmt across repository

src/adapters.rs

@@ -17,13 +17,13 @@ use custom::CustomAdapterConfig;
 use log::*;
 use tokio::io::AsyncRead;
 
+use core::fmt::Debug;
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::iter::Iterator;
 use std::path::PathBuf;
 use std::pin::Pin;
 use std::rc::Rc;
-use core::fmt::Debug;
 
 pub type ReadBox = Pin<Box<dyn AsyncRead + Send>>;
 pub struct AdapterMeta {
@@ -78,7 +78,7 @@ impl AdapterMeta {
 pub trait GetMetadata {
     fn metadata(&self) -> &AdapterMeta;
 }
-pub trait FileAdapter: GetMetadata + Send + Sync{
+pub trait FileAdapter: GetMetadata + Send + Sync {
     /// adapt a file.
     ///
     /// detection_reason is the Matcher that was used to identify this file. Unless --rga-accurate was given, it is always a FastMatcher

src/adapters/postproc.rs

@@ -4,19 +4,17 @@
 
 use anyhow::Context;
 use anyhow::Result;
+use async_stream::stream;
 use bytes::Bytes;
 use encoding_rs_io::DecodeReaderBytesBuilder;
-use tokio::io::{AsyncRead, AsyncReadExt};
-use async_stream::stream;
-use tokio_util::io::ReaderStream;
-use tokio_util::io::StreamReader;
+use std::cmp::min;
 use std::io::Cursor;
 use std::pin::Pin;
-use std::{
-    cmp::min,
-};
+use tokio::io::{AsyncRead, AsyncReadExt};
+use tokio_util::io::ReaderStream;
+use tokio_util::io::StreamReader;
 
-use crate::adapted_iter::{AdaptedFilesIterBox};
+use crate::adapted_iter::AdaptedFilesIterBox;
 
 use super::{AdaptInfo, AdapterMeta, FileAdapter, GetMetadata};
 
@@ -177,18 +175,30 @@ pub fn postproc_pagebreaks(line_prefix: &str, inp: impl AsyncRead) -> impl Async
 mod tests {
     use super::*;
     use anyhow::Result;
-    use tokio::pin;
     use std::io::Read;
+    use tokio::pin;
 
-    async fn test_from_strs(pagebreaks: bool, line_prefix: &str, a: &'static str, b: &str) -> Result<()> {
+    async fn test_from_strs(
+        pagebreaks: bool,
+        line_prefix: &str,
+        a: &'static str,
+        b: &str,
+    ) -> Result<()> {
         test_from_bytes(pagebreaks, line_prefix, a.as_bytes(), b).await
     }
 
-    async fn test_from_bytes(pagebreaks: bool, line_prefix: &str, a: &'static [u8], b: &str) -> Result<()> {
+    async fn test_from_bytes(
+        pagebreaks: bool,
+        line_prefix: &str,
+        a: &'static [u8],
+        b: &str,
+    ) -> Result<()> {
         let mut oup = Vec::new();
         let inp = postproc_encoding("", a)?;
         if pagebreaks {
-            postproc_pagebreaks(line_prefix, inp).read_to_end(&mut oup).await?;
+            postproc_pagebreaks(line_prefix, inp)
+                .read_to_end(&mut oup)
+                .await?;
         } else {
             let x = postproc_prefix(line_prefix, inp);
             pin!(x);
@@ -231,7 +241,8 @@ mod tests {
             "foo:",
             "this is a test \n\n \0 foo",
             "foo:[rga: binary data]",
-        ).await?;
+        )
+        .await?;
         test_from_strs(false, "foo:", "\0", "foo:[rga: binary data]").await?;
 
         Ok(())

src/adapters/spawning.rs

@@ -1,4 +1,3 @@
-
 use super::*;
 use anyhow::Result;
 use async_stream::{stream, AsyncStream};

src/bin/rga-preproc.rs

@@ -5,7 +5,7 @@ use ripgrep_all as rga;
 
 use anyhow::Context;
 use log::debug;
-use std::{time::Instant};
+use std::time::Instant;
 use tokio::fs::File;
 
 #[tokio::main]
@@ -20,7 +20,9 @@ async fn main() -> anyhow::Result<()> {
         std::env::current_dir()?.join(&filepath)
     };
 
-    let i = File::open(&path).await.context("Specified input file not found")?;
+    let i = File::open(&path)
+        .await
+        .context("Specified input file not found")?;
     let mut o = tokio::io::stdout();
     let ai = AdaptInfo {
         inp: Box::pin(i),

src/caching_writer.rs

@@ -17,11 +17,11 @@ use crate::adapters::ReadBox;
  * unless more than max_cache_size bytes is written, then the cache is dropped and it is pure passthrough.
  */
 pub fn async_read_and_write_to_cache<'a>(
-    inp: impl AsyncRead + Send +'a,
+    inp: impl AsyncRead + Send + 'a,
     max_cache_size: usize,
     compression_level: i32,
     on_finish: Box<dyn FnOnce((u64, Option<Vec<u8>>)) -> Result<()> + Send>,
-) -> Result<Pin<Box<dyn AsyncRead + Send +'a>>> {
+) -> Result<Pin<Box<dyn AsyncRead + Send + 'a>>> {
     let inp = Box::pin(inp);
     let mut zstd_writer = Some(ZstdEncoder::with_quality(
         Vec::new(),

src/config.rs

@@ -1,5 +1,5 @@
 use crate::{adapters::custom::CustomAdapterConfig, project_dirs};
-use anyhow::{Result, Context};
+use anyhow::{Context, Result};
 use derive_more::FromStr;
 use log::*;
 use schemars::JsonSchema;
@@ -237,7 +237,7 @@ pub struct CacheConfig {
         default_value,
         long = "--rga-cache-path",
         hidden_short_help = true,
-        require_equals = true,
+        require_equals = true
     )]
     pub path: CachePath,
 }

src/preproc.rs

@@ -13,11 +13,11 @@ use async_compression::tokio::bufread::ZstdDecoder;
 use async_stream::stream;
 use log::*;
 use path_clean::PathClean;
-use std::sync::Arc;
 use postproc::PostprocPrefix;
 use std::convert::TryInto;
 use std::io::Cursor;
 use std::path::Path;
+use std::sync::Arc;
 use tokio::io::AsyncBufRead;
 use tokio::io::AsyncBufReadExt;
 use tokio::io::BufReader;

src/recurse.rs

@@ -3,10 +3,7 @@ use tokio_util::io::{ReaderStream, StreamReader};
 use crate::{adapted_iter::AdaptedFilesIterBox, adapters::*};
 use async_stream::stream;
 
-
-pub fn concat_read_streams(
-    input: AdaptedFilesIterBox,
-) -> ReadBox {
+pub fn concat_read_streams(input: AdaptedFilesIterBox) -> ReadBox {
     let s = stream! {
         for await output in input {
             let stream = ReaderStream::new(output.inp);
@@ -16,4 +13,4 @@ pub fn concat_read_streams(
         }
     };
     Box::pin(StreamReader::new(s))
-}
+}