Passed
Push — master ( 8b6717...c8a221 )
by Gaetano
08:12
created
src/Server.php 1 patch
Spacing   +64 added lines, -64 removed lines patch added patch discarded remove patch
@@ -251,7 +251,7 @@  discard block
 block discarded – undo
251 251
     public function getOptions()
252 252
     {
253 253
         $values = array();
254
-        foreach(static::$options as $opt) {
254
+        foreach (static::$options as $opt) {
255 255
             $values[$opt] = $this->getOption($opt);
256 256
         }
257 257
         return $values;
@@ -264,7 +264,7 @@  discard block
 block discarded – undo
264 264
      */
265 265
     public function setOptions($options)
266 266
     {
267
-        foreach($options as $name => $value) {
267
+        foreach ($options as $name => $value) {
268 268
             $this->setOption($name, $value);
269 269
         }
270 270
 
@@ -302,7 +302,7 @@  discard block
 block discarded – undo
302 302
      */
303 303
     public static function xmlrpc_debugmsg($msg)
304 304
     {
305
-        static::$_xmlrpc_debuginfo .= $msg . "\n";
305
+        static::$_xmlrpc_debuginfo .= $msg."\n";
306 306
     }
307 307
 
308 308
     /**
@@ -314,7 +314,7 @@  discard block
 block discarded – undo
314 314
      */
315 315
     public static function error_occurred($msg)
316 316
     {
317
-        static::$_xmlrpcs_occurred_errors .= $msg . "\n";
317
+        static::$_xmlrpcs_occurred_errors .= $msg."\n";
318 318
     }
319 319
 
320 320
     /**
@@ -335,10 +335,10 @@  discard block
 block discarded – undo
335 335
         // user debug info should be encoded by the end user using the INTERNAL_ENCODING
336 336
         $out = '';
337 337
         if ($this->debug_info != '') {
338
-            $out .= "<!-- SERVER DEBUG INFO (BASE64 ENCODED):\n" . base64_encode($this->debug_info) . "\n-->\n";
338
+            $out .= "<!-- SERVER DEBUG INFO (BASE64 ENCODED):\n".base64_encode($this->debug_info)."\n-->\n";
339 339
         }
340 340
         if (static::$_xmlrpc_debuginfo != '') {
341
-            $out .= "<!-- DEBUG INFO:\n" . $this->getCharsetEncoder()->encodeEntities(str_replace('--', '_-', static::$_xmlrpc_debuginfo), PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "\n-->\n";
341
+            $out .= "<!-- DEBUG INFO:\n".$this->getCharsetEncoder()->encodeEntities(str_replace('--', '_-', static::$_xmlrpc_debuginfo), PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding)."\n-->\n";
342 342
             // NB: a better solution MIGHT be to use CDATA, but we need to insert it
343 343
             // into return payload AFTER the beginning tag
344 344
             //$out .= "<![CDATA[ DEBUG INFO:\n\n" . str_replace(']]>', ']_]_>', static::$_xmlrpc_debuginfo) . "\n]]>\n";
@@ -367,8 +367,8 @@  discard block
 block discarded – undo
367 367
         $this->debug_info = '';
368 368
 
369 369
         // Save what we received, before parsing it
370
-        if ($this->debug > 1) {
371
-            $this->debugMsg("+++GOT+++\n" . $data . "\n+++END+++");
370
+        if ($this->debug>1) {
371
+            $this->debugMsg("+++GOT+++\n".$data."\n+++END+++");
372 372
         }
373 373
 
374 374
         $resp = $this->parseRequestHeaders($data, $reqCharset, $respCharset, $respEncoding);
@@ -385,9 +385,9 @@  discard block
 block discarded – undo
385 385
             $resp->raw_data = $rawData;
386 386
         }
387 387
 
388
-        if ($this->debug > 2 && static::$_xmlrpcs_occurred_errors != '') {
389
-            $this->debugMsg("+++PROCESSING ERRORS AND WARNINGS+++\n" .
390
-                static::$_xmlrpcs_occurred_errors . "+++END+++");
388
+        if ($this->debug>2 && static::$_xmlrpcs_occurred_errors != '') {
389
+            $this->debugMsg("+++PROCESSING ERRORS AND WARNINGS+++\n".
390
+                static::$_xmlrpcs_occurred_errors."+++END+++");
391 391
         }
392 392
 
393 393
         $payload = $this->generatePayload($resp, $respCharset);
@@ -482,9 +482,9 @@  discard block
 block discarded – undo
482 482
             $numParams = count($in);
483 483
         }
484 484
         foreach ($sigs as $curSig) {
485
-            if (count($curSig) == $numParams + 1) {
485
+            if (count($curSig) == $numParams+1) {
486 486
                 $itsOK = 1;
487
-                for ($n = 0; $n < $numParams; $n++) {
487
+                for ($n = 0; $n<$numParams; $n++) {
488 488
                     if (is_object($in)) {
489 489
                         $p = $in->getParam($n);
490 490
                         if ($p->kindOf() == 'scalar') {
@@ -497,10 +497,10 @@  discard block
 block discarded – undo
497 497
                     }
498 498
 
499 499
                     // param index is $n+1, as first member of sig is return type
500
-                    if ($pt != $curSig[$n + 1] && $curSig[$n + 1] != Value::$xmlrpcValue) {
500
+                    if ($pt != $curSig[$n+1] && $curSig[$n+1] != Value::$xmlrpcValue) {
501 501
                         $itsOK = 0;
502
-                        $pno = $n + 1;
503
-                        $wanted = $curSig[$n + 1];
502
+                        $pno = $n+1;
503
+                        $wanted = $curSig[$n+1];
504 504
                         $got = $pt;
505 505
                         break;
506 506
                     }
@@ -527,10 +527,10 @@  discard block
 block discarded – undo
527 527
         // check if $_SERVER is populated: it might have been disabled via ini file
528 528
         // (this is true even when in CLI mode)
529 529
         if (count($_SERVER) == 0) {
530
-            $this->getLogger()->error('XML-RPC: ' . __METHOD__ . ': cannot parse request headers as $_SERVER is not populated');
530
+            $this->getLogger()->error('XML-RPC: '.__METHOD__.': cannot parse request headers as $_SERVER is not populated');
531 531
         }
532 532
 
533
-        if ($this->debug > 1) {
533
+        if ($this->debug>1) {
534 534
             if (function_exists('getallheaders')) {
535 535
                 $this->debugMsg(''); // empty line
536 536
                 foreach (getallheaders() as $name => $val) {
@@ -555,13 +555,13 @@  discard block
 block discarded – undo
555 555
                 if (function_exists('gzinflate') && in_array($contentEncoding, $this->accepted_compression)) {
556 556
                     if ($contentEncoding == 'deflate' && $degzdata = @gzuncompress($data)) {
557 557
                         $data = $degzdata;
558
-                        if ($this->debug > 1) {
559
-                            $this->debugMsg("\n+++INFLATED REQUEST+++[" . strlen($data) . " chars]+++\n" . $data . "\n+++END+++");
558
+                        if ($this->debug>1) {
559
+                            $this->debugMsg("\n+++INFLATED REQUEST+++[".strlen($data)." chars]+++\n".$data."\n+++END+++");
560 560
                         }
561 561
                     } elseif ($contentEncoding == 'gzip' && $degzdata = @gzinflate(substr($data, 10))) {
562 562
                         $data = $degzdata;
563
-                        if ($this->debug > 1) {
564
-                            $this->debugMsg("+++INFLATED REQUEST+++[" . strlen($data) . " chars]+++\n" . $data . "\n+++END+++");
563
+                        if ($this->debug>1) {
564
+                            $this->debugMsg("+++INFLATED REQUEST+++[".strlen($data)." chars]+++\n".$data."\n+++END+++");
565 565
                         }
566 566
                     } else {
567 567
                         $r = new static::$responseClass(0, PhpXmlRpc::$xmlrpcerr['server_decompress_fail'],
@@ -649,7 +649,7 @@  discard block
 block discarded – undo
649 649
                     if ($reqEncoding == 'ISO-8859-1') {
650 650
                         $data = utf8_encode($data);
651 651
                     } else {
652
-                        $this->getLogger()->error('XML-RPC: ' . __METHOD__ . ': unsupported charset encoding of received request: ' . $reqEncoding);
652
+                        $this->getLogger()->error('XML-RPC: '.__METHOD__.': unsupported charset encoding of received request: '.$reqEncoding);
653 653
                     }
654 654
                 }
655 655
             }
@@ -684,7 +684,7 @@  discard block
 block discarded – undo
684 684
             preg_match('/^XML error ([0-9]+)/', $_xh['isf_reason'], $matches);
685 685
             return new static::$responseClass(
686 686
                 0,
687
-                (PhpXmlRpc::isUsingInteropFaults() ? PhpXmlRpc::$xmlrpcerr['invalid_xml'] : PhpXmlRpc::$xmlrpcerrxml + (int)$matches[1]),
687
+                (PhpXmlRpc::isUsingInteropFaults() ? PhpXmlRpc::$xmlrpcerr['invalid_xml'] : PhpXmlRpc::$xmlrpcerrxml+(int) $matches[1]),
688 688
                 $_xh['isf_reason']);
689 689
         } elseif ($_xh['isf']) {
690 690
             /// @todo separate better the various cases, as we have done in Request::parseResponse: invalid xml-rpc vs.
@@ -692,7 +692,7 @@  discard block
 block discarded – undo
692 692
             return new static::$responseClass(
693 693
                 0,
694 694
                 PhpXmlRpc::$xmlrpcerr['invalid_request'],
695
-                PhpXmlRpc::$xmlrpcstr['invalid_request'] . ' ' . $_xh['isf_reason']);
695
+                PhpXmlRpc::$xmlrpcstr['invalid_request'].' '.$_xh['isf_reason']);
696 696
         } else {
697 697
             // small layering violation in favor of speed and memory usage: we should allow the 'execute' method handle
698 698
             // this, but in the most common scenario (xml-rpc values type server with some methods registered as phpvals)
@@ -702,8 +702,8 @@  discard block
 block discarded – undo
702 702
                     ($this->dmap[$_xh['method']]['parameters_type'] != 'xmlrpcvals')
703 703
                 )
704 704
             ) {
705
-                if ($this->debug > 1) {
706
-                    $this->debugMsg("\n+++PARSED+++\n" . var_export($_xh['params'], true) . "\n+++END+++");
705
+                if ($this->debug>1) {
706
+                    $this->debugMsg("\n+++PARSED+++\n".var_export($_xh['params'], true)."\n+++END+++");
707 707
                 }
708 708
 
709 709
                 return $this->execute($_xh['method'], $_xh['params'], $_xh['pt']);
@@ -711,12 +711,12 @@  discard block
 block discarded – undo
711 711
                 // build a Request object with data parsed from xml and add parameters in
712 712
                 $req = new Request($_xh['method']);
713 713
                 /// @todo for more speed, we could just pass in the array to the constructor (and loose the type validation)...
714
-                for ($i = 0; $i < count($_xh['params']); $i++) {
714
+                for ($i = 0; $i<count($_xh['params']); $i++) {
715 715
                     $req->addParam($_xh['params'][$i]);
716 716
                 }
717 717
 
718
-                if ($this->debug > 1) {
719
-                    $this->debugMsg("\n+++PARSED+++\n" . var_export($req, true) . "\n+++END+++");
718
+                if ($this->debug>1) {
719
+                    $this->debugMsg("\n+++PARSED+++\n".var_export($req, true)."\n+++END+++");
720 720
                 }
721 721
 
722 722
                 return $this->execute($req);
@@ -766,7 +766,7 @@  discard block
 block discarded – undo
766 766
                 return new static::$responseClass(
767 767
                     0,
768 768
                     PhpXmlRpc::$xmlrpcerr['incorrect_params'],
769
-                    PhpXmlRpc::$xmlrpcstr['incorrect_params'] . ": {$errStr}"
769
+                    PhpXmlRpc::$xmlrpcstr['incorrect_params'].": {$errStr}"
770 770
                 );
771 771
             }
772 772
         }
@@ -781,7 +781,7 @@  discard block
 block discarded – undo
781 781
         // build string representation of function 'name'
782 782
         if (is_array($func)) {
783 783
             if (is_object($func[0])) {
784
-                $funcName = get_class($func[0]) . '->' . $func[1];
784
+                $funcName = get_class($func[0]).'->'.$func[1];
785 785
             } else {
786 786
                 $funcName = implode('::', $func);
787 787
             }
@@ -793,16 +793,16 @@  discard block
 block discarded – undo
793 793
 
794 794
         // verify that function to be invoked is in fact callable
795 795
         if (!is_callable($func)) {
796
-            $this->getLogger()->error("XML-RPC: " . __METHOD__ . ": function '$funcName' registered as method handler is not callable");
796
+            $this->getLogger()->error("XML-RPC: ".__METHOD__.": function '$funcName' registered as method handler is not callable");
797 797
             return new static::$responseClass(
798 798
                 0,
799 799
                 PhpXmlRpc::$xmlrpcerr['server_error'],
800
-                PhpXmlRpc::$xmlrpcstr['server_error'] . ": no function matches method"
800
+                PhpXmlRpc::$xmlrpcstr['server_error'].": no function matches method"
801 801
             );
802 802
         }
803 803
 
804 804
         if (isset($dmap[$methodName]['exception_handling'])) {
805
-            $exception_handling = (int)$dmap[$methodName]['exception_handling'];
805
+            $exception_handling = (int) $dmap[$methodName]['exception_handling'];
806 806
         } else {
807 807
             $exception_handling = $this->exception_handling;
808 808
         }
@@ -823,14 +823,14 @@  discard block
 block discarded – undo
823 823
                     $r = call_user_func($func, $req);
824 824
                 }
825 825
                 if (!is_a($r, 'PhpXmlRpc\Response')) {
826
-                    $this->getLogger()->error("XML-RPC: " . __METHOD__ . ": function '$funcName' registered as method handler does not return an xmlrpc response object but a " . gettype($r));
826
+                    $this->getLogger()->error("XML-RPC: ".__METHOD__.": function '$funcName' registered as method handler does not return an xmlrpc response object but a ".gettype($r));
827 827
                     if (is_a($r, 'PhpXmlRpc\Value')) {
828 828
                         $r = new static::$responseClass($r);
829 829
                     } else {
830 830
                         $r = new static::$responseClass(
831 831
                             0,
832 832
                             PhpXmlRpc::$xmlrpcerr['server_error'],
833
-                            PhpXmlRpc::$xmlrpcstr['server_error'] . ": function does not return xmlrpc response object"
833
+                            PhpXmlRpc::$xmlrpcstr['server_error'].": function does not return xmlrpc response object"
834 834
                         );
835 835
                     }
836 836
                 }
@@ -845,7 +845,7 @@  discard block
 block discarded – undo
845 845
                         $r = call_user_func_array($func, array($methodName, $params, $this->user_data));
846 846
                         // mimic EPI behaviour: if we get an array that looks like an error, make it an error response
847 847
                         if (is_array($r) && array_key_exists('faultCode', $r) && array_key_exists('faultString', $r)) {
848
-                            $r = new static::$responseClass(0, (int)$r['faultCode'], (string)$r['faultString']);
848
+                            $r = new static::$responseClass(0, (int) $r['faultCode'], (string) $r['faultString']);
849 849
                         } else {
850 850
                             // functions using EPI api should NOT return resp objects, so make sure we encode the
851 851
                             // return type correctly
@@ -931,7 +931,7 @@  discard block
 block discarded – undo
931 931
     protected function generatePayload($resp, $respCharset)
932 932
     {
933 933
         $header = $resp->xml_header($respCharset);
934
-        if ($this->debug > 0) {
934
+        if ($this->debug>0) {
935 935
             $header .= $this->serializeDebug($respCharset);
936 936
         }
937 937
 
@@ -943,7 +943,7 @@  discard block
 block discarded – undo
943 943
             $payload = $resp->serialize($respCharset);
944 944
         }
945 945
 
946
-        return $header . $payload;
946
+        return $header.$payload;
947 947
     }
948 948
 
949 949
     /**
@@ -957,7 +957,7 @@  discard block
 block discarded – undo
957 957
         // if we get a warning/error that has output some text before here, then we cannot
958 958
         // add a new header. We cannot say we are sending xml, either...
959 959
         if (!headers_sent()) {
960
-            header('Content-Type: ' . $respContentType);
960
+            header('Content-Type: '.$respContentType);
961 961
             // we do not know if client actually told us an accepted charset, but if it did we have to tell it what we did
962 962
             header("Vary: Accept-Charset");
963 963
 
@@ -980,12 +980,12 @@  discard block
 block discarded – undo
980 980
             // Note that Apache/mod_php will add (and even alter!) the Content-Length header on its own, but only for
981 981
             // responses up to 8000 bytes
982 982
             if ($phpNoSelfCompress) {
983
-                header('Content-Length: ' . (int)strlen($payload));
983
+                header('Content-Length: '.(int) strlen($payload));
984 984
             }
985 985
         } else {
986 986
             /// @todo allow the user to easily subclass this in a way which allows the resp. headers to be already sent
987 987
             ///       by now without flagging it as an error. Possibly check for presence of Content-Type header
988
-            $this->getLogger()->error('XML-RPC: ' . __METHOD__ . ': http headers already sent before response is fully generated. Check for php warning or error messages');
988
+            $this->getLogger()->error('XML-RPC: '.__METHOD__.': http headers already sent before response is fully generated. Check for php warning or error messages');
989 989
         }
990 990
 
991 991
         print $payload;
@@ -1044,7 +1044,7 @@  discard block
 block discarded – undo
1044 1044
      */
1045 1045
     protected function debugMsg($string)
1046 1046
     {
1047
-        $this->debug_info .= $string . "\n";
1047
+        $this->debug_info .= $string."\n";
1048 1048
     }
1049 1049
 
1050 1050
     /**
@@ -1338,7 +1338,7 @@  discard block
 block discarded – undo
1338 1338
                 $i++; // for error message, we count params from 1
1339 1339
                 return static::_xmlrpcs_multicall_error(new static::$responseClass(0,
1340 1340
                     PhpXmlRpc::$xmlrpcerr['incorrect_params'],
1341
-                    PhpXmlRpc::$xmlrpcstr['incorrect_params'] . ": probable xml error in param " . $i));
1341
+                    PhpXmlRpc::$xmlrpcstr['incorrect_params'].": probable xml error in param ".$i));
1342 1342
             }
1343 1343
         }
1344 1344
 
@@ -1419,7 +1419,7 @@  discard block
 block discarded – undo
1419 1419
             }
1420 1420
         } else {
1421 1421
             $numCalls = count($req);
1422
-            for ($i = 0; $i < $numCalls; $i++) {
1422
+            for ($i = 0; $i<$numCalls; $i++) {
1423 1423
                 $result[$i] = static::_xmlrpcs_multicall_do_call_phpvals($server, $req[$i]);
1424 1424
             }
1425 1425
         }
@@ -1447,7 +1447,7 @@  discard block
 block discarded – undo
1447 1447
         // From PHP 8.4 the E_STRICT constant has been deprecated and will emit deprecation notices.
1448 1448
         // PHP core and core extensions since PHP 8.0 and later do not emit E_STRICT notices at all.
1449 1449
         // On PHP 7 series before PHP 7.4, some functions conditionally emit E_STRICT notices.
1450
-        if (PHP_VERSION_ID >= 70400) {
1450
+        if (PHP_VERSION_ID>=70400) {
1451 1451
             static::error_occurred($errString);
1452 1452
         } elseif ($errCode != E_STRICT) {
1453 1453
             static::error_occurred($errString);
@@ -1488,12 +1488,12 @@  discard block
 block discarded – undo
1488 1488
      */
1489 1489
     protected function xml_header($charsetEncoding = '')
1490 1490
     {
1491
-        $this->logDeprecation('Method ' . __METHOD__ . ' is deprecated');
1491
+        $this->logDeprecation('Method '.__METHOD__.' is deprecated');
1492 1492
 
1493 1493
         if ($charsetEncoding != '') {
1494
-            return "<?xml version=\"1.0\" encoding=\"$charsetEncoding\"?" . ">\n";
1494
+            return "<?xml version=\"1.0\" encoding=\"$charsetEncoding\"?".">\n";
1495 1495
         } else {
1496
-            return "<?xml version=\"1.0\"?" . ">\n";
1496
+            return "<?xml version=\"1.0\"?".">\n";
1497 1497
         }
1498 1498
     }
1499 1499
 
@@ -1509,7 +1509,7 @@  discard block
 block discarded – undo
1509 1509
             case self::OPT_FUNCTIONS_PARAMETERS_TYPE:
1510 1510
             case self::OPT_PHPVALS_ENCODING_OPTIONS:
1511 1511
             case self::OPT_RESPONSE_CHARSET_ENCODING:
1512
-                $this->logDeprecation('Getting property Request::' . $name . ' is deprecated');
1512
+                $this->logDeprecation('Getting property Request::'.$name.' is deprecated');
1513 1513
                 return $this->$name;
1514 1514
             case 'accepted_charset_encodings':
1515 1515
                 // manually implement the 'protected property' behaviour
@@ -1521,16 +1521,16 @@  discard block
 block discarded – undo
1521 1521
                     }
1522 1522
                 }
1523 1523
                 if ($canAccess) {
1524
-                    $this->logDeprecation('Getting property Request::' . $name . ' is deprecated');
1524
+                    $this->logDeprecation('Getting property Request::'.$name.' is deprecated');
1525 1525
                     return $this->accepted_compression;
1526 1526
                 } else {
1527
-                    trigger_error("Cannot access protected property Server::accepted_charset_encodings in " . __FILE__, E_USER_ERROR);
1527
+                    trigger_error("Cannot access protected property Server::accepted_charset_encodings in ".__FILE__, E_USER_ERROR);
1528 1528
                 }
1529 1529
                 break;
1530 1530
             default:
1531 1531
                 /// @todo throw instead? There are very few other places where the lib trigger errors which can potentially reach stdout...
1532 1532
                 $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
1533
-                trigger_error('Undefined property via __get(): ' . $name . ' in ' . $trace[0]['file'] . ' on line ' . $trace[0]['line'], E_USER_WARNING);
1533
+                trigger_error('Undefined property via __get(): '.$name.' in '.$trace[0]['file'].' on line '.$trace[0]['line'], E_USER_WARNING);
1534 1534
                 $result = null;
1535 1535
                 return $result;
1536 1536
         }
@@ -1547,7 +1547,7 @@  discard block
 block discarded – undo
1547 1547
             case self::OPT_FUNCTIONS_PARAMETERS_TYPE:
1548 1548
             case self::OPT_PHPVALS_ENCODING_OPTIONS:
1549 1549
             case self::OPT_RESPONSE_CHARSET_ENCODING:
1550
-                $this->logDeprecation('Setting property Request::' . $name . ' is deprecated');
1550
+                $this->logDeprecation('Setting property Request::'.$name.' is deprecated');
1551 1551
                 $this->$name = $value;
1552 1552
                 break;
1553 1553
             case 'accepted_charset_encodings':
@@ -1560,16 +1560,16 @@  discard block
 block discarded – undo
1560 1560
                     }
