Format.

Author: jmjoy

.rustfmt.toml

@@ -1 +1,12 @@
-imports_granularity = "Crate"
+fn_args_layout = "Compressed"
+format_code_in_doc_comments = true
+format_macro_bodies = true
+format_macro_matchers = true
+format_strings = true
+imports_granularity = "Crate"
+merge_derives = true
+newline_style = "Unix"
+normalize_comments = true
+reorder_impl_items = true
+use_field_init_shorthand = true
+wrap_comments = true

examples/http-client/src/utils.rs

@@ -1,4 +1,4 @@
-use std::mem::{take, replace};
+use std::mem::{replace, take};
 
 pub fn replace_and_set<T: Default>(t: &mut T, f: impl FnOnce(T) -> T) {
     let x = f(take(t));

phper-alloc/src/lib.rs

@@ -12,8 +12,9 @@ use std::{
 
 /// The item which can be placed into container [EBox].
 pub trait EAllocatable {
-    /// The method to free the heap allocated by `emalloc`, should call `efree` at the end.
-    /// 
+    /// The method to free the heap allocated by `emalloc`, should call `efree`
+    /// at the end.
+    ///
     /// # Safety
     unsafe fn free(ptr: *mut Self) {
         _efree(ptr.cast());
@@ -22,7 +23,8 @@ pub trait EAllocatable {
 
 /// The Box which use php `emalloc` and `efree` to manage memory.
 ///
-/// TODO now feature `allocator_api` is still unstable, implement myself, use Box<T, Alloc> later.
+/// TODO now feature `allocator_api` is still unstable, implement myself, use
+/// Box<T, Alloc> later.
 pub struct EBox<T: EAllocatable> {
     ptr: *mut T,
 }
@@ -43,9 +45,9 @@ impl<T: EAllocatable> EBox<T> {
     }
 
     /// Constructs from a raw pointer.
-    /// 
+    ///
     /// # Safety
-    /// 
+    ///
     /// Make sure the pointer is created from `emalloc`.
     pub unsafe fn from_raw(raw: *mut T) -> Self {
         Self { ptr: raw }

phper-macros/src/derives.rs

@@ -22,9 +22,7 @@ fn parse_throwable_attrs(input: &DeriveInput) -> syn::Result<TokenStream2> {
 }
 
 fn parse_throwable_input(
-    input: &DeriveInput,
-    crate_ident: TokenStream2,
-    exception: TokenStream2,
+    input: &DeriveInput, crate_ident: TokenStream2, exception: TokenStream2,
 ) -> syn::Result<TokenStream> {
     let input_ident = &input.ident;
 
@@ -49,7 +47,8 @@ fn parse_throwable_input(
                             _ => {
                                 return Err(syn::Error::new_spanned(
                                     &variant,
-                                    "now only support unnamed field with one item mark attribute #[throwable]",
+                                    "now only support unnamed field with one item mark attribute \
+                                     #[throwable]",
                                 ));
                             }
                         }

phper-macros/src/lib.rs

@@ -1,7 +1,8 @@
 #![warn(rust_2018_idioms, clippy::dbg_macro, clippy::print_stdout)]
 #![doc = include_str!("../README.md")]
 
-// TODO Write a bridge macro for easy usage about register functions and classes, like `cxx`.
+// TODO Write a bridge macro for easy usage about register functions and
+// classes, like `cxx`.
 
 mod alloc;
 mod derives;
@@ -60,7 +61,6 @@ pub fn c_str_ptr(input: TokenStream) -> TokenStream {
 ///
 ///     module
 /// }
-///
 /// ```
 #[proc_macro_attribute]
 pub fn php_get_module(attr: TokenStream, input: TokenStream) -> TokenStream {
@@ -84,7 +84,8 @@ pub fn php_get_module(attr: TokenStream, input: TokenStream) -> TokenStream {
 /// }
 /// ```
 ///
-/// TODO Support attribute `throwable` with `class`, `code` and `message`, integration tests.
+/// TODO Support attribute `throwable` with `class`, `code` and `message`,
+/// integration tests.
 #[proc_macro_derive(Throwable, attributes(throwable, throwable_class))]
 pub fn derive_throwable(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);

phper-test/src/cli.rs

@@ -8,9 +8,11 @@ use std::{
 
 use crate::{context::Context, utils};
 
-/// Check your extension by executing the php script, if the all executing return success, than the test is pass.
+/// Check your extension by executing the php script, if the all executing
+/// return success, than the test is pass.
 ///
-/// - `exec_path` is the path of the make executable, which will be used to detect the path of
+/// - `exec_path` is the path of the make executable, which will be used to
+///   detect the path of
 /// extension lib.
 ///
 /// - `scripts` is the path of your php test scripts.
@@ -28,17 +30,19 @@ pub fn test_php_scripts(exe_path: impl AsRef<Path>, scripts: &[&dyn AsRef<Path>]
 /// Script and condition pair.
 pub type ScriptCondition<'a> = (&'a dyn AsRef<Path>, &'a dyn Fn(Output) -> bool);
 
-/// Check your extension by executing the php script, if the all your specified checkers are pass, than the test is pass.
+/// Check your extension by executing the php script, if the all your specified
+/// checkers are pass, than the test is pass.
 ///
-/// - `exec_path` is the path of the make executable, which will be used to detect the path of
+/// - `exec_path` is the path of the make executable, which will be used to
+///   detect the path of
 /// extension lib.
 ///
-/// - `scripts` is the slice of the tuple, format is `(path of your php test script, checker function or closure)`.
+/// - `scripts` is the slice of the tuple, format is `(path of your php test
+///   script, checker function or closure)`.
 ///
 /// See [example logging integration test](https://github.com/jmjoy/phper/blob/master/examples/logging/tests/integration.rs).
 pub fn test_php_scripts_with_condition(
-    exe_path: impl AsRef<Path>,
-    scripts: &[ScriptCondition<'_>],
+    exe_path: impl AsRef<Path>, scripts: &[ScriptCondition<'_>],
 ) {
     let context = Context::get_global();
     let lib_path = utils::get_lib_path(exe_path);
@@ -82,11 +86,10 @@ pub fn test_php_scripts_with_condition(
     }
 }
 
-/// Check your extension by executing the long term php script such as http server, if the all your
-/// specified checkers are pass, than the test is pass.
+/// Check your extension by executing the long term php script such as http
+/// server, if the all your specified checkers are pass, than the test is pass.
 pub fn test_long_term_php_script_with_condition(
-    exe_path: impl AsRef<Path>,
-    script: impl AsRef<Path>,
+    exe_path: impl AsRef<Path>, script: impl AsRef<Path>,
     condition: impl FnOnce(&Child) + UnwindSafe,
 ) {
     let context = Context::get_global();

phper-test/src/context.rs

@@ -73,9 +73,7 @@ impl Context {
     }
 
     pub fn create_command_with_tmp_php_ini_args(
-        &self,
-        tmp_php_ini_file: &NamedTempFile,
-        script: impl AsRef<Path>,
+        &self, tmp_php_ini_file: &NamedTempFile, script: impl AsRef<Path>,
     ) -> ContextCommand {
         let mut cmd = Command::new(&self.php_bin);
         let args = vec![

phper-test/src/fpm.rs

@@ -1,5 +1,4 @@
 //! Test tools for php fpm program.
-//!
 use crate::{context::Context, utils, utils::spawn_command};
 use fastcgi_client::{Client, Params, Request};
 use libc::{atexit, kill, pid_t, SIGTERM};
@@ -92,10 +91,7 @@ extern "C" fn teardown() {
 
 /// Start php-fpm and test the url request.
 pub fn test_fpm_request(
-    method: &str,
-    root: impl AsRef<Path>,
-    request_uri: &str,
-    content_type: Option<String>,
+    method: &str, root: impl AsRef<Path>, request_uri: &str, content_type: Option<String>,
     body: Option<Vec<u8>>,
 ) {
     assert!(FPM_HANDLE.get().is_some(), "must call `setup()` first");

phper/src/arrays.rs

@@ -45,19 +45,19 @@ impl Array {
     }
 
     /// New Array reference from raw pointer.
-    /// 
+    ///
     /// # Safety
-    /// 
+    ///
     /// Make sure pointer is the type of `zend_array'.
     pub unsafe fn from_ptr<'a>(ptr: *const zend_array) -> Option<&'a Array> {
         let ptr = ptr as *const Array;
         ptr.as_ref()
     }
 
     /// New Array mutable reference from raw pointer.
-    /// 
+    ///
     /// # Safety
-    /// 
+    ///
     /// Make sure pointer is the type of `zend_array'.
     pub unsafe fn from_mut_ptr<'a>(ptr: *mut zend_array) -> Option<&'a mut Array> {
         let ptr = ptr as *mut Array;
@@ -190,10 +190,10 @@ impl Array {
 
 impl EAllocatable for Array {
     unsafe fn free(ptr: *mut Self) {
-            (*ptr).inner.gc.refcount -= 1;
-            if (*ptr).inner.gc.refcount == 0 {
-                zend_array_destroy(ptr.cast());
-            }
+        (*ptr).inner.gc.refcount -= 1;
+        if (*ptr).inner.gc.refcount == 0 {
+            zend_array_destroy(ptr.cast());
+        }
     }
 }
 

phper/src/classes.rs

@@ -60,8 +60,7 @@ impl<T: Default + Send + 'static> DynamicClass<T> {
 
 impl<T: Send + 'static> DynamicClass<T> {
     pub fn new_with_constructor(
-        class_name: impl ToString,
-        state_constructor: impl Fn() -> T + Send + Sync + 'static,
+        class_name: impl ToString, state_constructor: impl Fn() -> T + Send + Sync + 'static,
     ) -> Self {
         Self {
             class_name: class_name.to_string(),
@@ -72,15 +71,12 @@ impl<T: Send + 'static> DynamicClass<T> {
             _p: Default::default(),
         }
         // let ptr = &dyn_class.data_constructor as *const _ as usize;
-        // dyn_class.add_property(DATA_CONSTRUCTOR_PROPERTY_NAME, ptr.to_string());
+        // dyn_class.add_property(DATA_CONSTRUCTOR_PROPERTY_NAME,
+        // ptr.to_string());
     }
 
     pub fn add_method<F, R>(
-        &mut self,
-        name: impl ToString,
-        vis: Visibility,
-        handler: F,
-        arguments: Vec<Argument>,
+        &mut self, name: impl ToString, vis: Visibility, handler: F, arguments: Vec<Argument>,
     ) where
         F: Fn(&mut Object<T>, &mut [Val]) -> R + Send + Sync + 'static,
         R: SetVal + 'static,
@@ -95,11 +91,7 @@ impl<T: Send + 'static> DynamicClass<T> {
     }
 
     pub fn add_static_method<F, R>(
-        &mut self,
-        name: impl ToString,
-        vis: Visibility,
-        handler: F,
-        arguments: Vec<Argument>,
+        &mut self, name: impl ToString, vis: Visibility, handler: F, arguments: Vec<Argument>,
     ) where
         F: Fn(&mut [Val]) -> R + Send + Sync + 'static,
         R: SetVal + 'static,
@@ -115,13 +107,11 @@ impl<T: Send + 'static> DynamicClass<T> {
 
     /// Declare property.
     ///
-    /// The argument `value` should be `Copy` because 'zend_declare_property' receive only scalar
-    /// zval , otherwise will report fatal error: "Internal zvals cannot be refcounted".
+    /// The argument `value` should be `Copy` because 'zend_declare_property'
+    /// receive only scalar zval , otherwise will report fatal error:
+    /// "Internal zvals cannot be refcounted".
     pub fn add_property(
-        &mut self,
-        name: impl ToString,
-        visibility: Visibility,
-        value: impl Into<Scalar>,
+        &mut self, name: impl ToString, visibility: Visibility, value: impl Into<Scalar>,
     ) {
         self.property_entities
             .push(PropertyEntity::new(name, visibility, value));
@@ -168,11 +158,13 @@ pub type StatelessClassEntry = ClassEntry<()>;
 ///
 /// # Generic
 ///
-/// 1. Any `zend_class_entry` can be make into `ClassEntry<()>`, alias as [StatelessClassEntry].
+/// 1. Any `zend_class_entry` can be make into `ClassEntry<()>`, alias as
+/// [StatelessClassEntry].
 ///
-/// 2. Only the `zend_class_entry` created by [crate::modules::Module::add_class] can be make into
-/// `ClassEntry<T>`, where `T` is the type defined by [Classifiable::state_type_id], as the inner
-/// state of `ClassEntry<T>` and `Object<T>`.
+/// 2. Only the `zend_class_entry` created by
+/// [crate::modules::Module::add_class] can be make into `ClassEntry<T>`, where
+/// `T` is the type defined by [Classifiable::state_type_id], as the inner state
+/// of `ClassEntry<T>` and `Object<T>`.
 #[repr(transparent)]
 pub struct ClassEntry<T: 'static> {
     inner: zend_class_entry,
@@ -226,8 +218,8 @@ impl<T: 'static> ClassEntry<T> {
         Ok(object)
     }
 
-    /// Create the object from class, without calling `__construct`, be careful when `__construct`
-    /// is necessary.
+    /// Create the object from class, without calling `__construct`, be careful
+    /// when `__construct` is necessary.
     pub fn init_object(&self) -> crate::Result<EBox<Object<T>>> {
         unsafe {
             let ptr = self.as_ptr() as *mut _;