/**
* Execute the command
* @param array $args Arguments gived to the command
* @return array Response
*/
public function execute($args = array())
{
$fileExists = false;
// If we specified a file
if (count($args) > 0 && ($file = $args[0])) {
if (file_exists(Config::get('indexClasses'))) {
$index = json_decode(file_get_contents(Config::get('indexClasses')), true);
// Invalid json (#24)
if (false !== $index) {
$fileExists = true;
$found = false;
$fileParser = new FileParser($file);
$class = $fileParser->getFullClassName(null, $found);
// if (false !== $class = array_search($file, $classMap)) {
if ($found) {
if (isset($index['mapping'][$class])) {
unset($index['mapping'][$class]);
}
if (false !== ($key = array_search($class, $index['autocomplete']))) {
unset($index['autocomplete'][$key]);
$index['autocomplete'] = array_values($index['autocomplete']);
}
if ($value = $this->buildIndexClass($class)) {
$index['mapping'][$class] = array('methods' => $value);
$index['autocomplete'][] = $class;
}
}
}
}
}
// Otherwise, full index
if (!$fileExists) {
// Autoload classes
foreach ($this->getClassMap(true) as $class => $filePath) {
if ($value = $this->buildIndexClass($class)) {
$index['mapping'][$class] = $value;
$index['autocomplete'][] = $class;
}
}
// Internal classes
foreach (get_declared_classes() as $class) {
$provider = new ClassProvider();
if ($value = $provider->execute(array($class, true))) {
if (!empty($value)) {
$index['mapping'][$class] = $value;
$index['autocomplete'][] = $class;
}
}
}
}
file_put_contents(Config::get('indexClasses'), json_encode($index));
return array();
}
/**
* {@inheritDoc}
*/
public function execute(array $args = [])
{
$isSuccessful = true;
$fileToReindex = array_shift($args);
if (!$fileToReindex) {
$index = [];
foreach (get_declared_classes() as $class) {
if (mb_strpos($class, 'PhpIntegrator') === 0) {
continue;
// Don't include our own classes.
}
if ($value = $this->fetchClassInfo($class, false)) {
$index[$class] = $value;
}
}
foreach ($this->buildClassMap() as $class => $filePath) {
if ($value = $this->fetchClassInfo($class, true)) {
$index[$class] = $value;
}
}
} elseif (file_exists(Config::get('indexClasses'))) {
$index = json_decode(file_get_contents(Config::get('indexClasses')), true);
if ($index !== false) {
$found = false;
$fileParser = new FileParser($fileToReindex);
$class = $fileParser->getFullClassName(null, $found);
if ($found) {
if (isset($index[$class])) {
unset($index[$class]);
}
$value = $this->fetchClassInfo($class, true);
if ($value) {
$index[$class] = $value;
} else {
$isSuccessful = false;
}
}
}
}
file_put_contents(Config::get('indexClasses'), json_encode($index));
return ['success' => $isSuccessful, 'result' => null];
}
/**
* Resolves and determiens the full return type (class name) for the return value of the specified item.
*
* @param array $info
* @param string|null $currentClass The class that contains the method (either through inheritance or directly).
*
* @return string|null
*/
protected function determineFullReturnType(array $info, $currentClass = null)
{
if (!isset($info['return']['type']) || empty($info['return']['type'])) {
return null;
}
$returnValue = $info['return']['type'];
if ($returnValue == '$this' || $returnValue == 'self') {
return isset($info['declaringClass']['name']) ? $info['declaringClass']['name'] : null;
} elseif ($returnValue == 'static') {
return $currentClass ?: null;
}
$soleClassName = $this->getSoleClassName($returnValue);
if (!empty($soleClassName)) {
if ($soleClassName[0] !== "\\") {
$filename = isset($info['declaringStructure']['filename']) ? $info['declaringStructure']['filename'] : $info['filename'];
$parser = new FileParser($filename);
$completedClassName = $parser->getFullClassName($soleClassName, $useStatementFound);
return $completedClassName;
}
return $soleClassName;
}
return $returnValue;
}
/**
* Execute the command.
*
* @param array $args Arguments gived to the command.
*
* @return array Response
*/
public function execute($args = array())
{
$class = $args[0];
$name = $args[1];
if (strpos($class, '\\') === 0) {
$class = substr($class, 1);
}
$isMethod = false;
if (strpos($name, '()') !== false) {
$isMethod = true;
$name = str_replace('()', '', $name);
}
$relevantClass = null;
$data = $this->getClassMetadata($class);
if (isset($data['values'][$name])) {
$memberInfo = $data['values'][$name];
if (!isset($data['values'][$name]['isMethod'])) {
foreach ($data['values'][$name] as $value) {
if ($value['isMethod'] && $isMethod) {
$memberInfo = $value;
} elseif (!$value['isMethod'] && !$isMethod) {
$memberInfo = $value;
}
}
}
$returnValue = $memberInfo['args']['return'];
if ($returnValue == '$this' || $returnValue == 'static') {
$relevantClass = $class;
} elseif ($returnValue === 'self') {
$relevantClass = $memberInfo['declaringClass']['name'];
} else {
$soleClassName = $this->getSoleClassName($returnValue);
if ($soleClassName) {
// At this point, this could either be a class name relative to the current namespace or a full
// class name without a leading slash. For example, Foo\Bar could also be relative (e.g.
// My\Foo\Bar), in which case its absolute path is determined by the namespace and use statements
// of the file containing it.
$relevantClass = $soleClassName;
if (!empty($soleClassName) && $soleClassName[0] !== "\\") {
$parser = new FileParser($memberInfo['declaringStructure']['filename']);
$useStatementFound = false;
$completedClassName = $parser->getFullClassName($soleClassName, $useStatementFound);
if ($useStatementFound) {
$relevantClass = $completedClassName;
} else {
$isRelativeClass = true;
// Try instantiating the class, e.g. My\Foo\Bar.
try {
$reflection = new \ReflectionClass($completedClassName);
$relevantClass = $completedClassName;
} catch (\Exception $e) {
// The class, e.g. My\Foo\Bar, didn't exist. We can only assume its an absolute path,
// using a namespace set up in composer.json, without a leading slash.
}
}
}
}
}
}
// Minor optimization to avoid fetching the same data twice.
return $relevantClass === $class ? $data : $this->getClassMetadata($relevantClass);
}
