manuwhat / named-args

tests/NamedArgsTest.php

Indentation +1 added lines, -1 removed lines

@@ -18,7 +18,7 @@
                         'subject'=>'gris|gros|gras|grue'
                     ]
                 )
-         ),
+            ),
             preg_match_all('#a|o|i|u|e#', 'gris|gros|gras|grue', $matches1)
         );
         

Spacing +2 added lines, -2 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 use PHPUnit\Framework\TestCase;
 
-require ($dir=dirname(__DIR__)).DIRECTORY_SEPARATOR.'src'.DIRECTORY_SEPARATOR.'namedArgsHelper.php';
+require ($dir = dirname(__DIR__)).DIRECTORY_SEPARATOR.'src'.DIRECTORY_SEPARATOR.'namedArgsHelper.php';
 require $dir.DIRECTORY_SEPARATOR.'src'.DIRECTORY_SEPARATOR.'namedArgs.php';
 require $dir.DIRECTORY_SEPARATOR.'Args.php';
 use EZAMA\NamedArgs;
@@ -26,7 +26,7 @@ 
         $this->assertEquals($matches0, $matches1);
         
         $this->assertTrue(
-            (bool)NamedArgs::preg_match(
+            (bool) NamedArgs::preg_match(
                 [
                             'subpatterns'=>&$match,
                             'pattern'=>'#a|o|i|u|e#',

testNamedArgs.php

Spacing +24 added lines, -24 removed lines

@@ -5,56 +5,56 @@
 
 function codeWithoutRef(NamedArgs $mandatory)
 {
-    $required=['first','fourth'];//specify required parameters here
-    $default=['first'=>0,'second'=>1,'third'=>2,'fourth'=>9,'fifth'=>7];//define all parameters required and optional with their default values here
+    $required = ['first', 'fourth']; //specify required parameters here
+    $default = ['first'=>0, 'second'=>1, 'third'=>2, 'fourth'=>9, 'fifth'=>7]; //define all parameters required and optional with their default values here
     extract($mandatory->getParams($required, $default));
     unset($mandatory);
-    return $first+$second+$third+$fourth+$fifth;
+    return $first + $second + $third + $fourth + $fifth;
 }
 
 
 function codeWithRef(NamedArgs $mandatory)
 {
-    $required=['first'];
-    $default=['first'=>0,'second'=>1,'third'=>2];
-    extract($mandatory->getParams($required, $default), EXTR_OVERWRITE|EXTR_REFS);
+    $required = ['first'];
+    $default = ['first'=>0, 'second'=>1, 'third'=>2];
+    extract($mandatory->getParams($required, $default), EXTR_OVERWRITE | EXTR_REFS);
     unset($mandatory);
-    $first=$first+$second+$third;
+    $first = $first + $second + $third;
 }
 
 
-function test(&$tada, &$tada2, &$test=6)
+function test(&$tada, &$tada2, &$test = 6)
 {
-    $tada=1;
-    $tada2=2;
-    return  $tada+$tada2+$test;
+    $tada = 1;
+    $tada2 = 2;
+    return  $tada + $tada2 + $test;
 }
 
 
 echo "<pre>";
-var_dump(codeWithoutRef(Args(['fourth'=>9,'first'=>3,'third'=>79])));
-var_dump(codeWithoutRef(Args([1,2,3,0])));
+var_dump(codeWithoutRef(Args(['fourth'=>9, 'first'=>3, 'third'=>79])));
+var_dump(codeWithoutRef(Args([1, 2, 3, 0])));
 
 
-$first=3;
-codeWithRef(Args(['third'=>79,'first'=>&$first]));
+$first = 3;
+codeWithRef(Args(['third'=>79, 'first'=>&$first]));
 var_dump($first);
-$first2=3;
-codeWithRef(Args([&$first2,79]));
+$first2 = 3;
+codeWithRef(Args([&$first2, 79]));
 var_dump($first2);
 
-$tada=$tada2=null;
-var_dump(NamedArgs::test(args(['tada'=>&$tada,'tada2'=>&$tada2])), $tada, $tada2);
+$tada = $tada2 = null;
+var_dump(NamedArgs::test(args(['tada'=>&$tada, 'tada2'=>&$tada2])), $tada, $tada2);
 
-$tada=$tada2=null;
-var_dump(NamedArgs::test(args([&$tada,&$tada2])), $tada, $tada2);
+$tada = $tada2 = null;
+var_dump(NamedArgs::test(args([&$tada, &$tada2])), $tada, $tada2);
 
 
-NamedArgs::preg_match_all(args(['subpatterns'=>&$matches,'pattern'=>'#a|o|i|u|e#','subject'=>'gris|gros|gras|grue']));
+NamedArgs::preg_match_all(args(['subpatterns'=>&$matches, 'pattern'=>'#a|o|i|u|e#', 'subject'=>'gris|gros|gras|grue']));
 
 var_dump($matches);
-var_dump($x=NamedArgs::strtoupper(args(['str'=>'gris|gros|gras|grue'])), NamedArgs::strtolower(args(['str'=>$x])));//just for  funny example.
-NamedArgs::preg_match(['subpatterns'=>&$match,'pattern'=>'#a|o|i|u|e#','subject'=>'gris|gros|gras|grue']);
+var_dump($x = NamedArgs::strtoupper(args(['str'=>'gris|gros|gras|grue'])), NamedArgs::strtolower(args(['str'=>$x]))); //just for  funny example.
+NamedArgs::preg_match(['subpatterns'=>&$match, 'pattern'=>'#a|o|i|u|e#', 'subject'=>'gris|gros|gras|grue']);
 var_dump($match);
 
 highlight_string('

src/namedArgsHelper.php

Spacing +5 added lines, -5 removed lines

@@ -7,7 +7,7 @@ 
         {
             foreach ($arr1 as $k=>$v) {
                 if (array_key_exists($k, $arr2)) {
-                    $arr1[$k]=&$arr2[$k];
+                    $arr1[$k] = &$arr2[$k];
                 }
             }
         }
@@ -17,8 +17,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);
@@ -27,7 +27,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 {
@@ -41,7 +41,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;
                 }
             }

src/NamedArgs.php

Spacing +28 added lines, -28 removed lines

@@ -3,41 +3,41 @@ 
 
     class namedArgs extends namedArgsHelper
     {
-        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 &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;
         }
         
@@ -46,19 +46,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));
                 }
@@ -70,7 +70,7 @@ 
         public static function __callStatic($name, $mandatory)
         {
             if (empty($mandatory)) {
-                $mandatory[0]=[];
+                $mandatory[0] = [];
             }
             
             if ($mandatory[0] instanceof NamedArgs) {
@@ -84,7 +84,7 @@ 
         
         protected static function func($func, NamedArgs $mandatory)
         {
-            $args=&$mandatory->parameters;
+            $args = &$mandatory->parameters;
             return self::processParamsAndArgs($func, $args);
         }
         
@@ -92,10 +92,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);
                 }
@@ -112,12 +112,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());
         }
         
         
@@ -126,9 +126,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);
             }
         }
 
@@ -136,7 +136,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)));
         }
     }