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;
}
}
/**
* Begins the in-place refactoring operation.
*
* @return true if the in-place refactoring was successfully started, false if it failed to start
* and a dialog should be shown instead.
*/
public boolean startInplaceIntroduceTemplate() {
final boolean replaceAllOccurrences = isReplaceAllOccurrences();
final Ref<Boolean> result = new Ref<>();
CommandProcessor.getInstance()
.executeCommand(
myProject,
() -> {
final String[] names = suggestNames(replaceAllOccurrences, getLocalVariable());
final V variable = createFieldToStartTemplateOn(replaceAllOccurrences, names);
boolean started = false;
if (variable != null) {
int caretOffset = getCaretOffset();
myEditor.getCaretModel().moveToOffset(caretOffset);
myEditor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
final LinkedHashSet<String> nameSuggestions = new LinkedHashSet<>();
nameSuggestions.add(variable.getName());
nameSuggestions.addAll(Arrays.asList(names));
initOccurrencesMarkers();
setElementToRename(variable);
updateTitle(getVariable());
started = super.performInplaceRefactoring(nameSuggestions);
if (started) {
onRenameTemplateStarted();
myDocumentAdapter =
new DocumentAdapter() {
@Override
public void documentChanged(DocumentEvent e) {
if (myPreview == null) return;
final TemplateState templateState =
TemplateManagerImpl.getTemplateState(myEditor);
if (templateState != null) {
final TextResult value =
templateState.getVariableValue(
InplaceRefactoring.PRIMARY_VARIABLE_NAME);
if (value != null) {
updateTitle(getVariable(), value.getText());
}
}
}
};
myEditor.getDocument().addDocumentListener(myDocumentAdapter);
updateTitle(getVariable());
if (TemplateManagerImpl.getTemplateState(myEditor) != null) {
myEditor.putUserData(ACTIVE_INTRODUCE, this);
}
}
}
result.set(started);
if (!started) {
finish(true);
}
},
getCommandName(),
getCommandName());
return result.get();
}
@Override
public void calcData(final DataKey key, final DataSink sink) {
if (key.equals(LangDataKeys.PSI_ELEMENT)) {
if (mySelectedElements != null && !mySelectedElements.isEmpty()) {
T selectedElement = mySelectedElements.iterator().next();
if (selectedElement instanceof ClassMemberWithElement) {
sink.put(
LangDataKeys.PSI_ELEMENT, ((ClassMemberWithElement) selectedElement).getElement());
}
}
}
}
private String constructAmendedMessage() {
Set<VirtualFile> selectedRoots = getVcsRoots(getSelectedFilePaths()); // get only selected files
LinkedHashSet<String> messages = ContainerUtil.newLinkedHashSet();
if (myMessagesForRoots != null) {
for (VirtualFile root : selectedRoots) {
String message = myMessagesForRoots.get(root);
if (message != null) {
messages.add(message);
}
}
}
return DvcsUtil.joinMessagesOrNull(messages);
}
@SuppressWarnings("unchecked")
public void resetElements(
T[] elements,
final @Nullable Comparator<T> sortComparator,
final boolean restoreSelectedElements) {
final List<T> selectedElements =
restoreSelectedElements && mySelectedElements != null
? new ArrayList<T>(mySelectedElements)
: null;
myElements = elements;
if (sortComparator != null) {
myComparator = new ElementNodeComparatorWrapper(sortComparator);
}
mySelectedNodes.clear();
myNodeToParentMap.clear();
myElementToNodeMap.clear();
myContainerNodes.clear();
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
myTreeModel = buildModel();
}
});
myTree.setModel(myTreeModel);
myTree.setRootVisible(false);
restoreTree();
if (myOptionControls == null) {
myCopyJavadocCheckbox = new NonFocusableCheckBox(IdeBundle.message("checkbox.copy.javadoc"));
if (myIsInsertOverrideVisible) {
myInsertOverrideAnnotationCheckbox =
new NonFocusableCheckBox(IdeBundle.message("checkbox.insert.at.override"));
myOptionControls =
new JCheckBox[] {myCopyJavadocCheckbox, myInsertOverrideAnnotationCheckbox};
} else {
myOptionControls = new JCheckBox[] {myCopyJavadocCheckbox};
}
}
myTree.doLayout();
setOKActionEnabled(myElements != null && myElements.length > 0);
if (selectedElements != null) {
selectElements(selectedElements.toArray(new ClassMember[selectedElements.size()]));
}
if (mySelectedElements == null || mySelectedElements.isEmpty()) {
expandFirst();
}
}
@Nullable
public String getDefaultMessageFor(FilePath[] filesToCheckin) {
LinkedHashSet<String> messages = ContainerUtil.newLinkedHashSet();
for (VirtualFile root : GitUtil.gitRoots(Arrays.asList(filesToCheckin))) {
VirtualFile mergeMsg = root.findFileByRelativePath(GitRepositoryFiles.GIT_MERGE_MSG);
VirtualFile squashMsg = root.findFileByRelativePath(GitRepositoryFiles.GIT_SQUASH_MSG);
try {
if (mergeMsg == null && squashMsg == null) {
continue;
}
String encoding = GitConfigUtil.getCommitEncoding(myProject, root);
if (mergeMsg != null) {
messages.add(loadMessage(mergeMsg, encoding));
} else {
messages.add(loadMessage(squashMsg, encoding));
}
} catch (IOException e) {
if (log.isDebugEnabled()) {
log.debug("Unable to load merge message", e);
}
}
}
return DvcsUtil.joinMessagesOrNull(messages);
}
protected final boolean areElementsSelected() {
return mySelectedElements != null && !mySelectedElements.isEmpty();
}
@Nullable
public T[] getSelectedElements(T[] a) {
LinkedHashSet<T> list = getSelectedElementsList();
if (list == null) return null;
return list.toArray(a);
}
private static TextRange preprocess(@NotNull final ASTNode node, @NotNull TextRange range) {
TextRange result = range;
PsiElement psi = node.getPsi();
if (!psi.isValid()) {
for (PreFormatProcessor processor : Extensions.getExtensions(PreFormatProcessor.EP_NAME)) {
result = processor.process(node, result);
}
return result;
}
PsiFile file = psi.getContainingFile();
// We use a set here because we encountered a situation when more than one PSI leaf points to
// the same injected fragment
// (at least for sql injected into sql).
final LinkedHashSet<TextRange> injectedFileRangesSet = ContainerUtilRt.newLinkedHashSet();
if (!psi.getProject().isDefault()) {
List<DocumentWindow> injectedDocuments =
InjectedLanguageUtil.getCachedInjectedDocuments(file);
if (!injectedDocuments.isEmpty()) {
for (DocumentWindow injectedDocument : injectedDocuments) {
injectedFileRangesSet.add(
TextRange.from(injectedDocument.injectedToHost(0), injectedDocument.getTextLength()));
}
} else {
Collection<PsiLanguageInjectionHost> injectionHosts = collectInjectionHosts(file, range);
PsiLanguageInjectionHost.InjectedPsiVisitor visitor =
new PsiLanguageInjectionHost.InjectedPsiVisitor() {
@Override
public void visit(
@NotNull PsiFile injectedPsi,
@NotNull List<PsiLanguageInjectionHost.Shred> places) {
for (PsiLanguageInjectionHost.Shred place : places) {
Segment rangeMarker = place.getHostRangeMarker();
injectedFileRangesSet.add(
TextRange.create(rangeMarker.getStartOffset(), rangeMarker.getEndOffset()));
}
}
};
for (PsiLanguageInjectionHost host : injectionHosts) {
InjectedLanguageUtil.enumerate(host, visitor);
}
}
}
if (!injectedFileRangesSet.isEmpty()) {
List<TextRange> ranges = ContainerUtilRt.newArrayList(injectedFileRangesSet);
Collections.reverse(ranges);
for (TextRange injectedFileRange : ranges) {
int startHostOffset = injectedFileRange.getStartOffset();
int endHostOffset = injectedFileRange.getEndOffset();
if (startHostOffset >= range.getStartOffset() && endHostOffset <= range.getEndOffset()) {
PsiFile injected = InjectedLanguageUtil.findInjectedPsiNoCommit(file, startHostOffset);
if (injected != null) {
int startInjectedOffset =
range.getStartOffset() > startHostOffset
? startHostOffset - range.getStartOffset()
: 0;
int endInjectedOffset = injected.getTextLength();
if (range.getEndOffset() < endHostOffset) {
endInjectedOffset -= endHostOffset - range.getEndOffset();
}
final TextRange initialInjectedRange =
TextRange.create(startInjectedOffset, endInjectedOffset);
TextRange injectedRange = initialInjectedRange;
for (PreFormatProcessor processor :
Extensions.getExtensions(PreFormatProcessor.EP_NAME)) {
injectedRange = processor.process(injected.getNode(), injectedRange);
}
// Allow only range expansion (not reduction) for injected context.
if ((initialInjectedRange.getStartOffset() > injectedRange.getStartOffset()
&& initialInjectedRange.getStartOffset() > 0)
|| (initialInjectedRange.getEndOffset() < injectedRange.getEndOffset()
&& initialInjectedRange.getEndOffset() < injected.getTextLength())) {
range =
TextRange.create(
range.getStartOffset()
+ injectedRange.getStartOffset()
- initialInjectedRange.getStartOffset(),
range.getEndOffset()
+ initialInjectedRange.getEndOffset()
- injectedRange.getEndOffset());
}
}
}
}
}
for (PreFormatProcessor processor : Extensions.getExtensions(PreFormatProcessor.EP_NAME)) {
result = processor.process(node, result);
}
return result;
}