Does the given directive have an argument of the given name?

@param  \GraphQL\Language\AST\DirectiveNode  $directiveDefinition
@param  string  $name
@return bool
341970
public static function directiveHasArgument(DirectiveNode $directiveDefinition, string $name): bool
    {
        return (new Collection($directiveDefinition->arguments))
            ->contains(function (ArgumentNode $argumentNode) use ($name): bool {
                return $argumentNode->name->value === $name;
            });
    }
570922
public function removeDirective($name)
    {
        $name = strtolower(trim($name));
        unset($this->directives[$name]);
        return $this;
    }
865031
public function getDirective($name)
    {
        foreach ($this->getDirectives() as $directive) {
            if ($directive->getName() === $name) {
                return $directive;
            }
        }
        return NULL;
    }
768905
public function if($name, callable $callback)
    {
        $this->conditions[$name] = $callback;

        $this->directive($name, function ($expression) use ($name) {
            return $expression !== ''
                    ? "<?php if (\Illuminate\Support\Facades\Blade::check('{$name}', {$expression})): ?>"
                    : "<?php if (\Illuminate\Support\Facades\Blade::check('{$name}')): ?>";
        });

        $this->directive('else'.$name, function ($expression) use ($name) {
            return $expression !== ''
                ? "<?php elseif (\Illuminate\Support\Facades\Blade::check('{$name}', {$expression})): ?>"
                : "<?php elseif (\Illuminate\Support\Facades\Blade::check('{$name}')): ?>";
        });

        $this->directive('end'.$name, function () {
            return '<?php endif; ?>';
        });
    }
430405
public function providesMethod($name)
    {
        if (method_exists($this, $name)) {
            return true;
        }
        if ($this->text instanceof Generic) {
            return $this->text->providesMethod($name);
        }
        return false;
    }
675052
public function &__get($name)
    {
        list($result, $found) = $this->peridotScanChildren($this, function ($childScope, &$accumulator) use ($name) {
            if (property_exists($childScope, $name)) {
                $accumulator = [$childScope->$name, true, $childScope];
            }
        });
        if (!$found) {
            throw new DomainException("Scope property $name not found");
        }
        return $result;
    }
811739
protected function createOrFail(string $directiveName): Directive
    {
        foreach ($this->directiveBaseNamespaces as $baseNamespace) {
            $className = $baseNamespace.'\\'.Str::studly($directiveName).'Directive';
            if (class_exists($className)) {
                $directive = app($className);

                if (! $directive instanceof Directive) {
                    throw new DirectiveException("Class $className is not a directive.");
                }

                $this->addResolved($directiveName, $className);

                return $directive;
            }
        }

        throw new DirectiveException("No directive found for `{$directiveName}`");
    }
1027513
public function withArgument($name, $description, array $choices = [])
    {
        $this->choices[$name] = $choices;

        return $this->addArgument($name, InputArgument::REQUIRED, $description);
    }
511489
private function coerceName( $name ) {
		$coercedName = DOMUtils::coerceName( $name );
		if ( $name !== $coercedName ) {
			$this->coerced = true;
		}
		return $coercedName;
	}
57241
protected function shouldCommandBeAdded(string $commandName, array $commandDefinition): bool
    {
        $commandGroups = $this->getCommandGroups($commandDefinition);

        if ($this->isCommandExcluded($commandName, $commandDefinition, $commandGroups)) {
            return false;
        }

        if ($this->isGroupExcluded($commandGroups)) {
            return false;
        }

        if ($this->runOnlySpecified()) {
            return $this->isGroupRequested($commandGroups);
        }

        return true;
    }
786836
public function hasExtension($name)
    {
        return array_key_exists($name, $this->extensions) && $this->extensions[$name] instanceof EdgeExtensionInterface;
    }
939304
public function getDefinitionByName($name)
    {
        if (!array_key_exists($name, $this->definitions)) {
            throw new \InvalidArgumentException(sprintf('Can\'t find "%s" Definition.', $name));
        }

        return $this->definitions[$name];
    }
1225833
public function hasAnnotation($name)
    {
        $result = false;

        if (!string_ends_with($name, 'Annotation')) $name .= 'Annotation';

        foreach ($this->annotations as $annotation)
        {
            $class = get_class($annotation);

            if (string_starts_with($class, "\\") && !string_starts_with($name, "\\"))
                $name = "\\" . $name;
            elseif (!string_starts_with($class, "\\") && string_starts_with($name, "\\"))
                $name = substr($name, 1);

            if (string_ends_with($class, $name))
            {
                $result = true;
                break;
            }
        }

        return $result;
    }
653712
public function getDirective($name)
    {
        $name = strtolower(trim($name));
        return (isset($this->directives[$name]) ? $this->directives[$name] : null);
    }
659647
public function hasElement($name)
    {
        foreach($this->elements as $element){
            if($element->getName() == $name) {
                return true;
            }
        }

        return false;
    }
173413
protected function getOptionalNodeAttribute(\DOMNode $node, $name, $default = null)
    {
        $attribute = $node->attributes->getNamedItem($name);
        if ($attribute) {
            return $attribute->nodeValue;
        }

        return $default;
    }
1034372
public function getDefinition($name)
    {
        if (!$this->hasDefinition($name)) {
            throw new DcGeneralInvalidArgumentException('Data definition ' . $name . ' is not contained.');
        }

        return $this->definitions[$name];
    }