Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: d8f5967b42
Fetching contributors…

Cannot retrieve contributors at this time

file 396 lines (354 sloc) 15.618 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
<?php

   /**
*
* Paris
*
* http://github.com/j4mie/paris/
*
* A simple Active Record implementation built on top of Idiorm
* ( http://github.com/j4mie/idiorm/ ).
*
* You should include Idiorm before you include this file:
* require_once 'your/path/to/idiorm.php';
*
* BSD Licensed.
*
* Copyright (c) 2010, Jamie Matthews
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

    /**
* Subclass of Idiorm's ORM class that supports
* returning instances of a specified class rather
* than raw instances of the ORM class.
*
* You shouldn't need to interact with this class
* directly. It is used internally by the Model base
* class.
*/
    class ORMWrapper extends ORM {

        /**
* The wrapped find_one and find_many classes will
* return an instance or instances of this class.
*/
        protected $_class_name;

        /**
* Set the name of the class which the wrapped
* methods should return instances of.
*/
        public function set_class_name($class_name) {
            $this->_class_name = $class_name;
        }

        /**
* Add a custom filter to the method chain specified on the
* model class. This allows custom queries to be added
* to models. The filter should take an instance of the
* ORM wrapper as its first argument and return an instance
* of the ORM wrapper. Any arguments passed to this method
* after the name of the filter will be passed to the called
* filter function as arguments after the ORM class.
*/
        public function filter() {
            $args = func_get_args();
            $filter_function = array_shift($args);
            array_unshift($args, $this);
            if (method_exists($this->_class_name, $filter_function)) {
                return call_user_func_array(array($this->_class_name, $filter_function), $args);
            }
        }

        /**
* Factory method, return an instance of this
* class bound to the supplied table name.
*/
        public static function for_table($table_name) {
            self::_setup_db();
            return new self($table_name);
        }

        /**
* Method to create an instance of the model class
* associated with this wrapper and populate
* it with the supplied Idiorm instance.
*/
        protected function _create_model_instance($orm) {
            if ($orm === false) {
                return false;
            }
            $model = new $this->_class_name();
            $model->set_orm($orm);
            return $model;
        }

        /**
* Wrap Idiorm's find_one method to return
* an instance of the class associated with
* this wrapper instead of the raw ORM class.
*/
        public function find_one($id=null) {
            return $this->_create_model_instance(parent::find_one($id));
        }

        /**
* Wrap Idiorm's find_many method to return
* an array of instances of the class associated
* with this wrapper instead of the raw ORM class.
*/
        public function find_many() {
            return array_map(array($this, '_create_model_instance'), parent::find_many());
        }

        /**
* Wrap Idiorm's create method to return an
* empty instance of the class associated with
* this wrapper instead of the raw ORM class.
*/
        public function create($data=null) {
            return $this->_create_model_instance(parent::create($data));
        }
    }

    /**
* Model base class. Your model objects should extend
* this class. A minimal subclass would look like:
*
* class Widget extends Model {
* }
*
*/
    class Model {

        // Default ID column for all models. Can be overridden by adding
        // a public static _id_column property to your model classes.
        const DEFAULT_ID_COLUMN = 'id';

        // Default foreign key suffix used by relationship methods
        const DEFAULT_FOREIGN_KEY_SUFFIX = '_id';

        /**
* The ORM instance used by this model
* instance to communicate with the database.
*/
        public $orm;

        /**
* Retrieve the value of a static property on a class. If the
* class or the property does not exist, returns the default
* value supplied as the third argument (which defaults to null).
*/
        protected static function _get_static_property($class_name, $property, $default=null) {
            if (!class_exists($class_name) || !property_exists($class_name, $property)) {
                return $default;
            }
            $properties = get_class_vars($class_name);
            return $properties[$property];
        }

        /**
* Static method to get a table name given a class name.
* If the supplied class has a public static property
* named $_table, the value of this property will be
* returned. If not, the class name will be converted using
* the _class_name_to_table_name method method.
*/
        protected static function _get_table_name($class_name) {
            $specified_table_name = self::_get_static_property($class_name, '_table');
            if (is_null($specified_table_name)) {
                return self::_class_name_to_table_name($class_name);
            }
            return $specified_table_name;
        }

        /**
* Static method to convert a class name in CapWords
* to a table name in lowercase_with_underscores.
* For example, CarTyre would be converted to car_tyre.
*/
        protected static function _class_name_to_table_name($class_name) {
            return strtolower(preg_replace('/(?<=[a-z])([A-Z])/', '_$1', $class_name));
        }

        /**
* Return the ID column name to use for this class. If it is
* not set on the class, returns null.
*/
        protected static function _get_id_column_name($class_name) {
            return self::_get_static_property($class_name, '_id_column', self::DEFAULT_ID_COLUMN);
        }

        /**
* Build a foreign key based on a table name. If the first argument
* (the specified foreign key column name) is null, returns the second
* argument (the name of the table) with the default foreign key column
* suffix appended.
*/
        protected static function _build_foreign_key_name($specified_foreign_key_name, $table_name) {
            if (!is_null($specified_foreign_key_name)) {
                return $specified_foreign_key_name;
            }
            return $table_name . self::DEFAULT_FOREIGN_KEY_SUFFIX;
        }

        /**
* Factory method used to acquire instances of the given class.
* The class name should be supplied as a string, and the class
* should already have been loaded by PHP (or a suitable autoloader
* should exist). This method actually returns a wrapped ORM object
* which allows a database query to be built. The wrapped ORM object is
* responsible for returning instances of the correct class when
* its find_one or find_many methods are called.
*/
        public static function factory($class_name) {
            $table_name = self::_get_table_name($class_name);
            $wrapper = ORMWrapper::for_table($table_name);
            $wrapper->set_class_name($class_name);
            $wrapper->use_id_column(self::_get_id_column_name($class_name));
            return $wrapper;
        }

        /**
* Internal method to construct the queries for both the has_one and
* has_many methods. These two types of association are identical; the
* only difference is whether find_one or find_many is used to complete
* the method chain.
*/
        protected function _has_one_or_many($associated_class_name, $foreign_key_name=null) {
            $base_table_name = self::_get_table_name(get_class($this));
            $foreign_key_name = self::_build_foreign_key_name($foreign_key_name, $base_table_name);
            return self::factory($associated_class_name)->where($foreign_key_name, $this->id());
        }

        /**
* Helper method to manage one-to-one relations where the foreign
* key is on the associated table.
*/
        protected function has_one($associated_class_name, $foreign_key_name=null) {
            return $this->_has_one_or_many($associated_class_name, $foreign_key_name);
        }

        /**
* Helper method to manage one-to-many relations where the foreign
* key is on the associated table.
*/
        protected function has_many($associated_class_name, $foreign_key_name=null) {
            return $this->_has_one_or_many($associated_class_name, $foreign_key_name);
        }

        /**
* Helper method to manage one-to-one and one-to-many relations where
* the foreign key is on the base table.
*/
        protected function belongs_to($associated_class_name, $foreign_key_name=null) {
            $associated_table_name = self::_get_table_name($associated_class_name);
            $foreign_key_name = self::_build_foreign_key_name($foreign_key_name, $associated_table_name);
            $associated_object_id = $this->$foreign_key_name;
            return self::factory($associated_class_name)->where_id_is($associated_object_id);
        }

        /**
* Helper method to manage many-to-many relationships via an intermediate model. See
* README for a full explanation of the parameters.
*/
        protected function has_many_through($associated_class_name, $join_class_name=null, $key_to_base_table=null, $key_to_associated_table=null) {
            $base_class_name = get_class($this);

            // The class name of the join model, if not supplied, is
            // formed by concatenating the names of the base class
            // and the associated class, in alphabetical order.
            if (is_null($join_class_name)) {
                $class_names = array($base_class_name, $associated_class_name);
                sort($class_names, SORT_STRING);
                $join_class_name = join("", $class_names);
            }

            // Get table names for each class
            $base_table_name = self::_get_table_name($base_class_name);
            $associated_table_name = self::_get_table_name($associated_class_name);
            $join_table_name = self::_get_table_name($join_class_name);

            // Get ID column names
            $base_table_id_column = self::_get_id_column_name($base_class_name);
            $associated_table_id_column = self::_get_id_column_name($associated_class_name);

            // Get the column names for each side of the join table
            $key_to_base_table = self::_build_foreign_key_name($key_to_base_table, $base_table_name);
            $key_to_associated_table = self::_build_foreign_key_name($key_to_associated_table, $associated_table_name);

            return self::factory($associated_class_name)
                ->select("{$associated_table_name}.*")
                ->join($join_table_name, array("{$associated_table_name}.{$associated_table_id_column}", '=', "{$join_table_name}.{$key_to_associated_table}"))
                ->where("{$join_table_name}.{$key_to_base_table}", $this->id());
        }

        /**
* Set the wrapped ORM instance associated with this Model instance.
*/
        public function set_orm($orm) {
            $this->orm = $orm;
        }

        /**
* Magic getter method, allows $model->property access to data.
*/
        public function __get($property) {
            return $this->orm->get($property);
        }

        /**
* Magic setter method, allows $model->property = 'value' access to data.
*/
        public function __set($property, $value) {
            $this->orm->set($property, $value);
        }

        /**
* Magic isset method, allows isset($model->property) to work correctly.
*/
        public function __isset($property) {
            return $this->orm->__isset($property);
        }

        /**
* Getter method, allows $model->get('property') access to data
*/
        public function get($property) {
            return $this->orm->get($property);
        }

        /**
* Setter method, allows $model->set('property', 'value') access to data.
*/
        public function set($property, $value) {
            $this->orm->set($property, $value);
        }

        /**
* Check whether the given field has changed since the object was created or saved
*/
        public function is_dirty($property) {
            return $this->orm->is_dirty($property);
        }

        /**
* Wrapper for Idiorm's as_array method.
*/
        public function as_array() {
            $args = func_get_args();
            return call_user_func_array(array($this->orm, 'as_array'), $args);
        }

        /**
* Save the data associated with this model instance to the database.
*/
        public function save() {
            return $this->orm->save();
        }

        /**
* Delete the database row associated with this model instance.
*/
        public function delete() {
            return $this->orm->delete();
        }

        /**
* Get the database ID of this model instance.
*/
        public function id() {
            return $this->orm->id();
        }

        /**
* Hydrate this model instance with an associative array of data.
* WARNING: The keys in the array MUST match with columns in the
* corresponding database table. If any keys are supplied which
* do not match up with columns, the database will throw an error.
*/
        public function hydrate($data) {
            $this->orm->hydrate($data)->force_all_dirty();
        }
    }
Something went wrong with that request. Please try again.