DEV Community: alexdodonov

New achivements of Mezon PHP Framework - August 2022

alexdodonov — Wed, 10 Aug 2022 16:43:00 +0000

Hi! Today I'am going to continue posting news about Mezon Framework improvements.

Mezon Router bugfix

In 1.5.x version the bug was fixed for routers wich return false. In previous versions of router false value was traited like 'Route handler was not foud' what was obviously buggy behaviour.

$router = $this->getRouter();
$router->addRoute('/catalog/[a:cat_id]/', function (): bool {
    return false;
});

// test body
$result = $router->callRoute('/catalog/foo/');

Earlier this code caused exception but now is working fine.

Mezon Router refactoring

Lots of duplicate code was removed.

Non-ASCII parameters were implemented in the Mezon Router

Non-ASCII parameters were implemented as was requested in this issue. Now this code works fine:

$router = $this->getRouter();
RouterUnitTestUtils::setRequestMethod('GET');

$router->addRoute(
     'кириллический-урл/[s:non-ascii-param]',
     function (string $route, array $params): string {
          return $params['non-ascii-param'];
     },
'GET');

var_dump($router->callRoute(urlencode('кириллический-урл/ни разу не ASCII - 日本語')));

The bug in the Mezon Template Engine was fixed

1 bug in the Mezon Template Engine was fixed. I already don't remember what it was about. Just be sure - now it is less buggy )

New achivements of Mezon PHP Framework

alexdodonov — Thu, 16 Jun 2022 05:49:17 +0000

Hi all! Today I want to try a new format with Mezon Framework news. May be it will be more interesting for you.

Replacing Laravel with Mezon Router

It was quite surprising for me but some people use Mezon Router to replace Laravel’s one. Here is the proof

You can also refer to it if you need migration tips.

Non-ASCII routes in Mezon Router

Another news for my router. New feature was implemented after the issue was submitted.

If you need new featured in the router or in other packages of the Mezon Framework – please feel free to submit them )

But as we are speaking about non-ASCII routes let’s look at the simple example:

$router->addGetRoute('кириллический-урл', ...callback...);

No changes in your code required. You can use non-ASCII routes as common routes.

Plugin manager

Here I want to make a simple announce – right now I do small plugin manager wich can made web applications more granular.
Subscribe for updates )

PHP Framework for creating mockable code

alexdodonov — Tue, 31 May 2022 05:50:34 +0000

Intro

This class provides abstractions from basic infrastructure things wich can make you unit-testing harder. For example:

console output
file system operations
GD library
redirections
sessions
system methods

If you will write your code using this framework then your unit-tests will be much easier to write and support. And as aconsequence - your code will be more stable.

Basic concepts

Each abstraction can be setup to use either native function calls (such as file_get_contents) or mockups.

Mockuped calls can be used in your unit-tests. And native calls will be executed in production.

Let's see some real code examples:

// here we setup mock calls
\Mezon\Conf\Conf::setConfigStringValue('fs/layer', 'mock');

// here we setup that mock will return true if the we check that this directory exists
\Mezon\Fs\Layer::$createdDirectories[] = [
    'path' => 'path-to-existing-directory'
];

// here we will get true
var_dump(\Mezon\Fs\Layer::directoryExists('path-to-existing-directory'));

// and here we will get false
var_dump(\Mezon\Fs\Layer::directoryExists('path-to-unexisting-directory'));

In both calls Mezon\Fs\Layer::directoryExists no real call of method file_exists was performed.

No let's see what abstractions we have

Console layer

Class Mezon\Console\Layer provides abstractions for working winth console

// here we setup mock calls
Conf::setConfigStringValue('console/layer', 'mock');

// setup values wich will be returned by the method Mezon\Console\Layer::readline()
\Mezon\Console\Layer::$readlines[] = 'line 1';
\Mezon\Console\Layer::$readlines[] = 'line 2';

// read lines
// note that native php method `readline` will noe be called
// just returning value of the Mezon\Console\Layer::$readlines array
echo \Mezon\Console\Layer::readline(); // ouputs 'line 1'
echo \Mezon\Console\Layer::readline(); // ouputs 'line 2'

// here we setup native php methods calls
Conf::setConfigStringValue('console/layer', 'real');
echo \Mezon\Console\Layer::readline(); // outputs string wich you will input in the console
// because in this line real method `readline` will be called

File system layer

This package also have abstractions for file systems routine:

// here we setup mock calls
Conf::setConfigStringValue('fs/layer', 'mock');

// writing file
\Mezon\Fs\Layer::filePutContents('file-path', 'data', FILE_APPEND);
// ^^^ but in this call all file content will be stored into memory, not on disk
// on production this call works like file_put_contents

// creating directory
\Mezon\Fs\Layer::createDirectory('new-dir');
// ^^^ real directory also is not created

// checking if the directory exists
echo \Mezon\Fs\Layer::directoryExists('new-dir'); // we shall see 'true', because we have called \Mezon\Fs\Layer::createDirectory('new-dir');
echo \Mezon\Fs\Layer::directoryExists('unexisting-dir'); // we shall see 'false'

// checking if the file exists
echo \Mezon\Fs\Layer::fileExists('file-path'); // we shall see 'true', because we have called \Mezon\Fs\Layer::filePutContents('file-path', 'data', FILE_APPEND)
echo \Mezon\Fs\Layer::fileExists('unexisting-file-path'); // we shall see 'false'

// getting file contents
echo \Mezon\Fs\Layer::fileGutContents('file-path'); // we shall see 'data', because we have already called \Mezon\Fs\Layer::filePutContents('file-path', 'data', FILE_APPEND)
echo \Mezon\Fs\Layer::fileGutContents('unexisting-file-path'); // we shall see 'false'

In-memory file system

Almost all methods from \Mezon\Fs\Layer in mock mode use \Mezon\Fs\InMemory.

// writing data in memory file system
\Mezon\Fs\InMemory::filePutContents('file-path', 'data');

// reading data from inmemory file system
echo \Mezon\Fs\InMemory::fileGetContents('file-path');

// checking that file esists
echo \Mezon\Fs\InMemory::fileExists('file-path'); // outputs 'true'
echo \Mezon\Fs\InMemory::fileExists('unexisting-file'); // outputs 'false'

// preload file in FS
// this method reads real file from your FS and uploads it into inmemory FS
\Mezon\Fs\InMemory::preloadFile('real-file-path');

GD mocks

We also have mocks for some GD functions. Basically for those ones wich work with file system.

Conf::setConfigStringValue('gd/layer', 'mock');
// here we are trying to get file with this path from \Mezon\FS\InMemory
var_dump(\Mezon\GD\Layer::getImageSize('path-to-image'));

// reading image from file
$resource = \Mezon\GD\Layer::imageCreateFromBmp('path-to-image-file');
$resource = \Mezon\GD\Layer::imageCreateFromGif('path-to-image-file');
$resource = \Mezon\GD\Layer::imageCreateFromJpeg('path-to-image-file');
$resource = \Mezon\GD\Layer::imageCreateFromPng('path-to-image-file');
$resource = \Mezon\GD\Layer::imageCreateFromWebp('path-to-image-file');

// store images into file. In mock mode all data is stored into in-memory FS - \Mezon\FS\InMemory
\Mezon\GD\Layer::imageBmp($resource, 'path-to-file');
\Mezon\GD\Layer::imageGif($resource, 'path-to-file');
\Mezon\GD\Layer::imageJpeg($resource, 'path-to-file');
\Mezon\GD\Layer::imagePng($resource, 'path-to-file');
\Mezon\GD\Layer::imageWebp($resource, 'path-to-file');

Redirection mocks

You can mock redirects:

Conf::setConfigStringValue('redirect/layer', 'mock');

