OpenBuildings /
jam
Complex classes like Kohana_Jam_Model 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 Kohana_Jam_Model, and based on these observations, apply Extract Interface, too.
| 1 | <?php defined('SYSPATH') OR die('No direct script access.'); |
||
| 14 | abstract class Kohana_Jam_Model extends Jam_Validated { |
||
| 15 | |||
| 16 | /** |
||
| 17 | * @var boolean Whether or not the model is loaded |
||
| 18 | */ |
||
| 19 | protected $_loaded = FALSE; |
||
| 20 | |||
| 21 | /** |
||
| 22 | * @var boolean Whether or not the model is saved |
||
| 23 | */ |
||
| 24 | protected $_saved = FALSE; |
||
| 25 | |||
| 26 | /** |
||
| 27 | * @var boolean Whether or not the model is saving |
||
| 28 | */ |
||
| 29 | protected $_is_saving = FALSE; |
||
| 30 | |||
| 31 | /** |
||
| 32 | * @var Boolean A flag that indicates a record has been deleted from the database |
||
| 33 | */ |
||
| 34 | protected $_deleted = FALSE; |
||
| 35 | |||
| 36 | /** |
||
| 37 | * Constructor. |
||
| 38 | * |
||
| 39 | * A key can be passed to automatically load a model by its |
||
| 40 | * unique key. |
||
| 41 | * |
||
| 42 | * @param mixed|null $key |
||
|
|
|||
| 43 | */ |
||
| 44 | 441 | public function __construct($meta_name = NULL) |
|
| 55 | |||
| 56 | /** |
||
| 57 | * Gets the value for a field. |
||
| 58 | * |
||
| 59 | * @param string $name The field's name |
||
| 60 | * @return array|mixed |
||
| 61 | */ |
||
| 62 | 218 | public function get($name) |
|
| 63 | { |
||
| 64 | 218 | if ($association = $this->meta()->association($name)) |
|
| 65 | 218 | { |
|
| 66 | 20 | $name = $association->name; |
|
| 67 | |||
| 68 | 20 | return $association->get($this, Arr::get($this->_changed, $name), $this->changed($name)); |
|
| 69 | } |
||
| 70 | |||
| 71 | 217 | return parent::get($name); |
|
| 72 | } |
||
| 73 | |||
| 74 | public function __isset($name) |
||
| 78 | |||
| 79 | /** |
||
| 80 | * Sets the value of a field. |
||
| 81 | * |
||
| 82 | * You can pass an array of key => value pairs |
||
| 83 | * to set multiple fields at the same time: |
||
| 84 | * |
||
| 85 | * $model->set(array( |
||
| 86 | * 'field1' => 'value', |
||
| 87 | * 'field2' => 'value', |
||
| 88 | * .... |
||
| 89 | * )); |
||
| 90 | * |
||
| 91 | * @param array|string $values |
||
| 92 | * @param mixed|null $value |
||
| 93 | * @return $this |
||
| 94 | */ |
||
| 95 | 95 | public function set($values, $value = NULL) |
|
| 96 | { |
||
| 97 | // Accept set('name', 'value'); |
||
| 98 | 95 | if ( ! is_array($values)) |
|
| 99 | 95 | { |
|
| 100 | 80 | $values = array($values => $value); |
|
| 101 | 80 | } |
|
| 102 | |||
| 103 | 95 | foreach ($values as $key => & $value) |
|
| 104 | { |
||
| 105 | 95 | if ($association = $this->meta()->association($key)) |
|
| 106 | 95 | { |
|
| 107 | 20 | if ($association->readonly) |
|
| 108 | 20 | throw new Kohana_Exception('Cannot change the value of :name, its readonly', array(':name' => $association->name)); |
|
| 109 | |||
| 110 | 20 | $this->_changed[$association->name] = $association->set($this, $value, TRUE); |
|
| 111 | |||
| 112 | 20 | unset($this->_retrieved[$association->name]); |
|
| 113 | 20 | unset($values[$key]); |
|
| 114 | 20 | } |
|
| 115 | 95 | } |
|
| 116 | |||
| 117 | 95 | parent::set($values); |
|
| 118 | |||
| 119 | 95 | if ($this->_saved AND $this->changed()) |
|
| 120 | 95 | { |
|
| 121 | 27 | $this->_saved = FALSE; |
|
| 122 | 27 | } |
|
| 123 | |||
| 124 | 95 | return $this; |
|
| 125 | } |
||
| 126 | |||
| 127 | /** |
||
| 128 | * Clears the object and loads an array of values into the object. |
||
| 129 | * |
||
| 130 | * This should only be used for setting from database results |
||
| 131 | * since the model declares itself as saved and loaded after. |
||
| 132 | * |
||
| 133 | * @param Jam_Model|array $values |
||
| 134 | * @return $this |
||
| 135 | */ |
||
| 136 | 198 | public function load_fields($values) |
|
| 137 | { |
||
| 138 | // Clear the object |
||
| 139 | 198 | $this->clear(); |
|
| 140 | |||
| 141 | 198 | $this->meta()->events()->trigger('model.before_load', $this); |
|
| 142 | |||
| 143 | 198 | $this->_loaded = TRUE; |
|
| 144 | |||
| 145 | 198 | $columns = array(); |
|
| 146 | |||
| 147 | 198 | foreach ($this->meta()->fields() as $key => $field) |
|
| 148 | { |
||
| 149 | 198 | $columns[$field->column] = $field; |
|
| 150 | 198 | } |
|
| 151 | |||
| 152 | 198 | foreach ($values as $key => $value) |
|
| 153 | { |
||
| 154 | 195 | if ($field = $this->meta()->field($key)) |
|
| 155 | 195 | { |
|
| 156 | 195 | $this->_original[$field->name] = $field->set($this, $value, FALSE); |
|
| 157 | 195 | } |
|
| 158 | 48 | elseif (isset($columns[$key])) |
|
| 159 | { |
||
| 160 | $field = $columns[$key]; |
||
| 161 | 1 | $this->_original[$field->name] = $field->set($this, $value, FALSE); |
|
| 162 | } |
||
| 163 | 48 | elseif ($association = $this->meta()->association($key)) |
|
| 164 | { |
||
| 165 | 8 | $association_value = $association->load_fields($this, $value, FALSE); |
|
| 166 | 8 | if (is_object($association_value)) |
|
| 167 | 8 | { |
|
| 168 | 8 | $this->_retrieved[$association->name] = $association->load_fields($this, $value, FALSE); |
|
| 169 | 8 | } |
|
| 170 | else |
||
| 171 | { |
||
| 172 | 1 | $this->_changed[$association->name] = $association_value; |
|
| 173 | } |
||
| 174 | 8 | } |
|
| 175 | else |
||
| 176 | { |
||
| 177 | 40 | $this->_unmapped[$key] = $value; |
|
| 178 | } |
||
| 179 | 198 | } |
|
| 180 | |||
| 181 | // Model is now saved and loaded |
||
| 182 | 198 | $this->_saved = TRUE; |
|
| 183 | |||
| 184 | 198 | $this->meta()->events()->trigger('model.after_load', $this); |
|
| 185 | |||
| 186 | 198 | return $this; |
|
| 187 | } |
||
| 188 | |||
| 189 | /** |
||
| 190 | * Validates the current model's data |
||
| 191 | * |
||
| 192 | * @throws Jam_Exception_Validation |
||
| 193 | * @param Validation|null $extra_validation |
||
| 194 | * @return bool |
||
| 195 | */ |
||
| 196 | 21 | public function check($force = FALSE) |
|
| 202 | |||
| 203 | 756 | protected function _move_retrieved_to_changed() |
|
| 204 | { |
||
| 205 | 756 | foreach ($this->_retrieved as $column => $value) |
|
| 206 | { |
||
| 207 | 19 | if ($value instanceof Jam_Array_Association AND $value->changed()) |
|
| 208 | 19 | { |
|
| 209 | 5 | $this->_changed[$column] = $value; |
|
| 210 | 5 | } |
|
| 211 | 756 | } |
|
| 212 | 756 | } |
|
| 213 | |||
| 214 | 15 | public function update_fields($values, $value = NULL) |
|
| 215 | { |
||
| 216 | 15 | if ( ! $this->loaded()) |
|
| 217 | throw new Kohana_Exception('Model must be loaded to use update_fields method'); |
||
| 218 | |||
| 219 | if ( ! is_array($values)) |
||
| 220 | { |
||
| 221 | $values = array($values => $value); |
||
| 222 | } |
||
| 223 | |||
| 224 | $this->set($values); |
||
| 225 | |||
| 226 | Jam::update($this) |
||
| 227 | ->where_key($this->id()) |
||
| 228 | ->set($values) |
||
| 229 | ->execute(); |
||
| 230 | |||
| 231 | return $this; |
||
| 232 | } |
||
| 233 | |||
| 234 | /** |
||
| 235 | * Creates or updates the current record. |
||
| 236 | * |
||
| 237 | * @param bool|null $validate |
||
| 238 | * @return $this |
||
| 239 | * @throws Kohana_Exception |
||
| 240 | * @throws Jam_Exception_Validation |
||
| 241 | */ |
||
| 242 | 80 | public function save($validate = NULL) |
|
| 243 | { |
||
| 244 | 20 | if ($this->_is_saving) |
|
| 245 | 20 | throw new Kohana_Exception("Cannot save a model that is already in the process of saving"); |
|
| 246 | |||
| 247 | |||
| 248 | 20 | $key = $this->_original[$this->meta()->primary_key()]; |
|
| 249 | |||
| 250 | // Run validation |
||
| 251 | 20 | if ($validate !== FALSE && !$this->check()) |
|
| 252 | 20 | { |
|
| 253 | throw new Jam_Exception_Validation('There was an error validating the :model: :errors', $this); |
||
| 254 | } |
||
| 255 | |||
| 256 | 20 | $this->_is_saving = TRUE; |
|
| 257 | |||
| 258 | // These will be processed later |
||
| 259 | 20 | $values = $defaults = array(); |
|
| 260 | |||
| 261 | 20 | if ($this->meta()->events()->trigger('model.before_save', $this, array($this->_changed)) === FALSE) |
|
| 262 | 20 | { |
|
| 263 | return $this; |
||
| 264 | } |
||
| 265 | |||
| 266 | // Trigger callbacks and ensure we should proceed |
||
| 267 | 20 | $event_type = $key ? 'update' : 'create'; |
|
| 268 | |||
| 269 | 20 | if ($this->meta()->events()->trigger('model.before_'.$event_type, $this, array($this->_changed)) === FALSE) |
|
| 270 | 20 | { |
|
| 271 | return $this; |
||
| 272 | } |
||
| 273 | |||
| 274 | 20 | $this->_move_retrieved_to_changed(); |
|
| 275 | |||
| 276 | // Iterate through all fields in original in case any unchanged fields |
||
| 277 | // have convert() behavior like timestamp updating... |
||
| 278 | // |
||
| 279 | 20 | foreach (array_merge($this->_original, $this->_changed) as $column => $value) |
|
| 280 | { |
||
| 281 | 20 | if ($field = $this->meta()->field($column)) |
|
| 282 | 20 | { |
|
| 283 | // Only save in_db values |
||
| 284 | 20 | if ($field->in_db) |
|
| 285 | 20 | { |
|
| 286 | // See if field wants to alter the value on save() |
||
| 287 | 20 | $value = $field->convert($this, $value, $key); |
|
| 288 | |||
| 289 | // Only set the value to be saved if it's changed from the original |
||
| 290 | 20 | if ($value !== $this->_original[$column]) |
|
| 291 | 20 | { |
|
| 292 | 80 | $values[$field->column] = $value; |
|
| 293 | 16 | } |
|
| 294 | // Or if we're INSERTing and we need to set the defaults for the first time |
||
| 295 | 20 | elseif ( ! $key AND ( ! $this->changed($field->name) OR $field->default === $value) AND ! $field->primary) |
|
| 296 | { |
||
| 297 | 18 | $defaults[$field->column] = $field->default; |
|
| 298 | 18 | } |
|
| 299 | 20 | } |
|
| 300 | 20 | } |
|
| 301 | 20 | } |
|
| 302 | |||
| 303 | // If we have a key, we're updating |
||
| 304 | if ($key) |
||
| 305 | 20 | { |
|
| 306 | // Do we even have to update anything in the row? |
||
| 307 | if ($values) |
||
| 308 | 4 | { |
|
| 309 | 3 | Jam::update($this) |
|
| 310 | 3 | ->where_key($key) |
|
| 311 | 3 | ->set($values) |
|
| 312 | 3 | ->execute(); |
|
| 313 | 3 | } |
|
| 314 | 4 | } |
|
| 315 | else |
||
| 316 | { |
||
| 317 | 18 | $insert_values = array_merge($defaults, $values); |
|
| 318 | 18 | list($id) = Jam::insert($this) |
|
| 319 | 18 | ->columns(array_keys($insert_values)) |
|
| 320 | 18 | ->values(array_values($insert_values)) |
|
| 321 | 18 | ->execute(); |
|
| 322 | |||
| 323 | // Gotta make sure to set this |
||
| 324 | 18 | $key = $values[$this->meta()->primary_key()] = $id; |
|
| 325 | } |
||
| 326 | |||
| 327 | // Re-set any saved values; they may have changed |
||
| 328 | 20 | $this->set($values); |
|
| 329 | |||
| 330 | 20 | $this->_loaded = $this->_saved = TRUE; |
|
| 331 | |||
| 332 | 20 | $this->meta()->events()->trigger('model.after_save', $this, array($this->_changed, $event_type)); |
|
| 333 | |||
| 334 | 20 | $this->meta()->events()->trigger('model.after_'.$event_type, $this, array($this->_changed)); |
|
| 335 | |||
| 336 | // Set the changed data back as original |
||
| 337 | 20 | $this->_original = array_merge($this->_original, $this->_changed); |
|
| 338 | |||
| 339 | 20 | $this->_changed = array(); |
|
| 340 | |||
| 341 | 20 | foreach ($this->_retrieved as $name => $retrieved) |
|
| 342 | { |
||
| 343 | 17 | if (($association = $this->meta()->association($name))) |
|
| 344 | 17 | { |
|
| 345 | 2 | if ($association instanceof Jam_Association_Collection) |
|
| 346 | 2 | { |
|
| 347 | 1 | $retrieved->clear_changed(); |
|
| 348 | 1 | } |
|
| 349 | 2 | } |
|
| 350 | 17 | elseif (($field = $this->meta()->field($name)) AND $field->in_db) |
|
| 351 | { |
||
| 352 | 17 | unset($this->_retrieved[$name]); |
|
| 353 | 17 | } |
|
| 354 | 20 | } |
|
| 355 | |||
| 356 | 20 | $this->_is_saving = FALSE; |
|
| 357 | |||
| 358 | 20 | return $this; |
|
| 359 | } |
||
| 360 | |||
| 361 | /** |
||
| 362 | * Deletes a single record. |
||
| 363 | * |
||
| 364 | * @return boolean |
||
| 365 | **/ |
||
| 366 | 9 | public function delete() |
|
| 367 | 1 | { |
|
| 368 | 9 | $result = FALSE; |
|
| 369 | |||
| 370 | // Are we loaded? Then we're just deleting this record |
||
| 371 | 9 | if ($this->_loaded) |
|
| 372 | 9 | { |
|
| 373 | 9 | $key = $this->_original[$this->meta()->primary_key()]; |
|
| 374 | |||
| 375 | 9 | if (($result = $this->meta()->events()->trigger('model.before_delete', $this)) !== FALSE) |
|
| 376 | 9 | { |
|
| 377 | 9 | $result = Jam::delete($this)->where_key($key)->execute(); |
|
| 378 | 9 | } |
|
| 379 | 9 | } |
|
| 380 | |||
| 381 | // Trigger the after-delete |
||
| 382 | 9 | $this->meta()->events()->trigger('model.after_delete', $this, array($result)); |
|
| 383 | |||
| 384 | // Clear the object so it appears deleted anyway |
||
| 385 | 9 | $this->clear(); |
|
| 386 | |||
| 387 | // Set the flag indicatig the model has been successfully deleted |
||
| 388 | 9 | $this->_deleted = $result; |
|
| 389 | |||
| 390 | 9 | return $this->_deleted; |
|
| 391 | } |
||
| 392 | |||
| 393 | /** |
||
| 394 | * Removes any changes made to a model. |
||
| 395 | * |
||
| 396 | * This method only works on loaded models. |
||
| 397 | * |
||
| 398 | * @return $this |
||
| 399 | */ |
||
| 400 | public function revert() |
||
| 401 | { |
||
| 402 | if ($this->_loaded) |
||
| 403 | { |
||
| 404 | $this->_loaded = |
||
| 405 | $this->_saved = TRUE; |
||
| 406 | |||
| 407 | parent::revert(); |
||
| 408 | } |
||
| 409 | |||
| 410 | return $this; |
||
| 411 | } |
||
| 412 | |||
| 413 | /** |
||
| 414 | * Sets a model to its original state, as if freshly instantiated |
||
| 415 | * |
||
| 416 | * @return $this |
||
| 417 | */ |
||
| 418 | 198 | public function clear() |
|
| 427 | |||
| 428 | 1 | public function get_insist($attribute_name) |
|
| 429 | { |
||
| 430 | 1 | $attribute = $this->__get($attribute_name); |
|
| 431 | |||
| 432 | 1 | if ($attribute === NULL) |
|
| 433 | 1 | throw new Jam_Exception_Notfound('The association :name was empty on :model_name', NULL, array( |
|
| 434 | 1 | ':name' => $attribute_name, |
|
| 435 | 1 | ':model_name' => (string) $this, |
|
| 436 | 1 | )); |
|
| 437 | |||
| 438 | 1 | return $attribute; |
|
| 439 | } |
||
| 440 | |||
| 441 | 1 | public function build($association_name, array $attributes = array()) |
|
| 442 | { |
||
| 443 | 1 | $association = $this->meta()->association($association_name); |
|
| 444 | |||
| 445 | 1 | if ( ! $association) |
|
| 446 | 1 | throw new Kohana_Exception('There is no association named :association_name on model :model', array(':association_name' => $association_name, ':model' => $this->meta()->model())); |
|
| 447 | |||
| 448 | 1 | if ($association instanceof Jam_Association_Collection) |
|
| 449 | 1 | throw new Kohana_Exception(':association_name association must not be a collection on model :model', array(':association_name' => $association_name, ':model' => $this->meta()->model())); |
|
| 450 | |||
| 451 | 1 | $item = $association->build($this, $attributes); |
|
| 452 | |||
| 453 | 1 | $this->set($association_name, $item); |
|
| 454 | |||
| 455 | 1 | return $item; |
|
| 456 | } |
||
| 457 | |||
| 458 | /** |
||
| 459 | * Returns whether or not the model is loaded |
||
| 460 | * |
||
| 461 | * @return boolean |
||
| 462 | */ |
||
| 463 | 93 | public function loaded() |
|
| 464 | { |
||
| 465 | 93 | return $this->_loaded; |
|
| 466 | 1 | } |
|
| 467 | |||
| 468 | public function loaded_insist() |
||
| 475 | |||
| 476 | /** |
||
| 477 | * Whether or not the model is saved |
||
| 478 | * |
||
| 479 | * @return boolean |
||
| 480 | */ |
||
| 481 | 10 | public function saved() |
|
| 485 | |||
| 486 | /** |
||
| 487 | * Whether or not the model is in the process of being saved |
||
| 488 | * |
||
| 489 | * @return boolean |
||
| 490 | */ |
||
| 491 | 4 | public function is_saving() |
|
| 495 | |||
| 496 | /** |
||
| 497 | * Whether or not the model is deleted |
||
| 498 | * |
||
| 499 | * @return boolean |
||
| 500 | */ |
||
| 501 | public function deleted() |
||
| 505 | |||
| 506 | /** |
||
| 507 | * Build a new model object based on the current one, but without an ID, so it can be saved as a new object |
||
| 508 | * @return Jam_Model |
||
| 509 | */ |
||
| 510 | 1 | public function duplicate() |
|
| 518 | |||
| 519 | /** |
||
| 520 | * Returns a string representation of the model in the |
||
| 521 | * form of `Model_Name (id)` or `Model_Name (NULL)` if |
||
| 522 | * the model is not loaded. |
||
| 523 | * |
||
| 524 | * This is designed to be useful for debugging. |
||
| 525 | * |
||
| 526 | * @return string |
||
| 527 | */ |
||
| 528 | 4 | public function __toString() |
|
| 532 | |||
| 533 | 756 | public function serialize() |
|
| 534 | { |
||
| 535 | 756 | $this->_move_retrieved_to_changed(); |
|
| 536 | |||
| 537 | 756 | return serialize(array( |
|
| 538 | 756 | 'original' => $this->_original, |
|
| 546 | |||
| 547 | 756 | public function unserialize($data) |
|
| 548 | { |
||
| 549 | 756 | $data = unserialize($data); |
|
| 550 | |||
| 551 | 756 | $this->_meta = Jam::meta($this); |
|
| 568 | } |
||
| 569 |
Loading history...
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
$italyis not defined by the methodfinale(...).The most likely cause is that the parameter was removed, but the annotation was not.