PHP fORM::parseMethod方法代码示例

 /**
  * Uploads a file
  * 
  * @internal
  * 
  * @param  fActiveRecord $object            The fActiveRecord instance
  * @param  array         &$values           The current values
  * @param  array         &$old_values       The old values
  * @param  array         &$related_records  Any records related to this record
  * @param  array         &$cache            The cache array for the record
  * @param  string        $method_name       The method that was called
  * @param  array         $parameters        The parameters passed to the method
  * @return fFile  The uploaded file
  */
 public static function upload($object, &$values, &$old_values, &$related_records, &$cache, $method_name, $parameters)
 {
     $class = get_class($object);
     list($action, $column) = fORM::parseMethod($method_name);
     $existing_temp_file = FALSE;
     // Try to upload the file putting it in the temp dir incase there is a validation problem with the record
     try {
         $upload_dir = self::$file_upload_columns[$class][$column];
         $temp_dir = self::prepareTempDir($upload_dir);
         if (!fUpload::check($column)) {
             throw new fExpectedException('Please upload a file');
         }
         $uploader = self::setUpFUpload($class, $column);
         $file = $uploader->move($temp_dir, $column);
         // If there was an eror, check to see if we have an existing file
     } catch (fExpectedException $e) {
         // If there is an existing file and none was uploaded, substitute the existing file
         $existing_file = fRequest::get('existing-' . $column);
         $delete_file = fRequest::get('delete-' . $column, 'boolean');
         $no_upload = $e->getMessage() == self::compose('Please upload a file');
         if ($existing_file && $delete_file && $no_upload) {
             $file = NULL;
         } elseif ($existing_file) {
             $file_path = $upload_dir->getPath() . $existing_file;
             $file = fFilesystem::createObject($file_path);
             $current_file = $values[$column];
             // If the existing file is the same as the current file, we can just exit now
             if ($current_file && $file->getPath() == $current_file->getPath()) {
                 return;
             }
             $existing_temp_file = TRUE;
         } else {
             $file = NULL;
         }
     }
     // Assign the file
     fActiveRecord::assign($values, $old_values, $column, $file);
     // Perform the file upload inheritance
     if (!empty(self::$column_inheritence[$class][$column])) {
         foreach (self::$column_inheritence[$class][$column] as $other_column) {
             if ($file) {
                 // Image columns will only inherit if it is an fImage object
                 if (!$file instanceof fImage && isset(self::$image_upload_columns[$class][$other_column])) {
                     continue;
                 }
                 $other_upload_dir = self::$file_upload_columns[$class][$other_column];
                 $other_temp_dir = self::prepareTempDir($other_upload_dir);
                 if ($existing_temp_file) {
                     $other_file = fFilesystem::createObject($other_temp_dir->getPath() . $file->getName());
                 } else {
                     $other_file = $file->duplicate($other_temp_dir, FALSE);
                 }
             } else {
                 $other_file = $file;
             }
             fActiveRecord::assign($values, $old_values, $other_column, $other_file);
             if (!$existing_temp_file && $other_file) {
                 self::processImage($class, $other_column, $other_file);
             }
         }
     }
     // Process the file
     if (!$existing_temp_file && $file) {
         self::processImage($class, $column, $file);
     }
     return $file;
 }

 /**
  * Handles all method calls for columns, related records and hook callbacks
  * 
  * Dynamically handles `get`, `set`, `prepare`, `encode` and `inspect`
  * methods for each column in this record. Method names are in the form
  * `verbColumName()`.
  * 
  * This method also handles `associate`, `build`, `count`, `has`, and `link`
  * verbs for records in many-to-many relationships; `build`, `count`, `has`
  * and `populate` verbs for all related records in one-to-many relationships
  * and `create`, `has` and `populate` verbs for all related records in
  * one-to-one relationships, and the `create` verb for all related records
  * in many-to-one relationships.
  * 
  * Method callbacks registered through fORM::registerActiveRecordMethod()
  * will be delegated via this method.
  * 
  * @param  string $method_name  The name of the method called
  * @param  array  $parameters   The parameters passed
  * @return mixed  The value returned by the method called
  */
 public function __call($method_name, $parameters)
 {
     $class = get_class($this);
     if (!isset(self::$callback_cache[$class][$method_name])) {
         if (!isset(self::$callback_cache[$class])) {
             self::$callback_cache[$class] = array();
         }
         $callback = fORM::getActiveRecordMethod($class, $method_name);
         self::$callback_cache[$class][$method_name] = $callback ? $callback : FALSE;
     }
     if ($callback = self::$callback_cache[$class][$method_name]) {
         return call_user_func_array($callback, array($this, &$this->values, &$this->old_values, &$this->related_records, &$this->cache, $method_name, $parameters));
     }
     if (!isset(self::$method_name_cache[$method_name])) {
         list($action, $subject) = fORM::parseMethod($method_name);
         if (in_array($action, array('get', 'encode', 'prepare', 'inspect', 'set'))) {
             $subject = fGrammar::underscorize($subject);
         } else {
             if (in_array($action, array('build', 'count', 'inject', 'link', 'list', 'tally'))) {
                 $subject = fGrammar::singularize($subject);
             }
             $subject = fORM::getRelatedClass($class, $subject);
         }
         self::$method_name_cache[$method_name] = array('action' => $action, 'subject' => $subject);
     } else {
         $action = self::$method_name_cache[$method_name]['action'];
         $subject = self::$method_name_cache[$method_name]['subject'];
     }
     switch ($action) {
         // Value methods
         case 'get':
             return $this->get($subject);
         case 'encode':
             if (isset($parameters[0])) {
                 return $this->encode($subject, $parameters[0]);
             }
             return $this->encode($subject);
         case 'prepare':
             if (isset($parameters[0])) {
                 return $this->prepare($subject, $parameters[0]);
             }
             return $this->prepare($subject);
         case 'inspect':
             if (isset($parameters[0])) {
                 return $this->inspect($subject, $parameters[0]);
             }
             return $this->inspect($subject);
         case 'set':
             if (sizeof($parameters) < 1) {
                 throw new fProgrammerException('The method, %s(), requires at least one parameter', $method_name);
             }
             return $this->set($subject, $parameters[0]);
             // Related data methods
         // Related data methods
         case 'associate':
             if (sizeof($parameters) < 1) {
                 throw new fProgrammerException('The method, %s(), requires at least one parameter', $method_name);
             }
             $records = $parameters[0];
             $route = isset($parameters[1]) ? $parameters[1] : NULL;
             list($subject, $route, $plural) = self::determineSubject($class, $subject, $route);
             if ($plural) {
                 fORMRelated::associateRecords($class, $this->related_records, $subject, $records, $route);
             } else {
                 fORMRelated::associateRecord($class, $this->related_records, $subject, $records, $route);
             }
             return $this;
         case 'build':
             if (isset($parameters[0])) {
                 return fORMRelated::buildRecords($class, $this->values, $this->related_records, $subject, $parameters[0]);
             }
             return fORMRelated::buildRecords($class, $this->values, $this->related_records, $subject);
         case 'count':
             if (isset($parameters[0])) {
                 return fORMRelated::countRecords($class, $this->values, $this->related_records, $subject, $parameters[0]);
             }
             return fORMRelated::countRecords($class, $this->values, $this->related_records, $subject);
         case 'create':
             if (isset($parameters[0])) {
//.........这里部分代码省略.........

 /**
  * Sets the money column and then tries to objectify it with an related currency column
  * 
  * @internal
  * 
  * @param  fActiveRecord $object            The fActiveRecord instance
  * @param  array         &$values           The current values
  * @param  array         &$old_values       The old values
  * @param  array         &$related_records  Any records related to this record
  * @param  array         &$cache            The cache array for the record
  * @param  string        $method_name       The method that was called
  * @param  array         $parameters        The parameters passed to the method
  * @return fActiveRecord  The record object, to allow for method chaining
  */
 public static function setMoneyColumn($object, &$values, &$old_values, &$related_records, &$cache, $method_name, $parameters)
 {
     list($action, $column) = fORM::parseMethod($method_name);
     $class = get_class($object);
     if (count($parameters) < 1) {
         throw new fProgrammerException('The method, %s(), requires at least one parameter', $method_name);
     }
     $value = $parameters[0];
     fActiveRecord::assign($values, $old_values, $column, $value);
     $currency_column = self::$money_columns[$class][$column];
     // See if we can make an fMoney object out of the values
     self::objectifyMoneyWithCurrency($values, $old_values, $column, $currency_column);
     if ($currency_column) {
         if ($value instanceof fMoney) {
             fActiveRecord::assign($values, $old_values, $currency_column, $value->getCurrency());
         }
     }
     return $object;
 }

 /**
  * Allows for preloading various data related to the record set in single database queries, as opposed to one query per record
  * 
  * This method will handle methods in the format `verbRelatedRecords()` for
  * the verbs `build`, `prebuild`, `precount` and `precreate`.
  * 
  * `build` calls `create{RelatedClass}()` on each record in the set and
  * returns the result as a new record set. The relationship route can be
  * passed as an optional parameter.
  * 
  * `prebuild` builds *-to-many record sets for all records in the record
  * set. `precount` will count records in *-to-many record sets for every
  * record in the record set. `precreate` will create a *-to-one record
  * for every record in the record set.
  *  
  * @param  string $method_name  The name of the method called
  * @param  string $parameters   The parameters passed
  * @return void
  */
 public function __call($method_name, $parameters)
 {
     if ($callback = fORM::getRecordSetMethod($method_name)) {
         return call_user_func_array($callback, array($this, $this->class, &$this->records, $method_name, $parameters));
     }
     list($action, $subject) = fORM::parseMethod($method_name);
     $route = $parameters ? $parameters[0] : NULL;
     // This check prevents fGrammar exceptions being thrown when an unknown method is called
     if (in_array($action, array('build', 'prebuild', 'precount', 'precreate'))) {
         $related_class = fGrammar::singularize($subject);
         $related_class_sans_namespace = $related_class;
         if (!is_array($this->class)) {
             $related_class = fORM::getRelatedClass($this->class, $related_class);
         }
     }
     switch ($action) {
         case 'build':
             if ($route) {
                 $this->precreate($related_class, $route);
                 return $this->buildFromCall('create' . $related_class_sans_namespace, $route);
             }
             $this->precreate($related_class);
             return $this->buildFromCall('create' . $related_class_sans_namespace);
         case 'prebuild':
             return $this->prebuild($related_class, $route);
         case 'precount':
             return $this->precount($related_class, $route);
         case 'precreate':
             return $this->precreate($related_class, $route);
     }
     throw new fProgrammerException('Unknown method, %s(), called', $method_name);
 }

 /**
  * Sets the timezone column and then tries to objectify the related timestamp column
  *
  * @internal
  *
  * @param  fActiveRecord $object            The fActiveRecord instance
  * @param  array         &$values           The current values
  * @param  array         &$old_values       The old values
  * @param  array         &$related_records  Any records related to this record
  * @param  array         &$cache            The cache array for the record
  * @param  string        $method_name       The method that was called
  * @param  array         $parameters        The parameters passed to the method
  * @return fActiveRecord  The record object, to allow for method chaining
  */
 public static function setTimezoneColumn($object, &$values, &$old_values, &$related_records, &$cache, $method_name, $parameters)
 {
     list($action, $subject) = fORM::parseMethod($method_name);
     $column = fGrammar::underscorize($subject);
     $class = get_class($object);
     if (!isset($parameters[0])) {
         throw new fProgrammerException('The method, %s(), requires at least one parameter', $method_name);
     }
     fActiveRecord::assign($values, $old_values, $column, $parameters[0]);
     // See if we can make an fTimestamp object out of the values
     self::objectifyTimestampWithTimezone($values, $old_values, self::$timezone_columns[$class][$column], $column);
     return $object;
 }

 /**
  * Returns the metadata about a column including features added by this class
  *
  * @internal
  *
  * @param  fActiveRecord $object            The fActiveRecord instance
  * @param  array         &$values           The current values
  * @param  array         &$old_values       The old values
  * @param  array         &$related_records  Any records related to this record
  * @param  array         &$cache            The cache array for the record
  * @param  string        $method_name       The method that was called
  * @param  array         $parameters        The parameters passed to the method
  * @return mixed  The metadata array or element specified
  */
 public static function inspect($object, &$values, &$old_values, &$related_records, &$cache, $method_name, $parameters)
 {
     list($action, $subject) = fORM::parseMethod($method_name);
     $column = fGrammar::underscorize($subject);
     $class = get_class($object);
     $table = fORM::tablize($class);
     $db = fORMDatabase::retrieve($class, 'read');
     $schema = fORMSchema::retrieve($class);
     $info = $schema->getColumnInfo($table, $column);
     $element = isset($parameters[0]) ? $parameters[0] : NULL;
     $other_columns = self::$ordering_columns[$class][$column];
     // Retrieve the current max ordering index from the database
     $params = array("SELECT MAX(%r) FROM %r", $column, $table);
     if ($other_columns) {
         $params[0] .= " WHERE ";
         $params = self::addOtherFieldsWhereParams($schema, $params, $table, $other_columns, $values);
     }
     $max_value = (int) call_user_func_array($db->translatedQuery, $params)->fetchScalar();
     // If this is a new record, or in a new set, we need one more space in the ordering index
     if (self::isInNewSet($column, $other_columns, $values, $old_values)) {
         $max_value += 1;
     }
     $info['max_ordering_value'] = $max_value;
     $info['feature'] = 'ordering';
     fORM::callInspectCallbacks($class, $column, $info);
     if ($element) {
         return isset($info[$element]) ? $info[$element] : NULL;
     }
     return $info;
 }

 /**
  * Returns the metadata about a column including features added by this class
  * 
  * @internal
  * 
  * @param  fActiveRecord $object            The fActiveRecord instance 
  * @param  array         &$values           The current values 
  * @param  array         &$old_values       The old values 
  * @param  array         &$related_records  Any records related to this record 
  * @param  array         &$cache            The cache array for the record 
  * @param  string        $method_name       The method that was called 
  * @param  array         $parameters        The parameters passed to the method 
  * @return mixed  The metadata array or element specified 
  */
 public static function inspect($object, &$values, &$old_values, &$related_records, &$cache, $method_name, $parameters)
 {
     list($action, $column) = fORM::parseMethod($method_name);
     $class = get_class($object);
     $table = fORM::tablize($class);
     $info = fORMSchema::retrieve()->getColumnInfo($table, $column);
     $element = isset($parameters[0]) ? $parameters[0] : NULL;
     $column = self::$ordering_columns[$class]['column'];
     $other_columns = self::$ordering_columns[$class]['other_columns'];
     // Retrieve the current max ordering index from the database
     $sql = "SELECT max(" . $column . ") FROM " . $table;
     if ($other_columns) {
         $sql .= " WHERE " . self::createOtherFieldsWhereClause($table, $other_columns, $values);
     }
     $max_value = (int) fORMDatabase::retrieve()->translatedQuery($sql)->fetchScalar();
     // If this is a new record, or in a new set, we need one more space in the ordering index
     if (self::isInNewSet($column, $other_columns, $values, $old_values)) {
         $max_value += 1;
     }
     $info['max_ordering_value'] = $max_value;
     $info['feature'] = 'ordering';
     fORM::callInspectCallbacks($class, $column, $info);
     if ($element) {
         return isset($info[$element]) ? $info[$element] : NULL;
     }
     return $info;
 }

 /**
  * Sets the value for an email column, trimming the value if it is a valid email
  *
  * @internal
  *
  * @param  fActiveRecord $object            The fActiveRecord instance
  * @param  array         &$values           The current values
  * @param  array         &$old_values       The old values
  * @param  array         &$related_records  Any records related to this record
  * @param  array         &$cache            The cache array for the record
  * @param  string        $method_name       The method that was called
  * @param  array         $parameters        The parameters passed to the method
  * @return fActiveRecord  The record object, to allow for method chaining
  */
 public static function setEmailColumn($object, &$values, &$old_values, &$related_records, &$cache, $method_name, $parameters)
 {
     list($action, $subject) = fORM::parseMethod($method_name);
     $column = fGrammar::underscorize($subject);
     $class = get_class($object);
     if (count($parameters) < 1) {
         throw new fProgrammerException('The method, %s(), requires at least one parameter', $method_name);
     }
     $email = $parameters[0];
     if (preg_match('#^\\s*[a-z0-9\\.\'_\\-\\+]+@(?:[a-z0-9\\-]+\\.)+[a-z]{2,}\\s*$#iD', $email)) {
         $email = trim($email);
     }
     if ($email === '') {
         $email = NULL;
     }
     fActiveRecord::assign($values, $old_values, $column, $email);
     return $object;
 }

 /**
  * Handles all method calls for columns, related records and hook callbacks
  * 
  * Dynamically handles `get`, `set`, `prepare`, `encode` and `inspect`
  * methods for each column in this record. Method names are in the form
  * `verbColumName()`.
  * 
  * This method also handles `associate`, `build`, `count` and `link` verbs
  * for records in many-to-many relationships; `build`, `count` and
  * `populate` verbs for all related records in one-to-many relationships
  * and the `create` verb for all related records in *-to-one relationships.
  * 
  * Method callbacks registered through fORM::registerActiveRecordMethod()
  * will be delegated via this method.
  * 
  * @param  string $method_name  The name of the method called
  * @param  array  $parameters   The parameters passed
  * @return mixed  The value returned by the method called
  */
 public function __call($method_name, $parameters)
 {
     $class = get_class($this);
     if (!isset(self::$callback_cache[$class][$method_name])) {
         if (!isset(self::$callback_cache[$class])) {
             self::$callback_cache[$class] = array();
         }
         $callback = fORM::getActiveRecordMethod($class, $method_name);
         self::$callback_cache[$class][$method_name] = $callback ? $callback : FALSE;
     }
     if ($callback = self::$callback_cache[$class][$method_name]) {
         return call_user_func_array($callback, array($this, &$this->values, &$this->old_values, &$this->related_records, &$this->cache, $method_name, $parameters));
     }
     if (!isset(self::$method_name_cache[$method_name])) {
         list($action, $subject) = fORM::parseMethod($method_name);
         self::$method_name_cache[$method_name] = array('action' => $action, 'subject' => $subject);
     } else {
         $action = self::$method_name_cache[$method_name]['action'];
         $subject = self::$method_name_cache[$method_name]['subject'];
     }
     switch ($action) {
         // Value methods
         case 'get':
             return $this->get($subject);
         case 'encode':
             if (isset($parameters[0])) {
                 return $this->encode($subject, $parameters[0]);
             }
             return $this->encode($subject);
         case 'prepare':
             if (isset($parameters[0])) {
                 return $this->prepare($subject, $parameters[0]);
             }
             return $this->prepare($subject);
         case 'inspect':
             if (isset($parameters[0])) {
                 return $this->inspect($subject, $parameters[0]);
             }
             return $this->inspect($subject);
         case 'set':
             if (sizeof($parameters) < 1) {
                 throw new fProgrammerException('The method, %s(), requires at least one parameter', $method_name);
             }
             return $this->set($subject, $parameters[0]);
             // Related data methods
         // Related data methods
         case 'associate':
             if (sizeof($parameters) < 1) {
                 throw new fProgrammerException('The method, %s(), requires at least one parameter', $method_name);
             }
             $table = fORM::tablize($class);
             $records = $parameters[0];
             $route = isset($parameters[1]) ? $parameters[1] : NULL;
             $plural = FALSE;
             // one-to-many relationships need to use plural forms
             if (in_array($subject, fORMSchema::retrieve()->getTables())) {
                 if (fORMSchema::isOneToOne($table, $subject, $route)) {
                     throw new fProgrammerException('The table %1$s is not in a %2$srelationship with the table %3$s', $table, '*-to-many ', $subject);
                 }
                 $subject = fGrammar::singularize($subject);
                 $plural = TRUE;
             }
             $subject = fGrammar::camelize($subject, TRUE);
             // This handles one-to-many and many-to-many relationships
             if ($plural) {
                 return fORMRelated::associateRecords($class, $this->related_records, $subject, $records, $route);
             }
             // This handles one-to-one relationships
             return fORMRelated::associateRecord($class, $this->related_records, $subject, $records, $route);
         case 'build':
             $subject = fGrammar::singularize($subject);
             $subject = fGrammar::camelize($subject, TRUE);
             if (isset($parameters[0])) {
                 return fORMRelated::buildRecords($class, $this->values, $this->related_records, $subject, $parameters[0]);
             }
             return fORMRelated::buildRecords($class, $this->values, $this->related_records, $subject);
         case 'count':
             $subject = fGrammar::singularize($subject);
             $subject = fGrammar::camelize($subject, TRUE);
             if (isset($parameters[0])) {
                 return fORMRelated::countRecords($class, $this->values, $this->related_records, $subject, $parameters[0]);
//.........这里部分代码省略.........

 /**
  * Prepares a number column by calling fNumber::format()
  * 
  * @internal
  * 
  * @param  fActiveRecord $object            The fActiveRecord instance
  * @param  array         &$values           The current values
  * @param  array         &$old_values       The old values
  * @param  array         &$related_records  Any records related to this record
  * @param  array         &$cache            The cache array for the record
  * @param  string        $method_name       The method that was called
  * @param  array         $parameters        The parameters passed to the method
  * @return string  The formatted link
  */
 public static function prepareNumberColumn($object, &$values, &$old_values, &$related_records, &$cache, $method_name, $parameters)
 {
     list($action, $column) = fORM::parseMethod($method_name);
     $class = get_class($object);
     $column_info = fORMSchema::retrieve()->getColumnInfo(fORM::tablize($class), $column);
     $value = $values[$column];
     if ($value instanceof fNumber) {
         if ($column_info['type'] == 'float') {
             $decimal_places = isset($parameters[0]) ? (int) $parameters[0] : $column_info['decimal_places'];
             if ($decimal_places !== NULL) {
                 $value = $value->trunc($decimal_places)->format();
             } else {
                 $value = $value->format();
             }
         } else {
             $value = $value->format();
         }
     }
     return fHTML::prepare($value);
 }