chore: cargo fmt

Author: nickysn

runtime_tracing/build.rs

@@ -1,6 +1,3 @@
 fn main() {
-    ::capnpc::CompilerCommand::new()
-        .file("src/trace.capnp")
-        .run()
-        .expect("compiling schema")
+    ::capnpc::CompilerCommand::new().file("src/trace.capnp").run().expect("compiling schema")
 }

runtime_tracing/src/base64.rs

@@ -9,5 +9,7 @@ pub fn serialize<S: Serializer>(v: &Vec<u8>, s: S) -> Result<S::Ok, S::Error> {
 
 pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D::Error> {
     let base64 = String::deserialize(d)?;
-    base64::engine::general_purpose::STANDARD.decode(base64.as_bytes()).map_err(serde::de::Error::custom)
+    base64::engine::general_purpose::STANDARD
+        .decode(base64.as_bytes())
+        .map_err(serde::de::Error::custom)
 }

runtime_tracing/src/capnptrace.rs

@@ -8,11 +8,13 @@
 //! This crate provides the [`Tracer`] type for emitting trace events and a
 //! collection of serializable structures describing the trace format.
 //! The format is documented in `docs/` and the README.
-mod tracer;
-mod types;
 mod base64;
 mod capnptrace;
-pub use crate::tracer::{TraceReader, NonStreamingTraceWriter, TraceWriter, TraceEventsFileFormat, NONE_TYPE_ID, NONE_VALUE, create_trace_reader, create_trace_writer};
+mod tracer;
+mod types;
+pub use crate::tracer::{
+    create_trace_reader, create_trace_writer, NonStreamingTraceWriter, TraceEventsFileFormat, TraceReader, TraceWriter, NONE_TYPE_ID, NONE_VALUE,
+};
 pub use crate::types::*;
 
 pub mod trace_capnp {

runtime_tracing/src/lib.rs

@@ -18,8 +18,7 @@ pub trait TraceReader {
     fn load_trace_events(&mut self, path: &Path) -> Result<Vec<TraceLowLevelEvent>, Box<dyn Error>>;
 }
 
-pub struct JsonTraceReader {
-}
+pub struct JsonTraceReader {}
 
 impl TraceReader for JsonTraceReader {
     fn load_trace_events(&mut self, path: &Path) -> Result<Vec<TraceLowLevelEvent>, Box<dyn Error>> {
@@ -28,8 +27,7 @@ impl TraceReader for JsonTraceReader {
     }
 }
 
-pub struct BinaryTraceReader {
-}
+pub struct BinaryTraceReader {}
 
 impl TraceReader for BinaryTraceReader {
     fn load_trace_events(&mut self, path: &Path) -> Result<Vec<TraceLowLevelEvent>, Box<dyn Error>> {
@@ -87,7 +85,6 @@ pub trait TraceWriter {
     fn finish_writing_trace_paths(&mut self) -> Result<(), Box<dyn Error>>;
 }
 
-
 /// State machine used to record [`TraceLowLevelEvent`]s.
 ///
 /// A `NonStreamingTraceWriter` instance accumulates events in memory and stores them on
@@ -118,7 +115,7 @@ pub struct NonStreamingTraceWriter {
 #[derive(Debug, Clone, Copy)]
 pub enum TraceEventsFileFormat {
     Json,
-    Binary
+    Binary,
 }
 
 // we ensure in start they are registered with those id-s
@@ -460,14 +457,9 @@ impl TraceWriter for NonStreamingTraceWriter {
 
 pub fn create_trace_reader(format: TraceEventsFileFormat) -> Box<dyn TraceReader> {
     match format {
-        TraceEventsFileFormat::Json => {
-            Box::new(JsonTraceReader { } )
-        }
-        TraceEventsFileFormat::Binary => {
-            Box::new(BinaryTraceReader { } )
-        }
+        TraceEventsFileFormat::Json => Box::new(JsonTraceReader {}),
+        TraceEventsFileFormat::Binary => Box::new(BinaryTraceReader {}),
     }
-
 }
 
 pub fn create_trace_writer(program: &str, args: &[String], format: TraceEventsFileFormat) -> Box<dyn TraceWriter> {

runtime_tracing/src/tracer.rs

@@ -6,10 +6,10 @@ use std::cmp::Ord;
 use std::ops;
 use std::path::PathBuf;
 
+use crate::base64;
 use num_derive::FromPrimitive;
 use serde::{Deserialize, Serialize};
 use serde_repr::*;
-use crate::base64;
 
 // currently, we do assume that we record the whole program
 // so, we try to include minimal amount of data,
@@ -474,5 +474,5 @@ pub enum EventLogKind {
     Error,
     // used for trace events
     TraceLogEvent,
-    EvmEvent
+    EvmEvent,
 }

runtime_tracing/src/types.rs

@@ -1,15 +1,13 @@
 use runtime_tracing::{create_trace_reader, create_trace_writer, TraceEventsFileFormat};
-use std::path::Path;
 use std::fs;
+use std::path::Path;
 
 #[test]
 fn test_binary_roundtrip() {
     let json_path = Path::new("tests/data/trace.json");
 
     let mut json_reader = create_trace_reader(TraceEventsFileFormat::Json);
-    let original = json_reader
-        .load_trace_events(json_path)
-        .unwrap();
+    let original = json_reader.load_trace_events(json_path).unwrap();
 
     let bin_path = Path::new("tests/data/trace.bin");
 
@@ -19,9 +17,7 @@ fn test_binary_roundtrip() {
     bin_writer.finish_writing_trace_events().unwrap();
 
     let mut bin_reader = create_trace_reader(TraceEventsFileFormat::Binary);
-    let tracer2_events = bin_reader
-        .load_trace_events(bin_path)
-        .unwrap();
+    let tracer2_events = bin_reader.load_trace_events(bin_path).unwrap();
 
     fs::remove_file(bin_path).unwrap();
 

runtime_tracing/tests/binary_format.rs

@@ -1,8 +1,8 @@
 use std::path::Path;
 
+use crate::fmt_trace_cmd::FmtTraceCommand;
 use clap::{Args, Parser, Subcommand};
 use runtime_tracing::{create_trace_reader, create_trace_writer, TraceEventsFileFormat};
-use crate::fmt_trace_cmd::FmtTraceCommand;
 mod fmt_trace_cmd;
 
 #[derive(Debug, Clone, Args)]
@@ -50,7 +50,7 @@ fn main() {
             trace_writer.begin_writing_trace_events(Path::new(&convert_command.output_file)).unwrap();
             trace_writer.append_events(&mut trace_events);
             trace_writer.finish_writing_trace_events().unwrap();
-        },
+        }
         RuntimeTracingCliCommand::FormatTrace(fmt_trace_cmd) => {
             fmt_trace_cmd::run(fmt_trace_cmd);
         }

runtime_tracing_cli/src/main.rs

@@ -4,16 +4,13 @@ use std::fs;
 pub fn serialize_file(src_filename: String) -> Value {
     let file_content = fs::read_to_string(src_filename).expect("Failed to read the file");
 
-    serde_json::from_str(&file_content)
-        .expect("Failed to parse the json file that was given as a source")
+    serde_json::from_str(&file_content).expect("Failed to parse the json file that was given as a source")
 }
 
 pub fn save_to_file(dest_filename: String, json_string: String) {
     let mut json_string_copy = json_string.clone();
     if !json_string_copy.ends_with('\n') {
         json_string_copy.push('\n');
     }
-    fs::write(&dest_filename, json_string_copy).unwrap_or_else(|_| {
-        panic!("Unable to write to destination file: {}", dest_filename.as_str())
-    });
+    fs::write(&dest_filename, json_string_copy).unwrap_or_else(|_| panic!("Unable to write to destination file: {}", dest_filename.as_str()));
 }