static boolean checkSchemaNamespace(XmlTag context) {
final String namespace = context.getNamespace();
if (namespace.length() > 0) {
return checkSchemaNamespace(namespace);
}
return StringUtil.startsWithConcatenationOf(context.getName(), XSD_PREFIX, ":");
}
private static void processElementDescriptors(
XmlElementDescriptor descriptor,
XmlTag tag,
ElementNames names,
Set<XmlElementDescriptor> history) {
if (!history.add(descriptor)) {
return;
}
final String namespace =
descriptor instanceof XmlElementDescriptorImpl
? ((XmlElementDescriptorImpl) descriptor).getNamespace()
: tag.getNamespace();
names.elementNames.add(new QName(namespace, descriptor.getName()));
final XmlAttributeDescriptor[] attributesDescriptors =
descriptor.getAttributesDescriptors(null);
for (XmlAttributeDescriptor attributesDescriptor : attributesDescriptors) {
final String localPart = attributesDescriptor.getName();
if (!"xmlns".equals(localPart)) names.attributeNames.add(new QName(localPart));
}
final XmlElementDescriptor[] descriptors = descriptor.getElementsDescriptors(tag);
for (XmlElementDescriptor elem : descriptors) {
processElementDescriptors(elem, tag, names, history);
}
}
private static HighlightInfoType getTagProblemInfoType(XmlTag tag) {
if (tag instanceof HtmlTag && XmlUtil.HTML_URI.equals(tag.getNamespace())) {
if (isInjectedHtmlTagForWhichNoProblemsReporting((HtmlTag) tag))
return HighlightInfoType.INFORMATION;
return HighlightInfoType.WARNING;
}
return HighlightInfoType.WRONG_REF;
}
private static void fillFromSchema(PsiFile file, ElementNames names) {
if (!(file instanceof XmlFile)) return;
final XmlFile f = (XmlFile) file;
final XmlDocument d = f.getDocument();
if (d == null) return;
final XmlTag rootTag = d.getRootTag();
if (rootTag == null) return;
//noinspection unchecked
names.dependencies.add(new NSDeclTracker(rootTag));
try {
final Map<String, String> namespaceDeclarations = rootTag.getLocalNamespaceDeclarations();
final Collection<String> prefixes = namespaceDeclarations.keySet();
//noinspection unchecked
final Set<XmlElementDescriptor> history = new THashSet<XmlElementDescriptor>();
final XmlElementFactory ef = XmlElementFactory.getInstance(file.getProject());
int noSchemaNamespaces = 0;
for (String prefix : prefixes) {
final String namespace = namespaceDeclarations.get(prefix);
if (isIgnoredNamespace(prefix, namespace)) continue;
final XmlTag tag =
ef.createTagFromText("<dummy-tag xmlns='" + namespace + "' />", XMLLanguage.INSTANCE);
final XmlDocument document = PsiTreeUtil.getParentOfType(tag, XmlDocument.class);
final XmlNSDescriptor rootDescriptor = tag.getNSDescriptor(tag.getNamespace(), true);
if (rootDescriptor == null
|| (rootDescriptor instanceof XmlNSDescriptorImpl
&& ((XmlNSDescriptorImpl) rootDescriptor).getTag() == null)
|| !rootDescriptor.getDeclaration().isPhysical()) {
final QName any = QNameUtil.createAnyLocalName(namespace);
names.elementNames.add(any);
names.attributeNames.add(any);
noSchemaNamespaces++;
continue;
}
//noinspection unchecked
names.dependencies.add(rootDescriptor.getDescriptorFile());
final XmlElementDescriptor[] e = rootDescriptor.getRootElementsDescriptors(document);
for (XmlElementDescriptor descriptor : e) {
processElementDescriptors(descriptor, tag, names, history);
}
}
names.validateNames = names.elementNames.size() > noSchemaNamespaces;
// final QName any = QNameUtil.createAnyLocalName("");
// names.elementNames.add(any);
// names.attributeNames.add(any);
} catch (IncorrectOperationException e) {
Logger.getInstance(XsltContextProvider.class.getName()).error(e);
}
}
public static XmlTag getAncestorTag(XmlTag tag, String name, String namespace) {
if (tag == null) {
return null;
}
if (tag.getLocalName().equals(name) && tag.getNamespace().equals(namespace)) {
return tag;
}
return getAncestorTag(tag.getParentTag(), name, namespace);
}
@Nullable
private String getXmlApiCompatibleNamespace(DomInvocationHandler parent) {
final XmlTag tag = parent.getXmlTag();
if (tag == null) {
return null;
}
String ns = getXmlName().getNamespace(tag, parent.getFile());
// TODO: this seems ugly
return tag.getNamespace().equals(ns) ? null : ns;
}
@NotNull
private static XmlFileHeader calcXmlFileHeader(final PsiFile file) {
// if (file.getFileType() == XmlFileType.INSTANCE) {
// VirtualFile virtualFile = file.getVirtualFile();
// if (virtualFile instanceof VirtualFileWithId) {
// ObjectStubTree tree = StubTreeLoader.getInstance().readFromVFile(file.getProject(),
// virtualFile);
// if (tree != null) {
// return ((FileStub)tree.getRoot()).getHeader();
// }
// }
// }
if (file instanceof XmlFile && file.getNode().isParsed()) {
final XmlDocument document = ((XmlFile) file).getDocument();
if (document != null) {
String publicId = null;
String systemId = null;
final XmlProlog prolog = document.getProlog();
if (prolog != null) {
final XmlDoctype doctype = prolog.getDoctype();
if (doctype != null) {
publicId = doctype.getPublicId();
systemId = doctype.getSystemId();
if (systemId == null) {
systemId = doctype.getDtdUri();
}
}
}
final XmlTag tag = document.getRootTag();
if (tag != null) {
String localName = tag.getLocalName();
if (StringUtil.isNotEmpty(localName)) {
if (tag.getPrevSibling() instanceof PsiErrorElement) {
return XmlFileHeader.EMPTY;
}
String psiNs = tag.getNamespace();
return new XmlFileHeader(
localName,
psiNs == XmlUtil.EMPTY_URI || Comparing.equal(psiNs, systemId) ? null : psiNs,
publicId,
systemId);
}
}
}
return XmlFileHeader.EMPTY;
}
if (!file.isValid()) return XmlFileHeader.EMPTY;
return NanoXmlUtil.parseHeader(file);
}
@NotNull
public XmlTag[] findSubTags(final String name, final String namespace) {
final XmlTag[] subTags = getSubTags();
final List<XmlTag> result = new ArrayList<XmlTag>();
for (final XmlTag subTag : subTags) {
if (namespace == null) {
if (name.equals(subTag.getName())) result.add(subTag);
} else if (name.equals(subTag.getLocalName()) && namespace.equals(subTag.getNamespace())) {
result.add(subTag);
}
}
return ContainerUtil.toArray(result, new XmlTag[result.size()]);
}
public String getName(PsiElement context) {
if (context == null) {
return getName();
}
final String form = myTag.getAttributeValue("form");
boolean isQualifiedAttr = QUALIFIED_ATTR_VALUE.equals(form);
final XmlTag rootTag = (((XmlFile) myTag.getContainingFile())).getRootTag();
assert rootTag != null;
String targetNs = rootTag.getAttributeValue("targetNamespace");
XmlTag contextTag = (XmlTag) context;
String name = getName();
boolean attributeShouldBeQualified = false;
String contextNs = contextTag.getNamespace();
if (targetNs != null && !contextNs.equals(targetNs)) {
final XmlElementDescriptor xmlElementDescriptor = contextTag.getDescriptor();
if (xmlElementDescriptor instanceof XmlElementDescriptorImpl) {
final XmlElementDescriptorImpl elementDescriptor =
(XmlElementDescriptorImpl) xmlElementDescriptor;
final TypeDescriptor type = elementDescriptor.getType();
if (type instanceof ComplexTypeDescriptor) {
final ComplexTypeDescriptor typeDescriptor = (ComplexTypeDescriptor) type;
attributeShouldBeQualified =
typeDescriptor.canContainAttribute(targetNs, null)
!= ComplexTypeDescriptor.CanContainAttributeType.CanNotContain;
}
if (!attributeShouldBeQualified && contextNs.length() == 0 && targetNs.length() > 0) {
attributeShouldBeQualified = !targetNs.equals(elementDescriptor.getNamespace());
}
}
}
if (targetNs != null
&& (isQualifiedAttr
|| QUALIFIED_ATTR_VALUE.equals(rootTag.getAttributeValue("attributeFormDefault"))
|| attributeShouldBeQualified)) {
final String prefixByNamespace = contextTag.getPrefixByNamespace(targetNs);
if (prefixByNamespace != null && prefixByNamespace.length() > 0) {
name = prefixByNamespace + ":" + name;
}
}
return name;
}
public XmlElementDescriptor getElementDescriptor(@NotNull XmlTag tag) {
PsiElement parent = tag.getParent();
final String namespace = tag.getNamespace();
while (parent instanceof XmlTag && !namespace.equals(((XmlTag) parent).getNamespace()))
parent = parent.getContext();
if (parent instanceof XmlTag) {
final XmlTag parentTag = (XmlTag) parent;
final XmlElementDescriptor parentDescriptor = parentTag.getDescriptor();
if (parentDescriptor != null) {
XmlElementDescriptor elementDescriptorFromParent =
parentDescriptor.getElementDescriptor(tag, parentTag);
if (elementDescriptorFromParent == null) {
elementDescriptorFromParent = getDescriptorFromParent(tag, elementDescriptorFromParent);
}
if (elementDescriptorFromParent instanceof AnyXmlElementDescriptor) {
final XmlElementDescriptor elementDescriptor =
getElementDescriptor(tag.getLocalName(), namespace);
if (elementDescriptor != null) return elementDescriptor;
}
return elementDescriptorFromParent;
} else {
return null;
}
} else {
XmlElementDescriptor elementDescriptor =
getElementDescriptor(tag.getLocalName(), tag.getNamespace());
if (elementDescriptor == null) {
elementDescriptor = getDescriptorFromParent(tag, elementDescriptor);
}
return elementDescriptor;
}
}
public void testXercesForCompletion() throws Exception {
XSModel xsModel = getXSModel("testCompletion.xml", "test.xsd");
PsiElement element = myFixture.getFile().findElementAt(getEditor().getCaretModel().getOffset());
XmlTag tag = PsiTreeUtil.getParentOfType(element, XmlTag.class);
assert tag != null;
XSElementDeclaration elementDeclaration =
xsModel.getElementDeclaration(tag.getLocalName(), tag.getNamespace());
XSComplexTypeDefinition typeDefinition =
(XSComplexTypeDefinition) elementDeclaration.getTypeDefinition();
CMBuilder cmBuilder = new CMBuilder(new CMNodeFactory());
XSCMValidator validator = cmBuilder.getContentModel((XSComplexTypeDecl) typeDefinition, true);
int[] ints = validator.startContentModel();
Vector vector = validator.whatCanGoHere(ints);
XSElementDecl o = (XSElementDecl) vector.get(0);
assertEquals("b", o.getName());
}
@Nullable
@Override
public MyValidationMessageConsumer collectInformation(@NotNull final PsiFile file) {
final FileType type = file.getFileType();
if (type != StdFileTypes.XML && type != RncFileType.getInstance()) {
return null;
}
final XmlFile xmlfile = (XmlFile) file;
final XmlDocument document = xmlfile.getDocument();
if (document == null) {
return null;
}
if (type == StdFileTypes.XML) {
final XmlTag rootTag = document.getRootTag();
if (rootTag == null) {
return null;
}
if (!ApplicationLoader.RNG_NAMESPACE.equals(rootTag.getNamespace())) {
return null;
}
} else {
if (!ApplicationManager.getApplication().isUnitTestMode()
&& MyErrorFinder.hasError(xmlfile)) {
return null;
}
}
final Document doc = PsiDocumentManager.getInstance(file.getProject()).getDocument(file);
final MyValidationMessageConsumer consumer = new MyValidationMessageConsumer();
ErrorHandler eh =
new DefaultHandler() {
@Override
public void warning(SAXParseException e) {
handleError(e, file, doc, consumer.warning());
}
@Override
public void error(SAXParseException e) {
handleError(e, file, doc, consumer.error());
}
};
RngParser.parsePattern(file, eh, true);
return consumer;
}
@Nullable
@Override
public MyHost collectInformation(@NotNull PsiFile file) {
if (!(file instanceof XmlFile)) return null;
final XmlDocument document = ((XmlFile) file).getDocument();
if (document == null) return null;
XmlTag rootTag = document.getRootTag();
XmlNSDescriptor nsDescriptor =
rootTag == null ? null : rootTag.getNSDescriptor(rootTag.getNamespace(), false);
if (nsDescriptor instanceof Validator) {
//noinspection unchecked
MyHost host = new MyHost();
((Validator<XmlDocument>) nsDescriptor).validate(document, host);
return host;
}
return null;
}
static String getQualifiedAttributeName(PsiElement context, XmlName xmlName) {
final String localName = xmlName.getLocalName();
if (context instanceof XmlTag) {
final XmlTag tag = (XmlTag) context;
final DomInvocationHandler handler =
DomManagerImpl.getDomManager(context.getProject()).getDomHandler(tag);
if (handler != null) {
final String ns =
handler.createEvaluatedXmlName(xmlName).getNamespace(tag, handler.getFile());
if (!ns.equals(XmlUtil.EMPTY_URI) && !ns.equals(tag.getNamespace())) {
final String prefix = tag.getPrefixByNamespace(ns);
if (StringUtil.isNotEmpty(prefix)) {
return prefix + ":" + localName;
}
}
}
}
return localName;
}
private static XmlFileHeader computeHeaderByPsi(XmlFile file) {
final XmlDocument document = file.getDocument();
if (document == null) {
return XmlFileHeader.EMPTY;
}
String publicId = null;
String systemId = null;
final XmlProlog prolog = document.getProlog();
if (prolog != null) {
final XmlDoctype doctype = prolog.getDoctype();
if (doctype != null) {
publicId = doctype.getPublicId();
systemId = doctype.getSystemId();
if (systemId == null) {
systemId = doctype.getDtdUri();
}
}
}
final XmlTag tag = document.getRootTag();
if (tag == null) {
return XmlFileHeader.EMPTY;
}
String localName = tag.getLocalName();
if (StringUtil.isNotEmpty(localName)) {
if (tag.getPrevSibling() instanceof PsiErrorElement) {
return XmlFileHeader.EMPTY;
}
String psiNs = tag.getNamespace();
return new XmlFileHeader(
localName,
psiNs == XmlUtil.EMPTY_URI || Comparing.equal(psiNs, systemId) ? null : psiNs,
publicId,
systemId);
}
return XmlFileHeader.EMPTY;
}
@Override
@SuppressWarnings("ConstantConditions")
public XmlNSDescriptor getRootTagNSDescriptor() {
XmlTag rootTag = getRootTag();
return rootTag != null ? rootTag.getNSDescriptor(rootTag.getNamespace(), false) : null;
}
// this hack is needed, because we temporarily ignore svg and mathML namespaces
// todo: provide schemas for svg and mathML and remove this in IDEA XI
private static boolean isInSpecialHtml5Namespace(XmlTag tag) {
final String ns = tag.getNamespace();
return HtmlUtil.SVG_NAMESPACE.equals(ns) || HtmlUtil.MATH_ML_NAMESPACE.endsWith(ns);
}
public XmlNSDescriptor getRootTagNSDescriptor() {
XmlTag rootTag = getRootTag();
return rootTag != null ? rootTag.getNSDescriptor(rootTag.getNamespace(), false) : null;
}
private static boolean isNameSuitable(
final EvaluatedXmlName evaluatedXmlName, final XmlTag tag, final XmlFile file) {
return isNameSuitable(
evaluatedXmlName, tag.getLocalName(), tag.getName(), tag.getNamespace(), file);
}
static AbstractDomChildrenDescription findChildrenDescription(
final XmlTag tag, final DomInvocationHandler parent) {
final DomGenericInfoEx info = parent.getGenericInfo();
return info.findChildrenDescription(
parent, tag.getLocalName(), tag.getNamespace(), false, tag.getName());
}
public void visitXmlTag(XmlTag tag) {
final PsiFile file = tag.getContainingFile();
if (file.getFileType() != StdFileTypes.XML) {
return;
}
if (!tag.getLocalName().equals("define")) {
return;
}
if (!tag.getNamespace().equals(ApplicationLoader.RNG_NAMESPACE)) {
return;
}
if (tag.getAttribute("combine") != null) {
return; // ?
}
final XmlAttribute attr = tag.getAttribute("name");
if (attr == null) return;
final XmlAttributeValue value = attr.getValueElement();
if (value == null) return;
final String s = value.getValue();
if (s == null || s.length() == 0) {
return;
}
final PsiElement parent = value.getParent();
if (!(parent instanceof XmlAttribute)) {
return;
}
if (!"name".equals(((XmlAttribute) parent).getName())) {
return;
}
final PsiElement grandParent = parent.getParent();
if (!(grandParent instanceof XmlTag)) {
return;
}
final DomElement element = DomManager.getDomManager(tag.getProject()).getDomElement(tag);
if (element == null) {
return;
}
final RngGrammar rngGrammar = element.getParentOfType(RngGrammar.class, true);
if (rngGrammar != null) {
if (processUsages(tag, value, new LocalSearchScope(rngGrammar.getXmlTag()))) return;
} else {
if (processUsages(tag, value, new LocalSearchScope(file))) return;
}
final PsiElementProcessor.CollectElements<XmlFile> collector =
new PsiElementProcessor.CollectElements<XmlFile>();
RelaxIncludeIndex.processBackwardDependencies((XmlFile) file, collector);
if (processUsages(tag, value, new LocalSearchScope(collector.toArray()))) return;
myHolder.registerProblem(
value,
"Unreferenced define",
ProblemHighlightType.LIKE_UNUSED_SYMBOL,
new MyFix<XmlTag>(tag));
}
