public XmlAttributeDescriptor getAttributeDescriptor(String attributeName, final XmlTag context) { String caseSensitiveAttributeName = !myCaseSensitive ? attributeName.toLowerCase() : attributeName; XmlAttributeDescriptor descriptor = super.getAttributeDescriptor(caseSensitiveAttributeName, context); if (descriptor == null) descriptor = RelaxedHtmlFromSchemaElementDescriptor.getAttributeDescriptorFromFacelets( attributeName, context); if (descriptor == null) { String prefix = XmlUtil.findPrefixByQualifiedName(attributeName); if ("xml" .equals( prefix)) { // todo this is not technically correct dtd document references namespaces // but we should handle it at least for xml stuff XmlNSDescriptor nsdescriptor = context.getNSDescriptor(XmlUtil.XML_NAMESPACE_URI, true); if (nsdescriptor instanceof XmlNSDescriptorImpl) { descriptor = ((XmlNSDescriptorImpl) nsdescriptor) .getAttribute( XmlUtil.findLocalNameByQualifiedName(caseSensitiveAttributeName), XmlUtil.XML_NAMESPACE_URI, context); } } } if (descriptor == null && HtmlUtil.isHtml5Context(context)) { descriptor = myDelegate.getAttributeDescriptor(attributeName, context); } return descriptor; }
private static @Nullable XmlTag findSpecialTag( @NonNls String name, @NonNls String specialName, XmlTag rootTag, XmlNSDescriptorImpl descriptor, HashSet<XmlTag> visited) { XmlNSDescriptorImpl nsDescriptor = getNSDescriptorToSearchIn(rootTag, name, descriptor); if (nsDescriptor != descriptor) { final XmlDocument document = nsDescriptor.getDescriptorFile() != null ? nsDescriptor.getDescriptorFile().getDocument() : null; if (document == null) return null; return findSpecialTag( XmlUtil.findLocalNameByQualifiedName(name), specialName, document.getRootTag(), nsDescriptor, visited); } if (visited == null) visited = new HashSet<XmlTag>(1); else if (visited.contains(rootTag)) return null; visited.add(rootTag); XmlTag[] tags = rootTag.getSubTags(); return findSpecialTagIn(tags, specialName, name, rootTag, descriptor, visited); }
private boolean isCertainTypeElement( XmlTagImpl xml, final String typeName, final String nsPrefix) { if (!isTypeElement(xml)) return false; final XmlAttribute name = getNameAttr(xml); if (name == null) return false; final String value = name.getValue(); if (value == null) return false; final String localName = XmlUtil.findLocalNameByQualifiedName(value); return typeName.equals(localName) && nsPrefix.equals(XmlUtil.findPrefixByQualifiedName(value)); }
public TypeDescriptor getTypeDescriptor(final String name, XmlTag context) { if (checkSchemaNamespace(name, context)) { final String localNameByQualifiedName = XmlUtil.findLocalNameByQualifiedName(name); if (STD_TYPES.contains(localNameByQualifiedName) && (name.length() == localNameByQualifiedName.length() || UNDECLARED_STD_TYPES.contains(localNameByQualifiedName))) return new StdTypeDescriptor(localNameByQualifiedName); } return findTypeDescriptor(name, context); }
private boolean checkElementNameEquivalence( String localName, String namespace, String fqn, XmlTag context) { final String localAttrName = XmlUtil.findLocalNameByQualifiedName(fqn); if (!localAttrName.equals(localName)) return false; final String attrNamespace = context.getNamespaceByPrefix(XmlUtil.findPrefixByQualifiedName(fqn)); if (attrNamespace.equals(namespace)) return true; if (myTargetNamespace == null) { if (XmlUtil.EMPTY_URI.equals(attrNamespace)) return true; } else { final boolean b = myTargetNamespace.equals(namespace); if (b) return b; return context.getNSDescriptor(namespace, true) == this; // schema's targetNamespace could be different from file systemId } return false; }
@Nullable protected TypeDescriptor findTypeDescriptorImpl( XmlTag rootTag, final String name, String namespace, Set<XmlTag> visited) { XmlNSDescriptorImpl responsibleDescriptor = this; if (namespace != null && namespace.length() != 0 && !namespace.equals(getDefaultNamespace())) { final XmlNSDescriptor nsDescriptor = rootTag.getNSDescriptor(namespace, true); if (nsDescriptor instanceof XmlNSDescriptorImpl) { responsibleDescriptor = (XmlNSDescriptorImpl) nsDescriptor; } } if (responsibleDescriptor != this) { return responsibleDescriptor.findTypeDescriptor(XmlUtil.findLocalNameByQualifiedName(name)); } if (rootTag == null) return null; if (visited != null) { if (visited.contains(rootTag)) return null; visited.add(rootTag); } final Pair<QNameKey, XmlTag> pair = new Pair<QNameKey, XmlTag>(new QNameKey(name, namespace), rootTag); final CachedValue<TypeDescriptor> descriptor = myTypesMap.get(pair); if (descriptor != null) { TypeDescriptor value = descriptor.getValue(); if (value == null || (value instanceof ComplexTypeDescriptor && ((ComplexTypeDescriptor) value).getDeclaration().isValid())) return value; } XmlTag[] tags = rootTag.getSubTags(); if (visited == null) { visited = new HashSet<XmlTag>(1); visited.add(rootTag); } return doFindIn(tags, name, namespace, pair, rootTag, visited); }
@Nullable private BidirectionalMap<String, String> computeNamespaceMap(PsiElement parent) { BidirectionalMap<String, String> map = null; if (hasNamespaceDeclarations()) { map = new BidirectionalMap<String, String>(); final XmlAttribute[] attributes = getAttributes(); for (final XmlAttribute attribute : attributes) { if (attribute.isNamespaceDeclaration()) { final String name = attribute.getName(); int splitIndex = name.indexOf(':'); final String value = getRealNs(attribute.getValue()); if (value != null) { if (splitIndex < 0) { map.put("", value); } else { map.put(XmlUtil.findLocalNameByQualifiedName(name), value); } } } } } if (parent instanceof XmlDocument) { final XmlExtension extension = XmlExtension.getExtensionByElement(parent); if (extension != null) { final String[][] defaultNamespace = extension.getNamespacesFromDocument((XmlDocument) parent, map != null); if (defaultNamespace != null) { if (map == null) { map = new BidirectionalMap<String, String>(); } for (final String[] prefix2ns : defaultNamespace) { map.put(prefix2ns[0], getRealNs(prefix2ns[1])); } } } } return map; }
public static boolean isElementWithEmbeddedType( XmlTagImpl xml, final String typeName, final String typeNsPrefix) { final String localName = xml.getLocalName(); if (!(XmlUtil.XML_SCHEMA_URI.equals(xml.getNamespace()) && "element".equals(localName))) { return false; } final XmlAttribute nameAttr = getNameAttr(xml); if (nameAttr == null || nameAttr.getValue() == null) return false; final String localTypeName = XmlUtil.findLocalNameByQualifiedName(nameAttr.getValue()); final String prefix = XmlUtil.findPrefixByQualifiedName(nameAttr.getValue()); if (!typeName.equals(localTypeName) || !typeNsPrefix.equals(prefix)) { return false; } final XmlTag[] tags = xml.getSubTags(); for (XmlTag tag : tags) { if (isTypeElement((XmlTagImpl) tag)) { return true; } } return false; }
private void initSubstitutes() { if (mySubstitutions == null) { mySubstitutions = new HashMap<String, List<XmlTag>>(); XmlTag[] tags = myTag.getSubTags(); for (XmlTag tag : tags) { if (equalsToSchemaName(tag, ELEMENT_TAG_NAME)) { final String substAttr = tag.getAttributeValue("substitutionGroup"); if (substAttr != null) { String substLocalName = XmlUtil.findLocalNameByQualifiedName(substAttr); List<XmlTag> list = mySubstitutions.get(substLocalName); if (list == null) { list = new LinkedList<XmlTag>(); mySubstitutions.put(substLocalName, list); } list.add(tag); } } } } }
@Nullable protected TypeDescriptor findTypeDescriptor(final String qname, XmlTag context) { String namespace = context.getNamespaceByPrefix(XmlUtil.findPrefixByQualifiedName(qname)); return findTypeDescriptor(XmlUtil.findLocalNameByQualifiedName(qname), namespace); }