Apply rustfmt

hashintel · Sep 23, 2024 · f957006 · f957006
1 parent 33d7119
commit f957006
Show file tree

Hide file tree

Showing 23 changed files with 220 additions and 318 deletions.
diff --git a/.rustfmt.toml b/.rustfmt.toml
@@ -1,10 +1,9 @@
 # General
 edition = "2024" # Default: "2015"
 unstable_features = true # Default: false
-version = "Two" # Default: "One"
+style_edition = "2024"
 
 # Settings
-condense_wildcard_suffixes = true # Default: false
 reorder_impl_items = true # Default: false
 use_field_init_shorthand = true # Default: false
 use_try_shorthand = true # Default: false

diff --git a/libs/@blockprotocol/type-system/rust/src/schema/data_type/closed.rs b/libs/@blockprotocol/type-system/rust/src/schema/data_type/closed.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 
-use crate::{schema::DataType, url::VersionedUrl, Valid};
+use crate::{Valid, schema::DataType, url::VersionedUrl};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[cfg_attr(target_arch = "wasm32", derive(tsify::Tsify))]

diff --git a/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/array.rs b/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/array.rs
@@ -1,7 +1,7 @@
 use error_stack::Report;
 use serde_json::Value as JsonValue;
 
-use super::{extend_report, ConstraintError};
+use super::{ConstraintError, extend_report};
 use crate::schema::{DataType, JsonSchemaValueType};
 
 pub(crate) fn check_array_constraints(
@@ -10,12 +10,9 @@ pub(crate) fn check_array_constraints(
     result: &mut Result<(), Report<ConstraintError>>,
 ) {
     if !data_type.json_type.contains(&JsonSchemaValueType::Array) {
-        extend_report!(
-            *result,
-            ConstraintError::InvalidType {
-                actual: JsonSchemaValueType::Array,
-                expected: data_type.json_type.clone()
-            }
-        );
+        extend_report!(*result, ConstraintError::InvalidType {
+            actual: JsonSchemaValueType::Array,
+            expected: data_type.json_type.clone()
+        });
     }
 }
diff --git a/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/boolean.rs b/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/boolean.rs
@@ -1,6 +1,6 @@
 use error_stack::Report;
 
-use super::{extend_report, ConstraintError};
+use super::{ConstraintError, extend_report};
 use crate::schema::{DataType, JsonSchemaValueType};
 
 pub(crate) fn check_boolean_constraints(
@@ -9,12 +9,9 @@ pub(crate) fn check_boolean_constraints(
     result: &mut Result<(), Report<ConstraintError>>,
 ) {
     if !data_type.json_type.contains(&JsonSchemaValueType::Boolean) {
-        extend_report!(
-            *result,
-            ConstraintError::InvalidType {
-                actual: JsonSchemaValueType::Boolean,
-                expected: data_type.json_type.clone()
-            }
-        );
+        extend_report!(*result, ConstraintError::InvalidType {
+            actual: JsonSchemaValueType::Boolean,
+            expected: data_type.json_type.clone()
+        });
     }
 }
diff --git a/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/error.rs b/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/error.rs
@@ -3,10 +3,10 @@ use std::collections::HashSet;
 
 use iso8601_duration::ParseDurationError;
 use regex::Regex;
-use serde_json::{json, Number as JsonNumber, Value as JsonValue};
+use serde_json::{Number as JsonNumber, Value as JsonValue, json};
 use thiserror::Error;
 
-use crate::schema::{data_type::constraint::StringFormat, JsonSchemaValueType};
+use crate::schema::{JsonSchemaValueType, data_type::constraint::StringFormat};
 
 #[derive(Debug, Error)]
 pub enum ConstraintError {

diff --git a/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/mod.rs b/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/mod.rs
@@ -25,5 +25,5 @@ pub(crate) use self::{
     null::check_null_constraints,
     number::check_numeric_constraints,
     object::check_object_constraints,
-    string::{check_string_constraints, StringFormat},
+    string::{StringFormat, check_string_constraints},
 };
diff --git a/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/null.rs b/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/null.rs
@@ -1,19 +1,16 @@
 use error_stack::Report;
 
-use super::{extend_report, ConstraintError};
+use super::{ConstraintError, extend_report};
 use crate::schema::{DataType, JsonSchemaValueType};
 
 pub(crate) fn check_null_constraints(
     data_type: &DataType,
     result: &mut Result<(), Report<ConstraintError>>,
 ) {
     if !data_type.json_type.contains(&JsonSchemaValueType::Null) {
-        extend_report!(
-            *result,
-            ConstraintError::InvalidType {
-                actual: JsonSchemaValueType::Null,
-                expected: data_type.json_type.clone()
-            }
-        );
+        extend_report!(*result, ConstraintError::InvalidType {
+            actual: JsonSchemaValueType::Null,
+            expected: data_type.json_type.clone()
+        });
     }
 }
diff --git a/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/number.rs b/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/number.rs
@@ -1,6 +1,6 @@
 use error_stack::Report;
 
-use super::{extend_report, ConstraintError};
+use super::{ConstraintError, extend_report};
 use crate::schema::{DataType, JsonSchemaValueType};
 
 pub(crate) fn check_numeric_constraints(
@@ -11,22 +11,19 @@ pub(crate) fn check_numeric_constraints(
     if !data_type.json_type.contains(&JsonSchemaValueType::Number)
         && !data_type.json_type.contains(&JsonSchemaValueType::Integer)
     {
-        extend_report!(
-            *result,
-            ConstraintError::InvalidType {
-                actual: JsonSchemaValueType::Number,
-                expected: data_type.json_type.clone()
-            }
-        );
+        extend_report!(*result, ConstraintError::InvalidType {
+            actual: JsonSchemaValueType::Number,
+            expected: data_type.json_type.clone()
+        });
     }
 
     if let Some(expected) = data_type.minimum {
         if data_type.exclusive_minimum {
             if actual <= expected {
-                extend_report!(
-                    *result,
-                    ConstraintError::ExclusiveMinimum { actual, expected }
-                );
+                extend_report!(*result, ConstraintError::ExclusiveMinimum {
+                    actual,
+                    expected
+                });
             }
         } else if actual < expected {
             extend_report!(*result, ConstraintError::Minimum { actual, expected });
@@ -35,10 +32,10 @@ pub(crate) fn check_numeric_constraints(
     if let Some(expected) = data_type.maximum {
         if data_type.exclusive_maximum {
             if actual >= expected {
-                extend_report!(
-                    *result,
-                    ConstraintError::ExclusiveMaximum { actual, expected }
-                );
+                extend_report!(*result, ConstraintError::ExclusiveMaximum {
+                    actual,
+                    expected
+                });
             }
         } else if actual > expected {
             extend_report!(*result, ConstraintError::Maximum { actual, expected });

diff --git a/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/object.rs b/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/object.rs
@@ -1,6 +1,6 @@
 use error_stack::Report;
 
-use super::{extend_report, ConstraintError};
+use super::{ConstraintError, extend_report};
 use crate::schema::{DataType, JsonSchemaValueType};
 
 type JsonObject = serde_json::Map<String, serde_json::Value>;
@@ -11,12 +11,9 @@ pub(crate) fn check_object_constraints(
     result: &mut Result<(), Report<ConstraintError>>,
 ) {
     if !data_type.json_type.contains(&JsonSchemaValueType::Object) {
-        extend_report!(
-            *result,
-            ConstraintError::InvalidType {
-                actual: JsonSchemaValueType::Object,
-                expected: data_type.json_type.clone()
-            }
-        );
+        extend_report!(*result, ConstraintError::InvalidType {
+            actual: JsonSchemaValueType::Object,
+            expected: data_type.json_type.clone()
+        });
     }
 }
diff --git a/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/string.rs b/libs/@blockprotocol/type-system/rust/src/schema/data_type/constraint/string.rs
@@ -12,9 +12,9 @@ use serde::{Deserialize, Serialize};
 use url::{Host, Url};
 use uuid::Uuid;
 
-use super::{extend_report, ConstraintError};
+use super::{ConstraintError, extend_report};
 use crate::schema::{
-    data_type::constraint::error::StringFormatError, DataType, JsonSchemaValueType,
+    DataType, JsonSchemaValueType, data_type::constraint::error::StringFormatError,
 };
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -131,46 +131,34 @@ pub(crate) fn check_string_constraints(
     result: &mut Result<(), Report<ConstraintError>>,
 ) {
     if !data_type.json_type.contains(&JsonSchemaValueType::String) {
-        extend_report!(
-            *result,
-            ConstraintError::InvalidType {
-                actual: JsonSchemaValueType::String,
-                expected: data_type.json_type.clone()
-            }
-        );
+        extend_report!(*result, ConstraintError::InvalidType {
+            actual: JsonSchemaValueType::String,
+            expected: data_type.json_type.clone()
+        });
     }
 
     if let Some(expected) = data_type.min_length {
         if actual.len() < expected {
-            extend_report!(
-                *result,
-                ConstraintError::MinLength {
-                    actual: actual.to_owned(),
-                    expected
-                }
-            );
+            extend_report!(*result, ConstraintError::MinLength {
+                actual: actual.to_owned(),
+                expected
+            });
         }
     }
     if let Some(expected) = data_type.max_length {
         if actual.len() > expected {
-            extend_report!(
-                *result,
-                ConstraintError::MaxLength {
-                    actual: actual.to_owned(),
-                    expected
-                }
-            );
+            extend_report!(*result, ConstraintError::MaxLength {
+                actual: actual.to_owned(),
+                expected
+            });
         }
     }
     if let Some(expected) = &data_type.pattern {
         if !expected.is_match(actual) {
-            extend_report!(
-                *result,
-                ConstraintError::Pattern {
-                    actual: actual.to_owned(),
-                    expected: expected.clone()
-                }
-            );
+            extend_report!(*result, ConstraintError::Pattern {
+                actual: actual.to_owned(),
+                expected: expected.clone()
+            });
         }
     }
     if let Some(expected) = data_type.format {

diff --git a/libs/@blockprotocol/type-system/rust/src/schema/data_type/conversion.rs b/libs/@blockprotocol/type-system/rust/src/schema/data_type/conversion.rs
@@ -258,7 +258,7 @@ mod codec {
 
 #[cfg(test)]
 mod tests {
-    use serde_json::{self, json, Value as JsonValue};
+    use serde_json::{self, Value as JsonValue, json};
 
     use super::*;
 

diff --git a/libs/@blockprotocol/type-system/rust/src/schema/data_type/mod.rs b/libs/@blockprotocol/type-system/rust/src/schema/data_type/mod.rs
@@ -18,16 +18,16 @@ mod validation;
 
 use alloc::sync::Arc;
 use core::{cmp, fmt, mem};
-use std::collections::{hash_map::RawEntryMut, HashMap, HashSet};
+use std::collections::{HashMap, HashSet, hash_map::RawEntryMut};
 
-use error_stack::{bail, Report};
+use error_stack::{Report, bail};
 use regex::Regex;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
 use thiserror::Error;
 
 use crate::{
-    schema::data_type::constraint::{extend_report, ConstraintError, StringFormat},
+    schema::data_type::constraint::{ConstraintError, StringFormat, extend_report},
     url::VersionedUrl,
 };
 
@@ -263,26 +263,20 @@ impl OntologyTypeResolver {
             .raw_entry_mut()
             .from_key(&data_type.id)
             .or_insert_with(|| {
-                (
-                    data_type.id.clone(),
-                    DataTypeCacheEntry {
-                        data_type,
-                        metadata: None,
-                    },
-                )
+                (data_type.id.clone(), DataTypeCacheEntry {
+                    data_type,
+                    metadata: None,
+                })
             });
     }
 
     pub fn add_closed(&mut self, data_type: Arc<DataType>, metadata: Arc<ClosedDataTypeMetadata>) {
         match self.data_types.raw_entry_mut().from_key(&data_type.id) {
             RawEntryMut::Vacant(entry) => {
-                entry.insert(
-                    data_type.id.clone(),
-                    DataTypeCacheEntry {
-                        data_type,
-                        metadata: Some(metadata),
-                    },
-                );
+                entry.insert(data_type.id.clone(), DataTypeCacheEntry {
+                    data_type,
+                    metadata: Some(metadata),
+                });
             }
             RawEntryMut::Occupied(mut entry) => {
                 entry.insert(DataTypeCacheEntry {
@@ -525,23 +519,17 @@ impl DataType {
 
         if let Some(const_value) = &self.const_value {
             if value != const_value {
-                extend_report!(
-                    result,
-                    ConstraintError::Const {
-                        actual: value.clone(),
-                        expected: const_value.clone()
-                    }
-                );
+                extend_report!(result, ConstraintError::Const {
+                    actual: value.clone(),
+                    expected: const_value.clone()
+                });
             }
         }
         if !self.enum_values.is_empty() && !self.enum_values.contains(value) {
-            extend_report!(
-                result,
-                ConstraintError::Enum {
-                    actual: value.clone(),
-                    expected: self.enum_values.clone()
-                }
-            );
+            extend_report!(result, ConstraintError::Enum {
+                actual: value.clone(),
+                expected: self.enum_values.clone()
+            });
         }
 
         match value {
@@ -555,12 +543,9 @@ impl DataType {
                 if let Some(number) = number.as_f64() {
                     constraint::check_numeric_constraints(number, self, &mut result);
                 } else {
-                    extend_report!(
-                        result,
-                        ConstraintError::InsufficientPrecision {
-                            actual: number.clone()
-                        }
-                    );
+                    extend_report!(result, ConstraintError::InsufficientPrecision {
+                        actual: number.clone()
+                    });
                 }
             }
             JsonValue::String(string) => {
@@ -586,11 +571,11 @@ mod tests {
 
     use super::*;
     use crate::{
+        Validator,
         utils::tests::{
-            ensure_failed_deserialization, ensure_failed_validation, ensure_validation,
-            ensure_validation_from_str, JsonEqualityCheck,
+            JsonEqualityCheck, ensure_failed_deserialization, ensure_failed_validation,
+            ensure_validation, ensure_validation_from_str,
         },
-        Validator,
     };
 
     #[tokio::test]