Java RefactoringActionHandler类代码示例

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Override
protected void doFix(final Project project, ProblemDescriptor descriptor) throws IncorrectOperationException {
  final PsiNameIdentifierOwner owner = PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiVariable.class, PsiMethod.class);
  if (owner == null) {
    return;
  }
  final RefactoringActionHandler handler = JavaRefactoringActionHandlerFactory.getInstance().createInvertBooleanHandler();
  final Runnable runnable = new Runnable() {
    @Override
    public void run() {
      handler.invoke(project, new PsiElement[]{owner}, null);
    }
  };
  if (ApplicationManager.getApplication().isUnitTestMode()) {
    runnable.run();
  }
  else {
    ApplicationManager.getApplication().invokeLater(runnable, project.getDisposed());
  }
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
private void moveClass(Project project, Editor editor, PsiFile file, PsiClass aClass) {
  RefactoringActionHandler moveHandler = RefactoringActionHandlerFactory.getInstance().createMoveHandler();
  DataManager dataManager = DataManager.getInstance();
  DataContext dataContext = dataManager.getDataContext();
  final String fqName = aClass.getQualifiedName();
  LOG.assertTrue(fqName != null);
  PsiDirectory directory = PackageUtil
    .findOrCreateDirectoryForPackage(myCurrentModule, StringUtil.getPackageName(fqName), mySourceRoot, true);
  DataContext context = SimpleDataContext.getSimpleContext(LangDataKeys.TARGET_PSI_ELEMENT.getName(), directory, dataContext);

  moveHandler.invoke(project, new PsiElement[]{aClass}, context);
  PsiReference reference = file.findReferenceAt(editor.getCaretModel().getOffset());
  PsiClass newClass = JavaPsiFacade.getInstance(project).findClass(fqName, GlobalSearchScope.moduleScope(myCurrentModule));
  if (reference != null && newClass != null) {
    final QuestionAction action = new AddImportAction(project, reference, editor, newClass);
    action.execute();
  }
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Override
public void doFix(@NotNull final Project project, ProblemDescriptor descriptor) {
  final PsiElement nameElement = descriptor.getPsiElement();
  final PsiAnonymousClass aClass =
    (PsiAnonymousClass)nameElement.getParent();
  final JavaRefactoringActionHandlerFactory factory =
    JavaRefactoringActionHandlerFactory.getInstance();
  final RefactoringActionHandler anonymousToInner =
    factory.createAnonymousToInnerHandler();
  final DataManager dataManager = DataManager.getInstance();
  final DataContext dataContext = dataManager.getDataContext();
  final Runnable runnable = new Runnable() {
    @Override
    public void run() {
      anonymousToInner.invoke(project, new PsiElement[]{aClass}, dataContext);
    }
  };
  if (ApplicationManager.getApplication().isUnitTestMode()) {
    runnable.run();
  }
  else {
    ApplicationManager.getApplication().invokeLater(runnable, project.getDisposed());
  }
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Override
protected void doFix(@NotNull final Project project, ProblemDescriptor descriptor) throws IncorrectOperationException {
  final PsiElement location = descriptor.getPsiElement();
  final PsiMethod method = (PsiMethod)location.getParent();
  final RefactoringActionHandler moveHandler = RefactoringActionHandlerFactory.getInstance().createMoveHandler();
  final AsyncResult<DataContext> result = DataManager.getInstance().getDataContextFromFocus();
  result.doWhenDone(new Consumer<DataContext>() {
    @Override
    public void consume(final DataContext originalContext) {
      final DataContext dataContext = new DataContext() {
        @Override
        public Object getData(@NonNls String name) {
          if (LangDataKeys.TARGET_PSI_ELEMENT.is(name)) {
            return usageClass.getElement();
          }
          return originalContext.getData(name);
        }
      };
      moveHandler.invoke(project, new PsiElement[]{method}, dataContext);
    }
  });
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Override
public void doFix(final Project project, ProblemDescriptor descriptor) {
  final PsiExpression expression =
    (PsiExpression)descriptor.getPsiElement();
  final JavaRefactoringActionHandlerFactory factory =
    JavaRefactoringActionHandlerFactory.getInstance();
  final RefactoringActionHandler extractHandler =
    factory.createExtractMethodHandler();
  final DataManager dataManager = DataManager.getInstance();
  final DataContext dataContext = dataManager.getDataContext();
  final Runnable runnable = new Runnable() {
    @Override
    public void run() {
      extractHandler.invoke(project,
                            new PsiElement[]{expression}, dataContext);
    }
  };
  if (ApplicationManager.getApplication().isUnitTestMode()) {
    runnable.run();
  }
  else {
    ApplicationManager.getApplication().invokeLater(runnable);
  }
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
private void doTest(String newName) {
  final String testName = getTestName(false);
  final String beforeName = testName + ".before.py";
  final String afterName = testName + ".after.py";
  final String dir = "refactoring/extractmethod/";

  myFixture.configureByFile(dir + beforeName);
  final RefactoringSupportProvider provider = LanguageRefactoringSupport.INSTANCE.forLanguage(PythonLanguage.getInstance());
  assertNotNull(provider);
  final RefactoringActionHandler handler = provider.getExtractMethodHandler();
  assertNotNull(handler);
  System.setProperty(PyExtractMethodUtil.NAME, newName);
  try {
    refactorUsingHandler(handler);
  }
  finally {
    System.clearProperty(PyExtractMethodUtil.NAME);
  }
  myFixture.checkResultByFile(dir + afterName);
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Override
public void doFix(@NotNull final Project project,
                  ProblemDescriptor descriptor) {

  final PsiElement constant = descriptor.getPsiElement();
  final Application application = ApplicationManager.getApplication();
  application.invokeLater(new Runnable() {

    @Override
    public void run() {
      if (!constant.isValid()) return;
      final JavaRefactoringActionHandlerFactory factory =
        JavaRefactoringActionHandlerFactory.getInstance();
      final RefactoringActionHandler introduceHandler =
        factory.createIntroduceConstantHandler();
      final DataManager dataManager = DataManager.getInstance();
      final DataContext dataContext = dataManager.getDataContext();
      introduceHandler.invoke(project, new PsiElement[]{constant},
                              dataContext);
    }
  }, project.getDisposed());
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Override
protected boolean isEnabledOnElements(@NotNull PsiElement[] elements) {
  if (elements.length > 0) {
    Language language = elements[0].getLanguage();
    RefactoringActionHandler handler = getHandler(language, elements[0]);
    return handler instanceof ElementsHandler && ((ElementsHandler)handler).isEnabledOnElements(elements);
  }
  return false;
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Override
protected void doFix(final Project project, ProblemDescriptor descriptor) throws IncorrectOperationException {
  final PsiExpression expression = getExpressionToExtract(descriptor.getPsiElement());
  if (expression == null) {
    return;
  }
  final RefactoringActionHandler handler = JavaRefactoringActionHandlerFactory.getInstance().createIntroduceVariableHandler();
  final AsyncResult<DataContext> dataContextContainer = DataManager.getInstance().getDataContextFromFocus();
  dataContextContainer.doWhenDone(new Consumer<DataContext>() {
    @Override
    public void consume(DataContext dataContext) {
      handler.invoke(project, new PsiElement[]{expression}, dataContext);
    }
  });
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Override
protected void doFix(final Project project, ProblemDescriptor descriptor) throws IncorrectOperationException {
  final PsiElement element = PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiClass.class, PsiMethod.class);
  final AsyncResult<DataContext> context = DataManager.getInstance().getDataContextFromFocus();
  context.doWhenDone(new Consumer<DataContext>() {
    @Override
    public void consume(DataContext dataContext) {
      final JavaRefactoringActionHandlerFactory factory = JavaRefactoringActionHandlerFactory.getInstance();
      final RefactoringActionHandler handler = factory.createReplaceConstructorWithFactoryHandler();
      handler.invoke(project, new PsiElement[]{element}, dataContext);
    }
  });
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Override
protected RefactoringActionHandler getHandler(@NotNull Language language, PsiElement element) {
  RefactoringActionHandler handler = super.getHandler(language, element);
  if (handler != null) return handler;
  List<InlineHandler> handlers = InlineHandlers.getInlineHandlers(language);
  return handlers.isEmpty() ? null : new InlineRefactoringActionHandler();
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Override
public void update(final AnActionEvent e) {
  super.update(e);
  final RefactoringActionHandler handler = getHandler(e.getDataContext());
  if (handler instanceof TitledHandler) {
    e.getPresentation().setText(((TitledHandler) handler).getActionTitle());
  }
  else {
    e.getPresentation().setText("Include File...");
  }
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Nullable
protected RefactoringActionHandler getHandler(@NotNull Language language, PsiElement element) {
  List<RefactoringSupportProvider> providers = LanguageRefactoringSupport.INSTANCE.allForLanguage(language);
  if (providers.isEmpty()) return null;
  if (element == null) return getRefactoringHandler(providers.get(0));
  for (RefactoringSupportProvider provider : providers) {
    if (provider.isAvailable(element)) {
      return getRefactoringHandler(provider, element);
    }
  }
  return null;
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
@Override
public RefactoringActionHandler getIntroduceVariableHandler() {
    return new LuaIntroduceVariableHandler();
}
 

import com.intellij.refactoring.RefactoringActionHandler; //导入依赖的package包/类
public RunRefactoringAction(RefactoringActionHandler handler, String commandName) {
  myHandler = handler;
  myCommandName = commandName;
}