java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperclassHandler.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * created at Oct 25, 2001
  19  * @author Jeka
  20  */
  21 package com.intellij.refactoring.extractSuperclass;
  22
  23 import com.intellij.history.LocalHistory;
  24 import com.intellij.history.LocalHistoryAction;
  25 import com.intellij.openapi.actionSystem.DataContext;
  26 import com.intellij.openapi.actionSystem.PlatformDataKeys;
  27 import com.intellij.openapi.application.ApplicationManager;
  28 import com.intellij.openapi.command.CommandProcessor;
  29 import com.intellij.openapi.diagnostic.Logger;
  30 import com.intellij.openapi.editor.Editor;
  31 import com.intellij.openapi.editor.ScrollType;
  32 import com.intellij.openapi.project.Project;
  33 import com.intellij.openapi.ui.DialogWrapper;
  34 import com.intellij.psi.*;
  35 import com.intellij.refactoring.HelpID;
  36 import com.intellij.refactoring.RefactoringActionHandler;
  37 import com.intellij.refactoring.RefactoringBundle;
  38 import com.intellij.refactoring.extractInterface.ExtractClassUtil;
  39 import com.intellij.refactoring.lang.ElementsHandler;
  40 import com.intellij.refactoring.memberPullUp.PullUpConflictsUtil;
  41 import com.intellij.refactoring.ui.ConflictsDialog;
  42 import com.intellij.refactoring.util.CommonRefactoringUtil;
  43 import com.intellij.refactoring.util.DocCommentPolicy;
  44 import com.intellij.refactoring.util.classMembers.MemberInfo;
  45 import com.intellij.usageView.UsageViewUtil;
  46 import com.intellij.util.IncorrectOperationException;
  47 import com.intellij.util.containers.MultiMap;
  48 import org.jetbrains.annotations.NotNull;
  49
  50 import java.util.List;
  51
  52 public class ExtractSuperclassHandler implements RefactoringActionHandler, ExtractSuperclassDialog.Callback, ElementsHandler {
  53   private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.extractSuperclass.ExtractSuperclassHandler");
  54
  55   public static final String REFACTORING_NAME = RefactoringBundle.message("extract.superclass.title");
  56
  57   private PsiClass mySubclass;
  58   private Project myProject;
  59
  60
  61   public void invoke(@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) {
  62     editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
  63     int offset = editor.getCaretModel().getOffset();
  64     PsiElement element = file.findElementAt(offset);
  65     while (true) {
  66       if (element == null || element instanceof PsiFile) {
  67         String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("error.wrong.caret.position.class"));
  68         CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.EXTRACT_SUPERCLASS);
  69         return;
  70       }
  71       if (element instanceof PsiClass && !(element instanceof PsiAnonymousClass)) {
  72         invoke(project, new PsiElement[]{element}, dataContext);
  73         return;
  74       }
  75       element = element.getParent();
  76     }
  77   }
  78
  79   public void invoke(@NotNull final Project project, @NotNull PsiElement[] elements, DataContext dataContext) {
  80     if (elements.length != 1) return;
  81
  82     myProject = project;
  83     mySubclass = (PsiClass)elements[0];
  84
  85     if (!CommonRefactoringUtil.checkReadOnlyStatus(project, mySubclass)) return;
  86
  87     Editor editor = PlatformDataKeys.EDITOR.getData(dataContext);
  88     if (mySubclass.isInterface()) {
  89       String message =
  90         RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("superclass.cannot.be.extracted.from.an.interface"));
  91       CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.EXTRACT_SUPERCLASS);
  92       return;
  93     }
  94
  95     if (mySubclass.isEnum()) {
  96       String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("superclass.cannot.be.extracted.from.an.enum"));
  97       CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.EXTRACT_SUPERCLASS);
  98       return;
  99     }
 100
 101
 102     final List<MemberInfo> memberInfos = MemberInfo.extractClassMembers(mySubclass, new MemberInfo.Filter<PsiMember>() {
 103       public boolean includeMember(PsiMember element) {
 104         return true;
 105       }
 106     }, false);
 107
 108     final ExtractSuperclassDialog dialog =
 109       new ExtractSuperclassDialog(project, mySubclass, memberInfos, ExtractSuperclassHandler.this);
 110     dialog.show();
 111     if (!dialog.isOK() || !dialog.isExtractSuperclass()) return;
 112
 113     CommandProcessor.getInstance().executeCommand(myProject, new Runnable() {
 114       public void run() {
 115         final Runnable action = new Runnable() {
 116           public void run() {
 117             doRefactoring(project, mySubclass, dialog);
 118           }
 119         };
 120         ApplicationManager.getApplication().runWriteAction(action);
 121       }
 122     }, REFACTORING_NAME, null);
 123
 124   }
 125
 126   public boolean checkConflicts(ExtractSuperclassDialog dialog) {
 127     final MemberInfo[] infos = dialog.getSelectedMemberInfos();
 128     final PsiDirectory targetDirectory = dialog.getTargetDirectory();
 129     final PsiPackage targetPackage;
 130     if (targetDirectory != null) {
 131       targetPackage = JavaDirectoryService.getInstance().getPackage(targetDirectory);
 132     }
 133     else {
 134       targetPackage = null;
 135     }
 136     MultiMap<PsiElement,String> conflicts =
 137       PullUpConflictsUtil.checkConflicts(infos, mySubclass, null, targetPackage, targetDirectory, dialog.getContainmentVerifier());
 138     if (!conflicts.isEmpty()) {
 139       ConflictsDialog conflictsDialog = new ConflictsDialog(myProject, conflicts);
 140       conflictsDialog.show();
 141       final boolean ok = conflictsDialog.isOK();
 142       if (!ok && conflictsDialog.isShowConflicts()) dialog.close(DialogWrapper.CANCEL_EXIT_CODE);
 143       return ok;
 144     }
 145     return true;
 146   }
 147
 148   // invoked inside Command and Atomic action
 149   private void doRefactoring(final Project project, final PsiClass subclass, final ExtractSuperclassDialog dialog) {
 150     final String superclassName = dialog.getExtractedSuperName();
 151     final PsiDirectory targetDirectory = dialog.getTargetDirectory();
 152     final MemberInfo[] selectedMemberInfos = dialog.getSelectedMemberInfos();
 153     final DocCommentPolicy javaDocPolicy = new DocCommentPolicy(dialog.getJavaDocPolicy());
 154     LocalHistoryAction a = LocalHistory.startAction(myProject, getCommandName(subclass, superclassName));
 155     try {
 156       PsiClass superclass = null;
 157
 158       try {
 159         superclass =
 160           ExtractSuperClassUtil.extractSuperClass(project, targetDirectory, superclassName, subclass, selectedMemberInfos, javaDocPolicy);
 161       }
 162       finally {
 163         a.finish();
 164       }
 165
 166       // ask whether to search references to subclass and turn them into refs to superclass if possible
 167       if (superclass != null) {
 168         ExtractClassUtil.askAndTurnRefsToSuper(project, subclass, superclass);
 169       }
 170     }
 171     catch (IncorrectOperationException e) {
 172       LOG.error(e);
 173     }
 174
 175   }
 176
 177   private String getCommandName(final PsiClass subclass, String newName) {
 178     return RefactoringBundle.message("extract.superclass.command.name", newName, UsageViewUtil.getDescriptiveName(subclass));
 179   }
 180
 181   public boolean isEnabledOnElements(PsiElement[] elements) {
 182     return elements.length == 1 && elements[0] instanceof PsiClass && !((PsiClass) elements[0]).isInterface()
 183       &&!((PsiClass)elements[0]).isEnum();
 184   }
 185 }