1561 1561
                 }
1562 1562
                 if ($canAccess) {
1563
-                    $this->logDeprecation('Setting property Request::' . $name . ' is deprecated');
1563
+                    $this->logDeprecation('Setting property Request::'.$name.' is deprecated');
1564 1564
                     $this->accepted_compression = $value;
1565 1565
                 } else {
1566
-                    trigger_error("Cannot access protected property Server::accepted_charset_encodings in " . __FILE__, E_USER_ERROR);
1566
+                    trigger_error("Cannot access protected property Server::accepted_charset_encodings in ".__FILE__, E_USER_ERROR);
1567 1567
                 }
1568 1568
                 break;
1569 1569
             default:
1570 1570
                 /// @todo throw instead? There are very few other places where the lib trigger errors which can potentially reach stdout...
1571 1571
                 $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
1572
-                trigger_error('Undefined property via __set(): ' . $name . ' in ' . $trace[0]['file'] . ' on line ' . $trace[0]['line'], E_USER_WARNING);
1572
+                trigger_error('Undefined property via __set(): '.$name.' in '.$trace[0]['file'].' on line '.$trace[0]['line'], E_USER_WARNING);
1573 1573
         }
1574 1574
     }
1575 1575
 
@@ -1584,7 +1584,7 @@  discard block
 block discarded – undo
