Configuration::getCache() - Code Metrics - Inspection of "[WIP] New 4.3 release" - thecodingmachine/database.tdbm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — 4.2 (#140)

by David

created 2017-04-26 08:43 UTC

Configuration::getCache() A

↳ Parent: Configuration

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php


namespace Mouf\Database\TDBM;

use Doctrine\Common\Cache\Cache;
use Doctrine\Common\Cache\VoidCache;
use Doctrine\DBAL\Connection;
use Mouf\Database\SchemaAnalyzer\SchemaAnalyzer;
use Mouf\Database\TDBM\Utils\GeneratorEventDispatcher;
use Mouf\Database\TDBM\Utils\GeneratorListenerInterface;
use Mouf\Database\TDBM\Utils\NamingStrategyInterface;
use Psr\Log\LoggerInterface;

class Configuration implements ConfigurationInterface
{

    /**
     * @var string
     */
    private $beanNamespace;
    /**
     * @var string
     */
    private $daoNamespace;
    /**
     * @var Connection
     */
    private $connection;
    /**
     * @var Cache
     */
    private $cache;
    /**
     * @var SchemaAnalyzer
     */
    private $schemaAnalyzer;
    /**
     * @var LoggerInterface
     */
    private $logger;
    /**
     * @var GeneratorListenerInterface
     */
    private $generatorEventDispatcher;
    /**
     * @var NamingStrategyInterface
     */
    private $namingStrategy;
    /**
     * The Composer file used to detect the path where files should be written.
     *
     * @var string
     */
    private $composerFile;

    /**
     * @param string $beanNamespace The namespace hosting the beans
     * @param string $daoNamespace The namespace hosting the DAOs
     * @param Connection $connection The connection to the database
     * @param Cache|null $cache The Doctrine cache to store database metadata
     * @param SchemaAnalyzer|null $schemaAnalyzer The schema analyzer that will be used to find shortest paths... Will be automatically created if not passed
     * @param LoggerInterface|null $logger The logger
     * @param GeneratorListenerInterface[] $generatorListeners A list of listeners that will be triggered when beans/daos are generated
     */
    public function __construct(string $beanNamespace, string $daoNamespace, Connection $connection, NamingStrategyInterface $namingStrategy, Cache $cache = null, SchemaAnalyzer $schemaAnalyzer = null, LoggerInterface $logger = null, array $generatorListeners = [])
    {
        $this->beanNamespace = rtrim($beanNamespace, '\\');
        $this->daoNamespace = rtrim($daoNamespace, '\\');
        $this->connection = $connection;
        $this->namingStrategy = $namingStrategy;
        if ($cache !== null) {
            $this->cache = $cache;
        } else {
            $this->cache = new VoidCache();
        }
        if ($schemaAnalyzer !== null) {
            $this->schemaAnalyzer = $schemaAnalyzer;
        } else {
            $this->schemaAnalyzer = new SchemaAnalyzer($this->connection->getSchemaManager(), $this->cache, $this->getConnectionUniqueId());
        }
        $this->logger = $logger;
        $this->generatorEventDispatcher = new GeneratorEventDispatcher($generatorListeners);
        $this->composerFile = 'composer.json';
    }

    /**
     * @return string
     */
    public function getBeanNamespace(): string
    {
        return $this->beanNamespace;
    }

    /**
     * @return string
     */
    public function getDaoNamespace(): string
    {
        return $this->daoNamespace;
    }

    /**
     * @return Connection
     */
    public function getConnection(): Connection
    {
        return $this->connection;
    }

    /**
     * @return NamingStrategyInterface
     */
    public function getNamingStrategy(): NamingStrategyInterface
    {
        return $this->namingStrategy;
    }

    /**
     * @return Cache
     */
    public function getCache(): Cache
    {
        return $this->cache;
    }

    /**
     * @return SchemaAnalyzer
     */
    public function getSchemaAnalyzer(): SchemaAnalyzer
    {
        return $this->schemaAnalyzer;
    }

    /**
     * @return LoggerInterface
     */
    public function getLogger(): ?LoggerInterface
    {
        return $this->logger;
    }

    /**
     * @return GeneratorListenerInterface
     */
    public function getGeneratorEventDispatcher(): GeneratorListenerInterface
    {
        return $this->generatorEventDispatcher;
    }



    /**
     * Creates a unique cache key for the current connection.
     *
     * @return string
     */
    private function getConnectionUniqueId(): string
    {
        return hash('md4', $this->connection->getHost().'-'.$this->connection->getPort().'-'.$this->connection->getDatabase().'-'.$this->connection->getDriver()->getName());
    }

    /**
     * @return null|string
     */
    public function getComposerFile() : string
    {
        return $this->composerFile;
    }

    /**
     * Sets the Composer file used to detect the path where files should be written.
     *
     * @param null|string $composerFile
     */
    public function setComposerFile(string $composerFile)
    {
        $this->composerFile = $composerFile;
    }
}


1			<?php
2
3
4			namespace Mouf\Database\TDBM;
5
6			use Doctrine\Common\Cache\Cache;
7			use Doctrine\Common\Cache\VoidCache;
8			use Doctrine\DBAL\Connection;
9			use Mouf\Database\SchemaAnalyzer\SchemaAnalyzer;
10			use Mouf\Database\TDBM\Utils\GeneratorEventDispatcher;
11			use Mouf\Database\TDBM\Utils\GeneratorListenerInterface;
12			use Mouf\Database\TDBM\Utils\NamingStrategyInterface;
13			use Psr\Log\LoggerInterface;
14
15			class Configuration implements ConfigurationInterface
16			{
17
18			/**
19			* @var string
20			*/
21			private $beanNamespace;
22			/**
23			* @var string
24			*/
25			private $daoNamespace;
26			/**
27			* @var Connection
28			*/
29			private $connection;
30			/**
31			* @var Cache
32			*/
33			private $cache;
34			/**
35			* @var SchemaAnalyzer
36			*/
37			private $schemaAnalyzer;
38			/**
39			* @var LoggerInterface
40			*/
41			private $logger;
42			/**
43			* @var GeneratorListenerInterface
44			*/
45			private $generatorEventDispatcher;
46			/**
47			* @var NamingStrategyInterface
48			*/
49			private $namingStrategy;
50			/**
51			* The Composer file used to detect the path where files should be written.
52			*
53			* @var string
54			*/
55			private $composerFile;
56
57			/**
58			* @param string $beanNamespace The namespace hosting the beans
59			* @param string $daoNamespace The namespace hosting the DAOs
60			* @param Connection $connection The connection to the database
61			* @param Cache\|null $cache The Doctrine cache to store database metadata
62			* @param SchemaAnalyzer\|null $schemaAnalyzer The schema analyzer that will be used to find shortest paths... Will be automatically created if not passed
63			* @param LoggerInterface\|null $logger The logger
64			* @param GeneratorListenerInterface[] $generatorListeners A list of listeners that will be triggered when beans/daos are generated
65			*/
66			public function __construct(string $beanNamespace, string $daoNamespace, Connection $connection, NamingStrategyInterface $namingStrategy, Cache $cache = null, SchemaAnalyzer $schemaAnalyzer = null, LoggerInterface $logger = null, array $generatorListeners = [])
67			{
68			$this->beanNamespace = rtrim($beanNamespace, '\\');
69			$this->daoNamespace = rtrim($daoNamespace, '\\');
70			$this->connection = $connection;
71			$this->namingStrategy = $namingStrategy;
72			if ($cache !== null) {
73			$this->cache = $cache;
74			} else {
75			$this->cache = new VoidCache();
76			}
77			if ($schemaAnalyzer !== null) {
78			$this->schemaAnalyzer = $schemaAnalyzer;
79			} else {
80			$this->schemaAnalyzer = new SchemaAnalyzer($this->connection->getSchemaManager(), $this->cache, $this->getConnectionUniqueId());
81			}
82			$this->logger = $logger;
83			$this->generatorEventDispatcher = new GeneratorEventDispatcher($generatorListeners);
84			$this->composerFile = 'composer.json';
85			}
86
87			/**
88			* @return string
89			*/
90			public function getBeanNamespace(): string
91			{
92			return $this->beanNamespace;
93			}
94
95			/**
96			* @return string
97			*/
98			public function getDaoNamespace(): string
99			{
100			return $this->daoNamespace;
101			}
102
103			/**
104			* @return Connection
105			*/
106			public function getConnection(): Connection
107			{
108			return $this->connection;
109			}
110
111			/**
112			* @return NamingStrategyInterface
113			*/
114			public function getNamingStrategy(): NamingStrategyInterface
115			{
116			return $this->namingStrategy;
117			}
118
119			/**
120			* @return Cache
121			*/
122			public function getCache(): Cache
123			{
124			return $this->cache;
125			}
126
127			/**
128			* @return SchemaAnalyzer
129			*/
130			public function getSchemaAnalyzer(): SchemaAnalyzer
131			{
132			return $this->schemaAnalyzer;
133			}
134
135			/**
136			* @return LoggerInterface
137			*/
138			public function getLogger(): ?LoggerInterface
139			{
140			return $this->logger;
141			}
142
143			/**
144			* @return GeneratorListenerInterface
145			*/
146			public function getGeneratorEventDispatcher(): GeneratorListenerInterface
147			{
148			return $this->generatorEventDispatcher;
149			}
150
151
152
153			/**
154			* Creates a unique cache key for the current connection.
155			*
156			* @return string
157			*/
158			private function getConnectionUniqueId(): string
159			{
160			return hash('md4', $this->connection->getHost().'-'.$this->connection->getPort().'-'.$this->connection->getDatabase().'-'.$this->connection->getDriver()->getName());
161			}
162
163			/**
164			* @return null\|string
165			*/
166			public function getComposerFile() : string
167			{
168			return $this->composerFile;
169			}
170
171			/**
172			* Sets the Composer file used to detect the path where files should be written.
173			*
174			* @param null\|string $composerFile
175			*/
176			public function setComposerFile(string $composerFile)
177			{
178			$this->composerFile = $composerFile;
179			}
180			}
181

thecodingmachine / database.tdbm

Pull Request — 4.2 (#140)

Configuration::getCache() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like