ClientLocal::createResponseFromData() - Code Metrics - Inspection of "add branch alias" - directus/directus-sdk-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — d64 ( b18498...be696f )

by Welling

created 2016-11-16 18:15 UTC

ClientLocal::createResponseFromData() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

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

<?php

/**
 * Directus – <http://getdirectus.com>
 *
 * @link      The canonical repository – <https://github.com/directus/directus>
 * @copyright Copyright 2006-2016 RANGER Studio, LLC – <http://rangerstudio.com>
 * @license   GNU General Public License (v3) – <http://www.gnu.org/copyleft/gpl.html>
 */

namespace Directus\SDK;

use Directus\Database\Connection;
use Directus\Database\TableGateway\BaseTableGateway;
use Directus\Database\TableGateway\DirectusMessagesTableGateway;
use Directus\Database\TableGateway\RelationalTableGateway;
use Directus\Database\TableSchema;

/**
 * Client Local
 *
 * Client to Interact with the database directly using Directus Database Component
 *
 * @author Welling Guzmán <[email protected]>
 */
class ClientLocal extends AbstractClient
{
    /**
     * @var BaseTableGateway[]
     */
    protected $tableGateways = [];

    /**
     * @var Connection
     */
    protected $connection = null;

    /**
     * ClientLocal constructor.
     *
     * @param $connection
     */
    public function __construct($connection)
    {
        $this->connection = $connection;
    }

    /**
     * @inheritDoc
     */
    public function getTables(array $params = [])
    {
        return $this->createResponseFromData(TableSchema::getTablesSchema($params));

    }

    /**
     * @inheritDoc
     */
    public function getTable($tableName)
    {
        return $this->createResponseFromData(TableSchema::getSchemaArray($tableName));

    }

    /**
     * @inheritDoc
     */
    public function getColumns($tableName, array $params = [])
    {
        return $this->createResponseFromData(TableSchema::getColumnSchemaArray($tableName, $params));

    }

    /**
     * @inheritDoc
     */
    public function getColumn($tableName, $columnName)
    {
        return $this->createResponseFromData(TableSchema::getColumnSchemaArray($tableName, $columnName));

    }

    /**
     * @inheritDoc
     */
    public function getEntries($tableName, array $params = [])
    {
        $tableGateway = $this->getTableGateway($tableName);

        return $this->createResponseFromData($tableGateway->getEntries($params));

    }

    /**
     * @inheritDoc
     */
    public function getEntry($tableName, $id, array $params = [])
    {
        // @TODO: Dynamic ID
        return $this->getEntries($tableName, array_merge($params, [
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            'id' => $id
        ]));
    }

    /**
     * @inheritDoc
     */
    public function getUsers(array $params = [])
    {
        // @TODO: store the directus tables somewhere (SchemaManager?)
        return $this->getEntries('directus_users', $params);
    }

