opdavies/drupalcampbristol
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update to drupal 8.0.0-rc1. For more information, see https://www.drupal.org/node/2582663

Browse source
This commit is contained in:
Greg Anderson 2015-10-08 11:40:12 -07:00
parent eb34d130a8
commit f32e58e4b1
8476 changed files with 211648 additions and 170042 deletions
Download patch file Download diff file Expand all files Collapse all files

37
vendor/doctrine/common/lib/Doctrine/Common/Reflection/ClassFinderInterface.php vendored Normal file
View file

@ -0,0 +1,37 @@
<?php
/*
* 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.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace Doctrine\Common\Reflection;
/**
* Finds a class in a PSR-0 structure.
*
* @author Karoly Negyesi <karoly@negyesi.net>
*/
interface ClassFinderInterface
{
/**
* Finds a class.
*
* @param string $class The name of the class.
*
* @return string|null The name of the class or NULL if not found.
*/
public function findFile($class);
}

79
vendor/doctrine/common/lib/Doctrine/Common/Reflection/Psr0FindFile.php vendored Normal file
View file

@ -0,0 +1,79 @@
<?php
/*
* 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.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace Doctrine\Common\Reflection;
/**
* Finds a class in a PSR-0 structure.
*
* @author Karoly Negyesi <karoly@negyesi.net>
*/
class Psr0FindFile implements ClassFinderInterface
{
/**
* The PSR-0 prefixes.
*
* @var array
*/
protected $prefixes;
/**
* @param array $prefixes An array of prefixes. Each key is a PHP namespace and each value is
* a list of directories.
*/
public function __construct($prefixes)
{
$this->prefixes = $prefixes;
}
/**
* {@inheritDoc}
*/
public function findFile($class)
{
$lastNsPos = strrpos($class, '\\');
if ('\\' == $class[0]) {
$class = substr($class, 1);
}
if (false !== $lastNsPos) {
// namespaced class name
$classPath = str_replace('\\', DIRECTORY_SEPARATOR, substr($class, 0, $lastNsPos)) . DIRECTORY_SEPARATOR;
$className = substr($class, $lastNsPos + 1);
} else {
// PEAR-like class name
$classPath = null;
$className = $class;
}
$classPath .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
foreach ($this->prefixes as $prefix => $dirs) {
if (0 === strpos($class, $prefix)) {
foreach ($dirs as $dir) {
if (is_file($dir . DIRECTORY_SEPARATOR . $classPath)) {
return $dir . DIRECTORY_SEPARATOR . $classPath;
}
}
}
}
return null;
}
}

48
vendor/doctrine/common/lib/Doctrine/Common/Reflection/ReflectionProviderInterface.php vendored Normal file
View file

@ -0,0 +1,48 @@
<?php
/*
* 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.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace Doctrine\Common\Reflection;
interface ReflectionProviderInterface
{
/**
* Gets the ReflectionClass equivalent for this class.
*
* @return \ReflectionClass
*/
public function getReflectionClass();
/**
* Gets the ReflectionMethod equivalent for this class.
*
* @param string $name
*
* @return \ReflectionMethod
*/
public function getReflectionMethod($name);
/**
* Gets the ReflectionProperty equivalent for this class.
*
* @param string $name
*
* @return \ReflectionProperty
*/
public function getReflectionProperty($name);
}

76
vendor/doctrine/common/lib/Doctrine/Common/Reflection/RuntimePublicReflectionProperty.php vendored Normal file
View file

@ -0,0 +1,76 @@
<?php
/*
* 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.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace Doctrine\Common\Reflection;
use Doctrine\Common\Proxy\Proxy;
use ReflectionProperty;
/**
* PHP Runtime Reflection Public Property - special overrides for public properties.
*
* @author Marco Pivetta <ocramius@gmail.com>
* @since 2.4
*/
class RuntimePublicReflectionProperty extends ReflectionProperty
{
/**
* {@inheritDoc}
*
* Checks is the value actually exist before fetching it.
* This is to avoid calling `__get` on the provided $object if it
* is a {@see \Doctrine\Common\Proxy\Proxy}.
*/
public function getValue($object = null)
{
$name = $this->getName();
if ($object instanceof Proxy && ! $object->__isInitialized()) {
$originalInitializer = $object->__getInitializer();
$object->__setInitializer(null);
$val = isset($object->$name) ? $object->$name : null;
$object->__setInitializer($originalInitializer);
return $val;
}
return isset($object->$name) ? parent::getValue($object) : null;
}
/**
* {@inheritDoc}
*
* Avoids triggering lazy loading via `__set` if the provided object
* is a {@see \Doctrine\Common\Proxy\Proxy}.
* @link https://bugs.php.net/bug.php?id=63463
*/
public function setValue($object, $value = null)
{
if ( ! ($object instanceof Proxy && ! $object->__isInitialized())) {
parent::setValue($object, $value);
return;
}
$originalInitializer = $object->__getInitializer();
$object->__setInitializer(null);
parent::setValue($object, $value);
$object->__setInitializer($originalInitializer);
}
}

