Framework::ObtainBasePath() - Code Metrics - SignpostMarv/daft-framework - Measure and Improve Code Quality continuously with Scrutinizer

Framework::ObtainBasePath() A
last analyzed 2019-07-13 14:48 UTC

↳ Parent: Framework

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10

<?php
/**
* @author SignpostMarv
*/
declare(strict_types=1);

namespace SignpostMarv\DaftFramework;

use BadMethodCallException;
use InvalidArgumentException;
use ParagonIE\EasyDB\EasyDB;
use ParagonIE\EasyDB\Factory;
use Symfony\Component\HttpFoundation\Request;

class Framework
{
	const DEFAULT_BOOL_REQUIRE_FILE_EXISTS = true;

	const BOOL_IN_ARRAY_STRICT = true;

	/**
	* @var string
	*/
	private $baseUrl;

	/**
	* @var string
	*/
	private $basePath;

	/**
	* @var EasyDB|null
	*/
	private $db;

	/**
	* @var array
	*/
	private $config;

	/**
	* @var array<string, self>
	*/
	private static $requestpair = [];

	public function __construct(string $baseUrl, string $basePath, array $config = [])
	{
		if ( ! is_dir($basePath)) {
			throw new InvalidArgumentException('Base path must be a directory!');
		} elseif (realpath($basePath) !== $basePath) {
			throw new InvalidArgumentException('Path should be explicitly set to via realpath!');
		}

		$this->baseUrl = static::NormaliseUrl($baseUrl);
		$this->basePath = $basePath;

		$this->config = $this->ValidateConfig($config);
	}

	public static function NormaliseUrl(string $baseUrl) : string
	{
		$parsed = (array) parse_url($baseUrl);

		if ( ! isset($parsed['scheme'], $parsed['host'], $parsed['path'])) {
			throw new InvalidArgumentException(
				'Base URL must have at least a scheme, host & path in order to be normalised!'
			);
		}

		/**
		* @var string
		*/
		$scheme = $parsed['scheme'] ?? '';

		/**
		* @var string
		*/
		$host = $parsed['host'] ?? '';

		$baseUrl = $scheme . '://' . $host;

		if (isset($parsed['port'])) {
			$baseUrl .= ':' . (string) $parsed['port'];
		}

		/**
		* @var string
		*/
		$path = $parsed['path'] ?? '';

		return $baseUrl . str_replace('//', '/', $path);
	}

	public function ObtainDatabaseConnection() : EasyDB
	{
		if ( ! ($this->db instanceof EasyDB)) {
			throw new BadMethodCallException('Database Connection not available!');
		}

		return $this->db;
	}

	public function ConfigureDatabaseConnection(
		string $dsn,
		string $username = null,
		string $password = null,
		array $options = []
	) : void {
		if ($this->db instanceof EasyDB) {
			throw new BadMethodCallException('Database Connection already made!');
		}

		$this->db = Factory::create($dsn, $username, $password, $options);
	}

	public function ObtainBaseUrl() : string
	{
		return $this->baseUrl;
	}

	public function ObtainBasePath() : string
	{
		return $this->basePath;
	}

	public function ObtainConfig() : array
	{
		return $this->config;
	}

	public function FileIsUnderBasePath(
		string $filename,
		bool $requireFileExists = self::DEFAULT_BOOL_REQUIRE_FILE_EXISTS
	) : bool {
		$realpath = realpath($filename);

		return
			( ! $requireFileExists && ! file_exists($filename)) ||
			(
				is_file($filename) &&
				is_string($realpath) &&
				0 === mb_strpos($realpath, $this->basePath)
			);
	}

	public static function PairWithRequest(self $framework, Request $request) : void
	{
		self::$requestpair[spl_object_hash($request)] = $framework;
	}

	public static function ObtainFrameworkForRequest(Request $request) : self
	{
		$framework = self::$requestpair[spl_object_hash($request)] ?? null;

		if ( ! ($framework instanceof self)) {
			throw new InvalidArgumentException(
				'No framework instance has been paired with the provided request!'
			);
		}

		return $framework;
	}

	public static function DisposeOfFrameworkReferences(self ...$frameworks) : void
	{
		foreach (array_keys(self::$requestpair) as $hash) {
			if (in_array(self::$requestpair[$hash], $frameworks, self::BOOL_IN_ARRAY_STRICT)) {
				unset(self::$requestpair[$hash]);
			}
		}
	}

	public static function DisposeOfRequestReferences(Request ...$requests) : void
	{
		foreach ($requests as $request) {
			$hash = spl_object_hash($request);

			if (isset(self::$requestpair[$hash])) {
				unset(self::$requestpair[$hash]);
			}
		}
	}

	/**
	* @throws InvalidArgumentException if $config contains something not valid
	*/
	protected function ValidateConfig(array $config) : array
	{
		return $config;
	}
}