// in real mode this call method header('Location: ...') will be called
// in mock mode no redirection will be performed and redirect URL will be stored
// in the \Mezon\Redirect\Layer::$lastRedirectionUrl
// and \Mezon\Redirect\Layer::$redirectWasPerformed will be set to 'true'
\Mezon\Redirect\Layer::redirectTo('./url');

Session mocks

You can also mock session methods:

Conf::setConfigStringValue('session/layer', 'mock');

// method returns 'session-name' if it is used as mock mode
// and return result of session_name() if it is used in real model
\Mezon\Session\Layer::sessionName();

// setting cookie 
\Mezon\Session\Layer::setCookie(
        string $name,
        string $value = "",
        int $expires = 0,
        string $path = "",
        string $domain = "",
        bool $secure = false,
        bool $httponly = false);

// getting session id or setting it
\Mezon\Session\Layer::sessionId(string $id = ''): string;

// saving session data and closing session
\Mezon\Session\Layer::sessionWriteClose();

System methods mocks

You can also mock some system methods calls. Like die for example:

Conf::setConfigStringValue('system/layer', 'mock');

// in mock mode field $dieWasCalled will be set to 'true'
// in real mode built-in PHP method 'die' will be called
\Mezon\System\Layer::die();

What's next?

More articles can be found in my Twitter

What is mezon/infrastructure-layer?

mezon/infrastructure-layer now is:

framework for creating easy mockable code with 100% code coverage
mezon/infrastructure-layer is a part of the Mezon Project
repo on github.com: https://github.com/alexdodonov/mezon-infrastructure-layer

It will be great if you will contribute something to this project. Documentation, sharing the project in your social media, bug fixing, refactoring, or even submitting issue with question or feature request. Thanks anyway )

My practices of writing Unit-tests

alexdodonov — Wed, 02 Feb 2022 17:41:39 +0000

For my whole life I have written about 2700 unit tests. For example here are about 1300 unit-tests and code coverage is almost 100%.

I am not the most skillfull person but I have some tricks wich helpms to write more tests and easier maintain them. Hope they will be usefull for you.

Examples will be written for PHPUnit and PHP but you can implement all advices for any other unit-testing framework for any language you want.

Strict structure for all unit-tests

All my tests have absolutely the same structure (excepti for tests wich test exception )) ) and it looks like this:

// setup
here we have setup commands

// test body
here we call testing method

// assertions
here we validate the result

And here is some real life example:

/**
 * Testing method addPostRoute
 */
public function testAddPostRoute(): void
{
    // setup
    $router = $this->getRouter();
    $route = 'route';
    RouterUnitTestUtils::setRequestMethod('POST');

    // test body
    $router->addPostRoute($route, $this, 'actionRoute');

    // assertions
    $this->assertEquals(1, $router->callRoute($route));
}

Here strict structure of unit-test will help you easyly understand what is happening. And also prevents your tests from becoming a mess.

In some cases unit-test's structure can be a little different, but it consists of the same three parts: setup, test body and assertions. Just look at hte example:

/**
 * Testing exception while getting existing file
 */
public function testExceptionWhileGettingFileContent(): void
{
    // assertions
    $this->expectException(\Exception::class);
    $this->expectExceptionCode(- 1);
    $this->expectExceptionMessage('File unexisting does not exists');

    // setup
    InMemory::clearFs();

    // test body
    Layer::existingFileGetContents('unexisting');
}

This trick can be used for Selenium tests also, but it can be modified like this:

// prepare test data

// move our web app to the necessary state

// test body

// assertions

Here "move our web app to the necessary state" are steps wich need to be perfomed before testing functionality. For example you want to display data grid. So your selenium test will look like this (in pseudo code):

// prepare test data
create records for the grid
create testing user
grant permissions for him

// move our web app to the necessary state
login with the created user
open menu

// test body
click on the link in the menu to open testing grid

// assertions
verify that all created records are displayed

That's all for now. Hope this article will be usefull for you. If so - please press "STAR" for my project.

Mezon HTML Template Engine

alexdodonov — Wed, 26 Jan 2022 05:55:43 +0000

This class provides routine for HTML pages generation. Works fast and quite simple in use.

It is a part of Mezon Framework and used in the Application class

Link to repository

Learn more

More information can be found here:

Twitter

dev.to

I'll be very glad if you'll press "STAR" button )

It will be great if you will contribute something to this project. Documentation, sharing the project in your social media, bug fixing, refactoring, or even submitting issue with question or feature request. Thanks anyway )

Installation

Just type

composer require mezon/html-template

Usage

Paths to template files

First of all you need to create object.

use Mezon\HtmlTemplate\HtmlTemplate;

$template = new HtmlTemplate('./main-template/');

This code assumes that you have all template resources in the directory ./main-template/.

But you can also specify a list of paths, and while template compilation they all will be scanned for template files.

$template = new HtmlTemplate(['./main-template/', './extra-files/res/']);

No need to specify all paths in the constructor. You can do it later with methods:

$template = new HtmlTemplate('./main-template/');
$template->addPaths(['./path1', './path2']);

But be carefull if you have static files with the same names on different paths. While compilation the file on the latest added path will be used. It was done so to create a sort of overriding mechanism for template resources.

Or you can completely reset all paths:

$template->setPaths(['./path1', './path2']);

And view a list of paths:

var_dump($template->getPaths());

Setup layout

You can have different layouts for your pages:

$template = new HtmlTemplate(%template-sources%, 'index');
// or 'form' instead of 'index', or '404', or '403' etc.

Layout will let you to define different templates for your different purposes.

You can create in your template as much layouts as you need. Just add files:

%template-sources%/Res/Templates/infex.html
%template-sources%/Res/Templates/form.html
%template-sources%/Res/Templates/404.html
%template-sources%/Res/Templates/403.html
// and so on

Setup blocks

After the layout was setup you can pass blocks to the template.

It will allow you to put different content in your layout.

For example:

$template->addBlock('hello-world');

That means that HtmlTemplate class will get the file %template-sources%/Res/Blocks/%block-name%.tpl and put instead the placeholder {%block-name%} within your layout.

But you can place the block in any placeholder you need:

HtmlTemplate::setPageVarFromBlock(string $var, string $blockName);
// here is $var is the name if your placeholder within the layout
// and $blockName is %template-sources%/Res/Blocks/$blockName.tpl

If you have $var=foo then your placeholder must be {foo}

Setting vars

You can also pass almost any data to the template

// here is $value is a scalar value or object wich implements __toString method
// and $var is a name of your placeholder within the layout
setPageVar(string $var, $value): void;

// this method can be used if you need to place file's $path content in your layout
setPageVarFromFile(string $var, string $path): void;

// you can set multyple vars with one call
// here $vars is an assoc array
setPageVars(array $vars): void;

Compile template

Just call

compile(): string

The method will return a compiled page wich you can send to user of your application.

How to work with configs in Mezon Framework

alexdodonov — Mon, 17 Jan 2022 10:17:02 +0000

Mezon has it's own routine for working with configs. It can be accesed with a set of functions, wich are described below.

This is the way how to start using it in your project:

composer require mezon/conf

Or get it directly from repo;

Getting access to the key in config can be done with Conf::getValue($route, $defaultValue = false) function. It returns config value with route $route and return $defaultValue if this key was not found. For example:

$value = Conf::getValue('res/images/favicon', 'http://yoursite.com/res/images/favicon.ico');

Setting values for the config key can be done by calling Conf::setConfigValue($route, $value) or Conf::addConfigValue($route, $value) function. The main difference between these two functions is that the first one sets scalar key, and the second one adds element to the array in config. Here is small example:

Conf::setConfigValue('res/value', 'Value!');
var_dump(Conf::getValue('res/value')); // displays 'Value!' string

