manuwhat / named-args

src/NamedArgs.php

Spacing +33 added lines, -33 removed lines

@@ -2,21 +2,21 @@ 
 namespace EZAMA{
     class NamedArgs
     {
-        protected $parameters=array();
+        protected $parameters = array();
         
         public function __construct($mandatory)
         {
             if (!\is_array($mandatory)) {
                 throw new \InvalidArgumentException(\sprintf('parameter type must be array, %s given', \gettype($mandatory)));
             }
-            $this->parameters=$mandatory;
+            $this->parameters = $mandatory;
         }
         
         protected static function merge(&$arr1, &$arr2)
         {
             foreach ($arr1 as $k=>$v) {
                 if (array_key_exists($k, $arr2)) {
-                    $arr1[$k]=&$arr2[$k];
+                    $arr1[$k] = &$arr2[$k];
                 }
             }
         }
@@ -26,8 +26,8 @@ 
             if (!\is_array($OneDarray)) {
                 return '';
             }
-            if (\count($OneDarray)>1) {
-                $end=array_pop($OneDarray);
+            if (\count($OneDarray) > 1) {
+                $end = array_pop($OneDarray);
                 return \join(',', $OneDarray)." and $end ";
             } else {
                 return array_pop($OneDarray);
@@ -36,7 +36,7 @@ 
         
         protected static function throwError($error)
         {
-            $error=(string)($error);
+            $error = (string) ($error);
             if (\version_compare(\PHP_VERSION, '7.0.0') < 0) {
                 \trigger_error($error, \E_USER_ERROR);
             } else {
@@ -47,29 +47,29 @@ 
         
         protected static function &ProcessParams(&$argument, $required, $default)
         {
-            $missing=array();
+            $missing = array();
             if (!\is_array($argument)) {
                 return \false;
             }
-            $argument=array_intersect_key($argument, $default);//keep only predefined names
+            $argument = array_intersect_key($argument, $default); //keep only predefined names
             //check for missing required parameters
             foreach ($required as $k=>$v) {
                 if (!array_key_exists($v, $argument)) {
-                    $missing[]=$v;
+                    $missing[] = $v;
                 }
             }
 
             if (!empty($missing)) {
-                $function=\debug_backtrace();
-                $function=\end($function);
-                $function=$function['function'];
-                $cm=\count($missing);
-                $error=\call_user_func_array('sprintf', array('Function  %s\'s  Required '.($cm>1?'parameters %s are':'parameter %s is').' missing',$function,NamedArgs::format($missing)));
+                $function = \debug_backtrace();
+                $function = \end($function);
+                $function = $function['function'];
+                $cm = \count($missing);
+                $error = \call_user_func_array('sprintf', array('Function  %s\'s  Required '.($cm > 1 ? 'parameters %s are' : 'parameter %s is').' missing', $function, NamedArgs::format($missing)));
                 self::throwError($error);
             }
             
             
-            self::merge($default, $argument);//assign given values to parameters while keeping references
+            self::merge($default, $argument); //assign given values to parameters while keeping references
             return $default;
         }
         
@@ -78,19 +78,19 @@ 
             if (self::is_valid_associative($this->parameters)) {
                 return self::ProcessParams($this->parameters, $required, $default);
             } else {
-                $cp=\count($this->parameters);
-                if ($cp>=\count($required)) {
+                $cp = \count($this->parameters);
+                if ($cp >= \count($required)) {
                     foreach (array_keys($default) as $k=>$v) {
-                        if ($k===$cp) {
+                        if ($k === $cp) {
                             break;
                         }
-                        $default[$v]=&$this->parameters[$k];
+                        $default[$v] = &$this->parameters[$k];
                     }
                     return self::ProcessParams($default, $required, $default);
                 } else {
-                    $function=\debug_backtrace();
-                    $function=\end($function);
-                    $function=$function['function'];
+                    $function = \debug_backtrace();
+                    $function = \end($function);
+                    $function = $function['function'];
 
                     self::throwError(\sprintf('Function  %s : Two few parameters supplied', $function));
                 }
@@ -103,7 +103,7 @@ 
                 return \false;
             }
             foreach ($array as $k=>$v) {
-                if (!\preg_match('#^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$#', (string)$k)) {
+                if (!\preg_match('#^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$#', (string) $k)) {
                     return \false;
                 }
             }
@@ -113,7 +113,7 @@ 
         public static function __callStatic($name, $mandatory)
         {
             if (empty($mandatory)) {
-                $mandatory[0]=[];
+                $mandatory[0] = [];
             }
             
             if ($mandatory[0] instanceof NamedArgs) {
@@ -127,7 +127,7 @@ 
         
         protected static function func($func, NamedArgs $mandatory)
         {
-            $args=&$mandatory->parameters;
+            $args = &$mandatory->parameters;
             return self::processParamsAndArgs($func, $args);
         }
         
@@ -145,10 +145,10 @@ 
         
         protected static function getValues(&$func, &$params, $paramsArgs, &$args, $associative)
         {
-            foreach ((array)$params as $k=> $param) {
-                $key=$associative?$param->name:$k;
+            foreach ((array) $params as $k=> $param) {
+                $key = $associative ? $param->name : $k;
                 if (array_key_exists($key, $args)) {
-                    $paramsArgs[]=&$args[$key];
+                    $paramsArgs[] = &$args[$key];
                 } else {
                     self::elseifGetValues($func, $param, $paramsArgs);
                 }
@@ -165,12 +165,12 @@ 
         
         protected static function getParamDefaultValue(\reflectionParameter $param)
         {
-            return $param->getDefaultValueConstantName()?\constant($param->getDefaultValueConstantName()):$param->getDefaultValue();
+            return $param->getDefaultValueConstantName() ?\constant($param->getDefaultValueConstantName()) : $param->getDefaultValue();
         }
         
         protected static function canGetParamDefaultValue(\reflectionFunction $func, \reflectionParameter $param)
         {
-            return !$func->isInternal()&&($param->isDefaultValueAvailable()||$param->isDefaultValueConstant());
+            return !$func->isInternal() && ($param->isDefaultValueAvailable() || $param->isDefaultValueConstant());
         }
         
         
@@ -179,9 +179,9 @@ 
             if (self::canGetParamDefaultValue($func, $param)) {
                 $paramsArgs[] = self::getParamDefaultValue($param);
             } elseif ($param->allowsNull()) {
-                $paramsArgs[]=null;
+                $paramsArgs[] = null;
             } else {
-                self::handleOptional(!$param->isOptional(), (string)$func->name, (string)$param->name);
+                self::handleOptional(!$param->isOptional(), (string) $func->name, (string) $param->name);
             }
         }
 
@@ -189,7 +189,7 @@ 
         {
             self::getReflection($func);
             $paramsArgs = array();
-            $params =$func->getParameters();
+            $params = $func->getParameters();
             return $func->invokeArgs(self::getValues($func, $params, $paramsArgs, $args, self::is_valid_associative($args)));
         }
     }