feat: add support for trait use statements

Signed-off-by: azjezz <[email protected]>

Author: azjezz

README.md

@@ -27,7 +27,7 @@ Generate PHP code from Rust using a fluent API 🐘 🦀
 - [x] Code generation for interfaces
 - [ ] Code generation for enums
 - [ ] Code generation for traits
-- [ ] Code generation for trait use statements
+- [x] Code generation for trait use statements
 - [x] Code generation for variadic parameters
 
 ## License

examples/complete.php

@@ -64,6 +64,21 @@ function format(
  */
 abstract class Example extends Foo\Bar\Baz implements Foo\Bar\BazInterface
 {
+    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;
+    }
+
     final const A = "Hello World!";
 
     protected const B = null;

examples/complete.rs

@@ -10,8 +10,10 @@ use php_codegen::interface::Interface;
 use php_codegen::literal::Value;
 use php_codegen::method::Method;
 use php_codegen::modifiers::Modifier;
+use php_codegen::modifiers::VisibilityModifier;
 use php_codegen::parameter::Parameter;
 use php_codegen::property::Property;
+use php_codegen::usage::Usage;
 use php_codegen::Indentation;
 
 fn main() {
@@ -98,6 +100,24 @@ fn main() {
                             .simple_tag("immutable"),
                     )
                     .modifier(Modifier::Abstract)
+                    .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),
+                    )
                     .constant(
                         ClassConstant::new("A")
                             .valued("Hello World!")

src/class.rs

@@ -4,6 +4,7 @@ use crate::constant::ClassConstant;
 use crate::method::Method;
 use crate::modifiers::Modifier;
 use crate::property::Property;
+use crate::usage::Usage;
 use crate::Generator;
 use crate::Indentation;
 
@@ -15,6 +16,7 @@ pub struct Class {
     pub name: String,
     pub extends: Option<String>,
     pub implements: Vec<String>,
+    pub usages: Vec<Usage>,
     pub constants: Vec<ClassConstant>,
     pub properties: Vec<Property>,
     pub methods: Vec<Method>,
@@ -29,6 +31,7 @@ impl Class {
             name: name.to_string(),
             extends: None,
             implements: vec![],
+            usages: vec![],
             constants: vec![],
             properties: vec![],
             methods: vec![],
@@ -65,6 +68,12 @@ impl Class {
         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());
 
@@ -119,6 +128,19 @@ impl Generator for Class {
 
         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

src/lib.rs

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

src/usage.rs

@@ -0,0 +1,180 @@
+use crate::modifiers::VisibilityModifier;
+use crate::Generator;
+use crate::Indentation;
+
+#[derive(Debug)]
+pub struct Usage {
+    pub traits: Vec<String>,
+    pub adaptations: Vec<UsageAdaptation>,
+}
+
+#[derive(Debug)]
+pub enum UsageAdaptation {
+    Alias {
+        method: String,
+        alias: String,
+        visibility: Option<VisibilityModifier>,
+    },
+    Visibility {
+        method: String,
+        visibility: VisibilityModifier,
+    },
+    Precedence {
+        method: String,
+        insteadof: Vec<String>,
+    },
+}
+
+impl Usage {
+    pub fn new(traits: Vec<String>) -> Self {
+        Self {
+            traits,
+            adaptations: vec![],
+        }
+    }
+
+    pub fn with<T: ToString>(mut self, r#trait: T) -> Self {
+        self.traits.push(r#trait.to_string());
+
+        self
+    }
+
+    pub fn alias<T: ToString>(
+        mut self,
+        method: T,
+        alias: T,
+        visibility: VisibilityModifier,
+    ) -> Self {
+        self.adaptations.push(UsageAdaptation::Alias {
+            method: method.to_string(),
+            alias: alias.to_string(),
+            visibility: Some(visibility),
+        });
+
+        self
+    }
+
+    pub fn rename<T: ToString>(mut self, method: T, alias: T) -> Self {
+        self.adaptations.push(UsageAdaptation::Alias {
+            method: method.to_string(),
+            alias: alias.to_string(),
+            visibility: None,
+        });
+
+        self
+    }
+
+    pub fn public<T: ToString>(mut self, method: T) -> Self {
+        self.adaptations.push(UsageAdaptation::Visibility {
+            method: method.to_string(),
+            visibility: VisibilityModifier::Public,
+        });
+
+        self
+    }
+
+    pub fn protected<T: ToString>(mut self, method: T) -> Self {
+        self.adaptations.push(UsageAdaptation::Visibility {
+            method: method.to_string(),
+            visibility: VisibilityModifier::Protected,
+        });
+
+        self
+    }
+
+    pub fn private<T: ToString>(mut self, method: T) -> Self {
+        self.adaptations.push(UsageAdaptation::Visibility {
+            method: method.to_string(),
+            visibility: VisibilityModifier::Private,
+        });
+
+        self
+    }
+
+    pub fn visibility<T: ToString>(mut self, method: T, visibility: VisibilityModifier) -> Self {
+        self.adaptations.push(UsageAdaptation::Visibility {
+            method: method.to_string(),
+            visibility,
+        });
+
+        self
+    }
+
+    pub fn precede<T: ToString>(mut self, method: T, insteadof: Vec<T>) -> Self {
+        self.adaptations.push(UsageAdaptation::Precedence {
+            method: method.to_string(),
+            insteadof: insteadof
+                .into_iter()
+                .map(|insteadof| insteadof.to_string())
+                .collect(),
+        });
+
+        self
+    }
+}
+
+impl Generator for Usage {
+    fn generate(&self, indentation: Indentation, level: usize) -> String {
+        let mut code = indentation.indent("use", level);
+
+        code.push(' ');
+        code.push_str(&self.traits.join(", "));
+
+        if !self.adaptations.is_empty() {
+            code.push_str(" {\n");
+            for adaptation in &self.adaptations {
+                let adaptation = match adaptation {
+                    UsageAdaptation::Alias {
+                        method,
+                        alias,
+                        visibility,
+                    } => {
+                        let alias = if let Some(visibility) = visibility {
+                            format!("{} {}", visibility.generate(indentation, level), alias)
+                        } else {
+                            alias.to_string()
+                        };
+
+                        indentation.indent(format!("{} as {}", method, alias), level + 1)
+                    }
+                    UsageAdaptation::Visibility { method, visibility } => indentation.indent(
+                        format!("{} as {}", method, visibility.generate(indentation, level)),
+                        level + 1,
+                    ),
+                    UsageAdaptation::Precedence { method, insteadof } => indentation.indent(
+                        format!("{} insteadof {}", method, insteadof.join(", ")),
+                        level + 1,
+                    ),
+                };
+
+                code.push_str(&format!("{};\n", adaptation));
+            }
+
+            code.push_str(&format!("{}}}\n", indentation.value(level)));
+        } else {
+            code.push_str(";\n");
+        }
+
+        code
+    }
+}
+
+impl From<String> for Usage {
+    fn from(r#trait: String) -> Self {
+        Self::new(vec![r#trait])
+    }
+}
+
+impl From<&str> for Usage {
+    fn from(r#trait: &str) -> Self {
+        Self::new(vec![r#trait.to_string()])
+    }
+}
+
+impl<T: ToString> From<Vec<T>> for Usage {
+    fn from(traits: Vec<T>) -> Self {
+        traits
+            .into_iter()
+            .fold(Self::new(vec![]), |usage, r#trait| usage.with(r#trait))
+    }
+}