Table::getOrCreate() - Code Metrics - Inspection of "new functions for v7.3.0" - oscarotero/simple-crud - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c3b1de...399698 )

by Oscar

created 2019-11-28 13:26 UTC

Table::getOrCreate() A

↳ Parent: Table

Complexity

Conditions	3
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	18
rs	9.6666
c	0
b	0
f	0
cc	3
nc	4
nop	1

<?php
declare(strict_types = 1);

namespace SimpleCrud;

use ArrayAccess;
use Countable;
use Psr\EventDispatcher\EventDispatcherInterface;
use SimpleCrud\EventDispatcher\Dispatcher;
use SimpleCrud\Events\BeforeCreateRow;
use SimpleCrud\Events\CreateDeleteQuery;
use SimpleCrud\Events\CreateInsertQuery;
use SimpleCrud\Events\CreateSelectQuery;
use SimpleCrud\Events\CreateUpdateQuery;
use SimpleCrud\Fields\Field;
use SimpleCrud\Queries\Delete;
use SimpleCrud\Queries\Insert;
use SimpleCrud\Queries\Select;
use SimpleCrud\Queries\SelectAggregate;
use SimpleCrud\Queries\Update;

/**
 * Manages a database table.
 *
 * @property Field $id
 */
class Table implements ArrayAccess, Countable
{
    private $name;
    private $db;
    private $cache = [];
    private $fields = [];
    private $defaults = [];
    private $eventDispatcher;
    private $fieldFactories;

    protected const ROW_CLASS = Row::class;
    protected const ROWCOLLECTION_CLASS = RowCollection::class;

    final public function __construct(Database $db, string $name)
    {
        $this->db = $db;
        $this->name = $name;

        $this->fieldFactories = $db->getFieldFactories();
        $fields = $db->getScheme()->getTableFields($name);

        foreach ($fields as $info) {
            $field = $this->createField($info);

            $this->fields[$field->getName()] = $field;
            $this->defaults[$field->getName()] = null;
        }

        $this->init();
    }

    protected function init(): void
    {
    }

    public function __debugInfo(): array
    {
        return [
            'name' => $this->name,
            'fields' => $this->fields,
        ];
    }

    public function __toString()
    {
        return "`{$this->name}`";
    }

    public function setEventDispatcher(EventDispatcherInterface $eventDispatcher): self
    {
        $this->eventDispatcher = $eventDispatcher;

        return $this;
    }

    public function getEventDispatcher(): EventDispatcherInterface
    {
        if ($this->eventDispatcher === null) {
            $this->eventDispatcher = new Dispatcher();
        }

        return $this->eventDispatcher;
    }

    /**
     * Get the devault values used in new rows
     */
    public function getDefaults(array $overrides = null): array
    {
        if (empty($overrides)) {
            return $this->defaults;
        }

        $diff = array_diff_key($overrides, $this->fields);

        if (!empty($diff)) {
            throw new SimpleCrudException(
                sprintf('The field %s does not exist in the table %s', implode(array_keys($diff)), $this)
            );
        }

        return $overrides + $this->defaults;
    }

    /**
     * Format selected data from the database
    */
    public function format(array $values): array
    {
        foreach ($this->fields as $name => $field) {
            if (array_key_exists($name, $values)) {
                $values[$name] = $field->format($values[$name]);
            }
        }

        return $values;
    }

    /**
     * Store a row in the cache.
     */
    public function cache(Row $row): Row
    {
        if ($row->id) {
            $this->cache[$row->id] = $row;
        }

        return $row;
    }

    /**
     * Clear the current cache.
     */
    public function clearCache(): self
    {
        $this->cache = [];

        return $this;
    }

    /**
     * Returns whether the id is cached or not
     * @param mixed $id
     */
    public function isCached($id): bool
    {
        return array_key_exists($id, $this->cache);
    }

    /**
     * Returns a row from the cache.
     * @param mixed $id
     */
    public function getCached($id): ?Row
    {
        if (!$this->isCached($id)) {
            return null;
        }

        $row = $this->cache[$id];

        if ($row && !$row->id) {
            return $this->cache[$id] = null;
        }

        return $row;
    }

