private static List<XmlElementDescriptor> computeRequiredSubTags(XmlElementsGroup group) {
if (group.getMinOccurs() < 1) return Collections.emptyList();
switch (group.getGroupType()) {
case LEAF:
XmlElementDescriptor descriptor = group.getLeafDescriptor();
return descriptor == null
? Collections.<XmlElementDescriptor>emptyList()
: Collections.singletonList(descriptor);
case CHOICE:
LinkedHashSet<XmlElementDescriptor> set = null;
for (XmlElementsGroup subGroup : group.getSubGroups()) {
List<XmlElementDescriptor> descriptors = computeRequiredSubTags(subGroup);
if (set == null) {
set = new LinkedHashSet<XmlElementDescriptor>(descriptors);
} else {
set.retainAll(descriptors);
}
}
if (set == null || set.isEmpty()) {
return Collections.singletonList(null); // placeholder for smart completion
}
return new ArrayList<XmlElementDescriptor>(set);
default:
ArrayList<XmlElementDescriptor> list = new ArrayList<XmlElementDescriptor>();
for (XmlElementsGroup subGroup : group.getSubGroups()) {
list.addAll(computeRequiredSubTags(subGroup));
}
return list;
}
}
public static List<DomElement> getDefinedChildren(
@NotNull final DomElement parent, final boolean tags, final boolean attributes) {
if (parent instanceof MergedObject) {
final SmartList<DomElement> result = new SmartList<>();
parent.acceptChildren(
new DomElementVisitor() {
@Override
public void visitDomElement(final DomElement element) {
if (hasXml(element)) {
result.add(element);
}
}
});
return result;
}
ProgressManager.checkCanceled();
if (parent instanceof GenericAttributeValue) return Collections.emptyList();
if (parent instanceof DomFileElement) {
final DomFileElement element = (DomFileElement) parent;
return tags ? Arrays.asList(element.getRootElement()) : Collections.<DomElement>emptyList();
}
final XmlElement xmlElement = parent.getXmlElement();
if (xmlElement instanceof XmlTag) {
XmlTag tag = (XmlTag) xmlElement;
final DomManager domManager = parent.getManager();
final SmartList<DomElement> result = new SmartList<>();
if (attributes) {
for (final XmlAttribute attribute : tag.getAttributes()) {
if (!attribute.isValid()) {
LOG.error("Invalid attr: parent.valid=" + tag.isValid());
continue;
}
GenericAttributeValue element = domManager.getDomElement(attribute);
if (checkHasXml(attribute, element)) {
ContainerUtil.addIfNotNull(result, element);
}
}
}
if (tags) {
for (final XmlTag subTag : tag.getSubTags()) {
if (!subTag.isValid()) {
LOG.error("Invalid subtag: parent.valid=" + tag.isValid());
continue;
}
DomElement element = domManager.getDomElement(subTag);
if (checkHasXml(subTag, element)) {
ContainerUtil.addIfNotNull(result, element);
}
}
}
return result;
}
return Collections.emptyList();
}
public String[] knownNamespaces() {
final PsiElement parentElement = getParent();
BidirectionalMap<String, String> map = initNamespaceMaps(parentElement);
Set<String> known = Collections.emptySet();
if (map != null) {
known = new HashSet<String>(map.values());
}
if (parentElement instanceof XmlTag) {
if (known.isEmpty()) return ((XmlTag) parentElement).knownNamespaces();
ContainerUtil.addAll(known, ((XmlTag) parentElement).knownNamespaces());
} else {
XmlExtension xmlExtension = XmlExtension.getExtensionByElement(this);
if (xmlExtension != null) {
final XmlFile xmlFile = xmlExtension.getContainingFile(this);
if (xmlFile != null) {
final XmlTag rootTag = xmlFile.getRootTag();
if (rootTag != null && rootTag != this) {
if (known.isEmpty()) return rootTag.knownNamespaces();
ContainerUtil.addAll(known, rootTag.knownNamespaces());
}
}
}
}
return ArrayUtil.toStringArray(known);
}
@Override
@NotNull
public Set<String> getRootsToWatch() {
final File path = new File(getExternalResourcesPath());
if (!path.exists() && !path.mkdirs()) {
LOG.warn("Unable to create: " + path);
}
return Collections.singleton(path.getAbsolutePath());
}
public static List<? extends DomElement> getIdentitySiblings(DomElement element) {
final GenericDomValue nameDomElement = element.getGenericInfo().getNameDomElement(element);
if (nameDomElement == null) return Collections.emptyList();
final NameValue nameValue = nameDomElement.getAnnotation(NameValue.class);
if (nameValue == null || !nameValue.unique()) return Collections.emptyList();
final String stringValue = ElementPresentationManager.getElementName(element);
if (stringValue == null) return Collections.emptyList();
final DomElement scope = element.getManager().getIdentityScope(element);
if (scope == null) return Collections.emptyList();
final DomGenericInfo domGenericInfo = scope.getGenericInfo();
final String tagName = element.getXmlElementName();
final DomCollectionChildDescription childDescription =
domGenericInfo.getCollectionChildDescription(tagName, element.getXmlElementNamespaceKey());
if (childDescription != null) {
final ArrayList<DomElement> list = new ArrayList<>(childDescription.getValues(scope));
list.remove(element);
return list;
}
return Collections.emptyList();
}
@NotNull
private Map<String, CachedValue<XmlNSDescriptor>> computeNsDescriptorMap() {
Map<String, CachedValue<XmlNSDescriptor>> map = null;
// XSD aware attributes processing
final String noNamespaceDeclaration =
getAttributeValue("noNamespaceSchemaLocation", XmlUtil.XML_SCHEMA_INSTANCE_URI);
final String schemaLocationDeclaration =
getAttributeValue("schemaLocation", XmlUtil.XML_SCHEMA_INSTANCE_URI);
if (noNamespaceDeclaration != null) {
map = initializeSchema(XmlUtil.EMPTY_URI, null, noNamespaceDeclaration, map);
}
if (schemaLocationDeclaration != null) {
final StringTokenizer tokenizer = new StringTokenizer(schemaLocationDeclaration);
while (tokenizer.hasMoreTokens()) {
final String uri = tokenizer.nextToken();
if (tokenizer.hasMoreTokens()) {
map = initializeSchema(uri, null, tokenizer.nextToken(), map);
}
}
}
// namespace attributes processing (XSD declaration via ExternalResourceManager)
if (hasNamespaceDeclarations()) {
for (final XmlAttribute attribute : getAttributes()) {
if (attribute.isNamespaceDeclaration()) {
String ns = attribute.getValue();
if (ns == null) ns = XmlUtil.EMPTY_URI;
ns = getRealNs(ns);
if (map == null || !map.containsKey(ns)) {
map = initializeSchema(ns, getNSVersion(ns, this), getNsLocation(ns), map);
}
}
}
}
return map == null ? Collections.<String, CachedValue<XmlNSDescriptor>>emptyMap() : map;
}
public static List<XmlElementDescriptor> getRequiredSubTags(XmlElementDescriptor selected) {
XmlElementsGroup topGroup = selected.getTopGroup();
if (topGroup == null) return Collections.emptyList();
return computeRequiredSubTags(topGroup);
}
@NotNull
@Override
public Runnable processFile(final PsiFile file) {
VirtualFile vFile = file.getVirtualFile();
if (vFile instanceof VirtualFileWindow) vFile = ((VirtualFileWindow) vFile).getDelegate();
final Project project = file.getProject();
if (vFile == null
|| !ProjectRootManager.getInstance(project).getFileIndex().isInSourceContent(vFile)) {
return EmptyRunnable.INSTANCE;
}
final List<Pair<String, Boolean>> names = new ArrayList<Pair<String, Boolean>>();
final Set<String> demandedForNested = new HashSet<>();
collectNamesToImport(names, demandedForNested, (XmlFile) file);
Collections.sort(names, (o1, o2) -> StringUtil.compare(o1.first, o2.first, true));
final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project);
final List<Pair<String, Boolean>> sortedNames =
ImportHelper.sortItemsAccordingToSettings(names, settings);
final HashSet<String> onDemand = new HashSet<String>();
ImportHelper.collectOnDemandImports(sortedNames, onDemand, settings);
onDemand.addAll(demandedForNested);
final Set<String> imported = new HashSet<String>();
final List<String> imports = new ArrayList<String>();
for (Pair<String, Boolean> pair : sortedNames) {
final String qName = pair.first;
final String packageName = StringUtil.getPackageName(qName);
if (imported.contains(packageName) || imported.contains(qName)) {
continue;
}
if (onDemand.contains(packageName)) {
imported.add(packageName);
imports.add("<?import " + packageName + ".*?>");
} else {
imported.add(qName);
imports.add("<?import " + qName + "?>");
}
}
final PsiFileFactory factory = PsiFileFactory.getInstance(file.getProject());
final XmlFile dummyFile =
(XmlFile)
factory.createFileFromText(
"_Dummy_.fxml", StdFileTypes.XML, StringUtil.join(imports, "\n"));
final XmlDocument document = dummyFile.getDocument();
final XmlProlog newImportList = document != null ? document.getProlog() : null;
if (newImportList == null) return EmptyRunnable.getInstance();
return () -> {
final XmlDocument xmlDocument = ((XmlFile) file).getDocument();
final XmlProlog prolog = xmlDocument != null ? xmlDocument.getProlog() : null;
if (prolog != null) {
final Collection<XmlProcessingInstruction> instructions =
PsiTreeUtil.findChildrenOfType(prolog, XmlProcessingInstruction.class);
for (final XmlProcessingInstruction instruction : instructions) {
final ASTNode node = instruction.getNode();
final ASTNode nameNode = node.findChildByType(XmlTokenType.XML_NAME);
if (nameNode != null && nameNode.getText().equals("import")) {
instruction.delete();
}
}
prolog.add(newImportList);
} else {
document.addBefore(newImportList, document.getRootTag());
}
};
}