Update to Drupal 8.0.0 beta 14. For more information, see https://drupal.org/node/2544542
This commit is contained in:
Pantheon Automation
Greg Anderson
parent
3b2511d96d
commit
81ccda77eb
2155 changed files with 54307 additions and 46870 deletions
409
core/lib/Drupal/Component/Assertion/Inspector.php
Normal file
409
core/lib/Drupal/Component/Assertion/Inspector.php
Normal file
|
|
@ -0,0 +1,409 @@
|
|||
<?php
|
||||
/**
|
||||
* @file
|
||||
* Contains \Drupal\Component\Assertion\Inspector.
|
||||
*/
|
||||
|
||||
namespace Drupal\Component\Assertion;
|
||||
|
||||
use Traversable;
|
||||
|
||||
/**
|
||||
* Generic inspections for the assert() statement.
|
||||
*
|
||||
* This is a static function collection for inspecting variable contents. All
|
||||
* functions in this collection check a variable against an assertion about its
|
||||
* structure.
|
||||
*
|
||||
* Example call:
|
||||
* @code
|
||||
* assert('Drupal\\Component\\Assertion\\Inspector::assertAllStrings($array)');
|
||||
* @endcode
|
||||
*
|
||||
* @ingroup php_assert
|
||||
*/
|
||||
class Inspector {
|
||||
|
||||
/**
|
||||
* Asserts argument can be traversed with foreach.
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed with foreach.
|
||||
*/
|
||||
public static function assertTraversable($traversable) {
|
||||
return is_array($traversable) || $traversable instanceof Traversable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts callback returns TRUE for each member of a traversable.
|
||||
*
|
||||
* This is less memory intensive than using array_filter() to build a second
|
||||
* array and then comparing the arrays. Many of the other functions in this
|
||||
* collection alias this function passing a specific callback to make the
|
||||
* code more readable.
|
||||
*
|
||||
* @param callable $callable
|
||||
* Callback function.
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and $callable returns TRUE on
|
||||
* all members.
|
||||
*
|
||||
* @see http://php.net/manual/language.types.callable.php
|
||||
*/
|
||||
public static function assertAll(callable $callable, $traversable) {
|
||||
if (static::assertTraversable($traversable)) {
|
||||
foreach ($traversable as $member) {
|
||||
if (!$callable($member)) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that all members are strings.
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members are strings.
|
||||
*/
|
||||
public static function assertAllStrings($traversable) {
|
||||
return static::assertAll('is_string', $traversable);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts all members are strings or objects with magic __toString() method.
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members are strings or
|
||||
* objects with __toString().
|
||||
*/
|
||||
public static function assertAllStringable($traversable) {
|
||||
if (static::assertTraversable($traversable)) {
|
||||
foreach ($traversable as $member) {
|
||||
if (!(is_string($member) || (is_object($member) && method_exists($member, '__toString')))) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that all members are arrays.
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members are arrays.
|
||||
*/
|
||||
public static function assertAllArrays($traversable) {
|
||||
return static::assertAll('is_array', $traversable);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that the array is strict.
|
||||
*
|
||||
* What PHP calls arrays are more formally called maps in most other
|
||||
* programming languages. A map is a datatype that associates values to keys.
|
||||
* The term 'strict array' here refers to a 0-indexed array in the classic
|
||||
* sense found in programming languages other than PHP.
|
||||
*
|
||||
* @param mixed $array
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable is a 0-indexed array.
|
||||
*
|
||||
* @see http://php.net/manual/language.types.array.php
|
||||
*/
|
||||
public static function assertStrictArray($array) {
|
||||
if (!is_array($array)) {
|
||||
return FALSE;
|
||||
}
|
||||
$i = 0;
|
||||
|
||||
foreach (array_keys($array) as $key) {
|
||||
if ($i !== $key) {
|
||||
return FALSE;
|
||||
}
|
||||
$i++;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts all members are strict arrays.
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members are strict arrays.
|
||||
*
|
||||
* @see ::assertStrictArray
|
||||
*/
|
||||
public static function assertAllStrictArrays($traversable) {
|
||||
return static::assertAll([__CLASS__, 'assertStrictArray'], $traversable);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts all given keys exist in every member array.
|
||||
*
|
||||
* Drupal has several data structure arrays that require certain keys be set.
|
||||
* You can overload this function to specify a list of required keys. All
|
||||
* of the keys must be set for this method to return TRUE.
|
||||
*
|
||||
* As an example, this assertion tests for the keys of a theme registry.
|
||||
*
|
||||
* @code
|
||||
* assert('Drupal\\Component\\Assertion\\Inspector::assertAllHaveKey(
|
||||
* $arrayToTest, "type", "theme path", "function", "template", "variables", "render element", "preprocess functions")');
|
||||
* @endcode
|
||||
*
|
||||
* Note: If a method requires certain keys to be present it will usually be
|
||||
* specific about the data types for the values of those keys. Therefore it
|
||||
* will be best to write a specific test for it. Such tests are either bound
|
||||
* to the object that uses them, or are collected into one assertion set for
|
||||
* the package.
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
* @param string ...
|
||||
* Keys to be searched for.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members have all keys.
|
||||
*/
|
||||
public static function assertAllHaveKey() {
|
||||
$args = func_get_args();
|
||||
$traversable = array_shift($args);
|
||||
|
||||
if (static::assertTraversable($traversable)) {
|
||||
foreach ($traversable as $member) {
|
||||
foreach ($args as $key) {
|
||||
if (!array_key_exists($key, $member)) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that all members are integer values.
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members are integers.
|
||||
*/
|
||||
public static function assertAllIntegers($traversable) {
|
||||
return static::assertAll('is_int', $traversable);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that all members are float values.
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members are floating point
|
||||
* numbers.
|
||||
*/
|
||||
public static function assertAllFloat($traversable) {
|
||||
return static::assertAll('is_float', $traversable);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that all members are callable.
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members are callable.
|
||||
*/
|
||||
public static function assertAllCallable($traversable) {
|
||||
return static::assertAll('is_callable', $traversable);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that all members are not empty.
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members not empty.
|
||||
*/
|
||||
public static function assertAllNotEmpty($traversable) {
|
||||
if (static::assertTraversable($traversable)) {
|
||||
foreach ($traversable as $member) {
|
||||
if (empty($member)) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts all members are numeric data types or strings castable to such.
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members are numeric.
|
||||
*/
|
||||
public static function assertAllNumeric($traversable) {
|
||||
return static::assertAll('is_numeric', $traversable);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that all members are strings that contain the specified string.
|
||||
*
|
||||
* This runs faster than the regular expression equivalent.
|
||||
*
|
||||
* @param string $pattern
|
||||
* The needle to find.
|
||||
* @param mixed $traversable
|
||||
* Variable to examine.
|
||||
* @param bool $case_sensitive
|
||||
* TRUE to use strstr(), FALSE to use stristr() which is case insensitive.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members are strings
|
||||
* containing $pattern.
|
||||
*/
|
||||
public static function assertAllMatch($pattern, $traversable, $case_sensitive = FALSE) {
|
||||
if (static::assertTraversable($traversable)) {
|
||||
if ($case_sensitive) {
|
||||
foreach ($traversable as $member) {
|
||||
if (!(is_string($member) && strstr($member, $pattern))) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
foreach ($traversable as $member) {
|
||||
if (!(is_string($member) && stristr($member, $pattern))) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Asserts that all members are strings matching a regular expression.
|
||||
*
|
||||
* @param string $pattern
|
||||
* Regular expression string to find.
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members are strings
|
||||
* matching $pattern.
|
||||
*/
|
||||
public static function assertAllRegularExpressionMatch($pattern, $traversable) {
|
||||
if (static::assertTraversable($traversable)) {
|
||||
foreach ($traversable as $member) {
|
||||
if (!is_string($member)) {
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (!preg_match($pattern, $member)) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that all members are objects.
|
||||
*
|
||||
* When testing if a collection is composed of objects those objects should
|
||||
* be given a common interface to implement and the test should be written to
|
||||
* search for just that interface. While this method will allow tests for
|
||||
* just object status or for multiple classes and interfaces this was done to
|
||||
* allow tests to be written for existing code without altering it. Only use
|
||||
* this method in that manner when testing code from third party vendors.
|
||||
*
|
||||
* Here are some examples:
|
||||
* @code
|
||||
* // Just test all are objects, like a cache.
|
||||
* assert('Drupal\\Component\\Assertion\\Inspector::assertAllObjects(
|
||||
* $collection');
|
||||
*
|
||||
* // Test if traversable objects (arrays won't pass this)
|
||||
* assert('Drupal\\Component\\Assertion\\Inspector::assertAllObjects(
|
||||
* $collection', \'\\Traversable\');
|
||||
*
|
||||
* // Test for the Foo class or Bar\None interface
|
||||
* assert('Drupal\\Component\\Assertion\\Inspector::assertAllObjects(
|
||||
* $collection', \'\\Foo\', \'\\Bar\\None\'');
|
||||
* @endcode
|
||||
*
|
||||
* @param mixed $traversable
|
||||
* Variable to be examined.
|
||||
* @param string ...
|
||||
* Classes and interfaces to test objects against.
|
||||
*
|
||||
* @return bool
|
||||
* TRUE if $traversable can be traversed and all members are objects with
|
||||
* at least one of the listed classes or interfaces.
|
||||
*/
|
||||
public static function assertAllObjects() {
|
||||
$args = func_get_args();
|
||||
$traversable = array_shift($args);
|
||||
|
||||
if (static::assertTraversable($traversable)) {
|
||||
foreach ($traversable as $member) {
|
||||
if (count($args) > 0) {
|
||||
foreach ($args as $instance) {
|
||||
if ($member instanceof $instance) {
|
||||
// We're continuing to the next member on the outer loop.
|
||||
// @see http://php.net/continue
|
||||
continue 2;
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
elseif (!is_object($member)) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
}
|
||||
Reference in a new issue