Java RenameProcessor类代码示例

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
public void testRenameImportedProtoAtCaretPosition() {
    PsiFile[] files = myFixture.configureByFiles(
            "rename/import/import.proto",
            "rename/import/source.proto"
    );

    PsiElement elementAtCaret = myFixture.getElementAtCaret();
    Project project = myFixture.getProject();
    RenameProcessor processor = new RenameProcessor(project, elementAtCaret, "renamed.proto", false, false);
    for (AutomaticRenamerFactory factory : Extensions.getExtensions(AutomaticRenamerFactory.EP_NAME)) {
        processor.addRenamerFactory(factory);
    }
    processor.run();

    Assert.assertEquals("renamed.proto", files[0].getName());
    Assert.assertEquals("import \"rename/import/renamed.proto\";",
            ((ProtoPsiFileRoot) files[1]).getProtoRoot().getImports().get(0).getText());
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
private void doAutomaticRenameMethod(final String className, final String methodSignature, final String newName) throws Exception {
  doTest((rootDir, rootAfter) -> {
    final JavaPsiFacade manager = getJavaFacade();
    final PsiClass aClass = manager.findClass(className, GlobalSearchScope.moduleScope(myModule));
    assertNotNull(aClass);
    final PsiMethod methodBySignature = aClass.findMethodBySignature(manager.getElementFactory().createMethodFromText(
      methodSignature + "{}", null), false);
    assertNotNull(methodBySignature);

    final RenameProcessor processor = new RenameProcessor(myProject, methodBySignature, newName, false, false);
    for (AutomaticRenamerFactory factory : Extensions.getExtensions(AutomaticRenamerFactory.EP_NAME)) {
      processor.addRenamerFactory(factory);
    }
    processor.run();
    PsiDocumentManager.getInstance(myProject).commitAllDocuments();
    FileDocumentManager.getInstance().saveAllDocuments();
  });
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
@Override
public void invoke(@NotNull final Project project,
                   @NotNull final PsiFile file,
                   @Nullable("is null when called from inspection") Editor editor,
                   @NotNull final PsiElement startElement,
                   @NotNull PsiElement endElement) {
  if (isAvailable(project, null, file)) {
    new WriteCommandAction(project) {
      @Override
      protected void run(@NotNull Result result) throws Throwable {
        LOG.assertTrue(file == startElement.getContainingFile());
        if (!FileModificationService.getInstance().prepareFileForWrite(file)) return;
        RenameProcessor processor = new RenameProcessor(project, startElement, myNewName, false, false);
        processor.run();
      }
    }.execute();
  }
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
  PsiElement element = descriptor.getPsiElement();
  if (element instanceof PyReferenceExpression) {
    final PsiReference reference = element.getReference();
    if (reference == null) return;
    element = reference.resolve();
  }
  if (element instanceof PyTargetExpression) {
    final String name = ((PyTargetExpression)element).getName();
    if (name == null) return;
    final VirtualFile virtualFile = element.getContainingFile().getVirtualFile();
    if (virtualFile != null) {
      final String publicName = StringUtil.trimLeading(name, '_');
      new RenameProcessor(project, element, publicName, false, false).run();
    }
  }
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
@Override
public void collectRefElements(PsiElement psiElement,
                               @Nullable RenameProcessor renameProcessor,
                               @NotNull String newName,
                               Collection<PsiElement> elementsToInvert) {
  final Collection<PsiReference> refs = ReferencesSearch.search(psiElement).findAll();

  for (PsiReference ref : refs) {
    final PsiElement refElement = ref.getElement();
    final PsiElement elementToInvert = getElementToInvert(psiElement, refElement);
    if (elementToInvert != null) {
      elementsToInvert.add(elementToInvert);
    }
    else {
      ContainerUtil.addIfNotNull(elementsToInvert, getForeignElementToInvert(psiElement, refElement, PythonLanguage.getInstance()));
    }
  }
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
@Test
public void testRenameJavaClass() {
  PsiJavaFile javaFile =
      (PsiJavaFile)
          workspace.createPsiFile(
              new WorkspacePath("com/google/foo/JavaClass.java"),
              "package com.google.foo;",
              "public class JavaClass {}");

  BuildFile buildFile =
      createBuildFile(
          new WorkspacePath("com/google/foo/BUILD"),
          "java_library(name = \"ref2\", srcs = [\"JavaClass.java\"])");

  new RenameProcessor(getProject(), javaFile.getClasses()[0], "NewName", false, false).run();

  assertFileContents(buildFile, "java_library(name = \"ref2\", srcs = [\"NewName.java\"])");
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
private void doTest(final String className, final String methodSignature, final String newName) throws Exception {
  doTest(new PerformAction() {
    @Override
    public void performAction(VirtualFile rootDir, VirtualFile rootAfter) throws Exception {
      final JavaPsiFacade manager = getJavaFacade();
      final PsiClass aClass = manager.findClass(className, GlobalSearchScope.moduleScope(myModule));
      assertNotNull(aClass);
      final PsiMethod methodBySignature = aClass.findMethodBySignature(manager.getElementFactory().createMethodFromText(
                methodSignature + "{}", null), false);
      assertNotNull(methodBySignature);
      final RenameProcessor renameProcessor = new RenameProcessor(myProject, methodBySignature, newName, false, false);
      renameProcessor.run();
      FileDocumentManager.getInstance().saveAllDocuments();
    }
  });
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
private void doRenameClass(final String className, final String newName) throws Exception {
  doTest(new PerformAction() {
    @Override
    public void performAction(VirtualFile rootDir, VirtualFile rootAfter) throws Exception {
      PsiClass aClass = myJavaFacade.findClass(className, GlobalSearchScope.allScope(getProject()));
      assertNotNull("Class XX not found", aClass);

      final RenameProcessor processor = new RenameProcessor(myProject, aClass, newName, true, true);
      for (AutomaticRenamerFactory factory : Extensions.getExtensions(AutomaticRenamerFactory.EP_NAME)) {
        processor.addRenamerFactory(factory);
      }
      processor.run();
      PsiDocumentManager.getInstance(myProject).commitAllDocuments();
      FileDocumentManager.getInstance().saveAllDocuments();
    }
  });
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
protected void performRenameInner(PsiElement element, String newName) {
  final RenamePsiElementProcessor elementProcessor = RenamePsiElementProcessor.forElement(element);
  final RenameProcessor
    renameProcessor = new RenameProcessor(myProject, element, newName,
                                          elementProcessor.isToSearchInComments(element),
                                          elementProcessor.isToSearchForTextOccurrences(element)){
    @Override
    public void doRun() {
      try {
        super.doRun();
      }
      finally {
        restoreCaretOffsetAfterRename();
      }
    }
  };
  for (AutomaticRenamerFactory factory : Extensions.getExtensions(AutomaticRenamerFactory.EP_NAME)) {
    if (factory.getOptionName() != null && factory.isApplicable(element)) {
      renameProcessor.addRenamerFactory(factory);
    }
  }
  renameProcessor.run();
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
private void rename(final PsiElement psiElement, final String newName) {
  new WriteCommandAction(myProject, psiElement.getContainingFile()) {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      new RenameProcessor(myProject, psiElement, newName, false, false).run();
    }
  }.executeSilently();
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
private void renamePackage(String packageName, String newPackageName) throws Exception {
  PsiPackage aPackage = JavaPsiFacade.getInstance(myPsiManager.getProject()).findPackage(packageName);
  assertNotNull("Package " + packageName + " not found", aPackage);

  //PsiDirectory dir = aPackage.getDirectories()[0];
  //to rename dir with classes move is used
  new RenameProcessor(myProject, aPackage, newPackageName, true, true).run();
  FileDocumentManager.getInstance().saveAllDocuments();
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
private void renamePackage() {
  Runnable runnable = new Runnable() {
    @Override
    public void run() {
      PsiPackage aPackage = JavaPsiFacade.getInstance(myPsiManager.getProject()).findPackage("bla");
      assertNotNull("Package bla not found", aPackage);

      PsiDirectory dir = aPackage.getDirectories()[0];
      new RenameProcessor(myProject, dir, "anotherBla", true, true).run();
      FileDocumentManager.getInstance().saveAllDocuments();
    }
  };
  CommandProcessor.getInstance().executeCommand(myProject, runnable,  "", null);
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
private void doTest(final String newName) throws Exception {
  configureByFile(BASE_PATH + getTestName(false) + ".java");
  PsiElement element = TargetElementUtil
      .findTargetElement(myEditor, TargetElementUtil.ELEMENT_NAME_ACCEPTED | TargetElementUtil.REFERENCED_ELEMENT_ACCEPTED);
  assertNotNull(element);
  new RenameProcessor(getProject(), element, newName, true, true).run();
  checkResultByFile(BASE_PATH + getTestName(false) + ".java.after");
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
private void doTest(final String newName) throws Exception {
  configureByFile(BASE_PATH + getTestName(false) + ".java");
  PsiElement element = TargetElementUtil
    .findTargetElement(myEditor, TargetElementUtil.ELEMENT_NAME_ACCEPTED | TargetElementUtil.REFERENCED_ELEMENT_ACCEPTED);
  assertNotNull(element);
  new RenameProcessor(getProject(), element, newName, true, true).run();
  checkResultByFile(BASE_PATH + getTestName(false) + "_after.java");
}
 

import com.intellij.refactoring.rename.RenameProcessor; //导入依赖的package包/类
private void doTest(final String className, final String methodSignature, final String newName) throws Exception {
  doTest((rootDir, rootAfter) -> {
    final JavaPsiFacade manager = getJavaFacade();
    final PsiClass aClass = manager.findClass(className, GlobalSearchScope.moduleScope(myModule));
    assertNotNull(aClass);
    final PsiMethod methodBySignature = aClass.findMethodBySignature(manager.getElementFactory().createMethodFromText(
              methodSignature + "{}", null), false);
    assertNotNull(methodBySignature);
    final RenameProcessor renameProcessor = new RenameProcessor(myProject, methodBySignature, newName, false, false);
    renameProcessor.run();
    FileDocumentManager.getInstance().saveAllDocuments();
  });
}