433
vendor/doctrine/common/lib/Doctrine/Common/Reflection/StaticReflectionClass.php vendored Normal file
View file

@ -0,0 +1,433 @@
<?php
/*
* 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.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace Doctrine\Common\Reflection;
use ReflectionClass;
use ReflectionException;
class StaticReflectionClass extends ReflectionClass
{
/**
* The static reflection parser object.
*
* @var StaticReflectionParser
*/
private $staticReflectionParser;
/**
* @param StaticReflectionParser $staticReflectionParser
*/
public function __construct(StaticReflectionParser $staticReflectionParser)
{
$this->staticReflectionParser = $staticReflectionParser;
}
/**
* {@inheritDoc}
*/
public function getName()
{
return $this->staticReflectionParser->getClassName();
}
/**
* {@inheritDoc}
*/
public function getDocComment()
{
return $this->staticReflectionParser->getDocComment();
}
/**
* {@inheritDoc}
*/
public function getNamespaceName()
{
return $this->staticReflectionParser->getNamespaceName();
}
/**
* @return array
*/
public function getUseStatements()
{
return $this->staticReflectionParser->getUseStatements();
}
/**
* {@inheritDoc}
*/
public function getMethod($name)
{
return $this->staticReflectionParser->getReflectionMethod($name);
}
/**
* {@inheritDoc}
*/
public function getProperty($name)
{
return $this->staticReflectionParser->getReflectionProperty($name);
}
/**
* {@inheritDoc}
*/
public static function export($argument, $return = false)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getConstant($name)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getConstants()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getConstructor()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getDefaultProperties()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getEndLine()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getExtension()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getExtensionName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getFileName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getInterfaceNames()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getInterfaces()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getMethods($filter = null)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getModifiers()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getParentClass()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getProperties($filter = null)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getShortName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getStartLine()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getStaticProperties()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getStaticPropertyValue($name, $default = '')
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getTraitAliases()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getTraitNames()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getTraits()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function hasConstant($name)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function hasMethod($name)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function hasProperty($name)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function implementsInterface($interface)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function inNamespace()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isAbstract()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isCloneable()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isFinal()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isInstance($object)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isInstantiable()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isInterface()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isInternal()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isIterateable()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isSubclassOf($class)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isTrait()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isUserDefined()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function newInstance($args)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function newInstanceArgs(array $args = array())
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function newInstanceWithoutConstructor()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function setStaticPropertyValue($name, $value)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function __toString()
{
throw new ReflectionException('Method not implemented');
}
}

362
vendor/doctrine/common/lib/Doctrine/Common/Reflection/StaticReflectionMethod.php vendored Normal file
View file

@ -0,0 +1,362 @@
<?php
/*
* 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.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace Doctrine\Common\Reflection;
use ReflectionException;
use ReflectionMethod;
class StaticReflectionMethod extends ReflectionMethod
{
/**
* The PSR-0 parser object.
*
* @var StaticReflectionParser
*/
protected $staticReflectionParser;
/**
* The name of the method.
*
* @var string
*/
protected $methodName;
/**
* @param StaticReflectionParser $staticReflectionParser
* @param string $methodName
*/
public function __construct(StaticReflectionParser $staticReflectionParser, $methodName)
{
$this->staticReflectionParser = $staticReflectionParser;
$this->methodName = $methodName;
}
/**
* {@inheritDoc}
*/
public function getName()
{
return $this->methodName;
}
/**
* @return StaticReflectionParser
*/
protected function getStaticReflectionParser()
{
return $this->staticReflectionParser->getStaticReflectionParserForDeclaringClass('method', $this->methodName);
}
/**
* {@inheritDoc}
*/
public function getDeclaringClass()
{
return $this->getStaticReflectionParser()->getReflectionClass();
}
/**
* {@inheritDoc}
*/
public function getNamespaceName()
{
return $this->getStaticReflectionParser()->getNamespaceName();
}
/**
* {@inheritDoc}
*/
public function getDocComment()
{
return $this->getStaticReflectionParser()->getDocComment('method', $this->methodName);
}
/**
* @return array
*/
public function getUseStatements()
{
return $this->getStaticReflectionParser()->getUseStatements();
}
/**
* {@inheritDoc}
*/
public static function export($class, $name, $return = false)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getClosure($object)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getModifiers()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getPrototype()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function invoke($object, $parameter = null)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function invokeArgs($object, array $args)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isAbstract()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isConstructor()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isDestructor()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isFinal()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isPrivate()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isProtected()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isPublic()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isStatic()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function setAccessible($accessible)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function __toString()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getClosureThis()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getEndLine()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getExtension()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getExtensionName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getFileName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getNumberOfParameters()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getNumberOfRequiredParameters()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getParameters()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getShortName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getStartLine()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getStaticVariables()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function inNamespace()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isClosure()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isDeprecated()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isInternal()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isUserDefined()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function returnsReference()
{
throw new ReflectionException('Method not implemented');
}
}