Conf::addConfigValue('res/value', 'Value 1!');
Conf::addConfigValue('res/value', 'Value 2!');
var_dump(Conf::getValue('res/value')); // displays array( [0] => 'Value 1!' , [1] => 'Value 2!' )

You also can use typed versions of these methods:

Conf::getValueAsArray(...);
Conf::getValueAsObject(...);
Conf::getValueAsString(...);

Conf::setConfigArrayValue(...);
Conf::setConfigObjectValue(...);
Conf::setConfigStringValue(...);

You can set multyple values to the config:

// here $settings is an associative array
Conf::setConfigValues(array $settings);

Or you can read config from JSON:

Conf::loadConfigFromJson(string $pathToConfig);

If you are not shure that the key exists, then you can check it:

Conf::setConfigValue('res/value', 'Value!');

var_dump(Conf::configKeyExists('res')); // true
var_dump(Conf::configKeyExists('res2')); // false
var_dump(Conf::configKeyExists('res/value')); // true

You can also able to delete config key

Conf::setConfigValue('res/value', 'Value!');
Conf::deleteConfigValue('res/value');
var_dump(Conf::configKeyExists('res/value')); // false
var_dump(Conf::configKeyExists('res')); // also false

Or clear the entire config:

Conf::clear();

That's all you need to know about config read/write.

Learn more

More information can be found here:

Twitter
Mezon Framework

Mezon PHP Framework : results of the 2021 year

alexdodonov — Thu, 06 Jan 2022 09:52:28 +0000

Hi all! New Year and Christmas have passed and now is a good time to remind all achivements within the Mezon PHP Project and think what to do in 2022.

Let's start!

Mezon PHP Framework have gathered about 100 more stars (spread on different packages) on github.com Hope next year will give us at least 150 new stars.
Unit-test were improved and made more stable. Now we have 1220 unit-tests wich gives us 98% of code coverage.
Mutation testing was implemented. MSI is rather low (about 57%), but it will grow.
One new developer have joined the project and now he develops Mezon CLI tool.
Here is the TOP-10 of articles from this blog:

And what is next?

First of all - I want to find a couple of new developers for this project. If you want to join the project - just contact with me. You can choose any package of these ones. You can implement new featuers, write unit-tests or update documentation. Any help will be appreciated )

And certanly me and the team will implement new features and new code wich you can use in your PHP projects )

Good luck in a new 2022 )

Mezon Html Report generator

alexdodonov — Mon, 22 Nov 2021 16:27:46 +0000

Hi! Let me introduce eport generator wich I have created for personal use.

To be honest I don't like create reports. It took soooooooo mcuh time. But this class now allows me to do it much faster.

Pros and cons

Mezon HTML report generator allows you to create reports in a simple and pretty way. This tool also shortens time wich you spend on coding.

This package is a part of Mezon Framework

Installation

Just type:

composer require mezon/html-report

Usage

Lets start from creating object of the report generator:

$report = new Html();

And since that moment we can add elements to the head or body:

// not that stylesheets are not validated, it is totally on your side
$report->head()->style()->selector('p')->css('color', 'red');
$report->head()->style()->selector('div')->css('color', 'green');;

$report->body()->p('Hello!');
$report->body()->div('World!');

// here we get HTML code in the variable $result
$result = $report->compile();

More complex examples

This example shows that every call creates new tag (except html and body). So if you want to add multyple tags then you need to store tag into variable:

$table = $report->table();
$row = $table->tr();

$row->td()->innerHtml('#1');
$row->td()->innerHtml('Legolas');

$row->td()->innerHtml('#2');
$row->td()->innerHtml('Frodo');

$row->td()->innerHtml('#3');
$row->td()->innerHtml('Aragorn');

Supported tags

For now you can use following tags:

body
div
h1
h2
h3
h4
h5
head
p
strong
style
table
td
tr

Inner HTML

If you need more tags, you can use innerHtml like in the example below:

$report->body()->innerHtml('<script>alert(1);</scrip>');

Learn more

More information can be found here:

Twitter
Mezon Framework

How to create simple microservice using Mezon Framework

alexdodonov — Tue, 26 Oct 2021 17:24:47 +0000

Hi! In this article I shall show you how to create simple micro service with Mezon Framework

To be honest it is quite simple. First of all you need to create htaccess (if your are using Apache, or just skip this step otherwise):

# use mod_rewrite for pretty URL support
RewriteEngine on

RewriteRule ^(.*).html$ $1.html [L]
RewriteRule ^(.*).png$ $1.png [L]

RewriteRule ^cron/(.*)$ cron/$1 [L]
RewriteRule ^include/(.*)$ include/$1 [L]
RewriteRule ^Res/(.*)$ Res/$1 [L]
RewriteRule ^vendor/(.*)$ vendor/$1 [L]

RewriteRule ^data/files/(.*)$ data/files/$1 [L]

RewriteRule ^Res/Images/(.*)$ Res/Images/$1 [L]
RewriteRule ^([a-z0-9A-Z_\/\.\-\@%\ :,]+)/?(.*)$ index.php?r=$1&%{QUERY_STRING} [L]
RewriteRule ^/?(.*)$ index.php?r=index&%{QUERY_STRING} [L]

Next run:

composer require mezon/service
composer require mezon/service-logic

Then create simple class for business logic implementation:

<?php
namespace Lambda;

use Mezon\Service\ServiceBaseLogic;

class Logic extends ServiceBaseLogic
{

    public function helloWorld(): string
    {
        return 'Hello world!';
    }
}

Then we need to asseble our service in index.php:

// here we use MockProvider for no authentication or authorization
$securityProvider = new MockProvider();

// here we decide to use REST transport
$serviceTransport = new ServiceRestTransport($securityProvider);

// here we create object of the business logic
$serviceLogic = new Logic($serviceTransport->getParamsFetcher(), $serviceTransport->getSecurityProvider());

// setup transport and set that we need to use `helloWorld` method for router '/hello-world/' and GET method
$serviceTransport->setServiceLogic($serviceLogic);
$serviceTransport->getRouter()->addGetRoute('/hello-world/', $serviceLogic, 'helloWorld');

// create service object ...
$service = new ServiceBase($serviceTransport);

// ... and then simply run service
$service->run();

Pretty simple yeah? )

Do you have any proposals how to improve Mezon Framework? Then use GitHub to submit your feature request.

CRUD model class

alexdodonov — Tue, 27 Jul 2021 04:58:17 +0000

CRUD model

This model will help you to create CRUD models for your entitites, and provides you a huge set of methods after a simpe setup.

Installation

Just print in console

composer require mezon/crud-service-model

And that's all )

First steps

Let's define a new class for your DB entity:

class EntityModel extends CrudServiceModel
{
    /**
     * Constructor
     */
    public function __construct()
    {
        parent::__construct('*', 'entity_table_name');
    }
}

In this exact line of code:

parent::__construct('*', 'entity_table_name');

We have specified that we need '*' (all fields) from the table with name 'entity_table_name'.

If you need only some fields from your database, just list them in the first parameter:

parent::__construct('id,field1,field2,field3', 'entity_table_name');

And when you have done this, you will get the following methods.

But before using these methods note that you will need to meet the requirements for some naming conventions.

Field with the primary key must be named as id. I shall add setting to use another name.

Some methods reqire field creation_date for fetching new records for example.

You may add to the table field domain_id for implementing multy instancing out of the box.

Now lets look at available methods:

// Method fetches all new records since the $date
// For example $model->newRecordsSince($domainId, '2021-01-01');
newRecordsSince($domainId, string $date): array;

// Method calculates count of records fetched by filter
// For example $model->recordsCount(false, ['field1 = 1', 'field2 = 2']);
recordsCount($domainId = false, array $where = ['1=1']);

