Record - Code Metrics - Inspection of "Ensured targets of belongs-to associations are sav..." - darya/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2c1d81...7608f4 )

by Chris

created 2015-12-10 16:32 UTC

Record C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	589
Duplicated Lines	1.7 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	15
Bugs	4	Features	4

Metric	Value
wmc	79
c	15
b	4
f	4
lcom	1
cbo	5
dl	10
loc	589
rs	5.442

31 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	3
A	get()	0	7	2
A	set()	0	7	3
A	storage()	0	5	3
A	getSharedStorage()	0	3	1
A	setSharedStorage()	0	3	1
A	prepareFilter()	0	12	3
A	prepareListing()	0	14	3
A	load()	0	7	1
A	find()	0	5	2
A	findOrNew()	0	5	2
A	all()	0	3	1
A	eager()	0	12	3
A	search()	0	14	3
A	listing()	0	8	1
A	distinct()	0	10	2
A	query()	0	17	2
A	generate()	10	10	2
A	has()	0	3	2
A	table()	0	9	2
D	prepareData()	0	32	9
C	save()	0	38	7
A	saveMany()	0	11	3
A	delete()	0	11	3
A	hasRelation()	0	5	1
A	relation()	0	19	3
A	hasRelated()	0	5	2
A	related()	0	11	2
B	setRelated()	0	13	5
A	defaultSearchAttributes()	0	3	1
A	__call()	0	3	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Record often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Record, and based on these observations, apply Extract Interface, too.

<?php
namespace Darya\ORM;

use Exception;
use Darya\ORM\Model;
use Darya\ORM\Relation;
use Darya\Storage\Query;
use Darya\Storage\Readable;
use Darya\Storage\Queryable;
use Darya\Storage\Modifiable;
use Darya\Storage\Searchable;
use Darya\Storage\Aggregational;
use Darya\Storage\Query\Builder;

/**
 * Darya's active record implementation.
 * 
 * @author Chris Andrew <[email protected]>
 */
class Record extends Model {
	
	/**
	 * Overrides the name of the database table that persists the model. The
	 * model's lowercased class name is used if this is not set.
	 * 
	 * @var string Database table name
	 */
	protected $table;
	
	/**
	 * @var \Darya\Storage\Readable Instance storage
	 */
	protected $storage;
	
	/**
	 * @var \Darya\Storage\Readable Shared storage
	 */
	protected static $sharedStorage;
	
	/**
	 * @var array Definitions of related models
	 */
	protected $relations = array();
	
	/**
	 * @var array Default searchable attributes
	 */
	protected $search = array();
	
	/**
	 * Instantiate a new record with the given data or load an instance from
	 * storage if the given data is a valid primary key.
	 * 
	 * @param mixed $data An array of key-value attributes to set or a primary key to load by
	 */
	public function __construct($data = null) {
		if (is_numeric($data) || is_string($data)) {
			$this->data = static::load($data);
		}
		
		parent::__construct($data);
	}
	
	/**
	 * Generate instances of the model with the given sets of attributes.
	 * 
	 * @param array $rows
	 * @return Record[]
	 */
	public static function generate(array $rows = array()) {

		$instances = array();
		
		foreach ($rows as $key => $attributes) {
			$instances[$key] = new static;
			$instances[$key]->setMany($attributes);
		}
		
		return $instances;
	}
	
	/**
	 * Determine whether the given attribute or relation is set on the record.
	 * 
	 * @param string $attribute
	 */
	public function has($attribute) {
		return $this->hasRelated($attribute) || parent::has($attribute);
	}
	
	/**
	 * Retrieve the given attribute or relation from the record.
	 * 
	 * @param string $attribute
	 * @return mixed
	 */
	public function get($attribute) {
		if ($this->hasRelation($attribute)) {
			return $this->related($attribute);
		}
		
		return parent::get($attribute);
	}
	
	/**
	 * Set the value of an attribute or relation on the model.
	 * 
	 * @param string $attribute
	 * @param mixed  $value
	 */
	public function set($attribute, $value = null) {
		if (is_string($attribute) && $this->hasRelation($attribute)) {
			return $this->setRelated($attribute, $value);
		}
		
		parent::set($attribute, $value);
	}
	