    /**
     * @inheritDoc
     */
    public function getUser($id, array $params = [])
    {
        return $this->getEntry('directus_users', $id, $params);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @inheritDoc
     */
    public function getGroups(array $params = [])
    {
        return $this->getEntries('directus_groups', $params);
    }

    /**
     * @inheritDoc
     */
    public function getGroup($id, array $params = [])
    {
        return $this->getEntry('directus_groups', $id, $params);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @inheritDoc
     */
    public function getGroupPrivileges($groupID)
    {
        $this->getEntries('directus_privileges', [
            'filter' => [
                'group_id' => ['eq' => $groupID]
            ]
        ]);
    }

    /**
     * @inheritDoc
     */
    public function getFiles(array $params = [])
    {
        return $this->getEntries('directus_files', $params);
    }

    /**
     * @inheritDoc
     */
    public function getFile($id, array $params = [])
    {
        return $this->getEntry('directus_files', $id, $params);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @inheritDoc
     */
    public function getSettings()
    {
        return $this->getEntries('directus_settings');
    }

    /**
     * @inheritDoc
     */
    public function getSettingsByCollection($collectionName)
    {
        return $this->getEntries('directus_settings', [
            'filter' => [
                'collection' => ['eq' => $collectionName]
            ]
        ]);
    }

    /**
     * @inheritDoc
     */
    public function getMessages($userId)
    {
        $messagesTableGateway = new DirectusMessagesTableGateway($this->connection, null);
        $result = $messagesTableGateway->fetchMessagesInboxWithHeaders($userId);

        return $this->createResponseFromData($result);

    }

    /**
     * @inheritDoc
     */
    public function createEntry($tableName, array $data)
    {
        $tableGateway = $this->getTableGateway($tableName);
        $newRecord = $tableGateway->manageRecordUpdate($tableName, $data);

        return $this->createResponseFromData($newRecord->toArray());

    }

    /**
     * @inheritDoc
     */
    public function updateEntry($tableName, $id, array $data)
    {
        $tableGateway = $this->getTableGateway($tableName);
        $record = $tableGateway->manageRecordUpdate($tableName, array_merge($data, ['id' => $id]));

        return $this->createResponseFromData($record->toArray());
    }

    /**
     * @inheritDoc
     */
    public function deleteEntry($tableName, $ids)
    {
        // @TODO: Accept EntryCollection and Entry
        $tableGateway = $this->getTableGateway($tableName);

        if (!is_array($ids)) {
            $ids = [$ids];
        }

        return $tableGateway->delete(function($delete) use ($ids) {
            return $delete->where->in('id', $ids);
        });
    }

    /**
     * @inheritDoc
     */
    public function createUser(array $data)
    {
        return $this->createEntry('directus_users', $data);
    }

    /**
     * @inheritDoc
     */
    public function updateUser($id, array $data)
    {
        return $this->updateEntry('directus_users', $id, $data);
    }

    /**
     * @inheritDoc
     */
    public function deleteUser($ids)
    {
        return $this->deleteEntry('directus_users', $ids);
    }

    /**
     * @inheritDoc
     */
    public function createFile(array $data)
    {
        return $this->createEntry('directus_files', $data);
    }

    /**
     * @inheritDoc
     */
    public function updateFile($id, array $data)
    {
        return $this->updateEntry('directus_files', $id, $data);
    }

    /**
     * @inheritDoc
     */
    public function deleteFile($ids)
    {
        return $this->deleteEntry('directus_files', $ids);
    }


    /**
     * Get a table gateway for the given table name
     *
     * @param $tableName
     *
     * @return RelationalTableGateway
     */
    protected function getTableGateway($tableName)
    {
        if (!array_key_exists($tableName, $this->tableGateways)) {
            $acl = TableSchema::getAclInstance();
            $this->tableGateways[$tableName] = new RelationalTableGateway($tableName, $this->connection, $acl);
        }

        return $this->tableGateways[$tableName];

    }
}


1			<?php
2
3			/**
4			* Directus – <http://getdirectus.com>
5			*
6			* @link The canonical repository – <https://github.com/directus/directus>
7			* @copyright Copyright 2006-2016 RANGER Studio, LLC – <http://rangerstudio.com>
8			* @license GNU General Public License (v3) – <http://www.gnu.org/copyleft/gpl.html>
9			*/
10
11			namespace Directus\SDK;
12
13			use Directus\Database\Connection;
14			use Directus\Database\TableGateway\BaseTableGateway;
15			use Directus\Database\TableGateway\DirectusMessagesTableGateway;
16			use Directus\Database\TableGateway\RelationalTableGateway;
17			use Directus\Database\TableSchema;
18
19			/**
20			* Client Local
21			*
22			* Client to Interact with the database directly using Directus Database Component
23			*
24			* @author Welling Guzmán <[email protected]>
25			*/
26			class ClientLocal extends AbstractClient
27			{
28			/**
29			* @var BaseTableGateway[]
30			*/
31			protected $tableGateways = [];
32
33			/**
34			* @var Connection
35			*/
36			protected $connection = null;
37
38			/**
39			* ClientLocal constructor.
40			*
41			* @param $connection
42			*/
43			public function __construct($connection)
44			{
45			$this->connection = $connection;
46			}
47
48			/**
49			* @inheritDoc
50			*/
51			public function getTables(array $params = [])
52			{
53			return $this->createResponseFromData(TableSchema::getTablesSchema($params));
			0 ignored issues – show Bug Compatibility introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...TablesSchema($params));` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\Entry` to the return on line 53 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getTables` of type `Directus\SDK\Response\EntryCollection`. Loading history...
54			}
55
56			/**
57			* @inheritDoc
58			*/
59			public function getTable($tableName)
60			{
61			return $this->createResponseFromData(TableSchema::getSchemaArray($tableName));
			0 ignored issues – show Bug Compatibility introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...hemaArray($tableName));` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\EntryCollection` to the return on line 61 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getTable` of type `Directus\SDK\Response\Entry`. Loading history...
62			}
63
64			/**
65			* @inheritDoc
66			*/
67			public function getColumns($tableName, array $params = [])
68			{
69			return $this->createResponseFromData(TableSchema::getColumnSchemaArray($tableName, $params));
			0 ignored issues – show Bug Compatibility introduced 2016-11-02 22:04 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...($tableName, $params));` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\Entry` to the return on line 69 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getColumns` of type `Directus\SDK\Response\EntryCollection`. Loading history...
70			}
71
72			/**
73			* @inheritDoc
74			*/
75			public function getColumn($tableName, $columnName)
76			{
77			return $this->createResponseFromData(TableSchema::getColumnSchemaArray($tableName, $columnName));
			0 ignored issues – show Bug Compatibility introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...bleName, $columnName));` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\EntryCollection` to the return on line 77 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getColumn` of type `Directus\SDK\Response\Entry`. Loading history...
78			}
79
80			/**
81			* @inheritDoc
82			*/
83			public function getEntries($tableName, array $params = [])
84			{
85			$tableGateway = $this->getTableGateway($tableName);
86
87			return $this->createResponseFromData($tableGateway->getEntries($params));
			0 ignored issues – show Bug Compatibility introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...->getEntries($params));` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\Entry` to the return on line 87 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getEntries` of type `Directus\SDK\Response\EntryCollection`. Loading history...
88			}
89
90			/**
91			* @inheritDoc
92			*/
93			public function getEntry($tableName, $id, array $params = [])
94			{
95			// @TODO: Dynamic ID
96			return $this->getEntries($tableName, array_merge($params, [
			0 ignored issues – show Bug Best Practice introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The return type of `return $this->getEntries..., array('id' => $id)));` (`Directus\SDK\Response\EntryCollection`) is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getEntry` of type `Directus\SDK\Response\Entry`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
