public String getAttributeValue(String _name, String namespace) {
if (namespace == null) {
return getAttributeValue(_name);
}
XmlTagImpl current = this;
PsiElement parent = getParent();
while (current != null) {
BidirectionalMap<String, String> map = current.initNamespaceMaps(parent);
if (map != null) {
List<String> keysByValue = map.getKeysByValue(namespace);
if (keysByValue != null && !keysByValue.isEmpty()) {
for (String prefix : keysByValue) {
if (prefix != null && prefix.length() > 0) {
final String value = getAttributeValue(prefix + ":" + _name);
if (value != null) return value;
}
}
}
}
current = parent instanceof XmlTag ? (XmlTagImpl) parent : null;
parent = parent.getParent();
}
if (namespace.length() == 0 || getNamespace().equals(namespace)) {
return getAttributeValue(_name);
}
return null;
}
@NotNull
private XmlAttribute[] calculateAttributes(final Map<String, String> attributesValueMap) {
final List<XmlAttribute> result = new ArrayList<XmlAttribute>(10);
processChildren(
new PsiElementProcessor() {
public boolean execute(@NotNull PsiElement element) {
if (element instanceof XmlAttribute) {
XmlAttribute attribute = (XmlAttribute) element;
result.add(attribute);
cacheOneAttributeValue(attribute.getName(), attribute.getValue(), attributesValueMap);
myHaveNamespaceDeclarations =
myHaveNamespaceDeclarations || attribute.isNamespaceDeclaration();
} else if (element instanceof XmlToken
&& ((XmlToken) element).getTokenType() == XmlTokenType.XML_TAG_END) {
return false;
}
return true;
}
});
if (result.isEmpty()) {
return XmlAttribute.EMPTY_ARRAY;
} else {
return ContainerUtil.toArray(result, new XmlAttribute[result.size()]);
}
}
public String getPrefixByNamespace(String namespace) {
final PsiElement parent = getParent();
BidirectionalMap<String, String> map = initNamespaceMaps(parent);
if (map != null) {
List<String> keysByValue = map.getKeysByValue(namespace);
final String ns = keysByValue == null || keysByValue.isEmpty() ? null : keysByValue.get(0);
if (ns != null) return ns;
}
if (parent instanceof XmlTag) return ((XmlTag) parent).getPrefixByNamespace(namespace);
// The prefix 'xml' is by definition bound to the namespace name
// http://www.w3.org/XML/1998/namespace. It MAY, but need not, be declared
if (XmlUtil.XML_NAMESPACE_URI.equals(namespace)) return XML_NS_PREFIX;
return null;
}
private List<PostponedAction> normalizeAndReorderPostponedActions(
final TreeSet<PostprocessFormattingTask> rangesToProcess, Document document) {
final List<PostprocessFormattingTask> freeFormatingActions =
new ArrayList<PostprocessFormattingTask>();
final List<ReindentTask> indentActions = new ArrayList<ReindentTask>();
PostprocessFormattingTask accumulatedTask = null;
Iterator<PostprocessFormattingTask> iterator = rangesToProcess.iterator();
while (iterator.hasNext()) {
final PostprocessFormattingTask currentTask = iterator.next();
if (accumulatedTask == null) {
accumulatedTask = currentTask;
iterator.remove();
} else if (accumulatedTask.getStartOffset() > currentTask.getEndOffset()
|| accumulatedTask.getStartOffset() == currentTask.getEndOffset()
&& !canStickActionsTogether(accumulatedTask, currentTask)) {
// action can be pushed
if (accumulatedTask instanceof ReindentTask) {
indentActions.add((ReindentTask) accumulatedTask);
} else {
freeFormatingActions.add(accumulatedTask);
}
accumulatedTask = currentTask;
iterator.remove();
} else if (accumulatedTask instanceof ReformatTask && currentTask instanceof ReindentTask) {
// split accumulated reformat range into two
if (accumulatedTask.getStartOffset() < currentTask.getStartOffset()) {
final RangeMarker endOfRange =
document.createRangeMarker(
accumulatedTask.getStartOffset(), currentTask.getStartOffset());
// add heading reformat part
rangesToProcess.add(new ReformatTask(endOfRange));
// and manage heading whitespace because formatter does not edit it in previous action
iterator = rangesToProcess.iterator();
//noinspection StatementWithEmptyBody
while (iterator.next().getRange() != currentTask.getRange()) ;
}
final RangeMarker rangeToProcess =
document.createRangeMarker(currentTask.getEndOffset(), accumulatedTask.getEndOffset());
freeFormatingActions.add(new ReformatWithHeadingWhitespaceTask(rangeToProcess));
accumulatedTask = currentTask;
iterator.remove();
} else {
if (!(accumulatedTask instanceof ReindentTask)) {
iterator.remove();
boolean withLeadingWhitespace =
accumulatedTask instanceof ReformatWithHeadingWhitespaceTask;
if (accumulatedTask instanceof ReformatTask
&& currentTask instanceof ReformatWithHeadingWhitespaceTask
&& accumulatedTask.getStartOffset() == currentTask.getStartOffset()) {
withLeadingWhitespace = true;
} else if (accumulatedTask instanceof ReformatWithHeadingWhitespaceTask
&& currentTask instanceof ReformatTask
&& accumulatedTask.getStartOffset() < currentTask.getStartOffset()) {
withLeadingWhitespace = false;
}
int newStart = Math.min(accumulatedTask.getStartOffset(), currentTask.getStartOffset());
int newEnd = Math.max(accumulatedTask.getEndOffset(), currentTask.getEndOffset());
RangeMarker rangeMarker;
if (accumulatedTask.getStartOffset() == newStart
&& accumulatedTask.getEndOffset() == newEnd) {
rangeMarker = accumulatedTask.getRange();
} else if (currentTask.getStartOffset() == newStart
&& currentTask.getEndOffset() == newEnd) {
rangeMarker = currentTask.getRange();
} else {
rangeMarker = document.createRangeMarker(newStart, newEnd);
}
if (withLeadingWhitespace) {
accumulatedTask = new ReformatWithHeadingWhitespaceTask(rangeMarker);
} else {
accumulatedTask = new ReformatTask(rangeMarker);
}
} else if (currentTask instanceof ReindentTask) {
iterator.remove();
} // TODO[ik]: need to be fixed to correctly process indent inside indent
}
}
if (accumulatedTask != null) {
if (accumulatedTask instanceof ReindentTask) {
indentActions.add((ReindentTask) accumulatedTask);
} else {
freeFormatingActions.add(accumulatedTask);
}
}
final List<PostponedAction> result = new ArrayList<PostponedAction>();
Collections.reverse(freeFormatingActions);
Collections.reverse(indentActions);
if (!freeFormatingActions.isEmpty()) {
FormatTextRanges ranges = new FormatTextRanges();
for (PostprocessFormattingTask action : freeFormatingActions) {
TextRange range = TextRange.create(action);
ranges.add(range, action instanceof ReformatWithHeadingWhitespaceTask);
}
result.add(new ReformatRangesAction(ranges));
}
if (!indentActions.isEmpty()) {
ReindentRangesAction reindentRangesAction = new ReindentRangesAction();
for (ReindentTask action : indentActions) {
reindentRangesAction.add(action.getRange(), action.getOldIndent());
}
result.add(reindentRangesAction);
}
return result;
}
