import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesProcessor; //导入依赖的package包/类
@Override
public void moveFile(@NotNull @NonNls final String filePath, @NotNull @NonNls final String to, @NotNull final String... additionalFiles) {
  assertInitialized();
  final Project project = getProject();
  new WriteCommandAction.Simple(project) {
    @Override
    protected void run() throws Exception {
      configureByFiles(ArrayUtil.reverseArray(ArrayUtil.append(additionalFiles, filePath)));
      final VirtualFile file = findFileInTempDir(to);
      Assert.assertNotNull("Directory " + to + " not found", file);
      Assert.assertTrue(to + " is not a directory", file.isDirectory());
      final PsiDirectory directory = myPsiManager.findDirectory(file);
      new MoveFilesOrDirectoriesProcessor(project, new PsiElement[]{getFile()}, directory,
                                          false, false, null, null).run();
    }
  }.execute().throwException();
}
 

import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesProcessor; //导入依赖的package包/类
private void doTest(final String targetDirName, final String fileToMove) throws Exception {
  doTest(new PerformAction() {
    @Override
    public void performAction(VirtualFile rootDir, VirtualFile rootAfter) throws Exception {
      final VirtualFile child = rootDir.findFileByRelativePath(fileToMove);
      assertNotNull("File " + fileToMove + " not found", child);
      PsiFile file = myPsiManager.findFile(child);

      final VirtualFile child1 = rootDir.findChild(targetDirName);
      assertNotNull("File " + targetDirName + " not found", child1);
      final PsiDirectory targetDirectory = myPsiManager.findDirectory(child1);

      new MoveFilesOrDirectoriesProcessor(myProject, new PsiElement[] {file}, targetDirectory,
                                          false, false, null, null).run();
      /*assert targetDirectory != null;
      final PsiFile psiFile = targetDirectory.findFile(fileToMove);
      assert psiFile != null;
      final Document document = PsiDocumentManager.getInstance(myProject).getDocument(psiFile);
      assert document != null;
      PsiDocumentManager.getInstance(myProject).doPostponedOperationsAndUnblockDocument(document);*/
      FileDocumentManager.getInstance().saveAllDocuments();
    }
  });
}
 

import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesProcessor; //导入依赖的package包/类
@Override
protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException {
  PsiFile file = descriptor.getPsiElement().getContainingFile();

  if (!(file instanceof GroovyFile)) return;

  VirtualFile vfile = file.getVirtualFile();
  if (vfile == null) return;

  final Module module = ModuleUtilCore.findModuleForFile(vfile, project);
  if (module == null) return;

  final String packageName = ((GroovyFile)file).getPackageName();
  PsiDirectory directory = PackageUtil.findOrCreateDirectoryForPackage(module, packageName, null, true);
  if (directory == null) return;

  String error = RefactoringMessageUtil.checkCanCreateFile(directory, file.getName());
  if (error != null) {
    Messages.showMessageDialog(project, error, CommonBundle.getErrorTitle(), Messages.getErrorIcon());
    return;
  }
  new MoveFilesOrDirectoriesProcessor(project, new PsiElement[]{file}, directory, false, false, false, null, null).run();
}
 