97			'id' => $id
98			]));
99			}
100
101			/**
102			* @inheritDoc
103			*/
104			public function getUsers(array $params = [])
105			{
106			// @TODO: store the directus tables somewhere (SchemaManager?)
107			return $this->getEntries('directus_users', $params);
108			}
109
110			/**
111			* @inheritDoc
112			*/
113			public function getUser($id, array $params = [])
114			{
115			return $this->getEntry('directus_users', $id, $params);
			0 ignored issues – show Bug Best Practice introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The return type of `return $this->getEntry('..._users', $id, $params);` (`Directus\SDK\Response\EntryCollection`) is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getUser` of type `Directus\SDK\Response\Entry`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
116			}
117
118			/**
119			* @inheritDoc
120			*/
121			public function getGroups(array $params = [])
122			{
123			return $this->getEntries('directus_groups', $params);
124			}
125
126			/**
127			* @inheritDoc
128			*/
129			public function getGroup($id, array $params = [])
130			{
131			return $this->getEntry('directus_groups', $id, $params);
			0 ignored issues – show Bug Best Practice introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The return type of `return $this->getEntry('...groups', $id, $params);` (`Directus\SDK\Response\EntryCollection`) is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getGroup` of type `Directus\SDK\Response\Entry`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
132			}
133
134			/**
135			* @inheritDoc
136			*/
137			public function getGroupPrivileges($groupID)
138			{
139			$this->getEntries('directus_privileges', [
140			'filter' => [
141			'group_id' => ['eq' => $groupID]
142			]
143			]);
144			}
145
146			/**
147			* @inheritDoc
148			*/
149			public function getFiles(array $params = [])
150			{
151			return $this->getEntries('directus_files', $params);
152			}
153
154			/**
155			* @inheritDoc
156			*/
157			public function getFile($id, array $params = [])
158			{
159			return $this->getEntry('directus_files', $id, $params);
			0 ignored issues – show Bug Best Practice introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The return type of `return $this->getEntry('..._files', $id, $params);` (`Directus\SDK\Response\EntryCollection`) is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getFile` of type `Directus\SDK\Response\Entry`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
160			}
161
162			/**
163			* @inheritDoc
164			*/
165			public function getSettings()
166			{
167			return $this->getEntries('directus_settings');
168			}
169
170			/**
171			* @inheritDoc
172			*/
173			public function getSettingsByCollection($collectionName)
174			{
175			return $this->getEntries('directus_settings', [
176			'filter' => [
177			'collection' => ['eq' => $collectionName]
178			]
179			]);
180			}
181
182			/**
183			* @inheritDoc
184			*/
185			public function getMessages($userId)
186			{
187			$messagesTableGateway = new DirectusMessagesTableGateway($this->connection, null);
188			$result = $messagesTableGateway->fetchMessagesInboxWithHeaders($userId);
189
190			return $this->createResponseFromData($result);
			0 ignored issues – show Bug Compatibility introduced 2016-11-01 06:08 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFromData($result);` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\Entry` to the return on line 190 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getMessages` of type `Directus\SDK\Response\EntryCollection`. Loading history...
191			}
192
193			/**
194			* @inheritDoc
195			*/
196			public function createEntry($tableName, array $data)
197			{
198			$tableGateway = $this->getTableGateway($tableName);
199			$newRecord = $tableGateway->manageRecordUpdate($tableName, $data);
200
201			return $this->createResponseFromData($newRecord->toArray());
			0 ignored issues – show Bug Compatibility introduced 2016-11-01 21:59 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...$newRecord->toArray());` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\EntryCollection` to the return on line 201 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::createEntry` of type `Directus\SDK\Response\Entry`. Loading history...
202			}
203
204			/**
205			* @inheritDoc
206			*/
207			public function updateEntry($tableName, $id, array $data)
208			{
209			$tableGateway = $this->getTableGateway($tableName);
210			$record = $tableGateway->manageRecordUpdate($tableName, array_merge($data, ['id' => $id]));
211
212			return $this->createResponseFromData($record->toArray());
213			}
214
215			/**
216			* @inheritDoc
217			*/
218			public function deleteEntry($tableName, $ids)
219			{
220			// @TODO: Accept EntryCollection and Entry
221			$tableGateway = $this->getTableGateway($tableName);
222
223			if (!is_array($ids)) {
224			$ids = [$ids];
225			}
226
227			return $tableGateway->delete(function($delete) use ($ids) {
228			return $delete->where->in('id', $ids);
229			});
230			}
231
232			/**
233			* @inheritDoc
234			*/
235			public function createUser(array $data)
236			{
237			return $this->createEntry('directus_users', $data);
238			}
239
240			/**
241			* @inheritDoc
242			*/
243			public function updateUser($id, array $data)
244			{
245			return $this->updateEntry('directus_users', $id, $data);
246			}
247
248			/**
249			* @inheritDoc
250			*/
251			public function deleteUser($ids)
252			{
253			return $this->deleteEntry('directus_users', $ids);
254			}
255
256			/**
257			* @inheritDoc
258			*/
259			public function createFile(array $data)
260			{
261			return $this->createEntry('directus_files', $data);
262			}
263
264			/**
265			* @inheritDoc
266			*/
267			public function updateFile($id, array $data)
268			{
269			return $this->updateEntry('directus_files', $id, $data);
270			}
271
272			/**
273			* @inheritDoc
274			*/
275			public function deleteFile($ids)
276			{
277			return $this->deleteEntry('directus_files', $ids);
278			}
279
280
281			/**
282			* Get a table gateway for the given table name
283			*
284			* @param $tableName
285			*
286			* @return RelationalTableGateway
287			*/
288			protected function getTableGateway($tableName)
289			{
290			if (!array_key_exists($tableName, $this->tableGateways)) {
291			$acl = TableSchema::getAclInstance();
292			$this->tableGateways[$tableName] = new RelationalTableGateway($tableName, $this->connection, $acl);
293			}
294
295			return $this->tableGateways[$tableName];
			0 ignored issues – show Bug Compatibility introduced 2016-11-16 18:40 UTC by Report Bug Copy Issue Report The expression `$this->tableGateways[$tableName];` of type `Directus\Database\TableG...\RelationalTableGateway` adds the type `Directus\Database\TableGateway\BaseTableGateway` to the return on line 295 which is incompatible with the return type documented by `Directus\SDK\ClientLocal::getTableGateway` of type `Directus\Database\TableG...\RelationalTableGateway`. Loading history...
296			}
297			}
298

directus / directus-sdk-php

Push — d64 ( b18498...be696f )

ClientLocal::createResponseFromData() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like