import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@NotNull
@Override
public Collection<PsiReference> findReferences( PsiElement element )
{
  Collection<PsiReference> references = super.findReferences( element );

  if( element instanceof JsonProperty )
  {
    //## hack: IJ's json parser considers all properties having the same name as the same reference, which is total crap
    references.clear();
  }

  // Store refs to manifold types
  storeTypeManifoldReferences( element );

  return references;
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
private static String getHomePage(PsiDirectory directory) {
    PsiFile pkg = directory.findFile("package.json");
    if (pkg != null && pkg instanceof JsonFile) {
        if (((JsonFile) pkg).getTopLevelValue() instanceof JsonObject) {
            JsonObject object = (JsonObject) ((JsonFile) pkg).getTopLevelValue();
            if (object != null) {
                JsonProperty homePage = object.findProperty("homepage");
                if (homePage != null && homePage.getValue() != null && homePage.getValue() instanceof JsonStringLiteral) {
                    JsonStringLiteral propValue = (JsonStringLiteral) homePage.getValue();
                    return propValue.getValue();
                }
            }
        }
    }
    return null;
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
private static PsiFile getMain(PsiDirectory moduleRoot) {
    PsiFile pkg = moduleRoot.findFile("package.json");
    if (pkg != null && pkg instanceof JsonFile) {
        if (((JsonFile) pkg).getTopLevelValue() instanceof JsonObject) {
            JsonObject object = (JsonObject) ((JsonFile) pkg).getTopLevelValue();
            if (object != null) {
                JsonProperty property = object.findProperty("main");
                if (property != null && property.getValue() != null && property.getValue() instanceof JsonStringLiteral) {
                    JsonStringLiteral propValue = (JsonStringLiteral) property.getValue();
                    String value = propValue.getValue();
                    PsiFile psiFile = moduleRoot.findFile(value.replace("./", ""));
                    return psiFile;
                }
            }
        }
    }
    return null;
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
public static String getModuleName(PsiDirectory dir) {
    PsiFile pkg = dir.findFile("package.json");
    String name = dir.getName();
    if (pkg != null && pkg instanceof JsonFile) {
        if (((JsonFile) pkg).getTopLevelValue() instanceof JsonObject) {
            JsonObject object = (JsonObject) ((JsonFile) pkg).getTopLevelValue();
            if (object != null) {
                JsonProperty property = object.findProperty("name");
                JsonProperty property1 = object.findProperty("version");
                if (property != null && property.getValue() != null && property.getValue() instanceof JsonStringLiteral) {
                    JsonStringLiteral propValue = (JsonStringLiteral) property.getValue();
                    name = propValue.getValue();
                    if (property1 != null && property1.getValue() != null && property1.getValue() instanceof JsonStringLiteral) {
                        JsonStringLiteral propValue1 = (JsonStringLiteral) property1.getValue();
                        name = name + ":" + propValue1.getValue();
                    }
                }
            }
        }
    }
    return name;
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@Nullable
@Override
public Result<TemplateEngine> compute() {
  final JsonFile packageJsonFile = findPackageJsonFile();
  if (packageJsonFile == null)
    return Result.create(null, tracker.getValue());

  if(packageJsonFile.getTopLevelValue()==null)
    return Result.create(null, packageJsonFile);

  JsonValue dependencies = JsonPsiUtil.findPropertyValue(packageJsonFile.getTopLevelValue(), "dependencies");
  if(dependencies == null)
    return Result.create(null, packageJsonFile);
  List<JsonProperty> properties = PsiTreeUtil.getChildrenOfTypeAsList(dependencies, JsonProperty.class);
  for (JsonProperty property : properties) {
    TemplateEngine engine = engines.get(property.getName());
    if (engine != null)
      return Result.create(engine, packageJsonFile);
  }
  return Result.create(null, packageJsonFile);
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@Nullable
public static JsonValue findPropertyValue(@Nullable final JsonValue rootValue, @NotNull final String path) {
  if(rootValue == null)
    return null;

  JsonValue currentValue = rootValue;
  for(final String name : path.split("/")) {
    List<JsonProperty> properties = PsiTreeUtil.getChildrenOfTypeAsList(currentValue, JsonProperty.class);
    boolean found = false;
    for (JsonProperty property : properties) {
      if (!property.getName().equals(name))
        continue;
      currentValue = property.getValue();
      found = true;
    }
    if (!found)
      return null;
  }
  return currentValue;

}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@NotNull
public static Map<String, PsiFile> findComponents(@NotNull final Project project) {
  Map<String, PsiFile> result = new HashMap<String, PsiFile>();
  Collection<VirtualFile> virtualFiles =
      FileBasedIndex.getInstance().getContainingFiles(FilenameIndex.NAME, CatberryConstants.CAT_COMPONENT_JSON,
          GlobalSearchScope.allScope(project));
  for (VirtualFile virtualFile : virtualFiles) {
    JsonFile psiFile = (JsonFile) PsiManager.getInstance(project).findFile(virtualFile);
    if (psiFile != null) {
      JsonProperty[] properties = PsiTreeUtil.getChildrenOfType(psiFile.getTopLevelValue(), JsonProperty.class);
      if (properties != null) {
        for (JsonProperty property : properties) {
          if (!property.getName().equals("name"))
            continue;
          if (property.getValue() != null && property.getValue() instanceof JsonStringLiteral)
            result.put(((JsonStringLiteral) property.getValue()).getValue(), psiFile);
          break;
        }
      }
    }
  }
  return result;
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
private Set<String> getPartialJsonSwaggerFileNames(final PsiFile file) {
    final Set<String> result = new HashSet<>();

    file.accept(new JsonRecursiveElementVisitor() {
        @Override
        public void visitProperty(@NotNull JsonProperty property) {
            if (SwaggerConstants.REF_KEY.equals(property.getName())) {
                if (property.getValue() != null) {
                    final String refValue = StringUtils.removeAllQuotes(property.getValue().getText());
                    if (refValue.contains(FileConstants.JSON_FILE_NAME_SUFFIX)) {
                        result.add(extractFileNameFromFileRefValue(refValue) + DELIMITER +
                                getSwaggerFileType(property.getValue(), refValue));
                    }
                }
            }
            super.visitProperty(property);
        }
    });

    return result;
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@NotNull
@Override
public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, boolean isOnTheFly) {
  return new JsonElementVisitor() {
    @Override
    public void visitObject(@NotNull JsonObject o) {
      final MultiMap<String, PsiElement> keys = new MultiMap<String, PsiElement>();
      for (JsonProperty property : o.getPropertyList()) {
        keys.putValue(property.getName(), property.getNameElement());
      }
      for (Map.Entry<String, Collection<PsiElement>> entry : keys.entrySet()) {
        final Collection<PsiElement> sameNamedKeys = entry.getValue();
        if (sameNamedKeys.size() > 1) {
          for (PsiElement element : sameNamedKeys) {
            holder.registerProblem(element, JsonBundle.message("inspection.duplicate.keys.msg.duplicate.keys", entry.getKey()));
          }
        }
      }
    }
  };
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@Override
public void apply(@NotNull Editor editor, @NotNull JsonSmartEnterProcessor processor, @NotNull PsiElement element)
  throws IncorrectOperationException {
  if (element instanceof JsonProperty) {
    final JsonValue propertyValue = ((JsonProperty)element).getValue();
    if (propertyValue != null) {
      if (terminatedOnCurrentLine(editor, propertyValue) && !isFollowedByTerminal(propertyValue, COMMA)) {
        editor.getDocument().insertString(propertyValue.getTextRange().getEndOffset(), ",");
        processor.myShouldAddNewline = true;
      }
    }
    else {
      final JsonValue propertyKey = ((JsonProperty)element).getNameElement();
      final int keyEndOffset = propertyKey.getTextRange().getEndOffset();
      //processor.myFirstErrorOffset = keyEndOffset;
      if (terminatedOnCurrentLine(editor, propertyKey) && !isFollowedByTerminal(propertyKey, COLON)) {
        processor.myFirstErrorOffset = keyEndOffset + 2;
        editor.getDocument().insertString(keyEndOffset, ": ");
      }
    }
  }
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@NotNull
@Override
public String getElementInfo(@NotNull PsiElement e) {
  if (e instanceof JsonProperty) {
    return ((JsonProperty)e).getName();
  }
  //else if (isArrayElement(e)) {
  //  List<JsonValue> elements = ((JsonArray)e.getParent()).getValueList();
  //  for (int i = 0; i < elements.size(); i++) {
  //    if (e == elements.get(i)) {
  //      return String.valueOf(i);
  //    }
  //  }
  //}
  throw new AssertionError("Breadcrumbs can be extracted only from JsonProperty elements");
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@Nullable
private static String getValue(@NotNull final JsonProperty property) {
  final JsonValue value = property.getValue();

  if(!(value instanceof JsonStringLiteral)) {
    return null;
  }

  final JsonStringLiteral literal = (JsonStringLiteral)value;
  final String text = literal.getText();

  if(isNullOrEmpty(text) || text.length() < 3) {
    return null;
  }

  return text.substring(1, text.length() - 1);
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@Override
public void registerReferenceProviders(@NotNull final PsiReferenceRegistrar registrar) {
  registrar.registerReferenceProvider(
      psiElement(PsiLiteralExpression.class).
          withSuperParent(3, psiElement(PsiAnnotation.class)),
      new InjectionReferenceProvider()
  );

  registrar.registerReferenceProvider(
      psiElement(PsiLiteralExpression.class).
          withSuperParent(3, psiElement(PsiAnnotation.class)),
      new InjectorReferenceProvider()
  );

  registrar.registerReferenceProvider(
      psiElement(PsiLiteralExpression.class).
          withLanguage(JavaLanguage.INSTANCE).
          withSuperParent(3, psiElement(PsiAnnotation.class)),
      new MacroReferenceProvider()
  );

  registrar.registerReferenceProvider(
      psiElement(JsonProperty.class).withLanguage(JsonLanguage.INSTANCE),
      new MainClassReferenceProvider()
  );
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonLiteral> localReferencePattern(final String refTypePrefix) {
    return psiElement(JsonLiteral.class)
            .withParent(psiElement(JsonProperty.class).withName(OpenApiConstants.REF_KEY))
            .withText(StandardPatterns.string().contains(refTypePrefix))
            .andNot(StandardPatterns.string().contains(FileConstants.JSON_FILE_NAME_SUFFIX))
            .withLanguage(JsonLanguage.INSTANCE);
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonLiteral> localDefinitionsPattern() {
    return swagger(psiElement(JsonLiteral.class)
            .withParent(psiElement(JsonProperty.class).withName(SwaggerConstants.REF_KEY))
            .withText(StandardPatterns.string().contains(SwaggerConstants.LOCAL_DEFINITIONS_PREFIX))
            .andNot(StandardPatterns.string().contains(FileConstants.JSON_FILE_NAME_SUFFIX))
            .withLanguage(JsonLanguage.INSTANCE));
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@Override
public boolean isIncomplete() {
  final ASTNode lastChildNode = myNode.getLastChildNode();
  if (hasElementType(myNode, OBJECT)) {
    return lastChildNode != null && lastChildNode.getElementType() != R_CURLY;
  }
  else if (hasElementType(myNode, ARRAY)) {
    return lastChildNode != null && lastChildNode.getElementType() != R_BRACKET;
  }
  else if (hasElementType(myNode, PROPERTY)) {
    return ((JsonProperty)myPsiElement).getValue() == null;
  }
  return false;
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@Nullable
@Override
public String getQualifiedName(PsiElement element) {
  if (!(element instanceof JsonElement)) {
    return null;
  }
  final LinkedList<String> qualifiers = new LinkedList<String>();
  JsonProperty parentProperty = PsiTreeUtil.getNonStrictParentOfType(element, JsonProperty.class);
  while (parentProperty != null) {
    qualifiers.addFirst(parentProperty.getName());
    parentProperty = PsiTreeUtil.getParentOfType(parentProperty, JsonProperty.class);
  }
  return qualifiers.isEmpty() ? null : StringUtil.join(qualifiers, ".");
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@NotNull
@Override
public String getType(@NotNull PsiElement element) {
  if (element instanceof JsonProperty) {
    return "property";
  }
  return "";
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@Override
public boolean isReferenceTo(PsiElement element) {
  if (!(element instanceof JsonProperty)) {
    return false;
  }
  // May reference to the property with the same name for compatibility with JavaScript JSON support
  final JsonProperty otherProperty = (JsonProperty)element;
  final PsiElement selfResolve = resolve();
  return otherProperty.getName().equals(getCanonicalText()) && selfResolve != otherProperty;
}
 

import com.intellij.json.psi.JsonProperty; //导入依赖的package包/类
@Nullable
@Override
public Result<Map<String, JsonProperty>> compute() {
  final Map<String, JsonProperty> cache = new HashMap<String, JsonProperty>();
  for (JsonProperty property : getPropertyList()) {
    final String propertyName = property.getName();
    // Preserve the old behavior - return the first value in findProperty()
    if (!cache.containsKey(propertyName)) {
      cache.put(propertyName, property);
    }
  }
  // Cached value is invalidated every time file containing this object is modified
  return CachedValueProvider.Result.createSingleDependency(cache, JsonObjectMixin.this);
}