fix: attribute generator does not append new line

azjezz · azjezz · commit 74203750a434 · 2022-12-21T11:03:20.000+01:00
Signed-off-by: azjezz &lt;azjezz@protonmail.com&gt;
diff --git a/examples/complete.php b/examples/complete.php
@@ -62,7 +62,7 @@ function format(
  *
  * @immutable
  */
-abstract class Example
+abstract class Example extends Foo\Bar\Baz implements Foo\Bar\BazInterface
 {
     final const A = "Hello World!";
 
@@ -119,7 +119,13 @@ public final function helloWorld(): void {
     }
 }
 
-interface Formatter
+/**
+ * This is a simple formatter interface.
+ *
+ * @immutable
+ */
+#[Foo(foo: 1, bar: 2), Bar(foo: 1, bar: 2)]
+interface Formatter extends Qux
 {
     public function format(
         string $template,
diff --git a/examples/complete.rs b/examples/complete.rs
diff --git a/src/attribute.rs b/src/attribute.rs
@@ -34,14 +34,20 @@ impl Generator for AttributeGroup {
                     if let Some(arguments) = arguments {
                         format!("{}({})", name, arguments)
                     } else {
-                        format!("{}", name)
+                        name.to_string()
                     }
                 })
                 .collect::<Vec<String>>()
                 .join(", "),
         );
-        result.push_str("]");
+        result.push_str("]\n");
 
         result
     }
 }