1584 1584
             case self::OPT_FUNCTIONS_PARAMETERS_TYPE:
1585 1585
             case self::OPT_PHPVALS_ENCODING_OPTIONS:
1586 1586
             case self::OPT_RESPONSE_CHARSET_ENCODING:
1587
-                $this->logDeprecation('Checking property Request::' . $name . ' is deprecated');
1587
+                $this->logDeprecation('Checking property Request::'.$name.' is deprecated');
1588 1588
                 return isset($this->$name);
1589 1589
             case 'accepted_charset_encodings':
1590 1590
                 // manually implement the 'protected property' behaviour
@@ -1596,7 +1596,7 @@  discard block
 block discarded – undo
1596 1596
                     }
1597 1597
                 }
1598 1598
                 if ($canAccess) {
1599
-                    $this->logDeprecation('Checking property Request::' . $name . ' is deprecated');
1599
+                    $this->logDeprecation('Checking property Request::'.$name.' is deprecated');
1600 1600
                     return isset($this->accepted_compression);
1601 1601
                 }
1602 1602
                 // break through voluntarily
@@ -1616,7 +1616,7 @@  discard block
 block discarded – undo
1616 1616
             case self::OPT_FUNCTIONS_PARAMETERS_TYPE:
1617 1617
             case self::OPT_PHPVALS_ENCODING_OPTIONS:
