Add a class / method to the debug method blacklist

@api

@param string $class
The class, where  the method is hosted,
@param string $methodName
The name of the method.
427883
public static function addMethodToDebugBlacklist($class, $methodName)
    {
        if (isset(static::$blacklistDebugMethods[$class]) === false) {
            static::$blacklistDebugMethods[$class] = array();
        }
        if (in_array($methodName, static::$blacklistDebugMethods[$class]) === false) {
            static::$blacklistDebugMethods[$class][] = $methodName;
        }
    }
30371
private function initializeMethodNamesMap($class)
    {
        $this->serviceIdToMethodNameMap = array();
        $this->usedMethodNames = array();

        try {
            $reflectionClass = new \ReflectionClass($class);
            foreach ($reflectionClass->getMethods() as $method) {
                $this->usedMethodNames[strtolower($method->getName())] = true;
            }
        } catch (\ReflectionException $e) {
        }
    }
117354
public function addClass($class, $extends = null, $implements = [])
    {
        $classId = $this->registerClass($class);
        if ($extends) {
            $parentClassId = $this->registerClass($extends);
            $this->extends[$classId] = [$parentClassId];
        }
        if (!empty($implements)) {
            $interfaceIds = [];
            foreach ($implements as $interface) {
                $interfaceIds[] = $this->registerInterface($interface);
            }
            $this->implements[$classId] = $interfaceIds;
        }
    }
1019562
public static function listMethodsFromClass($class)
    {
        $filteredMethods = array();
        $reflection = new ReflectionClass($class);
        $methods = $reflection->getMethods();
        //Todo: lets make a better solution for this
        foreach ($methods as $method) {
            if ($class === $method->class) {
                $filteredMethods[] = $method;
            }
        }
        return $filteredMethods;
    }
141843
private function getMethodParameters(string $class, string $methodName) : array
    {
        $methodReflection = new ReflectionMethod($class, $methodName);
        $parametersName   = [];

        foreach ($methodReflection->getParameters() as $parameter) {
            $parametersName[] = $parameter->name;
        }

        return $parametersName;
    }
297091
public static void setDebuggerClass(Class<? extends SmackDebugger> debuggerClass) {
        if (debuggerClass == null) {
            System.clearProperty(DEBUGGER_CLASS_PROPERTY_NAME);
        } else {
            System.setProperty(DEBUGGER_CLASS_PROPERTY_NAME, debuggerClass.getCanonicalName());
        }
    }
540327
public function HasNewMethod($ClassName, $MethodName) {
      $Key = strtolower($ClassName.'_'.$MethodName.'_Create');
      if (array_key_exists($Key, $this->_NewMethodCollection)) {
         $Result = explode('.', $this->_NewMethodCollection[$Key]);
         return $Result[0];
      } else {
         return FALSE;
      }
   }
1242693
public function disallowMethod($class, $method = null)
    {
        if (is_array($class)) {
            foreach ($class as $elem) {
                unset($this->allowedMethods[strtolower($elem[0])][strtolower($elem[1])]);
            }
        } else {
            unset($this->allowedMethods[strtolower($class)][strtolower($method)]);
        }
    }
1033013
public function afterCompile(Nette\PhpGenerator\ClassType $class)
	{
		$initialize = $class->getMethod('initialize');
		$builder = $this->getContainerBuilder();

		if ($builder->parameters['debugMode'] && $builder->hasDefinition(self::TRACY_PANEL)) {
			$initialize->addBody($builder->formatPhp('?;', [
				new Nette\DI\Statement('@Tracy\Bar::addPanel', ['@' . self::TRACY_PANEL, self::TRACY_PANEL]),
			]));
		}
	}
284079
public function logFeature(string $class, string $method, array $args) : void
    {
        if (!isset($this->logged[$class])) {
            $this->logged[$class] = [];
        }
        if (!isset($this->logged[$class][$method])) {
            $this->logged[$class][$method] = [];
        }
        if (!in_array($args, $this->logged[$class][$method])) {
            $this->logged[$class][$method][] = $args;
        }
    }
1133589
public function isAllowedDebugCall($data)
    {
        // Check if the class itself is blacklisted.
        foreach ($this->classBlacklist as $classname) {
            if (is_a($data, $classname) === true) {
                // No debug methods for you.
                return false;
            }
        }

        // Nothing found?
        return true;
    }
1276304
public static void debug(Logger log, String methodName) {
        if (log.isDebugEnabled())
            log.debug(buildMethodLogString(methodName));
    }
276783
public function aliasClass($class)
    {
        if (Str::contains($class, '\\')) {
            return;
        }

        $fullName = isset($this->classes[$class])
            ? $this->classes[$class]
            : false;

        if ($fullName) {
            $this->shell->writeStdout("[!] Aliasing '{$class}' to '{$fullName}' for this Tinker session.\n");

            class_alias($fullName, $class);
        }
    }
990009
public function matchesMethod($className, $methodName): bool
    {
        $this->initialize();

        $methodIdentifier = strtolower($className . '->' . $methodName);
        if (isset(static::$methodPermissions[$methodIdentifier][$this->getCacheEntryIdentifier()])) {
            return true;
        }

        return false;
    }
1109264
public function addMethod(MethodGenerator $method)
    {
        $name = $method->getName();
        if (isset($this->methods[$name]) === true) {
            throw new InvalidArgumentException('Method name "' . $name . '" already added.');
        }

        $this->methods[$name] = $method;
    }
636324
public function section($name, $class = null)
    {
        /** @var \Foil\Contracts\SectionInterface $section */
        $section = $this->factory->factory($name, $this->mode(), $class);
        $section->start();
        $this->stack->push($section);
        $this->names->push($name);
    }
705770
public function remove($class, $method)
    {
        $callback = $class . '::' . $method;
        if (isset($this->configs['instances'][$callback])) {
            unset($this->configs['instances'][$callback], $this->configs['log'][$callback]);
            App::$Properties->writeConfig('Cron', $this->configs);
        }
    }