import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesProcessor; //导入依赖的package包/类
private void doMoveFileTest(String fileName, String toDirName) {
  Project project = myFixture.getProject();
  PsiManager manager = PsiManager.getInstance(project);

  String root = "/refactoring/move/" + getTestName(true);
  String rootBefore = root + "/before/src";
  String rootAfter = root + "/after/src";

  VirtualFile dir1 = myFixture.copyDirectoryToProject(rootBefore, "");
  PsiDocumentManager.getInstance(project).commitAllDocuments();

  VirtualFile virtualFile = dir1.findFileByRelativePath(fileName);
  assertNotNull(virtualFile);
  PsiElement file = manager.findFile(virtualFile);
  if (file == null) {
    file = manager.findDirectory(virtualFile);
  }
  assertNotNull(file);
  VirtualFile toVirtualDir = dir1.findFileByRelativePath(toDirName);
  assertNotNull(toVirtualDir);
  PsiDirectory toDir = manager.findDirectory(toVirtualDir);
  new MoveFilesOrDirectoriesProcessor(project, new PsiElement[]{file}, toDir, false, false, null, null).run();

  VirtualFile dir2 = getVirtualFileByName(PythonTestUtil.getTestDataPath() + rootAfter);
  try {
    PlatformTestUtil.assertDirectoriesEqual(dir2, dir1);
  }
  catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesProcessor; //导入依赖的package包/类
public void testCustomResourceBundleFilesMovedOrDeleted() throws IOException {
  final PropertiesFile file = PropertiesImplUtil.getPropertiesFile(myFixture.addFileToProject("resources-dev/my-app-dev.properties", ""));
  final PropertiesFile file2 = PropertiesImplUtil.getPropertiesFile(
    myFixture.addFileToProject("resources-dev/my-app-test.properties", ""));
  final PropertiesFile file3 = PropertiesImplUtil.getPropertiesFile(
    myFixture.addFileToProject("resources-prod/my-app-prod.properties", ""));
  assertNotNull(file);
  assertNotNull(file2);
  assertNotNull(file3);
  assertOneElement(file.getResourceBundle().getPropertiesFiles());
  assertOneElement(file2.getResourceBundle().getPropertiesFiles());
  assertOneElement(file3.getResourceBundle().getPropertiesFiles());
  final ResourceBundleManager resourceBundleBaseNameManager = ResourceBundleManager.getInstance(getProject());
  resourceBundleBaseNameManager.combineToResourceBundle(list(file, file2, file3), "my-app");

  assertSize(3, file.getResourceBundle().getPropertiesFiles());

  final PsiDirectory newDir = PsiManager.getInstance(getProject()).findDirectory(
    myFixture.getTempDirFixture().findOrCreateDir("new-resources-dir"));
  new MoveFilesOrDirectoriesProcessor(getProject(), new PsiElement[] {file2.getContainingFile()}, newDir, false, false, null, null).run();
  file3.getContainingFile().delete();

  assertSize(2, file.getResourceBundle().getPropertiesFiles());

  final ResourceBundleManagerState state = ResourceBundleManager.getInstance(getProject()).getState();
  assertNotNull(state);
  assertSize(1, state.getCustomResourceBundles());
  assertSize(2, state.getCustomResourceBundles().get(0).getFileUrls());
}
 

import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesProcessor; //导入依赖的package包/类
private void doTest(final String[] toMove, final String targetDirName) throws Exception {
  doTest(new PerformAction() {
    @Override
    public void performAction(VirtualFile rootDir, VirtualFile rootAfter) throws Exception {
      Collection<PsiElement> files = new ArrayList<PsiElement>();
      for (String s : toMove) {
        final VirtualFile child = VfsUtil.findRelativeFile(s, rootDir);
        assertNotNull("Neither class nor file " + s + " not found", child);
        PsiElement file = myPsiManager.findFile(child);
        if (file == null) file = JavaPsiFacade.getInstance(myProject).findPackage(s);
        files.add(file);
      }
      final VirtualFile child1 = VfsUtil.findRelativeFile(targetDirName, rootDir);
      assertNotNull("Target dir " + targetDirName + " not found", child1);
      final PsiDirectory targetDirectory = myPsiManager.findDirectory(child1);
      assertNotNull(targetDirectory);

      if (files.iterator().next() instanceof PsiFile) {
        new MoveFilesOrDirectoriesProcessor(myProject, PsiUtilCore.toPsiElementArray(files), targetDirectory,
                                            false, false, null, null).run();
      }
      else if (files.iterator().next() instanceof PsiPackage) {
        PsiPackage newParentPackage = JavaPsiFacade.getInstance(myPsiManager.getProject()).findPackage(targetDirName);
        assertNotNull(newParentPackage);
        final PsiDirectory[] dirs = newParentPackage.getDirectories();
        assertEquals(dirs.length, 1);

        new MoveClassesOrPackagesProcessor(myProject, PsiUtilCore.toPsiElementArray(files),
                                           new SingleSourceRootMoveDestination(PackageWrapper.create(newParentPackage),
                                                                               newParentPackage.getDirectories()[0]),
                                           true, true, null).run();
      }
      FileDocumentManager.getInstance().saveAllDocuments();
    }
  });
}