	/**
	 * Retrieve the name of the table this model belongs to.
	 * 
	 * If none is set, it defaults to creating it from the class name.
	 * 
	 * For example:
	 *     Page        -> pages
	 *     PageSection -> page_sections
	 * 
	 * @return string
	 */
	public function table() {
		if ($this->table) {
			return $this->table;
		}
		
		return preg_replace_callback('/([A-Z])/', function($matches) {
			return '_' . strtolower($matches[1]);
		}, lcfirst(basename(get_class($this)))) . 's';
	}
	
	/**
	 * Get and optionally set the model's storage instance.
	 * 
	 * @return \Darya\Storage\Readable
	 */
	public function storage(Readable $storage = null) {
		$this->storage = $storage ?: $this->storage;
		
		return $this->storage ?: static::getSharedStorage();
	}
	
	/**
	 * Get the storage shared to all instances of this model.
	 * 
	 * @return \Darya\Storage\Readable
	 */
	public static function getSharedStorage() {
		return static::$sharedStorage;
	}
	
	/**
	 * Share the given database connection to all instances of this model.
	 * 
	 * @param \Darya\Storage\Readable $storage
	 */
	public static function setSharedStorage(Readable $storage) {
		static::$sharedStorage = $storage;
	}
	
	/**
	 * Prepare the record's data for storage. This is here until repositories
	 * are implemented.
	 * 
	 * @return array
	 */
	protected function prepareData() {
		$types = $this->attributes;
		
		$changed = array_intersect_key($this->data, array_flip($this->changed));
		
		$data = $this->id() && $changed ? $changed : $this->data;
		
		foreach ($data as $attribute => $value) {
			if (isset($types[$attribute])) {
				$type = $types[$attribute];
				
				switch ($type) {
					case 'int':
						$value = (int) $value;
						break;
					case 'date':
						$value = date('Y-m-d', $value);
						break;
					case 'datetime':
						$value = date('Y-m-d H:i:s', $value);
						break;
					case 'time':
						$value = date('H:i:s', $value);
						break;
				}
				
				$data[$attribute] = $value;
			}
		}
		
		return $data;
	}
	
	/**
	 * Prepare the given filter.
	 * 
	 * Creates a filter for the record's key attribute if the given value is not
	 * an array.
	 * 
	 * @param mixed $filter
	 * @return string
	 */
	protected static function prepareFilter($filter) {
		if ($filter === null) {
			return array();
		}
		
		if (!is_array($filter)) {
			$instance = new static;
			$filter = array($instance->key() => $filter);
		}
		
		return $filter;
	}
	
	/**
	 * Prepare the given list data.
	 * 
	 * @param array  $data
	 * @param string $attribute
	 * @return array
	 */
	protected static function prepareListing($data, $attribute) {
		$instance = new static;
		$key = $instance->key();
		
		$list = array();
		
		foreach ($data as $row) {
			if (isset($row[$attribute])) {
				$list[$row[$key]] = $row[$attribute];
			}
		}
		
		return $list;
	}
	
	/**
	 * Load record data from storage using the given criteria.
	 * 
	 * @param array|string|int $filter [optional]
	 * @param array|string     $order  [optional]
	 * @param int              $limit  [optional]
	 * @param int              $offset [optional]
	 * @return array
	 */
	public static function load($filter = array(), $order = array(), $limit = null, $offset = 0) {
		$instance = new static;
		$storage = $instance->storage();
		$filter = static::prepareFilter($filter);
		
		return $storage->read($instance->table(), $filter, $order, $limit, $offset);
	}
	
	/**
	 * Load a record instance from storage using the given criteria.
	 * 
	 * Returns false if the record cannot be found.
	 * 
	 * @param array|string|int $filter [optional]
	 * @param array|string     $order  [optional]
	 * @return Record|bool
	 */
	public static function find($filter = array(), $order = array()) {
		$data = static::load($filter, $order, 1);
		
		return !empty($data[0]) ? new static($data[0]) : false;
	}
	