1618 1618
             case self::OPT_RESPONSE_CHARSET_ENCODING:
1619
-                $this->logDeprecation('Unsetting property Request::' . $name . ' is deprecated');
1619
+                $this->logDeprecation('Unsetting property Request::'.$name.' is deprecated');
1620 1620
                 unset($this->$name);
1621 1621
                 break;
1622 1622
             case 'accepted_charset_encodings':
@@ -1629,16 +1629,16 @@  discard block
 block discarded – undo
1629 1629
                     }
1630 1630
                 }
1631 1631
                 if ($canAccess) {
1632
-                    $this->logDeprecation('Unsetting property Request::' . $name . ' is deprecated');
1632
+                    $this->logDeprecation('Unsetting property Request::'.$name.' is deprecated');
1633 1633
                     unset($this->accepted_compression);
1634 1634
                 } else {
1635
-                    trigger_error("Cannot access protected property Server::accepted_charset_encodings in " . __FILE__, E_USER_ERROR);
1635
+                    trigger_error("Cannot access protected property Server::accepted_charset_encodings in ".__FILE__, E_USER_ERROR);
1636 1636
                 }
1637 1637
                 break;
1638 1638
             default:
1639 1639
                 /// @todo throw instead? There are very few other places where the lib trigger errors which can potentially reach stdout...