1		<?php
2		/**
3		* @author SignpostMarv
4		*/
5		declare(strict_types=1);
6
7		namespace SignpostMarv\DaftFramework;
8
9		use BadMethodCallException;
10		use InvalidArgumentException;
11		use ParagonIE\EasyDB\EasyDB;
12		use ParagonIE\EasyDB\Factory;
13		use Symfony\Component\HttpFoundation\Request;
14
15		class Framework
16		{
17		const DEFAULT_BOOL_REQUIRE_FILE_EXISTS = true;
18
19		const BOOL_IN_ARRAY_STRICT = true;
20
21		/**
22		* @var string
23		*/
24		private $baseUrl;
25
26		/**
27		* @var string
28		*/
29		private $basePath;
30
31		/**
32		* @var EasyDB\|null
33		*/
34		private $db;
35
36		/**
37		* @var array
38		*/
39		private $config;
40
41		/**
42		* @var array<string, self>
43		*/
44		private static $requestpair = [];
45
46	58	public function __construct(string $baseUrl, string $basePath, array $config = [])
47		{
48	58	if ( ! is_dir($basePath)) {
49	1	throw new InvalidArgumentException('Base path must be a directory!');
50	57	} elseif (realpath($basePath) !== $basePath) {
51	1	throw new InvalidArgumentException('Path should be explicitly set to via realpath!');
52		}
53
54	56	$this->baseUrl = static::NormaliseUrl($baseUrl);
55	56	$this->basePath = $basePath;
56
57	56	$this->config = $this->ValidateConfig($config);
58	34	}
59
60	62	public static function NormaliseUrl(string $baseUrl) : string
61		{
62	62	$parsed = (array) parse_url($baseUrl);
63
64	62	if ( ! isset($parsed['scheme'], $parsed['host'], $parsed['path'])) {
65	6	throw new InvalidArgumentException(
66	6	'Base URL must have at least a scheme, host & path in order to be normalised!'
67		);
68		}
69
70		/**
71		* @var string
72		*/
73	56	$scheme = $parsed['scheme'] ?? '';
74
75		/**
76		* @var string
77		*/
78	56	$host = $parsed['host'] ?? '';
79
80	56	$baseUrl = $scheme . '://' . $host;
81
82	56	if (isset($parsed['port'])) {
83	4	$baseUrl .= ':' . (string) $parsed['port'];
84		}
85
86		/**
87		* @var string
88		*/
89	56	$path = $parsed['path'] ?? '';
90
91	56	return $baseUrl . str_replace('//', '/', $path);
92		}
93
94	6	public function ObtainDatabaseConnection() : EasyDB
95		{
96	6	if ( ! ($this->db instanceof EasyDB)) {
97	2	throw new BadMethodCallException('Database Connection not available!');
98		}
99
100	4	return $this->db;
101		}
102
103	16	public function ConfigureDatabaseConnection(
104		string $dsn,
105		string $username = null,
106		string $password = null,
107		array $options = []
108		) : void {
109	16	if ($this->db instanceof EasyDB) {
110	4	throw new BadMethodCallException('Database Connection already made!');
111		}
112
113	16	$this->db = Factory::create($dsn, $username, $password, $options);
114	16	}
115
116	34	public function ObtainBaseUrl() : string
117		{
118	34	return $this->baseUrl;
119		}
120
121	7	public function ObtainBasePath() : string
122		{
123	7	return $this->basePath;
124		}
125
126	16	public function ObtainConfig() : array
127		{
128	16	return $this->config;
129		}
130
131	18	public function FileIsUnderBasePath(
132		string $filename,
133		bool $requireFileExists = self::DEFAULT_BOOL_REQUIRE_FILE_EXISTS
134		) : bool {
135	18	$realpath = realpath($filename);
136
137		return
138	18	( ! $requireFileExists && ! file_exists($filename)) \|\|
139		(
140	9	is_file($filename) &&
141	9	is_string($realpath) &&
142	18	0 === mb_strpos($realpath, $this->basePath)
143		);
144		}
145
146	39	public static function PairWithRequest(self $framework, Request $request) : void
147		{
148	39	self::$requestpair[spl_object_hash($request)] = $framework;
149	39	}
150
151	27	public static function ObtainFrameworkForRequest(Request $request) : self
152		{
153	27	$framework = self::$requestpair[spl_object_hash($request)] ?? null;
154
155	27	if ( ! ($framework instanceof self)) {
156	18	throw new InvalidArgumentException(
157	18	'No framework instance has been paired with the provided request!'
158		);
159		}
160
161	21	return $framework;
162		}
163
164	12	public static function DisposeOfFrameworkReferences(self ...$frameworks) : void
165		{
166	12	foreach (array_keys(self::$requestpair) as $hash) {
167	12	if (in_array(self::$requestpair[$hash], $frameworks, self::BOOL_IN_ARRAY_STRICT)) {
168	12	unset(self::$requestpair[$hash]);
169		}
170		}
171	12	}
172
173	6	public static function DisposeOfRequestReferences(Request ...$requests) : void
174		{
175	6	foreach ($requests as $request) {
176	6	$hash = spl_object_hash($request);
177
178	6	if (isset(self::$requestpair[$hash])) {
179	6	unset(self::$requestpair[$hash]);
180		}
181		}
182	6	}
183
184		/**
185		* @throws InvalidArgumentException if $config contains something not valid
186		*/
187	34	protected function ValidateConfig(array $config) : array
188		{
189	34	return $config;
190		}
191		}
192

SignpostMarv / daft-framework

Framework::ObtainBasePath() A last analyzed 2019-07-13 14:48 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Framework::ObtainBasePath() A
last analyzed 2019-07-13 14:48 UTC