    public function delete(): Delete
    {
        $query = new Delete($this);

        if ($eventDispatcher = $this->getEventDispatcher()) {
            $eventDispatcher->dispatch(new CreateDeleteQuery($query));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return $query;
    }

    public function insert(array $data = []): Insert
    {
        $query = new Insert($this, $data);

        if ($eventDispatcher = $this->getEventDispatcher()) {
            $eventDispatcher->dispatch(new CreateInsertQuery($query));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return $query;
    }

    public function select(): Select
    {
        $query = new Select($this);

        if ($eventDispatcher = $this->getEventDispatcher()) {
            $eventDispatcher->dispatch(new CreateSelectQuery($query));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return $query;
    }

    public function selectAggregate(string $function, string $field = 'id'): SelectAggregate
    {
        $query = new SelectAggregate($this, $function, $field);

        if ($eventDispatcher = $this->getEventDispatcher()) {
            $eventDispatcher->dispatch(new CreateSelectQuery($query));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return $query;
    }

    public function update(array $data = []): Update
    {
        $query = new Update($this, $data);

        if ($eventDispatcher = $this->getEventDispatcher()) {
            $eventDispatcher->dispatch(new CreateUpdateQuery($query));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return $query;
    }

    /**
     * Magic method to get the Field instance of a table field
     */
    public function __get(string $name): Field
    {
        if (!isset($this->fields[$name])) {
            throw new SimpleCrudException(
                sprintf('The field `%s` does not exist in the table %s', $name, $this)
            );
        }

        return $this->fields[$name];
    }

    /**
     * Magic method to check if a field exists or not.
     */
    public function __isset(string $name): bool
    {
        return isset($this->fields[$name]);
    }

    /**
     * @see Countable
     */
    public function count(): int
    {
        return $this->selectAggregate('COUNT')->run();
    }

    /**
     * Check if a row with a specific id exists.
     *
     * @see ArrayAccess
     * @param mixed $offset
     */
    public function offsetExists($offset): bool
    {
        if ($this->isCached($offset)) {
            return $this->getCached($offset) !== null;
        }

        return $this->selectAggregate('COUNT')
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->where('id = ', $offset)
            ->limit(1)
            ->run() === 1;
    }

    /**
     * Returns a row with a specific id.
     *
     * @see ArrayAccess
     *
     * @param mixed $offset
     */
    public function offsetGet($offset): ?Row
    {
        if ($this->isCached($offset)) {
            return $this->getCached($offset);
        }

        return $this->cache[$offset] = $this->select()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->one()
            ->where('id = ', $offset)
            ->run();
    }

    /**
     * Store a row with a specific id.
     *
     * @see ArrayAccess
     * @param mixed $offset
     * @param mixed $value
     */
    public function offsetSet($offset, $value): Row
    {
        //Insert on missing offset
        if ($offset === null) {
            $value['id'] = null;

            return $this->create($value)->save();
        }

        //Update if the element is cached and exists
        $row = $this->getCached($offset);

        if ($row) {
            return $row->edit($value)->save();
        }

        //Update if the element it's not cached
        if (!$this->isCached($row)) {
            $this->update()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                ->columns($value)
                ->where('id = ', $offset)
                ->run();
        }
    }

    /**
     * Remove a row with a specific id.
     *
     * @see ArrayAccess
     * @param mixed $offset
     */
    public function offsetUnset($offset)
    {
        $this->cache[$offset] = null;

        $this->delete()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->where('id = ', $offset)
            ->run();
    }

    /**
     * Returns the table name.
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * Returns the foreign key name.
     */
    public function getForeignKey(): string
    {
        return "{$this->name}_id";
    }

    /**
     * Returns the foreign key.
     */
    public function getJoinField(Table $table): ?Field
    {
        $field = $table->getForeignKey();

        return $this->fields[$field] ?? null;
    }

    public function getJoinTable(Table $table): ?Table
    {
        $name1 = $this->getName();
        $name2 = $table->getName();
        $name = $name1 < $name2 ? "{$name1}_{$name2}" : "{$name2}_{$name1}";

        $joinTable = $this->db->{$name} ?? null;

        if ($joinTable && $joinTable->getJoinField($this) && $joinTable->getJoinField($table)) {
            return $joinTable;
        }

        return null;
    }

    /**
     * Returns the Database instance associated with this table.
     */
    public function getDatabase(): Database
    {
        return $this->db;
    }

    /**
     * Returns all fields.
     *
     * @return Field[]
     */
    public function getFields()
    {
        return $this->fields;
    }

    public function __call(string $name, array $args): ?Row
    {
        $field = $this->__get($name);

        return $this->select()->one()->where("{$field} = ", $args[0])->run();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /**
     * Search a row with some values or create one if it does not exist
     */
    public function getOrCreate(array $data): Row
    {
        $query = $this->select()->one();

        foreach ($data as $name => $value) {
            $field = $this->__get($name);

            $query->where("{$field} = ", $value);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        }

        $row = $query->run();

        if ($row) {
            return $row;
        }

        return $this->create($data);
    }

    public function create(array $data = []): Row
    {
        if (isset($data['id']) && ($row = $this->getCached($data['id']))) {
            return $row;
        }

        $eventDispatcher = $this->getEventDispatcher();

        if ($eventDispatcher) {
            $event = new BeforeCreateRow($data);
            $eventDispatcher->dispatch($event);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $data = $event->getData();
        }

        $class = static::ROW_CLASS;
        return $this->cache(new $class($this, $data));
    }

    public function createCollection(array $rows = []): RowCollection
    {
        $class = static::ROWCOLLECTION_CLASS;
        return new $class($this, ...$rows);
    }

    public function createField(array $info): Field
    {
        foreach ($this->fieldFactories as $fieldFactory) {
            if ($field = $fieldFactory->create($this, $info)) {
                return $field;
            }
        }

        return new Field($this, $info);
    }
}


1			<?php
2			declare(strict_types = 1);
3
4			namespace SimpleCrud;
5
6			use ArrayAccess;
7			use Countable;
8			use Psr\EventDispatcher\EventDispatcherInterface;
9			use SimpleCrud\EventDispatcher\Dispatcher;
10			use SimpleCrud\Events\BeforeCreateRow;
11			use SimpleCrud\Events\CreateDeleteQuery;
12			use SimpleCrud\Events\CreateInsertQuery;
13			use SimpleCrud\Events\CreateSelectQuery;
14			use SimpleCrud\Events\CreateUpdateQuery;
15			use SimpleCrud\Fields\Field;
16			use SimpleCrud\Queries\Delete;
17			use SimpleCrud\Queries\Insert;
18			use SimpleCrud\Queries\Select;
19			use SimpleCrud\Queries\SelectAggregate;
20			use SimpleCrud\Queries\Update;
21
22			/**
23			* Manages a database table.
24			*
25			* @property Field $id
26			*/
27			class Table implements ArrayAccess, Countable
28			{
29			private $name;
30			private $db;
31			private $cache = [];
32			private $fields = [];
33			private $defaults = [];
34			private $eventDispatcher;
35			private $fieldFactories;
36
37			protected const ROW_CLASS = Row::class;
38			protected const ROWCOLLECTION_CLASS = RowCollection::class;
39
40			final public function __construct(Database $db, string $name)
41			{
42			$this->db = $db;
43			$this->name = $name;
44
45			$this->fieldFactories = $db->getFieldFactories();
46			$fields = $db->getScheme()->getTableFields($name);
47
48			foreach ($fields as $info) {
49			$field = $this->createField($info);
50
51			$this->fields[$field->getName()] = $field;
52			$this->defaults[$field->getName()] = null;
53			}
54
55			$this->init();
56			}
57
58			protected function init(): void
59			{
60			}
61
62			public function __debugInfo(): array
63			{
64			return [
65			'name' => $this->name,
66			'fields' => $this->fields,
67			];
68			}
69
70			public function __toString()
71			{
72			return "`{$this->name}`";
73			}
74
75			public function setEventDispatcher(EventDispatcherInterface $eventDispatcher): self
76			{
77			$this->eventDispatcher = $eventDispatcher;
78
79			return $this;
80			}
81
82			public function getEventDispatcher(): EventDispatcherInterface
83			{
84			if ($this->eventDispatcher === null) {
85			$this->eventDispatcher = new Dispatcher();
86			}
87
88			return $this->eventDispatcher;
89			}
90
91			/**
92			* Get the devault values used in new rows
93			*/
94			public function getDefaults(array $overrides = null): array
95			{
96			if (empty($overrides)) {
97			return $this->defaults;
98			}
99
100			$diff = array_diff_key($overrides, $this->fields);
101
102			if (!empty($diff)) {
103			throw new SimpleCrudException(
104			sprintf('The field %s does not exist in the table %s', implode(array_keys($diff)), $this)
105			);
106			}
107
108			return $overrides + $this->defaults;
109			}
110
111			/**
112			* Format selected data from the database
113			*/
114			public function format(array $values): array
115			{
116			foreach ($this->fields as $name => $field) {
117			if (array_key_exists($name, $values)) {
118			$values[$name] = $field->format($values[$name]);
119			}
120			}
121
122			return $values;
123			}
124
125			/**
126			* Store a row in the cache.
127			*/
128			public function cache(Row $row): Row
129			{
130			if ($row->id) {
131			$this->cache[$row->id] = $row;
132			}
133
134			return $row;
135			}
136
137			/**
138			* Clear the current cache.
139			*/
140			public function clearCache(): self
141			{
142			$this->cache = [];
143
144			return $this;
145			}
146
147			/**
148			* Returns whether the id is cached or not
149			* @param mixed $id
150			*/
151			public function isCached($id): bool
152			{
153			return array_key_exists($id, $this->cache);
154			}
155
156			/**
157			* Returns a row from the cache.
158			* @param mixed $id
159			*/
160			public function getCached($id): ?Row
161			{
162			if (!$this->isCached($id)) {
163			return null;
164			}
165
166			$row = $this->cache[$id];
167
168			if ($row && !$row->id) {
169			return $this->cache[$id] = null;
170			}
171
172			return $row;
173			}
174
175			public function delete(): Delete
176			{
177			$query = new Delete($this);
178
179			if ($eventDispatcher = $this->getEventDispatcher()) {
180			$eventDispatcher->dispatch(new CreateDeleteQuery($query));
			0 ignored issues – show Documentation introduced 2019-04-01 22:58 UTC by Report Bug Copy Issue Report `new \SimpleCrud\Events\CreateDeleteQuery($query)` is of type `object<SimpleCrud\Events\CreateDeleteQuery>`, but the function expects a `object<Psr\EventDispatcher\object>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
181			}
182
183			return $query;
184			}
185
186			public function insert(array $data = []): Insert
187			{
188			$query = new Insert($this, $data);
189
190			if ($eventDispatcher = $this->getEventDispatcher()) {
191			$eventDispatcher->dispatch(new CreateInsertQuery($query));
			0 ignored issues – show Documentation introduced 2019-04-01 22:58 UTC by Report Bug Copy Issue Report `new \SimpleCrud\Events\CreateInsertQuery($query)` is of type `object<SimpleCrud\Events\CreateInsertQuery>`, but the function expects a `object<Psr\EventDispatcher\object>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
192			}
193
194			return $query;
195			}
196
197			public function select(): Select
198			{
199			$query = new Select($this);
200
201			if ($eventDispatcher = $this->getEventDispatcher()) {
202			$eventDispatcher->dispatch(new CreateSelectQuery($query));
			0 ignored issues – show Documentation introduced 2019-04-01 22:58 UTC by Report Bug Copy Issue Report `new \SimpleCrud\Events\CreateSelectQuery($query)` is of type `object<SimpleCrud\Events\CreateSelectQuery>`, but the function expects a `object<Psr\EventDispatcher\object>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
203			}
204
205			return $query;
206			}
207
208			public function selectAggregate(string $function, string $field = 'id'): SelectAggregate
209			{
210			$query = new SelectAggregate($this, $function, $field);
211
212			if ($eventDispatcher = $this->getEventDispatcher()) {
213			$eventDispatcher->dispatch(new CreateSelectQuery($query));
			0 ignored issues – show Documentation introduced 2019-04-01 22:58 UTC by Report Bug Copy Issue Report `new \SimpleCrud\Events\CreateSelectQuery($query)` is of type `object<SimpleCrud\Events\CreateSelectQuery>`, but the function expects a `object<Psr\EventDispatcher\object>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
214			}
215
216			return $query;
217			}
218
219			public function update(array $data = []): Update
220			{
221			$query = new Update($this, $data);
222
223			if ($eventDispatcher = $this->getEventDispatcher()) {
224			$eventDispatcher->dispatch(new CreateUpdateQuery($query));
			0 ignored issues – show Documentation introduced 2019-04-01 22:58 UTC by Report Bug Copy Issue Report `new \SimpleCrud\Events\CreateUpdateQuery($query)` is of type `object<SimpleCrud\Events\CreateUpdateQuery>`, but the function expects a `object<Psr\EventDispatcher\object>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
225			}
226
227			return $query;
228			}
229
230			/**
231			* Magic method to get the Field instance of a table field
232			*/
233			public function __get(string $name): Field
234			{
235			if (!isset($this->fields[$name])) {
236			throw new SimpleCrudException(
237			sprintf('The field `%s` does not exist in the table %s', $name, $this)
238			);
239			}
240
241			return $this->fields[$name];
242			}
243
244			/**
245			* Magic method to check if a field exists or not.
246			*/
247			public function __isset(string $name): bool
248			{
249			return isset($this->fields[$name]);
250			}
251
252			/**
253			* @see Countable
254			*/
255			public function count(): int
256			{
257			return $this->selectAggregate('COUNT')->run();
258			}
259
260			/**
261			* Check if a row with a specific id exists.
262			*
263			* @see ArrayAccess
264			* @param mixed $offset
265			*/
266			public function offsetExists($offset): bool
267			{
268			if ($this->isCached($offset)) {
269			return $this->getCached($offset) !== null;
270			}
271
272			return $this->selectAggregate('COUNT')
			0 ignored issues – show Documentation Bug introduced 2019-04-02 23:16 UTC by Report Bug Copy Issue Report The method `where` does not exist on `object<SimpleCrud\Queries\SelectAggregate>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
273			->where('id = ', $offset)
274			->limit(1)
275			->run() === 1;
276			}
277
278			/**
279			* Returns a row with a specific id.
280			*
281			* @see ArrayAccess
282			*
283			* @param mixed $offset
284			*/
285			public function offsetGet($offset): ?Row
286			{
287			if ($this->isCached($offset)) {
288			return $this->getCached($offset);
289			}
290
291			return $this->cache[$offset] = $this->select()
			0 ignored issues – show Documentation Bug introduced 2019-04-02 23:16 UTC by Report Bug Copy Issue Report The method `where` does not exist on `object<SimpleCrud\Queries\Select>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
292			->one()
293			->where('id = ', $offset)
294			->run();
295			}
296
297			/**
298			* Store a row with a specific id.
299			*
300			* @see ArrayAccess
301			* @param mixed $offset
302			* @param mixed $value
303			*/
304			public function offsetSet($offset, $value): Row
305			{
306			//Insert on missing offset
307			if ($offset === null) {
308			$value['id'] = null;
309
310			return $this->create($value)->save();
311			}
312
313			//Update if the element is cached and exists
314			$row = $this->getCached($offset);
315
316			if ($row) {
317			return $row->edit($value)->save();
318			}
319
320			//Update if the element it's not cached
321			if (!$this->isCached($row)) {
322			$this->update()
			0 ignored issues – show Documentation Bug introduced 2019-04-02 23:16 UTC by Report Bug Copy Issue Report The method `columns` does not exist on `object<SimpleCrud\Queries\Update>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
323			->columns($value)
324			->where('id = ', $offset)
325			->run();
326			}
327			}
328
329			/**
330			* Remove a row with a specific id.
331			*
332			* @see ArrayAccess
333			* @param mixed $offset
334			*/
335			public function offsetUnset($offset)
336			{
337			$this->cache[$offset] = null;
338
339			$this->delete()
			0 ignored issues – show Documentation Bug introduced 2019-04-02 23:16 UTC by Report Bug Copy Issue Report The method `where` does not exist on `object<SimpleCrud\Queries\Delete>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
340			->where('id = ', $offset)
341			->run();
342			}
343
344			/**
345			* Returns the table name.
346			*/
347			public function getName(): string
348			{
349			return $this->name;
350			}
351
352			/**
353			* Returns the foreign key name.
354			*/
355			public function getForeignKey(): string
356			{
357			return "{$this->name}_id";
358			}
359
360			/**
361			* Returns the foreign key.
362			*/
363			public function getJoinField(Table $table): ?Field
364			{
365			$field = $table->getForeignKey();
366
367			return $this->fields[$field] ?? null;
368			}
369
370			public function getJoinTable(Table $table): ?Table
371			{
372			$name1 = $this->getName();
373			$name2 = $table->getName();
374			$name = $name1 < $name2 ? "{$name1}_{$name2}" : "{$name2}_{$name1}";
375
376			$joinTable = $this->db->{$name} ?? null;
377
378			if ($joinTable && $joinTable->getJoinField($this) && $joinTable->getJoinField($table)) {
379			return $joinTable;
380			}
381
382			return null;
383			}
384
385			/**
386			* Returns the Database instance associated with this table.
387			*/
388			public function getDatabase(): Database
389			{
390			return $this->db;
391			}
392
393			/**
394			* Returns all fields.
395			*
396			* @return Field[]
397			*/
398			public function getFields()
399			{
400			return $this->fields;
401			}
402
403			public function __call(string $name, array $args): ?Row
404			{
405			$field = $this->__get($name);
406
407			return $this->select()->one()->where("{$field} = ", $args[0])->run();
			0 ignored issues – show Documentation Bug introduced 2019-11-28 13:27 UTC by Report Bug Copy Issue Report The method `where` does not exist on `object<SimpleCrud\Queries\Select>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
408			}
409
410			/**
411			* Search a row with some values or create one if it does not exist
412			*/
413			public function getOrCreate(array $data): Row
414			{
415			$query = $this->select()->one();
416
417			foreach ($data as $name => $value) {
418			$field = $this->__get($name);
419
420			$query->where("{$field} = ", $value);
			0 ignored issues – show Documentation Bug introduced 2019-11-28 13:27 UTC by Report Bug Copy Issue Report The method `where` does not exist on `object<SimpleCrud\Queries\Select>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
421			}
422
423			$row = $query->run();
424
425			if ($row) {
426			return $row;
427			}
428
429			return $this->create($data);
430			}
431
432			public function create(array $data = []): Row
433			{
434			if (isset($data['id']) && ($row = $this->getCached($data['id']))) {
435			return $row;
436			}
437
438			$eventDispatcher = $this->getEventDispatcher();
439
440			if ($eventDispatcher) {
441			$event = new BeforeCreateRow($data);
442			$eventDispatcher->dispatch($event);
			0 ignored issues – show Documentation introduced 2019-03-30 00:32 UTC by Report Bug Copy Issue Report `$event` is of type `object<SimpleCrud\Events\BeforeCreateRow>`, but the function expects a `object<Psr\EventDispatcher\object>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
443			$data = $event->getData();
444			}
445
446			$class = static::ROW_CLASS;
447			return $this->cache(new $class($this, $data));
448			}
449
450			public function createCollection(array $rows = []): RowCollection
451			{
452			$class = static::ROWCOLLECTION_CLASS;
453			return new $class($this, ...$rows);
454			}
455
456			public function createField(array $info): Field
457			{
458			foreach ($this->fieldFactories as $fieldFactory) {
459			if ($field = $fieldFactory->create($this, $info)) {
460			return $field;
461			}
462			}
463
464			return new Field($this, $info);
465			}
466			}
467

oscarotero / simple-crud

Push — master ( c3b1de...399698 )

Table::getOrCreate() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like