Merge pull request #1701 from marc2332/feat/inline-attributes-fmt

jkelleyrtp · web-flow · commit 18a56bf62c18 · 2024-01-08T20:19:39.000-08:00
feat: `--split-line-attributes` parameter for CLI `fmt`
diff --git a/packages/autofmt/src/component.rs b/packages/autofmt/src/component.rs
@@ -67,7 +67,7 @@ impl Writer<'_> {
         }
 
         // multiline handlers bump everything down
-        if attr_len > 1000 {
+        if attr_len > 1000 || self.out.indent.split_line_attributes() {
             opt_level = ShortOptimization::NoOpt;
         }
 
@@ -158,7 +158,7 @@ impl Writer<'_> {
 
         while let Some(field) = field_iter.next() {
             if !sameline {
-                self.out.indented_tabbed_line()?;
+                self.out.indented_tabbed_line().unwrap();
             }
 
             let name = &field.name;
@@ -206,7 +206,7 @@ impl Writer<'_> {
 
         if let Some(exp) = manual_props {
             if !sameline {
-                self.out.indented_tabbed_line()?;
+                self.out.indented_tabbed_line().unwrap();
             }
             self.write_manual_props(exp)?;
         }
diff --git a/packages/autofmt/src/element.rs b/packages/autofmt/src/element.rs
@@ -103,7 +103,7 @@ impl Writer<'_> {
         }
 
         // multiline handlers bump everything down
-        if attr_len > 1000 {
+        if attr_len > 1000 || self.out.indent.split_line_attributes() {
             opt_level = ShortOptimization::NoOpt;
         }
 
@@ -262,7 +262,6 @@ impl Writer<'_> {
             }
             ElementAttrValue::EventTokens(tokens) => {
                 let out = self.retrieve_formatted_expr(tokens).to_string();
-
                 let mut lines = out.split('\n').peekable();
                 let first = lines.next().unwrap();
 
@@ -327,6 +326,10 @@ impl Writer<'_> {
         beginning.is_empty()
     }
 
+    pub fn is_empty_children(&self, children: &[BodyNode]) -> bool {
+        children.is_empty()
+    }
+
     // check if the children are short enough to be on the same line
     // We don't have the notion of current line depth - each line tries to be < 80 total
     // returns the total line length if it's short
diff --git a/packages/autofmt/src/indent.rs b/packages/autofmt/src/indent.rs
@@ -8,17 +8,19 @@ pub enum IndentType {
 pub struct IndentOptions {
     width: usize,
     indent_string: String,
+    split_line_attributes: bool,
 }
 
 impl IndentOptions {
-    pub fn new(typ: IndentType, width: usize) -> Self {
+    pub fn new(typ: IndentType, width: usize, split_line_attributes: bool) -> Self {
         assert_ne!(width, 0, "Cannot have an indent width of 0");
         Self {
             width,
             indent_string: match typ {
                 IndentType::Tabs => "\t".into(),
                 IndentType::Spaces => " ".repeat(width),
             },
+            split_line_attributes,
         }
     }
 
@@ -62,11 +64,15 @@ impl IndentOptions {
         }
         indent
     }
+
+    pub fn split_line_attributes(&self) -> bool {
+        self.split_line_attributes
+    }
 }
 
 impl Default for IndentOptions {
     fn default() -> Self {
-        Self::new(IndentType::Spaces, 4)
+        Self::new(IndentType::Spaces, 4, false)
     }
 }
 
@@ -77,31 +83,31 @@ mod tests {
     #[test]
     fn count_indents() {
         assert_eq!(
-            IndentOptions::new(IndentType::Spaces, 4).count_indents("no indentation here!"),
+            IndentOptions::new(IndentType::Spaces, 4, false).count_indents("no indentation here!"),
             0
         );
         assert_eq!(
-            IndentOptions::new(IndentType::Spaces, 4).count_indents("    v += 2"),
+            IndentOptions::new(IndentType::Spaces, 4, false).count_indents("    v += 2"),
             1
         );
         assert_eq!(
-            IndentOptions::new(IndentType::Spaces, 4).count_indents("        v += 2"),
+            IndentOptions::new(IndentType::Spaces, 4, false).count_indents("        v += 2"),
             2
         );
         assert_eq!(
-            IndentOptions::new(IndentType::Spaces, 4).count_indents("          v += 2"),
+            IndentOptions::new(IndentType::Spaces, 4, false).count_indents("          v += 2"),
             2
         );
         assert_eq!(
-            IndentOptions::new(IndentType::Spaces, 4).count_indents("\t\tv += 2"),
+            IndentOptions::new(IndentType::Spaces, 4, false).count_indents("\t\tv += 2"),
             2
         );
         assert_eq!(
-            IndentOptions::new(IndentType::Spaces, 4).count_indents("\t\t  v += 2"),
+            IndentOptions::new(IndentType::Spaces, 4, false).count_indents("\t\t  v += 2"),
             2
         );
         assert_eq!(
-            IndentOptions::new(IndentType::Spaces, 2).count_indents("    v += 2"),
+            IndentOptions::new(IndentType::Spaces, 2, false).count_indents("    v += 2"),
             2
         );
     }
diff --git a/packages/autofmt/src/lib.rs b/packages/autofmt/src/lib.rs
@@ -140,7 +140,9 @@ pub fn write_block_out(body: CallBody) -> Option<String> {
 }
 
 fn write_body(buf: &mut Writer, body: &CallBody) {
-    if buf.is_short_children(&body.roots).is_some() {
+    let is_short = buf.is_short_children(&body.roots).is_some();
+    let is_empty = buf.is_empty_children(&body.roots);
+    if (is_short && !buf.out.indent.split_line_attributes()) || is_empty {
         // write all the indents with spaces and commas between
         for idx in 0..body.roots.len() - 1 {
             let ident = &body.roots[idx];
diff --git a/packages/autofmt/tests/wrong.rs b/packages/autofmt/tests/wrong.rs
@@ -18,11 +18,11 @@ macro_rules! twoway {
     };
 }
 
-twoway!("comments-4sp" => comments_4sp (IndentOptions::new(IndentType::Spaces, 4)));
-twoway!("comments-tab" => comments_tab (IndentOptions::new(IndentType::Tabs, 4)));
+twoway!("comments-4sp" => comments_4sp (IndentOptions::new(IndentType::Spaces, 4, false)));
+twoway!("comments-tab" => comments_tab (IndentOptions::new(IndentType::Tabs, 4, false)));
 
-twoway!("multi-4sp" => multi_4sp (IndentOptions::new(IndentType::Spaces, 4)));
-twoway!("multi-tab" => multi_tab (IndentOptions::new(IndentType::Tabs, 4)));
+twoway!("multi-4sp" => multi_4sp (IndentOptions::new(IndentType::Spaces, 4, false)));
+twoway!("multi-tab" => multi_tab (IndentOptions::new(IndentType::Tabs, 4, false)));
 
-twoway!("multiexpr-4sp" => multiexpr_4sp (IndentOptions::new(IndentType::Spaces, 4)));
-twoway!("multiexpr-tab" => multiexpr_tab (IndentOptions::new(IndentType::Tabs, 4)));
+twoway!("multiexpr-4sp" => multiexpr_4sp (IndentOptions::new(IndentType::Spaces, 4, false)));
+twoway!("multiexpr-tab" => multiexpr_tab (IndentOptions::new(IndentType::Tabs, 4, false)));
diff --git a/packages/cli/src/cli/autoformat.rs b/packages/cli/src/cli/autoformat.rs
@@ -22,23 +22,33 @@ pub struct Autoformat {
     /// Input file
     #[clap(short, long)]
     pub file: Option<String>,
+
+    /// Split attributes in lines or not
+    #[clap(short, long, default_value = "false")]
+    pub split_line_attributes: bool,
 }
 
 impl Autoformat {
     // Todo: autoformat the entire crate
     pub async fn autoformat(self) -> Result<()> {
-        let Autoformat { check, raw, file } = self;
+        let Autoformat {
+            check,
+            raw,
+            file,
+            split_line_attributes,
+            ..
+        } = self;
 
         // Default to formatting the project
         if raw.is_none() && file.is_none() {
-            if let Err(e) = autoformat_project(check).await {
+            if let Err(e) = autoformat_project(check, split_line_attributes).await {
                 eprintln!("error formatting project: {}", e);
                 exit(1);
             }
         }
 
         if let Some(raw) = raw {
-            let indent = indentation_for(".")?;
+            let indent = indentation_for(".", self.split_line_attributes)?;
             if let Some(inner) = dioxus_autofmt::fmt_block(&raw, 0, indent) {
                 println!("{}", inner);
             } else {
@@ -50,15 +60,15 @@ impl Autoformat {
 
         // Format single file
         if let Some(file) = file {
-            refactor_file(file)?;
+            refactor_file(file, split_line_attributes)?;
         }
 
         Ok(())
     }
 }
 
-fn refactor_file(file: String) -> Result<(), Error> {
-    let indent = indentation_for(".")?;
+fn refactor_file(file: String, split_line_attributes: bool) -> Result<(), Error> {
+    let indent = indentation_for(".", split_line_attributes)?;
     let file_content = if file == "-" {
         let mut contents = String::new();
         std::io::stdin().read_to_string(&mut contents)?;
@@ -138,7 +148,7 @@ async fn format_file(
 /// Runs using Tokio for multithreading, so it should be really really fast
 ///
 /// Doesn't do mod-descending, so it will still try to format unreachable files. TODO.
-async fn autoformat_project(check: bool) -> Result<()> {
+async fn autoformat_project(check: bool, split_line_attributes: bool) -> Result<()> {
     let crate_config = dioxus_cli_config::CrateConfig::new(None)?;
 
     let files_to_format = get_project_files(&crate_config);
@@ -147,7 +157,7 @@ async fn autoformat_project(check: bool) -> Result<()> {
         return Ok(());
     }
 
-    let indent = indentation_for(&files_to_format[0])?;
+    let indent = indentation_for(&files_to_format[0], split_line_attributes)?;
 
     let counts = files_to_format
         .into_iter()
@@ -181,7 +191,10 @@ async fn autoformat_project(check: bool) -> Result<()> {
     Ok(())
 }
 
-fn indentation_for(file_or_dir: impl AsRef<Path>) -> Result<IndentOptions> {
+fn indentation_for(
+    file_or_dir: impl AsRef<Path>,
+    split_line_attributes: bool,
+) -> Result<IndentOptions> {
     let out = std::process::Command::new("cargo")
         .args(["fmt", "--", "--print-config", "current"])
         .arg(file_or_dir.as_ref())
@@ -221,6 +234,7 @@ fn indentation_for(file_or_dir: impl AsRef<Path>) -> Result<IndentOptions> {
             IndentType::Spaces
         },
         tab_spaces,
+        split_line_attributes,
     ))
 }
 
@@ -269,6 +283,7 @@ async fn test_auto_fmt() {
         check: false,
         raw: Some(test_rsx),
         file: None,
+        split_line_attributes: false,
     };
 
     fmt.autoformat().await.unwrap();
diff --git a/packages/extension/src/lib.rs b/packages/extension/src/lib.rs
@@ -15,6 +15,7 @@ pub fn format_rsx(raw: String, use_tabs: bool, indent_size: usize) -> String {
                 IndentType::Spaces
             },
             indent_size,
+            false,
         ),
     );
     block.unwrap()
@@ -32,6 +33,7 @@ pub fn format_selection(raw: String, use_tabs: bool, indent_size: usize) -> Stri
                 IndentType::Spaces
             },
             indent_size,
+            false,
         ),
     );
     block.unwrap()
@@ -67,6 +69,7 @@ pub fn format_file(contents: String, use_tabs: bool, indent_size: usize) -> Form
                 IndentType::Spaces
             },
             indent_size,
+            false,
         ),
     );
     let out = dioxus_autofmt::apply_formats(&contents, _edits.clone());

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ impl Writer<'_> {`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`// multiline handlers bump everything down`
`70`		`- if attr_len > 1000 {`
	`70`	`+ if attr_len > 1000 \|\| self.out.indent.split_line_attributes() {`
`71`	`71`	`opt_level = ShortOptimization::NoOpt;`
`72`	`72`	`}`
`73`	`73`
`@@ -158,7 +158,7 @@ impl Writer<'_> {`
`158`	`158`
`159`	`159`	`while let Some(field) = field_iter.next() {`
`160`	`160`	`if !sameline {`
`161`		`- self.out.indented_tabbed_line()?;`
	`161`	`+ self.out.indented_tabbed_line().unwrap();`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`let name = &field.name;`
`@@ -206,7 +206,7 @@ impl Writer<'_> {`
`206`	`206`
`207`	`207`	`if let Some(exp) = manual_props {`
`208`	`208`	`if !sameline {`
`209`		`- self.out.indented_tabbed_line()?;`
	`209`	`+ self.out.indented_tabbed_line().unwrap();`
`210`	`210`	`}`
`211`	`211`	`self.write_manual_props(exp)?;`
`212`	`212`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ impl Writer<'_> {`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`// multiline handlers bump everything down`
`106`		`- if attr_len > 1000 {`
	`106`	`+ if attr_len > 1000 \|\| self.out.indent.split_line_attributes() {`
`107`	`107`	`opt_level = ShortOptimization::NoOpt;`
`108`	`108`	`}`
`109`	`109`
`@@ -262,7 +262,6 @@ impl Writer<'_> {`
`262`	`262`	`}`
`263`	`263`	`ElementAttrValue::EventTokens(tokens) => {`
`264`	`264`	`let out = self.retrieve_formatted_expr(tokens).to_string();`
`265`		`-`
`266`	`265`	`let mut lines = out.split('\n').peekable();`
`267`	`266`	`let first = lines.next().unwrap();`
`268`	`267`
`@@ -327,6 +326,10 @@ impl Writer<'_> {`
`327`	`326`	`beginning.is_empty()`
`328`	`327`	`}`
`329`	`328`
	`329`	`+ pub fn is_empty_children(&self, children: &[BodyNode]) -> bool {`
	`330`	`+ children.is_empty()`
	`331`	`+ }`
	`332`	`+`
`330`	`333`	`// check if the children are short enough to be on the same line`
`331`	`334`	`// We don't have the notion of current line depth - each line tries to be < 80 total`
`332`	`335`	`// returns the total line length if it's short`
Original file line number	Diff line number	Diff line change
`@@ -8,17 +8,19 @@ pub enum IndentType {`
`8`	`8`	`pub struct IndentOptions {`
`9`	`9`	`width: usize,`
`10`	`10`	`indent_string: String,`
	`11`	`+ split_line_attributes: bool,`
`11`	`12`	`}`
`12`	`13`
`13`	`14`	`impl IndentOptions {`
`14`		`- pub fn new(typ: IndentType, width: usize) -> Self {`
	`15`	`+ pub fn new(typ: IndentType, width: usize, split_line_attributes: bool) -> Self {`
`15`	`16`	`assert_ne!(width, 0, "Cannot have an indent width of 0");`
`16`	`17`	`Self {`
`17`	`18`	`width,`
`18`	`19`	`indent_string: match typ {`
`19`	`20`	`IndentType::Tabs => "\t".into(),`
`20`	`21`	`IndentType::Spaces => " ".repeat(width),`
`21`	`22`	`},`
	`23`	`+ split_line_attributes,`
`22`	`24`	`}`
`23`	`25`	`}`
`24`	`26`
`@@ -62,11 +64,15 @@ impl IndentOptions {`
`62`	`64`	`}`
`63`	`65`	`indent`
`64`	`66`	`}`
	`67`	`+`
	`68`	`+ pub fn split_line_attributes(&self) -> bool {`
	`69`	`+ self.split_line_attributes`
	`70`	`+ }`
`65`	`71`	`}`
`66`	`72`
`67`	`73`	`impl Default for IndentOptions {`
`68`	`74`	`fn default() -> Self {`
`69`		`- Self::new(IndentType::Spaces, 4)`
	`75`	`+ Self::new(IndentType::Spaces, 4, false)`
`70`	`76`	`}`
`71`	`77`	`}`
`72`	`78`
`@@ -77,31 +83,31 @@ mod tests {`
`77`	`83`	`#[test]`
`78`	`84`	`fn count_indents() {`
`79`	`85`	`assert_eq!(`
`80`		`- IndentOptions::new(IndentType::Spaces, 4).count_indents("no indentation here!"),`
	`86`	`+ IndentOptions::new(IndentType::Spaces, 4, false).count_indents("no indentation here!"),`
`81`	`87`	`0`
`82`	`88`	`);`
`83`	`89`	`assert_eq!(`
`84`		`- IndentOptions::new(IndentType::Spaces, 4).count_indents(" v += 2"),`
	`90`	`+ IndentOptions::new(IndentType::Spaces, 4, false).count_indents(" v += 2"),`
`85`	`91`	`1`
`86`	`92`	`);`
`87`	`93`	`assert_eq!(`
`88`		`- IndentOptions::new(IndentType::Spaces, 4).count_indents(" v += 2"),`
	`94`	`+ IndentOptions::new(IndentType::Spaces, 4, false).count_indents(" v += 2"),`
`89`	`95`	`2`
`90`	`96`	`);`
`91`	`97`	`assert_eq!(`
`92`		`- IndentOptions::new(IndentType::Spaces, 4).count_indents(" v += 2"),`
	`98`	`+ IndentOptions::new(IndentType::Spaces, 4, false).count_indents(" v += 2"),`
`93`	`99`	`2`
`94`	`100`	`);`
`95`	`101`	`assert_eq!(`
`96`		`- IndentOptions::new(IndentType::Spaces, 4).count_indents("\t\tv += 2"),`
	`102`	`+ IndentOptions::new(IndentType::Spaces, 4, false).count_indents("\t\tv += 2"),`
`97`	`103`	`2`
`98`	`104`	`);`
`99`	`105`	`assert_eq!(`
`100`		`- IndentOptions::new(IndentType::Spaces, 4).count_indents("\t\t v += 2"),`
	`106`	`+ IndentOptions::new(IndentType::Spaces, 4, false).count_indents("\t\t v += 2"),`
`101`	`107`	`2`
`102`	`108`	`);`
`103`	`109`	`assert_eq!(`
`104`		`- IndentOptions::new(IndentType::Spaces, 2).count_indents(" v += 2"),`
	`110`	`+ IndentOptions::new(IndentType::Spaces, 2, false).count_indents(" v += 2"),`
`105`	`111`	`2`
`106`	`112`	`);`
`107`	`113`	`}`