s9e\Bencode\Bencode

Complexity

Total Complexity

50

Size/Duplication

Total Lines	291
Duplicated Lines	0 %

Importance

Changes	12
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	decodeString()	0	7	1
A	encodeScalar()	0	8	4
A	encode()	0	20	5
A	decode()	0	8	1
A	decodeDigits()	0	26	5
A	encodeArrayObject()	0	13	2
A	decodeDictionary()	0	28	5
A	__construct()	0	12	2
A	decodeInteger()	0	15	4
A	decodeAnything()	0	17	4
A	computeSafeBoundary()	0	19	5
A	checkCursorPosition()	0	10	3
A	decodeList()	0	18	3
A	encodeArray()	0	14	3
A	checkBoundary()	0	10	3

<?php declare(strict_types=1);

/**
* @package   s9e\Bencode
* @copyright Copyright (c) 2014-2020 The s9e authors
* @license   http://www.opensource.org/licenses/mit-license.php The MIT License
*/
namespace s9e\Bencode;

use ArrayObject;
use InvalidArgumentException;
use RuntimeException;
use stdClass;

class Bencode
{
	/**
	* @var string Bencoded string being decoded
	*/
	protected string $bencoded;

	/**
	* @var int Length of the bencoded string
	*/
	protected int $len;

	/**
	* @var int Safe rightmost boundary
	*/
	protected int $max;

	/**
	* @var int Position of the cursor while decoding
	*/
	protected int $pos;

	protected function __construct(string $bencoded)
	{
		if ($bencoded === '')
		{
			throw new InvalidArgumentException;
		}

		$this->bencoded = $bencoded;
		$this->len      = strlen($bencoded);
		$this->pos      = 0;

		$this->computeSafeBoundary();
	}

	public static function decode(string $bencoded)
	{
		$decoder = new static($bencoded);
		$value   = $decoder->decodeAnything();

		$decoder->checkCursorPosition();

		return $value;
	}

	public static function encode($value): string
	{
		if (is_scalar($value))
		{
			return self::encodeScalar($value);
		}
		if (is_array($value))
		{
			return self::encodeArray($value);
		}
		if ($value instanceof stdClass)
		{
			$value = new ArrayObject(get_object_vars($value));
		}
		if ($value instanceof ArrayObject)
		{
			return self::encodeArrayObject($value);
		}

		throw new InvalidArgumentException('Unsupported value');
	}

	protected function checkBoundary(): void
	{
		if ($this->max < 1)
		{
			if (strpos('-e', $this->bencoded[0]) !== false)
			{
				throw new RuntimeException('Illegal character found at offset 0');
			}

			throw new RuntimeException('Premature end of data');
		}
	}

	protected function checkCursorPosition(): void
	{
		if ($this->pos !== $this->len)
		{
			if ($this->pos < $this->len)
			{
				throw new RuntimeException('Superfluous content found at offset ' . $this->pos);
			}

			throw new RuntimeException('Premature end of data');
		}
	}

	/**
	* Adjust the rightmost boundary to the last safe character
	*
	* Will rewind the boundary to skip the rightmost digits, optionally preceded by "i" or "i-"
	*/
	protected function computeSafeBoundary(): void
	{
		$boundary = $this->len - 1;
		$c = $this->bencoded[$boundary];
		while (is_numeric($c) && --$boundary >= 0)
		{
			$c = $this->bencoded[$boundary];
		}
		if ($c === '-')
		{
			$boundary -= 2;
		}
		elseif ($c === 'i')
		{
			--$boundary;
		}

		$this->max = $boundary;
		$this->checkBoundary();
	}

	protected function decodeAnything()
	{
		$c = $this->bencoded[$this->pos];
		if ($c === 'i')
		{
			return $this->decodeInteger();
		}
		if ($c === 'd')
		{
			return $this->decodeDictionary();
		}
		if ($c === 'l')
		{
			return $this->decodeList();
		}

		return $this->decodeString();
	}

	protected function decodeDictionary(): ArrayObject
	{
		$dictionary = new ArrayObject;
		$dictionary->setFlags(ArrayObject::ARRAY_AS_PROPS);

		++$this->pos;
		while ($this->pos <= $this->max)
		{
			if ($this->bencoded[$this->pos] === 'e')
			{
				++$this->pos;

				return $dictionary;
			}

			$pos = $this->pos;
			$key = $this->decodeString();
			if (isset($dictionary->$key))
			{
				throw new RuntimeException("Duplicate dictionary entry '" . $key . "' at pos " . $pos);
			}
			if ($this->pos <= $this->max)
			{
				$dictionary->$key = $this->decodeAnything();
			}
		}

		throw new RuntimeException('Premature end of data');
	}

	protected function decodeDigits(string $terminator): int
	{
		$spn = strspn($this->bencoded, '1234567890', $this->pos);
		if ($spn > 1)
		{
			if ($this->bencoded[$this->pos] === '0')
			{
				throw new RuntimeException('Illegal character found at offset ' . $this->pos);
			}
		}
		elseif (!$spn)
		{
			throw new RuntimeException('Illegal character found at offset ' . $this->pos);
		}

		// Capture the value and cast it as an integer
		$value = (int) substr($this->bencoded, $this->pos, $spn);

		$this->pos += $spn;
		if ($this->bencoded[$this->pos] !== $terminator)
		{
			throw new RuntimeException('Illegal character found at offset ' . $this->pos);
		}
		++$this->pos;

		return $value;
	}

	protected function decodeInteger(): int
	{
		$negative = ($this->bencoded[++$this->pos] === '-');
		if ($negative && $this->bencoded[++$this->pos] === '0')
		{
			throw new RuntimeException('Illegal character found at offset ' . $this->pos);
		}

		$value = $this->decodeDigits('e');
		if ($negative)
		{
			$value = -$value;
		}

		return $value;
	}

	protected function decodeList(): array
	{
		++$this->pos;

		$list = [];
		while ($this->pos <= $this->max)
		{
			if ($this->bencoded[$this->pos] === 'e')
			{
				++$this->pos;

				return $list;
			}

			$list[] = $this->decodeAnything();
		}

		throw new RuntimeException('Premature end of data');
	}

	protected function decodeString(): string
	{
		$len        = $this->decodeDigits(':');
		$string     = substr($this->bencoded, $this->pos, $len);
		$this->pos += $len;

		return $string;
	}

	/**
	* Encode an array into either an array of a dictionary
	*/
	protected static function encodeArray(array $value): string
	{
		if (empty($value))
		{
			return 'le';
		}

		if (array_keys($value) === range(0, count($value) - 1))
		{
			return 'l' . implode('', array_map([__CLASS__, 'encode'], $value)) . 'e';
		}

		// Encode associative arrays as dictionaries
		return self::encodeArrayObject(new ArrayObject($value));
	}

	/**
	* Encode given ArrayObject instance into a dictionary
	*/
	protected static function encodeArrayObject(ArrayObject $dict): string
	{
		$vars = $dict->getArrayCopy();
		ksort($vars);

		$str = 'd';
		foreach ($vars as $k => $v)
		{
			$str .= strlen($k) . ':' . $k . self::encode($v);
		}
		$str .= 'e';

		return $str;
	}

	/**
	* Encode a scalar value
	*/
	protected static function encodeScalar($value): string
	{
		if (is_int($value) || is_float($value) || is_bool($value))
		{
			return sprintf('i%de', round($value));

It seems like $value can also be of type boolean; however, parameter $val of round() does only seem to accept double, maybe add an additional type check?

		}

		return strlen($value) . ':' . $value;
	}
}