feat: add partial support for property hooks

azjezz · azjezz · commit 52413956cf5e · 2024-08-13T12:49:00.000+01:00
This commit adds support for non-abstract property hooks, meaning it allows for the creation of property hooks in classes, but not in interfaces.

Additionally, property hooks with no body are not allowed.

Signed-off-by: azjezz &lt;azjezz@protonmail.com&gt;
diff --git a/examples/class.rs b/examples/class.rs
@@ -0,0 +1,76 @@
+use php_codegen::class::Class;
+use php_codegen::data_type::DataType;
+use php_codegen::file::File;
+use php_codegen::literal::Value;
+use php_codegen::modifiers::VisibilityModifier;
+use php_codegen::property::Property;
+use php_codegen::property::PropertyHook;
+use php_codegen::property::PropertySetHookParameter;
+
+fn main() {
+    let file = File::new()
+        .namespaced("App")
+        .declare("strict_types", 1)
+        // A class that uses property hooks
+        .class(
+            Class::new("SimpleUser")
+                .property(
+                    Property::new("firstName")
+                        .typed(DataType::String)
+                        .visibility(VisibilityModifier::Private)
+                        .default(Value::String("Jane".to_string())),
+                )
+                .property(
+                    Property::new("lastName")
+                        .typed(DataType::String)
+                        .visibility(VisibilityModifier::Private)
+                        .default(Value::String("Doe".to_string())),
+                )
+                .property(
+                    Property::new("fullname")
+                        .typed(DataType::String)
+                        .visibility(VisibilityModifier::Public)
+                        .hook(PropertyHook::Get(
+                            false,
+                            vec!["return $this->firstName . ' ' . $this->lastName;"].into(),
+                        ))
+                        .hook(PropertyHook::Set(
+                            Some(
+                                PropertySetHookParameter::new("$fullname").typed(DataType::String),
+                            ),
+                            vec![
+                                "[$first, $last] = explode(' ', $fullname);",
+                                "$this->firstName = $first;",
+                                "$this->lastName = $last;",
+                            ]
+                            .into(),
+                        )),
+                ),
+        )
+        .class(
+            Class::new("SimpleUser2")
+                .property(
+                    Property::new("firstName")
+                        .typed(DataType::String)
+                        .visibility(VisibilityModifier::Private)
+                        .default(Value::String("Jane".to_string())),
+                )
+                .property(
+                    Property::new("lastName")
+                        .typed(DataType::String)
+                        .visibility(VisibilityModifier::Private)
+                        .default(Value::String("Doe".to_string())),
+                )
+                .property(
+                    Property::new("fullname")
+                        .typed(DataType::String)
+                        .visibility(VisibilityModifier::Public)
+                        .hook(PropertyHook::Get(
+                            false,
+                            vec!["return $this->firstName . ' ' . $this->lastName;"].into(),
+                        )),
+                ),
+        );
+
+    print!("{file}");
+}
diff --git a/src/body.rs b/src/body.rs
@@ -1,4 +1,4 @@
-use core::fmt::Debug;
+use std::fmt::Debug;
 
 use crate::Generator;
 use crate::Indentation;
