Writer::save() - Code Metrics - Inspection of "Extra options for neuralyzer" - edyan/neuralyzer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#9)

by Sander

created 2018-09-28 13:39 UTC

Writer::save() A

↳ Parent: Writer

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

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

<?php
/**
 * neuralyzer : Data Anonymization Library and CLI Tool
 *
 * PHP Version 7.1
 *
 * @package edyan/neuralyzer
 *
 * @author Emmanuel Dyan
 * @author Rémi Sauvat
 * @copyright 2018 Emmanuel Dyan
 * @license GNU General Public License v2.0
 *
 * @link https://github.com/edyan/neuralyzer
 */

namespace Edyan\Neuralyzer\Configuration;

use Edyan\Neuralyzer\Anonymizer\DB;
use Edyan\Neuralyzer\Exception\NeuralizerConfigurationException;
use Edyan\Neuralyzer\GuesserInterface;
use Symfony\Component\Config\Definition\Processor;
use Symfony\Component\Yaml\Yaml;

/**
 * Configuration Writer
 */
class Writer
{
    /**
     * List of tables patterns to ignore
     *
     * @var array
     */
    protected $ignoredTables = [];

    /**
     * Should I protect the cols ? That will also protect the Primary Keys
     *
     * @var boolean
     */
    protected $protectCols = true;

    /**
     * List the cols to protected. Could containe regexp
     *
     * @var array
     */
    protected $protectedCols = ['id', 'parent_id'];

    /**
     * Store the tables added to the conf
     *
     * @var array
     */
    protected $tablesInConf = [];

    /**
     * Doctrine conection handler
     * @var \Doctrine\DBAL\Connection
     */
    private $conn;


    /**
     * Generate the configuration by reading tables + cols
     *
     * @param  DB               $db
     * @param  GuesserInterface $guesser
     * @return array
     */
    public function generateConfFromDB(DB $db, GuesserInterface $guesser): array
    {
        $this->conn = $db->getConn();

        // First step : get the list of tables
        $tables = $this->getTablesList();
        if (empty($tables)) {
            throw new NeuralizerConfigurationException('No tables to read in that database');
        }

        // For each table, read the cols and guess the Faker
        $data = [];
        foreach ($tables as $table) {
            $cols = $this->getColsList($table);
            // No cols because all are ignored ?
            if (empty($cols)) {
                continue;
            }

            $data[$table]['cols'] = $this->guessColsAnonType($table, $cols, $guesser);
        }

        if (empty($data)) {
            throw new NeuralizerConfigurationException('All tables or fields have been ignored');
        }

        $config = [
            'entities' => $data
        ];

        $processor = new Processor();

        return $processor->processConfiguration(new ConfigDefinition, [$config]);
    }


    /**
     * Get Tables List added to the conf
     *
     * @return array
     */
    public function getTablesInConf(): array
    {
        return $this->tablesInConf;
    }


    /**
     * Set a flat to protect cols (Primary Key is protected by default)
     *
     * @param  bool   $protectCols
     * @return Writer
     */
    public function protectCols(bool $protectCols): Writer
    {
        $this->protectCols = $protectCols;

        return $this;
    }


    /**
     * Save the data to the file as YAML
     *
     * @param array  $data
     * @param string $filename
     */
    public function save(array $data, string $filename)
    {
        if (!is_writeable(dirname($filename))) {
            throw new NeuralizerConfigurationException(dirname($filename) . ' is not writeable.');
        }

        file_put_contents($filename, Yaml::dump($data, 4));
    }


    /**
     * Set protected cols
     *
     * @param array $ignoredTables
     * @return Writer
     */
    public function setIgnoredTables(array $ignoredTables): Writer
    {
        $this->ignoredTables = $ignoredTables;

        return $this;
    }


    /**
     * Set protected cols
     *
     * @param array $protectedCols
     * @return Writer
     */
    public function setProtectedCols(array $protectedCols): Writer
    {
        $this->protectedCols = $protectedCols;

        return $this;
    }


    /**
     * Check if that col has to be ignored
     *
     * @param  string $table
     * @param  string $col
     * @return bool
     */
    protected function colIgnored(string $table, string $col): bool
    {
        if ($this->protectCols === false) {
            return false;
        }

        foreach ($this->protectedCols as $protectedCol) {
            if (preg_match("/^$protectedCol\$/", $table . '.' . $col)) {
                return true;
            }
        }

        return false;
    }


