Passed
Pull Request — 4.2 (#140)
by David
05:21
created

Configuration::__construct()   A

Complexity

Conditions 3
Paths 4

Size

Total Lines 20
Code Lines 16

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
dl 0
loc 20
rs 9.4285
c 0
b 0
f 0
cc 3
eloc 16
nc 4
nop 8

How to fix   Many Parameters   

Many Parameters

Methods with many parameters are not only hard to understand, but their parameters also often become inconsistent when you need more, or different data.

There are several approaches to avoid long parameter lists:

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