Gerenciador & Editor PHP

📝 Editando: ReflectingCommand.php

<?php

/*
 * This file is part of Psy Shell.
 *
 * (c) 2012-2018 Justin Hileman
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Psy\Command;

use Psy\CodeCleaner\NoReturnValue;
use Psy\Context;
use Psy\ContextAware;
use Psy\Exception\RuntimeException;
use Psy\Util\Mirror;

/**
 * An abstract command with helpers for inspecting the current context.
 */
abstract class ReflectingCommand extends Command implements ContextAware
{
    const CLASS_OR_FUNC   = '/^[\\\\\w]+$/';
    const CLASS_MEMBER    = '/^([\\\\\w]+)::(\w+)$/';
    const CLASS_STATIC    = '/^([\\\\\w]+)::\$(\w+)$/';
    const INSTANCE_MEMBER = '/^(\$\w+)(::|->)(\w+)$/';

/**
     * Context instance (for ContextAware interface).
     *
     * @var Context
     */
    protected $context;

/**
     * ContextAware interface.
     *
     * @param Context $context
     */
    public function setContext(Context $context)
    {
        $this->context = $context;
    }

/**
     * Get the target for a value.
     *
     * @throws \InvalidArgumentException when the value specified can't be resolved
     *
     * @param string $valueName Function, class, variable, constant, method or property name
     *
     * @return array (class or instance name, member name, kind)
     */
    protected function getTarget($valueName)
    {
        $valueName = trim($valueName);
        $matches   = [];
        switch (true) {
            case preg_match(self::CLASS_OR_FUNC, $valueName, $matches):
                return [$this->resolveName($matches[0], true), null, 0];

case preg_match(self::CLASS_MEMBER, $valueName, $matches):
                return [$this->resolveName($matches[1]), $matches[2], Mirror::CONSTANT | Mirror::METHOD];

case preg_match(self::CLASS_STATIC, $valueName, $matches):
                return [$this->resolveName($matches[1]), $matches[2], Mirror::STATIC_PROPERTY | Mirror::PROPERTY];

case preg_match(self::INSTANCE_MEMBER, $valueName, $matches):
                if ($matches[2] === '->') {
                    $kind = Mirror::METHOD | Mirror::PROPERTY;
                } else {
                    $kind = Mirror::CONSTANT | Mirror::METHOD;
                }

return [$this->resolveObject($matches[1]), $matches[3], $kind];

default:
                return [$this->resolveObject($valueName), null, 0];
        }
    }

/**
     * Resolve a class or function name (with the current shell namespace).
     *
     * @param string $name
     * @param bool   $includeFunctions (default: false)
     *
     * @return string
     */
    protected function resolveName($name, $includeFunctions = false)
    {
        if (substr($name, 0, 1) === '\\') {
            return $name;
        }

if ($namespace = $this->getApplication()->getNamespace()) {
            $fullName = $namespace . '\\' . $name;

if (class_exists($fullName) || interface_exists($fullName) || ($includeFunctions && function_exists($fullName))) {
                return $fullName;
            }
        }

return $name;
    }

/**
     * Get a Reflector and documentation for a function, class or instance, constant, method or property.
     *
     * @param string $valueName Function, class, variable, constant, method or property name
     *
     * @return array (value, Reflector)
     */
    protected function getTargetAndReflector($valueName)
    {
        list($value, $member, $kind) = $this->getTarget($valueName);

return [$value, Mirror::get($value, $member, $kind)];
    }

/**
     * Resolve code to a value in the current scope.
     *
     * @throws RuntimeException when the code does not return a value in the current scope
     *
     * @param string $code
     *
     * @return mixed Variable value
     */
    protected function resolveCode($code)
    {
        try {
            $value = $this->getApplication()->execute($code, true);
        } catch (\Exception $e) {
            // Swallow all exceptions?
        }

if (!isset($value) || $value instanceof NoReturnValue) {
            throw new RuntimeException('Unknown target: ' . $code);
        }

return $value;
    }

/**
     * Resolve code to an object in the current scope.
     *
     * @throws RuntimeException when the code resolves to a non-object value
     *
     * @param string $code
     *
     * @return object Variable instance
     */
    private function resolveObject($code)
    {
        $value = $this->resolveCode($code);

if (!is_object($value)) {
            throw new RuntimeException('Unable to inspect a non-object');
        }

return $value;
    }

/**
     * @deprecated Use `resolveCode` instead
     *
     * @param string $name
     *
     * @return mixed Variable instance
     */
    protected function resolveInstance($name)
    {
        @trigger_error('`resolveInstance` is deprecated; use `resolveCode` instead.', E_USER_DEPRECATED);

return $this->resolveCode($name);
    }

/**
     * Get a variable from the current shell scope.
     *
     * @param string $name
     *
     * @return mixed
     */
    protected function getScopeVariable($name)
    {
        return $this->context->get($name);
    }

/**
     * Get all scope variables from the current shell scope.
     *
     * @return array
     */
    protected function getScopeVariables()
    {
        return $this->context->getAll();
    }

/**
     * Given a Reflector instance, set command-scope variables in the shell
     * execution context. This is used to inject magic $__class, $__method and
     * $__file variables (as well as a handful of others).
     *
     * @param \Reflector $reflector
     */
    protected function setCommandScopeVariables(\Reflector $reflector)
    {
        $vars = [];

switch (get_class($reflector)) {
            case 'ReflectionClass':
            case 'ReflectionObject':
                $vars['__class'] = $reflector->name;
                if ($reflector->inNamespace()) {
                    $vars['__namespace'] = $reflector->getNamespaceName();
                }
                break;

case 'ReflectionMethod':
                $vars['__method'] = sprintf('%s::%s', $reflector->class, $reflector->name);
                $vars['__class'] = $reflector->class;
                $classReflector = $reflector->getDeclaringClass();
                if ($classReflector->inNamespace()) {
                    $vars['__namespace'] = $classReflector->getNamespaceName();
                }
                break;

case 'ReflectionFunction':
                $vars['__function'] = $reflector->name;
                if ($reflector->inNamespace()) {
                    $vars['__namespace'] = $reflector->getNamespaceName();
                }
                break;

case 'ReflectionGenerator':
                $funcReflector = $reflector->getFunction();
                $vars['__function'] = $funcReflector->name;
                if ($funcReflector->inNamespace()) {
                    $vars['__namespace'] = $funcReflector->getNamespaceName();
                }
                if ($fileName = $reflector->getExecutingFile()) {
                    $vars['__file'] = $fileName;
                    $vars['__line'] = $reflector->getExecutingLine();
                    $vars['__dir']  = dirname($fileName);
                }
                break;

case 'ReflectionProperty':
            case 'Psy\Reflection\ReflectionConstant':
                $classReflector = $reflector->getDeclaringClass();
                $vars['__class'] = $classReflector->name;
                if ($classReflector->inNamespace()) {
                    $vars['__namespace'] = $classReflector->getNamespaceName();
                }
                // no line for these, but this'll do
                if ($fileName = $reflector->getDeclaringClass()->getFileName()) {
                    $vars['__file'] = $fileName;
                    $vars['__dir']  = dirname($fileName);
                }
                break;
        }

if ($reflector instanceof \ReflectionClass || $reflector instanceof \ReflectionFunctionAbstract) {
            if ($fileName = $reflector->getFileName()) {
                $vars['__file'] = $fileName;
                $vars['__line'] = $reflector->getStartLine();
                $vars['__dir']  = dirname($fileName);
            }
        }

$this->context->setCommandScopeVariables($vars);
    }
}

