Kohana_Jam_Association_Hasone - Code Metrics - Inspection of "Prevent side effects from count_with_subquery" - OpenBuildings/jam - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — count-subquery-clone ( d5815f...6cc328 )

by Haralan

created 2016-06-14 10:22 UTC

Kohana_Jam_Association_Hasone B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	326
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

88.69%

Importance

Changes	6
Bugs	4	Features	0

Metric	Value
wmc	54
c	6
b	4
f	0
lcom	1
cbo	10
dl	0
loc	326
ccs	149
cts	168
cp	0.8869
rs	7.0642

13 Methods

Rating	Name	Size	Complexity
C	get()	34	8
B	set()	27	6
A	build()	8	1
C	model_after_save()	39	8
B	_find_item()	22	4
B	initialize()	24	5
A	load_fields()	14	4
A	join()	13	3
B	model_after_check()	10	5
B	model_before_delete()	20	5
A	is_polymorphic()	4	1
A	query_builder()	12	2
A	update_query()	12	2

How to fix Complexity

<?php defined('SYSPATH') OR die('No direct script access.');
/**
 * Handles has one to relationships
 *
 * @package    Jam
 * @category   Associations
 * @author     Ivan Kerin
 * @copyright  (c) 2012 Despark Ltd.
 * @license    http://www.opensource.org/licenses/isc-license.txt
 */
abstract class Kohana_Jam_Association_Hasone extends Jam_Association {

	/**
	 * Set this for polymorphic association, this has to be the name of the opposite belongsto relation,
	 * so if the oposite relation was item->parent, then this will have to be 'ites' => Jam::association('hasone, array('as' => 'parent')
	 * If this option is set then the foreign_key default becomes "{$as}_id", and polymorphic_key to "{$as}_model"
	 * @var string
	 */
	public $as = NULL;

	/**
	 * The foreign key
	 * @var string
	 */
	public $foreign_key = NULL;

	public $inverse_of = NULL;

	public $polymorphic_key = NULL;

	/**
	 * Automatically sets foreign to sensible defaults.
	 *
	 * @param   string  $model
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
	 * @param   string  $name
	 * @return  void
	 */
	public function initialize(Jam_Meta $meta, $name)
	{
		parent::initialize($meta, $name);

		if ( ! $this->foreign_model)
		{
			$this->foreign_model = $name;
		}

		if ( ! $this->foreign_key)
		{
			$this->foreign_key = $this->model.'_id';
		}

		// Polymorphic associations
		if ($this->as)
		{
			$this->foreign_key = $this->as.'_id';
			if ( ! $this->polymorphic_key)
			{
				$this->polymorphic_key = $this->as.'_model';
			}
		}
	}