1640 1640
                 $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
1641
-                trigger_error('Undefined property via __unset(): ' . $name . ' in ' . $trace[0]['file'] . ' on line ' . $trace[0]['line'], E_USER_WARNING);
1641
+                trigger_error('Undefined property via __unset(): '.$name.' in '.$trace[0]['file'].' on line '.$trace[0]['line'], E_USER_WARNING);
1642 1642
         }
1643 1643
     }
1644 1644
 }
Please login to merge, or discard this patch.
src/Request.php 1 patch
Spacing   +38 added lines, -38 removed lines patch added patch discarded remove patch
@@ -84,7 +84,7 @@  discard block
 block discarded – undo
84 84
 
85 85
             return true;
86 86
         } else {
87
-            $this->getLogger()->error('XML-RPC: ' . __METHOD__ . ': value passed in must be a PhpXmlRpc\Value');
87
+            $this->getLogger()->error('XML-RPC: '.__METHOD__.': value passed in must be a PhpXmlRpc\Value');
88 88
             return false;
89 89
         }
90 90
     }
@@ -134,17 +134,17 @@  discard block
 block discarded – undo
134 134
         $this->logDeprecationUnlessCalledBy('serialize');
135 135
 
136 136
         if ($charsetEncoding != '') {
137
-            $this->content_type = 'text/xml; charset=' . $charsetEncoding;
137
+            $this->content_type = 'text/xml; charset='.$charsetEncoding;
138 138
         } else {
139 139
             $this->content_type = 'text/xml';
140 140
         }
