GraphQL\Language\Visitor::visit PHP Method

Visitor Class Documentation Usage Examples Of GraphQL\Language\Visitor::visit Show file Open project: webonyx/graphql-php

visit() public static method

By returning different values from the enter and leave functions, the behavior of the visitor can be altered, including skipping over a sub-tree of the AST (by returning false), editing the AST by returning a value or null to remove the value, or to stop the whole traversal by returning BREAK. When using visit() to edit an AST, the original AST will not be modified, and a new version of the AST with the changes applied will be returned from the visit function. var editedAST = visit(ast, { enter(node, key, parent, path, ancestors) { @return undefined: no action false: skip visiting this node visitor.BREAK: stop visiting altogether null: delete this node any value: replace this node with the returned value }, leave(node, key, parent, path, ancestors) { @return undefined: no action visitor.BREAK: stop visiting altogether null: delete this node any value: replace this node with the returned value } }); Alternatively to providing enter() and leave() functions, a visitor can instead provide functions named the same as the kinds of AST nodes, or enter/leave visitors at a named key, leading to four permutations of visitor API: 1) Named visitors triggered when entering a node a specific kind. visit(ast, { Kind(node) { enter the "Kind" node } }) 2) Named visitors that trigger upon entering and leaving a node of a specific kind. visit(ast, { Kind: { enter(node) { enter the "Kind" node } leave(node) { leave the "Kind" node } } }) 3) Generic visitors that trigger upon entering and leaving any node. visit(ast, { enter(node) { enter any node }, leave(node) { leave any node } }) 4) Parallel visitors for entering and leaving nodes of a specific kind. visit(ast, { enter: { Kind(node) { enter the "Kind" node } }, leave: { Kind(node) { leave the "Kind" node } } })

public static visit ( $root, $visitor, $keyMap = null )

    public static function visit($root, $visitor, $keyMap = null)
    {
        $visitorKeys = $keyMap ?: self::$visitorKeys;
        $stack = null;
        $inArray = is_array($root);
        $keys = [$root];
        $index = -1;
        $edits = [];
        $parent = null;
        $path = [];
        $ancestors = [];
        $newRoot = $root;
        $UNDEFINED = null;
        do {
            $index++;
            $isLeaving = $index === count($keys);
            $key = null;
            $node = null;
            $isEdited = $isLeaving && count($edits) !== 0;
            if ($isLeaving) {
                $key = count($ancestors) === 0 ? $UNDEFINED : array_pop($path);
                $node = $parent;
                $parent = array_pop($ancestors);
                if ($isEdited) {
                    if ($inArray) {
                        // $node = $node; // arrays are value types in PHP
                    } else {
                        $node = clone $node;
                    }
                    $editOffset = 0;
                    for ($ii = 0; $ii < count($edits); $ii++) {
                        $editKey = $edits[$ii][0];
                        $editValue = $edits[$ii][1];
                        if ($inArray) {
                            $editKey -= $editOffset;
                        }
                        if ($inArray && $editValue === null) {
                            array_splice($node, $editKey, 1);
                            $editOffset++;
                        } else {
                            if (is_array($node)) {
                                $node[$editKey] = $editValue;
                            } else {
                                $node->{$editKey} = $editValue;
                            }
                        }
                    }
                }
                $index = $stack['index'];
                $keys = $stack['keys'];
                $edits = $stack['edits'];
                $inArray = $stack['inArray'];
                $stack = $stack['prev'];
            } else {
                $key = $parent ? $inArray ? $index : $keys[$index] : $UNDEFINED;
                $node = $parent ? is_array($parent) ? $parent[$key] : $parent->{$key} : $newRoot;
                if ($node === null || $node === $UNDEFINED) {
                    continue;
                }
                if ($parent) {
                    $path[] = $key;
                }
            }
            $result = null;
            if (!is_array($node)) {
                if (!$node instanceof Node) {
                    throw new \Exception('Invalid AST Node: ' . json_encode($node));
                }
                $visitFn = self::getVisitFn($visitor, $node->kind, $isLeaving);
                if ($visitFn) {
                    $result = call_user_func($visitFn, $node, $key, $parent, $path, $ancestors);
                    if ($result !== null) {
                        if ($result instanceof VisitorOperation) {
                            if ($result->doBreak) {
                                break;
                            }
                            if (!$isLeaving && $result->doContinue) {
                                array_pop($path);
                                continue;
                            }
                            if ($result->removeNode) {
                                $editValue = null;
                            }
                        } else {
                            $editValue = $result;
                        }
                        $edits[] = [$key, $editValue];
                        if (!$isLeaving) {
                            if ($editValue instanceof Node) {
                                $node = $editValue;
                            } else {
                                array_pop($path);
                                continue;
                            }
                        }
                    }
                }
            }
            if ($result === null && $isEdited) {
                $edits[] = [$key, $node];
            }
            if (!$isLeaving) {
                $stack = ['inArray' => $inArray, 'index' => $index, 'keys' => $keys, 'edits' => $edits, 'prev' => $stack];
                $inArray = is_array($node);
                $keys = $inArray ? $node : $visitorKeys[$node->kind] ?: [];
                $index = -1;
                $edits = [];
                if ($parent) {
                    $ancestors[] = $parent;
                }
                $parent = $node;
            }
        } while ($stack);
        if (count($edits) !== 0) {
            $newRoot = $edits[0][1];
        }
        return $newRoot;
    }

Usage Example

Example #1

Show file

File: NoFragmentCycles.php Project: rtuin/graphql-php

 private function gatherSpreads($node)
 {
     $spreadNodes = [];
     Visitor::visit($node, [Node::FRAGMENT_SPREAD => function (FragmentSpread $spread) use(&$spreadNodes) {
         $spreadNodes[] = $spread;
     }]);
     return $spreadNodes;
 }

All Usage Examples Of GraphQL\Language\Visitor::visit

Visitor

getVisitFn

removeNode

skipNode

stop

visit

visitInParallel

visitWithTypeInfo