+
+impl Default for AttributeGroup {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/src/body.rs b/src/body.rs
@@ -46,28 +46,28 @@ impl Generator for Body {
                 let mut code = String::new();
 
                 code.push_str(" {");
-                code.push_str("\n");
+                code.push('\n');
                 code.push_str(&factory(indentation, level + 1));
-                code.push_str("\n");
+                code.push('\n');
                 code.push_str(&indentation.indent("}", level));
-                code.push_str("\n");
+                code.push('\n');
 
                 code
             }
             None => {
                 let mut code = String::new();
 
                 if self.semicolon_for_empty {
-                    code.push_str(";");
+                    code.push(';');
                 } else {
                     code.push_str(" {");
-                    code.push_str("\n");
+                    code.push('\n');
                     code.push_str(&indentation.indent("// empty body", level + 1));
-                    code.push_str("\n");
+                    code.push('\n');
                     code.push_str(&indentation.indent("}", level));
                 }
 
-                code.push_str("\n");
+                code.push('\n');
 
                 code
             }
diff --git a/src/class.rs b/src/class.rs
@@ -53,13 +53,13 @@ impl Class {
         self
     }
 
-    pub fn extend<T: ToString>(mut self, extends: T) -> Self {
+    pub fn extends<T: ToString>(mut self, extends: T) -> Self {
         self.extends = Some(extends.to_string());
 
         self
     }
 
-    pub fn implement<T: ToString>(mut self, implements: T) -> Self {
+    pub fn implements<T: ToString>(mut self, implements: T) -> Self {
         self.implements.push(implements.to_string());
 
         self
@@ -129,7 +129,7 @@ impl Generator for Class {
                     .join("\n"),
             );
 
-            code.push_str("\n");
+            code.push('\n');
         }
 
         if !self.properties.is_empty() {
@@ -142,7 +142,7 @@ impl Generator for Class {
                     .join("\n"),
             );
 
-            code.push_str("\n");
+            code.push('\n');
         }
 
         if !self.methods.is_empty() {
diff --git a/src/comment.rs b/src/comment.rs
@@ -18,7 +18,7 @@ impl Document {
         Self { elements: vec![] }
     }
 
-    pub fn add(mut self, element: Element) -> Self {
+    pub fn add_element(mut self, element: Element) -> Self {
         self.elements.push(element);
 
         self
@@ -46,7 +46,7 @@ impl Document {
 
     pub fn text<T: ToString>(mut self, text: T) -> Self {
         self.elements
-            .push(Element::Text(format!("{}\n", text.to_string()).to_owned()));
+            .push(Element::Text(format!("{}\n", text.to_string())));
 
         self
     }
@@ -90,3 +90,9 @@ impl Generator for Element {
         }
     }
 }
+
+impl Default for Document {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/src/constant.rs b/src/constant.rs
@@ -152,7 +152,7 @@ impl Generator for ClassConstant {
                     .join("\n"),
             );
 
-            code.push_str("\n");
+            code.push('\n');
         }
 
         if let Some(visibility) = &self.visibility {
diff --git a/src/data_type.rs b/src/data_type.rs
@@ -27,20 +27,20 @@ pub enum DataType {
 }
 
 impl Generator for DataType {
-    fn generate(&self, indentation: Indentation, level: usize) -> String {
+    fn generate(&self, _indentation: Indentation, _level: usize) -> String {
         match self {
             DataType::Named(name) => name.to_string(),
             DataType::Nullable(inner) => {
-                format!("?{}", inner.generate(indentation, level))
+                format!("?{}", inner.generate(_indentation, _level))
             }
             DataType::Union(inner) => inner
                 .iter()
-                .map(|t| t.generate(indentation, level))
+                .map(|t| t.generate(_indentation, _level))
                 .collect::<Vec<String>>()
                 .join("|"),
             DataType::Intersection(inner) => inner
                 .iter()
-                .map(|t| t.generate(indentation, level))
+                .map(|t| t.generate(_indentation, _level))
                 .collect::<Vec<String>>()
                 .join("&"),
             DataType::Null => "null".to_string(),
diff --git a/src/file.rs b/src/file.rs
@@ -79,13 +79,13 @@ impl File {
     }
 
     pub fn class(mut self, class: Class) -> Self {
-        self.classes.push(class.into());
+        self.classes.push(class);
 
         self
     }
 
     pub fn interface(mut self, interface: Interface) -> Self {
-        self.interfaces.push(interface.into());
+        self.interfaces.push(interface);
 
         self
     }
@@ -116,7 +116,7 @@ impl Generator for File {
                 code.push_str(&format!("use {};\n", r#use));
             }
 
-            code.push_str("\n");
+            code.push('\n');
         }
 
         if !self.function_uses.is_empty() {
@@ -125,7 +125,7 @@ impl Generator for File {
                 code.push_str(&format!("use function {};\n", function));
             }
 
-            code.push_str("\n");
+            code.push('\n');
         }
 
         if !self.constant_uses.is_empty() {
@@ -134,34 +134,34 @@ impl Generator for File {
                 code.push_str(&format!("use const {};\n", constant));
             }
 
-            code.push_str("\n");
+            code.push('\n');
         }
 
         if used {
-            code.push_str("\n");
+            code.push('\n');
         }
 
         if !self.constants.is_empty() {
             for constant in &self.constants {
                 code.push_str(&constant.generate(indentation, level));
             }
 
-            code.push_str("\n");
+            code.push('\n');
         }
 
         for function in &self.functions {
             code.push_str(&function.generate(indentation, level));
-            code.push_str("\n");
+            code.push('\n');
         }
 
         for class in &self.classes {
             code.push_str(&class.generate(indentation, level));
-            code.push_str("\n");
+            code.push('\n');
         }
 
         for interface in &self.interfaces {
             code.push_str(&interface.generate(indentation, level));
-            code.push_str("\n");
+            code.push('\n');
         }
 
         code
@@ -170,6 +170,12 @@ impl Generator for File {
 
 impl Display for File {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.generate(Indentation::Spaces(4), 0))
+        write!(f, "{}", self.generate(Indentation::default(), 0))
+    }
+}
+
+impl Default for File {
+    fn default() -> Self {
+        Self::new()
     }
 }
diff --git a/src/function.rs b/src/function.rs
@@ -68,17 +68,8 @@ impl Generator for Function {
             code.push_str(&document.generate(indentation, level));
         }
 
-        if !self.attributes.is_empty() {
-            code.push_str(
-                &self
-                    .attributes
-                    .iter()
-                    .map(|attributes| attributes.generate(indentation, level))
-                    .collect::<Vec<String>>()
-                    .join("\n"),
-            );
-
-            code.push_str("\n");
+        for attribute in &self.attributes {
+            code.push_str(&attribute.generate(indentation, level));
         }
 
         code.push_str(format!("function {}", self.name).as_str());
@@ -97,7 +88,7 @@ impl Generator for Function {
             );
 
             code.push_str(",\n");
-            code.push_str(")");
+            code.push(')');
         }
 
         if let Some(return_type) = &self.return_type {
diff --git a/src/interface.rs b/src/interface.rs
@@ -32,7 +32,7 @@ impl Interface {
         self
     }
 
-    pub fn extend<T: ToString>(mut self, extends: T) -> Self {
+    pub fn extends<T: ToString>(mut self, extends: T) -> Self {
         self.extends = Some(extends.to_string());
 
         self
diff --git a/src/lib.rs b/src/lib.rs
@@ -13,7 +13,7 @@ pub mod modifiers;
 pub mod parameter;
 pub mod property;
 
-#[derive(Debug, PartialEq, PartialOrd, Clone, Copy)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Clone, Copy)]
 pub enum Indentation {
     Spaces(usize),
     Tabs(usize),
@@ -44,6 +44,12 @@ impl std::fmt::Display for Indentation {
     }
 }
 
+impl Default for Indentation {
+    fn default() -> Self {
+        Indentation::Spaces(4)
+    }
+}
+
 pub trait Generator {
     fn generate(&self, indentation: Indentation, level: usize) -> String;
 }
diff --git a/src/literal.rs b/src/literal.rs
@@ -72,7 +72,7 @@ impl<T: Into<Value>> From<Vec<(T, T)>> for Value {
 }
 
 impl Generator for Value {
-    fn generate(&self, identation: Indentation, level: usize) -> String {
+    fn generate(&self, _identation: Indentation, _level: usize) -> String {
         match self {
             Value::Null => "null".to_string(),
             Value::True => "true".to_string(),
@@ -88,7 +88,7 @@ impl Generator for Value {
                 result.push_str(
                     &values
                         .iter()
-                        .map(|value| value.generate(identation, level))
+                        .map(|value| value.generate(_identation, _level))
                         .collect::<Vec<String>>()
                         .join(", "),
                 );
@@ -106,8 +106,8 @@ impl Generator for Value {
                         .map(|(key, value)| {
                             format!(
                                 "{} => {}",
-                                key.generate(identation, level),
-                                value.generate(identation, level)
+                                key.generate(_identation, _level),
+                                value.generate(_identation, _level)
                             )
                         })
                         .collect::<Vec<String>>()
diff --git a/src/method.rs b/src/method.rs
@@ -105,17 +105,8 @@ impl Generator for Method {
             code.push_str(&document.generate(indentation, level));
         }
 
-        if !self.attributes.is_empty() {
-            code.push_str(
-                &self
-                    .attributes
-                    .iter()
-                    .map(|attributes| attributes.generate(indentation, level))
-                    .collect::<Vec<String>>()
-                    .join("\n"),
-            );
-
-            code.push_str("\n");
+        for attribute in &self.attributes {
+            code.push_str(&attribute.generate(indentation, level));
         }
 
         code.push_str(&indentation.value(level));
@@ -133,7 +124,7 @@ impl Generator for Method {
                     .join(" "),
             );
 
-            code.push_str(" ");
+            code.push(' ');
         }
 
         code.push_str(format!("function {}", self.name).as_str());
diff --git a/src/parameter.rs b/src/parameter.rs
diff --git a/src/property.rs b/src/property.rs

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ function format(`
`62`	`62`	`*`
`63`	`63`	`* @immutable`
`64`	`64`	`*/`
`65`		`-abstract class Example`
	`65`	`+abstract class Example extends Foo\Bar\Baz implements Foo\Bar\BazInterface`
`66`	`66`	`{`
`67`	`67`	`final const A = "Hello World!";`
`68`	`68`
`@@ -119,7 +119,13 @@ public final function helloWorld(): void {`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`
`122`		`-interface Formatter`
	`122`	`+/**`
	`123`	`+ * This is a simple formatter interface.`
	`124`	`+ *`
	`125`	`+ * @immutable`
	`126`	`+ */`
	`127`	`+#[Foo(foo: 1, bar: 2), Bar(foo: 1, bar: 2)]`
	`128`	`+interface Formatter extends Qux`
`123`	`129`	`{`
`124`	`130`	`public function format(`
`125`	`131`	`string $template,`
Original file line number	Diff line number	Diff line change
`@@ -53,13 +53,13 @@ impl Class {`
`53`	`53`	`self`
`54`	`54`	`}`
`55`	`55`
`56`		`- pub fn extend<T: ToString>(mut self, extends: T) -> Self {`
	`56`	`+ pub fn extends<T: ToString>(mut self, extends: T) -> Self {`
`57`	`57`	`self.extends = Some(extends.to_string());`
`58`	`58`
`59`	`59`	`self`
`60`	`60`	`}`
`61`	`61`
`62`		`- pub fn implement<T: ToString>(mut self, implements: T) -> Self {`
	`62`	`+ pub fn implements<T: ToString>(mut self, implements: T) -> Self {`
`63`	`63`	`self.implements.push(implements.to_string());`
`64`	`64`
`65`	`65`	`self`
`@@ -129,7 +129,7 @@ impl Generator for Class {`
`129`	`129`	`.join("\n"),`
`130`	`130`	`);`
`131`	`131`
`132`		`- code.push_str("\n");`
	`132`	`+ code.push('\n');`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`if !self.properties.is_empty() {`
`@@ -142,7 +142,7 @@ impl Generator for Class {`
`142`	`142`	`.join("\n"),`
`143`	`143`	`);`
`144`	`144`
`145`		`- code.push_str("\n");`
	`145`	`+ code.push('\n');`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`if !self.methods.is_empty() {`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ impl Document {`
`18`	`18`	`Self { elements: vec![] }`
`19`	`19`	`}`
`20`	`20`
`21`		`- pub fn add(mut self, element: Element) -> Self {`
	`21`	`+ pub fn add_element(mut self, element: Element) -> Self {`
`22`	`22`	`self.elements.push(element);`
`23`	`23`
`24`	`24`	`self`
`@@ -46,7 +46,7 @@ impl Document {`
`46`	`46`
`47`	`47`	`pub fn text<T: ToString>(mut self, text: T) -> Self {`
`48`	`48`	`self.elements`
`49`		`- .push(Element::Text(format!("{}\n", text.to_string()).to_owned()));`
	`49`	`+ .push(Element::Text(format!("{}\n", text.to_string())));`
`50`	`50`
`51`	`51`	`self`
`52`	`52`	`}`
`@@ -90,3 +90,9 @@ impl Generator for Element {`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`	`}`
	`93`	`+`
	`94`	`+impl Default for Document {`
	`95`	`+ fn default() -> Self {`
	`96`	`+ Self::new()`
	`97`	`+ }`
	`98`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ impl Generator for ClassConstant {`
`152`	`152`	`.join("\n"),`
`153`	`153`	`);`
`154`	`154`
`155`		`- code.push_str("\n");`
	`155`	`+ code.push('\n');`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`if let Some(visibility) = &self.visibility {`
Original file line number	Diff line number	Diff line change
`@@ -79,13 +79,13 @@ impl File {`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`pub fn class(mut self, class: Class) -> Self {`
`82`		`- self.classes.push(class.into());`
	`82`	`+ self.classes.push(class);`
`83`	`83`
`84`	`84`	`self`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`pub fn interface(mut self, interface: Interface) -> Self {`
`88`		`- self.interfaces.push(interface.into());`
	`88`	`+ self.interfaces.push(interface);`
`89`	`89`
`90`	`90`	`self`
`91`	`91`	`}`
`@@ -116,7 +116,7 @@ impl Generator for File {`
`116`	`116`	`code.push_str(&format!("use {};\n", r#use));`
`117`	`117`	`}`
`118`	`118`
`119`		`- code.push_str("\n");`
	`119`	`+ code.push('\n');`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`if !self.function_uses.is_empty() {`
`@@ -125,7 +125,7 @@ impl Generator for File {`
`125`	`125`	`code.push_str(&format!("use function {};\n", function));`
`126`	`126`	`}`
`127`	`127`
`128`		`- code.push_str("\n");`
	`128`	`+ code.push('\n');`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`if !self.constant_uses.is_empty() {`
`@@ -134,34 +134,34 @@ impl Generator for File {`
`134`	`134`	`code.push_str(&format!("use const {};\n", constant));`
`135`	`135`	`}`
`136`	`136`
`137`		`- code.push_str("\n");`
	`137`	`+ code.push('\n');`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`if used {`
`141`		`- code.push_str("\n");`
	`141`	`+ code.push('\n');`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`if !self.constants.is_empty() {`
`145`	`145`	`for constant in &self.constants {`
`146`	`146`	`code.push_str(&constant.generate(indentation, level));`
`147`	`147`	`}`
`148`	`148`
`149`		`- code.push_str("\n");`
	`149`	`+ code.push('\n');`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`for function in &self.functions {`
`153`	`153`	`code.push_str(&function.generate(indentation, level));`
`154`		`- code.push_str("\n");`
	`154`	`+ code.push('\n');`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`for class in &self.classes {`
`158`	`158`	`code.push_str(&class.generate(indentation, level));`
`159`		`- code.push_str("\n");`
	`159`	`+ code.push('\n');`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`for interface in &self.interfaces {`
`163`	`163`	`code.push_str(&interface.generate(indentation, level));`
`164`		`- code.push_str("\n");`
	`164`	`+ code.push('\n');`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`code`
`@@ -170,6 +170,12 @@ impl Generator for File {`
`170`	`170`
`171`	`171`	`impl Display for File {`
`172`	`172`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`173`		`- write!(f, "{}", self.generate(Indentation::Spaces(4), 0))`
	`173`	`+ write!(f, "{}", self.generate(Indentation::default(), 0))`
	`174`	`+ }`
	`175`	`+}`
	`176`	`+`
	`177`	`+impl Default for File {`
	`178`	`+ fn default() -> Self {`
	`179`	`+ Self::new()`
`174`	`180`	`}`
`175`	`181`	`}`