141 141
 
142 142
         $result = $this->xml_header($charsetEncoding);
143
-        $result .= '<methodName>' . $this->getCharsetEncoder()->encodeEntities(
144
-                $this->methodname, PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "</methodName>\n";
143
+        $result .= '<methodName>'.$this->getCharsetEncoder()->encodeEntities(
144
+                $this->methodname, PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding)."</methodName>\n";
145 145
         $result .= "<params>\n";
146 146
         foreach ($this->params as $p) {
147
-            $result .= "<param>\n" . $p->serialize($charsetEncoding) .
147
+            $result .= "<param>\n".$p->serialize($charsetEncoding).
148 148
                 "</param>\n";
149 149
         }
150 150
         $result .= "</params>\n";
@@ -164,9 +164,9 @@  discard block
 block discarded – undo
164 164
         $this->logDeprecationUnlessCalledBy('createPayload');
165 165
 
166 166
         if ($charsetEncoding != '') {
167
-            return "<?xml version=\"1.0\" encoding=\"$charsetEncoding\" ?" . ">\n<methodCall>\n";
167
+            return "<?xml version=\"1.0\" encoding=\"$charsetEncoding\" ?".">\n<methodCall>\n";
168 168
         } else {
169
-            return "<?xml version=\"1.0\"?" . ">\n<methodCall>\n";
169
+            return "<?xml version=\"1.0\"?".">\n<methodCall>\n";
170 170
         }
171 171
     }
172 172
 
@@ -228,14 +228,14 @@  discard block
 block discarded – undo
228 228
      */
229 229
     public function parseResponse($data = '', $headersProcessed = false, $returnType = XMLParser::RETURN_XMLRPCVALS)
