Update coding style

Author: haihv433

Helper/HooksHelper.php

@@ -8,6 +8,7 @@
 
 namespace Goomento\Core\Helper;
 
+use Goomento\Core\Model\Transport;
 use Goomento\Core\Traits\TraitStaticInstances;
 use Goomento\Core\Model\HookManager;
 
@@ -39,12 +40,13 @@ public static function addAction(string $tag, $callbackToAdd, int $sortOrder = 1
     /**
      * Hooks a function or method to a specific filter action.
      *
-     * @param string $tag The name of the filter to hook the $function_to_add callback to.
+     * @param string $tag The name of the filter to hook the $callbackToAdd callback to.
      * @param callable|string|array $callbackToAdd The callback to be run when the filter is applied.
      * @param int $sortOrder The order in which the functions associated with a
      *                                  particular action are executed. Lower numbers correspond with
      *                                  earlier execution, and functions with the same priority are executed
      *                                  in the order in which they were added to the action.
+     * @return Transport
      *
      */
     public static function addFilter(
@@ -55,7 +57,7 @@ public static function addFilter(
     {
         /** @var HookManager $instance */
         $instance = self::getInstance(HookManager::class);
-        $instance->addFilter($tag, $callbackToAdd, $sortOrder);
+        return $instance->addFilter($tag, $callbackToAdd, $sortOrder);
     }
 
     /**
@@ -69,6 +71,7 @@ public static function addFilter(
      * The function also allows for multiple additional arguments to be passed to hooks.
      * @param string $tag     The name of the filter hook.
      * @param mixed  $value   The value to filter.
+     * @return Transport
      */
     public static function applyFilters(string $tag, ...$value)
     {
@@ -143,7 +146,7 @@ public static function removeAction(string $tag, $callbackToRemove, int $sortOrd
      * @param string $tag The name of the filter hook. Used for building
      *                                         the callback ID when SPL is not available. Default empty.
      * @param callable|null $functionToCheck Optional. The callback to check for. Default false.
-     * @return bool|int The priority of that hook is returned, or false if the function is not attached.
+     * @return bool The priority of that hook is returned, or false if the function is not attached.
      */
     public static function hasFilter($tag, $functionToCheck = null)
     {

Model/AssetDependencies.php

@@ -50,19 +50,18 @@ abstract class AssetDependencies
      * @var array
      */
     protected $groups = [];
+
     /**
      * @var HookManager
+     * @deprecated
      */
     protected $hookManager;
 
     /**
      * ScriptsManager constructor.
-     * @param HookManager $hookManager
      */
-    public function __construct(
-        HookManager $hookManager
-    ) {
-        $this->hookManager = $hookManager;
+    public function __construct()
+    {
         $this->init();
     }
 
@@ -132,31 +131,31 @@ public function allDeps($handles, $recursion = false, $group = false)
         }
 
         foreach ($handles as $handle) {
-            $handle_parts = explode('?', $handle);
-            $handle       = $handle_parts[0];
+            $handleParts = explode('?', $handle);
+            $handle       = $handleParts[0];
             $queued       = in_array($handle, $this->toDo, true);
 
             if (in_array($handle, $this->done, true)) { // Already done
                 continue;
             }
 
             $moved     = $this->setGroup($handle, $recursion, $group);
-            $new_group = $this->groups[ $handle ];
+            $newGroup = $this->groups[ $handle ];
 
             if ($queued && ! $moved) { // already queued and in the right group
                 continue;
             }
 
-            $keep_going = true;
+            $keepGoing = true;
             if (! isset($this->registered[ $handle ])) {
-                $keep_going = false; // Item doesn't exist.
+                $keepGoing = false; // Item doesn't exist.
             } elseif ($this->registered[ $handle ]['deps'] && array_diff($this->registered[ $handle ]['deps'], array_keys($this->registered))) {
-                $keep_going = false; // Item requires dependencies that don't exist.
-            } elseif ($this->registered[ $handle ]['deps'] && ! $this->allDeps($this->registered[ $handle ]['deps'], true, $new_group)) {
-                $keep_going = false; // Item requires dependencies that don't exist.
+                $keepGoing = false; // Item requires dependencies that don't exist.
+            } elseif ($this->registered[ $handle ]['deps'] && ! $this->allDeps($this->registered[ $handle ]['deps'], true, $newGroup)) {
+                $keepGoing = false; // Item requires dependencies that don't exist.
             }
 
-            if (! $keep_going) { // Either item or its dependencies don't exist.
+            if (! $keepGoing) { // Either item or its dependencies don't exist.
                 if ($recursion) {
                     return false; // Abort this branch.
                 } else {
@@ -168,8 +167,8 @@ public function allDeps($handles, $recursion = false, $group = false)
                 continue;
             }
 
-            if (isset($handle_parts[1])) {
-                $this->args[ $handle ] = $handle_parts[1];
+            if (isset($handleParts[1])) {
+                $this->args[ $handle ] = $handleParts[1];
             }
 
             $this->toDo[] = $handle;

Model/Hook.php

@@ -51,6 +51,19 @@ class Hook implements Iterator, ArrayAccess
      */
     private $doingAction = false;
 
+    /**
+     * @var Transport
+     */
+    private $transport;
+
+    /**
+     * Hook Constructor
+     */
+    public function __construct()
+    {
+        $this->transport = new Transport([]);
+    }
+
     /**
      * Reveal the callbacks
      *
@@ -63,56 +76,59 @@ public function getCallBacks()
 
     /**
      * Hooks a function or method to a specific filter action.
+     * @return Transport
      */
     public function addFilter(string $tag, $functionToAdd, int $priority)
     {
         $idx = $this->uniqueId($tag, $functionToAdd, $priority);
-        $priority_existed = isset($this->callbacks[$priority]);
+        $priorityExisted = isset($this->callbacks[$priority]);
 
         $this->callbacks[$priority][$idx] = [
             'function' => $functionToAdd,
         ];
 
         // if we're adding a new priority to the list, put them back in sorted order
-        if (!$priority_existed && count($this->callbacks) > 1) {
+        if (!$priorityExisted && count($this->callbacks) > 1) {
             ksort($this->callbacks, SORT_NUMERIC);
         }
 
         if ($this->nestingLevel > 0) {
-            $this->resortActiveIterations($priority, $priority_existed);
+            $this->resortActiveIterations($priority, $priorityExisted);
         }
+
+        return $this->transport;
     }
 
     /**
      * Handles resetting callback priority keys mid-iteration.
      *
-     * @param bool|int $new_priority Optional. The priority of the new filter being added. Default false,
+     * @param bool|int $newPriority Optional. The priority of the new filter being added. Default false,
      *                                   for no priority being added.
      * @param bool $priorityExisted Optional. Flag for whether the priority already existed before the new
      *                                   filter was added. Default false.
      *
      */
-    private function resortActiveIterations($new_priority = false, bool $priorityExisted = false)
+    private function resortActiveIterations($newPriority = false, bool $priorityExisted = false)
     {
-        $new_priorities = array_keys($this->callbacks);
+        $newPriorities = array_keys($this->callbacks);
 
         // If there are no remaining hooks, clear out all running iterations.
-        if (!$new_priorities) {
+        if (!$newPriorities) {
             foreach ($this->iterations as $index => $iteration) {
-                $this->iterations[$index] = $new_priorities;
+                $this->iterations[$index] = $newPriorities;
             }
             return;
         }
 
-        $min = min($new_priorities);
+        $min = min($newPriorities);
         foreach ($this->iterations as $index => &$iteration) {
             $current = current($iteration);
             // If we're already at the end of this iteration, just leave the array pointer where it is.
             if (false === $current) {
                 continue;
             }
 
-            $iteration = $new_priorities;
+            $iteration = $newPriorities;
 
             if ($current < $min) {
                 array_unshift($iteration, $current);
@@ -125,7 +141,7 @@ private function resortActiveIterations($new_priority = false, bool $priorityExi
                 }
             }
 
-            if ($new_priority === $this->currentPriority[$index] && !$priorityExisted) {
+            if ($newPriority === $this->currentPriority[$index] && !$priorityExisted) {
                 /*
                  * ... and the new priority is the same as what $this->iterations thinks is the previous
                  * priority, we need to move back to it.
@@ -141,7 +157,7 @@ private function resortActiveIterations($new_priority = false, bool $priorityExi
                 if (false === $prev) {
                     // Start of the array. Reset, and go about our day.
                     reset($iteration);
-                } elseif ($new_priority !== $prev) {
+                } elseif ($newPriority !== $prev) {
                     // Previous wasn't the same. Move forward again.
                     next($iteration);
                 }
@@ -162,11 +178,11 @@ private function resortActiveIterations($new_priority = false, bool $priorityExi
      */
     public function removeFilter(string $tag, callable $functionToRemove, int $priority)
     {
-        $function_key = $this->uniqueId($tag, $functionToRemove, $priority);
+        $functionKey = $this->uniqueId($tag, $functionToRemove, $priority);
 
-        $exists = isset($this->callbacks[$priority][$function_key]);
+        $exists = isset($this->callbacks[$priority][$functionKey]);
         if ($exists) {
-            unset($this->callbacks[$priority][$function_key]);
+            unset($this->callbacks[$priority][$functionKey]);
             if (!$this->callbacks[$priority]) {
                 unset($this->callbacks[$priority]);
                 if ($this->nestingLevel > 0) {
@@ -191,13 +207,13 @@ public function hasFilter(string $tag = '', $functionToCheck = false)
             return $this->hasFilters();
         }
 
-        $function_key = $this->uniqueId($tag, $functionToCheck, false);
-        if (!$function_key) {
+        $functionKey = $this->uniqueId($tag, $functionToCheck, false);
+        if (!$functionKey) {
             return false;
         }
 
         foreach ($this->callbacks as $priority => $callbacks) {
-            if (isset($callbacks[$function_key])) {
+            if (isset($callbacks[$functionKey])) {
                 return $priority;
             }
         }
@@ -294,37 +310,63 @@ private function uniqueId(string $tag, $function, $priority)
     /**
      * @param $value
      * @param array $args
-     * @return false|mixed
+     * @return Transport
      */
     public function applyFilters($value, array $args)
     {
+        $transport = $this->transport;
+
+        $transport->setData('_args', $args);
+        $transport->setData('_value', $value);
+
+        $transport->setResult($value);
+
         if (!$this->callbacks) {
-            return $value;
+            return $transport;
         }
 
-        $nesting_level = $this->nestingLevel++;
+        $nestingLevel = $this->nestingLevel++;
+
+        $this->iterations[$nestingLevel] = array_keys($this->callbacks);
 
-        $this->iterations[$nesting_level] = array_keys($this->callbacks);
+        $args[] = $transport;
+
+        $valueClass =  is_object($value) ? get_class($value) : null;
 
         do {
-            $this->currentPriority[$nesting_level] = current($this->iterations[$nesting_level]);
-            $priority = $this->currentPriority[$nesting_level];
+            $this->currentPriority[$nestingLevel] = current($this->iterations[$nestingLevel]);
+
+            $priority = $this->currentPriority[$nestingLevel];
 
             foreach ($this->callbacks[$priority] as $the_) {
                 if (!$this->doingAction) {
                     $args[0] = $value;
                 }
 
                 $value = call_user_func_array($the_['function'], $args);
+
+                if ($value === null) { // Return void
+                    $value = $transport->getData('_value');
+                } else {
+                    $valueType = gettype($value);
+                    $resultType = gettype($transport->getResult());
+
+                    $transport->setResult($value);
+
+                    if ($valueType !== $resultType || // Not the same type
+                        ($valueType === 'object' && $valueClass && get_class($value) !== $valueClass)) { // Not the same class
+                        $value = $transport->getData('_value');
+                    }
+                }
             }
-        } while (false !== next($this->iterations[$nesting_level]));
+        } while (false !== next($this->iterations[$nestingLevel]));
 
-        unset($this->iterations[$nesting_level]);
-        unset($this->currentPriority[$nesting_level]);
+        unset($this->iterations[$nestingLevel]);
+        unset($this->currentPriority[$nestingLevel]);
 
         $this->nestingLevel--;
 
-        return $value;
+        return $transport;
     }
 
     /**
@@ -350,17 +392,17 @@ public function doAction(array $args)
      */
     public function doAllHook(array &$args)
     {
-        $nesting_level = $this->nestingLevel++;
-        $this->iterations[$nesting_level] = array_keys($this->callbacks);
+        $nestingLevel = $this->nestingLevel++;
+        $this->iterations[$nestingLevel] = array_keys($this->callbacks);
 
         do {
-            $priority = current($this->iterations[$nesting_level]);
+            $priority = current($this->iterations[$nestingLevel]);
             foreach ($this->callbacks[$priority] as $the_) {
                 call_user_func_array($the_['function'], $args);
             }
-        } while (false !== next($this->iterations[$nesting_level]));
+        } while (false !== next($this->iterations[$nestingLevel]));
 
-        unset($this->iterations[$nesting_level]);
+        unset($this->iterations[$nestingLevel]);
         $this->nestingLevel--;
     }