[ Cancelar ]

Nome	Permissões	Ações
[ .. Voltar ]
📄 BufferCommand.php	0644	[ EDITAR/VER ]
📄 ClearCommand.php	0644	[ EDITAR/VER ]
📄 Command.php	0644	[ EDITAR/VER ]
📄 DocCommand.php	0644	[ EDITAR/VER ]
📄 DumpCommand.php	0644	[ EDITAR/VER ]
📄 EditCommand.php	0644	[ EDITAR/VER ]
📄 ExitCommand.php	0644	[ EDITAR/VER ]
📄 HelpCommand.php	0644	[ EDITAR/VER ]
📄 HistoryCommand.php	0644	[ EDITAR/VER ]
📁 ListCommand/	0755
📄 ListCommand.php	0644	[ EDITAR/VER ]
📄 ParseCommand.php	0644	[ EDITAR/VER ]
📄 PsyVersionCommand.php	0644	[ EDITAR/VER ]
📄 ReflectingCommand.php	0644	[ EDITAR/VER ]
📄 ShowCommand.php	0644	[ EDITAR/VER ]
📄 SudoCommand.php	0644	[ EDITAR/VER ]
📄 ThrowUpCommand.php	0644	[ EDITAR/VER ]
📄 TimeitCommand.php	0644	[ EDITAR/VER ]
📄 TraceCommand.php	0644	[ EDITAR/VER ]
📄 WhereamiCommand.php	0644	[ EDITAR/VER ]
📄 WtfCommand.php	0644	[ EDITAR/VER ]

📍 /home/diasdiamonds/public_html/adminarea/vendor/psy/psysh/src/Command

📝 Editando: ReflectingCommand.php