230 230
     {
231
-        if ($this->debug > 0) {
231
+        if ($this->debug>0) {
232 232
             $this->getLogger()->debug("---GOT---\n$data\n---END---");
233 233
         }
234 234
 
235 235
         $this->httpResponse = array('raw_data' => $data, 'headers' => array(), 'cookies' => array());
236 236
 
237 237
         if ($data == '') {
238
-            $this->getLogger()->error('XML-RPC: ' . __METHOD__ . ': no response received from server.');
238
+            $this->getLogger()->error('XML-RPC: '.__METHOD__.': no response received from server.');
239 239
             return new Response(0, PhpXmlRpc::$xmlrpcerr['no_data'], PhpXmlRpc::$xmlrpcstr['no_data']);
240 240
         }
241 241
 
@@ -243,12 +243,12 @@  discard block
 block discarded – undo
243 243
         if (substr($data, 0, 4) == 'HTTP') {
244 244
             $httpParser = new Http();
245 245
             try {
246
-                $httpResponse = $httpParser->parseResponseHeaders($data, $headersProcessed, $this->debug > 0);
246
+                $httpResponse = $httpParser->parseResponseHeaders($data, $headersProcessed, $this->debug>0);
247 247
             } catch (HttpException $e) {
248 248
                 // failed processing of HTTP response headers
249 249
                 // save into response obj the full payload received, for debugging
250 250
                 return new Response(0, $e->getCode(), $e->getMessage(), '', array('raw_data' => $data, 'status_code' => $e->statusCode()));
251
-            } catch(\Exception $e) {
251
+            } catch (\Exception $e) {
252 252
                 return new Response(0, $e->getCode(), $e->getMessage(), '', array('raw_data' => $data));
253 253
             }
254 254
         } else {
@@ -264,7 +264,7 @@  discard block
 block discarded – undo
264 264
         // idea from Luca Mariano, originally in PEARified version of the lib
265 265
         $pos = strrpos($data, '</methodResponse>');
266 266
         if ($pos !== false) {
267
-            $data = substr($data, 0, $pos + 17);
267
+            $data = substr($data, 0, $pos+17);
268 268
         }
269 269
 
270 270
         // try to 'guestimate' the character encoding of the received response
@@ -273,21 +273,21 @@  discard block
 block discarded – undo
273 273
             $data
274 274
         );
275 275
 
276
-        if ($this->debug >= 0) {
276
+        if ($this->debug>=0) {
277 277
             $this->httpResponse = $httpResponse;
278 278
         } else {
279 279
             $httpResponse = null;
280 280
         }
281 281
 
282
-        if ($this->debug > 0) {
282
+        if ($this->debug>0) {
283 283
             $start = strpos($data, '<!-- SERVER DEBUG INFO (BASE64 ENCODED):');
284 284
             if ($start) {
285 285
                 $start += strlen('<!-- SERVER DEBUG INFO (BASE64 ENCODED):');
286 286
                 /// @todo what if there is no end tag?
287 287
                 $end = strpos($data, '-->', $start);
288
-                $comments = substr($data, $start, $end - $start);
289
-                $this->getLogger()->debug("---SERVER DEBUG INFO (DECODED)---\n\t" .
290
-                    str_replace("\n", "\n\t", base64_decode($comments)) . "\n---END---", array('encoding' => $respEncoding));
288
+                $comments = substr($data, $start, $end-$start);
289
+                $this->getLogger()->debug("---SERVER DEBUG INFO (DECODED)---\n\t".
290
+                    str_replace("\n", "\n\t", base64_decode($comments))."\n---END---", array('encoding' => $respEncoding));
291 291
             }
292 292
         }
293 293
 
@@ -309,7 +309,7 @@  discard block
 block discarded – undo
309 309
                     if ($respEncoding == 'ISO-8859-1') {
310 310
                         $data = utf8_encode($data);
311 311
                     } else {
312
-                        $this->getLogger()->error('XML-RPC: ' . __METHOD__ . ': unsupported charset encoding of received response: ' . $respEncoding);
312
+                        $this->getLogger()->error('XML-RPC: '.__METHOD__.': unsupported charset encoding of received response: '.$respEncoding);
313 313
                     }
314 314
                 }
315 315
             }
@@ -339,16 +339,16 @@  discard block
 block discarded – undo
339 339
             //       there could be proxies meddling with the request, or network data corruption...
340 340
 
341 341
             $r = new Response(0, PhpXmlRpc::$xmlrpcerr['invalid_xml'],
342
-                PhpXmlRpc::$xmlrpcstr['invalid_xml'] . ' ' . $_xh['isf_reason'], '', $httpResponse);
342
+                PhpXmlRpc::$xmlrpcstr['invalid_xml'].' '.$_xh['isf_reason'], '', $httpResponse);
343 343
 
344
-            if ($this->debug > 0) {
344
+            if ($this->debug>0) {
345 345
                 $this->getLogger()->debug($_xh['isf_reason']);
346 346
             }
347 347
         }
348 348
         // second error check: xml well-formed but not xml-rpc compliant
349 349
         elseif ($_xh['isf'] == 2) {
350 350
             $r = new Response(0, PhpXmlRpc::$xmlrpcerr['xml_not_compliant'],
351
-                PhpXmlRpc::$xmlrpcstr['xml_not_compliant'] . ' ' . $_xh['isf_reason'], '', $httpResponse);
351
+                PhpXmlRpc::$xmlrpcstr['xml_not_compliant'].' '.$_xh['isf_reason'], '', $httpResponse);
352 352
 
353 353
             /// @todo echo something for the user? check if it was already done by the parser...
354 354
             //if ($this->debug > 0) {
@@ -358,7 +358,7 @@  discard block
 block discarded – undo
358 358
         // third error check: parsing of the response has somehow gone boink.
359 359
         /// @todo shall we omit the 2nd part of this check, since we trust the parsing code?
360 360
         ///       Either that, or check the fault results too...
361
-        elseif ($_xh['isf'] > 3 || ($returnType == XMLParser::RETURN_XMLRPCVALS && !$_xh['isf'] && !is_object($_xh['value']))) {
361
+        elseif ($_xh['isf']>3 || ($returnType == XMLParser::RETURN_XMLRPCVALS && !$_xh['isf'] && !is_object($_xh['value']))) {
362 362
             // something odd has happened and it's time to generate a client side error indicating something odd went on
363 363
             $r = new Response(0, PhpXmlRpc::$xmlrpcerr['xml_parsing_error'], PhpXmlRpc::$xmlrpcstr['xml_parsing_error'],
364 364
                 '', $httpResponse
@@ -366,7 +366,7 @@  discard block
 block discarded – undo
366 366
 
367 367
             /// @todo echo something for the user?
368 368
         } else {
369
-            if ($this->debug > 1) {
369
+            if ($this->debug>1) {
370 370
                 $this->getLogger()->debug(
371 371
                     "---PARSED---\n".var_export($_xh['value'], true)."\n---END---"
372 372
                 );
@@ -390,7 +390,7 @@  discard block
 block discarded – undo
390 390
                 if ($errNo == 0) {
391 391
                     // FAULT returned, errno needs to reflect that
392 392
                     /// @todo feature creep - add this code to PhpXmlRpc::$xmlrpcerr
393
-                    $this->getLogger()->error('XML-RPC: ' . __METHOD__ . ': fault response received with faultCode 0 or null. Converted it to -1');
393
+                    $this->getLogger()->error('XML-RPC: '.__METHOD__.': fault response received with faultCode 0 or null. Converted it to -1');
394 394
                     /// @todo in Encoder::decodeXML, we use PhpXmlRpc::$xmlrpcerr['invalid_return'] for this case (see
395 395
                     ///       also the todo 17 lines above)
396 396
                     $errNo = -1;
@@ -438,7 +438,7 @@  discard block
 block discarded – undo
438 438
             case '_php_class':
439 439
             case 'payload':
440 440
             case 'content_type':
441
-                $this->logDeprecation('Getting property Request::' . $name . ' is deprecated');
441
+                $this->logDeprecation('Getting property Request::'.$name.' is deprecated');
442 442
                 return $this->$name;
443 443
             case 'httpResponse':
444 444
                 // manually implement the 'protected property' behaviour
@@ -450,16 +450,16 @@  discard block
 block discarded – undo
450 450
                     }
451 451
                 }
452 452
                 if ($canAccess) {
453
-                    $this->logDeprecation('Getting property Request::' . $name . ' is deprecated');
453
+                    $this->logDeprecation('Getting property Request::'.$name.' is deprecated');
454 454
                     return $this->httpResponse;
455 455
                 } else {
456
-                    trigger_error("Cannot access protected property Request::httpResponse in " . __FILE__, E_USER_ERROR);
456
+                    trigger_error("Cannot access protected property Request::httpResponse in ".__FILE__, E_USER_ERROR);
457 457
                 }
458 458
                 break;
459 459
             default:
460 460
                 /// @todo throw instead? There are very few other places where the lib trigger errors which can potentially reach stdout...
461 461
                 $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
462
-                trigger_error('Undefined property via __get(): ' . $name . ' in ' . $trace[0]['file'] . ' on line ' . $trace[0]['line'], E_USER_WARNING);
462
+                trigger_error('Undefined property via __get(): '.$name.' in '.$trace[0]['file'].' on line '.$trace[0]['line'], E_USER_WARNING);
463 463
                 $result = null;
464 464
                 return $result;
465 465
         }
@@ -473,7 +473,7 @@  discard block
 block discarded – undo
473 473
             case 'debug':
474 474
             case 'payload':
475 475
             case 'content_type':
476
-                $this->logDeprecation('Setting property Request::' . $name . ' is deprecated');
476
+                $this->logDeprecation('Setting property Request::'.$name.' is deprecated');
477 477
                 $this->$name = $value;
478 478
                 break;
479 479
             case 'httpResponse':
@@ -486,16 +486,16 @@  discard block
 block discarded – undo
486 486
                     }
487 487
                 }
488 488
                 if ($canAccess) {
489
-                    $this->logDeprecation('Setting property Request::' . $name . ' is deprecated');
489
+                    $this->logDeprecation('Setting property Request::'.$name.' is deprecated');
490 490
                     $this->httpResponse = $value;
491 491
                 } else {
492
-                    trigger_error("Cannot access protected property Request::httpResponse in " . __FILE__, E_USER_ERROR);
492
+                    trigger_error("Cannot access protected property Request::httpResponse in ".__FILE__, E_USER_ERROR);
493 493
                 }
494 494
                 break;
495 495
             default:
496 496
                 /// @todo throw instead? There are very few other places where the lib trigger errors which can potentially reach stdout...
497 497
                 $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
498
-                trigger_error('Undefined property via __set(): ' . $name . ' in ' . $trace[0]['file'] . ' on line ' . $trace[0]['line'], E_USER_WARNING);
498
+                trigger_error('Undefined property via __set(): '.$name.' in '.$trace[0]['file'].' on line '.$trace[0]['line'], E_USER_WARNING);
499 499
         }
500 500
     }
