import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
private List<Pair<PsiElement, String>> getElementNamePairs(YAMLDocument yamlDocument, String elementName) {
    final PsiElement psiElement = findChildRecursively(yamlDocument, new String[]{elementName});
    if (psiElement == null) {
        return Collections.emptyList();
    }

    List<Pair<PsiElement, String>> elementStringPairs = new ArrayList<>();
    try (BufferedReader reader = new BufferedReader(new StringReader(psiElement.getText()))) {
        for (String line; (line = reader.readLine()) != null;) {
            final Matcher matcher = keyInListPattern.matcher(line);
            if (matcher.find()) {
                String elementNameGroup = matcher.group(1);
                YAMLPsiElement childElement = findChildRecursively((YAMLPsiElement) psiElement, new String[]{elementNameGroup});
                PsiElement elementToHighlight = (childElement != null) ? childElement : ((psiElement instanceof YAMLKeyValue) ? ((YAMLKeyValue) psiElement).getKey() : psiElement);
                elementStringPairs.add(new ImmutablePair<>(elementToHighlight, elementNameGroup));
            }
        }
    } catch (IOException ignore) {  // this code is never reached because the reader reads from memory
    }
    return elementStringPairs;
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
public YamlCompletionContributor() {

        extend(
            CompletionType.BASIC, PlatformPatterns.psiElement().withParent(PlatformPatterns.psiElement(YAMLDocument.class)).inFile(
            PlatformPatterns.psiFile().withName(PlatformPatterns.string().endsWith(".info.yml"))
        ),
            new CompletionProvider<CompletionParameters>() {
                @Override
                protected void addCompletions(@NotNull CompletionParameters completionParameters, ProcessingContext processingContext, @NotNull CompletionResultSet completionResultSet) {

                    if(!DrupalProjectComponent.isEnabled(completionParameters.getOriginalPosition())) {
                        return;
                    }

                    for(String key: MODULE_KEYS) {
                        completionResultSet.addElement(LookupElementBuilder.create(key).withIcon(DrupalIcons.DRUPAL));
                    }

                }
            }
        );
    }
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
@Override
public void visitFile(PsiFile file) {
    // @TODO: detection of routing files in right way
    // routing.yml
    // comment.routing.yml
    // routing/foo.yml
    if(!YamlHelper.isRoutingFile(file)) {
        return;
    }

    YAMLDocument document = PsiTreeUtil.findChildOfType(file, YAMLDocument.class);
    if(document == null) {
        return;
    }

    YAMLValue topLevelValue = document.getTopLevelValue();
    if(topLevelValue != null) {
        YamlHelper.attachDuplicateKeyInspection(topLevelValue, holder);
    }
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
/**
 * @see fr.adrienbrault.idea.symfony2plugin.routing.RouteHelper#getYamlRouteDefinitions
 */
public void testGetYamlRouteDefinitionsWithMethods() {
    Collection<StubIndexedRoute> yamlRouteDefinitions = RouteHelper.getYamlRouteDefinitions(YamlPsiElementFactory.createFromText(getProject(), YAMLDocument.class,
        "route1:\n" +
        "    path: /foo\n" +
        "    methods: [GET]\n" +
        "route2:\n" +
        "    path: /foo\n" +
        "    methods: GET\n" +
        "route3:\n" +
        "    path: /foo\n" +
        "    methods: [GET,   POST]\n"
    ));

    assertContainsElements(Collections.singletonList("get"), ContainerUtil.find(yamlRouteDefinitions, new MyEqualStubIndexedRouteCondition("route1")).getMethods());
    assertContainsElements(Collections.singletonList("get"), ContainerUtil.find(yamlRouteDefinitions, new MyEqualStubIndexedRouteCondition("route2")).getMethods());
    assertContainsElements(Arrays.asList("get", "post"), ContainerUtil.find(yamlRouteDefinitions, new MyEqualStubIndexedRouteCondition("route3")).getMethods());
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
public List<YAMLDocument> getDocuments() {
    final ArrayList<YAMLDocument> result = new ArrayList<>();
    for (ASTNode node : getNode().getChildren(TokenSet.create(YAMLElementTypes.DOCUMENT))) {
        result.add((YAMLDocument) node.getPsi());
    }
    return result;
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
public static List<YAMLDocument> findCoffigDocuments(Project project) {
    List<YAMLDocument> result = new ArrayList<>();
    for (VirtualFile virtualFile : findCoffigFiles(project)) {
        YAMLFile coffigFile = (YAMLFile) PsiManager.getInstance(project).findFile(virtualFile);
        if (coffigFile != null) {
            result.addAll(coffigFile.getDocuments());
        }
    }
    return result;
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
public static Set<YAMLKeyValue> findCoffigKeys(Project project, String path) {
    Set<YAMLKeyValue> results = new HashSet<>();
    for (YAMLDocument yamlDocument : findCoffigDocuments(project)) {
        YAMLKeyValue yamlKeyValue = searchForKey(yamlDocument, path.split("\\."), 0);
        if (yamlKeyValue != null) {
            results.add(yamlKeyValue);
        }
    }
    return results;
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
public List<YAMLDocument> getDocuments()
{
    ArrayList<YAMLDocument> result = new ArrayList<>();
    ASTNode[] var2 = this.getNode().getChildren(TokenSet.create(YAMLElementTypes.DOCUMENT));
    for (ASTNode node : var2)
    {
        result.add((YAMLDocument) node.getPsi());
    }

    return result;
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
@Override
public void apply(@NotNull PsiFile file, List<RuntimeException> annotationResult, @NotNull AnnotationHolder holder) {
    if (file instanceof YAMLFile) {
        YAMLFile yamlFile = (YAMLFile) file;
        if (!yamlFile.getDocuments().isEmpty()) {
            YAMLDocument yamlDocument = yamlFile.getDocuments().get(0);
            PsiElement found = findChildRecursively(yamlDocument, new String[]{"flow", "operation", "decision"});
            if (found instanceof YAMLKeyValue) {
                YAMLKeyValue keyValue = (YAMLKeyValue) found;
                found = keyValue.getKey();
            } else {
                found = yamlDocument;
            }
            createErrorAnnotations(found, yamlFile, holder, annotationResult);
            createWarningsForMissingElementsInDescription(yamlDocument, yamlFile, holder);
        }
        if (!annotationResult.isEmpty()) {
            HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                    .descriptionAndTooltip("Found " + annotationResult.size() + " errors")
                    .range(file).create();
            if (highlightInfo != null) {
                Problem problem = new ProblemImpl(file.getVirtualFile(), highlightInfo, true);
                WolfTheProblemSolver theProblemSolver = WolfTheProblemSolver.getInstance(file.getProject());
                theProblemSolver.reportProblems(file.getVirtualFile(), Collections.singletonList(problem));
            }
        }
    }
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
@Override
public void collectSlowLineMarkers(@NotNull List<PsiElement> elements, @NotNull Collection<LineMarkerInfo> result) {
    for (PsiElement el : elements) {
        if (!NeosProjectComponent.isEnabled(el)) {
            return;
        }

        if (!el.getContainingFile().getVirtualFile().getName().startsWith("NodeTypes.")) {
            continue;
        }

        if (!(el instanceof YAMLKeyValue)) {
            continue;
        }

        YAMLMapping parentMapping = ((YAMLKeyValue) el).getParentMapping();
        if (parentMapping != null && parentMapping.getParent() instanceof YAMLDocument) {
            String nodeType = ((YAMLKeyValue) el).getKeyText();
            String[] nodeTypeSplit = nodeType.split(":");

            if (nodeTypeSplit.length < 2) {
                continue;
            }

            List<PsiElement> targets = ResolveEngine.getPrototypeDefinitions(el.getProject(), nodeTypeSplit[1], nodeTypeSplit[0]);
            if (!targets.isEmpty()) {
                RelatedItemLineMarkerInfo info = NavigationGutterIconBuilder
                        .create(FusionIcons.PROTOTYPE)
                        .setTargets(targets)
                        .setTooltipText("Go to Fusion prototype")
                        .createLineMarkerInfo(el);
                result.add(info);
            }
        }
    }
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
/**
 * Gets the top-level mapping in the document, if present.
 *
 * @param element an element within the document.
 * @return the top-level mapping, or {@code null} if one is not defined (e.g. in an empty document).
 */
@Nullable
public static YAMLMapping getTopLevelMapping(final PsiElement element) {
    final YAMLDocument document = PsiTreeUtil.getParentOfType(element, YAMLDocument.class);
    if (document != null) {
        final YAMLValue topLevelValue = document.getTopLevelValue();
        if (topLevelValue instanceof YAMLMapping) {
            return (YAMLMapping) topLevelValue;
        }
    }
    return null;
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
public static String findGUIDFromFile(@NotNull YAMLFile psiFile)
{
	String guid = null;
	List<YAMLDocument> documents = psiFile.getDocuments();
	for(YAMLDocument document : documents)
	{
		YAMLValue topLevelValue = document.getTopLevelValue();
		if(topLevelValue instanceof YAMLMapping)
		{
			YAMLKeyValue guidValue = ((YAMLMapping) topLevelValue).getKeyValueByKey(Unity3dMetaManager.GUID_KEY);
			guid = guidValue == null ? null : guidValue.getValueText();
		}
	}
	return guid;
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
@NotNull
@Override
public Collection<PsiElement> getPsiTargets(PsiElement psiElement) {

    PsiElement element = psiElement.getParent();
    if(!(element instanceof StringLiteralExpression)) {
        return Collections.emptyList();
    }

    final String contents = ((StringLiteralExpression) element).getContents();
    if(StringUtils.isBlank(contents)) {
        return Collections.emptyList();
    }

    final Collection<PsiElement> psiElements = new ArrayList<>();
    FileBasedIndex.getInstance().getFilesWithKey(ConfigSchemaIndex.KEY, new HashSet<>(Collections.singletonList(contents)), virtualFile -> {

        PsiFile psiFile = PsiManager.getInstance(getProject()).findFile(virtualFile);
        if(psiFile == null) {
            return true;
        }

        YAMLDocument yamlDocument = PsiTreeUtil.getChildOfType(psiFile, YAMLDocument.class);
        if(yamlDocument == null) {
            return true;
        }

        for(YAMLKeyValue yamlKeyValue: PsiTreeUtil.getChildrenOfTypeAsList(yamlDocument, YAMLKeyValue.class)) {
            String keyText = PsiElementUtils.trimQuote(yamlKeyValue.getKeyText());
            if(StringUtils.isNotBlank(keyText) && keyText.equals(contents)) {
                psiElements.add(yamlKeyValue);
            }
        }

        return true;
    }, GlobalSearchScope.getScopeRestrictedByFileTypes(GlobalSearchScope.allScope(getProject()), YAMLFileType.YML));

    return psiElements;
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
/**
 * @see fr.adrienbrault.idea.symfony2plugin.routing.RouteHelper#getYamlRouteDefinitions
 */
public void testGetYamlRouteDefinitionsForControllerKeyword() {
    Collection<StubIndexedRoute> yamlRouteDefinitions = RouteHelper.getYamlRouteDefinitions(YamlPsiElementFactory.createFromText(getProject(), YAMLDocument.class,
        "foo_keyword:\n" +
            "   path: /foo\n" +
            "   controller: 'AppBundle:Blog:list'\n"
    ));

    StubIndexedRoute route = ContainerUtil.find(yamlRouteDefinitions, new MyEqualStubIndexedRouteCondition("foo_keyword"));
    assertNotNull(route);

    assertContainsElements(Collections.singletonList("AppBundle:Blog:list"), route.getController());
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
private boolean isKey(PsiElement position) {
    PsiElement parentContext = position.getParent().getContext();
    PsiElement leftContext = Optional.ofNullable(position.getContext()).map(PsiElement::getPrevSibling).orElse(null);
    return parentContext instanceof YAMLMapping || parentContext instanceof YAMLDocument || leftContext != null && ((LeafPsiElement) leftContext).getElementType() == YAMLTokenTypes.INDENT;
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
private void createWarningsForMissingElementsInDescription(YAMLDocument yamlDocument, YAMLFile yamlFile, AnnotationHolder holder) {
    List<PsiElement> commentsList = Arrays.stream(yamlFile.getChildren()).filter(e -> e instanceof PsiComment).collect(toList());
    for (int index = 0; index < keysForDocumentation.length; index++) {
        createWarningsIfNecessary(keysForDescription[index], commentsList, holder, getElementNamePairs(yamlDocument, keysForDocumentation[index]));
    }
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
@Override
protected void addCompletions(@NotNull CompletionParameters completionParameters, ProcessingContext processingContext, @NotNull CompletionResultSet completionResultSet) {

    PsiElement element = completionParameters.getPosition();
    if(!Symfony2ProjectComponent.isEnabled(element)) {
        return;
    }

    PsiElement yamlScalar = element.getParent();
    if(yamlScalar == null) {
        return;
    }

    PsiElement yamlCompount = yamlScalar.getParent();

    // yaml document root context
    if(yamlCompount.getParent() instanceof YAMLDocument) {
        attachRootConfig(completionResultSet, element);
        return;
    }

    // check inside yaml key value context
    if(!(yamlCompount instanceof YAMLCompoundValue || yamlCompount instanceof YAMLKeyValue)) {
        return;
    }

    // get all parent yaml keys
    List<String> items = YamlHelper.getParentArrayKeys(element);
    if(items.size() == 0) {
        return;
    }

    // normalize for xml
    items = ContainerUtil.map(items, s -> s.replace('_', '-'));

    // reverse to get top most item first
    Collections.reverse(items);

    Document document = getConfigTemplate(element.getProject().getBaseDir());
    if(document == null) {
        return;
    }

    Node configNode = getMatchingConfigNode(document, items);
    if(configNode == null) {
        return;
    }

    getConfigPathLookupElements(completionResultSet, configNode, false);

    // map shortcuts like eg <dbal default-connection="">
    if(configNode instanceof Element) {
        NamedNodeMap attributes = configNode.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {
            String attributeName = attributes.item(i).getNodeName();
            if(attributeName.startsWith("default-")) {
                Node defaultNode = getElementByTagNameWithUnPluralize((Element) configNode, attributeName.substring("default-".length()));
                if(defaultNode != null) {
                    getConfigPathLookupElements(completionResultSet, defaultNode, true);
                }
            }
        }
    }

}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
/**
 * @see fr.adrienbrault.idea.symfony2plugin.routing.RouteHelper#getYamlRouteDefinitions
 */
public void testGetYamlRouteDefinitionsAsHashAndKeyValue() {
    Collection<String[]> providers = new ArrayList<String[]>() {{
        add(new String[] {"'MyController::fooAction'", "MyController::fooAction"});
        add(new String[] {"MyController::fooAction", "MyController::fooAction"});
        add(new String[] {"\"MyController::fooAction\"", "MyController::fooAction"});
    }};

    for (String[] provider : providers) {
        Collection<YAMLDocument> yamlDocuments = new ArrayList<YAMLDocument>();

        yamlDocuments.add(YamlPsiElementFactory.createFromText(getProject(), YAMLDocument.class, String.format(
                "route1:\n" +
                "    path: /foo\n" +
                "    defaults: { _controller: %s }",
            provider[1]
        )));

        yamlDocuments.add(YamlPsiElementFactory.createFromText(getProject(), YAMLDocument.class, String.format(
            "route1:\n" +
                "    path: /foo\n" +
                "    defaults:\n" +
                "       _controller: %s",
            provider[1]
        )));

        yamlDocuments.add(YamlPsiElementFactory.createFromText(getProject(), YAMLDocument.class, String.format(
            "route1:\n" +
                "    pattern: /foo\n" +
                "    defaults:\n" +
                "       _controller: %s",
            provider[1]
        )));

        for (YAMLDocument yamlDocument : yamlDocuments) {
            StubIndexedRoute route1 = ContainerUtil.find(RouteHelper.getYamlRouteDefinitions(yamlDocument), new MyEqualStubIndexedRouteCondition("route1"));
            assertNotNull(route1);

            assertEquals(provider[1], route1.getController());
            assertEquals("route1", route1.getName());
            assertEquals("/foo", route1.getPath());
        }
    }
}
 

import org.jetbrains.yaml.psi.YAMLDocument; //导入依赖的package包/类
/**
 * Gets whether a given {@link YAMLKeyValue} is at the root level of the document.
 *
 * @param keyValue the element to evaluate.
 * @return {@code true} if this is a top-level mapping; otherwise, {@code false}.
 */
private static boolean isTopLevelMapping(final YAMLKeyValue keyValue) {
    return keyValue.getParentMapping() != null && keyValue.getParentMapping().getParent() instanceof YAMLDocument;
}