Uglify

Signed-off-by: Bob Weinand <[email protected]>

Author: bwoebi

ddcommon-ffi/src/option.rs

@@ -12,7 +12,7 @@ impl<T> Option<T> {
     pub fn to_std(self) -> std::option::Option<T> {
         self.into()
     }
-    
+
     pub fn to_std_ref(&self) -> std::option::Option<&T> {
         match self {
             Option::Some(ref s) => Some(s),

live-debugger-ffi/src/data.rs

@@ -1,13 +1,13 @@
-// Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
-// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present Datadog, Inc.
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache
+// License Version 2.0. This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present Datadog, Inc.
 
+use datadog_live_debugger::debugger_defs::{ProbeMetadata, ProbeMetadataLocation};
 use datadog_live_debugger::{
     Capture, DslString, EvaluateAt, InBodyLocation, MetricKind, ProbeCondition, ProbeValue,
     SpanProbeTarget,
 };
-use datadog_live_debugger::debugger_defs::{ProbeMetadata, ProbeMetadataLocation};
-use ddcommon_ffi::{CharSlice, Option};
 use ddcommon_ffi::slice::AsBytes;
+use ddcommon_ffi::{CharSlice, Option};
 
 #[repr(C)]
 pub struct CharSliceVec<'a> {
@@ -222,8 +222,16 @@ impl<'a> From<&Probe<'a>> for ProbeMetadata<'a> {
         ProbeMetadata {
             id: unsafe { val.id.assume_utf8() }.into(),
             location: ProbeMetadataLocation {
-                method: val.target.method_name.to_std_ref().map(|s| unsafe { s.assume_utf8() }.into()),
-                r#type: val.target.type_name.to_std_ref().map(|s| unsafe { s.assume_utf8() }.into()),
+                method: val
+                    .target
+                    .method_name
+                    .to_std_ref()
+                    .map(|s| unsafe { s.assume_utf8() }.into()),
+                r#type: val
+                    .target
+                    .type_name
+                    .to_std_ref()
+                    .map(|s| unsafe { s.assume_utf8() }.into()),
             },
         }
     }

live-debugger-ffi/src/evaluator.rs

@@ -1,12 +1,12 @@
-// Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
-// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present Datadog, Inc.
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache
+// License Version 2.0. This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present Datadog, Inc.
 
-use std::borrow::Cow;
+use datadog_live_debugger::debugger_defs::SnapshotEvaluationError;
 use datadog_live_debugger::{DslString, ProbeCondition};
+use ddcommon_ffi::slice::AsBytes;
 use ddcommon_ffi::CharSlice;
+use std::borrow::Cow;
 use std::ffi::c_void;
-use ddcommon_ffi::slice::AsBytes;
-use datadog_live_debugger::debugger_defs::SnapshotEvaluationError;
 
 #[repr(C)]
 pub enum IntermediateValue<'a> {
@@ -50,7 +50,7 @@ pub struct Evaluator {
     pub greater_or_equals:
         for<'a> extern "C" fn(&'a mut c_void, IntermediateValue<'a>, IntermediateValue<'a>) -> bool,
     pub fetch_identifier:
-        for<'a, 'b> extern "C" fn(&'a mut c_void, &CharSlice<'b>) -> Option<&'static c_void>, // special values: @duration, @return, @exception
+        for<'a, 'b> extern "C" fn(&'a mut c_void, &CharSlice<'b>) -> Option<&'static c_void>, /* special values: @duration, @return, @exception */
     pub fetch_index: for<'a, 'b> extern "C" fn(
         &'a mut c_void,
         &'a c_void,
@@ -65,7 +65,7 @@ pub struct Evaluator {
     pub try_enumerate: for<'a> extern "C" fn(&'a mut c_void, &'a c_void) -> VoidCollection,
     pub stringify: for<'a> extern "C" fn(&'a mut c_void, &'a c_void) -> CharSlice<'static>,
     pub get_string: for<'a> extern "C" fn(&'a mut c_void, &'a c_void) -> CharSlice<'static>,
-    pub convert_index: for<'a> extern "C" fn(&'a mut c_void, &'a c_void) -> isize, // return < 0 on error
+    pub convert_index: for<'a> extern "C" fn(&'a mut c_void, &'a c_void) -> isize, /* return < 0 on error */
     pub instanceof: for<'a> extern "C" fn(&'a mut c_void, &'a c_void, &CharSlice<'a>) -> bool,
 }
 
@@ -80,33 +80,53 @@ impl<'e> EvalCtx<'e> {
     fn new(context: &'e mut c_void) -> Self {
         EvalCtx {
             context,
-            eval: unsafe { FFI_EVALUATOR.as_ref().unwrap() }
+            eval: unsafe { FFI_EVALUATOR.as_ref().unwrap() },
         }
     }
 }
 
 impl<'e> datadog_live_debugger::Evaluator<'e, c_void> for EvalCtx<'e> {
-    fn equals(&mut self, a: datadog_live_debugger::IntermediateValue<'e, c_void>, b: datadog_live_debugger::IntermediateValue<'e, c_void>) -> bool {
+    fn equals(
+        &mut self,
+        a: datadog_live_debugger::IntermediateValue<'e, c_void>,
+        b: datadog_live_debugger::IntermediateValue<'e, c_void>,
+    ) -> bool {
         (self.eval.equals)(self.context, (&a).into(), (&b).into())
     }
 
-    fn greater_than(&mut self, a: datadog_live_debugger::IntermediateValue<'e, c_void>, b: datadog_live_debugger::IntermediateValue<'e, c_void>) -> bool {
+    fn greater_than(
+        &mut self,
+        a: datadog_live_debugger::IntermediateValue<'e, c_void>,
+        b: datadog_live_debugger::IntermediateValue<'e, c_void>,
+    ) -> bool {
         (self.eval.greater_than)(self.context, (&a).into(), (&b).into())
     }
 
-    fn greater_or_equals(&mut self, a: datadog_live_debugger::IntermediateValue<'e, c_void>, b: datadog_live_debugger::IntermediateValue<'e, c_void>) -> bool {
+    fn greater_or_equals(
+        &mut self,
+        a: datadog_live_debugger::IntermediateValue<'e, c_void>,
+        b: datadog_live_debugger::IntermediateValue<'e, c_void>,
+    ) -> bool {
         (self.eval.greater_or_equals)(self.context, (&a).into(), (&b).into())
     }
 
     fn fetch_identifier(&mut self, identifier: &str) -> Option<&'e c_void> {
         (self.eval.fetch_identifier)(self.context, &CharSlice::from(identifier))
     }
 
-    fn fetch_index(&mut self, value: &'e c_void, index: datadog_live_debugger::IntermediateValue<'e, c_void>) -> Option<&'e c_void> {
+    fn fetch_index(
+        &mut self,
+        value: &'e c_void,
+        index: datadog_live_debugger::IntermediateValue<'e, c_void>,
+    ) -> Option<&'e c_void> {
         (self.eval.fetch_index)(self.context, value, (&index).into())
     }
 
-    fn fetch_nested(&mut self, value: &'e c_void, member: datadog_live_debugger::IntermediateValue<'e, c_void>) -> Option<&'e c_void> {
+    fn fetch_nested(
+        &mut self,
+        value: &'e c_void,
+        member: datadog_live_debugger::IntermediateValue<'e, c_void>,
+    ) -> Option<&'e c_void> {
         (self.eval.fetch_nested)(self.context, value, (&member).into())
     }
 
@@ -119,12 +139,15 @@ impl<'e> datadog_live_debugger::Evaluator<'e, c_void> for EvalCtx<'e> {
         if collection.count < 0 {
             None
         } else {
-            // We need to copy, Vec::from_raw_parts with only free in the allocator would be unstable...
+            // We need to copy, Vec::from_raw_parts with only free in the allocator would be
+            // unstable...
             let mut vec = Vec::with_capacity(collection.count as usize);
-            unsafe { vec.extend_from_slice(std::slice::from_raw_parts(
-                collection.elements as *const &c_void,
-                collection.count as usize,
-            )) };
+            unsafe {
+                vec.extend_from_slice(std::slice::from_raw_parts(
+                    collection.elements as *const &c_void,
+                    collection.count as usize,
+                ))
+            };
             (collection.free)(collection);
             Some(vec)
         }
@@ -162,20 +185,27 @@ pub unsafe extern "C" fn ddog_register_expr_evaluator(eval: &Evaluator) {
 pub enum ConditionEvaluationResult {
     Success,
     Failure,
-    Error(Box<Vec<SnapshotEvaluationError>>)
+    Error(Box<Vec<SnapshotEvaluationError>>),
 }
 
 #[no_mangle]
-pub extern "C" fn ddog_evaluate_condition(condition: &ProbeCondition, context: &mut c_void) -> ConditionEvaluationResult {
+pub extern "C" fn ddog_evaluate_condition(
+    condition: &ProbeCondition,
+    context: &mut c_void,
+) -> ConditionEvaluationResult {
     let mut ctx = EvalCtx::new(context);
     match datadog_live_debugger::eval_condition(&mut ctx, condition) {
         Ok(true) => ConditionEvaluationResult::Success,
         Ok(false) => ConditionEvaluationResult::Failure,
-        Err(error) => ConditionEvaluationResult::Error(Box::new(vec![error]))
+        Err(error) => ConditionEvaluationResult::Error(Box::new(vec![error])),
     }
 }
 
-pub fn ddog_evaluate_string<'a>(condition: &'a DslString, context: &'a mut c_void, errors: &mut Option<Box<Vec<SnapshotEvaluationError>>>) -> Cow<'a, str> {
+pub fn ddog_evaluate_string<'a>(
+    condition: &'a DslString,
+    context: &'a mut c_void,
+    errors: &mut Option<Box<Vec<SnapshotEvaluationError>>>,
+) -> Cow<'a, str> {
     let mut ctx = EvalCtx::new(context);
     let (result, new_errors) = datadog_live_debugger::eval_string(&mut ctx, condition);
     if !new_errors.is_empty() {

live-debugger-ffi/src/lib.rs

@@ -1,5 +1,5 @@
-// Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
-// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present Datadog, Inc.
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache
+// License Version 2.0. This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present Datadog, Inc.
 
 pub mod data;
 pub mod evaluator;

live-debugger-ffi/src/parse.rs

@@ -1,3 +1,6 @@
+// Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
 use crate::data::LiveDebuggingData;
 use ddcommon_ffi::slice::AsBytes;
 use ddcommon_ffi::CharSlice;
@@ -15,7 +18,8 @@ pub extern "C" fn ddog_parse_live_debugger_json(json: CharSlice) -> LiveDebuggin
     {
         let parsed = Box::new(parsed);
         LiveDebuggingParseResult {
-            // we have the box. Rust doesn't allow us to specify a self-referential struct, so pretend it's 'static
+            // we have the box. Rust doesn't allow us to specify a self-referential struct, so
+            // pretend it's 'static
             data: unsafe {
                 std::mem::transmute::<&_, &'static datadog_live_debugger::LiveDebuggingData>(
                     &*parsed,