    /**
     * Get the cols lists from a connection + table
     *
     * @param  string  $table
     * @return array
     */
    protected function getColsList(string $table): array
    {
        $schema = $this->conn->getSchemaManager();
        $tableDetails = $schema->listTableDetails($table);
        // No primary ? Exception !
        if ($tableDetails->hasPrimaryKey() === false) {
            throw new NeuralizerConfigurationException("Can't work with $table, it has no primary key.");
        }
        $primaryKey = $tableDetails->getPrimaryKey()->getColumns()[0];

        $cols = $schema->listTableColumns($table);
        $colsInfo = [];
        foreach ($cols as $col) {
            // If the col has to be ignored: just leave
            if ($primaryKey === $col->getName() || $this->colIgnored($table, $col->getName())) {
                continue;
            }

            $colsInfo[] = [
                'name' => $col->getName(),
                'type' => strtolower((string) $col->getType()),
                'len' => $col->getLength(),
            ];
        }

        return $colsInfo;
    }


    /**
     * Get the table lists from a connection
     *
     * @return array
     */
    protected function getTablesList(): array
    {
        $schemaManager = $this->conn->getSchemaManager();

        $tablesInDB = $schemaManager->listTables();
        $tables = [];
        foreach ($tablesInDB as $table) {
            if ($this->tableIgnored($table->getName())) {
                continue;
            }

            $tables[] = $this->tablesInConf[] = $table->getName();
        }

        return array_values($tables);
    }


    /**
     * Guess the cols with the guesser
     *
     * @param  string           $table
     * @param  array            $cols
     * @param  GuesserInterface $guesser
     * @return array
     */
    protected function guessColsAnonType(string $table, array $cols, GuesserInterface $guesser): array
    {
        $mapping = [];
        foreach ($cols as $props) {
            $mapping[$props['name']] = $guesser->mapCol($table, $props['name'], $props['type'], $props['len']);
        }

        return $mapping;
    }


    /**
     * Check if that table has to be ignored
     *
     * @param  string $table
     * @return bool
     */
    protected function tableIgnored(string $table): bool
    {
        foreach ($this->ignoredTables as $ignoredTable) {
            if (preg_match("/^$ignoredTable\$/", $table)) {
                return true;
            }
        }

        return false;
    }
}