	/**
	 * Load a record instance from storage using the given criteria or create a
	 * new instance if nothing is found.
	 * 
	 * @param array|string|int $filter [optional]
	 * @param array|string     $order  [optional]
	 * @return Record
	 */
	public static function findOrNew($filter = array(), $order = array()) {
		$instance = static::find($filter, $order);
		
		return $instance === false ? new static : $instance;
	}

	/**
	 * Load multiple record instances from storage using the given criteria.
	 * 
	 * @param array|string|int $filter [optional]
	 * @param array|string     $order  [optional]
	 * @param int              $limit  [optional]
	 * @param int              $offset [optional]
	 * @return array
	 */
	public static function all($filter = array(), $order = array(), $limit = null, $offset = 0) {
		return static::generate(static::load($filter, $order, $limit, $offset));
	}
	
	/**
	 * Eagerly load the given relations of multiple record instances.
	 * 
	 * @param array|string $relations
	 * @return array
	 */
	public static function eager($relations) {
		$instance = new static;
		$instances = static::all();
		
		foreach ((array) $relations as $relation) {
			if ($instance->relation($relation)) {
				$instances = $instance->relation($relation)->eager($instances, $relation);
			}
		}
		
		return $instances;
	}
	
	/**
	 * Search for record instances in storage using the given criteria.
	 * 
	 * @param string           $query
	 * @param array            $attributes [optional]
	 * @param array|string|int $filter     [optional]
	 * @param array|string     $order      [optional]
	 * @param int              $limit      [optional]
	 * @param int              $offset     [optional]
	 * @return array
	 */
	public static function search($query, $attributes = array(), $filter = array(), $order = array(), $limit = null, $offset = 0) {
		$instance = new static;
		$storage = $instance->storage();
		
		if (!$storage instanceof Searchable) {
			throw new Exception(get_class($instance) . ' storage is not searchable');
		}
		
		$attributes = $attributes ?: $instance->defaultSearchAttributes();
		
		$data = $storage->search($instance->table(), $query, $attributes, $filter, $order, $limit, $offset);
		
		return static::generate($data);
	}
	
	/**
	 * Retrieve key => value pairs using `id` for keys and the given attribute
	 * for values.
	 * 
	 * @param string $attribute
	 * @param array  $filter    [optional]
	 * @param array  $order     [optional]
	 * @param int    $limit     [optional]
	 * @param int    $offset    [optional]
	 * @return array
	 */
	public static function listing($attribute, $filter = array(), $order = array(), $limit = null, $offset = 0) {
		$instance = new static;
		$storage = $instance->storage();
		
		$data = $storage->listing($instance->table(), array($instance->key(), $attribute), $filter, $order, $limit, $offset);
		
		return static::prepareListing($data, $attribute);
	}
	
	/**
	 * Retrieve the distinct values of the given attribute.
	 * 
	 * @param string $attribute
	 * @param array  $filter    [optional]
	 * @param array  $order     [optional]
	 * @param int    $limit     [optional]
	 * @param int    $offset    [optional]
	 * @return array
	 */
	public static function distinct($attribute, $filter = array(), $order = array(), $limit = null, $offset = 0) {
		$instance = new static;
		$storage = $instance->storage();
		
		if (!$storage instanceof Aggregational) {
			return array_values(array_unique(static::listing($attribute, $filter, $order)));
		}
		
		return $storage->distinct($instance->table(), $attribute, $filter, $order, $limit, $offset);
	}
	
	/**
	 * Create a query builder for the model.
	 * 
	 * @return Builder
	 */
	public static function query() {
		$instance = new static;
		$storage = $instance->storage();
		
		if (!$storage instanceof Queryable) {
			throw new Exception(get_class($instance) . ' storage is not queryable');
		}
		
		$query = new Query($instance->table());
		$builder = new Builder($query, $instance->storage());
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		
		$builder->callback(function($result) use ($instance) {
			return $instance::generate($result->data);
		});
		
		return $builder;
	}
	