// Method returns data as is without any transformations
getSimpleRecords($domainId, int $from, int $limit, array $where, array $order = []): array;

// Method returns records wich are transformed by method getRecordsTransformer wuch 
// you can override in your subclass
getRecords($domainId, int $from, int $limit, array $where = ['1=1'], array $order = []): array;

// Method returns the last $count records filtered by where
lastRecords($domainId, $count, $where): array;

// Method returns records by their ids
fetchRecordsByIds($domainId, string $ids): array;

// Method calculates count of records grouped by fieldName and filtered by where
recordsCountByField($domainId, string $fieldName, array $where): array;

// Method updates records with values record
updateBasicFields($domainId, array $record, array $where): array;

// Method inserts record record
insertBasicFields(array $record, $domainId = 0): array;

// Method deletes all records filtered by where
deleteFiltered($domainId, array $where): int;

It will be great if you will contribute something to this project. Documentation, sharing the project in your social media, bug fixing, refactoring, or even submitting issue with question or feature request. Thanks anyway )

New benchmark: Mezon Router is up to 235 times faster than Macaw Router

alexdodonov — Mon, 26 Jul 2021 09:13:52 +0000

Hi all! Today we have one more benchmark.

As usual we have two cases:

http server accepts request, launches php script, which handles this request, and then all script data is removed from memory. All following requests are processed in the same way. In this case very critical to launch script as soon as possible and we do not have time for long pre-compilations and preparations. Because all of it will be lost after the script will finish working;
php script is launching, initiating all internal components (and router is one of them) and then starting processing requests. This case can be organized via for example react-php. It differs from the previous case because we can spend reasonable time to pre-compile routes for faster processing.

The first case

// static routes
$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/0';
RouteGenerator::generateMacawStaticRoutes(1000);
Macaw::dispatch();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/99';
RouteGenerator::generateMacawStaticRoutes(1000);
Macaw::dispatch();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/199';
RouteGenerator::generateMacawStaticRoutes(1000);
Macaw::dispatch();
// and so on up to /static/999 route

// non static routes
$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/0/1';
RouteGenerator::generateMacawNonStaticRoutes(1000);
Macaw::dispatch();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/99/1';
RouteGenerator::generateMacawNonStaticRoutes(1000);
Macaw::dispatch();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/199/1';
RouteGenerator::generateMacawNonStaticRoutes(1000);
Macaw::dispatch();
// and so on up to /param/999/1 route

The second case

// static routes
$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/0';
RouteGenerator::generateMacawStaticRoutes(1000);
Macaw::dispatch();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/99';
Macaw::dispatch();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/199';
Macaw::dispatch();
// and so on up to /static/999 route

// non static routes
$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/0/1';
RouteGenerator::generateMacawNonStaticRoutes(1000);
Macaw::dispatch();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/99/1';
Macaw::dispatch();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/199/1';
Macaw::dispatch();
// and so on up to /param/1/999 route

OK What do we have?

The first case + static routes

+------------------------------------+-------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+-------------+--------+---------+
| benchmark                          | subject     | set | revs | its | mem_peak     | best          | mean          | mode          | worst         | stdev       | rstdev | diff    |
+------------------------------------+-------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+-------------+--------+---------+
| CoffeeSingleRequestStaticBench     | benchStatic | 0   | 10   | 10  | 4,421,792b   | 42,887.400μs  | 44,110.520μs  | 44,006.318μs  | 45,896.700μs  | 731.456μs   | 1.66%  | 26.88x  |
| DVKSingleRequestStaticBench        | benchStatic | 0   | 10   | 10  | 4,878,600b   | 26,610.800μs  | 27,311.260μs  | 27,157.306μs  | 28,591.400μs  | 545.456μs   | 2.00%  | 16.64x  |
| HoaSingleRequestStaticBench        | benchStatic | 0   | 10   | 10  | 5,398,504b   | 46,112.900μs  | 47,123.440μs  | 46,722.304μs  | 48,868.700μs  | 786.022μs   | 1.67%  | 28.71x  |
| IBSingleRequestStaticBench         | benchStatic | 0   | 10   | 10  | 5,120,480b   | 130,339.600μs | 133,999.070μs | 131,788.961μs | 139,483.100μs | 3,237.588μs | 2.42%  | 81.65x  |
| JoomlaSingleRequestStaticBench     | benchStatic | 0   | 10   | 10  | 4,404,816b   | 29,574.900μs  | 31,202.060μs  | 31,060.434μs  | 34,093.400μs  | 1,140.019μs | 3.65%  | 19.01x  |
| LeafSingleRequestStaticBench       | benchStatic | 0   | 10   | 10  | 152,268,656b | 31,250.000μs  | 32,078.900μs  | 31,882.215μs  | 33,418.200μs  | 590.913μs   | 1.84%  | 19.55x  |
| MacawSingleRequestStaticBench      | benchStatic | 0   | 10   | 10  | 4,404,816b   | 15,953.600μs  | 17,173.270μs  | 17,431.719μs  | 17,989.500μs  | 634.877μs   | 3.70%  | 10.46x  |
| MezonSingleRequestStaticBench      | benchStatic | 0   | 10   | 10  | 4,405,224b   | 9,269.200μs   | 10,218.480μs  | 10,358.104μs  | 10,789.500μs  | 429.245μs   | 4.20%  | 6.23x   |
| MiladSingleRequestStaticBench      | benchStatic | 0   | 10   | 10  | 35,134,736b  | 32,030.300μs  | 32,779.910μs  | 32,257.182μs  | 33,930.900μs  | 718.028μs   | 2.19%  | 19.97x  |
| PeceeSingleRequestStaticBench      | benchStatic | 0   | 10   | 10  | 8,570,512b   | 39,446.800μs  | 41,928.180μs  | 40,962.929μs  | 50,059.700μs  | 2,936.226μs | 7.00%  | 25.55x  |
| PowerSingleRequestStaticBench      | benchStatic | 0   | 10   | 10  | 5,347,688b   | 21,038.100μs  | 22,333.040μs  | 22,047.192μs  | 23,902.800μs  | 838.572μs   | 3.75%  | 13.61x  |
| SteampixelSingleRequestStaticBench | benchStatic | 0   | 10   | 10  | 4,404,848b   | 214,769.600μs | 219,732.850μs | 218,472.236μs | 227,553.700μs | 3,569.859μs | 1.62%  | 133.90x |
| TetoSingleRequestStaticBench       | benchStatic | 0   | 10   | 10  | 6,765,328b   | 42,704.200μs  | 46,040.130μs  | 43,741.671μs  | 65,754.100μs  | 6,685.943μs | 14.52% | 28.05x  |
| ToroSingleRequestStaticBench       | benchStatic | 0   | 10   | 10  | 4,404,816b   | 1,520.800μs   | 1,641.080μs   | 1,648.426μs   | 1,815.900μs   | 91.010μs    | 5.55%  | 1.00x   |
| ZaphpaSingleRequestStaticBench     | benchStatic | 0   | 10   | 10  | 4,922,128b   | 34,852.900μs  | 36,750.860μs  | 36,017.122μs  | 42,579.100μs  | 2,086.035μs | 5.68%  | 22.39x  |
+------------------------------------+-------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+-------------+--------+---------+

The first case + non-static routes

