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 | 384 | 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 | 170 | public function get($name) |
|
| 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 string $value |
||
| 93 | * @return $this |
||
| 94 | */ |
||
| 95 | 63 | public function set($values, $value = NULL) |
|
| 96 | { |
||
| 97 | // Accept set('name', 'value'); |
||
| 98 | 63 | if ( ! is_array($values)) |
|
| 99 | 63 | { |
|
| 100 | 51 | $values = array($values => $value); |
|
| 101 | 51 | } |
|
| 102 | |||
| 103 | 63 | foreach ($values as $key => & $value) |
|
| 104 | { |
||
| 105 | 63 | if ($association = $this->meta()->association($key)) |
|
| 106 | 63 | { |
|
| 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 | 63 | } |
|
| 116 | |||
| 117 | 63 | parent::set($values); |
|
| 118 | |||
| 119 | 63 | if ($this->_saved AND $this->changed()) |
|
| 120 | 63 | { |
|
| 121 | 18 | $this->_saved = FALSE; |
|
| 122 | 18 | } |
|
| 123 | |||
| 124 | 63 | 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 | 157 | public function load_fields($values) |
|
| 137 | { |
||
| 138 | // Clear the object |
||
| 139 | 157 | $this->clear(); |
|
| 140 | |||
| 141 | 157 | $this->meta()->events()->trigger('model.before_load', $this); |
|
| 142 | |||
| 143 | 157 | $this->_loaded = TRUE; |
|
| 144 | |||
| 145 | 157 | $columns = array(); |
|
| 146 | |||
| 147 | 157 | foreach ($this->meta()->fields() as $key => $field) |
|
| 148 | { |
||
| 149 | 157 | $columns[$field->column] = $field; |
|
| 150 | 157 | } |
|
| 151 | |||
| 152 | 157 | foreach ($values as $key => $value) |
|
| 153 | { |
||
| 154 | 154 | if ($field = $this->meta()->field($key)) |
|
| 155 | 154 | { |
|
| 156 | 154 | $this->_original[$field->name] = $field->set($this, $value, FALSE); |
|
| 157 | 154 | } |
|
| 158 | 23 | elseif (isset($columns[$key])) |
|
| 159 | { |
||
| 160 | $field = $columns[$key]; |
||
| 161 | 1 | $this->_original[$field->name] = $field->set($this, $value, FALSE); |
|
| 162 | } |
||
| 163 | 23 | 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 | 15 | $this->_unmapped[$key] = $value; |
|
| 178 | } |
||
| 179 | 157 | } |
|
| 180 | |||
| 181 | // Model is now saved and loaded |
||
| 182 | 157 | $this->_saved = TRUE; |
|
| 183 | |||
| 184 | 157 | $this->meta()->events()->trigger('model.after_load', $this); |
|
| 185 | |||
| 186 | 157 | 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 | 11 | public function check($force = FALSE) |
|
| 197 | { |
||
| 198 | 11 | $this->_move_retrieved_to_changed(); |
|
| 199 | |||
| 200 | 11 | return parent::check( ! $this->loaded() OR $force); |
|
| 201 | } |
||
| 202 | |||
| 203 | 644 | protected function _move_retrieved_to_changed() |
|
| 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 | */ |
||
| 240 | 54 | public function save($validate = NULL) |
|
| 241 | { |
||
| 242 | 10 | if ($this->_is_saving) |
|
| 243 | 10 | throw new Kohana_Exception("Cannot save a model that is already in the process of saving"); |
|
| 244 | |||
| 245 | |||
| 246 | 10 | $key = $this->_original[$this->meta()->primary_key()]; |
|
| 247 | |||
| 248 | // Run validation |
||
| 249 | 10 | if ($validate !== FALSE) |
|
| 250 | 10 | { |
|
| 251 | 10 | $this->check_insist(); |
|
| 252 | 10 | } |
|
| 253 | |||
| 254 | 10 | $this->_is_saving = TRUE; |
|
| 255 | |||
| 256 | // These will be processed later |
||
| 257 | 10 | $values = $defaults = array(); |
|
| 258 | |||
| 259 | 10 | if ($this->meta()->events()->trigger('model.before_save', $this, array($this->_changed)) === FALSE) |
|
| 260 | 10 | { |
|
| 261 | return $this; |
||
| 262 | } |
||
| 263 | |||
| 264 | // Trigger callbacks and ensure we should proceed |
||
| 265 | 10 | $event_type = $key ? 'update' : 'create'; |
|
| 266 | |||
| 267 | 10 | if ($this->meta()->events()->trigger('model.before_'.$event_type, $this, array($this->_changed)) === FALSE) |
|
| 268 | 10 | { |
|
| 269 | return $this; |
||
| 270 | } |
||
| 271 | |||
| 272 | 10 | $this->_move_retrieved_to_changed(); |
|
| 273 | |||
| 274 | // Iterate through all fields in original in case any unchanged fields |
||
| 275 | // have convert() behavior like timestamp updating... |
||
| 276 | // |
||
| 277 | 10 | foreach (array_merge($this->_original, $this->_changed) as $column => $value) |
|
| 278 | { |
||
| 279 | 10 | if ($field = $this->meta()->field($column)) |
|
| 280 | 10 | { |
|
| 281 | // Only save in_db values |
||
| 282 | 10 | if ($field->in_db) |
|
| 283 | 10 | { |
|
| 284 | // See if field wants to alter the value on save() |
||
| 285 | 10 | $value = $field->convert($this, $value, $key); |
|
| 286 | |||
| 287 | // Only set the value to be saved if it's changed from the original |
||
| 288 | 10 | if ($value !== $this->_original[$column]) |
|
| 289 | 10 | { |
|
| 290 | 7 | $values[$field->column] = $value; |
|
| 291 | 54 | } |
|
| 292 | // Or if we're INSERTing and we need to set the defaults for the first time |
||
| 293 | 10 | elseif ( ! $key AND ( ! $this->changed($field->name) OR $field->default === $value) AND ! $field->primary) |
|
| 294 | { |
||
| 295 | 8 | $defaults[$field->column] = $field->default; |
|
| 296 | 8 | } |
|
| 297 | 10 | } |
|
| 298 | 10 | } |
|
| 299 | 10 | } |
|
| 300 | |||
| 301 | // If we have a key, we're updating |
||
| 302 | if ($key) |
||
| 303 | 10 | { |
|
| 304 | // Do we even have to update anything in the row? |
||
| 305 | if ($values) |
||
| 306 | 4 | { |
|
| 307 | 3 | Jam::update($this) |
|
| 308 | 3 | ->where_key($key) |
|
| 309 | 3 | ->set($values) |
|
| 310 | 3 | ->execute(); |
|
| 311 | 3 | } |
|
| 312 | 4 | } |
|
| 313 | else |
||
| 314 | { |
||
| 315 | 8 | $insert_values = array_merge($defaults, $values); |
|
| 316 | 8 | list($id) = Jam::insert($this) |
|
| 317 | 8 | ->columns(array_keys($insert_values)) |
|
| 318 | 8 | ->values(array_values($insert_values)) |
|
| 319 | 8 | ->execute(); |
|
| 320 | |||
| 321 | // Gotta make sure to set this |
||
| 322 | 8 | $key = $values[$this->meta()->primary_key()] = $id; |
|
| 323 | } |
||
| 324 | |||
| 325 | // Re-set any saved values; they may have changed |
||
| 326 | 10 | $this->set($values); |
|
| 327 | |||
| 328 | 10 | $this->_loaded = $this->_saved = TRUE; |
|
| 329 | |||
| 330 | 10 | $this->meta()->events()->trigger('model.after_save', $this, array($this->_changed, $event_type)); |
|
| 331 | |||
| 332 | 10 | $this->meta()->events()->trigger('model.after_'.$event_type, $this, array($this->_changed)); |
|
| 333 | |||
| 334 | // Set the changed data back as original |
||
| 335 | 10 | $this->_original = array_merge($this->_original, $this->_changed); |
|
| 336 | |||
| 337 | 10 | $this->_changed = array(); |
|
| 338 | |||
| 339 | 10 | foreach ($this->_retrieved as $name => $retrieved) |
|
| 340 | { |
||
| 341 | 7 | if (($association = $this->meta()->association($name))) |
|
| 342 | 7 | { |
|
| 343 | 2 | if ($association instanceof Jam_Association_Collection) |
|
| 344 | 2 | { |
|
| 345 | 1 | $retrieved->clear_changed(); |
|
| 346 | 1 | } |
|
| 347 | 2 | } |
|
| 348 | 7 | elseif (($field = $this->meta()->field($name)) AND $field->in_db) |
|
| 349 | { |
||
| 350 | 7 | unset($this->_retrieved[$name]); |
|
| 351 | 7 | } |
|
| 352 | 10 | } |
|
| 353 | |||
| 354 | 10 | $this->_is_saving = FALSE; |
|
| 355 | |||
| 356 | 10 | return $this; |
|
| 357 | } |
||
| 358 | |||
| 359 | /** |
||
| 360 | * Deletes a single record. |
||
| 361 | * |
||
| 362 | * @return boolean |
||
| 363 | **/ |
||
| 364 | 10 | public function delete() |
|
| 390 | |||
| 391 | /** |
||
| 392 | * Removes any changes made to a model. |
||
| 393 | * |
||
| 394 | * This method only works on loaded models. |
||
| 395 | * |
||
| 396 | * @return $this |
||
| 397 | */ |
||
| 398 | public function revert() |
||
| 410 | |||
| 411 | /** |
||
| 412 | * Sets a model to its original state, as if freshly instantiated |
||
| 413 | * |
||
| 414 | * @return $this |
||
| 415 | */ |
||
| 416 | 157 | public function clear() |
|
| 425 | |||
| 426 | 1 | public function get_insist($attribute_name) |
|
| 427 | { |
||
| 428 | 1 | $attribute = $this->__get($attribute_name); |
|
| 429 | |||
| 430 | 1 | if ($attribute === NULL) |
|
| 431 | 1 | throw new Jam_Exception_Notfound('The association :name was empty on :model_name', NULL, array( |
|
| 432 | 1 | ':name' => $attribute_name, |
|
| 433 | 1 | ':model_name' => (string) $this, |
|
| 434 | 1 | )); |
|
| 435 | |||
| 436 | 1 | return $attribute; |
|
| 437 | } |
||
| 438 | |||
| 439 | 1 | public function build($association_name, array $attributes = array()) |
|
| 440 | { |
||
| 441 | 1 | $association = $this->meta()->association($association_name); |
|
| 442 | |||
| 443 | 1 | if ( ! $association) |
|
| 444 | 1 | throw new Kohana_Exception('There is no association named :association_name on model :model', array(':association_name' => $association_name, ':model' => $this->meta()->model())); |
|
| 445 | |||
| 446 | 1 | if ($association instanceof Jam_Association_Collection) |
|
| 447 | 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())); |
|
| 448 | |||
| 449 | 1 | $item = $association->build($this, $attributes); |
|
| 450 | |||
| 451 | 1 | $this->set($association_name, $item); |
|
| 452 | |||
| 453 | 1 | return $item; |
|
| 454 | } |
||
| 455 | |||
| 456 | /** |
||
| 457 | * Returns whether or not the model is loaded |
||
| 458 | * |
||
| 459 | * @return boolean |
||
| 460 | */ |
||
| 461 | 73 | public function loaded() |
|
| 465 | |||
| 466 | public function loaded_insist() |
||
| 467 | { |
||
| 468 | if ( ! $this->loaded()) |
||
| 469 | throw new Jam_Exception_NotLoaded("Model not loaded", $this); |
||
| 470 | |||
| 471 | return $this; |
||
| 472 | } |
||
| 473 | |||
| 474 | /** |
||
| 475 | * Whether or not the model is saved |
||
| 476 | * |
||
| 477 | * @return boolean |
||
| 478 | */ |
||
| 479 | 10 | public function saved() |
|
| 483 | |||
| 484 | /** |
||
| 485 | * Whether or not the model is in the process of being saved |
||
| 486 | * |
||
| 487 | * @return boolean |
||
| 488 | */ |
||
| 489 | 4 | public function is_saving() |
|
| 493 | |||
| 494 | /** |
||
| 495 | * Whether or not the model is deleted |
||
| 496 | * |
||
| 497 | * @return boolean |
||
| 498 | */ |
||
| 499 | public function deleted() |
||
| 503 | |||
| 504 | /** |
||
| 505 | * Build a new model object based on the current one, but without an ID, so it can be saved as a new object |
||
| 506 | * @return Jam_Model |
||
| 507 | */ |
||
| 508 | 1 | public function duplicate() |
|
| 509 | { |
||
| 510 | 1 | $fields = $this->as_array(); |
|
| 511 | |||
| 512 | 1 | unset($fields[$this->meta()->primary_key()]); |
|
| 513 | |||
| 514 | 1 | return Jam::build($this->meta()->model(), $fields); |
|
| 515 | } |
||
| 516 | |||
| 517 | /** |
||
| 518 | * Returns a string representation of the model in the |
||
| 519 | * form of `Model_Name (id)` or `Model_Name (NULL)` if |
||
| 520 | * the model is not loaded. |
||
| 521 | * |
||
| 522 | * This is designed to be useful for debugging. |
||
| 523 | * |
||
| 524 | * @return string |
||
| 525 | */ |
||
| 526 | 2 | public function __toString() |
|
| 530 | |||
| 531 | 644 | public function serialize() |
|
| 532 | { |
||
| 533 | 644 | $this->_move_retrieved_to_changed(); |
|
| 534 | |||
| 535 | 644 | return serialize(array( |
|
| 536 | 644 | 'original' => $this->_original, |
|
| 537 | 644 | 'changed' => $this->_changed, |
|
| 538 | 644 | 'unmapped' => $this->_unmapped, |
|
| 539 | 644 | 'saved' => $this->_saved, |
|
| 540 | 644 | 'loaded' => $this->_loaded, |
|
| 541 | 644 | 'deleted' => $this->_deleted, |
|
| 542 | 644 | )); |
|
| 543 | } |
||
| 544 | |||
| 545 | 644 | public function unserialize($data) |
|
| 566 | } |
||
| 567 |
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.