1			<?php
2			/**
3			* neuralyzer : Data Anonymization Library and CLI Tool
4			*
5			* PHP Version 7.1
6			*
7			* @package edyan/neuralyzer
8			*
9			* @author Emmanuel Dyan
10			* @author Rémi Sauvat
11			* @copyright 2018 Emmanuel Dyan
12			* @license GNU General Public License v2.0
13			*
14			* @link https://github.com/edyan/neuralyzer
15			*/
16
17			namespace Edyan\Neuralyzer\Configuration;
18
19			use Edyan\Neuralyzer\Anonymizer\DB;
20			use Edyan\Neuralyzer\Exception\NeuralizerConfigurationException;
21			use Edyan\Neuralyzer\GuesserInterface;
22			use Symfony\Component\Config\Definition\Processor;
23			use Symfony\Component\Yaml\Yaml;
24
25			/**
26			* Configuration Writer
27			*/
28			class Writer
29			{
30			/**
31			* List of tables patterns to ignore
32			*
33			* @var array
34			*/
35			protected $ignoredTables = [];
36
37			/**
38			* Should I protect the cols ? That will also protect the Primary Keys
39			*
40			* @var boolean
41			*/
42			protected $protectCols = true;
43
44			/**
45			* List the cols to protected. Could containe regexp
46			*
47			* @var array
48			*/
49			protected $protectedCols = ['id', 'parent_id'];
50
51			/**
52			* Store the tables added to the conf
53			*
54			* @var array
55			*/
56			protected $tablesInConf = [];
57
58			/**
59			* Doctrine conection handler
60			* @var \Doctrine\DBAL\Connection
61			*/
62			private $conn;
63
64
65			/**
66			* Generate the configuration by reading tables + cols
67			*
68			* @param DB $db
69			* @param GuesserInterface $guesser
70			* @return array
71			*/
72			public function generateConfFromDB(DB $db, GuesserInterface $guesser): array
73			{
74			$this->conn = $db->getConn();
75
76			// First step : get the list of tables
77			$tables = $this->getTablesList();
78			if (empty($tables)) {
79			throw new NeuralizerConfigurationException('No tables to read in that database');
80			}
81
82			// For each table, read the cols and guess the Faker
83			$data = [];
84			foreach ($tables as $table) {
85			$cols = $this->getColsList($table);
86			// No cols because all are ignored ?
87			if (empty($cols)) {
88			continue;
89			}
90
91			$data[$table]['cols'] = $this->guessColsAnonType($table, $cols, $guesser);
92			}
93
94			if (empty($data)) {
95			throw new NeuralizerConfigurationException('All tables or fields have been ignored');
96			}
97
98			$config = [
99			'entities' => $data
100			];
101
102			$processor = new Processor();
103
104			return $processor->processConfiguration(new ConfigDefinition, [$config]);
105			}
106
107
108			/**
109			* Get Tables List added to the conf
110			*
111			* @return array
112			*/
113			public function getTablesInConf(): array
114			{
115			return $this->tablesInConf;
116			}
117
118
119			/**
120			* Set a flat to protect cols (Primary Key is protected by default)
121			*
122			* @param bool $protectCols
123			* @return Writer
124			*/
125			public function protectCols(bool $protectCols): Writer
126			{
127			$this->protectCols = $protectCols;
128
129			return $this;
130			}
131
132
133			/**
134			* Save the data to the file as YAML
135			*
136			* @param array $data
137			* @param string $filename
138			*/
139			public function save(array $data, string $filename)
140			{
141			if (!is_writeable(dirname($filename))) {
142			throw new NeuralizerConfigurationException(dirname($filename) . ' is not writeable.');
143			}
144
145			file_put_contents($filename, Yaml::dump($data, 4));
146			}
147
148
149			/**
150			* Set protected cols
151			*
152			* @param array $ignoredTables
153			* @return Writer
154			*/
155			public function setIgnoredTables(array $ignoredTables): Writer
156			{
157			$this->ignoredTables = $ignoredTables;
158
159			return $this;
160			}
161
162
163			/**
164			* Set protected cols
165			*
166			* @param array $protectedCols
167			* @return Writer
168			*/
169			public function setProtectedCols(array $protectedCols): Writer
170			{
171			$this->protectedCols = $protectedCols;
172
173			return $this;
174			}
175
176
177			/**
178			* Check if that col has to be ignored
179			*
180			* @param string $table
181			* @param string $col
182			* @return bool
183			*/
184			protected function colIgnored(string $table, string $col): bool
185			{
186			if ($this->protectCols === false) {
187			return false;
188			}
189
190			foreach ($this->protectedCols as $protectedCol) {
191			if (preg_match("/^$protectedCol\$/", $table . '.' . $col)) {
192			return true;
193			}
194			}
195
196			return false;
197			}
198
199
200			/**
201			* Get the cols lists from a connection + table
202			*
203			* @param string $table
204			* @return array
205			*/
206			protected function getColsList(string $table): array
207			{
208			$schema = $this->conn->getSchemaManager();
209			$tableDetails = $schema->listTableDetails($table);
210			// No primary ? Exception !
211			if ($tableDetails->hasPrimaryKey() === false) {
212			throw new NeuralizerConfigurationException("Can't work with $table, it has no primary key.");
213			}
214			$primaryKey = $tableDetails->getPrimaryKey()->getColumns()[0];
215
216			$cols = $schema->listTableColumns($table);
217			$colsInfo = [];
218			foreach ($cols as $col) {
219			// If the col has to be ignored: just leave
220			if ($primaryKey === $col->getName() \|\| $this->colIgnored($table, $col->getName())) {
221			continue;
222			}
223
224			$colsInfo[] = [
225			'name' => $col->getName(),
226			'type' => strtolower((string) $col->getType()),
227			'len' => $col->getLength(),
228			];
229			}
230
231			return $colsInfo;
232			}
233
234
235			/**
236			* Get the table lists from a connection
237			*
238			* @return array
239			*/
240			protected function getTablesList(): array
241			{
242			$schemaManager = $this->conn->getSchemaManager();
243
244			$tablesInDB = $schemaManager->listTables();
245			$tables = [];
246			foreach ($tablesInDB as $table) {
247			if ($this->tableIgnored($table->getName())) {
248			continue;
249			}
250
251			$tables[] = $this->tablesInConf[] = $table->getName();
252			}
253
254			return array_values($tables);
255			}
256
257
258			/**
259			* Guess the cols with the guesser
260			*
261			* @param string $table
262			* @param array $cols
263			* @param GuesserInterface $guesser
264			* @return array
265			*/
266			protected function guessColsAnonType(string $table, array $cols, GuesserInterface $guesser): array
267			{
268			$mapping = [];
269			foreach ($cols as $props) {
270			$mapping[$props['name']] = $guesser->mapCol($table, $props['name'], $props['type'], $props['len']);
271			}
272
273			return $mapping;
274			}
275
276
277			/**
278			* Check if that table has to be ignored
279			*
280			* @param string $table
281			* @return bool
282			*/
283			protected function tableIgnored(string $table): bool
284			{
285			foreach ($this->ignoredTables as $ignoredTable) {
286			if (preg_match("/^$ignoredTable\$/", $table)) {
287			return true;
288			}
289			}
290
291			return false;
292			}
293			}
294

edyan / neuralyzer

Pull Request — master (#9)

Writer::save() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like