+-----------------------------------+------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+--------------+--------+--------+
| benchmark                         | subject    | set | revs | its | mem_peak     | best          | mean          | mode          | worst         | stdev        | rstdev | diff   |
+-----------------------------------+------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+--------------+--------+--------+
| CoffeeSingleRequestParamBench     | benchParam | 0   | 10   | 10  | 5,388,832b   | 57,210.900μs  | 58,142.010μs  | 57,612.744μs  | 59,372.400μs  | 752.514μs    | 1.29%  | 2.54x  |
| DVKSingleRequestParamBench        | benchParam | 0   | 10   | 10  | 4,870,984b   | 30,440.400μs  | 33,219.850μs  | 32,300.568μs  | 39,669.000μs  | 2,454.361μs  | 7.39%  | 1.45x  |
| HoaSingleRequestParamBench        | benchParam | 0   | 10   | 10  | 5,600,184b   | 49,161.600μs  | 52,082.390μs  | 50,409.781μs  | 64,347.800μs  | 4,331.550μs  | 8.32%  | 2.28x  |
| IBSingleRequestParamBench         | benchParam | 0   | 10   | 10  | 5,241,200b   | 155,206.200μs | 168,856.750μs | 159,161.075μs | 199,139.700μs | 15,550.415μs | 9.21%  | 7.39x  |
| JoomlaSingleRequestParamBench     | benchParam | 0   | 10   | 10  | 5,096,376b   | 39,944.500μs  | 43,655.270μs  | 41,607.303μs  | 51,912.000μs  | 3,674.424μs  | 8.42%  | 1.91x  |
| LeafSingleRequestParamBench       | benchParam | 0   | 10   | 10  | 152,278,112b | 34,874.500μs  | 37,790.860μs  | 37,767.886μs  | 41,445.700μs  | 1,873.793μs  | 4.96%  | 1.65x  |
| MacawSingleRequestParamBench      | benchParam | 0   | 10   | 10  | 4,404,816b   | 27,943.800μs  | 35,659.150μs  | 31,393.071μs  | 73,138.100μs  | 12,755.662μs | 35.77% | 1.56x  |
| MezonSingleRequestParamBench      | benchParam | 0   | 10   | 10  | 141,061,056b | 146,752.500μs | 170,194.630μs | 152,785.473μs | 260,932.100μs | 36,489.637μs | 21.44% | 7.45x  |
| MiladSingleRequestParamBench      | benchParam | 0   | 10   | 10  | 35,993,272b  | 38,704.200μs  | 39,850.380μs  | 39,249.865μs  | 42,422.000μs  | 1,230.384μs  | 3.09%  | 1.74x  |
| PeceeSingleRequestParamBench      | benchParam | 0   | 10   | 10  | 8,154,696b   | 80,192.000μs  | 82,885.880μs  | 81,251.688μs  | 88,274.100μs  | 2,705.337μs  | 3.26%  | 3.63x  |
| PowerSingleRequestParamBench      | benchParam | 0   | 10   | 10  | 5,347,688b   | 21,736.300μs  | 22,851.370μs  | 22,290.195μs  | 24,333.000μs  | 816.581μs    | 3.57%  | 1.00x  |
| SteampixelSingleRequestParamBench | benchParam | 0   | 10   | 10  | 4,404,848b   | 244,784.400μs | 253,750.480μs | 249,475.559μs | 278,078.600μs | 9,616.243μs  | 3.79%  | 11.10x |
| TetoSingleRequestParamBench       | benchParam | 0   | 10   | 10  | 6,726,408b   | 60,670.300μs  | 79,920.380μs  | 73,702.178μs  | 130,037.900μs | 19,394.914μs | 24.27% | 3.50x  |
| ToroSingleRequestParamBench       | benchParam | 0   | 10   | 10  | 4,404,816b   | 9,689.800μs   | 27,495.940μs  | 17,091.499μs  | 99,743.800μs  | 26,067.520μs | 94.80% | 1.20x  |
| ZaphpaSingleRequestParamBench     | benchParam | 0   | 10   | 10  | 5,025,536b   | 48,650.000μs  | 53,104.450μs  | 50,692.984μs  | 64,711.000μs  | 4,885.802μs  | 9.20%  | 2.32x  |
+-----------------------------------+------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+--------------+--------+--------+

The second case + static routes

+----------------------------+-------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+------------+
| benchmark                  | subject     | set | revs | its | mem_peak    | best          | mean          | mode          | worst         | stdev        | rstdev | diff       |
+----------------------------+-------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+------------+
| CoffeeReactStaticBench     | benchStatic | 0   | 10   | 10  | 4,404,816b  | 9,244.100μs   | 10,291.010μs  | 9,959.738μs   | 13,219.000μs  | 1,120.150μs  | 10.88% | 533.63x    |
| DVKReactStaticBench        | benchStatic | 0   | 100  | 10  | 4,404,816b  | 11,486.660μs  | 12,126.296μs  | 11,940.553μs  | 13,204.730μs  | 482.820μs    | 3.98%  | 628.79x    |
| HoaReactStaticBench        | benchStatic | 0   | 100  | 10  | 4,444,576b  | 3,867.240μs   | 4,144.961μs   | 4,069.371μs   | 4,454.110μs   | 181.688μs    | 4.38%  | 214.93x    |
| IBReactStaticBench         | benchStatic | 0   | 10   | 10  | 4,683,736b  | 27,970.900μs  | 30,546.820μs  | 29,286.966μs  | 39,980.000μs  | 3,427.355μs  | 11.22% | 1,583.97x  |
| JoomlaReactStaticBench     | benchStatic | 0   | 10   | 10  | 4,404,816b  | 5,581.900μs   | 6,261.770μs   | 6,333.534μs   | 6,763.700μs   | 331.498μs    | 5.29%  | 324.70x    |
| LeafReactStaticBench       | benchStatic | 0   | 10   | 10  | 17,032,288b | 8,718.700μs   | 9,429.620μs   | 9,596.009μs   | 10,077.200μs  | 418.128μs    | 4.43%  | 488.96x    |
| MacawReactStaticBench      | benchStatic | 0   | 10   | 10  | 4,404,816b  | 3,966.500μs   | 4,547.030μs   | 4,287.913μs   | 5,229.900μs   | 440.286μs    | 9.68%  | 235.78x    |
| MezonReactStaticBench      | benchStatic | 0   | 100  | 10  | 4,405,224b  | 18.830μs      | 19.285μs      | 19.052μs      | 20.360μs      | 0.471μs      | 2.44%  | 1.00x      |
| MiladReactStaticBench      | benchStatic | 0   | 10   | 10  | 6,760,320b  | 16,863.200μs  | 17,928.550μs  | 17,538.320μs  | 20,783.500μs  | 1,113.527μs  | 6.21%  | 929.66x    |
| PeceeReactStaticBench      | benchStatic | 0   | 10   | 10  | 5,729,376b  | 20,468.700μs  | 22,616.480μs  | 21,170.085μs  | 28,094.400μs  | 2,524.951μs  | 11.16% | 1,172.75x  |
| PowerReactStaticBench      | benchStatic | 0   | 10   | 10  | 4,515,104b  | 16,747.600μs  | 17,718.270μs  | 17,725.738μs  | 19,259.300μs  | 726.676μs    | 4.10%  | 918.76x    |
| SteampixelReactStaticBench | benchStatic | 0   | 10   | 10  | 4,404,816b  | 254,838.600μs | 264,584.430μs | 259,244.541μs | 295,773.800μs | 12,104.379μs | 4.57%  | 13,719.70x |
| TetoReactStaticBench       | benchStatic | 0   | 10   | 10  | 5,238,440b  | 4,072.800μs   | 4,749.520μs   | 4,475.797μs   | 6,553.900μs   | 687.568μs    | 14.48% | 246.28x    |
| ToroReactStaticBench       | benchStatic | 0   | 10   | 10  | 4,404,816b  | 409.800μs     | 464.380μs     | 436.985μs     | 693.300μs     | 80.115μs     | 17.25% | 24.08x     |
| ZaphpaReactStaticBench     | benchStatic | 0   | 10   | 10  | 4,404,816b  | 12,586.100μs  | 14,936.320μs  | 13,641.531μs  | 18,931.100μs  | 2,113.612μs  | 14.15% | 774.50x    |
+----------------------------+-------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+------------+

