s9e\RegexpBuilder\Builder

Complexity

Total Complexity

10

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

97.37%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	build()	0	14	2
B	compareStrings()	0	19	5
B	getConfig()	0	25	1
A	splitStrings()	0	4	1

<?php

/**
* @package   s9e\RegexpBuilder
* @copyright Copyright (c) 2016 The s9e Authors
* @license   http://www.opensource.org/licenses/mit-license.php The MIT License
*/
namespace s9e\RegexpBuilder;

use s9e\RegexpBuilder\Input\InputInterface;
use s9e\RegexpBuilder\Output\OutputInterface;
use s9e\RegexpBuilder\Passes\CoalesceSingleCharacterPrefix;
use s9e\RegexpBuilder\Passes\GroupSingleCharacters;
use s9e\RegexpBuilder\Passes\MergePrefix;
use s9e\RegexpBuilder\Passes\MergeSuffix;
use s9e\RegexpBuilder\Passes\PromoteSingleStrings;
use s9e\RegexpBuilder\Passes\Recurse;

class Builder
{
	/**
	* @var InputInterface
	*/
	protected $input;

	/**
	* @var Runner
	*/
	protected $runner;

	/**
	* @var Serializer
	*/
	protected $serializer;

	/**
	* @param array $config
	*/
	public function __construct(array $config = [])
	{
		$config = $this->getConfig($config);

		$this->input      = $config['input'];
		$this->runner     = $config['runner'];
		$this->serializer = new Serializer($config['output'], $config['escaper']);
	}

	/**
	* Build and return a regular expression that matches all of the given strings
	*
	* @param  string[] $strings Literal strings to be matched
	* @return string            Regular expression (without delimiters)
	*/
	public function build(array $strings)
	{
		$strings = array_unique($strings);
		if ($strings === [''])
		{
			return '';
		}

		$strings = $this->splitStrings($strings);
		usort($strings, __CLASS__ . '::compareStrings');
		$strings = $this->runner->run($strings);

		return $this->serializer->serializeStrings($strings);
	}

	/**
	* Compare two split strings
	*
	* Will sort strings in ascending order
	*
	* @param  integer[] $a
	* @param  integer[] $b
	* @return integer
	*/
	protected function compareStrings(array $a, array $b)
	{
		foreach ($b as $k => $v)
		{
			if (!isset($a[$k]) || $a[$k] < $b[$k])
			{
				// A is shorter or A[k] is less than B[k]. Sort A before B
				return -1;
			}
			if ($a[$k] > $b[$k])
			{
				// A[k] comes after B[k]. Sort A after B
				return 1;
			}
		}

		// A is longer than B. Sort A after B
		return 1;
	}

	/**
	* Build the full config array based on given input
	*
	* @param  array $config Sparse config
	* @return array         Full config
	*/
	protected function getConfig(array $config)
	{
		$config += [
			'delimiter' => '/',
			'input'     => 'Bytes',
			'output'    => 'Bytes'
		];
		$config['escaper'] = new Escaper($config['delimiter']);

		$className = __NAMESPACE__ . '\\Input\\' . $config['input'];
		$config['input'] = new $className;

		$className = __NAMESPACE__ . '\\Output\\' . $config['output'];
		$config['output'] = new $className;

		$config['runner'] = new Runner;
		$config['runner']->addPass(new MergePrefix);
		$config['runner']->addPass(new GroupSingleCharacters);
		$config['runner']->addPass(new Recurse($config['runner']));
		$config['runner']->addPass(new PromoteSingleStrings);
		$config['runner']->addPass(new MergeSuffix);
		$config['runner']->addPass(new CoalesceSingleCharacterPrefix);

		return $config;
	}

	/**
	* Split all given strings by character
	*
	* @param  string[] $strings List of strings
	* @return array[]           List of arrays
	*/
	protected function splitStrings(array $strings)
	{
		return array_map([$this->input, 'split'], $strings);
	}
}