	/**
	 * Save the record to storage.
	 * 
	 * @return bool
	 */
	public function save() {
		if ($this->validate()) {
			$storage = $this->storage();
			$class = get_class($this);
			
			if (!$storage instanceof Modifiable) {
				throw new Exception(basename($class) . ' storage is not modifiable');
			}
			
			$data = $this->prepareData();
			
			if (!$this->id()) {
				$id = $storage->create($this->table(), $data);
				
				if ($id) {
					$this->set($this->key(), $id);
					
					return true;
				}
			} else {
				$updated = $storage->update($this->table(), $data, array($this->key() => $this->id()), 1);
				
				if (!$updated) {
					$updated = $storage->create($this->table(), $data) > 0;
				}
				
				if ($updated) {
					return true;
				}
			}
			
			$entity = strtolower(basename($class));
			$this->errors['save'] = "Failed to save $entity";
			$this->errors['storage'] = $this->storage()->error();
		}
		
		return false;
	}
	
	/**
	 * Save multiple record instances to storage.
	 * 
	 * Returns the number of instances that saved successfully.
	 * 
	 * @param array $instances
	 * @return int
	 */
	public static function saveMany($instances) {
		$failed = 0;
		
		foreach ($instances as $instance) {
			if (!$instance->save()) {
				$failed++;
			}
		}
		
		return count($instances) - $failed;
	}
	
	/**
	 * Delete the record from storage.
	 * 
	 * @return bool
	 */
	public function delete() {
		if ($this->id()) {
			$storage = $this->storage();
			
			if ($storage instanceof Modifiable) {
				return (bool) $storage->delete($this->table(), array($this->key() => $this->id()), 1);
			}
		}
		
		return false;
	}
	
	/**
	 * Determine whether the given attribute is a relation.
	 * 
	 * @param string $attribute
	 * @return bool
	 */
	protected function hasRelation($attribute) {
		$attribute = $this->prepareAttribute($attribute);
		
		return isset($this->relations[$attribute]);
	}
	
	/**
	 * Retrieve the given relation.
	 * 
	 * @param string $attribute
	 * @return \Darya\ORM\Relation
	 */
	public function relation($attribute) {
		if (!$this->hasRelation($attribute)) {
			return null;
		}
		
		$attribute = $this->prepareAttribute($attribute);
		$relation = $this->relations[$attribute];
		
		if (!$relation instanceof Relation) {
			$type = array_shift($relation);
			$arguments = array_merge(array($this), $relation);
			
			$relation = Relation::factory($type, $arguments);
			
			$this->relations[$attribute] = $relation;
		}
		
		return $relation;
	}
	
	/**
	 * Determine whether the given relation has any set model(s).
	 * 
	 * @param string $attribute
	 * @return bool
	 */
	protected function hasRelated($attribute) {
		$attribute = $this->prepareAttribute($attribute);
		
		return $this->hasRelation($attribute) && $this->relation($attribute)->count();
	}
	
	/**
	 * Retrieve the model(s) of the given relation.
	 * 
	 * @param string $attribute
	 * @return array
	 */
	public function related($attribute) {
		if (!$this->hasRelation($attribute)) {
			return null;
		}
		
		$attribute = $this->prepareAttribute($attribute);
		
		$relation = $this->relation($attribute);
		
		return $relation->retrieve();
	}
	
	/**
	 * Set the given related model(s).
	 * 
	 * @param string $attribute
	 * @param mixed  $value
	 */
	protected function setRelated($attribute, $value) {
		if (!$this->hasRelation($attribute)) {
			return;
		}
		
		$relation = $this->relation($attribute);
		
		if ($value !== null && !$value instanceof $relation->target && !is_array($value)) {
			return;
		}
		
		$relation->associate($value);
	}

	/**
	 * Retrieve the default search attributes for the model.
	 * 
	 * @return array
	 */
	public function defaultSearchAttributes() {
		return $this->search;
	}
	