The second case + non-static routes

+---------------------------+------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+---------+
| benchmark                 | subject    | set | revs | its | mem_peak    | best          | mean          | mode          | worst         | stdev        | rstdev | diff    |
+---------------------------+------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+---------+
| CoffeeReactParamBench     | benchParam | 0   | 10   | 10  | 4,404,816b  | 9,346.100μs   | 12,261.110μs  | 10,725.392μs  | 25,364.700μs  | 4,551.819μs  | 37.12% | 8.59x   |
| DVKReactParamBench        | benchParam | 0   | 100  | 10  | 4,404,816b  | 14,638.400μs  | 15,790.154μs  | 14,979.128μs  | 17,804.070μs  | 1,052.202μs  | 6.66%  | 11.06x  |
| HoaReactParamBench        | benchParam | 0   | 100  | 10  | 4,730,008b  | 3,957.450μs   | 4,058.723μs   | 4,037.900μs   | 4,255.350μs   | 75.601μs     | 1.86%  | 2.84x   |
| IBReactParamBench         | benchParam | 0   | 10   | 10  | 4,820,208b  | 37,245.200μs  | 38,581.780μs  | 38,063.843μs  | 42,749.500μs  | 1,504.175μs  | 3.90%  | 27.03x  |
| JoomlaReactParamBench     | benchParam | 0   | 10   | 10  | 4,404,816b  | 4,040.700μs   | 4,294.750μs   | 4,223.156μs   | 4,769.100μs   | 215.156μs    | 5.01%  | 3.01x   |
| LeafReactParamBench       | benchParam | 0   | 10   | 10  | 17,041,664b | 9,973.200μs   | 10,710.610μs  | 10,376.970μs  | 13,052.700μs  | 871.227μs    | 8.13%  | 7.51x   |
| MacawReactParamBench      | benchParam | 0   | 10   | 10  | 4,404,816b  | 14,705.800μs  | 15,567.440μs  | 15,621.434μs  | 16,569.900μs  | 495.179μs    | 3.18%  | 10.91x  |
| MezonReactParamBench      | benchParam | 0   | 100  | 10  | 4,681,176b  | 1,070.680μs   | 1,427.126μs   | 1,139.771μs   | 4,012.790μs   | 862.979μs    | 60.47% | 1.00x   |
| MiladReactParamBench      | benchParam | 0   | 10   | 10  | 6,887,816b  | 21,768.200μs  | 23,694.400μs  | 22,963.173μs  | 30,491.500μs  | 2,333.609μs  | 9.85%  | 16.60x  |
| PeceeReactParamBench      | benchParam | 0   | 10   | 10  | 6,110,472b  | 46,821.300μs  | 50,153.060μs  | 48,169.419μs  | 65,957.100μs  | 5,510.359μs  | 10.99% | 35.14x  |
| PowerReactParamBench      | benchParam | 0   | 10   | 10  | 4,515,104b  | 17,027.000μs  | 17,705.200μs  | 17,330.517μs  | 18,659.600μs  | 570.959μs    | 3.22%  | 12.41x  |
| SteampixelReactParamBench | benchParam | 0   | 10   | 10  | 4,404,816b  | 240,130.300μs | 245,763.930μs | 245,531.622μs | 253,088.400μs | 3,355.995μs  | 1.37%  | 172.21x |
| TetoReactParamBench       | benchParam | 0   | 10   | 10  | 5,219,056b  | 10,345.100μs  | 11,818.020μs  | 11,057.018μs  | 15,774.800μs  | 1,599.283μs  | 13.53% | 8.28x   |
| ToroReactParamBench       | benchParam | 0   | 10   | 10  | 4,404,800b  | 8,782.900μs   | 13,319.470μs  | 10,442.532μs  | 29,984.700μs  | 6,346.543μs  | 47.65% | 9.33x   |
| ZaphpaReactParamBench     | benchParam | 0   | 10   | 10  | 4,421,912b  | 25,464.700μs  | 39,406.550μs  | 29,009.220μs  | 60,979.400μs  | 13,633.090μs | 34.60% | 27.61x  |
+---------------------------+------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+---------+

As you can see in half of all cases Mezon Router is faster than Macaw router.

What's next?

More articles can be found in my Twitter

What is mezon/router?

mezon/router now is:

framework for routing with 100% code coverage
10.0 points on scrutinizer-ci.com
router is a part of the Mezon Project

Repo on github.com: https://github.com/alexdodonov/mezon-router

It will be great if you will contribute something to this project. Documentation, sharing the project in your social media, bug fixing, refactoring, or even submitting issue with question or feature request. Thanks anyway )

New benchmark: Mezon Router is up to 480 times faster than Leaf Router

alexdodonov — Mon, 19 Jul 2021 09:20:32 +0000

Hi all! Today we have one more benchmark.

As usual we have two cases:

http server accepts request, launches php script, which handles this request, and then all script data is removed from memory. All following requests are processed in the same way. In this case very critical to launch script as soon as possible and we do not have time for long pre-compilations and preparations. Because all of it will be lost after the script will finish working;
php script is launching, initiating all internal components (and router is one of them) and then starting processing requests. This case can be organized via for example react-php. It differs from the previous case because we can spend reasonable time to pre-compile routes for faster processing.

The first case

// static routes
$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/0';
$router = RouteGenerator::generateLeafStaticRoutes(1000);
$router->run();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/99';
$router = RouteGenerator::generateLeafStaticRoutes(1000);
$router->run();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/199';
$router = RouteGenerator::generateLeafStaticRoutes(1000);
$router->run();
// and so on up to /static/999 route

// non static routes
$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/0/1';
$router = RouteGenerator::generateLeafNonStaticRoutes(1000);
$router->run();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/99/1';
$router = RouteGenerator::generateLeafNonStaticRoutes(1000);
$router->run();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/199/1';
$router = RouteGenerator::generateLeafNonStaticRoutes(1000);
$router->run();
// and so on up to /param/999/1 route

The second case

// static routes
$router = RouteGenerator::generateLeafStaticRoutes(1000);

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/0';
$router->run();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/99';
$router->run();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/static/199';
$router->run();
// and so on up to /static/999 route

// non static routes
$router = RouteGenerator::generateLeafNonStaticRoutes(1000);

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/0/1';
$router->run();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/99/1';
$router->run();

$_SERVER['REQUEST_METHOD'] = 'GET';
$_SERVER['REQUEST_URI'] = '/param/199/1';
$router->run();
// and so on up to /param/1/999 route

OK What do we have?

The first case + static routes