501 501
 
@@ -507,7 +507,7 @@  discard block
 block discarded – undo
507 507
             case 'debug':
508 508
             case 'payload':
509 509
             case 'content_type':
510
-                $this->logDeprecation('Checking property Request::' . $name . ' is deprecated');
510
+                $this->logDeprecation('Checking property Request::'.$name.' is deprecated');
511 511
                 return isset($this->$name);
512 512
             case 'httpResponse':
513 513
                 // manually implement the 'protected property' behaviour
@@ -519,7 +519,7 @@  discard block
 block discarded – undo
519 519
                     }
520 520
                 }
521 521
                 if ($canAccess) {
522
-                    $this->logDeprecation('Checking property Request::' . $name . ' is deprecated');
522
+                    $this->logDeprecation('Checking property Request::'.$name.' is deprecated');
523 523
                     return isset($this->httpResponse);
524 524
                 }
525 525
                 // break through voluntarily
@@ -536,7 +536,7 @@  discard block
 block discarded – undo
536 536
             case 'debug':
537 537
             case 'payload':
538 538
             case 'content_type':
539
-                $this->logDeprecation('Unsetting property Request::' . $name . ' is deprecated');
539
+                $this->logDeprecation('Unsetting property Request::'.$name.' is deprecated');
540 540
                 unset($this->$name);
541 541
                 break;
542 542
             case 'httpResponse':
@@ -549,16 +549,16 @@  discard block
 block discarded – undo
549 549
                     }
550 550
                 }
551 551
                 if ($canAccess) {
552
-                    $this->logDeprecation('Unsetting property Request::' . $name . ' is deprecated');
552
+                    $this->logDeprecation('Unsetting property Request::'.$name.' is deprecated');
553 553
                     unset($this->httpResponse);
554 554
                 } else {
555
-                    trigger_error("Cannot access protected property Request::httpResponse in " . __FILE__, E_USER_ERROR);
555
+                    trigger_error("Cannot access protected property Request::httpResponse in ".__FILE__, E_USER_ERROR);
556 556
                 }
557 557
                 break;
558 558
             default:
559 559
                 /// @todo throw instead? There are very few other places where the lib trigger errors which can potentially reach stdout...
560 560
                 $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
561
-                trigger_error('Undefined property via __unset(): ' . $name . ' in ' . $trace[0]['file'] . ' on line ' . $trace[0]['line'], E_USER_WARNING);
561
+                trigger_error('Undefined property via __unset(): '.$name.' in '.$trace[0]['file'].' on line '.$trace[0]['line'], E_USER_WARNING);
562 562
         }
563 563
     }
564 564
 }
Please login to merge, or discard this patch.