mirror of https://gitee.com/karson/fastadmin.git
554 lines
18 KiB
PHP
554 lines
18 KiB
PHP
<?php
|
||
|
||
namespace app\admin\command\Api\library;
|
||
|
||
/**
|
||
* Class imported from https://github.com/eriknyk/Annotations
|
||
* @author Erik Amaru Ortiz https://github.com/eriknyk
|
||
*
|
||
* @license http://opensource.org/licenses/bsd-license.php The BSD License
|
||
* @author Calin Rada <rada.calin@gmail.com>
|
||
*/
|
||
class Extractor
|
||
{
|
||
|
||
/**
|
||
* Static array to store already parsed annotations
|
||
* @var array
|
||
*/
|
||
private static $annotationCache;
|
||
|
||
/**
|
||
* Indicates that annotations should has strict behavior, 'false' by default
|
||
* @var boolean
|
||
*/
|
||
private $strict = false;
|
||
|
||
/**
|
||
* Stores the default namespace for Objects instance, usually used on methods like getMethodAnnotationsObjects()
|
||
* @var string
|
||
*/
|
||
public $defaultNamespace = '';
|
||
|
||
/**
|
||
* Sets strict variable to true/false
|
||
* @param bool $value boolean value to indicate that annotations to has strict behavior
|
||
*/
|
||
public function setStrict($value)
|
||
{
|
||
$this->strict = (bool) $value;
|
||
}
|
||
|
||
/**
|
||
* Sets default namespace to use in object instantiation
|
||
* @param string $namespace default namespace
|
||
*/
|
||
public function setDefaultNamespace($namespace)
|
||
{
|
||
$this->defaultNamespace = $namespace;
|
||
}
|
||
|
||
/**
|
||
* Gets default namespace used in object instantiation
|
||
* @return string $namespace default namespace
|
||
*/
|
||
public function getDefaultAnnotationNamespace()
|
||
{
|
||
return $this->defaultNamespace;
|
||
}
|
||
|
||
/**
|
||
* Gets all anotations with pattern @SomeAnnotation() from a given class
|
||
*
|
||
* @param string $className class name to get annotations
|
||
* @return array self::$annotationCache all annotated elements
|
||
*/
|
||
public static function getClassAnnotations($className)
|
||
{
|
||
if (!isset(self::$annotationCache[$className]))
|
||
{
|
||
$class = new \ReflectionClass($className);
|
||
self::$annotationCache[$className] = self::parseAnnotations($class->getDocComment());
|
||
}
|
||
|
||
return self::$annotationCache[$className];
|
||
}
|
||
|
||
public static function getAllClassAnnotations($className)
|
||
{
|
||
$class = new \ReflectionClass($className);
|
||
|
||
foreach ($class->getMethods() as $object)
|
||
{
|
||
self::$annotationCache['annotations'][$className][$object->name] = self::getMethodAnnotations($className, $object->name);
|
||
}
|
||
|
||
return self::$annotationCache['annotations'];
|
||
}
|
||
|
||
/**
|
||
* Gets all anotations with pattern @SomeAnnotation() from a determinated method of a given class
|
||
*
|
||
* @param string $className class name
|
||
* @param string $methodName method name to get annotations
|
||
* @return array self::$annotationCache all annotated elements of a method given
|
||
*/
|
||
public static function getMethodAnnotations($className, $methodName)
|
||
{
|
||
if (!isset(self::$annotationCache[$className . '::' . $methodName]))
|
||
{
|
||
try
|
||
{
|
||
$method = new \ReflectionMethod($className, $methodName);
|
||
$class = new \ReflectionClass($className);
|
||
if (!$method->isPublic() || $method->isConstructor())
|
||
{
|
||
$annotations = array();
|
||
}
|
||
else
|
||
{
|
||
$annotations = self::consolidateAnnotations($method, $class);
|
||
}
|
||
}
|
||
catch (\ReflectionException $e)
|
||
{
|
||
$annotations = array();
|
||
}
|
||
|
||
self::$annotationCache[$className . '::' . $methodName] = $annotations;
|
||
}
|
||
|
||
return self::$annotationCache[$className . '::' . $methodName];
|
||
}
|
||
|
||
/**
|
||
* Gets all anotations with pattern @SomeAnnotation() from a determinated method of a given class
|
||
* and instance its abcAnnotation class
|
||
*
|
||
* @param string $className class name
|
||
* @param string $methodName method name to get annotations
|
||
* @return array self::$annotationCache all annotated objects of a method given
|
||
*/
|
||
public function getMethodAnnotationsObjects($className, $methodName)
|
||
{
|
||
$annotations = $this->getMethodAnnotations($className, $methodName);
|
||
$objects = array();
|
||
|
||
$i = 0;
|
||
|
||
foreach ($annotations as $annotationClass => $listParams)
|
||
{
|
||
$annotationClass = ucfirst($annotationClass);
|
||
$class = $this->defaultNamespace . $annotationClass . 'Annotation';
|
||
|
||
// verify is the annotation class exists, depending if Annotations::strict is true
|
||
// if not, just skip the annotation instance creation.
|
||
if (!class_exists($class))
|
||
{
|
||
if ($this->strict)
|
||
{
|
||
throw new Exception(sprintf('Runtime Error: Annotation Class Not Found: %s', $class));
|
||
}
|
||
else
|
||
{
|
||
// silent skip & continue
|
||
continue;
|
||
}
|
||
}
|
||
|
||
if (empty($objects[$annotationClass]))
|
||
{
|
||
$objects[$annotationClass] = new $class();
|
||
}
|
||
|
||
foreach ($listParams as $params)
|
||
{
|
||
if (is_array($params))
|
||
{
|
||
foreach ($params as $key => $value)
|
||
{
|
||
$objects[$annotationClass]->set($key, $value);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
$objects[$annotationClass]->set($i++, $params);
|
||
}
|
||
}
|
||
}
|
||
|
||
return $objects;
|
||
}
|
||
|
||
private static function consolidateAnnotations($method, $class)
|
||
{
|
||
$dockblockClass = $class->getDocComment();
|
||
$docblockMethod = $method->getDocComment();
|
||
$methodName = $method->getName();
|
||
|
||
$methodAnnotations = self::parseAnnotations($docblockMethod);
|
||
$classAnnotations = self::parseAnnotations($dockblockClass);
|
||
if (isset($methodAnnotations['ApiInternal']) || $methodName == '_initialize' || $methodName == '_empty')
|
||
{
|
||
return [];
|
||
}
|
||
|
||
$properties = $class->getDefaultProperties();
|
||
$noNeedLogin = isset($properties['noNeedLogin']) ? is_array($properties['noNeedLogin']) ? $properties['noNeedLogin'] : [$properties['noNeedLogin']] : [];
|
||
$noNeedRight = isset($properties['noNeedRight']) ? is_array($properties['noNeedRight']) ? $properties['noNeedRight'] : [$properties['noNeedRight']] : [];
|
||
|
||
preg_match_all("/\*[\s]+(.*)(\\r\\n|\\r|\\n)/U", str_replace('/**', '', $docblockMethod), $methodArr);
|
||
preg_match_all("/\*[\s]+(.*)(\\r\\n|\\r|\\n)/U", str_replace('/**', '', $dockblockClass), $classArr);
|
||
|
||
$methodTitle = isset($methodArr[1]) && isset($methodArr[1][0]) ? $methodArr[1][0] : '';
|
||
$classTitle = isset($classArr[1]) && isset($classArr[1][0]) ? $classArr[1][0] : '';
|
||
|
||
if (!isset($methodAnnotations['ApiMethod']))
|
||
{
|
||
$methodAnnotations['ApiMethod'] = ['get'];
|
||
}
|
||
if (!isset($methodAnnotations['ApiSummary']))
|
||
{
|
||
$methodAnnotations['ApiSummary'] = [$methodTitle];
|
||
}
|
||
|
||
if ($methodAnnotations)
|
||
{
|
||
foreach ($classAnnotations as $name => $valueClass)
|
||
{
|
||
if (count($valueClass) !== 1)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if ($name === 'ApiRoute')
|
||
{
|
||
if (isset($methodAnnotations[$name]))
|
||
{
|
||
$methodAnnotations[$name] = [rtrim($valueClass[0], '/') . $methodAnnotations[$name][0]];
|
||
}
|
||
else
|
||
{
|
||
$methodAnnotations[$name] = [rtrim($valueClass[0], '/') . '/' . $method->getName()];
|
||
}
|
||
}
|
||
|
||
if ($name === 'ApiSector')
|
||
{
|
||
$methodAnnotations[$name] = $valueClass;
|
||
}
|
||
}
|
||
}
|
||
if (!isset($methodAnnotations['ApiTitle']))
|
||
{
|
||
$methodAnnotations['ApiTitle'] = [$methodTitle];
|
||
}
|
||
if (!isset($methodAnnotations['ApiRoute']))
|
||
{
|
||
$urlArr = [];
|
||
$className = $class->getName();
|
||
|
||
list($prefix, $suffix) = explode('\\' . \think\Config::get('url_controller_layer') . '\\', $className);
|
||
$prefixArr = explode('\\', $prefix);
|
||
$suffixArr = explode('\\', $suffix);
|
||
if ($prefixArr[0] == \think\Config::get('app_namespace'))
|
||
{
|
||
$prefixArr[0] = '';
|
||
}
|
||
$urlArr = array_merge($urlArr, $prefixArr);
|
||
$urlArr[] = implode('.', array_map(function($item) {
|
||
return \think\Loader::parseName($item);
|
||
}, $suffixArr));
|
||
$urlArr[] = $method->getName();
|
||
$methodAnnotations['ApiRoute'] = [implode('/', $urlArr)];
|
||
}
|
||
if (!isset($methodAnnotations['ApiSector']))
|
||
{
|
||
$methodAnnotations['ApiSector'] = isset($classAnnotations['ApiSector']) ? $classAnnotations['ApiSector'] : [$classTitle];
|
||
}
|
||
if (!isset($methodAnnotations['ApiParams']))
|
||
{
|
||
$params = self::parseCustomAnnotations($docblockMethod, 'param');
|
||
foreach ($params as $k => $v)
|
||
{
|
||
$arr = explode(' ', preg_replace("/[\s]+/", " ", $v));
|
||
$methodAnnotations['ApiParams'][] = [
|
||
'name' => isset($arr[1]) ? str_replace('$', '', $arr[1]) : '',
|
||
'nullable' => false,
|
||
'type' => isset($arr[0]) ? $arr[0] : 'string',
|
||
'description' => isset($arr[2]) ? $arr[2] : ''
|
||
];
|
||
}
|
||
}
|
||
$methodAnnotations['ApiPermissionLogin'] = [!in_array('*', $noNeedLogin) && !in_array($methodName, $noNeedLogin)];
|
||
$methodAnnotations['ApiPermissionRight'] = [!in_array('*', $noNeedRight) && !in_array($methodName, $noNeedRight)];
|
||
return $methodAnnotations;
|
||
}
|
||
|
||
/**
|
||
* Parse annotations
|
||
*
|
||
* @param string $docblock
|
||
* @param string $name
|
||
* @return array parsed annotations params
|
||
*/
|
||
private static function parseCustomAnnotations($docblock, $name = 'param')
|
||
{
|
||
$annotations = array();
|
||
|
||
$docblock = substr($docblock, 3, -2);
|
||
if (preg_match_all('/@' . $name . '(?:\s*(?:\(\s*)?(.*?)(?:\s*\))?)??\s*(?:\n|\*\/)/', $docblock, $matches))
|
||
{
|
||
foreach ($matches[1] as $k => $v)
|
||
{
|
||
$annotations[] = $v;
|
||
}
|
||
}
|
||
return $annotations;
|
||
}
|
||
|
||
/**
|
||
* Parse annotations
|
||
*
|
||
* @param string $docblock
|
||
* @return array parsed annotations params
|
||
*/
|
||
private static function parseAnnotations($docblock)
|
||
{
|
||
$annotations = array();
|
||
|
||
// Strip away the docblock header and footer to ease parsing of one line annotations
|
||
$docblock = substr($docblock, 3, -2);
|
||
if (preg_match_all('/@(?<name>[A-Za-z_-]+)[\s\t]*\((?<args>(?:(?!\)).)*)\)\r?/s', $docblock, $matches))
|
||
{
|
||
$numMatches = count($matches[0]);
|
||
for ($i = 0; $i < $numMatches; ++$i)
|
||
{
|
||
// annotations has arguments
|
||
if (isset($matches['args'][$i]))
|
||
{
|
||
$argsParts = trim($matches['args'][$i]);
|
||
$name = $matches['name'][$i];
|
||
$argsParts = preg_replace("/\{(\w+)\}/", '#$1#', $argsParts);
|
||
$value = self::parseArgs($argsParts);
|
||
if(is_string($value))
|
||
{
|
||
$value = preg_replace("/\#(\w+)\#/", '{$1}', $argsParts);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
$value = array();
|
||
}
|
||
|
||
$annotations[$name][] = $value;
|
||
}
|
||
}
|
||
|
||
return $annotations;
|
||
}
|
||
|
||
/**
|
||
* Parse individual annotation arguments
|
||
*
|
||
* @param string $content arguments string
|
||
* @return array annotated arguments
|
||
*/
|
||
private static function parseArgs($content)
|
||
{
|
||
// Replace initial stars
|
||
$content = preg_replace('/^\s*\*/m', '', $content);
|
||
|
||
$data = array();
|
||
$len = strlen($content);
|
||
$i = 0;
|
||
$var = '';
|
||
$val = '';
|
||
$level = 1;
|
||
|
||
$prevDelimiter = '';
|
||
$nextDelimiter = '';
|
||
$nextToken = '';
|
||
$composing = false;
|
||
$type = 'plain';
|
||
$delimiter = null;
|
||
$quoted = false;
|
||
$tokens = array('"', '"', '{', '}', ',', '=');
|
||
|
||
while ($i <= $len)
|
||
{
|
||
$prev_c = substr($content, $i - 1, 1);
|
||
$c = substr($content, $i++, 1);
|
||
|
||
if ($c === '"' && $prev_c !== "\\")
|
||
{
|
||
$delimiter = $c;
|
||
//open delimiter
|
||
if (!$composing && empty($prevDelimiter) && empty($nextDelimiter))
|
||
{
|
||
$prevDelimiter = $nextDelimiter = $delimiter;
|
||
$val = '';
|
||
$composing = true;
|
||
$quoted = true;
|
||
}
|
||
else
|
||
{
|
||
// close delimiter
|
||
if ($c !== $nextDelimiter)
|
||
{
|
||
throw new Exception(sprintf(
|
||
"Parse Error: enclosing error -> expected: [%s], given: [%s]", $nextDelimiter, $c
|
||
));
|
||
}
|
||
|
||
// validating syntax
|
||
if ($i < $len)
|
||
{
|
||
if (',' !== substr($content, $i, 1) && '\\' !== $prev_c)
|
||
{
|
||
throw new Exception(sprintf(
|
||
"Parse Error: missing comma separator near: ...%s<--", substr($content, ($i - 10), $i)
|
||
));
|
||
}
|
||
}
|
||
|
||
$prevDelimiter = $nextDelimiter = '';
|
||
$composing = false;
|
||
$delimiter = null;
|
||
}
|
||
}
|
||
elseif (!$composing && in_array($c, $tokens))
|
||
{
|
||
switch ($c)
|
||
{
|
||
case '=':
|
||
$prevDelimiter = $nextDelimiter = '';
|
||
$level = 2;
|
||
$composing = false;
|
||
$type = 'assoc';
|
||
$quoted = false;
|
||
break;
|
||
case ',':
|
||
$level = 3;
|
||
|
||
// If composing flag is true yet,
|
||
// it means that the string was not enclosed, so it is parsing error.
|
||
if ($composing === true && !empty($prevDelimiter) && !empty($nextDelimiter))
|
||
{
|
||
throw new Exception(sprintf(
|
||
"Parse Error: enclosing error -> expected: [%s], given: [%s]", $nextDelimiter, $c
|
||
));
|
||
}
|
||
|
||
$prevDelimiter = $nextDelimiter = '';
|
||
break;
|
||
case '{':
|
||
$subc = '';
|
||
$subComposing = true;
|
||
|
||
while ($i <= $len)
|
||
{
|
||
$c = substr($content, $i++, 1);
|
||
|
||
if (isset($delimiter) && $c === $delimiter)
|
||
{
|
||
throw new Exception(sprintf(
|
||
"Parse Error: Composite variable is not enclosed correctly."
|
||
));
|
||
}
|
||
|
||
if ($c === '}')
|
||
{
|
||
$subComposing = false;
|
||
break;
|
||
}
|
||
$subc .= $c;
|
||
}
|
||
|
||
// if the string is composing yet means that the structure of var. never was enclosed with '}'
|
||
if ($subComposing)
|
||
{
|
||
throw new Exception(sprintf(
|
||
"Parse Error: Composite variable is not enclosed correctly. near: ...%s'", $subc
|
||
));
|
||
}
|
||
|
||
$val = self::parseArgs($subc);
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if ($level == 1)
|
||
{
|
||
$var .= $c;
|
||
}
|
||
elseif ($level == 2)
|
||
{
|
||
$val .= $c;
|
||
}
|
||
}
|
||
|
||
if ($level === 3 || $i === $len)
|
||
{
|
||
if ($type == 'plain' && $i === $len)
|
||
{
|
||
$data = self::castValue($var);
|
||
}
|
||
else
|
||
{
|
||
$data[trim($var)] = self::castValue($val, !$quoted);
|
||
}
|
||
|
||
$level = 1;
|
||
$var = $val = '';
|
||
$composing = false;
|
||
$quoted = false;
|
||
}
|
||
}
|
||
|
||
return $data;
|
||
}
|
||
|
||
/**
|
||
* Try determinate the original type variable of a string
|
||
*
|
||
* @param string $val string containing possibles variables that can be cast to bool or int
|
||
* @param boolean $trim indicate if the value passed should be trimmed after to try cast
|
||
* @return mixed returns the value converted to original type if was possible
|
||
*/
|
||
private static function castValue($val, $trim = false)
|
||
{
|
||
if (is_array($val))
|
||
{
|
||
foreach ($val as $key => $value)
|
||
{
|
||
$val[$key] = self::castValue($value);
|
||
}
|
||
}
|
||
elseif (is_string($val))
|
||
{
|
||
if ($trim)
|
||
{
|
||
$val = trim($val);
|
||
}
|
||
$val = stripslashes($val);
|
||
$tmp = strtolower($val);
|
||
|
||
if ($tmp === 'false' || $tmp === 'true')
|
||
{
|
||
$val = $tmp === 'true';
|
||
}
|
||
elseif (is_numeric($val))
|
||
{
|
||
return $val + 0;
|
||
}
|
||
|
||
unset($tmp);
|
||
}
|
||
|
||
return $val;
|
||
}
|
||
|
||
}
|