+------------------------------------+-------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+--------------+--------+---------+
| benchmark                          | subject     | set | revs | its | mem_peak     | best          | mean          | mode          | worst         | stdev        | rstdev | diff    |
+------------------------------------+-------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+--------------+--------+---------+
| CoffeeSingleRequestStaticBench     | benchStatic | 0   | 10   | 10  | 4,416,760b   | 47,939.100μs  | 57,073.950μs  | 52,448.314μs  | 92,250.800μs  | 12,711.502μs | 22.27% | 29.40x  |
| DVKSingleRequestStaticBench        | benchStatic | 0   | 10   | 10  | 4,873,600b   | 29,406.000μs  | 31,359.430μs  | 30,224.780μs  | 33,764.300μs  | 1,578.558μs  | 5.03%  | 16.15x  |
| HoaSingleRequestStaticBench        | benchStatic | 0   | 10   | 10  | 5,327,968b   | 50,925.400μs  | 55,086.900μs  | 52,131.973μs  | 69,609.000μs  | 5,744.275μs  | 10.43% | 28.38x  |
| IBSingleRequestStaticBench         | benchStatic | 0   | 10   | 10  | 5,115,480b   | 144,288.000μs | 156,082.490μs | 149,775.315μs | 179,781.900μs | 11,638.906μs | 7.46%  | 80.40x  |
| JoomlaSingleRequestStaticBench     | benchStatic | 0   | 10   | 10  | 4,402,888b   | 34,357.600μs  | 37,628.510μs  | 35,417.780μs  | 43,386.800μs  | 3,418.865μs  | 9.09%  | 19.38x  |
| LeafSingleRequestStaticBench       | benchStatic | 0   | 10   | 10  | 152,263,656b | 35,078.800μs  | 38,101.440μs  | 37,164.095μs  | 43,742.100μs  | 2,487.527μs  | 6.53%  | 19.63x  |
| MezonSingleRequestStaticBench      | benchStatic | 0   | 10   | 10  | 4,403,296b   | 10,426.900μs  | 11,419.360μs  | 11,486.902μs  | 12,418.300μs  | 619.609μs    | 5.43%  | 5.88x   |
| MiladSingleRequestStaticBench      | benchStatic | 0   | 10   | 10  | 35,129,704b  | 34,830.900μs  | 36,623.310μs  | 37,527.545μs  | 37,886.300μs  | 1,128.127μs  | 3.08%  | 18.87x  |
| PeceeSingleRequestStaticBench      | benchStatic | 0   | 10   | 10  | 8,565,512b   | 44,259.500μs  | 47,010.690μs  | 46,139.941μs  | 49,370.700μs  | 1,646.278μs  | 3.50%  | 24.22x  |
| PowerSingleRequestStaticBench      | benchStatic | 0   | 10   | 10  | 5,342,656b   | 23,509.500μs  | 27,317.570μs  | 26,116.556μs  | 37,681.900μs  | 3,827.772μs  | 14.01% | 14.07x  |
| SteampixelSingleRequestStaticBench | benchStatic | 0   | 10   | 10  | 4,402,920b   | 245,642.000μs | 252,848.030μs | 251,697.069μs | 266,980.900μs | 5,706.743μs  | 2.26%  | 130.25x |
| TetoSingleRequestStaticBench       | benchStatic | 0   | 10   | 10  | 6,760,328b   | 49,796.100μs  | 52,161.840μs  | 50,862.160μs  | 54,660.000μs  | 1,743.920μs  | 3.34%  | 26.87x  |
| ToroSingleRequestStaticBench       | benchStatic | 0   | 10   | 10  | 4,402,888b   | 1,598.300μs   | 1,941.310μs   | 1,947.188μs   | 2,284.000μs   | 178.139μs    | 9.18%  | 1.00x   |
| ZaphpaSingleRequestStaticBench     | benchStatic | 0   | 10   | 10  | 4,917,128b   | 39,126.200μs  | 41,894.490μs  | 40,677.525μs  | 50,615.000μs  | 3,206.580μs  | 7.65%  | 21.58x  |
+------------------------------------+-------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+--------------+--------+---------+

The first case + non-static routes

+-----------------------------------+------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+--------------+--------+--------+
| benchmark                         | subject    | set | revs | its | mem_peak     | best          | mean          | mode          | worst         | stdev        | rstdev | diff   |
+-----------------------------------+------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+--------------+--------+--------+
| CoffeeSingleRequestParamBench     | benchParam | 0   | 10   | 10  | 5,383,800b   | 64,149.900μs  | 68,643.870μs  | 66,966.558μs  | 77,000.900μs  | 3,921.354μs  | 5.71%  | 5.62x  |
| DVKSingleRequestParamBench        | benchParam | 0   | 10   | 10  | 4,865,984b   | 35,881.000μs  | 38,117.380μs  | 36,357.450μs  | 42,288.000μs  | 2,323.897μs  | 6.10%  | 3.12x  |
| HoaSingleRequestParamBench        | benchParam | 0   | 10   | 10  | 5,529,648b   | 55,389.700μs  | 59,949.570μs  | 58,228.467μs  | 69,895.800μs  | 4,100.430μs  | 6.84%  | 4.91x  |
| IBSingleRequestParamBench         | benchParam | 0   | 10   | 10  | 5,236,200b   | 174,096.700μs | 183,709.660μs | 182,310.005μs | 200,004.100μs | 6,536.611μs  | 3.56%  | 15.05x |
| JoomlaSingleRequestParamBench     | benchParam | 0   | 10   | 10  | 5,091,376b   | 43,591.300μs  | 48,020.070μs  | 44,911.551μs  | 75,717.400μs  | 9,302.832μs  | 19.37% | 3.93x  |
| LeafSingleRequestParamBench       | benchParam | 0   | 10   | 10  | 152,273,112b | 40,056.100μs  | 46,651.370μs  | 43,610.004μs  | 65,999.600μs  | 7,444.629μs  | 15.96% | 3.82x  |
| MezonSingleRequestParamBench      | benchParam | 0   | 10   | 10  | 141,056,056b | 160,933.400μs | 172,964.680μs | 167,216.711μs | 199,617.400μs | 12,057.579μs | 6.97%  | 14.17x |
| MiladSingleRequestParamBench      | benchParam | 0   | 10   | 10  | 35,988,240b  | 42,030.700μs  | 47,074.700μs  | 43,814.086μs  | 72,407.700μs  | 8,792.596μs  | 18.68% | 3.86x  |
| PeceeSingleRequestParamBench      | benchParam | 0   | 10   | 10  | 8,149,696b   | 90,550.200μs  | 96,066.750μs  | 93,528.156μs  | 110,313.000μs | 5,935.073μs  | 6.18%  | 7.87x  |
| PowerSingleRequestParamBench      | benchParam | 0   | 10   | 10  | 5,342,656b   | 24,573.500μs  | 26,827.200μs  | 25,561.859μs  | 31,686.900μs  | 2,271.591μs  | 8.47%  | 2.20x  |
| SteampixelSingleRequestParamBench | benchParam | 0   | 10   | 10  | 4,402,920b   | 270,994.300μs | 280,615.200μs | 283,062.232μs | 289,402.400μs | 6,105.135μs  | 2.18%  | 22.99x |
| TetoSingleRequestParamBench       | benchParam | 0   | 10   | 10  | 6,721,408b   | 66,515.100μs  | 69,275.460μs  | 70,647.850μs  | 72,914.600μs  | 2,245.638μs  | 3.24%  | 5.67x  |
| ToroSingleRequestParamBench       | benchParam | 0   | 10   | 10  | 4,402,888b   | 10,670.000μs  | 12,207.530μs  | 11,418.532μs  | 14,782.900μs  | 1,274.212μs  | 10.44% | 1.00x  |
| ZaphpaSingleRequestParamBench     | benchParam | 0   | 10   | 10  | 5,020,536b   | 53,622.100μs  | 63,750.200μs  | 57,301.614μs  | 79,378.700μs  | 9,849.251μs  | 15.45% | 5.22x  |
+-----------------------------------+------------+-----+------+-----+--------------+---------------+---------------+---------------+---------------+--------------+--------+--------+

The second case + static routes