	/**
	 * Retrieve a relation. Shortcut for `relation()`.
	 * 
	 * @param string $method
	 * @param array  $arguments
	 * @return Relation
	 */
	public function __call($method, $arguments) {
		return $this->relation($method);
	}
	
}


1		<?php
2		namespace Darya\ORM;
3
4		use Exception;
5		use Darya\ORM\Model;
6		use Darya\ORM\Relation;
7		use Darya\Storage\Query;
8		use Darya\Storage\Readable;
9		use Darya\Storage\Queryable;
10		use Darya\Storage\Modifiable;
11		use Darya\Storage\Searchable;
12		use Darya\Storage\Aggregational;
13		use Darya\Storage\Query\Builder;
14
15		/**
16		* Darya's active record implementation.
17		*
18		* @author Chris Andrew <[email protected]>
19		*/
20		class Record extends Model {
21
22		/**
23		* Overrides the name of the database table that persists the model. The
24		* model's lowercased class name is used if this is not set.
25		*
26		* @var string Database table name
27		*/
28		protected $table;
29
30		/**
31		* @var \Darya\Storage\Readable Instance storage
32		*/
33		protected $storage;
34
35		/**
36		* @var \Darya\Storage\Readable Shared storage
37		*/
38		protected static $sharedStorage;
39
40		/**
41		* @var array Definitions of related models
42		*/
43		protected $relations = array();
44
45		/**
46		* @var array Default searchable attributes
47		*/
48		protected $search = array();
49
50		/**
51		* Instantiate a new record with the given data or load an instance from
52		* storage if the given data is a valid primary key.
53		*
54		* @param mixed $data An array of key-value attributes to set or a primary key to load by
55		*/
56		public function __construct($data = null) {
57		if (is_numeric($data) \|\| is_string($data)) {
58		$this->data = static::load($data);
59		}
60
61		parent::__construct($data);
62		}
63
64		/**
65		* Generate instances of the model with the given sets of attributes.
66		*
67		* @param array $rows
68		* @return Record[]
69		*/
70	View Code Duplication	public static function generate(array $rows = array()) {
		0 ignored issues – show Duplication introduced 2015-11-24 14:38 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
71		$instances = array();
72
73		foreach ($rows as $key => $attributes) {
74		$instances[$key] = new static;
75		$instances[$key]->setMany($attributes);
76		}
77
78		return $instances;
79		}
80
81		/**
82		* Determine whether the given attribute or relation is set on the record.
83		*
84		* @param string $attribute
85		*/
86		public function has($attribute) {
87		return $this->hasRelated($attribute) \|\| parent::has($attribute);
88		}
89
90		/**
91		* Retrieve the given attribute or relation from the record.
92		*
93		* @param string $attribute
94		* @return mixed
95		*/
96		public function get($attribute) {
97		if ($this->hasRelation($attribute)) {
98		return $this->related($attribute);
99		}
100
101		return parent::get($attribute);
102		}
103
104		/**
105		* Set the value of an attribute or relation on the model.
106		*
107		* @param string $attribute
108		* @param mixed $value
109		*/
110		public function set($attribute, $value = null) {
111		if (is_string($attribute) && $this->hasRelation($attribute)) {
112		return $this->setRelated($attribute, $value);
113		}
114
115		parent::set($attribute, $value);
116		}
117
118		/**
119		* Retrieve the name of the table this model belongs to.
120		*
121		* If none is set, it defaults to creating it from the class name.
122		*
123		* For example:
124		* Page -> pages
125		* PageSection -> page_sections
126		*
127		* @return string
128		*/
129		public function table() {
130		if ($this->table) {
131		return $this->table;
132		}
133
134		return preg_replace_callback('/([A-Z])/', function($matches) {
135		return '_' . strtolower($matches[1]);
136		}, lcfirst(basename(get_class($this)))) . 's';
137		}
138
139		/**
140		* Get and optionally set the model's storage instance.
141		*
142		* @return \Darya\Storage\Readable
143		*/
144		public function storage(Readable $storage = null) {
145		$this->storage = $storage ?: $this->storage;
146
147		return $this->storage ?: static::getSharedStorage();
148		}
149
150		/**
151		* Get the storage shared to all instances of this model.
152		*
153		* @return \Darya\Storage\Readable
154		*/
155		public static function getSharedStorage() {
156		return static::$sharedStorage;
157		}
158
159		/**
160		* Share the given database connection to all instances of this model.
161		*
162		* @param \Darya\Storage\Readable $storage
163		*/
164		public static function setSharedStorage(Readable $storage) {
165		static::$sharedStorage = $storage;
166		}
167
168		/**
169		* Prepare the record's data for storage. This is here until repositories
170		* are implemented.
171		*
172		* @return array
173		*/
174		protected function prepareData() {
175		$types = $this->attributes;
176
177		$changed = array_intersect_key($this->data, array_flip($this->changed));
178
179		$data = $this->id() && $changed ? $changed : $this->data;
180
181		foreach ($data as $attribute => $value) {
182		if (isset($types[$attribute])) {
183		$type = $types[$attribute];
184
185		switch ($type) {
186		case 'int':
187		$value = (int) $value;
188		break;
189		case 'date':
190		$value = date('Y-m-d', $value);
191		break;
192		case 'datetime':
193		$value = date('Y-m-d H:i:s', $value);
194		break;
195		case 'time':
196		$value = date('H:i:s', $value);
197		break;
198		}
199
200		$data[$attribute] = $value;
201		}
202		}
203
204		return $data;
205		}
206
207		/**
208		* Prepare the given filter.
209		*
210		* Creates a filter for the record's key attribute if the given value is not
211		* an array.
212		*
213		* @param mixed $filter
214		* @return string
215		*/
216		protected static function prepareFilter($filter) {
217		if ($filter === null) {
218		return array();
219		}
220
221		if (!is_array($filter)) {
222		$instance = new static;
223		$filter = array($instance->key() => $filter);
224		}
225
226		return $filter;
227		}
228
229		/**
230		* Prepare the given list data.
231		*
232		* @param array $data
233		* @param string $attribute
234		* @return array
235		*/
236		protected static function prepareListing($data, $attribute) {
237		$instance = new static;
238		$key = $instance->key();
239
240		$list = array();
241
242		foreach ($data as $row) {
243		if (isset($row[$attribute])) {
244		$list[$row[$key]] = $row[$attribute];
245		}
246		}
247
248		return $list;
249		}
250
251		/**
252		* Load record data from storage using the given criteria.
253		*
254		* @param array\|string\|int $filter [optional]
255		* @param array\|string $order [optional]
256		* @param int $limit [optional]
257		* @param int $offset [optional]
258		* @return array
259		*/
260		public static function load($filter = array(), $order = array(), $limit = null, $offset = 0) {
261		$instance = new static;
262		$storage = $instance->storage();
263		$filter = static::prepareFilter($filter);
264
265		return $storage->read($instance->table(), $filter, $order, $limit, $offset);
266		}
267
268		/**
269		* Load a record instance from storage using the given criteria.
270		*
271		* Returns false if the record cannot be found.
272		*
273		* @param array\|string\|int $filter [optional]
274		* @param array\|string $order [optional]
275		* @return Record\|bool
276		*/
277		public static function find($filter = array(), $order = array()) {
278		$data = static::load($filter, $order, 1);
279
280		return !empty($data[0]) ? new static($data[0]) : false;
281		}
282
283		/**
284		* Load a record instance from storage using the given criteria or create a
285		* new instance if nothing is found.
286		*
287		* @param array\|string\|int $filter [optional]
288		* @param array\|string $order [optional]
289		* @return Record
290		*/
291		public static function findOrNew($filter = array(), $order = array()) {
292		$instance = static::find($filter, $order);
293
294		return $instance === false ? new static : $instance;
295		}
296
297		/**
298		* Load multiple record instances from storage using the given criteria.
299		*
300		* @param array\|string\|int $filter [optional]
301		* @param array\|string $order [optional]
302		* @param int $limit [optional]
303		* @param int $offset [optional]
304		* @return array
305		*/
306		public static function all($filter = array(), $order = array(), $limit = null, $offset = 0) {
307		return static::generate(static::load($filter, $order, $limit, $offset));
308		}
309
310		/**
311		* Eagerly load the given relations of multiple record instances.
312		*
313		* @param array\|string $relations
314		* @return array
315		*/
316		public static function eager($relations) {
317		$instance = new static;
318		$instances = static::all();
319
320		foreach ((array) $relations as $relation) {
321		if ($instance->relation($relation)) {
322		$instances = $instance->relation($relation)->eager($instances, $relation);
323		}
324		}
325
326		return $instances;
327		}
328
329		/**
330		* Search for record instances in storage using the given criteria.
331		*
332		* @param string $query
333		* @param array $attributes [optional]
334		* @param array\|string\|int $filter [optional]
335		* @param array\|string $order [optional]
336		* @param int $limit [optional]
337		* @param int $offset [optional]
338		* @return array
339		*/
340		public static function search($query, $attributes = array(), $filter = array(), $order = array(), $limit = null, $offset = 0) {
341		$instance = new static;
342		$storage = $instance->storage();
343
344		if (!$storage instanceof Searchable) {
345		throw new Exception(get_class($instance) . ' storage is not searchable');
346		}
347
348		$attributes = $attributes ?: $instance->defaultSearchAttributes();
349
350		$data = $storage->search($instance->table(), $query, $attributes, $filter, $order, $limit, $offset);
351
352		return static::generate($data);
353		}
354
355		/**
356		* Retrieve key => value pairs using `id` for keys and the given attribute
357		* for values.
358		*
359		* @param string $attribute
360		* @param array $filter [optional]
361		* @param array $order [optional]
362		* @param int $limit [optional]
363		* @param int $offset [optional]
364		* @return array
365		*/
366		public static function listing($attribute, $filter = array(), $order = array(), $limit = null, $offset = 0) {
367		$instance = new static;
368		$storage = $instance->storage();
369
370		$data = $storage->listing($instance->table(), array($instance->key(), $attribute), $filter, $order, $limit, $offset);
371
372		return static::prepareListing($data, $attribute);
373		}
374
375		/**
376		* Retrieve the distinct values of the given attribute.
377		*
378		* @param string $attribute
379		* @param array $filter [optional]
380		* @param array $order [optional]
381		* @param int $limit [optional]
382		* @param int $offset [optional]
383		* @return array
384		*/
385		public static function distinct($attribute, $filter = array(), $order = array(), $limit = null, $offset = 0) {
386		$instance = new static;
387		$storage = $instance->storage();
388
389		if (!$storage instanceof Aggregational) {
390		return array_values(array_unique(static::listing($attribute, $filter, $order)));
391		}
392
393		return $storage->distinct($instance->table(), $attribute, $filter, $order, $limit, $offset);
394		}
395
396		/**
397		* Create a query builder for the model.
398		*
399		* @return Builder
400		*/
401		public static function query() {
402		$instance = new static;
403		$storage = $instance->storage();
404
405		if (!$storage instanceof Queryable) {
406		throw new Exception(get_class($instance) . ' storage is not queryable');
407		}
408
409		$query = new Query($instance->table());
410		$builder = new Builder($query, $instance->storage());
		0 ignored issues – show Documentation introduced 2015-11-24 14:38 UTC by Report Bug Copy Issue Report `$instance->storage()` is of type `object<Darya\Storage\Readable>`, but the function expects a `object<Darya\Storage\Queryable>`. 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...
411
412		$builder->callback(function($result) use ($instance) {
413		return $instance::generate($result->data);
414		});
415
416		return $builder;
417		}
418
419		/**
420		* Save the record to storage.
421		*
422		* @return bool
423		*/
424		public function save() {
425		if ($this->validate()) {
426		$storage = $this->storage();
427		$class = get_class($this);
428
429		if (!$storage instanceof Modifiable) {
430		throw new Exception(basename($class) . ' storage is not modifiable');
431		}
432
433		$data = $this->prepareData();
434
435		if (!$this->id()) {
436		$id = $storage->create($this->table(), $data);
437
438		if ($id) {
439		$this->set($this->key(), $id);
440
441		return true;
442		}
443		} else {
444		$updated = $storage->update($this->table(), $data, array($this->key() => $this->id()), 1);
445
446		if (!$updated) {
447		$updated = $storage->create($this->table(), $data) > 0;
448		}
449
450		if ($updated) {
451		return true;
452		}
453		}
454
455		$entity = strtolower(basename($class));
456		$this->errors['save'] = "Failed to save $entity";
457		$this->errors['storage'] = $this->storage()->error();
458		}
459
460		return false;
461		}
462
463		/**
464		* Save multiple record instances to storage.
465		*
466		* Returns the number of instances that saved successfully.
467		*
468		* @param array $instances
469		* @return int
470		*/
471		public static function saveMany($instances) {
472		$failed = 0;
473
474		foreach ($instances as $instance) {
475		if (!$instance->save()) {
476		$failed++;
477		}
478		}
479
480		return count($instances) - $failed;
481		}
482
483		/**
484		* Delete the record from storage.
485		*
486		* @return bool
487		*/
488		public function delete() {
489		if ($this->id()) {
490		$storage = $this->storage();
491
492		if ($storage instanceof Modifiable) {
493		return (bool) $storage->delete($this->table(), array($this->key() => $this->id()), 1);
494		}
495		}
496
497		return false;
498		}
499
500		/**
501		* Determine whether the given attribute is a relation.
502		*
503		* @param string $attribute
504		* @return bool
505		*/
506		protected function hasRelation($attribute) {
507		$attribute = $this->prepareAttribute($attribute);
508
509		return isset($this->relations[$attribute]);
510		}
511
512		/**
513		* Retrieve the given relation.
514		*
515		* @param string $attribute
516		* @return \Darya\ORM\Relation
517		*/
518		public function relation($attribute) {
519		if (!$this->hasRelation($attribute)) {
520		return null;
521		}
522
523		$attribute = $this->prepareAttribute($attribute);
524		$relation = $this->relations[$attribute];
525
526		if (!$relation instanceof Relation) {
527		$type = array_shift($relation);
528		$arguments = array_merge(array($this), $relation);
529
530		$relation = Relation::factory($type, $arguments);
531
532		$this->relations[$attribute] = $relation;
533		}
534
535		return $relation;
536		}
537
538		/**
539		* Determine whether the given relation has any set model(s).
540		*
541		* @param string $attribute
542		* @return bool
543		*/
544		protected function hasRelated($attribute) {
545		$attribute = $this->prepareAttribute($attribute);
546
547		return $this->hasRelation($attribute) && $this->relation($attribute)->count();
548		}
549
550		/**
551		* Retrieve the model(s) of the given relation.
552		*
553		* @param string $attribute
554		* @return array
555		*/
556		public function related($attribute) {
557		if (!$this->hasRelation($attribute)) {
558		return null;
559		}
560
561		$attribute = $this->prepareAttribute($attribute);
562
563		$relation = $this->relation($attribute);
564
565		return $relation->retrieve();
566		}
567
568		/**
569		* Set the given related model(s).
570		*
571		* @param string $attribute
572		* @param mixed $value
573		*/
574		protected function setRelated($attribute, $value) {
575		if (!$this->hasRelation($attribute)) {
576		return;
577		}
578
579		$relation = $this->relation($attribute);
580
581		if ($value !== null && !$value instanceof $relation->target && !is_array($value)) {
582		return;
583		}
584
585		$relation->associate($value);
586		}
587
588		/**
589		* Retrieve the default search attributes for the model.
590		*
591		* @return array
592		*/
593		public function defaultSearchAttributes() {
594		return $this->search;
595		}
596
597		/**
598		* Retrieve a relation. Shortcut for `relation()`.
599		*
600		* @param string $method
601		* @param array $arguments
602		* @return Relation
603		*/
604		public function __call($method, $arguments) {
605		return $this->relation($method);
606		}
607
608		}
609

darya / framework