Cargo fmt

Author: tom-leys

bindings_generator/src/api.rs

@@ -1,5 +1,5 @@
-use std::collections::{HashMap, HashSet};
 use serde_json;
+use std::collections::{HashMap, HashSet};
 
 pub struct Api {
     pub classes: Vec<GodotClass>,
@@ -9,7 +9,8 @@ pub struct Api {
 impl Api {
     pub fn new() -> Self {
         let mut api = Api {
-            classes: serde_json::from_slice(get_api_json()).expect("Failed to parse the API description"),
+            classes: serde_json::from_slice(get_api_json())
+                .expect("Failed to parse the API description"),
             api_underscore: Default::default(),
         };
 
@@ -74,9 +75,13 @@ pub struct GodotClass {
 }
 
 impl GodotClass {
-    pub fn is_refcounted(&self) -> bool { self.is_reference || &self.name == "Reference" }
+    pub fn is_refcounted(&self) -> bool {
+        self.is_reference || &self.name == "Reference"
+    }
 
-    pub fn is_pointer_safe(&self) -> bool { self.is_refcounted() || self.singleton }
+    pub fn is_pointer_safe(&self) -> bool {
+        self.is_refcounted() || self.singleton
+    }
 }
 
 #[derive(Deserialize, Debug)]
@@ -207,9 +212,7 @@ impl Ty {
                 let name = split.next().unwrap();
                 Ty::Enum(format!("{}{}", class, name))
             }
-            ty => {
-                Ty::Object(ty.into())
-            },
+            ty => Ty::Object(ty.into()),
         }
     }
 
@@ -286,6 +289,10 @@ impl Ty {
     }
 }
 
-pub fn get_api_json() -> &'static [u8] { include_bytes!("../api.json") }
+pub fn get_api_json() -> &'static [u8] {
+    include_bytes!("../api.json")
+}
 
-pub fn get_namespaces_json() -> &'static [u8] { include_bytes!("../namespaces.json") }
+pub fn get_namespaces_json() -> &'static [u8] {
+    include_bytes!("../namespaces.json")
+}

bindings_generator/src/classes.rs

@@ -1,15 +1,16 @@
 use crate::api::*;
-use std::io::Write;
 use crate::GeneratorResult;
 use heck::CamelCase;