+----------------------------+-------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+------------+
| benchmark                  | subject     | set | revs | its | mem_peak    | best          | mean          | mode          | worst         | stdev        | rstdev | diff       |
+----------------------------+-------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+------------+
| CoffeeReactStaticBench     | benchStatic | 0   | 10   | 10  | 4,402,888b  | 10,034.700μs  | 11,286.760μs  | 10,773.621μs  | 14,051.600μs  | 1,197.867μs  | 10.61% | 496.03x    |
| DVKReactStaticBench        | benchStatic | 0   | 100  | 10  | 4,402,888b  | 13,148.010μs  | 13,771.349μs  | 13,981.083μs  | 14,271.230μs  | 374.943μs    | 2.72%  | 605.23x    |
| HoaReactStaticBench        | benchStatic | 0   | 100  | 10  | 4,402,872b  | 4,298.550μs   | 4,763.865μs   | 4,589.042μs   | 5,725.870μs   | 416.916μs    | 8.75%  | 209.36x    |
| IBReactStaticBench         | benchStatic | 0   | 10   | 10  | 4,678,736b  | 30,335.300μs  | 32,897.550μs  | 33,364.751μs  | 34,822.400μs  | 1,411.764μs  | 4.29%  | 1,445.79x  |
| JoomlaReactStaticBench     | benchStatic | 0   | 10   | 10  | 4,402,888b  | 6,436.100μs   | 7,693.700μs   | 7,049.448μs   | 10,506.500μs  | 1,209.691μs  | 15.72% | 338.13x    |
| LeafReactStaticBench       | benchStatic | 0   | 10   | 10  | 17,027,288b | 9,771.700μs   | 10,912.610μs  | 10,306.522μs  | 14,403.800μs  | 1,344.440μs  | 12.32% | 479.59x    |
| MezonReactStaticBench      | benchStatic | 0   | 100  | 10  | 4,403,296b  | 18.780μs      | 22.754μs      | 19.670μs      | 47.190μs      | 8.421μs      | 37.01% | 1.00x      |
| MiladReactStaticBench      | benchStatic | 0   | 10   | 10  | 6,755,288b  | 17,780.200μs  | 19,608.880μs  | 18,943.244μs  | 22,691.900μs  | 1,404.706μs  | 7.16%  | 861.78x    |
| PeceeReactStaticBench      | benchStatic | 0   | 10   | 10  | 5,724,376b  | 22,200.700μs  | 23,723.330μs  | 23,272.309μs  | 25,580.900μs  | 1,023.059μs  | 4.31%  | 1,042.60x  |
| PowerReactStaticBench      | benchStatic | 0   | 10   | 10  | 4,510,072b  | 18,329.000μs  | 19,799.810μs  | 19,385.573μs  | 21,834.900μs  | 1,008.011μs  | 5.09%  | 870.17x    |
| SteampixelReactStaticBench | benchStatic | 0   | 10   | 10  | 4,402,888b  | 278,668.000μs | 294,515.740μs | 288,365.878μs | 351,544.700μs | 19,453.272μs | 6.61%  | 12,943.47x |
| TetoReactStaticBench       | benchStatic | 0   | 10   | 10  | 5,233,440b  | 4,675.600μs   | 5,433.200μs   | 5,129.949μs   | 6,929.700μs   | 654.188μs    | 12.04% | 238.78x    |
| ToroReactStaticBench       | benchStatic | 0   | 10   | 10  | 4,402,888b  | 397.800μs     | 528.510μs     | 467.933μs     | 796.000μs     | 122.898μs    | 23.25% | 23.23x     |
| ZaphpaReactStaticBench     | benchStatic | 0   | 10   | 10  | 4,402,888b  | 14,429.300μs  | 15,781.300μs  | 16,399.930μs  | 17,093.300μs  | 852.563μs    | 5.40%  | 693.56x    |
+----------------------------+-------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+------------+

The second case + non-static routes

+----------------------------+-------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+------------+
| benchmark                  | subject     | set | revs | its | mem_peak    | best          | mean          | mode          | worst         | stdev        | rstdev | diff       |
+----------------------------+-------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+------------+
| CoffeeReactStaticBench     | benchStatic | 0   | 10   | 10  | 4,402,888b  | 10,034.700μs  | 11,286.760μs  | 10,773.621μs  | 14,051.600μs  | 1,197.867μs  | 10.61% | 496.03x    |
| DVKReactStaticBench        | benchStatic | 0   | 100  | 10  | 4,402,888b  | 13,148.010μs  | 13,771.349μs  | 13,981.083μs  | 14,271.230μs  | 374.943μs    | 2.72%  | 605.23x    |
| HoaReactStaticBench        | benchStatic | 0   | 100  | 10  | 4,402,872b  | 4,298.550μs   | 4,763.865μs   | 4,589.042μs   | 5,725.870μs   | 416.916μs    | 8.75%  | 209.36x    |
| IBReactStaticBench         | benchStatic | 0   | 10   | 10  | 4,678,736b  | 30,335.300μs  | 32,897.550μs  | 33,364.751μs  | 34,822.400μs  | 1,411.764μs  | 4.29%  | 1,445.79x  |
| JoomlaReactStaticBench     | benchStatic | 0   | 10   | 10  | 4,402,888b  | 6,436.100μs   | 7,693.700μs   | 7,049.448μs   | 10,506.500μs  | 1,209.691μs  | 15.72% | 338.13x    |
| LeafReactStaticBench       | benchStatic | 0   | 10   | 10  | 17,027,288b | 9,771.700μs   | 10,912.610μs  | 10,306.522μs  | 14,403.800μs  | 1,344.440μs  | 12.32% | 479.59x    |
| MezonReactStaticBench      | benchStatic | 0   | 100  | 10  | 4,403,296b  | 18.780μs      | 22.754μs      | 19.670μs      | 47.190μs      | 8.421μs      | 37.01% | 1.00x      |
| MiladReactStaticBench      | benchStatic | 0   | 10   | 10  | 6,755,288b  | 17,780.200μs  | 19,608.880μs  | 18,943.244μs  | 22,691.900μs  | 1,404.706μs  | 7.16%  | 861.78x    |
| PeceeReactStaticBench      | benchStatic | 0   | 10   | 10  | 5,724,376b  | 22,200.700μs  | 23,723.330μs  | 23,272.309μs  | 25,580.900μs  | 1,023.059μs  | 4.31%  | 1,042.60x  |
| PowerReactStaticBench      | benchStatic | 0   | 10   | 10  | 4,510,072b  | 18,329.000μs  | 19,799.810μs  | 19,385.573μs  | 21,834.900μs  | 1,008.011μs  | 5.09%  | 870.17x    |
| SteampixelReactStaticBench | benchStatic | 0   | 10   | 10  | 4,402,888b  | 278,668.000μs | 294,515.740μs | 288,365.878μs | 351,544.700μs | 19,453.272μs | 6.61%  | 12,943.47x |
| TetoReactStaticBench       | benchStatic | 0   | 10   | 10  | 5,233,440b  | 4,675.600μs   | 5,433.200μs   | 5,129.949μs   | 6,929.700μs   | 654.188μs    | 12.04% | 238.78x    |
| ToroReactStaticBench       | benchStatic | 0   | 10   | 10  | 4,402,888b  | 397.800μs     | 528.510μs     | 467.933μs     | 796.000μs     | 122.898μs    | 23.25% | 23.23x     |
| ZaphpaReactStaticBench     | benchStatic | 0   | 10   | 10  | 4,402,888b  | 14,429.300μs  | 15,781.300μs  | 16,399.930μs  | 17,093.300μs  | 852.563μs    | 5.40%  | 693.56x    |
+----------------------------+-------------+-----+------+-----+-------------+---------------+---------------+---------------+---------------+--------------+--------+------------+

As you can see almost in all cases Mezon Router is faster than Leaf router.

What's next?

More articles can be found in my Twitter

What is mezon/router?

mezon/router now is:

framework for routing with 100% code coverage
10.0 points on scrutinizer-ci.com
router is a part of the Mezon Project

Repo on github.com: https://github.com/alexdodonov/mezon-router

It will be great if you will contribute something to this project. Documentation, sharing the project in your social media, bug fixing, refactoring, or even submitting issue with question or feature request. Thanks anyway )