307
vendor/doctrine/common/lib/Doctrine/Common/Reflection/StaticReflectionParser.php vendored Normal file
View file

@ -0,0 +1,307 @@
<?php
/*
* 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.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace Doctrine\Common\Reflection;
use Doctrine\Common\Annotations\TokenParser;
use ReflectionException;
/**
* Parses a file for namespaces/use/class declarations.
*
* @author Karoly Negyesi <karoly@negyesi.net>
*/
class StaticReflectionParser implements ReflectionProviderInterface
{
/**
* The fully qualified class name.
*
* @var string
*/
protected $className;
/**
* The short class name.
*
* @var string
*/
protected $shortClassName;
/**
* Whether the caller only wants class annotations.
*
* @var boolean.
*/
protected $classAnnotationOptimize;
/**
* Whether the parser has run.
*
* @var boolean
*/
protected $parsed = false;
/**
* The namespace of the class.
*
* @var string
*/
protected $namespace = '';
/**
* The use statements of the class.
*
* @var array
*/
protected $useStatements = array();
/**
* The docComment of the class.
*
* @var string
*/
protected $docComment = array(
'class' => '',
'property' => array(),
'method' => array()
);
/**
* The name of the class this class extends, if any.
*
* @var string
*/
protected $parentClassName = '';
/**
* The parent PSR-0 Parser.
*
* @var \Doctrine\Common\Reflection\StaticReflectionParser
*/
protected $parentStaticReflectionParser;
/**
* Parses a class residing in a PSR-0 hierarchy.
*
* @param string $className The full, namespaced class name.
* @param ClassFinderInterface $finder A ClassFinder object which finds the class.
* @param boolean $classAnnotationOptimize Only retrieve the class docComment.
* Presumes there is only one statement per line.
*/
public function __construct($className, $finder, $classAnnotationOptimize = false)
{
$this->className = ltrim($className, '\\');
$lastNsPos = strrpos($this->className, '\\');
if ($lastNsPos !== false) {
$this->namespace = substr($this->className, 0, $lastNsPos);
$this->shortClassName = substr($this->className, $lastNsPos + 1);
} else {
$this->shortClassName = $this->className;
}
$this->finder = $finder;
$this->classAnnotationOptimize = $classAnnotationOptimize;
}
/**
* @return void
*/
protected function parse()
{
if ($this->parsed || !$fileName = $this->finder->findFile($this->className)) {
return;
}
$this->parsed = true;
$contents = file_get_contents($fileName);
if ($this->classAnnotationOptimize) {
if (preg_match("/\A.*^\s*((abstract|final)\s+)?class\s+{$this->shortClassName}\s+/sm", $contents, $matches)) {
$contents = $matches[0];
}
}
$tokenParser = new TokenParser($contents);
$docComment = '';
while ($token = $tokenParser->next(false)) {
if (is_array($token)) {
switch ($token[0]) {
case T_USE:
$this->useStatements = array_merge($this->useStatements, $tokenParser->parseUseStatement());
break;
case T_DOC_COMMENT:
$docComment = $token[1];
break;
case T_CLASS:
$this->docComment['class'] = $docComment;
$docComment = '';
break;
case T_VAR:
case T_PRIVATE:
case T_PROTECTED:
case T_PUBLIC:
$token = $tokenParser->next();
if ($token[0] === T_VARIABLE) {
$propertyName = substr($token[1], 1);
$this->docComment['property'][$propertyName] = $docComment;
continue 2;
}
if ($token[0] !== T_FUNCTION) {
// For example, it can be T_FINAL.
continue 2;
}
// No break.
case T_FUNCTION:
// The next string after function is the name, but
// there can be & before the function name so find the
// string.
while (($token = $tokenParser->next()) && $token[0] !== T_STRING);
$methodName = $token[1];
$this->docComment['method'][$methodName] = $docComment;
$docComment = '';
break;
case T_EXTENDS:
$this->parentClassName = $tokenParser->parseClass();
$nsPos = strpos($this->parentClassName, '\\');
$fullySpecified = false;
if ($nsPos === 0) {
$fullySpecified = true;
} else {
if ($nsPos) {
$prefix = strtolower(substr($this->parentClassName, 0, $nsPos));
$postfix = substr($this->parentClassName, $nsPos);
} else {
$prefix = strtolower($this->parentClassName);
$postfix = '';
}
foreach ($this->useStatements as $alias => $use) {
if ($alias == $prefix) {
$this->parentClassName = '\\' . $use . $postfix;
$fullySpecified = true;
}
}
}
if (!$fullySpecified) {
$this->parentClassName = '\\' . $this->namespace . '\\' . $this->parentClassName;
}
break;
}
}
}
}
/**
* @return StaticReflectionParser
*/
protected function getParentStaticReflectionParser()
{
if (empty($this->parentStaticReflectionParser)) {
$this->parentStaticReflectionParser = new static($this->parentClassName, $this->finder);
}
return $this->parentStaticReflectionParser;
}
/**
* @return string
*/
public function getClassName()
{
return $this->className;
}
/**
* @return string
*/
public function getNamespaceName()
{
return $this->namespace;
}
/**
* {@inheritDoc}
*/
public function getReflectionClass()
{
return new StaticReflectionClass($this);
}
/**
* {@inheritDoc}
*/
public function getReflectionMethod($methodName)
{
return new StaticReflectionMethod($this, $methodName);
}
/**
* {@inheritDoc}
*/
public function getReflectionProperty($propertyName)
{
return new StaticReflectionProperty($this, $propertyName);
}
/**
* Gets the use statements from this file.
*
* @return array
*/
public function getUseStatements()
{
$this->parse();
return $this->useStatements;
}
/**
* Gets the doc comment.
*
* @param string $type The type: 'class', 'property' or 'method'.
* @param string $name The name of the property or method, not needed for 'class'.
*
* @return string The doc comment, empty string if none.
*/
public function getDocComment($type = 'class', $name = '')
{
$this->parse();
return $name ? $this->docComment[$type][$name] : $this->docComment[$type];
}
/**
* Gets the PSR-0 parser for the declaring class.
*
* @param string $type The type: 'property' or 'method'.
* @param string $name The name of the property or method.
*
* @return StaticReflectionParser A static reflection parser for the declaring class.
*
* @throws ReflectionException
*/
public function getStaticReflectionParserForDeclaringClass($type, $name)
{
$this->parse();
if (isset($this->docComment[$type][$name])) {
return $this;
}
if (!empty($this->parentClassName)) {
return $this->getParentStaticReflectionParser()->getStaticReflectionParserForDeclaringClass($type, $name);
}
throw new ReflectionException('Invalid ' . $type . ' "' . $name . '"');
}
}