+use std::io::Write;
 
 pub fn generate_class_struct(output: &mut impl Write, class: &GodotClass) -> GeneratorResult {
     if !class.is_refcounted() {
         writeln!(output, "#[derive(Copy, Clone)]")?;
     }
 
-    writeln!(output,
-r#"#[allow(non_camel_case_types)]
+    writeln!(
+        output,
+        r#"#[allow(non_camel_case_types)]
 #[derive(Debug)]
 pub struct {name} {{
     #[doc(hidden)]
@@ -28,14 +29,16 @@ pub fn generate_enum(output: &mut impl Write, class: &GodotClass, e: &Enum) -> G
     // it. For example ImageFormat::Rgb8 instead of ImageFormat::FormatRgb8.
 
     let mut values: Vec<(&String, &u32)> = e.values.iter().collect();
-    values.sort_by(|a, b|{ a.1.cmp(&b.1) });
+    values.sort_by(|a, b| a.1.cmp(&b.1));
 
-    writeln!(output,
-r#"#[repr(u32)]
+    writeln!(
+        output,
+        r#"#[repr(u32)]
 #[allow(non_camel_case_types)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum {class_name}{enum_name} {{"#,
-        class_name = class.name, enum_name = e.name
+        class_name = class.name,
+        enum_name = e.name
     )?;
 
     for &(key, val) in &values {
@@ -60,9 +63,14 @@ pub enum {class_name}{enum_name} {{"#,
 
 fn try_remove_prefix(key: &str, prefix: &str) -> Option<String> {
     let key_lower = key.to_lowercase();
-    if key_lower.starts_with(prefix) && !key.chars().nth(prefix.len()).map_or(true, |c| c.is_numeric()) {
+    if key_lower.starts_with(prefix)
+        && !key
+            .chars()
+            .nth(prefix.len())
+            .map_or(true, |c| c.is_numeric())
+    {
         return Some(key[prefix.len()..].to_string());
     }
 
     None
-}
+}

bindings_generator/src/dependency.rs

@@ -15,18 +15,14 @@ pub fn strongly_connected_components(
 ) -> HashSet<String> {
     let mut visited = visited.unwrap_or_default();
 
-    if let Some(class)  = api.find_class(class) {
+    if let Some(class) = api.find_class(class) {
         visit(api, class, &mut visited);
     }
 
     visited
 }
 
-fn visit(
-    api: &Api,
-    class: &GodotClass,
-    visited: &mut HashSet<String>,
-) {
+fn visit(api: &Api, class: &GodotClass, visited: &mut HashSet<String>) {
     visited.insert(class.name.clone());
 
     let mut to_visit = HashSet::new();
@@ -45,11 +41,7 @@ fn visit(
     }
 }
 
-
-fn base_classes(
-    api: &Api,
-    class: &GodotClass,
-) -> HashSet<String> {
+fn base_classes(api: &Api, class: &GodotClass) -> HashSet<String> {
     let mut bases = HashSet::new();
 
     if class.base_class.is_empty() {
@@ -64,10 +56,7 @@ fn base_classes(
     }
 }
 
-fn referenced_classes(
-    api: &Api,
-    class: &GodotClass
-) -> HashSet<String> {
+fn referenced_classes(api: &Api, class: &GodotClass) -> HashSet<String> {
     let mut classes = HashSet::new();
 
     for method in &class.methods {
@@ -84,4 +73,4 @@ fn referenced_classes(
     }
 
     classes
-}
+}

bindings_generator/src/documentation.rs

@@ -1,6 +1,6 @@
 use crate::api::*;
-use std::io::Write;
 use crate::GeneratorResult;
+use std::io::Write;
 
 pub fn class_doc_link(class: &GodotClass) -> String {
     // TODO: link the correct crate
@@ -15,51 +15,69 @@ pub fn official_doc_url(class: &GodotClass) -> String {
     )
 }
 
-pub fn generate_class_documentation(output: &mut impl Write, api: &Api, class: &GodotClass) -> GeneratorResult {
-        let has_parent = class.base_class != "";
-        let singleton_str = if class.singleton { "singleton " } else { "" } ;
-        let ownership_type = if class.is_refcounted() { "reference counted" } else { "unsafe" };
-        if &class.name == "Reference" {
-            writeln!(output, "/// Base class of all reference-counted types. Inherits `Object`.")?;
-        } else if &class.name == "Object" {
-            writeln!(output, "/// The base class of most Godot classes.")?;
-        } else if has_parent {
-            writeln!(output, r#"
+pub fn generate_class_documentation(
+    output: &mut impl Write,
+    api: &Api,
+    class: &GodotClass,
+) -> GeneratorResult {
+    let has_parent = class.base_class != "";
+    let singleton_str = if class.singleton { "singleton " } else { "" };
+    let ownership_type = if class.is_refcounted() {
+        "reference counted"
+    } else {
+        "unsafe"
+    };
+    if &class.name == "Reference" {
+        writeln!(
+            output,
+            "/// Base class of all reference-counted types. Inherits `Object`."
+        )?;
+    } else if &class.name == "Object" {
+        writeln!(output, "/// The base class of most Godot classes.")?;
+    } else if has_parent {
+        writeln!(
+            output,
+            r#"
 /// `{api_type} {singleton}class {name}` inherits `{base_class}` ({ownership_type})."#,
-                api_type = class.api_type,
-                name = class.name,
-                base_class = class.base_class,
-                ownership_type = ownership_type,
-                singleton = singleton_str
-            )?;
-        } else {
-            writeln!(output, r#"
+            api_type = class.api_type,
+            name = class.name,
+            base_class = class.base_class,
+            ownership_type = ownership_type,
+            singleton = singleton_str
+        )?;
+    } else {
+        writeln!(
+            output,
+            r#"
 /// `{api_type} {singleton}class {name}` ({ownership_type})."#,
-                api_type = class.api_type,
-                name = class.name,
-                ownership_type = ownership_type,
-                singleton = singleton_str
-            )?;
-        }
+            api_type = class.api_type,
+            name = class.name,
+            ownership_type = ownership_type,
+            singleton = singleton_str
+        )?;
+    }
 
-        writeln!(output,
-r#"///
+    writeln!(
+        output,
+        r#"///
 /// ## Official documentation
 ///
 /// See the [documentation of this class]({url}) in the Godot engine's official documentation."#,
-            url = official_doc_url(class),
-        )?;
+        url = official_doc_url(class),
+    )?;
 
-        if class.is_refcounted() {
-            writeln!(output,
-r#"///
+    if class.is_refcounted() {
+        writeln!(
+            output,
+            r#"///
 /// ## Memory management
 ///
 /// The lifetime of this object is automatically managed through reference counting."#
-            )?;
-        } else if class.instanciable {
-            writeln!(output,
-r#"///
+        )?;
+    } else if class.instanciable {
+        writeln!(
+            output,
+            r#"///
 /// ## Memory management
 ///
 /// Non reference counted objects such as the ones of this type are usually owned by the engine.
@@ -69,43 +87,37 @@ r#"///
 /// In the cases where Rust code owns an object of this type, for example if the object was just
 /// created on the Rust side and not passed to the engine yet, ownership should be either given
 /// to the engine or the object must be manually destroyed using `{name}::free`."#,
-                name = class.name
-            )?;
-        }
+            name = class.name
+        )?;
+    }
 
-        if class.base_class != "" {
-            writeln!(output,
-r#"///
+    if class.base_class != "" {
+        writeln!(
+            output,
+            r#"///
 /// ## Class hierarchy
 ///
 /// {name} inherits methods from:"#,
-                name = class.name,
-            )?;
+            name = class.name,
+        )?;
 
-            list_base_classes(
-                output,
-                api,
-                &class.base_class,
-            )?;
-        }
+        list_base_classes(output, api, &class.base_class)?;
+    }
 
-        if class.api_type == "tools" {
-            writeln!(output,
-r#"///
+    if class.api_type == "tools" {
+        writeln!(
+            output,
+            r#"///
 /// ## Tool
 ///
 /// This class is used to interact with Godot's editor."#,
-            )?;
-        }
+        )?;
+    }
 
-        Ok(())
+    Ok(())
 }
 
-fn list_base_classes(
-    output: &mut impl Write,
-    api: &Api,
-    parent_name: &str,
-) -> GeneratorResult {
+fn list_base_classes(output: &mut impl Write, api: &Api, parent_name: &str) -> GeneratorResult {
     if let Some(parent) = api.find_class(parent_name) {
         let class_link = class_doc_link(&parent);