public static void copyAsFiles(
PsiElement[] elements, @Nullable PsiDirectory defaultTargetDirectory, Project project) {
PsiDirectory targetDirectory = null;
String newName = null;
boolean openInEditor = true;
if (ApplicationManager.getApplication().isUnitTestMode()) {
targetDirectory = defaultTargetDirectory;
} else {
CopyFilesOrDirectoriesDialog dialog =
new CopyFilesOrDirectoriesDialog(elements, defaultTargetDirectory, project, false);
if (dialog.showAndGet()) {
newName = elements.length == 1 ? dialog.getNewName() : null;
targetDirectory = dialog.getTargetDirectory();
openInEditor = dialog.openInEditor();
}
}
if (targetDirectory != null) {
try {
for (PsiElement element : elements) {
PsiFileSystemItem psiElement = (PsiFileSystemItem) element;
if (psiElement.isDirectory()) {
MoveFilesOrDirectoriesUtil.checkIfMoveIntoSelf(psiElement, targetDirectory);
}
}
} catch (IncorrectOperationException e) {
CommonRefactoringUtil.showErrorHint(
project, null, e.getMessage(), CommonBundle.getErrorTitle(), null);
return;
}
copyImpl(elements, newName, targetDirectory, false, openInEditor);
}
}
@Override
public void moduleAdded() {
if (!myModuleInitialized) {
myConnection.subscribe(
ProjectTopics.PROJECT_ROOTS,
new ModuleRootAdapter() {
@Override
public void rootsChanged(ModuleRootEvent event) {
scheduleUpdate();
}
});
myConnection.subscribe(GoLibrariesService.LIBRARIES_TOPIC, newRootUrls -> scheduleUpdate());
Project project = myModule.getProject();
StartupManager.getInstance(project)
.runWhenProjectIsInitialized(
() -> {
if (!project.isDisposed() && !myModule.isDisposed()) {
for (PsiFileSystemItem vendor :
FilenameIndex.getFilesByName(
project, GoConstants.VENDOR, GoUtil.moduleScope(myModule), true)) {
if (vendor.isDirectory()) {
showVendoringNotification();
break;
}
}
}
});
VirtualFileManager.getInstance().addVirtualFileListener(myFilesListener);
}
scheduleUpdate(0);
myModuleInitialized = true;
}
public static boolean isRoot(PsiFileSystemItem directory) {
if (directory == null) return true;
VirtualFile vFile = directory.getVirtualFile();
if (vFile == null) return true;
ProjectFileIndex fileIndex = ProjectFileIndex.SERVICE.getInstance(directory.getProject());
return Comparing.equal(fileIndex.getClassRootForFile(vFile), vFile)
|| Comparing.equal(fileIndex.getContentRootForFile(vFile), vFile)
|| Comparing.equal(fileIndex.getSourceRootForFile(vFile), vFile);
}
@Override
@NotNull
public Collection<PsiFileSystemItem> getContexts(
final Project project, @NotNull final VirtualFile file) {
final PsiFileSystemItem item = getPsiFileSystemItem(project, file);
if (item != null) {
final PsiFileSystemItem parent = item.getParent();
if (parent != null) {
return Collections.singleton(parent);
}
}
return Collections.emptyList();
}
@Override
protected String getContainerText(PsiFileSystemItem element, String name) {
PsiFileSystemItem parent = element.getParent();
final PsiDirectory psiDirectory = parent instanceof PsiDirectory ? (PsiDirectory) parent : null;
if (psiDirectory == null) return null;
final VirtualFile virtualFile = psiDirectory.getVirtualFile();
final String relativePath = getRelativePath(virtualFile, element.getProject());
if (relativePath == null) return "( " + File.separator + " )";
String path =
FilePathSplittingPolicy.SPLIT_BY_SEPARATOR.getOptimalTextForComponent(
name + " ", new File(relativePath), this, myMaxWidth);
return "(" + path + ")";
}
/**
* @param elementToCopy PsiFile or PsiDirectory
* @param newName can be not null only if elements.length == 1
* @param choice a horrible way to pass/keep user preference
* @return first copied PsiFile (recursively); null if no PsiFiles copied
*/
@Nullable
public static PsiFile copyToDirectory(
@NotNull PsiFileSystemItem elementToCopy,
@Nullable String newName,
@NotNull PsiDirectory targetDirectory,
@Nullable int[] choice)
throws IncorrectOperationException, IOException {
if (elementToCopy instanceof PsiFile) {
PsiFile file = (PsiFile) elementToCopy;
String name = newName == null ? file.getName() : newName;
if (checkFileExist(targetDirectory, choice, file, name, "Copy")) return null;
return targetDirectory.copyFileFrom(name, file);
} else if (elementToCopy instanceof PsiDirectory) {
PsiDirectory directory = (PsiDirectory) elementToCopy;
if (directory.equals(targetDirectory)) {
return null;
}
if (newName == null) newName = directory.getName();
final PsiDirectory existing = targetDirectory.findSubdirectory(newName);
final PsiDirectory subdirectory =
existing == null ? targetDirectory.createSubdirectory(newName) : existing;
EncodingRegistry.doActionAndRestoreEncoding(
directory.getVirtualFile(),
new ThrowableComputable<VirtualFile, IOException>() {
@Override
public VirtualFile compute() {
return subdirectory.getVirtualFile();
}
});
PsiFile firstFile = null;
PsiElement[] children = directory.getChildren();
for (PsiElement child : children) {
PsiFileSystemItem item = (PsiFileSystemItem) child;
PsiFile f = copyToDirectory(item, item.getName(), subdirectory, choice);
if (firstFile == null) {
firstFile = f;
}
}
return firstFile;
} else {
throw new IllegalArgumentException("unexpected elementToCopy: " + elementToCopy);
}
}
private PsiDirectory findOurSourceRoot(PsiFileSystemItem item) {
for (VirtualFile sourceRoot : ModuleRootManager.getInstance(myIdeaModule).getSourceRoots()) {
String rootPath = sourceRoot.toString();
String itemPath = item.getVirtualFile().toString();
if (itemPath.startsWith(rootPath)) {
return PsiManager.getInstance(myIdeaModule.getProject()).findDirectory(sourceRoot);
}
}
return null;
}
public void processIncludingFiles(
PsiFile context, Processor<Pair<VirtualFile, FileIncludeInfo>> processor) {
context = context.getOriginalFile();
VirtualFile contextFile = context.getVirtualFile();
if (contextFile == null) return;
MultiMap<VirtualFile, FileIncludeInfoImpl> infoList =
FileIncludeIndex.getIncludingFileCandidates(
context.getName(), GlobalSearchScope.allScope(myProject));
for (VirtualFile candidate : infoList.keySet()) {
PsiFile psiFile = myPsiManager.findFile(candidate);
if (psiFile == null || context.equals(psiFile)) continue;
for (FileIncludeInfo info : infoList.get(candidate)) {
PsiFileSystemItem item = resolveFileInclude(info, psiFile);
if (item != null && contextFile.equals(item.getVirtualFile())) {
if (!processor.process(Pair.create(candidate, info))) {
return;
}
}
}
}
}
@Nullable
public static List<File> asFileList(final PsiElement[] elements) {
final List<File> result = new ArrayList<File>();
for (PsiElement element : elements) {
final PsiFileSystemItem psiFile;
if (element instanceof PsiFileSystemItem) {
psiFile = (PsiFileSystemItem) element;
} else if (element instanceof PsiDirectoryContainer) {
final PsiDirectory[] directories = ((PsiDirectoryContainer) element).getDirectories();
psiFile = directories[0];
} else {
psiFile = element.getContainingFile();
}
if (psiFile != null) {
VirtualFile vFile = psiFile.getVirtualFile();
if (vFile != null && vFile.getFileSystem() instanceof LocalFileSystem) {
result.add(new File(vFile.getPath()));
}
}
}
return result.isEmpty() ? null : result;
}
@Nullable
public BundleManifest getManifest(@NotNull PsiFileSystemItem item) {
VirtualFile file = item.getVirtualFile();
if (file != null) {
List<OrderEntry> entries = myIndex.getOrderEntriesForFile(file);
if (entries.size() == 1 && entries.get(0) instanceof JdkOrderEntry) {
return new JdkBundleManifest();
}
Module module = myIndex.getModuleForFile(file);
if (module != null) {
return getManifest(module);
}
VirtualFile libRoot = myIndex.getClassRootForFile(file);
if (libRoot != null) {
return getManifest(libRoot);
}
}
return null;
}
@Override
public Object[] getFileReferenceCompletionVariants(final FileReference reference) {
final String s = reference.getText();
if (s != null && s.equals("/")) {
return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
final CommonProcessors.CollectUniquesProcessor<PsiFileSystemItem> collector =
new CommonProcessors.CollectUniquesProcessor<PsiFileSystemItem>();
final PsiElementProcessor<PsiFileSystemItem> processor =
new PsiElementProcessor<PsiFileSystemItem>() {
@Override
public boolean execute(@NotNull PsiFileSystemItem fileSystemItem) {
return new FilteringProcessor<PsiFileSystemItem>(
reference.getFileReferenceSet().getReferenceCompletionFilter(), collector)
.process(FileReference.getOriginalFile(fileSystemItem));
}
};
List<Object> additionalItems = ContainerUtil.newArrayList();
for (PsiFileSystemItem context : reference.getContexts()) {
for (final PsiElement child : context.getChildren()) {
if (child instanceof PsiFileSystemItem) {
processor.execute((PsiFileSystemItem) child);
}
}
if (context instanceof FileReferenceResolver) {
additionalItems.addAll(((FileReferenceResolver) context).getVariants(reference));
}
}
final FileType[] types = reference.getFileReferenceSet().getSuitableFileTypes();
final THashSet<PsiElement> set =
new THashSet<PsiElement>(collector.getResults(), VARIANTS_HASHING_STRATEGY);
final PsiElement[] candidates = PsiUtilCore.toPsiElementArray(set);
final Object[] variants = new Object[candidates.length + additionalItems.size()];
for (int i = 0; i < candidates.length; i++) {
PsiElement candidate = candidates[i];
Object item = reference.createLookupItem(candidate);
if (item == null) {
item = FileInfoManager.getFileLookupItem(candidate);
}
if (candidate instanceof PsiFile
&& item instanceof LookupElement
&& types.length > 0
&& ArrayUtil.contains(((PsiFile) candidate).getFileType(), types)) {
item = PrioritizedLookupElement.withPriority((LookupElement) item, Double.MAX_VALUE);
}
variants[i] = item;
}
for (int i = 0; i < additionalItems.size(); i++) {
variants[i + candidates.length] = additionalItems.get(i);
}
if (!reference.getFileReferenceSet().isUrlEncoded()) {
return variants;
}
List<Object> encodedVariants = new ArrayList<Object>(variants.length + additionalItems.size());
for (int i = 0; i < candidates.length; i++) {
final PsiElement element = candidates[i];
if (element instanceof PsiNamedElement) {
final PsiNamedElement psiElement = (PsiNamedElement) element;
String name = psiElement.getName();
final String encoded = reference.encode(name, psiElement);
if (encoded == null) continue;
if (!encoded.equals(name)) {
final Icon icon =
psiElement.getIcon(Iconable.ICON_FLAG_READ_STATUS | Iconable.ICON_FLAG_VISIBILITY);
LookupElementBuilder item =
FileInfoManager.getFileLookupItem(candidates[i], encoded, icon);
encodedVariants.add(item.withTailText(" (" + name + ")"));
} else {
encodedVariants.add(variants[i]);
}
}
}
encodedVariants.addAll(additionalItems);
return ArrayUtil.toObjectArray(encodedVariants);
}
@Nullable
@Override
public PsiElement[] getGotoDeclarationTargets(
@Nullable PsiElement sourceElement, int offset, Editor editor) {
ArrayList<PsiElement> result = new ArrayList<PsiElement>();
if (sourceElement != null)
for (PsiReference reference : sourceElement.getReferences())
if (reference instanceof PsiPolyVariantReference)
for (ResolveResult resolveResult :
((PsiPolyVariantReference) reference).multiResolve(false))
result.add(resolveResult.getElement());
else result.add(reference.resolve());
// add shadowed variables declaration
if (sourceElement instanceof PerlVariableNameElement) {
PsiElement variable = sourceElement.getParent();
if (variable instanceof PerlVariable) {
PsiElement variableContainer = sourceElement.getParent().getParent();
PsiFile myFile = sourceElement.getContainingFile();
if (myFile instanceof PerlFileElement
&& (variableContainer instanceof PsiPerlVariableDeclarationLexical
|| variableContainer instanceof PsiPerlVariableDeclarationGlobal)) {
PerlVariable shadowedVariable =
((PerlFileElement) myFile).getLexicalDeclaration((PerlVariable) variable);
if (shadowedVariable != null && !result.contains(shadowedVariable))
result.add(shadowedVariable);
}
}
}
// additional procesing for subname
else if (sourceElement instanceof PerlSubNameElement) {
PsiElement elementParent = sourceElement.getParent();
// suppress declaration if there is a definition and declaration
if (result.size() == 2
&& !(elementParent instanceof PerlSubDefinition
|| elementParent instanceof PerlSubDeclaration))
if (result.get(0).getOriginalElement() instanceof PerlSubDeclaration
&& result.get(1).getOriginalElement() instanceof PerlSubDefinition) result.remove(0);
}
// string content to file jump
else if (sourceElement instanceof PerlStringContentElement
&& ((PerlStringContentElement) sourceElement).looksLikePath()) {
String tokenText = sourceElement.getText().replaceAll("\\\\", "/").replaceAll("/+", "/");
Project project = sourceElement.getProject();
String fileName = ((PerlStringContentElement) sourceElement).getContentFileName();
for (String file : FilenameIndex.getAllFilenames(project))
if (file.contains(fileName)) {
// fixme somehow if includeDirectories is true - no files found
for (PsiFileSystemItem fileItem :
FilenameIndex.getFilesByName(project, file, GlobalSearchScope.allScope(project))) {
String canonicalPath = fileItem.getVirtualFile().getCanonicalPath();
if (canonicalPath != null)
if (canonicalPath.contains(tokenText + ".")) // higer priority
result.add(0, fileItem);
else if (canonicalPath.contains(tokenText)) result.add(fileItem);
}
for (PsiFileSystemItem fileItem :
FilenameIndex.getFilesByName(
project, file, GlobalSearchScope.allScope(project), true)) {
String canonicalPath = fileItem.getVirtualFile().getCanonicalPath();
if (canonicalPath != null) if (canonicalPath.contains(tokenText)) result.add(fileItem);
}
}
}
return result.toArray(new PsiElement[result.size()]);
}
@Override
public String getElementText(PsiFileSystemItem element) {
return element.getName();
}