diff --git a/src/comment.rs b/src/comment.rs
@@ -84,7 +84,13 @@ impl Generator for Document {
 impl Generator for Element {
     fn generate(&self, _: Indentation, _: usize) -> String {
         match self {
-            Element::Tag(tag, description) => format!("@{} {}", tag, description),
+            Element::Tag(tag, description) => {
+                if description.is_empty() {
+                    format!("@{}", tag)
+                } else {
+                    format!("@{} {}", tag, description)
+                }
+            }
             Element::Text(text) => text.to_string(),
             Element::EmptyLine => String::new(),
         }
diff --git a/src/data_type.rs b/src/data_type.rs
@@ -31,7 +31,7 @@ impl Generator for DataType {
         match self {
             DataType::Named(name) => name.to_string(),
             DataType::Nullable(inner) => {
-                format!("?{}", inner.generate(_indentation, _level))
+                format!("null|{}", inner.generate(_indentation, _level))
             }
             DataType::Union(inner) => inner
                 .iter()
diff --git a/src/interface.rs b/src/interface.rs
@@ -1,4 +1,8 @@
-use crate::{attribute::AttributeGroup, comment::Document, method::Method, Generator, Indentation};
+use crate::attribute::AttributeGroup;
+use crate::comment::Document;
+use crate::method::Method;
+use crate::Generator;
+use crate::Indentation;
 
 #[derive(Debug)]
 pub struct Interface {
diff --git a/src/method.rs b/src/method.rs
@@ -1,4 +1,4 @@
-use core::fmt::Debug;
+use std::fmt::Debug;
 
 use crate::attribute::AttributeGroup;
 use crate::body::Body;
diff --git a/src/property.rs b/src/property.rs
@@ -1,4 +1,5 @@
 use crate::attribute::AttributeGroup;
+use crate::body::Body;
 use crate::comment::Document;
 use crate::data_type::DataType;
 use crate::literal::Value;
@@ -7,15 +8,43 @@ use crate::modifiers::VisibilityModifier;
 use crate::Generator;
 use crate::Indentation;
 
+#[derive(Debug)]
+pub struct PropertySetHookParameter {
+    pub data_type: Option<DataType>,
+    pub name: String,
+}
+
+#[derive(Debug)]
+pub enum PropertyHook {
+    Get(bool, Body),
+    Set(Option<PropertySetHookParameter>, Body),
+}
+
 #[derive(Debug)]
 pub struct Property {
     pub documentation: Option<Document>,
     pub attributes: Vec<AttributeGroup>,
-    pub name: String,
+    pub visibility: Option<VisibilityModifier>,
+    pub modifiers: Vec<Modifier>,
     pub data_type: Option<DataType>,
+    pub name: String,
     pub default: Option<Value>,
-    pub modifiers: Vec<Modifier>,
-    pub visibility: Option<VisibilityModifier>,
+    pub hooks: Vec<PropertyHook>,
+}
+
+impl PropertySetHookParameter {
+    pub fn new<T: ToString>(name: T) -> Self {
+        Self {
+            name: name.to_string(),
+            data_type: None,
+        }
+    }
+
+    pub fn typed(mut self, data_type: DataType) -> Self {
+        self.data_type = Some(data_type);
+
+        self
+    }
 }
 
 impl Property {
@@ -28,6 +57,7 @@ impl Property {
             attributes: vec![],
             visibility: None,
             documentation: None,
+            hooks: vec![],
         }
     }
 
@@ -84,6 +114,79 @@ impl Property {
 
         self
     }
+
+    pub fn hook(mut self, hook: PropertyHook) -> Self {
+        self.hooks.push(hook);
+
+        self
+    }
+}
+
+impl Generator for PropertySetHookParameter {
+    fn generate(&self, indentation: Indentation, level: usize) -> String {
+        let mut code = String::new();
+
+        if let Some(data_type) = &self.data_type {
+            code.push_str(&format!("{} ", data_type.generate(indentation, level)));
+        }
+
+        code.push_str(&self.name);
+
+        code
+    }
+}
+
+impl Generator for PropertyHook {
+    fn generate(&self, indentation: Indentation, level: usize) -> String {
+        match self {
+            PropertyHook::Get(by_reference, body) => {
+                let mut code = String::new();
+
+                code.push_str(&indentation.value(level + 1));
+                if *by_reference {
+                    code.push_str("&get");
+                } else {
+                    code.push_str("get");
+                }
+
+                code.push_str(&body.generate(indentation, level + 1));
+
+                code
+            }
+            PropertyHook::Set(parameter, body) => {
+                let mut code = String::new();
+
+                code.push_str(&indentation.value(level + 1));
+                code.push_str("set");
+
+                if let Some(parameter) = parameter {
+                    code.push_str(" (");
+                    code.push_str(&parameter.generate(indentation, level + 1));
+                    code.push(')');
+                }
+
+                code.push_str(&body.generate(indentation, level + 1));
+
+                code
+            }
+        }
+    }
+}
+
+impl Generator for Vec<PropertyHook> {
+    fn generate(&self, indentation: Indentation, level: usize) -> String {
+        if self.is_empty() {
+            return String::from(";");
+        }
+
+        let hooks = self
+            .iter()
+            .map(|hook| hook.generate(indentation, level))
+            .collect::<Vec<String>>()
+            .join("");
+
+        format!(" {{\n{}{}}}", hooks, indentation.value(level))
+    }
 }
 
 impl Generator for Property {
@@ -122,11 +225,11 @@ impl Generator for Property {
         code.push_str(&format!("${}", &self.name));
 
         if let Some(default) = &self.default {
-            code.push_str(&format!(" = {};\n", default.generate(indentation, level)));
-        } else {
-            code.push_str(";\n");
+            code.push_str(&format!(" = {}", default.generate(indentation, level)));
         }
 
+        code.push_str(&self.hooks.generate(indentation, level));
+
         code
     }
 }
diff --git a/tests/complete.php b/tests/complete.php
@@ -92,11 +92,8 @@ abstract class Example extends Foo\Bar\Baz implements Foo\Bar\BazInterface
     public const bool E = false;
 
     private string $foo;
-
     protected string $bar;
-
     public string|int $baz = "Hello World!";
-
     /**
      * This is a simple hello function.
      *
@@ -138,6 +135,33 @@ public final function helloWorld(): void {
     }
 }
 
+class SimpleUser
+{
+    private string $firstName = "Jane";
+    private string $lastName = "Doe";
+    public string $fullname {
+        get {
+            return $this->firstName . ' ' . $this->lastName;
+        }
+        set (string $fullname) {
+            [$first, $last] = explode(' ', $fullname);
+            $this->firstName = $first;
+            $this->lastName = $last;
+        }
+    }
+}
+
+class SimpleUser2
+{
+    private string $firstName = "Jane";
+    private string $lastName = "Doe";
+    public string $fullname {
+        get {
+            return $this->firstName . ' ' . $this->lastName;
+        }
+    }
+}
+
 /**
  * This is an example trait.
  */
@@ -157,11 +181,8 @@ trait ExampleTrait
     }
 
     private string $foo;
-
     protected string $bar;
-
     public string|int $baz = "Hello World!";
-
     /**
      * This is a simple hello function.
      *
diff --git a/tests/complete.rs b/tests/complete.rs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use core::fmt::Debug;`
	`1`	`+use std::fmt::Debug;`
`2`	`2`
`3`	`3`	`use crate::Generator;`
`4`	`4`	`use crate::Indentation;`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ impl Generator for DataType {`
`31`	`31`	`match self {`
`32`	`32`	`DataType::Named(name) => name.to_string(),`
`33`	`33`	`DataType::Nullable(inner) => {`
`34`		`- format!("?{}", inner.generate(_indentation, _level))`
	`34`	`+ format!("null\|{}", inner.generate(_indentation, _level))`
`35`	`35`	`}`
`36`	`36`	`DataType::Union(inner) => inner`
`37`	`37`	`.iter()`