PHP Object::combined_static方法代码示例

 public function testCombinedStatic()
 {
     // test basic operation
     $this->assertEquals(array('test_1', 'test_2', 'test_3'), Object::combined_static('ObjectStaticTest_Combined3', 'first'));
     // test that null values are ignored, but values on either side are still merged
     $this->assertEquals(array('test_1', 'test_3'), Object::combined_static('ObjectStaticTest_Combined3', 'second'));
     // test the $ceiling param
     $this->assertEquals(array('test_2', 'test_3'), Object::combined_static('ObjectStaticTest_Combined3', 'first', 'ObjectStaticTest_Combined2'));
 }

	/**
	 * Since DataObjectRetroactiveCleanerTask can be destructive,
	 * make sure that only admins can run it.
	 */
	public function testAccessRestrictionWithNonAdminMember() {
		$devServers = Object::combined_static('Director', 'dev_servers');
		Director::set_dev_servers(array('example.com'));
		$response = $this->get("dev/tasks/DataObjectRetroactiveCleanerTask");
		
		$selector = 'form[action="Security/LoginForm"]';
		$this->assertTrue((bool)$this->cssParser()->getBySelector($selector),
			'Non admin members can run DataObjectRetroactiveCleanerTask.');
		
		Director::set_dev_servers($devServers);
	}

 /**
  * Return a list of all available keywords in the format 
  * 
  * array(
  *	'keyword' => 'A description'
  * )
  *
  * @return array
  */
 public function getAvailableKeywords()
 {
     if (!$this->availableKeywords) {
         $objectFields = Object::combined_static($this->class, 'db');
         // $objectFields = array_combine(array_keys($objectFields), array_keys($objectFields));
         $objectFields['Created'] = 'Created';
         $objectFields['LastEdited'] = 'LastEdited';
         $this->availableKeywords = array();
         foreach ($objectFields as $key => $value) {
             $this->availableKeywords[$key] = array('short' => $key, 'long' => $key);
         }
     }
     return $this->availableKeywords;
 }

	/**
	 * Get all updatable relations from $this->owner.
	 * 
	 * @return array
	 */
	protected function updatableRelations() {
		$updatableRelations = array();
		foreach (array_merge($this->owner->has_many(), $this->getExtensionComponents('has_many')) as
				$hasManyRelation => $hasManyClass) {
			$hasOneOnVersioning = (array)Object::combined_static($hasManyClass, 'has_one_on_versioning');
			foreach ($hasOneOnVersioning as $onUpdateRelation => $process) {
				$hasOneClass = singleton($hasManyClass)->has_one($onUpdateRelation);
				if (in_array($hasOneClass, ClassInfo::ancestry($this->owner->ClassName)) && $process) {
					$updatableRelations[$hasManyRelation] = array(
						$hasManyClass,
						$onUpdateRelation
					);
				}
			}
		}
		return $updatableRelations;
	}

 public function __construct($name, $title = null, $options = array())
 {
     parent::__construct($name, $title);
     $defaults = Object::combined_static($this->class, 'default_options', 'ItemSetField');
     $this->options = array_merge($defaults, $options ? $options : array());
 }

 /**
  * Get a unified array of allowed actions on this controller (if such data is available) from both the controller
  * ancestry and any extensions.
  *
  * @return array|null
  */
 public function allowedActions()
 {
     $actions = Object::combined_static(get_class($this), 'allowed_actions', 'RequestHandler');
     foreach ($this->extension_instances as $extension) {
         if ($extensionActions = Object::get_static(get_class($extension), 'allowed_actions')) {
             $actions = array_merge($actions, $extensionActions);
         }
     }
     if ($actions) {
         // convert all keys and values to lowercase to
         // allow for easier comparison, unless it is a permission code
         $actions = array_change_key_case($actions, CASE_LOWER);
         foreach ($actions as $key => $value) {
             if (is_numeric($key)) {
                 $actions[$key] = strtolower($value);
             }
         }
         return $actions;
     }
 }

 /**
  * Builds out the metadata for the class attribute of the file input tag. This
  * is later parsed by the jQuery metadata plugin.
  *
  * @return string
  */
 public function Metadata()
 {
     $ret = array();
     $vars = Object::combined_static(get_class($this), "defaults");
     foreach ($vars as $setting => $value) {
         $ret[] = "{$setting} : '" . $this->getSetting($setting) . "'";
     }
     $data = implode(",", $ret);
     if (!empty($this->extraParams)) {
         $data .= ", scriptData : { ";
         $extras = array();
         foreach ($this->extraParams as $key => $val) {
             $extras[] = "'{$key}' : '{$val}'";
         }
         $params = implode(",", $extras);
         $data .= $params . "}";
     }
     return $data;
 }

 /**
  * Check that the given action is allowed to be called from a URL.
  * It will interrogate {@link self::$allowed_actions} to determine this.
  */
 function checkAccessAction($action)
 {
     $action = strtolower($action);
     $allowedActions = Object::combined_static(get_class($this), 'allowed_actions');
     $newAllowedActions = array();
     // merge in any $allowed_actions from extensions
     if ($this->extension_instances) {
         foreach ($this->extension_instances as $extension) {
             if ($extAccess = $extension->stat('allowed_actions')) {
                 $allowedActions = array_merge($allowedActions, $extAccess);
             }
         }
     }
     if ($action == 'index') {
         return true;
     }
     if ($allowedActions) {
         foreach ($allowedActions as $key => $value) {
             $newAllowedActions[strtolower($key)] = strtolower($value);
         }
         $allowedActions = $newAllowedActions;
         if (isset($allowedActions[$action])) {
             $test = $allowedActions[$action];
             // PHP can be loose about typing; let's give people a break if true becomes 1 or '1'
             if ($test === true || $test === 1 || $test === '1') {
                 return true;
             } elseif (substr($test, 0, 2) == '->') {
                 return $this->{substr($test, 2)}();
             } elseif (Permission::check($test)) {
                 return true;
             }
         } elseif (($key = array_search($action, $allowedActions)) !== false && is_numeric($key)) {
             return true;
         }
     }
     if ($allowedActions === null || !$this->uninherited('allowed_actions')) {
         // If no allowed_actions are provided, then we should only let through actions that aren't handled by magic methods
         // we test this by calling the unmagic method_exists and comparing it to the magic $this->hasMethod().  This will
         // still let through actions that are handled by templates.
         return method_exists($this, $action) || !$this->hasMethod($action);
     }
     return false;
 }

 /**
  * Return the "casting helper" (a piece of PHP code that when evaluated creates a casted value object) for a field
  * on this object. MODIFIED TO LEAVE FAILOVER ALONE (so it doesn't have to inherit Object).
  *
  * @param string $field
  * @return string
  */
 public function castingHelper($field)
 {
     if ($this->hasMethod('db') && ($fieldSpec = $this->db($field))) {
         return $fieldSpec;
     }
     $specs = Object::combined_static(get_class($this), 'casting');
     if (isset($specs[$field])) {
         return $specs[$field];
     }
     //if($this->failover) return $this->failover->castingHelper($field);
 }

 /**
  * Gets the class of a one-to-many relationship. If no $component is specified then an array of all the one-to-many
  * relationships and their classes will be returned.
  *
  * @param string $component Name of component
  * @param bool $classOnly If this is TRUE, than any has_many relationships in the form "ClassName.Field" will have
  *        the field data stripped off. It defaults to TRUE.
  * @return string|array
  */
 public function has_many($component = null, $classOnly = true)
 {
     $hasMany = Object::combined_static($this->class, 'has_many', 'DataObject');
     if ($component) {
         if ($hasMany && array_key_exists($component, $hasMany)) {
             $hasMany = $hasMany[$component];
         } else {
             return false;
         }
     }
     if ($hasMany && $classOnly) {
         return preg_replace('/(.+)?\\..+/', '$1', $hasMany);
     } else {
         return $hasMany ? $hasMany : array();
     }
 }

	/**
	 * Probe the given relation, it is necessary to find out
	 * which relations on $class which links back to the given
	 * $ownerRelationName, for each match self::handleRelation()
	 * is called to have it handled.
	 * 
	 * @param string $ownerRelationName The name of the current
	 * relation on the owner.
	 * @param string $class The class for $ownerRelationName.
	 */
	public function probeRelationClass($ownerRelationName, $class) {
		$ancestry = ClassInfo::ancestry($this->object->ClassName);
		foreach ((array)Object::combined_static($class, 'has_one') as $relationName => $relationClass) {
			if (in_array($relationClass, $ancestry))
				$this->handleRelation($ownerRelationName, $class, $relationName);
		}
	}

 public function __construct()
 {
     $this->options = Object::combined_static(get_class($this), 'default_options');
 }