com.intellij.refactoring.rename.RenameProcessor Java Examples

public void testRenameImportedProtoAtCaretPosition() {
    PsiFile[] files = myFixture.configureByFiles(
            "rename/import/source.proto",
            "rename/import/import.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[1].getName());
    Assert.assertEquals("import \"rename/import/renamed.proto\";",
            ((ProtoPsiFileRoot) files[0]).getProtoRoot().getImports().get(0).getText());
}
 

@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\"])");
}
 

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();
}
 

private void doRename(PsiFile psiElement, String newName) {
    final RenameProcessor processor = new RenameProcessor(myProject, psiElement, newName, false, false);
    for (AutomaticRenamerFactory factory : Extensions.getExtensions(AutomaticRenamerFactory.EP_NAME)) {
        processor.addRenamerFactory(factory);
    }
    processor.run();

    PsiDocumentManager.getInstance(myProject).commitAllDocuments();
    FileDocumentManager.getInstance().saveAllDocuments();
}
 

private void processLoggerField(@NotNull PsiField psiField, @NotNull PsiClass psiClass, @NotNull AbstractLogProcessor logProcessor, @NotNull String lombokLoggerName) {
  if (!lombokLoggerName.equals(psiField.getName())) {
    RenameProcessor processor = new RenameProcessor(psiField.getProject(), psiField, lombokLoggerName, false, false);
    processor.doRun();
  }

  addAnnotation(psiClass, logProcessor.getSupportedAnnotationClasses()[0]);

  psiField.delete();
}
 

@Override
public void invoke(@Nonnull final Project project,
                   @Nonnull final PsiFile file,
                   @Nullable Editor editor,
                   @Nonnull final PsiElement startElement,
                   @Nonnull PsiElement endElement) {
  if (isAvailable(project, null, file)) {
    LOG.assertTrue(file == startElement.getContainingFile());
    if (!FileModificationService.getInstance().prepareFileForWrite(file)) return;
    RenameProcessor processor = new RenameProcessor(project, startElement, myNewName, false, false);
    processor.run();
  }
}
 

public RenameRefactoringImpl(Project project,
                             PsiElement element,
                             String newName,
                             boolean toSearchInComments,
                             boolean toSearchInNonJavaFiles) {
  super(new RenameProcessor(project, element, newName, toSearchInComments, toSearchInNonJavaFiles));
}
 

@RequiredReadAction
public void findUsages(List<UsageInfo> result,
                       final boolean searchInStringsAndComments,
                       final boolean searchInNonJavaFiles,
                       List<UnresolvableCollisionUsageInfo> unresolvedUsages,
                       Map<PsiElement, String> allRenames) {
  for (Iterator<PsiNamedElement> iterator = myElements.iterator(); iterator.hasNext();) {
    final PsiNamedElement variable = iterator.next();
    RenameProcessor.assertNonCompileElement(variable);
    final boolean success = findUsagesForElement(variable, result, searchInStringsAndComments, searchInNonJavaFiles, unresolvedUsages, allRenames);
    if (!success) {
      iterator.remove();
    }
  }
}
 

public void perform() {
  final PsiNameIdentifierOwner element = getNamedElement();
  if (element != null) {
    final String name = element.getName();
    ApplicationManager.getApplication().runWriteAction(new Runnable() {
      @Override
      public void run() {
        element.setName(myOldName);
      }
    });
    new RenameProcessor(element.getProject(), element, name, false, false).run();
  }
}
 

public void perform() {
  final PsiNameIdentifierOwner element = getNamedElement();
  if (element != null) {
    final String name = element.getName();
    ApplicationManager.getApplication().runWriteAction(() -> {
      element.setName(myOldName);
    });
    new RenameProcessor(element.getProject(), element, name, false, false).run();
  }
}
 

@Override
public void renameElement(final PsiElement element, final String newName, final boolean searchInComments, final boolean searchTextOccurrences) {
  final PsiElement substitution = RenamePsiElementProcessor.forElement(element).substituteElementToRename(element, myEditor);
  if (substitution == null) return;
  new RenameProcessor(getProject(), substitution, newName, searchInComments, searchTextOccurrences).run();
}