<?php 
trait name { 
  private $name; 
  public function setName($name) { 
    $this->name = $name;
  }

  public function getName() {   
    return $this->name;
  } 
}

class Dog {   
  use name;
}

class Car {   
  use name;
}
?>

    
<?php 
  trait a { 
   function t() {} 
  } 

 trait b { 
   function t() {} 
 } 

 class Foo { 
   use a, b { 
      a::t insteadof b; // This sets the priority of a::t over b::t 
      b::t as u; // This aliases b::t as Foo::c 
   } 
} 
?>

    
<?php 
  trait t { 
    use t; 
    function foo() {} 
} 

?>

    
<?php 
trait t { 
  use t{ foo as bar; }; 
  function foo() {} 
} 
?>

    
<?php 
trait t { 
  use a, b, c, b, e, f, g; 
  function foo() {} 
} 
?>

    
<?php 
trait a { 
  use b; 
  function a() {} 
} 

trait b { 
  use c; 
  function b() {} 
} 

trait c { 
  use a; // Back to the first one 
  function c() {} 
} 
?>

    
<?php 
class x { 
  function a() { 
  // display the current class 
  echo self::class; 
  } 
} 
?>

    
<?php 
  $for_a_static_call = array('x', 'a'); 
  class x { 
     static function a() { 
     // display the current class 
     echo self::class; 
  } 
} 

?>

    
<?php 
  class x { 
    static function a() { 
    // display the current class 
    echo self::class; 
  } 

  static function b($method) { 
   // display the current class with method a above 
   call_user_func($method); 
   echo self::class; 
   } 
} 

(new x)->method(array('static', 'a'));

?>

Support for the ext/wasm and ext/async extension

We added support for two extensions this week : ext/wasm and ext/async.

php-ext-wasm is an extension by no one other than Ivan Enderlin from the Hoa project. “The goal of the php-ext-wasm project is to be able to run WebAssembly binaries from PHP directly.”

What is WebAssembly ? “WebAssembly (abbreviated WASM) is a binary instruction format for a stack-based virtual machine. WASM is designed as a portable target for compilation of high-level languages like C/C++/Rust, enabling deployment on the web for client and server applications.”

On the other hand, ext/async is an async framework for PHP, written by Martin Schröder : it “provides concurrent Zend VM executions using native C fibers in PHP.” In particular, “A task is a fiber-based object that executes a PHP function or method on a separate call stack. ”

ext/async makes it easy to start a task, including PHP code, and keep running the rest of PHP. This is particularly efficient with a task that requires waiting, like database queries, sockets or even files. Here is an example from the extension :

    

<?php 

namespace Concurrent;
$domain = (\DIRECTORY_SEPARATOR == '\\') ? \STREAM_PF_INET : \STREAM_PF_UNIX;
list ($a, $b) = stream_socket_pair($domain, \STREAM_SOCK_STREAM, \STREAM_IPPROTO_IP);
foreach ([$a, $b] as $r) {     
  stream_set_blocking($r, false);
  stream_set_read_buffer($r, 0);
  stream_set_write_buffer($r, 0);
}

$watcher = new StreamWatcher($b);
task::async(function () use ($a, $watcher) {     
    (new Timer(500))->awaitTimeout();

   fwrite($a, 'Hello Socket ');
   fclose($a);
   var_dump('EOF!');
});

var_dump('WAIT FOR IO...');
while (\is_resource($b) && !\feof($b)) {     
   $watcher>awaitReadable();

   var_dump(fread($b, 4));
}
fclose($b);
var_dump('DONE!');

?>

This displays :

string(14) "WAIT FOR IO..."
string(4) "EOF!"
string(4) "Hell" 
string(4) "o So" 
string(4) "cket" 
string(3) " " 
string(5) "DONE!"

Visit those two extensions, as they are under heavy work.

Methods that could be static

What do you call a method that makes no usage of $this ? A static method.

We already have an analysis called This is not for static methods, which reports the usage of $this in static methods : this is a bug, as PHP will report its usage a execution time : Using $this when not in object context

Like visibility (private, public, protected), abstract or final, those keywords are dropped during development or refactoring, so as to avoid recurring PHP error messages. And, when the situation settles, it is difficult to review them, as it implies also checking the code that calls them.

Exakat now scours the code to find all legit usage, and report any method that can be made static. This clarifies the code, and help understand its structure.

And while you’re at it, you may also consider moving the static method to a function : as long as the method doesn’t have any link with the current class, including static properties.

The Weekly Audits : 2018, Week #50

Exakat includes a ‘weekly’ report : this report is built with a selection of five analyses. This means a short audit report, with few issues to review. This is not a lot to read them, and review them in your code. Everyone in the PHP community can focus on one of the classic coding problems and fix it. Talk about the weekly audit around you : you’ll find programmers facing the same challenges.

To obtain the ‘weekly’ audit, run an audit, and request the ‘Weekly’ report.

# Init the project (skip when it is already done)    
php exakat.phar init -p <yourproject> -R https://github.com/Seldaek/monolog.git -git 

# Run the project (skip when it is already done)    
php exakat.phar project -p <yourproject> 

# Export the weekly project (every monday)    
php exakat.phar report -p <yourproject> -format Weekly 

# Open projects/<yourproject>/weekly/index.html in your browser    

Every week, you can find here 5 new analysis to review in your code. In fact, when your code is clean, you can also take a quick look at the upcoming

Weekly recommendations for PHP code review : 2018, week 2018-50

• Inclusion Wrong Case : Inclusion should follow exactly the case of included files and paths.
• Static Methods Can’t Contain $this : Static methods are also called class methods : they may be called even if the class has no instantiated object.
• Use Positive Condition : Whenever possible, use a positive condition.
• No Hardcoded Hash : Hash should never be hardcoded.
• Undefined Parent : List of properties and methods that are accessed using parentkeyword but are not defined in the parent classes.

Happy PHP Code Reviews

All the 352 analyzers are presented in the docs, including the neat Unthrown Exception : Exceptions are defined in the code but never thrown.

It is a common bug : 31% applications have too many exceptions.

You can check all of the Exakat reports at the gallery: exakat gallery.

Download Exakat on exakat.io, install it with Docker, upgrade it with ‘exakat.phar upgrade -u’ and like us on github.