	/**
	 * Load associated model (from database or after deserialization)
	 * @param  Jam_Validated $model
	 * @param  mixed         $value
	 * @return Jam_Model
	 */
	public function load_fields(Jam_Validated $model, $value)
	{
		if (is_array($value))
		{
			$value = Jam::build($this->foreign_model)->load_fields($value);
		}

		if ($value instanceof Jam_Model AND $this->inverse_of)
		{
			$value->retrieved($this->inverse_of, $model);
		}

		return $value;
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());
}
	}

	/**
	 * Return a Jam_Query_Builder_Join object to allow a query to join with this association
	 *
	 * @param  string $alias table name alias
	 * @param  string $type  join type (LEFT, NATURAL)
	 * @return Jam_Query_Builder_Join
	 */
	public function join($alias, $type = NULL)
	{
		$join = Jam_Query_Builder_Join::factory($alias ? array($this->foreign_model, $alias) : $this->foreign_model, $type)
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
			->context_model($this->model)
			->on($this->foreign_key, '=', ':primary_key');

		if ($this->is_polymorphic())
		{
			$join->on($this->polymorphic_key, '=', DB::expr(':model', array(':model' => $this->model)));
		}

		return $join;
	}

	/**
	 * Get the belonging model for this association using the foreign key,
	 * if the data was changed, use the key from the changed data.
	 * Assign inverse_of
	 *
	 * @param  Jam_Validated $model
	 * @param  mixed         $value      changed data
	 * @param  boolean       $is_changed
	 * @return Jam_Model
	 */
	public function get(Jam_Validated $model, $value, $is_changed)
	{
		if ($is_changed)
		{
			if ($value instanceof Jam_Validated OR ! $value)
				return $value;

			$key = Jam_Association::primary_key($this->foreign_model, $value);

			if ($key)
			{
				$item = $this->_find_item($this->foreign_model, $key);
			}
			elseif (is_array($value))
			{
				$item = Jam::build($this->foreign_model, $value);
			}
			else
			{
				$item = NULL;
			}

			if ($item AND is_array($value))
			{
				$item->set($value);
			}
		}
		else
		{
			$item = $this->_find_item($this->foreign_model, $model);
		}

		return $this->set($model, $item, $is_changed);
	}

	public function set(Jam_Validated $model, $value, $is_changed)
	{
		if ($value instanceof Jam_Model)
		{
			if ($this->is_polymorphic())
			{
				$value->{$this->polymorphic_key} = $model->meta()->model();
			}

			if ($model->loaded())
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 { }
			{
				$value->{$this->foreign_key} = $model->id();
			}

			if ($this->as)
			{
				$value->retrieved($this->as, $model);
			}

			if ($this->inverse_of)
			{
				$value->retrieved($this->inverse_of, $model);
			}
		}

		return $value;
	}

	public function build(Jam_Validated $model, array $attributes = NULL)
	{
		$item = Jam::build($this->foreign_model, $attributes);

		$this->set($model, $item, TRUE);

		return $item;
	}

	/**
	 * Perform validation on the belonging model, if it was changed.
	 * @param  Jam_Model      $model
	 * @param  Jam_Event_Data $data
	 * @param  array         $changed
	 */
	public function model_after_check(Jam_Model $model, Jam_Event_Data $data, $changed)

	{
		if (($value = Arr::get($changed, $this->name)) AND Jam_Association::is_changed($value))
		{
			if ( ! $model->{$this->name}->is_validating() AND ! $model->{$this->name}->check())
			{
				$model->errors()->add($this->name, 'association', array(':errors' => $model->{$this->name}->errors()));

			}
		}
	}

	/**
	 * Save the related model after the main model, if it was changed
	 * Only save related model if it has been changed, and is not in a process of saving itself
	 *
	 * @param  Jam_Model      $model
	 * @param  Jam_Event_Data $data
	 * @param  boolean        $changed
	 */
	public function model_after_save(Jam_Model $model, Jam_Event_Data $data, $changed)

	{
		$nullify_query = $this->update_query($model, NULL, NULL);

		if (($value = Arr::get($changed, $this->name)))
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		{
			if (Jam_Association::is_changed($value) AND ($item = $model->{$this->name}))
			{
				if ( ! $item->is_saving())
				{
					$this->set($model, $item, TRUE)->save();
				}
				if ($item->id())
				{
					$nullify_query->where('id', '!=', $item->id())->execute();
				}
			}
			else
			{
				$key = Jam_Association::primary_key($this->foreign_model, $value);

				$query = Jam_Query_Builder_Update::factory($this->foreign_model)
					->where(':unique_key', '=', $key)
					->value($this->foreign_key, $model->id());

				if ($this->is_polymorphic())
				{
					$query
						->value($this->polymorphic_key, $model->meta()->model());
				}
				$nullify_query->execute();
				$query->execute();
			}
		}
		elseif (array_key_exists($this->name, $changed))
		{
			$nullify_query->execute();
		}
	}

	/**
	 * Delete related model if it has been assigned as dependent
	 * If dependent is Jam_Association::DELETE - execute the delete method (and all events)
	 * IF dependent is Jam_Association::ERASE - simply remove from database without executing any events (faster)
	 * @param  Jam_Model $model
	 */
	public function model_before_delete(Jam_Model $model)
	{
		switch ($this->dependent)
		{
			case Jam_Association::DELETE:
				if ($model->{$this->name})
				{
					$model->{$this->name}->delete();
				}
			break;

			case Jam_Association::ERASE:
				$this->query_builder('delete', $model)->execute();
			break;

			case Jam_Association::NULLIFY:
				$this->update_query($model, NULL, NULL)->execute();
			break;
		}
	}

	/**
	 * See if the association is polymorphic
	 * @return boolean
	 */
	public function is_polymorphic()
	{
		return (bool) $this->as;
	}

	protected function _find_item($foreign_model, $key)
	{
		if ( ! $key)
			return;

		if ($key instanceof Jam_Model)
		{
			if ( ! $key->loaded())
				return;

			$query = $this->query_builder('all', $key);
		}
		else
		{
			$query = new Jam_Query_Builder_Collection($foreign_model);
			$query
				->where(':unique_key', '=', $key)
				->limit(1);
		}

		return $query->current();
	}

	public function query_builder($type, Jam_Model $model)
	{
		$query = call_user_func("Jam::{$type}", $this->foreign_model)
			->where($this->foreign_key, '=', $model->id());

		if ($this->is_polymorphic())
		{
			$query->where($this->polymorphic_key, '=', $model->meta()->model());
		}

		return $query;
	}

	public function update_query(Jam_Model $model, $new_id, $new_model)
	{
		$query = $this->query_builder('update', $model)
			->value($this->foreign_key, $new_id);

		if ($this->is_polymorphic())
		{
			$query->value($this->polymorphic_key, $new_model);
		}

		return $query;
	}
}