178
vendor/doctrine/common/lib/Doctrine/Common/Reflection/StaticReflectionProperty.php vendored Normal file
View file

@ -0,0 +1,178 @@
<?php
/*
* 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.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the MIT license. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace Doctrine\Common\Reflection;
use ReflectionException;
use ReflectionProperty;
class StaticReflectionProperty extends ReflectionProperty
{
/**
* The PSR-0 parser object.
*
* @var StaticReflectionParser
*/
protected $staticReflectionParser;
/**
* The name of the property.
*
* @var string|null
*/
protected $propertyName;
/**
* @param StaticReflectionParser $staticReflectionParser
* @param string|null $propertyName
*/
public function __construct(StaticReflectionParser $staticReflectionParser, $propertyName)
{
$this->staticReflectionParser = $staticReflectionParser;
$this->propertyName = $propertyName;
}
/**
* {@inheritDoc}
*/
public function getName()
{
return $this->propertyName;
}
/**
* @return StaticReflectionParser
*/
protected function getStaticReflectionParser()
{
return $this->staticReflectionParser->getStaticReflectionParserForDeclaringClass('property', $this->propertyName);
}
/**
* {@inheritDoc}
*/
public function getDeclaringClass()
{
return $this->getStaticReflectionParser()->getReflectionClass();
}
/**
* {@inheritDoc}
*/
public function getDocComment()
{
return $this->getStaticReflectionParser()->getDocComment('property', $this->propertyName);
}
/**
* @return array
*/
public function getUseStatements()
{
return $this->getStaticReflectionParser()->getUseStatements();
}
/**
* {@inheritDoc}
*/
public static function export ($class, $name, $return = false)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getModifiers()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getValue($object = null)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isDefault()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isPrivate()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isProtected()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isPublic()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isStatic()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function setAccessible ($accessible)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function setValue ($object, $value = null)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function __toString()
{
throw new ReflectionException('Method not implemented');
}
}