feat: add support for traits

Signed-off-by: azjezz <azjezz@protonmail.com>

Author: azjezz

README.md

@@ -26,7 +26,7 @@ Generate PHP code from Rust using a fluent API 🐘 🦀
 - [x] Code generation for function/method bodies
 - [x] Code generation for interfaces
 - [ ] Code generation for enums
-- [ ] Code generation for traits
+- [x] Code generation for traits
 - [x] Code generation for trait use statements
 - [x] Code generation for variadic parameters
 

examples/complete.php

@@ -134,6 +134,73 @@ public final function helloWorld(): void {
     }
 }
 
+/**
+ * This is an example trait.
+ */
+trait ExampleTrait
+{
+    use A;
+
+    use B, C;
+
+    use D, E, F, G {
+        E::bar as baz;
+        D::foo as public bar;
+        E::qux as public;
+        D::format as protected;
+        D::d as private;
+        D::drop insteadof E;
+        G::something insteadof E, F, D;
+        E::e as protected;
+    }
+
+    private string $foo;
+
+    protected string $bar;
+
+    public string|int $baz = "Hello World!";
+
+    /**
+     * This is a simple hello function.
+     *
+     * @param non-empty-string $firstname
+     *
+     * @return string
+     *
+     * @pure
+     */
+    #[Qux(foo: 1, bar: 2), Qux(foo: 1, bar: 2)]
+    function hello(
+        string $firstname,
+        string $lastname = Qux::Foo,
+    ): string {
+        return 'Hello ' . $firstname . ' ' . $lastname . '!';
+    }
+
+    /**
+     * This is a simple x function.
+     *
+     * @pure
+     */
+    #[Foo(foo: 1, bar: 2), Bar(foo: 1, bar: 2)]
+    #[Baz, Qux]
+    public function x(): mixed {
+        return 'Hello!';
+    }
+
+    /**
+     * This is a simple poop function.
+     */
+    public abstract function poop(): void;
+
+    /**
+     * This is a simple echo function.
+     */
+    public final function helloWorld(): void {
+        echo 'Hello World!';
+    }
+}
+
 /**
  * This is a simple formatter interface.
  *

examples/complete.rs

@@ -13,6 +13,7 @@ use php_codegen::modifiers::Modifier;
 use php_codegen::modifiers::VisibilityModifier;
 use php_codegen::parameter::Parameter;
 use php_codegen::property::Property;
+use php_codegen::r#trait::Trait;
 use php_codegen::usage::Usage;
 use php_codegen::Indentation;
 
@@ -196,6 +197,97 @@ fn main() {
                             }),
                     ),
             )
+            .r#trait(
+                Trait::new("ExampleTrait")
+                    .document(Document::new().text("This is an example trait."))
+                    .using("A")
+                    .using(vec!["B", "C"])
+                    .using(
+                        Usage::new(vec![
+                            "D".to_string(),
+                            "E".to_string(),
+                            "F".to_string(),
+                            "G".to_string(),
+                        ])
+                        .rename("E::bar", "baz")
+                        .alias("D::foo", "bar", VisibilityModifier::Public)
+                        .public("E::qux")
+                        .protected("D::format")
+                        .private("D::d")
+                        .precede("D::drop", vec!["E"])
+                        .precede("G::something", vec!["E", "F", "D"])
+                        .visibility("E::e", VisibilityModifier::Protected),
+                    )
+                    .property(Property::new("foo").typed(DataType::String).private())
+                    .property(Property::new("bar").typed(DataType::String).protected())
+                    .property(
+                        Property::new("baz")
+                            .typed(DataType::Union(vec![DataType::String, DataType::Integer]))
+                            .public()
+                            .default("Hello World!"),
+                    )
+                    .method(
+                        Method::new("hello")
+                            .returns(DataType::String)
+                            .parameter(Parameter::new("firstname").typed(DataType::String))
+                            .parameter(
+                                Parameter::new("lastname")
+                                    .typed(DataType::String)
+                                    .default(Value::Literal("Qux::Foo".to_string())),
+                            )
+                            .body("return 'Hello ' . $firstname . ' ' . $lastname . '!';")
+                            .attributes(
+                                AttributeGroup::new()
+                                    .add("Qux", Some("foo: 1, bar: 2"))
+                                    .add("Qux", Some("foo: 1, bar: 2")),
+                            )
+                            .document(
+                                Document::new()
+                                    .text("This is a simple hello function.")
+                                    .empty_line()
+                                    .tag("param", "non-empty-string $firstname")
+                                    .empty_line()
+                                    .tag("return", "string")
+                                    .empty_line()
+                                    .simple_tag("pure"),
+                            ),
+                    )
+                    .method(
+                        Method::new("x")
+                            .public()
+                            .returns(DataType::Mixed)
+                            .body("return 'Hello!';")
+                            .attributes(
+                                AttributeGroup::new()
+                                    .add("Foo", Some("foo: 1, bar: 2"))
+                                    .add("Bar", Some("foo: 1, bar: 2")),
+                            )
+                            .attributes(AttributeGroup::new().add("Baz", None).add("Qux", None))
+                            .document(
+                                Document::new()
+                                    .text("This is a simple x function.")
+                                    .empty_line()
+                                    .simple_tag("pure"),
+                            ),
+                    )
+                    .method(
+                        Method::new("poop")
+                            .public()
+                            .modifier(Modifier::Abstract)
+                            .returns(DataType::Void)
+                            .document(Document::new().text("This is a simple poop function.")),
+                    )
+                    .method(
+                        Method::new("helloWorld")
+                            .public()
+                            .modifier(Modifier::Final)
+                            .returns(DataType::Void)
+                            .document(Document::new().text("This is a simple echo function."))
+                            .body(|indentation: Indentation, level| {
+                                indentation.indent("echo 'Hello World!';", level)
+                            }),
+                    ),
+            )
             .interface(
                 Interface::new("Formatter")
                     .document(

src/file.rs

@@ -5,6 +5,7 @@ use crate::constant::Constant;
 use crate::function::Function;
 use crate::interface::Interface;
 use crate::literal::Value;
+use crate::r#trait::Trait;
 use crate::Generator;
 use crate::Indentation;
 
@@ -18,6 +19,7 @@ pub struct File {
     pub functions: Vec<Function>,
     pub constants: Vec<Constant>,
     pub classes: Vec<Class>,
+    pub traits: Vec<Trait>,
     pub interfaces: Vec<Interface>,
 }
 
@@ -32,6 +34,7 @@ impl File {
             constants: vec![],
             functions: vec![],
             classes: vec![],
+            traits: vec![],
             interfaces: vec![],
         }
     }
@@ -84,6 +87,12 @@ impl File {
         self
     }
 
+    pub fn r#trait(mut self, r#trait: Trait) -> Self {
+        self.traits.push(r#trait);
+
+        self
+    }
+
     pub fn interface(mut self, interface: Interface) -> Self {
         self.interfaces.push(interface);
 
@@ -159,6 +168,11 @@ impl Generator for File {
             code.push('\n');
         }
 
+        for r#trait in &self.traits {
+            code.push_str(&r#trait.generate(indentation, level));
+            code.push('\n');
+        }
+
         for interface in &self.interfaces {
             code.push_str(&interface.generate(indentation, level));
             code.push('\n');

src/lib.rs

@@ -12,6 +12,7 @@ pub mod method;
 pub mod modifiers;
 pub mod parameter;
 pub mod property;
+pub mod r#trait;
 pub mod usage;
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Clone, Copy)]

src/trait.rs

@@ -0,0 +1,141 @@
+use crate::attribute::AttributeGroup;
+use crate::comment::Document;
+use crate::constant::ClassConstant;
+use crate::method::Method;
+use crate::property::Property;
+use crate::usage::Usage;
+use crate::Generator;
+use crate::Indentation;
+
+#[derive(Debug)]
+pub struct Trait {
+    pub documentation: Option<Document>,
+    pub attributes: Vec<AttributeGroup>,
+    pub name: String,
+    pub usages: Vec<Usage>,
+    pub constants: Vec<ClassConstant>,
+    pub properties: Vec<Property>,
+    pub methods: Vec<Method>,
+}
+
+impl Trait {
+    pub fn new<T: ToString>(name: T) -> Self {
+        Self {
+            documentation: None,
+            attributes: vec![],
+            name: name.to_string(),
+            usages: vec![],
+            constants: vec![],
+            properties: vec![],
+            methods: vec![],
+        }
+    }
+
+    pub fn document(mut self, documentation: Document) -> Self {
+        self.documentation = Some(documentation);
+
+        self
+    }
+
+    pub fn attributes(mut self, attributes: AttributeGroup) -> Self {
+        self.attributes.push(attributes);
+
+        self
+    }
+
+    pub fn using<T: Into<Usage>>(mut self, usage: T) -> Self {
+        self.usages.push(usage.into());
+
+        self
+    }
+
+    pub fn constant<T: Into<ClassConstant>>(mut self, constant: T) -> Self {
+        self.constants.push(constant.into());
+
+        self
+    }
+
+    pub fn property(mut self, property: Property) -> Self {
+        self.properties.push(property);
+
+        self
+    }
+
+    pub fn method(mut self, method: Method) -> Self {
+        self.methods.push(method);
+
+        self
+    }
+}
+
+impl Generator for Trait {
+    fn generate(&self, indentation: Indentation, level: usize) -> String {
+        let mut code = String::new();
+
+        if let Some(documentation) = &self.documentation {
+            code.push_str(&documentation.generate(indentation, level));
+        }
+
+        for attribute in &self.attributes {
+            code.push_str(&attribute.generate(indentation, level));
+        }
+
+        code.push_str(&format!("trait {}", self.name));
+
+        code.push_str("\n{\n");
+
+        if !self.usages.is_empty() {
+            code.push_str(
+                &self
+                    .usages
+                    .iter()
+                    .map(|usage| usage.generate(indentation, level + 1))
+                    .collect::<Vec<String>>()
+                    .join("\n"),
+            );
+
+            code.push('\n');
+        }
+
+        if !self.constants.is_empty() {
+            code.push_str(
+                &self
+                    .constants
+                    .iter()
+                    .map(|constant| constant.generate(indentation, level + 1))
+                    .collect::<Vec<String>>()
+                    .join("\n"),
+            );
+
+            code.push('\n');
+        }
+
+        if !self.properties.is_empty() {
+            code.push_str(
+                &self
+                    .properties
+                    .iter()
+                    .map(|property| property.generate(indentation, level + 1))
+                    .collect::<Vec<String>>()
+                    .join("\n"),
+            );
+
+            code.push('\n');
+        }
+
+        if !self.methods.is_empty() {
+            code.push_str(
+                &self
+                    .methods
+                    .iter()
+                    .map(|method| method.generate(indentation, level + 1))
+                    .collect::<Vec<String>>()
+                    .join("\n"),
+            );
+        }
+
+        code.push_str("}\n");
+
+        code
+    }
+}