1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.jetbrains.jsonSchema.impl;
import com.intellij.json.navigation.JsonQualifiedNameKind;
import com.intellij.json.navigation.JsonQualifiedNameProvider;
import com.intellij.json.psi.*;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.Pair;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiManager;
import com.intellij.psi.SyntaxTraverser;
import com.intellij.psi.util.CachedValue;
import com.intellij.util.AstLoadingFilter;
import com.intellij.util.Function;
import com.intellij.util.ObjectUtils;
import com.intellij.util.containers.ContainerUtil;
import com.jetbrains.jsonSchema.ide.JsonSchemaService;
import com.jetbrains.jsonSchema.remote.JsonFileResolver;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
public class JsonCachedValues {
private static final Key<CachedValue<JsonSchemaObject>> JSON_OBJECT_CACHE_KEY = Key.create("JsonSchemaObjectCache");
@Nullable
public static JsonSchemaObject getSchemaObject(@NotNull VirtualFile schemaFile, @NotNull Project project) {
JsonFileResolver.startFetchingHttpFileIfNeeded(schemaFile, project);
return computeForFile(schemaFile, project, JsonCachedValues::computeSchemaObject, JSON_OBJECT_CACHE_KEY);
}
@Nullable
private static JsonSchemaObject computeSchemaObject(@NotNull PsiFile f) {
final JsonObject topLevelValue = AstLoadingFilter.forceAllowTreeLoading(
f,
() -> ObjectUtils.tryCast(((JsonFile)f).getTopLevelValue(), JsonObject.class));
if (topLevelValue != null) {
return new JsonSchemaReader().read(topLevelValue);
}
return null;
}
static final String URL_CACHE_KEY = "JsonSchemaUrlCache";
private static final Key<CachedValue<String>> SCHEMA_URL_KEY = Key.create(URL_CACHE_KEY);
@Nullable
public static String getSchemaUrlFromSchemaProperty(@NotNull VirtualFile file,
@NotNull Project project) {
String value = JsonSchemaFileValuesIndex.getCachedValue(project, file, URL_CACHE_KEY);
if (value != null) {
return JsonSchemaFileValuesIndex.NULL.equals(value) ? null : value;
}
PsiFile psiFile = resolveFile(file, project);
return !(psiFile instanceof JsonFile) ? null : CachedValueProviderOnPsiFile
.getOrCompute(psiFile, JsonCachedValues::fetchSchemaUrl, SCHEMA_URL_KEY);
}
private static PsiFile resolveFile(@NotNull VirtualFile file,
@NotNull Project project) {
if (project.isDisposed() || !file.isValid()) return null;
return PsiManager.getInstance(project).findFile(file);
}
@Nullable
static String fetchSchemaUrl(@Nullable PsiFile psiFile) {
if (!(psiFile instanceof JsonFile)) return null;
final String url = JsonSchemaFileValuesIndex.readTopLevelProps(psiFile.getFileType(), psiFile.getText()).get(URL_CACHE_KEY);
return url == null || JsonSchemaFileValuesIndex.NULL.equals(url) ? null : url;
}
static final String ID_CACHE_KEY = "JsonSchemaIdCache";
static final String OBSOLETE_ID_CACHE_KEY = "JsonSchemaObsoleteIdCache";
private static final Key<CachedValue<String>> SCHEMA_ID_CACHE_KEY = Key.create(ID_CACHE_KEY);
@Nullable
public static String getSchemaId(@NotNull final VirtualFile schemaFile,
@NotNull final Project project) {
String value = JsonSchemaFileValuesIndex.getCachedValue(project, schemaFile, ID_CACHE_KEY);
if (value != null && !JsonSchemaFileValuesIndex.NULL.equals(value)) return JsonSchemaService.normalizeId(value);
String obsoleteValue = JsonSchemaFileValuesIndex.getCachedValue(project, schemaFile, OBSOLETE_ID_CACHE_KEY);
if (obsoleteValue != null && !JsonSchemaFileValuesIndex.NULL.equals(obsoleteValue)) return JsonSchemaService.normalizeId(obsoleteValue);
if (JsonSchemaFileValuesIndex.NULL.equals(value) || JsonSchemaFileValuesIndex.NULL.equals(obsoleteValue)) return null;
final String result = computeForFile(schemaFile, project, JsonCachedValues::fetchSchemaId, SCHEMA_ID_CACHE_KEY);
return result == null ? null : JsonSchemaService.normalizeId(result);
}
@Nullable
private static <T> T computeForFile(@NotNull final VirtualFile schemaFile,
@NotNull final Project project,
@NotNull Function<? super PsiFile, ? extends T> eval,
@NotNull Key<CachedValue<T>> cacheKey) {
final PsiFile psiFile = resolveFile(schemaFile, project);
if (!(psiFile instanceof JsonFile)) return null;
return CachedValueProviderOnPsiFile.getOrCompute(psiFile, eval, cacheKey);
}
static final String ID_PATHS_CACHE_KEY = "JsonSchemaIdToPointerCache";
private static final Key<CachedValue<Map<String, String>>> SCHEMA_ID_PATHS_CACHE_KEY = Key.create(ID_PATHS_CACHE_KEY);
public static Collection<String> getAllIdsInFile(PsiFile psiFile) {
final Map<String, String> map = CachedValueProviderOnPsiFile.getOrCompute(psiFile, JsonCachedValues::computeIdsMap, SCHEMA_ID_PATHS_CACHE_KEY);
return map == null ? ContainerUtil.emptyList() : map.keySet();
}
@Nullable
public static String resolveId(PsiFile psiFile, String id) {
final Map<String, String> map = CachedValueProviderOnPsiFile.getOrCompute(psiFile, JsonCachedValues::computeIdsMap, SCHEMA_ID_PATHS_CACHE_KEY);
return map == null ? null : map.get(id);
}
private static Map<String, String> computeIdsMap(PsiFile file) {
return SyntaxTraverser.psiTraverser(file).filter(JsonProperty.class).filter(p -> "$id".equals(p.getName()))
.filter(p -> p.getValue() instanceof JsonStringLiteral)
.toMap(p -> ((JsonStringLiteral)Objects.requireNonNull(p.getValue())).getValue(),
p -> JsonQualifiedNameProvider.generateQualifiedName(p.getParent(), JsonQualifiedNameKind.JsonPointer));
}
@Nullable
static String fetchSchemaId(@NotNull PsiFile psiFile) {
if (!(psiFile instanceof JsonFile)) return null;
final Map<String, String> props = JsonSchemaFileValuesIndex.readTopLevelProps(psiFile.getFileType(), psiFile.getText());
final String id = props.get(ID_CACHE_KEY);
if (id != null && !JsonSchemaFileValuesIndex.NULL.equals(id)) return id;
final String obsoleteId = props.get(OBSOLETE_ID_CACHE_KEY);
return obsoleteId == null || JsonSchemaFileValuesIndex.NULL.equals(obsoleteId) ? null : obsoleteId;
}
private static final Key<CachedValue<List<Pair<Collection<String>, String>>>> SCHEMA_CATALOG_CACHE_KEY = Key.create("JsonSchemaCatalogCache");
@Nullable
public static List<Pair<Collection<String>, String>> getSchemaCatalog(@NotNull final VirtualFile catalog,
@NotNull final Project project) {
if (!catalog.isValid()) return null;
return computeForFile(catalog, project, JsonCachedValues::computeSchemaCatalog, SCHEMA_CATALOG_CACHE_KEY);
}
private static List<Pair<Collection<String>, String>> computeSchemaCatalog(PsiFile catalog) {
if (!catalog.isValid()) return null;
JsonValue value = AstLoadingFilter.forceAllowTreeLoading(catalog, () -> ((JsonFile)catalog).getTopLevelValue());
if (!(value instanceof JsonObject)) return null;
JsonProperty schemas = ((JsonObject)value).findProperty("schemas");
if (schemas == null) return null;
JsonValue schemasValue = schemas.getValue();
if (!(schemasValue instanceof JsonArray)) return null;
List<Pair<Collection<String>, String>> catalogMap = ContainerUtil.newArrayList();
fillMap((JsonArray)schemasValue, catalogMap);
return catalogMap;
}
private static void fillMap(@NotNull JsonArray array, @NotNull List<Pair<Collection<String>, String>> catalogMap) {
for (JsonValue value: array.getValueList()) {
if (!(value instanceof JsonObject)) continue;
JsonProperty fileMatch = ((JsonObject)value).findProperty("fileMatch");
Collection<String> masks = fileMatch == null ? ContainerUtil.emptyList() : resolveMasks(fileMatch.getValue());
JsonProperty url = ((JsonObject)value).findProperty("url");
if (url == null) continue;
JsonValue urlValue = url.getValue();
if (urlValue instanceof JsonStringLiteral) {
String urlStringValue = ((JsonStringLiteral)urlValue).getValue();
if (!StringUtil.isEmpty(urlStringValue)) {
catalogMap.add(Pair.create(masks, urlStringValue));
}
}
}
}
@NotNull
private static Collection<String> resolveMasks(@Nullable JsonValue value) {
if (value instanceof JsonStringLiteral) {
return ContainerUtil.createMaybeSingletonList(((JsonStringLiteral)value).getValue());
}
if (value instanceof JsonArray) {
List<String> strings = ContainerUtil.newArrayList();
for (JsonValue val: ((JsonArray)value).getValueList()) {
if (val instanceof JsonStringLiteral) {
strings.add(((JsonStringLiteral)val).getValue());
}
}
return strings;
}
return ContainerUtil.emptyList();
}
}
|
