fix: formatting in baml- and language_client_

BoundaryML · Oct 21, 2024 · 709ae7d · 709ae7d
1 parent af04c3e
commit 709ae7d
Show file tree

Hide file tree

Showing 31 changed files with 200 additions and 142 deletions.
diff --git a/engine/baml-lib/baml-core/src/ir/json_schema.rs b/engine/baml-lib/baml-core/src/ir/json_schema.rs
@@ -3,9 +3,7 @@
 use baml_types::TypeValue;
 use serde_json::json;
 
-use super::{
-    Class, Enum, FieldType, FunctionArgs, FunctionNode, IntermediateRepr, Walker,
-};
+use super::{Class, Enum, FieldType, FunctionArgs, FunctionNode, IntermediateRepr, Walker};
 
 pub trait WithJsonSchema {
     fn json_schema(&self) -> serde_json::Value;

diff --git a/engine/baml-lib/jinja-runtime/src/output_format/mod.rs b/engine/baml-lib/jinja-runtime/src/output_format/mod.rs
@@ -103,9 +103,7 @@ impl minijinja::value::Object for OutputFormat {
                 Err(e) => {
                     return Err(Error::new(
                         ErrorKind::SyntaxError,
-                        format!(
-                            "Invalid value for always_hoist_enums (expected bool): {e}"
-                        ),
+                        format!("Invalid value for always_hoist_enums (expected bool): {e}"),
                     ))
                 }
             }

diff --git a/engine/baml-lib/jinja/src/evaluate_type/mod.rs b/engine/baml-lib/jinja/src/evaluate_type/mod.rs
@@ -98,9 +98,7 @@ impl TypeError {
         } else {
             // If there are multiple close names, suggest them all
             let suggestions = close_names.join("`, `");
-            format!(
-                "Variable `{name}` does not exist. Did you mean one of these: `{suggestions}`?"
-            )
+            format!("Variable `{name}` does not exist. Did you mean one of these: `{suggestions}`?")
         };
 
         Self { message, span }
@@ -135,9 +133,7 @@ impl TypeError {
 
     fn new_wrong_arg_count(func: &str, span: Span, expected: usize, got: usize) -> Self {
         Self {
-            message: format!(
-                "Function '{func}' expects {expected} arguments, but got {got}"
-            ),
+            message: format!("Function '{func}' expects {expected} arguments, but got {got}"),
             span,
         }
     }
@@ -185,9 +181,7 @@ impl TypeError {
         } else {
             // If there are multiple close names, suggest them all
             let suggestions = close_names.join("', '");
-            format!(
-                "Filter '{name}' does not exist. Did you mean one of these: '{suggestions}'?"
-            )
+            format!("Filter '{name}' does not exist. Did you mean one of these: '{suggestions}'?")
         };
 
         Self { message: format!("{message}\n\nSee: https://docs.rs/minijinja/latest/minijinja/filters/index.html#functions for the compelete list"), span }

diff --git a/engine/baml-lib/jsonish/src/deserializer/coercer/array_helper.rs b/engine/baml-lib/jsonish/src/deserializer/coercer/array_helper.rs
@@ -1,4 +1,3 @@
-
 use crate::deserializer::{deserialize_flags::Flag, types::BamlValueWithFlags};
 use anyhow::Result;
 use internal_baml_core::ir::FieldType;

diff --git a/engine/baml-lib/jsonish/src/jsonish/iterative_parser.rs b/engine/baml-lib/jsonish/src/jsonish/iterative_parser.rs
@@ -215,9 +215,7 @@ impl JsonParseState {
                 }
                 _ => {
                     // TODO: this should never happen as we should only be pushing objects and arrays
-                    panic!(
-                        "Unexpected value: {value:?} in collection stack: {last:?}"
-                    );
+                    panic!("Unexpected value: {value:?} in collection stack: {last:?}");
                 }
             }
         } else {

diff --git a/engine/baml-lib/jsonish/src/jsonish/parser/fixing_parser.rs b/engine/baml-lib/jsonish/src/jsonish/parser/fixing_parser.rs
@@ -96,7 +96,7 @@ pub fn parse<'a>(str: &'a str, _options: &ParseOptions) -> Result<Vec<(Value, Ve
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::jsonish::{Value, ParseOptions};
+    use crate::jsonish::{ParseOptions, Value};
 
     #[test]
     fn test_partial_array() {
@@ -117,7 +117,6 @@ mod tests {
             }
             _ => panic!("Expected array"),
         }
-
     }
 
     #[test]
