下面列出了怎么用com.intellij.psi.PsiDirectory的API类实例代码及写法,或者点击链接到github查看源代码。
public Set<String> getModules() {
Set<String> modules = new HashSet<String>();
PsiDirectory baseDir = PsiDirectoryFactory.getInstance(project).createDirectory(project.getBaseDir());
if (isAndroidProject(baseDir)) {
Logger.debug(project.getName() + " is an Android project");
PsiDirectory[] dirs = baseDir.getSubdirectories();
for (PsiDirectory dir : dirs) {
if (!dir.getName().equals("build") && !dir.getName().equals("gradle")) {
if (isModule(dir)) {
Logger.debug(dir.getName() + " is a Module");
modules.add(dir.getName());
}
}
}
}
Logger.debug(modules.toString());
return modules;
}
/**
* Traverses the given directories and returns the first valid
* extension definition that's applicable.
*
* @param directories List of directories to analyze
*/
public static TYPO3ExtensionDefinition findContainingExtension(PsiDirectory[] directories) {
for (PsiDirectory directory : directories) {
VirtualDirectoryImpl virtualFile = (VirtualDirectoryImpl) directory.getVirtualFile();
while (!isExtensionRootDirectory(virtualFile)) {
if (virtualFile.getParent() == null) {
return null;
}
virtualFile = virtualFile.getParent();
}
TYPO3ExtensionDefinition extensionDefinition = ExtensionDefinitionFactory.fromDirectory(virtualFile);
if (extensionDefinition != null) {
return extensionDefinition;
}
}
return null;
}
private void renameDirs(final Project project,
final PsiElement nameSuggestionContext,
final Editor editor,
final PsiDirectory contextDirectory,
final T aPackage,
final PsiDirectory... dirsToRename) {
final RenameDialog dialog = new RenameDialog(project, contextDirectory, nameSuggestionContext, editor) {
@Override
protected void doAction() {
String newQName = StringUtil.getQualifiedName(StringUtil.getPackageName(getQualifiedName(aPackage)), getNewName());
BaseRefactoringProcessor moveProcessor = createProcessor(newQName, project, dirsToRename, isSearchInComments(),
isSearchInNonJavaFiles());
invokeRefactoring(moveProcessor);
}
};
dialog.show();
}
@Override
public Object[] createPath(final Project project) {
if (moduleName != null) {
final Module module = ApplicationManager.getApplication().runReadAction(new Computable<Module>() {
@Nullable
@Override
public Module compute() {
return ModuleManager.getInstance(project).findModuleByName(moduleName);
}
});
if (module == null) return null;
}
final VirtualFileManager virtualFileManager = VirtualFileManager.getInstance();
final VirtualFile file = virtualFileManager.findFileByUrl(url);
if (file == null) return null;
final PsiDirectory directory = ApplicationManager.getApplication().runReadAction(new Computable<PsiDirectory>() {
@Nullable
@Override
public PsiDirectory compute() {
return PsiManager.getInstance(project).findDirectory(file);
}
});
if (directory == null) return null;
return new Object[]{directory};
}
public static void addLibraryChildren(final OrderEntry entry, final List<AbstractTreeNode> children, Project project, ProjectViewNode node) {
final PsiManager psiManager = PsiManager.getInstance(project);
VirtualFile[] files =
entry instanceof LibraryOrderEntry ? getLibraryRoots((LibraryOrderEntry)entry) : entry.getFiles(BinariesOrderRootType.getInstance());
for (final VirtualFile file : files) {
if (!file.isValid()) continue;
if (file.isDirectory()) {
final PsiDirectory psiDir = psiManager.findDirectory(file);
if (psiDir == null) {
continue;
}
children.add(new PsiDirectoryNode(project, psiDir, node.getSettings()));
}
else {
final PsiFile psiFile = psiManager.findFile(file);
if (psiFile == null) continue;
children.add(new PsiFileNode(project, psiFile, node.getSettings()));
}
}
}
@Nullable
public static PhpClass getBundleClassInDirectory(@NotNull PsiDirectory bundleDirContext) {
for (PsiFile psiFile : bundleDirContext.getFiles()) {
if(!(psiFile instanceof PhpFile)) {
continue;
}
PhpClass aClass = PhpPsiUtil.findClass((PhpFile) psiFile, phpClass ->
PhpElementsUtil.isInstanceOf(phpClass, "\\Symfony\\Component\\HttpKernel\\Bundle\\BundleInterface")
);
if(aClass != null) {
return aClass;
}
}
return null;
}
private static PsiElement generateCPP(Project project, TaskData taskData) {
VirtualFile parent = FileUtils.findOrCreateByRelativePath(project.getBaseDir(), FileUtils.getDirectory(taskData.getCppPath()));
PsiDirectory psiParent = PsiManager.getInstance(project).findDirectory(parent);
if (psiParent == null) {
throw new NotificationException("Couldn't open parent directory as PSI");
}
Language objC = Language.findLanguageByID("ObjectiveC");
if (objC == null) {
throw new NotificationException("Language not found");
}
PsiFile file = PsiFileFactory.getInstance(project).createFileFromText(
FileUtils.getFilename(taskData.getCppPath()),
objC,
getTaskContent(project, taskData.getClassName())
);
if (file == null) {
throw new NotificationException("Couldn't generate file");
}
return ApplicationManager.getApplication().runWriteAction(
(Computable<PsiElement>) () -> psiParent.add(file)
);
}
private static PsiFile getMain(PsiDirectory moduleRoot) {
PsiFile pkg = moduleRoot.findFile("package.json");
if (pkg != null && pkg instanceof JsonFile) {
if (((JsonFile) pkg).getTopLevelValue() instanceof JsonObject) {
JsonObject object = (JsonObject) ((JsonFile) pkg).getTopLevelValue();
if (object != null) {
JsonProperty property = object.findProperty("main");
if (property != null && property.getValue() != null && property.getValue() instanceof JsonStringLiteral) {
JsonStringLiteral propValue = (JsonStringLiteral) property.getValue();
String value = propValue.getValue();
PsiFile psiFile = moduleRoot.findFile(value.replace("./", ""));
return psiFile;
}
}
}
}
return null;
}
@Nullable
@RequiredReadAction
public final Image getChildDirectoryIcon(@Nullable PsiDirectory psiDirectory, @Nullable PsiPackageManager oldPsiPackageManager) {
Image packageIcon = getChildPackageIcon();
if (packageIcon == null) {
return getChildDirectoryIcon();
}
if (psiDirectory != null) {
PsiPackageManager psiPackageManager = oldPsiPackageManager == null ? PsiPackageManager.getInstance(psiDirectory.getProject()) : oldPsiPackageManager;
PsiPackage anyPackage = psiPackageManager.findAnyPackage(psiDirectory);
if (anyPackage != null) {
return packageIcon;
}
else {
return getChildDirectoryIcon();
}
}
else {
//
return packageIcon;
}
}
@Test
public void testResolvableImportPrefix() {
Label label = Label.create("//foo/bar:baz");
PsiDirectory externalGithubDirectory = mockPsiDirectory("github.com", null);
PsiDirectory externalGithubUserDirectory = mockPsiDirectory("user", externalGithubDirectory);
PsiDirectory fooDirectory = mockPsiDirectory("foo", externalGithubUserDirectory);
PsiDirectory fooBarDirectory = mockPsiDirectory("bar", fooDirectory);
BuildFile fooBarBuild = mockBuildFile(fooBarDirectory);
FuncallExpression fooBarBazRule = mockRule("baz", fooBarBuild);
PsiElement[] importReferences =
BlazeGoPackage.getImportReferences(label, fooBarBazRule, "github.com/user/foo/bar/baz");
assertThat(importReferences)
.isEqualTo(
new PsiElement[] {
externalGithubDirectory, // github.com
externalGithubUserDirectory, // user
fooDirectory, // foo
fooBarDirectory, // bar
fooBarBazRule, // baz
});
}
public static PsiDirectory writeDirectory(PsiDirectory dir, DirectoryWrapper dirWrapper, Project project) {
if (dir == null) {
//todo print error
return null;
}
RunnableFuture<PsiDirectory> runnableFuture = new FutureTask<>(() ->
ApplicationManager.getApplication().runWriteAction(new Computable<PsiDirectory>() {
@Override
public PsiDirectory compute() {
return writeDirectoryAction(dir, dirWrapper, project);
}
}));
ApplicationManager.getApplication().invokeLater(runnableFuture);
try {
return runnableFuture.get();
} catch (InterruptedException | ExecutionException e) {
Logger.log("runnableFuture " + e.getMessage());
Logger.printStack(e);
}
return null;
}
private static void collectFiles2Move(Map<PsiFile, TargetDirectoryWrapper> files2Move,
PsiDirectory directory,
PsiDirectory rootDirectory,
@Nonnull TargetDirectoryWrapper targetDirectory) {
final PsiElement[] children = directory.getChildren();
final String relativePath = VfsUtilCore.getRelativePath(directory.getVirtualFile(), rootDirectory.getVirtualFile(), '/');
final TargetDirectoryWrapper newTargetDirectory = relativePath.length() == 0
? targetDirectory
: targetDirectory.findOrCreateChild(relativePath);
for (PsiElement child : children) {
if (child instanceof PsiFile) {
files2Move.put((PsiFile)child, newTargetDirectory);
}
else if (child instanceof PsiDirectory){
collectFiles2Move(files2Move, (PsiDirectory)child, directory, newTargetDirectory);
}
}
}
public void collectSimpleActions(Project project, VirtualFile virtualFile, List<SimpleAction> listSimpleAction) {
ApplicationManager.getApplication().runReadAction(() -> {
PsiDirectory currentDir = FileWriter.findCurrentDirectory(project, virtualFile);
if (currentDir == null) {
return;
}
// Disabled
if (!getRootElement().getDirectory().isEnabled()) {
return;
}
SimpleAction rootAction = getRootAction(project, listSimpleAction, currentDir);
CollectSimpleActionVisitor visitor = new CollectSimpleActionVisitor(rootAction, project);
for (ElementWrapper elementWrapper : rootElement.getListElementWrapper()) {
elementWrapper.accept(visitor);
}
});
}
public static void generateBaseArchitecture(PsiDirectory parent) {
// Check if exists main package
PsiDirectory packageResult = containsPackage(parent, MAIN.toLowerCase());
// Not exists
if (packageResult == null) {
// Create main package
mainDirectory = createDirectory(parent, MAIN.toLowerCase());
} else { // Exists
// Set user main package
setMainDirectory(packageResult);
}
// Create data package
BaseDataController.create();
// Create domain package
BaseDomainController.create();
// Create view package
BaseViewController.create();
}
/**
* Gives targets to files which relative to current file directory
*/
@NotNull
public static Collection<PsiFile> getFileResourceTargetsInDirectoryScope(@NotNull PsiFile psiFile, @NotNull String content) {
// bundle scope
if(content.startsWith("@")) {
return Collections.emptyList();
}
PsiDirectory containingDirectory = psiFile.getContainingDirectory();
if(containingDirectory == null) {
return Collections.emptyList();
}
VirtualFile relativeFile = VfsUtil.findRelativeFile(content, containingDirectory.getVirtualFile());
if(relativeFile == null) {
return Collections.emptyList();
}
PsiFile targetFile = PsiElementUtils.virtualFileToPsiFile(psiFile.getProject(), relativeFile);
if(targetFile == null) {
return Collections.emptyList();
}
return Collections.singletonList(targetFile);
}
@Nullable
@Override
public List<UsageInfo> findUsages(final PsiFile psiFile, final PsiDirectory newParent, final boolean searchInComments, final boolean searchInNonJavaFiles) {
Query<PsiReference> search = ReferencesSearch.search(psiFile);
final List<PsiExtraFileReference> extraFileRefs = new ArrayList<PsiExtraFileReference>();
search.forEach(new Processor<PsiReference>() {
@Override
public boolean process(PsiReference psiReference) {
if (psiReference instanceof PsiExtraFileReference) {
extraFileRefs.add((PsiExtraFileReference) psiReference);
}
return true;
}
});
if (extraFileRefs.isEmpty()) {
return null;
} else {
final List<UsageInfo> result = new ArrayList<UsageInfo>(extraFileRefs.size());
for (final PsiExtraFileReference e : extraFileRefs) {
result.add(new FileUsageInfo(e));
}
return result;
}
}
@Override
public void doRun() {
PsiDirectory psiDirectory = VFSHelper.findPsiDirByPath(project, fileDirToDelete.getPath());
if (psiDirectory == null) {
ReportHelper.setState(ExecutionState.FAILED);
return;
}
try {
psiDirectory.delete();
} catch (IncorrectOperationException ex) {
Logger.log("DeleteDirectoryAction " + ex.getMessage());
Logger.printStack(ex);
ReportHelper.setState(ExecutionState.FAILED);
return;
}
}
@Nonnull
public static List<PsiDirectory> collectModuleDirectories(Module module) {
List<PsiDirectory> dirs = ContainerUtil.newArrayList();
VirtualFile[] contentRoots = ModuleRootManager.getInstance(module).getContentRoots();
for (VirtualFile root : contentRoots) {
PsiDirectory dir = PsiManager.getInstance(module.getProject()).findDirectory(root);
if (dir != null) {
dirs.add(dir);
}
}
return dirs;
}
@Override
public boolean isConfigurationFromContext(RunConfiguration config, ConfigurationContext context) {
if (!(config.getType() instanceof GaugeRunTaskConfigurationType)) return false;
if (!(context.getPsiLocation() instanceof PsiDirectory) && !(context.getPsiLocation() instanceof PsiFile))
return false;
VirtualFile[] selectedFiles = CommonDataKeys.VIRTUAL_FILE_ARRAY.getData(context.getDataContext());
if (selectedFiles == null) return false;
String specs = ((GaugeRunConfiguration) config).getSpecsToExecute();
return StringUtil.join(getSpecs(selectedFiles), Constants.SPEC_FILE_DELIMITER).equals(specs);
}
public int getTodoItemCount(PsiDirectory directory) {
if (TodoTreeHelper.skipDirectory(directory)) {
return 0;
}
int count = 0;
Iterator<PsiFile> iterator = myBuilder.getFiles(directory);
while (iterator.hasNext()) {
PsiFile psiFile = iterator.next();
count += getStructure().getTodoItemCount(psiFile);
}
return count;
}
@Override
@RequiredReadAction
public void prepareProperties(Map<String, Object> props)
{
PsiDirectory directory = (PsiDirectory) props.get("psiDirectory");
if(directory == null)
{
return;
}
Module module = ModuleUtilCore.findModuleForPsiElement(directory);
if(module != null)
{
props.put("MODULE", module.getName());
}
props.put("GUID", UUID.randomUUID().toString());
DotNetSimpleModuleExtension<?> extension = ModuleUtilCore.getExtension(directory, DotNetSimpleModuleExtension.class);
if(extension == null)
{
Module moduleByPsiDirectory = findModuleByPsiDirectory(directory);
if(moduleByPsiDirectory != null)
{
extension = ModuleUtilCore.getExtension(moduleByPsiDirectory, DotNetSimpleModuleExtension.class);
}
}
String namespace = null;
if(extension != null)
{
namespace = formatNamespace(extension.getNamespaceGeneratePolicy().calculateNamespace(directory));
}
props.put("NAMESPACE_NAME", namespace);
}
@Override
public boolean addSubtreeToUpdateByElement(@Nonnull Object element) {
if (element instanceof PsiDirectory && !myProject.isDisposed()) {
final PsiDirectory dir = (PsiDirectory)element;
final ProjectTreeStructure treeStructure = (ProjectTreeStructure)myTreeStructure;
PsiDirectory dirToUpdateFrom = dir;
// optimization
// isEmptyMiddleDirectory can be slow when project VFS is not fully loaded (initial dumb mode).
// It's easiest to disable the optimization in any dumb mode
if (!treeStructure.isFlattenPackages() && treeStructure.isHideEmptyMiddlePackages() && !DumbService.isDumb(myProject)) {
while (dirToUpdateFrom != null && BaseProjectViewDirectoryHelper.isEmptyMiddleDirectory(dirToUpdateFrom, true)) {
dirToUpdateFrom = dirToUpdateFrom.getParentDirectory();
}
}
boolean addedOk;
while (!(addedOk = super.addSubtreeToUpdateByElement(dirToUpdateFrom == null ? myTreeStructure.getRootElement() : dirToUpdateFrom))) {
if (dirToUpdateFrom == null) {
break;
}
dirToUpdateFrom = dirToUpdateFrom.getParentDirectory();
}
return addedOk;
}
return super.addSubtreeToUpdateByElement(element);
}
@Test
public void testExcludeDirectories() {
PsiDirectory dir = workspace.createPsiDirectory(new WorkspacePath("java/com/google/tests"));
workspace.createPsiFile(new WorkspacePath("java/com/google/tests/Test.java"));
workspace.createPsiFile(new WorkspacePath("java/com/google/Foo.java"));
BuildFile file =
createBuildFile(
new WorkspacePath("java/com/google/BUILD"),
"glob(" + " ['**/*']," + " exclude = ['BUILD'])");
PsiUtils.findFirstChildOfClassRecursive(file, GlobExpression.class);
PsiReference[] references = FindUsages.findAllReferences(dir);
assertThat(references).isEmpty();
}
protected HaxeFile getFile(String fileName) {
PsiDirectory directory = root.access(path);
if (directory != null && directory.isValid()) {
PsiFile file = directory.findFile(fileName + ".hx");
if (file != null && file.isValid() && file instanceof HaxeFile) {
return (HaxeFile)file;
}
}
return null;
}
@Override
protected PsiFile createFile(String name, String templateName, PsiDirectory dir) {
String nameWithoutPrefix = name.replaceFirst("NodeTypes\\.", "");
String prefix = "";
switch (templateName) {
case DOCUMENT_NODE_TYPE_TEMPLATE_NAME:
prefix = "Document.";
break;
case CONTENT_NODE_TYPE_TEMPLATE_NAME:
prefix = "Content.";
break;
case COLLECTION_NODE_TYPE_TEMPLATE_NAME:
prefix = "Collection.";
break;
case MIXIN_NODE_TYPE_TEMPLATE_NAME:
prefix = "Mixin.";
break;
case CONSTRAINT_NODE_TYPE_TEMPLATE_NAME:
prefix = "Constraint.";
break;
}
if (!nameWithoutPrefix.startsWith(prefix)) {
nameWithoutPrefix = prefix + nameWithoutPrefix;
}
name = "NodeTypes." + nameWithoutPrefix;
return super.createFile(name, templateName, dir);
}
/**
* Gets Ignore file for given {@link Project} and root {@link PsiDirectory}.
* If file is missing - creates new one.
*
* @param project current project
* @param fileType current ignore file type
* @param directory root directory
* @param createIfMissing create new file if missing
* @return Ignore file
*/
@Nullable
public static PsiFile getIgnoreFile(@NotNull Project project, @NotNull IgnoreFileType fileType,
@Nullable PsiDirectory directory, boolean createIfMissing) {
VirtualFile projectDir = Utils.guessProjectDir(project);
if (projectDir == null) {
return null;
}
if (directory == null) {
directory = PsiManager.getInstance(project).findDirectory(projectDir);
}
assert directory != null;
String filename = fileType.getIgnoreLanguage().getFilename();
PsiFile file = directory.findFile(filename);
VirtualFile virtualFile = file == null ? directory.getVirtualFile().findChild(filename) : file.getVirtualFile();
if (file == null && virtualFile == null && createIfMissing) {
try {
file = new CreateFileCommandAction(project, directory, fileType).execute();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
}
return file;
}
@NotNull
public List<HaxePackageModel> getChildren() {
PsiDirectory directory = root.access(path);
if (directory != null) {
return Arrays.stream(directory.getSubdirectories())
.map(subDirectory -> new HaxePackageModel(root, subDirectory.getName(), this))
.collect(Collectors.toList());
}
return Collections.emptyList();
}
private static boolean isPyPackageOutsideProject(PsiElement element) {
if (!(element instanceof PsiDirectory)) {
return false;
}
PsiDirectory dir = (PsiDirectory) element;
return dir.findFile(PyNames.INIT_DOT_PY) != null
&& !inProjectScope(dir.getProject(), dir.getVirtualFile());
}
void createOrUpdateIntrospectionOutputFile(String schemaText, IntrospectionOutputFormat format, VirtualFile introspectionSourceFile, String outputFileName) {
ApplicationManager.getApplication().runWriteAction(() -> {
try {
final String header;
switch (format) {
case SDL:
header = "# This file was generated based on \"" + introspectionSourceFile.getName() + "\". Do not edit manually.\n\n";
break;
case JSON:
header = "";
break;
default:
throw new IllegalArgumentException("unsupported output format: " + format);
}
String relativeOutputFileName = StringUtils.replaceChars(outputFileName, '\\', '/');
VirtualFile outputFile = introspectionSourceFile.getParent().findFileByRelativePath(relativeOutputFileName);
if (outputFile == null) {
PsiDirectory directory = PsiDirectoryFactory.getInstance(myProject).createDirectory(introspectionSourceFile.getParent());
CreateFileAction.MkDirs dirs = new CreateFileAction.MkDirs(relativeOutputFileName, directory);
outputFile = dirs.directory.getVirtualFile().createChildData(introspectionSourceFile, dirs.newName);
}
outputFile.putUserData(GraphQLSchemaKeys.IS_GRAPHQL_INTROSPECTION_JSON, true);
final FileEditor[] fileEditors = FileEditorManager.getInstance(myProject).openFile(outputFile, true, true);
if (fileEditors.length > 0) {
final FileEditor fileEditor = fileEditors[0];
setEditorTextAndFormatLines(header + schemaText, fileEditor);
} else {
Notifications.Bus.notify(new Notification("GraphQL", "GraphQL Error", "Unable to open an editor for '" + outputFile.getPath() + "'", NotificationType.ERROR));
}
} catch (IOException ioe) {
Notifications.Bus.notify(new Notification("GraphQL", "GraphQL IO Error", "Unable to create file '" + outputFileName + "' in directory '" + introspectionSourceFile.getParent().getPath() + "': " + ioe.getMessage(), NotificationType.ERROR));
}
});
}
@RequiredUIAccess
@Override
public final void actionPerformed(@Nonnull AnActionEvent e) {
DataContext dataContext = e.getDataContext();
IdeView view = dataContext.getData(LangDataKeys.IDE_VIEW);
if (view == null) return;
PsiDirectory dir = getTargetDirectory(dataContext, view);
if (dir == null) return;
Project project = dir.getProject();
FileTemplate selectedTemplate = getTemplate(project, dir);
if (selectedTemplate != null) {
AnAction action = getReplacedAction(selectedTemplate);
if (action != null) {
action.actionPerformed(e);
}
else {
FileTemplateManager.getInstance(project).addRecentName(selectedTemplate.getName());
AttributesDefaults defaults = getAttributesDefaults(dataContext);
Map<String, Object> properties = defaults != null ? defaults.getDefaultProperties() : null;
CreateFromTemplateDialog dialog = new CreateFromTemplateDialog(dir, selectedTemplate, defaults, properties);
PsiElement createdElement = dialog.create();
if (createdElement != null) {
elementCreated(dialog, createdElement);
view.selectElement(createdElement);
if (selectedTemplate.isLiveTemplateEnabled() && createdElement instanceof PsiFile) {
Map<String, String> defaultValues = getLiveTemplateDefaults(dataContext, ((PsiFile)createdElement));
startLiveTemplate((PsiFile)createdElement, notNull(defaultValues, Collections.emptyMap()));
}
}
}
}
}