Java VirtualFileFilter类代码示例

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
private void checkHighlighting(ExpectedHighlightingData data, String filePath) {
  data.init();

  PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
  getFile().getText(); //to load text
  myJavaFilesFilter.allowTreeAccessForFile(getVFile());
  getJavaFacade().setAssertOnFileLoadingFilter(myJavaFilesFilter, myTestRootDisposable); // check repository work

  try {
    Collection<HighlightInfo> infos = doHighlighting();

    data.checkResult(infos, getEditor().getDocument().getText(), filePath);
  }
  finally {
    getJavaFacade().setAssertOnFileLoadingFilter(VirtualFileFilter.NONE, myTestRootDisposable);
  }
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
public void testAnnotationIndex() throws Exception {
  getJavaFacade().setAssertOnFileLoadingFilter(new VirtualFileFilter() {
    @Override
    public boolean accept(final VirtualFile file) {
      return !"package-info.java".equals(file.getName());
    }
  }, myTestRootDisposable);

  final PsiClass annotationTypeClass = findClass("annotations.AnnotationType");
  assertTrue(annotationTypeClass.isAnnotationType());

  final Collection<PsiMember> all = AnnotatedMembersSearch.search(annotationTypeClass, GlobalSearchScope.moduleScope(myModule)).findAll();

  assertEquals(2, all.size());
  Set<String> correctNames = new HashSet<String>(Arrays.asList("AnnotatedClass", "correctMethod"));
  for (PsiMember member : all) {
    assertTrue(correctNames.contains(member.getName()));
  }

  final Collection<PsiPackage> packages =
    AnnotatedPackagesSearch.search(annotationTypeClass, GlobalSearchScope.moduleScope(myModule)).findAll();
  assertEquals(1, packages.size());
  assertEquals("annotated", packages.iterator().next().getQualifiedName());

  tearDownLoadingFilter();
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
protected boolean accept(@NotNull final PsiDirectory dir, @NotNull final Processor<VirtualFile> processor) {
  final Project project = dir.getProject();
  final ProjectFileIndex index = ProjectRootManager.getInstance(project).getFileIndex();
  //we should analyze generated source files only if the action is explicitly invoked for a directory located under generated roots
  final boolean processGeneratedFiles = isInGeneratedSources(dir.getVirtualFile(), project);
  return VfsUtilCore.iterateChildrenRecursively(dir.getVirtualFile(), VirtualFileFilter.ALL, new ContentIterator() {
    @Override
    @SuppressWarnings({"SimplifiableIfStatement"})
    public boolean processFile(@NotNull final VirtualFile fileOrDir) {
      if (!myIncludeTestSource && index.isInTestSourceContent(fileOrDir)) return true;
      if (!processGeneratedFiles && isInGeneratedSources(fileOrDir, project)) return true;
      if (!fileOrDir.isDirectory()) {
        return processor.process(fileOrDir);
      }
      return true;
    }
  });
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
public static void registerScopeFilter(@NotNull AbstractLayoutCodeProcessor processor, @Nullable final SearchScope scope) {
  if (scope == null) {
    return;
  }

  processor.addFileFilter(new VirtualFileFilter() {
    @Override
    public boolean accept(@NotNull VirtualFile file) {
      if (scope instanceof LocalSearchScope) {
        return ((LocalSearchScope)scope).isInScope(file);
      }
      if (scope instanceof GlobalSearchScope) {
        return ((GlobalSearchScope)scope).contains(file);
      }

      return false;
    }
  });
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
protected PsiElement doResolve(PsiFile psiFile) {
  final PsiPolyVariantReference ref = PyResolveTestCase.findReferenceByMarker(psiFile);
  final PsiManagerImpl psiManager = (PsiManagerImpl)myFixture.getPsiManager();
  psiManager.setAssertOnFileLoadingFilter(new VirtualFileFilter() {
    @Override
    public boolean accept(VirtualFile file) {
      FileType fileType = file.getFileType();
      return fileType == PythonFileType.INSTANCE;
    }
  }, myTestRootDisposable);
  final ResolveResult[] resolveResults = ref.multiResolve(false);
  psiManager.setAssertOnFileLoadingFilter(VirtualFileFilter.NONE, myTestRootDisposable);
  if (resolveResults.length == 0) {
    return null;
  }
  return resolveResults[0].isValidResult() ? resolveResults[0].getElement() : null;
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
public void testConvert() throws IOException {
  final String testDataPath = AndroidTestCase.getTestDataPath() + "/conversion/proguardOptions";
  final File testData = new File(testDataPath, "before");
  final File tempDir = FileUtil.createTempDirectory("project", null);
  FileUtil.copyDir(testData, tempDir);
  ProjectConversionTestUtil.convert(tempDir.getAbsolutePath());
  final File expectedDataDir = new File(testDataPath, "after");
  PlatformTestUtil.assertDirectoriesEqual(
    LocalFileSystem.getInstance().refreshAndFindFileByIoFile(expectedDataDir),
    LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDir),
    new VirtualFileFilter() {
      @Override
      public boolean accept(VirtualFile file) {
        return !file.getName().startsWith(ProjectConversionUtil.PROJECT_FILES_BACKUP);
      }
    });
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
public void testConvert() throws IOException {
  String testDataPath = "plugins/google-app-engine/testData/conversion/appEngineFacet/";
  File testData = PathManagerEx.findFileUnderProjectHome(testDataPath + "before", getClass());
  File tempDir = FileUtil.createTempDirectory("app-engine-project", null);
  FileUtil.copyDir(testData, tempDir);
  ProjectConversionTestUtil.convert(tempDir.getAbsolutePath());
  File expectedDataDir = PathManagerEx.findFileUnderProjectHome(testDataPath + "after", getClass());
  PlatformTestUtil.assertDirectoriesEqual(LocalFileSystem.getInstance().refreshAndFindFileByIoFile(expectedDataDir),
                                          LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDir),
                                          new VirtualFileFilter() {
                                            @Override
                                            public boolean accept(VirtualFile file) {
                                              return !file.getName().startsWith(ProjectConversionUtil.PROJECT_FILES_BACKUP);
                                            }
                                          });
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
@Nullable
public static FileLookupData nonLocalFileLookup(
    String originalLabel,
    @Nullable BuildFile containingFile,
    QuoteType quoteType,
    PathFormat pathFormat) {
  if (originalLabel.indexOf(':') != -1) {
    // it's a package-local reference
    return null;
  }
  // handle the single '/' case by calling twice.
  String relativePath = StringUtil.trimStart(StringUtil.trimStart(originalLabel, "/"), "/");
  if (relativePath.startsWith("/")) {
    return null;
  }
  boolean onlyDirectories = pathFormat != PathFormat.NonLocalWithoutInitialBackslashes;
  VirtualFileFilter filter = vf -> !onlyDirectories || vf.isDirectory();
  return new FileLookupData(
      originalLabel, containingFile, null, relativePath, pathFormat, quoteType, filter);
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
@Nullable
public static FileLookupData packageLocalFileLookup(
    String originalLabel,
    StringLiteral element,
    @Nullable BuildFile basePackage,
    @Nullable VirtualFileFilter fileFilter) {
  if (basePackage == null) {
    return null;
  }
  Label packageLabel = basePackage.getPackageLabel();
  if (packageLabel == null) {
    return null;
  }
  String basePackagePath = packageLabel.blazePackage().relativePath();
  String filePath = basePackagePath + "/" + LabelUtils.getRuleComponent(originalLabel);
  return new FileLookupData(
      originalLabel,
      basePackage,
      basePackagePath,
      filePath,
      PathFormat.PackageLocal,
      element.getQuoteType(),
      fileFilter);
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
private FileLookupData(
    String originalLabel,
    @Nullable BuildFile containingFile,
    @Nullable String containingPackage,
    String filePathFragment,
    PathFormat pathFormat,
    QuoteType quoteType,
    @Nullable VirtualFileFilter fileFilter) {

  this.originalLabel = originalLabel;
  this.containingFile = containingFile;
  this.containingPackage = containingPackage;
  this.fileFilter = fileFilter;
  this.filePathFragment = filePathFragment;
  this.pathFormat = pathFormat;
  this.quoteType = quoteType;

  assert (pathFormat != PathFormat.PackageLocal
      || (containingPackage != null && containingFile != null));
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
@Override
public final void registerDetectors( FacetDetectorRegistry<PolygeneFacetConfiguration> registry )
{
    registry.registerOnTheFlyDetector(
        StdFileTypes.JAVA, VirtualFileFilter.ALL, new HasPolygeneImportPackageCondition(),
        new FacetDetector<PsiFile, PolygeneFacetConfiguration>( "PolygeneFacetDetector" )
        {
            @Override
            public PolygeneFacetConfiguration detectFacet( PsiFile source,
                                                       Collection<PolygeneFacetConfiguration> existingConfigurations )
            {
                if( !existingConfigurations.isEmpty() )
                {
                    return existingConfigurations.iterator().next();
                }

                return createDefaultConfiguration();
            }
        }
    );
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
protected CodeInsightTestFixture createCodeInsightFixture(final String relativeTestDataPath)
    throws Exception {
  final String testDataPath = new File(getTestDataPath(), relativeTestDataPath).getAbsolutePath();
  final CodeInsightTestFixture codeInsightFixture =
      JavaTestFixtureFactory.getFixtureFactory().createCodeInsightFixture(myProjectFixture);
  codeInsightFixture.setTestDataPath(testDataPath);
  final TempDirTestFixture tempDir = codeInsightFixture.getTempDirFixture();
  myModuleBuilder.addSourceContentRoot(tempDir.getTempDirPath());
  codeInsightFixture.setUp();
  final VirtualFile dir = LocalFileSystem.getInstance().refreshAndFindFileByPath(testDataPath);
  Assert.assertNotNull("Test data directory not found: " + testDataPath, dir);
  VfsUtil.processFilesRecursively(dir, new CommonProcessors.CollectProcessor<VirtualFile>());
  dir.refresh(false, true);
  tempDir.copyAll(
      testDataPath,
      "",
      new VirtualFileFilter() {
        @Override
        public boolean accept(VirtualFile file) {
          return !file.getName().contains("_after");
        }
      });
  return codeInsightFixture;
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
protected void testConvert(String testDataPath) throws IOException {
  // setup test data
  File testDataRoot = new File(AppEngineCodeInsightTestCase.getTestDataPath(), testDataPath);
  File testData = new File(testDataRoot, BEFORE_PATH);
  File tempDir = FileUtil.createTempDirectory(testDataPath, null);
  FileUtil.copyDir(testData, tempDir);
  File expectedDataDir = new File(testDataRoot, AFTER_PATH);

  // run the conversion operation
  ProjectConversionTestUtil.convert(tempDir.getAbsolutePath());

  PlatformTestUtil.assertDirectoriesEqual(
      LocalFileSystem.getInstance().refreshAndFindFileByIoFile(expectedDataDir),
      LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDir),
      new VirtualFileFilter() {
        @Override
        public boolean accept(VirtualFile file) {
          // ignore any generated backup files
          return !file.getName().startsWith(ProjectConversionUtil.PROJECT_FILES_BACKUP);
        }
      });
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
public void testAnnotationIndex() throws Exception {
  getJavaFacade().setAssertOnFileLoadingFilter(new VirtualFileFilter() {
    @Override
    public boolean accept(final VirtualFile file) {
      return !"package-info.java".equals(file.getName());
    }
  });

  final PsiClass annotationTypeClass = findClass("annotations.AnnotationType");
  assertTrue(annotationTypeClass.isAnnotationType());

  final Collection<PsiMember> all = AnnotatedMembersSearch.search(annotationTypeClass, GlobalSearchScope.moduleScope(myModule)).findAll();

  assertEquals(2, all.size());
  Set<String> correctNames = new HashSet<String>(Arrays.asList("AnnotatedClass", "correctMethod"));
  for (PsiMember member : all) {
    assertTrue(correctNames.contains(member.getName()));
  }

  final Collection<PsiPackage> packages =
    AnnotatedPackagesSearch.search(annotationTypeClass, GlobalSearchScope.moduleScope(myModule)).findAll();
  assertEquals(1, packages.size());
  assertEquals("annotated", packages.iterator().next().getQualifiedName());

  tearDownLoadingFilter();
}
 

import com.intellij.openapi.vfs.VirtualFileFilter; //导入依赖的package包/类
protected void accept(@NotNull final PsiDirectory dir, @NotNull final PsiElementVisitor visitor, final boolean needReadAction) {
  final Project project = dir.getProject();
  final PsiManager psiManager = PsiManager.getInstance(project);
  final ProjectFileIndex index = ProjectRootManager.getInstance(project).getFileIndex();
  VfsUtilCore.iterateChildrenRecursively(dir.getVirtualFile(), VirtualFileFilter.ALL, new ContentIterator() {
    @Override
    @SuppressWarnings({"SimplifiableIfStatement"})
    public boolean processFile(@NotNull final VirtualFile fileOrDir) {
      if (!myIncludeTestSource && index.isInTestSourceContent(fileOrDir)) return true;
      if (!fileOrDir.isDirectory()) {
        return AnalysisScope.processFile(fileOrDir, visitor, psiManager, needReadAction);
      }
      return true;
    }
  });
}