@@ -135,10 +134,10 @@ mod tests {
                         assert_eq!(a, &serde_json::Number::from(11));
                         assert_eq!(b, &serde_json::Number::from(22));
                     }
-                    _ => panic!("Expected two numbers.")
+                    _ => panic!("Expected two numbers."),
                 }
             }
-            _ => panic!("Expected object")
+            _ => panic!("Expected object"),
         }
     }
 
@@ -157,10 +156,10 @@ mod tests {
                         assert_eq!(a, &serde_json::Number::from(11));
                         assert_eq!(b, &serde_json::Number::from(22));
                     }
-                    _ => panic!("Expected two numbers.")
+                    _ => panic!("Expected two numbers."),
                 }
             }
-            _ => panic!("Expected object")
+            _ => panic!("Expected object"),
         }
     }
 }
diff --git a/engine/baml-lib/jsonish/src/jsonish/parser/fixing_parser/json_collection.rs b/engine/baml-lib/jsonish/src/jsonish/parser/fixing_parser/json_collection.rs
@@ -1,4 +1,3 @@
-
 use crate::jsonish::Value;
 
 #[derive(Debug)]

diff --git a/engine/baml-lib/jsonish/src/jsonish/parser/fixing_parser/json_parse_state.rs b/engine/baml-lib/jsonish/src/jsonish/parser/fixing_parser/json_parse_state.rs
@@ -51,9 +51,7 @@ impl JsonParseState {
                 }
                 _ => {
                     // TODO: this should never happen as we should only be pushing objects and arrays
-                    panic!(
-                        "Unexpected value: {value:?} in collection stack: {last:?}"
-                    );
+                    panic!("Unexpected value: {value:?} in collection stack: {last:?}");
                 }
             }
         } else {

diff --git a/engine/baml-lib/jsonish/src/jsonish/value.rs b/engine/baml-lib/jsonish/src/jsonish/value.rs
@@ -1,6 +1,5 @@
 use std::collections::HashSet;
 
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Fixes {
     GreppedForJSON,

diff --git a/engine/baml-lib/jsonish/src/tests/mod.rs b/engine/baml-lib/jsonish/src/tests/mod.rs
@@ -698,7 +698,7 @@ fn singleton_list_int_deleted() {
     let output_format = OutputFormatContent::new(Vec::new(), Vec::new(), target.clone());
     let res = from_str(&output_format, &target, "[123", true).expect("Can parse");
     let baml_value: BamlValue = res.into();
-    assert_eq!(baml_value, BamlValue::List( vec![] ));
+    assert_eq!(baml_value, BamlValue::List(vec![]));
 }
 
 #[test]
@@ -710,7 +710,7 @@ fn list_int_deleted() {
     let output_format = OutputFormatContent::new(Vec::new(), Vec::new(), target.clone());
     let res = from_str(&output_format, &target, "[123, 456", true).expect("Can parse");
     let baml_value: BamlValue = res.into();
-    assert_eq!(baml_value, BamlValue::List( vec![ BamlValue::Int(123)] ));
+    assert_eq!(baml_value, BamlValue::List(vec![BamlValue::Int(123)]));
 }
 
 #[test]
@@ -722,7 +722,10 @@ fn list_int_not_deleted() {
     let output_format = OutputFormatContent::new(Vec::new(), Vec::new(), target.clone());
     let res = from_str(&output_format, &target, "[123, 456 // Done", true).expect("Can parse");
     let baml_value: BamlValue = res.into();
-    assert_eq!(baml_value, BamlValue::List( vec![ BamlValue::Int(123), BamlValue::Int(456)] ));
+    assert_eq!(
+        baml_value,
+        BamlValue::List(vec![BamlValue::Int(123), BamlValue::Int(456)])
+    );
 }
 
 #[test]

diff --git a/engine/baml-lib/parser-database/src/attributes/mod.rs b/engine/baml-lib/parser-database/src/attributes/mod.rs
@@ -63,7 +63,6 @@ impl Attributes {
     pub fn set_skip(&mut self) {
         self.skip.replace(true);
     }
-
 }
 pub(super) fn resolve_attributes(ctx: &mut Context<'_>) {
     for top in ctx.ast.iter_tops() {

diff --git a/engine/baml-lib/prompt-parser/src/parser/parse_prompt.rs b/engine/baml-lib/prompt-parser/src/parser/parse_prompt.rs
@@ -97,9 +97,7 @@ pub fn parse_prompt(
         }
         Err(err) => {
             diagnostics.push_error(DatamodelError::new_parser_error(
-                format!(
-                    "Unabled to parse this raw string. Please file a bug.\n{err}"
-                ),
+                format!("Unabled to parse this raw string. Please file a bug.\n{err}"),
                 raw_string.span().clone(),
             ));
             Err(diagnostics)

diff --git a/engine/baml-lib/schema-ast/src/ast/attribute.rs b/engine/baml-lib/schema-ast/src/ast/attribute.rs
@@ -36,8 +36,7 @@ impl Attribute {
     pub fn assert_eq_up_to_span(&self, other: &Attribute) {
         assert_eq!(self.name.to_string(), other.name.to_string());
         assert_eq!(self.parenthesized, other.parenthesized);
-        self
-            .arguments
+        self.arguments
             .iter()
             .zip(other.arguments.iter())
             .for_each(|(arg1, arg2)| {

diff --git a/engine/baml-lib/schema-ast/src/ast/expression.rs b/engine/baml-lib/schema-ast/src/ast/expression.rs
@@ -1,4 +1,3 @@
-
 use crate::ast::Span;
 use std::fmt;
 
@@ -191,7 +190,6 @@ impl fmt::Display for Expression {
 }
 
 impl Expression {
-
     pub fn from_json(value: serde_json::Value, span: Span, empty_span: Span) -> Expression {
         match value {
             serde_json::Value::Null => Expression::StringValue("Null".to_string(), empty_span),
@@ -343,30 +341,31 @@ impl Expression {
     pub fn assert_eq_up_to_span(&self, other: &Expression) {
         use Expression::*;
         match (self, other) {
-            (BoolValue(v1,_), BoolValue(v2,_)) => assert_eq!(v1,v2),
-            (BoolValue(_,_), _) => panic!("Types do not match: {self:?} and {other:?}"),
-            (NumericValue(n1,_), NumericValue(n2,_)) => assert_eq!(n1, n2),
-            (NumericValue(_,_), _) => panic!("Types do not match: {self:?} and {other:?}"),
-            (Identifier(i1), Identifier(i2)) => assert_eq!(i1,i2),
+            (BoolValue(v1, _), BoolValue(v2, _)) => assert_eq!(v1, v2),
+            (BoolValue(_, _), _) => panic!("Types do not match: {self:?} and {other:?}"),
+            (NumericValue(n1, _), NumericValue(n2, _)) => assert_eq!(n1, n2),
+            (NumericValue(_, _), _) => panic!("Types do not match: {self:?} and {other:?}"),
+            (Identifier(i1), Identifier(i2)) => assert_eq!(i1, i2),
             (Identifier(_), _) => panic!("Types do not match: {self:?} and {other:?}"),
-            (StringValue(s1,_), StringValue(s2,_)) => assert_eq!(s1, s2),
-            (StringValue(_,_), _) => panic!("Types do not match: {self:?} and {other:?}"),
+            (StringValue(s1, _), StringValue(s2, _)) => assert_eq!(s1, s2),
+            (StringValue(_, _), _) => panic!("Types do not match: {self:?} and {other:?}"),
             (RawStringValue(s1), RawStringValue(s2)) => s1.assert_eq_up_to_span(s2),
             (RawStringValue(_), _) => panic!("Types do not match: {self:?} and {other:?}"),
-            (Array(xs,_), Array(ys,_)) => {
+            (Array(xs, _), Array(ys, _)) => {
                 assert_eq!(xs.len(), ys.len());
-                xs.iter().zip(ys).for_each(|(x,y)| { x.assert_eq_up_to_span(y); })
-            },
-            (Array(_,_), _) => panic!("Types do not match: {self:?} and {other:?}"),
-            (Map(m1,_), Map(m2,_)) => {
+                xs.iter().zip(ys).for_each(|(x, y)| {
+                    x.assert_eq_up_to_span(y);
+                })
+            }
+            (Array(_, _), _) => panic!("Types do not match: {self:?} and {other:?}"),
+            (Map(m1, _), Map(m2, _)) => {
                 assert_eq!(m1.len(), m2.len());
                 m1.iter().zip(m2).for_each(|((k1, v1), (k2, v2))| {
                     k1.assert_eq_up_to_span(k2);
                     v1.assert_eq_up_to_span(v2);
                 });
-            },
-            (Map(_,_), _) => panic!("Types do not match: {self:?} and {other:?}"),
-
+            }
+            (Map(_, _), _) => panic!("Types do not match: {self:?} and {other:?}"),
         }
     }
 }
diff --git a/engine/baml-lib/schema-ast/src/ast/identifier.rs b/engine/baml-lib/schema-ast/src/ast/identifier.rs
@@ -69,16 +69,16 @@ impl Identifier {
     pub fn assert_eq_up_to_span(&self, other: &Identifier) {
         use Identifier::*;
         match (self, other) {
-            (ENV(e1,_), ENV(e2, _)) => assert_eq!(e1, e2),
-            (ENV(_,_), _) => panic!("Mismatched identifiers: {self:?}, {other:?}"),
-            (Local(l1,_), Local(l2,_)) => assert_eq!(l1, l2),
-            (Local(_,_), _) => panic!("Mismatched identifiers: {self:?}, {other:?}"),
-            (Ref(r1,_), Ref(r2,_)) => assert_eq!(r1, r2),
-            (Ref(_,_), _) => panic!("Mismatched identifiers: {self:?}, {other:?}"),
-            (Identifier::String(s1,_), Identifier::String(s2,_)) => assert_eq!(s1,s2),
-            (Identifier::String(_,_), _) => panic!("Mismatched identifiers: {self:?}, {other:?}"),
-            (Invalid(i1,_), Invalid(i2,_)) => assert_eq!(i1,i2),
-            (Invalid(_,_), _) => panic!("Mismatched identifiers: {self:?}, {other:?}"),
+            (ENV(e1, _), ENV(e2, _)) => assert_eq!(e1, e2),
+            (ENV(_, _), _) => panic!("Mismatched identifiers: {self:?}, {other:?}"),
+            (Local(l1, _), Local(l2, _)) => assert_eq!(l1, l2),
+            (Local(_, _), _) => panic!("Mismatched identifiers: {self:?}, {other:?}"),
+            (Ref(r1, _), Ref(r2, _)) => assert_eq!(r1, r2),
+            (Ref(_, _), _) => panic!("Mismatched identifiers: {self:?}, {other:?}"),
+            (Identifier::String(s1, _), Identifier::String(s2, _)) => assert_eq!(s1, s2),
+            (Identifier::String(_, _), _) => panic!("Mismatched identifiers: {self:?}, {other:?}"),
+            (Invalid(i1, _), Invalid(i2, _)) => assert_eq!(i1, i2),
+            (Invalid(_, _), _) => panic!("Mismatched identifiers: {self:?}, {other:?}"),
         }
     }
 }

diff --git a/engine/baml-lib/schema-ast/src/parser/parse_field.rs b/engine/baml-lib/schema-ast/src/parser/parse_field.rs
@@ -78,14 +78,16 @@ pub(crate) fn parse_type_expr(
         match current.as_rule() {
             Rule::identifier => {
                 name = Some(parse_identifier(current, diagnostics));
-            },
+            }
             Rule::trailing_comment => {
                 comment = merge_comments(comment, parse_trailing_comment(current));
             }
             Rule::field_type_chain => {
-                    field_type = parse_field_type_chain(current, diagnostics);
+                field_type = parse_field_type_chain(current, diagnostics);
+            }
+            Rule::field_attribute => {
+                field_attributes.push(parse_attribute(current, false, diagnostics))
             }
-            Rule::field_attribute => field_attributes.push(parse_attribute(current, false, diagnostics)),
             _ => parsing_catch_all(current, "field"),
         }
     }
@@ -178,8 +180,7 @@ pub(crate) fn parse_field_type_with_attr(
                     //     ft.set_attributes(attributes.clone()); // Clone the borrowed `Vec<Attribute>`
                     // }
                 }
-                _ => {
-                }
+                _ => {}
             }
             ft.extend_attributes(field_attributes);
 
@@ -252,7 +253,10 @@ mod tests {
         let result = parse_field_type_chain(parsed, &mut diagnostics).unwrap();
         if let FieldType::Union(_, types, _, _) = &result {
             assert_eq!(types[1].clone().attributes().len(), 1);
-            assert_eq!(types[1].clone().attributes()[0].name.to_string().as_str(), "description");
+            assert_eq!(
+                types[1].clone().attributes()[0].name.to_string().as_str(),
+                "description"
+            );
         } else {
             panic!("Expected union");
         }

diff --git a/engine/baml-lib/schema-ast/src/parser/parse_type_expression_block.rs b/engine/baml-lib/schema-ast/src/parser/parse_type_expression_block.rs
@@ -120,7 +120,7 @@ mod tests {
     use super::*;
     use crate::parser::{BAMLParser, Rule};
     use internal_baml_diagnostics::{Diagnostics, SourceFile};
-    use pest::{Parser, consumes_to, fails_with, parses_to};
+    use pest::{consumes_to, fails_with, parses_to, Parser};
 
     #[test]
     fn keyword_name_mandatory_whitespace() {

diff --git a/engine/baml-lib/schema-ast/src/parser/parse_value_expression_block.rs b/engine/baml-lib/schema-ast/src/parser/parse_value_expression_block.rs
@@ -42,10 +42,12 @@ pub(crate) fn parse_value_expression_block(
                 Ok(arg) => input = Some(arg),
                 Err(err) => diagnostics.push_error(err),
             },
-            Rule::field_type | Rule::field_type_chain => match parse_function_arg(current, diagnostics) {
-                Ok(arg) => output = Some(arg),
-                Err(err) => diagnostics.push_error(err),
-            },
+            Rule::field_type | Rule::field_type_chain => {
+                match parse_function_arg(current, diagnostics) {
+                    Ok(arg) => output = Some(arg),
+                    Err(err) => diagnostics.push_error(err),
+                }
+            }
             Rule::BLOCK_OPEN | Rule::BLOCK_CLOSE => {}
 
             Rule::value_expression_contents => {

diff --git a/engine/baml-runtime/src/cli/serve/mod.rs b/engine/baml-runtime/src/cli/serve/mod.rs
@@ -615,16 +615,23 @@ Tip: test that the server is up using `curl http://localhost:{}/_debug/ping`
             true,
             GeneratorDefaultClientMode::Sync,
             Vec::new(),
-        ).map_err(|_| BamlError::InternalError{ message: "Failed to make placeholder generator".to_string()})?;
+        )
+        .map_err(|_| BamlError::InternalError {
+            message: "Failed to make placeholder generator".to_string(),
+        })?;
         let schema: OpenApiSchema = (locked.inner.ir.as_ref(), &fake_generator)
             .try_into()
             .map_err(|e| {
                 log::warn!("Failed to generate openapi schema: {}", e);
-                BamlError::InternalError{ message: format!("Failed to generate openapi schema")}
+                BamlError::InternalError {
+                    message: format!("Failed to generate openapi schema"),
+                }
             })?;
         serde_json::to_string(&schema).map_err(|e| {
             log::warn!("Failed to serialize openapi schema: {}", e);
-            BamlError::InternalError{ message: format!("Failed to serialize openapi schema") }
+            BamlError::InternalError {
+                message: format!("Failed to serialize openapi schema"),
+            }
         })
     }
 }

diff --git a/engine/baml-runtime/src/internal/llm_client/orchestrator/call.rs b/engine/baml-runtime/src/internal/llm_client/orchestrator/call.rs
@@ -39,7 +39,11 @@ pub async fn orchestrate(
         let prompt = match node.render_prompt(ir, prompt, ctx, params).await {
             Ok(p) => p,
             Err(e) => {
-                results.push((node.scope, LLMResponse::InternalFailure(e.to_string()), None));
+                results.push((
+                    node.scope,
+                    LLMResponse::InternalFailure(e.to_string()),
+                    None,
+                ));
                 continue;
             }
         };