Run rustfmt on generated code

gtk-rs · Mar 1, 2020 · fac4726 · fac4726
1 parent fa5cb13
commit fac4726
Show file tree

Hide file tree

Showing 20 changed files with 240 additions and 129 deletions.
diff --git a/.gitignore b/.gitignore
@@ -2,6 +2,7 @@ target
 /gio
 /gtk
 /src/gir_version.rs
+/.vscode
 tests/gir-files
 tests/sys/*-sys/**
 tests/sys/sys_build/Cargo.lock

diff --git a/README.md b/README.md
@@ -119,6 +119,9 @@ single_version_file = true
 # which do not have an override for `generate_display_trait`
 # (defaults to "true")
 generate_display_trait = true
+# Disable running rustfmt on generated files
+# (defaults to false)
+disable_format = true
 ```
 
 This mode generates only the specified objects. You can either add the object's fullname to the `generate` array or add it to the `manual` array (but in this case, it won't be generated, just used in other functions/methods instead of generating an "ignored" argument). Example:

diff --git a/src/codegen/alias.rs b/src/codegen/alias.rs
@@ -34,23 +34,28 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec<String>) {
     }
 
     let path = root_path.join("alias.rs");
-    file_saver::save_to_file(path, env.config.make_backup, |w| {
-        general::start_comments(w, &env.config)?;
-        writeln!(w)?;
-        writeln!(w, "#[allow(unused_imports)]")?;
-        writeln!(w, "use auto::*;")?;
-        writeln!(w)?;
+    file_saver::save_to_file(
+        path,
+        env.config.make_backup,
+        !env.config.disable_format,
+        |w| {
+            general::start_comments(w, &env.config)?;
+            writeln!(w)?;
+            writeln!(w, "#[allow(unused_imports)]")?;
+            writeln!(w, "use auto::*;")?;
+            writeln!(w)?;
 
-        mod_rs.push("\nmod alias;".into());
-        for config in &configs {
-            if let Type::Alias(ref alias) = *env.library.type_(config.type_id.unwrap()) {
-                mod_rs.push(format!("pub use self::alias::{};", alias.name));
-                generate_alias(env, w, alias, config)?;
+            mod_rs.push("\nmod alias;".into());
+            for config in &configs {
+                if let Type::Alias(ref alias) = *env.library.type_(config.type_id.unwrap()) {
+                    mod_rs.push(format!("pub use self::alias::{};", alias.name));
+                    generate_alias(env, w, alias, config)?;
+                }
             }
-        }
 
-        Ok(())
-    });
+            Ok(())
+        },
+    );
 }
 
 fn generate_alias(env: &Env, w: &mut dyn Write, alias: &Alias, _: &GObject) -> Result<()> {

diff --git a/src/codegen/constants.rs b/src/codegen/constants.rs
@@ -20,34 +20,39 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec<String>) {
     imports.add(sys_crate_name);
     imports.add("std::ffi::CStr");
 
-    file_saver::save_to_file(path, env.config.make_backup, |w| {
-        general::start_comments(w, &env.config)?;
-        general::uses(w, env, &imports)?;
-        writeln!(w)?;
+    file_saver::save_to_file(
+        path,
+        env.config.make_backup,
+        !env.config.disable_format,
+        |w| {
+            general::start_comments(w, &env.config)?;
+            general::uses(w, env, &imports)?;
+            writeln!(w)?;
 
-        mod_rs.push("\nmod constants;".into());
+            mod_rs.push("\nmod constants;".into());
 
-        for constant in &env.analysis.constants {
-            let type_ = env.type_(constant.typ);
-            if let library::Type::Fundamental(library::Fundamental::Utf8) = *type_ {
-                cfg_deprecated(w, env, constant.deprecated_version, false, 0)?;
-                cfg_condition(w, &constant.cfg_condition, false, 0)?;
-                version_condition(w, env, constant.version, false, 0)?;
-                writeln!(
+            for constant in &env.analysis.constants {
+                let type_ = env.type_(constant.typ);
+                if let library::Type::Fundamental(library::Fundamental::Utf8) = *type_ {
+                    cfg_deprecated(w, env, constant.deprecated_version, false, 0)?;
+                    cfg_condition(w, &constant.cfg_condition, false, 0)?;
+                    version_condition(w, env, constant.version, false, 0)?;
+                    writeln!(
                     w,
                     "pub static {name}: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| \
                      unsafe{{CStr::from_ptr({sys_crate_name}::{c_id}).to_str().unwrap()}});",
                     sys_crate_name = sys_crate_name,
                     name = constant.name,
                     c_id = constant.glib_name
                 )?;
-                if let Some(cfg) = version_condition_string(env, constant.version, false, 0) {
-                    mod_rs.push(cfg);
+                    if let Some(cfg) = version_condition_string(env, constant.version, false, 0) {
+                        mod_rs.push(cfg);
+                    }
+                    mod_rs.push(format!("pub use self::constants::{};", constant.name));
                 }
-                mod_rs.push(format!("pub use self::constants::{};", constant.name));
             }
-        }
 
-        Ok(())
-    });
+            Ok(())
+        },
+    );
 }
diff --git a/src/codegen/doc/mod.rs b/src/codegen/doc/mod.rs
@@ -92,9 +92,12 @@ impl_function_like_type!(Signal);
 
 pub fn generate(env: &Env) {
     info!("Generating documentation {:?}", env.config.doc_target_path);
-    save_to_file(&env.config.doc_target_path, env.config.make_backup, |w| {
-        generate_doc(w, env)
-    });
+    save_to_file(
+        &env.config.doc_target_path,
+        env.config.make_backup,
+        false,
+        |w| generate_doc(w, env),
+    );
 }
 
 #[allow(clippy::type_complexity)]

diff --git a/src/codegen/enums.rs b/src/codegen/enums.rs
@@ -73,24 +73,29 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec<String>) {
     }
 
     let path = root_path.join("enums.rs");
-    file_saver::save_to_file(path, env.config.make_backup, |w| {
-        general::start_comments(w, &env.config)?;
-        general::uses(w, env, &imports)?;
-        writeln!(w)?;
+    file_saver::save_to_file(
+        path,
+        env.config.make_backup,
+        !env.config.disable_format,
+        |w| {
+            general::start_comments(w, &env.config)?;
+            general::uses(w, env, &imports)?;
+            writeln!(w)?;
 
-        mod_rs.push("\nmod enums;".into());
-        for config in &configs {
-            if let Type::Enumeration(ref enum_) = *env.library.type_(config.type_id.unwrap()) {
-                if let Some(cfg) = version_condition_string(env, enum_.version, false, 0) {
-                    mod_rs.push(cfg);
+            mod_rs.push("\nmod enums;".into());
+            for config in &configs {
+                if let Type::Enumeration(ref enum_) = *env.library.type_(config.type_id.unwrap()) {
+                    if let Some(cfg) = version_condition_string(env, enum_.version, false, 0) {
+                        mod_rs.push(cfg);
+                    }
+                    mod_rs.push(format!("pub use self::enums::{};", enum_.name));
+                    generate_enum(env, w, enum_, config)?;
                 }
-                mod_rs.push(format!("pub use self::enums::{};", enum_.name));
-                generate_enum(env, w, enum_, config)?;
             }
-        }
 
-        Ok(())
-    });
+            Ok(())
+        },
+    );
 }
 
 fn generate_enum(

diff --git a/src/codegen/flags.rs b/src/codegen/flags.rs
@@ -36,43 +36,48 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec<String>) {
         return;
     }
     let path = root_path.join("flags.rs");
-    file_saver::save_to_file(path, env.config.make_backup, |w| {
-        let mut imports = Imports::new(&env.library);
-        imports.add(env.main_sys_crate_name());
-        imports.add("glib::translate::*");
-
-        for config in &configs {
-            if let Type::Bitfield(ref flags) = *env.library.type_(config.type_id.unwrap()) {
-                if flags.glib_get_type.is_some() {
-                    imports.add("glib::Type");
-                    imports.add("glib::StaticType");
-                    imports.add("glib::value::Value");
-                    imports.add("glib::value::SetValue");
-                    imports.add("glib::value::FromValue");
-                    imports.add("glib::value::FromValueOptional");
-                    imports.add("gobject_sys");
-                    break;
+    file_saver::save_to_file(
+        path,
+        env.config.make_backup,
+        !env.config.disable_format,
+        |w| {
+            let mut imports = Imports::new(&env.library);
+            imports.add(env.main_sys_crate_name());
+            imports.add("glib::translate::*");
+
+            for config in &configs {
+                if let Type::Bitfield(ref flags) = *env.library.type_(config.type_id.unwrap()) {
+                    if flags.glib_get_type.is_some() {
+                        imports.add("glib::Type");
+                        imports.add("glib::StaticType");
+                        imports.add("glib::value::Value");
+                        imports.add("glib::value::SetValue");
+                        imports.add("glib::value::FromValue");
+                        imports.add("glib::value::FromValueOptional");
+                        imports.add("gobject_sys");
+                        break;
+                    }
                 }
             }
-        }
-
-        general::start_comments(w, &env.config)?;
-        general::uses(w, env, &imports)?;
-        writeln!(w)?;
 
-        mod_rs.push("\nmod flags;".into());
-        for config in &configs {
-            if let Type::Bitfield(ref flags) = *env.library.type_(config.type_id.unwrap()) {
-                if let Some(cfg) = version_condition_string(env, flags.version, false, 0) {
-                    mod_rs.push(cfg);
+            general::start_comments(w, &env.config)?;
+            general::uses(w, env, &imports)?;
+            writeln!(w)?;
+
+            mod_rs.push("\nmod flags;".into());
+            for config in &configs {
+                if let Type::Bitfield(ref flags) = *env.library.type_(config.type_id.unwrap()) {
+                    if let Some(cfg) = version_condition_string(env, flags.version, false, 0) {
+                        mod_rs.push(cfg);
+                    }
+                    mod_rs.push(format!("pub use self::flags::{};", flags.name));
+                    generate_flags(env, w, flags, config)?;
                 }
-                mod_rs.push(format!("pub use self::flags::{};", flags.name));
-                generate_flags(env, w, flags, config)?;
             }
-        }
 
-        Ok(())
-    });
+            Ok(())
+        },
+    );
 }
 
 fn generate_flags(env: &Env, w: &mut dyn Write, flags: &Bitfield, config: &GObject) -> Result<()> {

diff --git a/src/codegen/functions.rs b/src/codegen/functions.rs
@@ -15,18 +15,23 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec<String>) {
     };
 
     let path = root_path.join("functions.rs");
-    file_saver::save_to_file(path, env.config.make_backup, |w| {
-        general::start_comments(w, &env.config)?;
-        general::uses(w, env, &functions.imports)?;
+    file_saver::save_to_file(
+        path,
+        env.config.make_backup,
+        !env.config.disable_format,
+        |w| {
+            general::start_comments(w, &env.config)?;
+            general::uses(w, env, &functions.imports)?;
 
-        writeln!(w)?;
+            writeln!(w)?;
 
-        mod_rs.push("\npub mod functions;".into());
+            mod_rs.push("\npub mod functions;".into());
 
-        for func_analysis in &functions.functions {
-            function::generate(w, env, func_analysis, false, false, 0)?;
-        }
+            for func_analysis in &functions.functions {
+                function::generate(w, env, func_analysis, false, false, 0)?;
+            }
 
-        Ok(())
-    });
+            Ok(())
+        },
+    );
 }
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
@@ -57,20 +57,25 @@ fn normal_generate(env: &Env) {
 
 pub fn generate_mod_rs(env: &Env, root_path: &Path, mod_rs: &[String], traits: &[String]) {
     let path = root_path.join("mod.rs");
-    save_to_file(path, env.config.make_backup, |w| {
-        general::start_comments(w, &env.config)?;
-        general::write_vec(w, mod_rs)?;
-        writeln!(w)?;
-        writeln!(w, "#[doc(hidden)]")?;
-        writeln!(w, "pub mod traits {{")?;
-        general::write_vec(w, traits)?;
-        writeln!(w, "}}")
-    });
+    save_to_file(
+        path,
+        env.config.make_backup,
+        !env.config.disable_format,
+        |w| {
+            general::start_comments(w, &env.config)?;
+            general::write_vec(w, mod_rs)?;
+            writeln!(w)?;
+            writeln!(w, "#[doc(hidden)]")?;
+            writeln!(w, "pub mod traits {{")?;
+            general::write_vec(w, traits)?;
+            writeln!(w, "}}")
+        },
+    );
 }
 
 pub fn generate_single_version_file(env: &Env) {
     if let Some(ref path) = env.config.single_version_file {
-        save_to_file(path, env.config.make_backup, |w| {
+        save_to_file(path, env.config.make_backup, false, |w| {
             general::single_version_file(w, &env.config)
         });
     }

diff --git a/src/codegen/objects.rs b/src/codegen/objects.rs
@@ -20,9 +20,12 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec<String>, traits: &
         path.set_extension("rs");
         info!("Generating file {:?}", path);
 
-        save_to_file(path, env.config.make_backup, |ref mut w| {
-            super::object::generate(w, env, class_analysis, generate_display_trait)
-        });
+        save_to_file(
+            path,
+            env.config.make_backup,
+            !env.config.disable_format,
+            |ref mut w| super::object::generate(w, env, class_analysis, generate_display_trait),
+        );
 
         super::object::generate_reexports(env, class_analysis, &mod_name, mod_rs, traits);
     }

diff --git a/src/codegen/records.rs b/src/codegen/records.rs
@@ -19,9 +19,12 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec<String>) {
         path.set_extension("rs");
         info!("Generating file {:?}", path);
 
-        save_to_file(path, env.config.make_backup, |w| {
-            super::record::generate(w, env, record_analysis)
-        });
+        save_to_file(
+            path,
+            env.config.make_backup,
+            !env.config.disable_format,
+            |w| super::record::generate(w, env, record_analysis),
+        );
 
         super::record::generate_reexports(env, record_analysis, &mod_name, mod_rs);
     }

diff --git a/src/codegen/sys/build.rs b/src/codegen/sys/build.rs
@@ -15,9 +15,12 @@ pub fn generate(env: &Env) {
     let path = env.config.target_path.join("build.rs");
 
     info!("Generating file {:?}", path);
-    save_to_file(&path, env.config.make_backup, |w| {
-        generate_build_script(w, env)
-    });
+    save_to_file(
+        &path,
+        env.config.make_backup,
+        !env.config.disable_format,
+        |w| generate_build_script(w, env),
+    );
 }
 
 fn generate_build_script(w: &mut dyn Write, env: &Env) -> Result<()> {

diff --git a/src/codegen/sys/cargo_toml.rs b/src/codegen/sys/cargo_toml.rs
@@ -21,7 +21,7 @@ pub fn generate(env: &Env) -> String {
     }
     fill_in(&mut root_table, env);
 
-    save_to_file(&path, env.config.make_backup, |w| {
+    save_to_file(&path, env.config.make_backup, false, |w| {
         w.write_all(toml::to_string(&root_table).unwrap().as_bytes())
     });
 

diff --git a/src/codegen/sys/lib_.rs b/src/codegen/sys/lib_.rs
@@ -22,7 +22,12 @@ pub fn generate(env: &Env) {
     let path = env.config.auto_path.join(file_name_sys("lib"));
 
     info!("Generating file {:?}", path);
-    save_to_file(&path, env.config.make_backup, |w| generate_lib(w, env));
+    save_to_file(
+        &path,
+        env.config.make_backup,
+        !env.config.disable_format,
+        |w| generate_lib(w, env),
+    );
 }
 
 fn generate_lib(w: &mut dyn Write, env: &Env) -> Result<()> {