1		<?php defined('SYSPATH') OR die('No direct script access.');
2		/**
3		* Handles has one to relationships
4		*
5		* @package Jam
6		* @category Associations
7		* @author Ivan Kerin
8		* @copyright (c) 2012 Despark Ltd.
9		* @license http://www.opensource.org/licenses/isc-license.txt
10		*/
11		abstract class Kohana_Jam_Association_Hasone extends Jam_Association {
12
13		/**
14		* Set this for polymorphic association, this has to be the name of the opposite belongsto relation,
15		* so if the oposite relation was item->parent, then this will have to be 'ites' => Jam::association('hasone, array('as' => 'parent')
16		* If this option is set then the foreign_key default becomes "{$as}_id", and polymorphic_key to "{$as}_model"
17		* @var string
18		*/
19		public $as = NULL;
20
21		/**
22		* The foreign key
23		* @var string
24		*/
25		public $foreign_key = NULL;
26
27		public $inverse_of = NULL;
28
29		public $polymorphic_key = NULL;
30
31		/**
32		* Automatically sets foreign to sensible defaults.
33		*
34		* @param string $model
		0 ignored issues – show Bug introduced 2015-11-24 23:50 UTC by Report Bug Copy Issue Report There is no parameter named `$model`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
35		* @param string $name
36		* @return void
37		*/
38	18	public function initialize(Jam_Meta $meta, $name)
39		{
40	18	parent::initialize($meta, $name);
41
42	18	if ( ! $this->foreign_model)
43	18	{
44	15	$this->foreign_model = $name;
45	15	}
46
47	18	if ( ! $this->foreign_key)
48	18	{
49	17	$this->foreign_key = $this->model.'_id';
50	17	}
51
52		// Polymorphic associations
53	18	if ($this->as)
54	18	{
55	7	$this->foreign_key = $this->as.'_id';
56	7	if ( ! $this->polymorphic_key)
57	7	{
58	7	$this->polymorphic_key = $this->as.'_model';
59	7	}
60	7	}
61	18	}
62
63		/**
64		* Load associated model (from database or after deserialization)
65		* @param Jam_Validated $model
66		* @param mixed $value
67		* @return Jam_Model
68		*/
69	1	public function load_fields(Jam_Validated $model, $value)
70		{
71	1	if (is_array($value))
72	1	{
73	1	$value = Jam::build($this->foreign_model)->load_fields($value);
74	1	}
75
76	1	if ($value instanceof Jam_Model AND $this->inverse_of)
77	1	{
78		$value->retrieved($this->inverse_of, $model);
79		}
80
81	1	return $value;
		0 ignored issues – show Bug Best Practice introduced 2015-11-24 23:50 UTC by Report Bug Copy Issue Report The return type of `return $value;` (`object\|integer\|double\|string\|null\|boolean`) is incompatible with the return type documented by `Kohana_Jam_Association_Hasone::load_fields` of type `Jam_Model\|null`. 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...
82		}
83
84		/**
85		* Return a Jam_Query_Builder_Join object to allow a query to join with this association
86		*
87		* @param string $alias table name alias
88		* @param string $type join type (LEFT, NATURAL)
89		* @return Jam_Query_Builder_Join
90		*/
91	5	public function join($alias, $type = NULL)
92		{
93	5	$join = Jam_Query_Builder_Join::factory($alias ? array($this->foreign_model, $alias) : $this->foreign_model, $type)
		0 ignored issues – show Bug introduced 2015-11-24 23:50 UTC by Report Bug Copy Issue Report It seems like `$alias ? array($this->fo... : $this->foreign_model` can also be of type `array<integer,string,{"0":"string","1":"string"}>`; however, `Kohana_Jam_Query_Builder_Join::factory()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
94	5	->context_model($this->model)
95	5	->on($this->foreign_key, '=', ':primary_key');
96
97	5	if ($this->is_polymorphic())
98	5	{
99	2	$join->on($this->polymorphic_key, '=', DB::expr(':model', array(':model' => $this->model)));
100	2	}
101
102	5	return $join;
103		}
104
105		/**
106		* Get the belonging model for this association using the foreign key,
107		* if the data was changed, use the key from the changed data.
108		* Assign inverse_of
109		*
110		* @param Jam_Validated $model
111		* @param mixed $value changed data
112		* @param boolean $is_changed
113		* @return Jam_Model
114		*/
115	7	public function get(Jam_Validated $model, $value, $is_changed)
116		{
117		if ($is_changed)
118	7	{
119	5	if ($value instanceof Jam_Validated OR ! $value)
120	5	return $value;
121
122	3	$key = Jam_Association::primary_key($this->foreign_model, $value);
123
124		if ($key)
125	3	{
126	2	$item = $this->_find_item($this->foreign_model, $key);
127	2	}
128	1	elseif (is_array($value))
129		{
130	1	$item = Jam::build($this->foreign_model, $value);
131	1	}
132		else
133		{
134		$item = NULL;
135		}
136
137	3	if ($item AND is_array($value))
138	3	{
139	3	$item->set($value);
140	3	}
141	3	}
142		else
143		{
144	5	$item = $this->_find_item($this->foreign_model, $model);
145		}
146
147	5	return $this->set($model, $item, $is_changed);
148		}
149
150	8	public function set(Jam_Validated $model, $value, $is_changed)
151		{
152	8	if ($value instanceof Jam_Model)
153	8	{
154	5	if ($this->is_polymorphic())
155	5	{
156	2	$value->{$this->polymorphic_key} = $model->meta()->model();
157	2	}
158
159	5	if ($model->loaded())
		0 ignored issues – show Documentation Bug introduced 2015-11-24 23:50 UTC by Report Bug Copy Issue Report The method `loaded` does not exist on `object<Jam_Validated>`? 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...
160	5	{
161	4	$value->{$this->foreign_key} = $model->id();
162	4	}
163
164	5	if ($this->as)
165	5	{
166	2	$value->retrieved($this->as, $model);
167	2	}
168
169	5	if ($this->inverse_of)
170	5	{
171	3	$value->retrieved($this->inverse_of, $model);
172	3	}
173	5	}
174
175	8	return $value;
176		}
177
178	1	public function build(Jam_Validated $model, array $attributes = NULL)
179		{
180	1	$item = Jam::build($this->foreign_model, $attributes);
181
182	1	$this->set($model, $item, TRUE);
183
184	1	return $item;
185		}
186
187		/**
188		* Perform validation on the belonging model, if it was changed.
189		* @param Jam_Model $model
190		* @param Jam_Event_Data $data
191		* @param array $changed
192		*/
193	8	public function model_after_check(Jam_Model $model, Jam_Event_Data $data, $changed)
		0 ignored issues – show Unused Code introduced 2015-11-24 23:50 UTC by Report Bug Copy Issue Report The parameter `$data` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
194		{
195	8	if (($value = Arr::get($changed, $this->name)) AND Jam_Association::is_changed($value))
196	8	{
197	3	if ( ! $model->{$this->name}->is_validating() AND ! $model->{$this->name}->check())
198	3	{
199		$model->errors()->add($this->name, 'association', array(':errors' => $model->{$this->name}->errors()));
		0 ignored issues – show Bug introduced 2015-11-24 23:50 UTC by Report Bug Copy Issue Report The method `add` cannot be called on `$model->errors()` (of type `array\|null`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
200		}
201	3	}
202	8	}
203
204		/**
205		* Save the related model after the main model, if it was changed
206		* Only save related model if it has been changed, and is not in a process of saving itself
207		*
208		* @param Jam_Model $model
209		* @param Jam_Event_Data $data
210		* @param boolean $changed
211		*/
212	7	public function model_after_save(Jam_Model $model, Jam_Event_Data $data, $changed)
		0 ignored issues – show Unused Code introduced 2015-11-24 23:50 UTC by Report Bug Copy Issue Report The parameter `$data` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
213		{
214	7	$nullify_query = $this->update_query($model, NULL, NULL);
215
216	7	if (($value = Arr::get($changed, $this->name)))
		0 ignored issues – show Documentation introduced 2015-11-24 23:50 UTC by Report Bug Copy Issue Report `$changed` is of type `boolean`, but the function expects a `array`. 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...
217	7	{
218	2	if (Jam_Association::is_changed($value) AND ($item = $model->{$this->name}))
219	2	{
220	2	if ( ! $item->is_saving())
221	2	{
222	2	$this->set($model, $item, TRUE)->save();
223	2	}
224	2	if ($item->id())
225	2	{
226	2	$nullify_query->where('id', '!=', $item->id())->execute();
227	2	}
228	2	}
229		else
230		{
231		$key = Jam_Association::primary_key($this->foreign_model, $value);
232
233		$query = Jam_Query_Builder_Update::factory($this->foreign_model)
234		->where(':unique_key', '=', $key)
235		->value($this->foreign_key, $model->id());
236
237		if ($this->is_polymorphic())
238		{
239		$query
240		->value($this->polymorphic_key, $model->meta()->model());
241		}
242		$nullify_query->execute();
243		$query->execute();
244		}
245	2	}
246	7	elseif (array_key_exists($this->name, $changed))
247		{
248	1	$nullify_query->execute();
249	1	}
250	7	}
251
252		/**
253		* Delete related model if it has been assigned as dependent
254		* If dependent is Jam_Association::DELETE - execute the delete method (and all events)
255		* IF dependent is Jam_Association::ERASE - simply remove from database without executing any events (faster)
256		* @param Jam_Model $model
257		*/
258	4	public function model_before_delete(Jam_Model $model)
259		{
260	4	switch ($this->dependent)
261		{
262	4	case Jam_Association::DELETE:
263	1	if ($model->{$this->name})
264	1	{
265		$model->{$this->name}->delete();
266		}
267	1	break;
268
269	3	case Jam_Association::ERASE:
270	1	$this->query_builder('delete', $model)->execute();
271	1	break;
272
273	2	case Jam_Association::NULLIFY:
274		$this->update_query($model, NULL, NULL)->execute();
275		break;
276	4	}
277	4	}
278
279		/**
280		* See if the association is polymorphic
281		* @return boolean
282		*/
283	24	public function is_polymorphic()
284		{
285	24	return (bool) $this->as;
286		}
287
288	4	protected function _find_item($foreign_model, $key)
289		{
290	4	if ( ! $key)
291	4	return;
292
293	4	if ($key instanceof Jam_Model)
294	4	{
295	4	if ( ! $key->loaded())
296	4	return;
297
298	4	$query = $this->query_builder('all', $key);
299	4	}
300		else
301		{
302	1	$query = new Jam_Query_Builder_Collection($foreign_model);
303		$query
304	1	->where(':unique_key', '=', $key)
305	1	->limit(1);
306		}
307
308	4	return $query->current();
309		}
310
311	11	public function query_builder($type, Jam_Model $model)
312		{
313	11	$query = call_user_func("Jam::{$type}", $this->foreign_model)
314	11	->where($this->foreign_key, '=', $model->id());
315
316	11	if ($this->is_polymorphic())
317	11	{
318	5	$query->where($this->polymorphic_key, '=', $model->meta()->model());
319	5	}
320
321	11	return $query;
322		}
323
324	9	public function update_query(Jam_Model $model, $new_id, $new_model)
325		{
326	9	$query = $this->query_builder('update', $model)
327	9	->value($this->foreign_key, $new_id);
328
329	9	if ($this->is_polymorphic())
330	9	{
331	4	$query->value($this->polymorphic_key, $new_model);
332	4	}
333
334	9	return $query;
335		}
336		}
337

OpenBuildings / jam

Push — count-subquery-clone ( d5815f...6cc328 )

Kohana_Jam_Association_Hasone B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

13 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like