Automattic\Jetpack\Analyzer\Analyzer

Complexity

Total Complexity

19

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	slashit()	0	4	2
A	add_declaration()	0	3	1
A	print_declarations()	0	3	1
A	scan()	0	22	5
A	file()	0	19	2
B	enterNode()	0	16	7

<?php

namespace Automattic\Jetpack\Analyzer;

use PhpParser\Error;
use PhpParser\NodeDumper;
use PhpParser\ParserFactory;
use PhpParser\Node;
use PhpParser\Node\Stmt\Function_;
use PhpParser\Node\Stmt\ClassMethod_;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitorAbstract;

// const STATE_NONE = 0;
// const STATE_CLASS_DECLARATION = 1;

const VIS_PUBLIC  = 0;
const VIS_PRIVATE = 1;

class Analyzer extends NodeVisitorAbstract {
	private $declarations;
	private $base_path;
	private $current_path;
	private $parser;

	function __construct( $base_path ) {
		$this->parser       = ( new ParserFactory() )->create( ParserFactory::PREFER_PHP7 );
		$this->declarations = array();
		$this->base_path    = $this->slashit( $base_path );
	}

	private function slashit( $path ) {
		$path .= ( substr( $path, -1 ) == '/' ? '' : '/' );
		return $path;
	}

	protected function add_declaration( $declaration ) {
		$this->declarations[] = $declaration;
	}

	private function print_declarations() {
		print_r( $this->declarations );
	}

	public function scan() {
		$exclude = array( '.git', 'vendor', 'tests', 'docker', 'bin', 'scss', 'images', 'docs', 'languages', 'node_modules' );
		$filter  = function ( $file, $key, $iterator ) use ( $exclude ) {
			if ( $iterator->hasChildren() && ! in_array( $file->getFilename(), $exclude ) ) {
				return true;
			}
			return $file->isFile();
		};

		$inner_iterator = new \RecursiveDirectoryIterator( $this->base_path, \RecursiveDirectoryIterator::SKIP_DOTS );

		$iterator = new \RecursiveIteratorIterator(
			new \RecursiveCallbackFilterIterator( $inner_iterator, $filter )
		);

		$display = array( 'php' );
		foreach ( $iterator as $file ) {
			if ( in_array( strtolower( array_pop( explode( '.', $file ) ) ), $display ) ) {

explode('.', $file) cannot be passed to array_pop() as the parameter $array expects a reference.

				echo "$file\n";
			}
		}
	}

	public function file( $file_path ) {
		$this->current_path = $file_path;
		$source             = file_get_contents( $file_path );
		try {
			$ast = $this->parser->parse( $source );
		} catch ( Error $error ) {

The class PhpParser\Error does not exist. Did you forget a USE statement, or did you not list all dependencies?

			echo "Parse error: {$error->getMessage()}\n";
			return;
		}

		// $dumper = new NodeDumper;
		// echo $dumper->dump($ast) . "\n";

		$traverser = new NodeTraverser();
		$traverser->addVisitor( $this );
		$ast = $traverser->traverse( $ast );

$ast is not used, you could remove the assignment.

		$this->print_declarations();
		return;
	}

	public function enterNode( Node $node ) {
		// print_r($node);
		if ( $node instanceof Node\Stmt\Class_ ) {

The class PhpParser\Node\Stmt\Class_ does not exist. Did you forget a USE statement, or did you not list all dependencies?

			$this->add_declaration( new Class_Declaration( $this->current_path, $node->getLine(), $node->name->name ) );
		}
		if ( $node instanceof Node\Stmt\Property && $node->isPublic() ) {

The class PhpParser\Node\Stmt\Property does not exist. Did you forget a USE statement, or did you not list all dependencies?

			$this->add_declaration( new Class_Property_Declaration( $this->current_path, $node->getLine(), $node->props[0]->name->name ) );
		}
		if ( $node instanceof Node\Stmt\ClassMethod && $node->isPublic() ) {

The class PhpParser\Node\Stmt\ClassMethod does not exist. Did you forget a USE statement, or did you not list all dependencies?

			$method = new Class_Method_Declaration( $this->current_path, $node->getLine(), $node->name->name, $node->isStatic() );
			foreach ( $node->getParams() as $param ) {
				$method->add_param( $node->var->name, $node->default, $node->type, $node->byRef, $node->variadic );
			}
			$this->add_declaration( $method );
		}
	}
}

class Declaration {
	public $path;
	public $line;
	public $name;

	function __construct( $path, $line, $name ) {
		$this->path = $path;
		$this->line = $line;
		$this->name = $name;
	}
}

class Class_Declaration extends Declaration {
}

/**
 * We only log public class methods, whether they are static, and their parameters
 */
class Class_Method_Declaration extends Declaration {
	public $static;

	function __construct( $path, $line, $name, $static ) {
		$this->static = $static;
		$this->params = array();

The property params does not exist. Did you maybe forget to declare it?

		parent::__construct( $path, $line, $name );
	}

	function add_param( $name, $default, $type, $byRef, $variadic ) {
		$this->params[] = (object) compact( 'name', 'default', 'type', 'byRef', 'variadic' );
	}
}

/**
 * We only log public class variables
 */
class Class_Property_Declaration extends Declaration {
}