Added configuration, updated readme, added CI tools

Author: lulco

.scrutinizer.yml

@@ -0,0 +1,7 @@
+filter:
+  excluded_paths: [tests/*]
+
+tools:
+  external_code_coverage:
+    timeout: 600
+    runs: 2

.travis.yml

@@ -0,0 +1,28 @@
+language: php
+
+php:
+  - 7.3
+  - 7.4
+
+script:
+  - mkdir -p build/logs
+
+  - composer outdated -D --strict
+
+  - composer require squizlabs/php_codesniffer --dev
+  - vendor/bin/phpcs src --standard=PSR2 -n
+  - composer remove squizlabs/php_codesniffer --dev
+
+  - composer require phpstan/phpstan --dev
+  - vendor/bin/phpstan analyze src --level 7 --no-progress
+  - composer remove phpstan/phpstan --dev
+
+  - composer require efabrica/php-extensions-finder --dev
+  - vendor/bin/php-extensions-finder check src tests
+  - composer remove efabrica/php-extensions-finder --dev
+
+  - vendor/bin/phpunit --coverage-text --coverage-clover=coverage.clover
+
+after_script:
+  - wget https://scrutinizer-ci.com/ocular.phar
+  - php ocular.phar code-coverage:upload --format=php-clover coverage.clover;

README.md

@@ -1,21 +1,54 @@
 # Sphpera
 
-Sphpera is **S**tatic **ph**p **per**formance **a**nalysis tool designed for finding slowest methods and classes based on functions / methods called in them.
+Sphpera is **S**tatic **ph**p **per**formance **a**nalysis tool designed for finding potentially the slowest methods and classes based on functions / methods called in them.
 
-## Installation
-This project is not meant to be run as a dependency, but as separate project.
+## Features
+
+### Implemented
+- detection of global function calls
+- multiplication for calls in cycles
+- custom configuration
 
-### Composer
-The recommended way is to install this library via composer.
+### Planned
+- detection of class methods calls
+- HTML output similar to PHPUnit
+- detection of multiple implementations - when some interface or class has multiple implementations and there is only this interface injected, we have to decide which implementation will be used for analysis (default the slowest, can be overridden via configuration)
+- multiplication for calls in array_map and similar cycle-style functions
+
+## Installation
+This project should not be run as a dependency, but as separate project. Create some directory for it:
 
 ```shell script
 mkdir sphpera
 cd sphpera
+```
+and follow one of next steps:
+ 
+### use composer
+The recommended way is to install this project via composer.
+
+```shell script
 composer require lulco/sphpera
 ``` 
 
-### Usage
-Run command
+### git clone
+You can also clone this project directly. Use this for contribution.
+```shell script
+git clone [email protected]:lulco/sphpera.git .
+composer install 
 ```
+
+## Usage
+Note: Following examples describe how to use sphpera when it is installed via composer.
+
+Run command:
+```shell script
 vendor/bin/sphpera analyse dir1 dir2
 ```
+
+## Configuration
+Create your own configuration file where you set the score for functions / methods and default score. Then use this configuration file as option in `analyse` command.
+
+```shell script
+vendor/bin/sphpera analyse dir1 dir2 --config=path_to_custom_config_file
+```

example/config/config.php

@@ -0,0 +1,16 @@
+<?php
+
+use GuzzleHttp\Client;
+
+return [
+    'default' => 0.0001,
+    'functions' => [
+        'curl_exec' => 10,
+        'file_*' => 1,
+    ],
+    'methods' => [
+        Client::class => [
+            'request' => 10,
+        ],
+    ],
+];

src/Command/AnalyseCommand.php

@@ -2,10 +2,13 @@
 
 namespace Sphpera\Command;
 
+use InvalidArgumentException;
+use Sphpera\Config\Config;
 use Sphpera\ScoreResolver;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Finder\Finder;
 
@@ -15,25 +18,39 @@ protected function configure(): void
     {
         $this->setName('analyse')
             ->addArgument('dirs', InputArgument::REQUIRED | InputArgument::IS_ARRAY, 'List of dirs to analyse')
+            ->addOption('config', null, InputOption::VALUE_REQUIRED, 'Path to custom config file')
         ;
     }
 
     protected function execute(InputInterface $input, OutputInterface $output): int
     {
-        $config = [
-            'default' => 0.0001,
-            'functions' => [],
-            'methods' => [],
-        ];
+        $configuration = [];
+        /** @var string|null $configPath */
+        $configPath = $input->getOption('config');
+        if ($configPath) {
+            if (!file_exists($configPath)) {
+                throw new InvalidArgumentException('File "' . $configPath . '" not found');
+            }
+            $configuration = require $configPath;
+        }
+
+        if (!is_array($configuration)) {
+            throw new InvalidArgumentException('Configuration is not array');
+        }
 
+        $config = new Config($configuration);
         $scoreResolver = new ScoreResolver($config);
 
+        /** @var array $dirs */
         $dirs = $input->getArgument('dirs');
         $slowest = 0;
         $slowestName = '';
         foreach (Finder::create()->in($dirs)->name('*.php') as $path) {
             $path = (string)$path;
             $scores = $scoreResolver->resolve($path);
+
+            print_R($scores);
+
             foreach ($scores as $class => $methods) {
                 foreach ($methods as $method => $score) {
                     if ($slowest < $score) {

src/Config/Config.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Sphpera\Config;
+
+class Config
+{
+    private $configuration = [
+        'default' => 0.0001,
+        'functions' => [],
+        'methods' => [],
+    ];
+
+    public function __construct(array $configuration)
+    {
+        $this->configuration = array_merge($this->configuration, $configuration);
+    }
+
+    public function getDefault(): float
+    {
+        return $this->configuration['default'];
+    }
+
+    public function getFunctions(): array
+    {
+        return $this->configuration['functions'];
+    }
+
+    public function getMethods(): array
+    {
+        return $this->configuration['methods'];
+    }
+}

src/Parser/Visitor/MyVisitor.php

@@ -9,30 +9,32 @@
 use PhpParser\Node\Name;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassMethod;
+use PhpParser\Node\Stmt\Do_;
 use PhpParser\Node\Stmt\For_;
 use PhpParser\Node\Stmt\Foreach_;
 use PhpParser\Node\Stmt\Namespace_;
 use PhpParser\Node\Stmt\While_;
 use PhpParser\NodeVisitorAbstract;
+use Sphpera\Config\Config;
 use Sphpera\Stack;
 
 class MyVisitor extends NodeVisitorAbstract
 {
-    /** @var array */
+    /** @var Config */
     private $config;
 
     /** @var Stack */
     private $stack;
 
-    public function __construct(array $config, Stack $stack)
+    public function __construct(Config $config, Stack $stack)
     {
         $this->config = $config;
         $this->stack = $stack;
     }
 
     public function enterNode(Node $node)
     {
-        if ($node instanceof Foreach_ || $node instanceof While_ || $node instanceof For_) {
+        if ($node instanceof Foreach_ || $node instanceof While_ || $node instanceof For_ || $node instanceof Do_) {
             // TODO get number of cycle iterations
             $this->stack->startCycle($node->getStartLine(), $node->getEndLine());
             return null;
@@ -41,25 +43,40 @@ public function enterNode(Node $node)
         $this->stack->checkCycle($node->getStartLine());
 
         if ($node instanceof Namespace_) {
-            $this->stack->actualNamespace(implode('\\', $node->name->parts));
+            $name = $node->name;
+            $namespace = null;
+            if ($name) {
+                $namespace = implode('\\', $name->parts);
+            }
+            $this->stack->actualNamespace($namespace);
             return null;
         }
 
         if ($node instanceof Class_) {
-            $this->stack->actualClass($node->name->name);
+            $name = $node->name;
+            $className = null;
+            if ($name) {
+                $className = $name->name;
+            }
+            $this->stack->actualClass($className);
             return null;
         }
 
         if ($node instanceof ClassMethod) {
-            $this->stack->actualMethod($node->name->name);
+            $name = $node->name;
+            $methodName = null;
+            if ($name) {
+                $methodName = $name->name;
+            }
+            $this->stack->actualMethod($methodName);
             return null;
         }
 
         if ($node instanceof MethodCall) {
             // TODO resolve class name from variables etc
             $className = '';
             $methodName = $node->name->name;
-            foreach ($this->config['methods'] as $class => $methods) {
+            foreach ($this->config->getMethods() as $class => $methods) {
                 if (!preg_match('/' . str_replace('*', '(.*?)', $class) . '/', $className)) {
                     continue;
                 }
@@ -70,7 +87,7 @@ public function enterNode(Node $node)
                     }
                 }
             }
-            $this->stack->add($this->config['default']);
+            $this->stack->add($this->config->getDefault());
             return null;
         }
 
@@ -82,13 +99,13 @@ public function enterNode(Node $node)
             } elseif ($name instanceof Variable) {
                 $functionName = $name->name;
             }
-            foreach ($this->config['functions'] as $function => $score) {
+            foreach ($this->config->getFunctions() as $function => $score) {
                 if (preg_match('/' . str_replace('*', '(.*?)', $function) . '/', $functionName)) {
                     $this->stack->add($score);
                     return null;
                 }
             }
-            $this->stack->add($this->config['default']);
+            $this->stack->add($this->config->getDefault());
             return null;
         }
 

src/ScoreResolver.php

@@ -7,14 +7,15 @@
 use PhpParser\NodeTraverserInterface;
 use PhpParser\NodeVisitor\NameResolver;
 use PhpParser\ParserFactory;
+use Sphpera\Config\Config;
 use Sphpera\Parser\Visitor\MyVisitor;
 
 class ScoreResolver
 {
-    /** @var array */
+    /** @var Config */
     private $config;
 
-    public function __construct(array $config)
+    public function __construct(Config $config)
     {
         $this->config = $config;
     }

src/Stack.php

@@ -20,17 +20,17 @@ class Stack
 
     private $scores = [];
 
-    public function actualNamespace(string $namespace): void
+    public function actualNamespace(?string $namespace): void
     {
         $this->actualNamespace = $namespace;
     }
 
-    public function actualClass(string $class): void
+    public function actualClass(?string $class): void
     {
         $this->actualClass = $class;
     }
 
-    public function actualMethod(string $method): void
+    public function actualMethod(?string $method): void
     {
         $this->actualMethod = $method;
     }
@@ -62,13 +62,16 @@ public function checkCycle(int $line): bool
 
     public function add(float $score): void
     {
-        if (!isset($this->scores[$this->actualNamespace . '\\' . $this->actualClass][$this->actualMethod])) {
-            $this->scores[$this->actualNamespace . '\\' . $this->actualClass][$this->actualMethod] = 0;
+        $className = implode('\\', array_filter([$this->actualNamespace, $this->actualClass]));
+        $methodName = $this->actualMethod ?: '';
+
+        if (!isset($this->scores[$className][$methodName])) {
+            $this->scores[$className][$methodName] = 0;
         }
         if ($this->inCycle && $this->cycleMultiplier) {
             $score *= $this->cycleMultiplier;
         }
-        $this->scores[$this->actualNamespace . '\\' . $this->actualClass][$this->actualMethod] += $score;
+        $this->scores[$className][$methodName] += $score;
     }
 
     public function getScores(): array

tests/ScoreTest.php

@@ -4,15 +4,15 @@
 
 use GuzzleHttp\Client;
 use PHPUnit\Framework\TestCase;
+use Sphpera\Config\Config;
 use Sphpera\ScoreResolver;
 use SphperaTest\Sample\Sample;
 
 class ScoreTest extends TestCase
 {
     public function testSample()
     {
-        $config = [
-            'default' => 0.0001,
+        $config = new Config([
             'functions' => [
                 'curl_exec' => 10,
                 'file_*' => 1,
@@ -22,7 +22,7 @@ public function testSample()
                     'request' => 10,
                 ],
             ],
-        ];
+        ]);
 
         $expectedScores = [
             Sample::class => [