feat: Add interface class registration

Author: Norbytus

Cargo.toml

@@ -17,7 +17,7 @@ parking_lot = "0.12"
 cfg-if = "1.0"
 once_cell = "1.17"
 anyhow = { version = "1", optional = true }
-ext-php-rs-derive = { version = "=0.11.0", path = "./crates/macros" }
+ext-php-rs-derive = { version = "=0.10.2", path = "./crates/macros" }
 
 [dev-dependencies]
 skeptic = "0.13"

crates/macros/Cargo.toml

@@ -4,7 +4,7 @@ description = "Derive macros for ext-php-rs."
 repository = "https://github.com/davidcole1340/ext-php-rs"
 homepage = "https://github.com/davidcole1340/ext-php-rs"
 license = "MIT OR Apache-2.0"
-version = "0.11.0"
+version = "0.10.2"
 authors = ["David Cole <[email protected]>"]
 edition = "2018"
 

crates/macros/src/impl_.rs

@@ -62,15 +62,15 @@ impl RenameRule {
 
 /// Method visibilities.
 #[derive(Debug)]
-pub enum MethodVis {
+enum MethodVis {
     Public,
     Private,
     Protected,
 }
 
 /// Method types.
 #[derive(Debug)]
-pub enum MethodTy {
+enum MethodTy {
     /// Regular PHP method.
     Normal,
     /// Constructor method.
@@ -122,17 +122,17 @@ pub fn parser(args: TokenStream, mut input: ItemImpl) -> Result<TokenStream> {
 
 /// Arguments applied to methods.
 #[derive(Debug)]
-pub struct MethodArgs {
+struct MethodArgs {
     /// Method name. Only applies to PHP (not the Rust method name).
-    pub name: String,
+    name: String,
     /// The first optional argument of the function signature.
-    pub optional: Option<Ident>,
+    optional: Option<Ident>,
     /// Default values for optional arguments.
-    pub defaults: HashMap<Ident, Lit>,
+    defaults: HashMap<Ident, Lit>,
     /// Visibility of the method (public, protected, private).
-    pub vis: MethodVis,
+    vis: MethodVis,
     /// Method type.
-    pub ty: MethodTy,
+    ty: MethodTy,
 }
 
 impl MethodArgs {
@@ -151,7 +151,7 @@ impl MethodArgs {
         }
     }
 
-    pub fn parse(&mut self, attrs: &mut Vec<syn::Attribute>) -> Result<()> {
+    fn parse(&mut self, attrs: &mut Vec<syn::Attribute>) -> Result<()> {
         let mut unparsed = vec![];
         unparsed.append(attrs);
         for attr in unparsed {
@@ -226,7 +226,7 @@ pub struct FnBuilder {
 }
 
 #[derive(Debug)]
-pub struct Constant<'a> {
+struct Constant<'a> {
     /// Name of the constant in PHP land.
     name: String,
     /// Identifier of the constant in Rust land.

src/builders/class.rs

@@ -9,7 +9,7 @@ use crate::{
     exception::PhpException,
     ffi::{
         zend_declare_class_constant, zend_declare_property, zend_do_implement_interface,
-        zend_register_internal_class_ex,
+        zend_register_internal_class_ex, zend_register_internal_interface,
     },
     flags::{ClassFlags, MethodFlags, PropertyFlags},
     types::{ZendClassObject, ZendObject, ZendStr, Zval},
@@ -293,16 +293,24 @@ impl ClassBuilder {
         let func = Box::into_raw(methods.into_boxed_slice()) as *const FunctionEntry;
         self.ce.info.internal.builtin_functions = func;
 
-        let class = unsafe {
-            zend_register_internal_class_ex(
-                &mut self.ce,
-                match self.extends {
-                    Some(ptr) => (ptr as *const _) as *mut _,
-                    None => std::ptr::null_mut(),
-                },
-            )
-            .as_mut()
-            .ok_or(Error::InvalidPointer)?
+        let class = if self.ce.flags().contains(ClassFlags::Interface) {
+            unsafe {
+                zend_register_internal_interface(&mut self.ce)
+                    .as_mut()
+                    .ok_or(Error::InvalidPointer)?
+            }
+        } else {
+            unsafe {
+                zend_register_internal_class_ex(
+                    &mut self.ce,
+                    match self.extends {
+                        Some(ptr) => (ptr as *const _) as *mut _,
+                        None => std::ptr::null_mut(),
+                    },
+                )
+                .as_mut()
+                .ok_or(Error::InvalidPointer)?
+            }
         };
 
         // disable serialization if the class has an associated object
@@ -364,3 +372,77 @@ impl ClassBuilder {
         Ok(())
     }
 }
+
+pub struct InterfaceBuilder {
+    class_builder: ClassBuilder,
+}
+
+impl InterfaceBuilder {
+    pub fn new<T: Into<String>>(name: T) -> Self {
+        Self {
+            class_builder: ClassBuilder::new(name),
+        }
+    }
+
+    pub fn implements(mut self, interface: &'static ClassEntry) -> Self {
+        self.class_builder = self.class_builder.implements(interface);
+
+        self
+    }
+
+    pub fn method(mut self, func: FunctionBuilder<'static>, flags: MethodFlags) -> Self {
+        self.class_builder = self.class_builder.method(func, flags);
+
+        self
+    }
+
+    pub fn constant<T: Into<String>>(
+        mut self,
+        name: T,
+        value: impl IntoZval + 'static,
+        docs: DocComments,
+    ) -> Result<Self> {
+        self.class_builder = self.class_builder.constant(name, value, docs)?;
+
+        Ok(self)
+    }
+
+    pub fn dyn_constant<T: Into<String>>(
+        mut self,
+        name: T,
+        value: &'static dyn IntoZvalDyn,
+        docs: DocComments,
+    ) -> Result<Self> {
+        self.class_builder = self.class_builder.dyn_constant(name, value, docs)?;
+
+        Ok(self)
+    }
+
+    pub fn flags(mut self, flags: ClassFlags) -> Self {
+        self.class_builder = self.class_builder.flags(flags);
+        self
+    }
+
+    pub fn object_override<T: RegisteredClass>(mut self) -> Self {
+        self.class_builder = self.class_builder.object_override::<T>();
+
+        self
+    }
+
+    pub fn registration(mut self, register: fn(&'static mut ClassEntry)) -> Self {
+        self.class_builder = self.class_builder.registration(register);
+
+        self
+    }
+
+    pub fn docs(mut self, docs: DocComments) -> Self {
+        self.class_builder = self.class_builder.docs(docs);
+        self
+    }
+
+    pub fn builder(mut self) -> ClassBuilder {
+        self.class_builder = self.class_builder.flags(ClassFlags::Interface);
+        dbg!(self.class_builder.ce.ce_flags);
+        self.class_builder
+    }
+}

src/builders/module.rs

@@ -1,6 +1,6 @@
 use std::{convert::TryFrom, ffi::CString, mem, ptr};
 
-use super::{ClassBuilder, FunctionBuilder};
+use super::{class::InterfaceBuilder, ClassBuilder, FunctionBuilder};
 use crate::{
     class::RegisteredClass,
     constant::IntoConst,
@@ -167,6 +167,37 @@ impl ModuleBuilder<'_> {
         self
     }
 
+    pub fn interface<T: RegisteredClass>(mut self) -> Self {
+        self.classes.push(|| {
+            let mut builder = InterfaceBuilder::new(T::CLASS_NAME);
+            for (method, flags) in T::method_builders() {
+                builder = builder.method(method, flags);
+            }
+            for iface in T::IMPLEMENTS {
+                builder = builder.implements(iface());
+            }
+            for (name, value, docs) in T::constants() {
+                builder = builder
+                    .dyn_constant(*name, *value, docs)
+                    .expect("Failed to register constant");
+            }
+
+            let mut class_builder = builder.builder();
+
+            if let Some(modifier) = T::BUILDER_MODIFIER {
+                class_builder = modifier(class_builder);
+            }
+
+            class_builder
+                .object_override::<T>()
+                .registration(|ce| {
+                    T::get_metadata().set_ce(ce);
+                })
+                .docs(T::DOC_COMMENTS)
+        });
+        self
+    }
+
     /// Adds a class to the extension.
     pub fn class<T: RegisteredClass>(mut self) -> Self {
         self.classes.push(|| {