Check if the action requires a parent resource.

@param  string $methodName
@return bool
770177
protected function requiresParent(string $methodName)
    {
        if (in_array('*', $this->requiresParent)) {
            return true;
        }

        return in_array($methodName, $this->requiresParent);
    }
681937
private function isMethodExcluded($methodName, $attr)
    {
        if (empty($attr[self::CONFIG_EXCLUDE]) || !is_array($attr[self::CONFIG_EXCLUDE])) {
            return false;
        }

        return in_array($methodName, $attr[self::CONFIG_EXCLUDE]);
    }
718016
protected function isPropelQueryFactoryMethod(string $methodName): bool
    {
        $propelQueryFactoryMethodPattern = '/^get([a-zA-Z]+)PropelQuery$/';

        if (!preg_match($propelQueryFactoryMethodPattern, $methodName)) {
            return false;
        }

        return true;
    }
1193906
public function support(ResourceNode $resourceNode, string $actionName, string $method): bool
    {
        $action = $this->get($resourceNode, $actionName);

        if (empty($action) || !in_array($method, $action->getApi())) {
            return false;
        }

        return true;
    }
948845
public function isController(string $className) : bool
    {
        $refClass = new \ReflectionClass($className);


        foreach ($refClass->getMethods() as $refMethod) {
            $actionAnnotation = $this->annotationReader->getMethodAnnotation($refMethod, Action::class);
            if ($actionAnnotation) {
                return true;
            }
            $urlAnnotation = $this->annotationReader->getMethodAnnotation($refMethod, URL::class);
            if ($urlAnnotation) {
                return true;
            }
        }

        return false;
    }
332519
public function load(string $className): bool
   {
       if (($fileName = $this->fileName($className))) {
           require $fileName;
           return true;
       } 
       return false;
   }
1354564
protected function isActionAllowed($actionName)
    {
        switch ($actionName) {
            // autocomplete action is mapped to list action for access permissions
            case 'autocomplete':
            // embeddedList action is mapped to list action for access permissions
            case 'embeddedList':
                $actionName = 'list';
                break;
            // newAjax action is mapped to new action for access permissions
            case 'newAjax':
                $actionName = 'new';
                break;
            default:
                break;
        }

        // Get item for edit/show or custom actions => security voters may apply
        $easyadmin = $this->request->attributes->get('easyadmin');
        $subject = $easyadmin['item'] ?? null;
        $this->get(AdminAuthorizationChecker::class)->checksUserAccess($this->entity, $actionName, $subject);

        return parent::isActionAllowed($actionName);
    }
852806
public function call($methodName = null)
    {
        $this->setMethod($methodName);

        $curl = $this->getCurl();
        $curl->setParameters($this->getParameters());

        $this->log($this->getParameters(), 'Request to PayPal');

        $response = $curl->execute();

        $this->log($response, 'Response from PayPal');

        $this->validateResponse($response);

        return $response;
    }
632826
public function containsMethodAnnotation($annotationName)
    {
        foreach ($this->getMethodAnnotations() as $annotations) {
            foreach ($annotations as $annotation) {
                if ($annotation instanceof $annotationName) {
                    return true;
                }
            }
        }

        return false;
    }
690929
protected function isTagProcessorExclusion($className, $methodName, array $methodParams)
    {
        if (strpos($className, 'TagProcessor') === false) {
            // Not TagProcessor class.
            return false;
        }

        return count($methodParams) === 1 && $methodParams[0]['name'] === '$params';
    }
715679
public function call($mock, string $methodName)
    {
        $this->checkMockType($mock);

        return $this->doCall($mock, $methodName);
    }
281290
public static function doesClassExtendClass($childClassName, $parentClassName) {

        $reflectionClass = new \ReflectionClass ($childClassName);

        do {
            if ($reflectionClass->getName() == $parentClassName)
                return true;
            $reflectionClass = $reflectionClass->getParentClass();
        } while ($reflectionClass);

        // Assume false if we get this far
        return false;
    }
766155
public function getProperty(string $methodName): ?string
    {
        $pattern = implode('|', array_merge(self::ACCESSOR_PREFIXES, self::MUTATOR_PREFIXES));

        if (preg_match('/^('.$pattern.')(.+)$/i', $methodName, $matches)) {
            return $matches[2];
        }

        return null;
    }
355612
public static function autoload($className)
    {
        if (isset(self::$autoloadMap[$className])) {
            require self::$baseDir . self::$autoloadMap[$className];

            return true;
        }

        return false;
    }
1037011
protected function isExclusion($className, $methodName, $isPublic)
    {
        foreach ($this->exclusions as $classRegExp => $excludedMethods) {
            if (preg_match($classRegExp, $className)) {
                return ($excludedMethods[0] == '*' && $isPublic) || in_array($methodName, $excludedMethods);
            }
        }

        return false;
    }
27730
public function hasListeners($eventName = null)
    {
        return ($this->symfonyDispatcher->hasListeners($eventName) ||
            $this->laravelDispatcher->hasListeners($eventName));
    }
1334523
private function isPackageRequired(string $packageName): bool
    {
        foreach ($this->composer->getPackage()->getRequires() as $require) {
            if ($require->getTarget() === $packageName) {
                return true;
            }
        }

        return false;
    }