inspection toolwindow: remove redundant "is single run" detection way
[idea/community.git] / platform / lang-impl / src / com / intellij / codeInspection / actions / RunInspectionIntention.java
1 /*
2  * Copyright 2000-2014 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 package com.intellij.codeInspection.actions;
18
19 import com.intellij.analysis.AnalysisScope;
20 import com.intellij.analysis.AnalysisScopeBundle;
21 import com.intellij.analysis.AnalysisUIOptions;
22 import com.intellij.analysis.BaseAnalysisActionDialog;
23 import com.intellij.codeInsight.daemon.HighlightDisplayKey;
24 import com.intellij.codeInsight.intention.HighPriorityAction;
25 import com.intellij.codeInsight.intention.IntentionAction;
26 import com.intellij.codeInspection.InspectionManager;
27 import com.intellij.codeInspection.InspectionsBundle;
28 import com.intellij.codeInspection.ex.*;
29 import com.intellij.openapi.diagnostic.Logger;
30 import com.intellij.openapi.editor.Editor;
31 import com.intellij.openapi.module.Module;
32 import com.intellij.openapi.module.ModuleUtilCore;
33 import com.intellij.openapi.project.Project;
34 import com.intellij.openapi.util.InvalidDataException;
35 import com.intellij.openapi.util.WriteExternalException;
36 import com.intellij.openapi.vfs.VirtualFile;
37 import com.intellij.profile.codeInspection.InspectionProfileManager;
38 import com.intellij.psi.PsiElement;
39 import com.intellij.psi.PsiFile;
40 import com.intellij.util.IncorrectOperationException;
41 import org.jdom.Element;
42 import org.jetbrains.annotations.NotNull;
43 import org.jetbrains.annotations.Nullable;
44
45 import java.util.LinkedHashSet;
46
47 /**
48  * User: anna
49  * Date: 21-Feb-2006
50  */
51 public class RunInspectionIntention implements IntentionAction, HighPriorityAction {
52   private final static Logger LOG = Logger.getInstance(RunInspectionIntention.class);
53
54   private final String myShortName;
55
56   public RunInspectionIntention(@NotNull InspectionToolWrapper toolWrapper) {
57     myShortName = toolWrapper.getShortName();
58   }
59
60   public RunInspectionIntention(final HighlightDisplayKey key) {
61     myShortName = key.toString();
62   }
63
64   @Override
65   @NotNull
66   public String getText() {
67     return InspectionsBundle.message("run.inspection.on.file.intention.text");
68   }
69
70   @Override
71   @NotNull
72   public String getFamilyName() {
73     return getText();
74   }
75
76   @Override
77   public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
78     return LocalInspectionToolWrapper.findTool2RunInBatch(project, file, myShortName) != null;
79   }
80
81   @Override
82   public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
83     final Module module = file != null ? ModuleUtilCore.findModuleForPsiElement(file) : null;
84     AnalysisScope analysisScope = new AnalysisScope(project);
85     if (file != null) {
86       final VirtualFile virtualFile = file.getVirtualFile();
87       if (file.isPhysical() && virtualFile != null && virtualFile.isInLocalFileSystem()) {
88         analysisScope = new AnalysisScope(file);
89       }
90     }
91
92     selectScopeAndRunInspection(myShortName, analysisScope, module, file, project);
93   }
94
95   public static void selectScopeAndRunInspection(@NotNull String toolShortName,
96                                                  @NotNull AnalysisScope customScope,
97                                                  @Nullable Module module,
98                                                  @Nullable PsiElement context,
99                                                  @NotNull Project project) {
100     final BaseAnalysisActionDialog dlg = new BaseAnalysisActionDialog(
101       AnalysisScopeBundle.message("specify.analysis.scope", InspectionsBundle.message("inspection.action.title")),
102       AnalysisScopeBundle.message("analysis.scope.title", InspectionsBundle.message("inspection.action.noun")),
103       project,
104       customScope,
105       module != null ? module.getName() : null,
106       true, AnalysisUIOptions.getInstance(project), context);
107     if (!dlg.showAndGet()) {
108       return;
109     }
110     final AnalysisUIOptions uiOptions = AnalysisUIOptions.getInstance(project);
111     customScope = dlg.getScope(uiOptions, customScope, project, module);
112     final InspectionToolWrapper wrapper = LocalInspectionToolWrapper.findTool2RunInBatch(project, context, toolShortName);
113     LOG.assertTrue(wrapper != null, "Can't find tool with name = \"" + toolShortName + "\"");
114     rerunInspection(wrapper, (InspectionManagerEx)InspectionManager.getInstance(project), customScope, context);
115   }
116
117   public static void rerunInspection(@NotNull InspectionToolWrapper toolWrapper,
118                                      @NotNull InspectionManagerEx managerEx,
119                                      @NotNull AnalysisScope scope,
120                                      PsiElement psiElement) {
121     GlobalInspectionContextImpl inspectionContext = createContext(toolWrapper, managerEx, psiElement);
122     inspectionContext.doInspections(scope);
123   }
124
125   public static GlobalInspectionContextImpl createContext(@NotNull InspectionToolWrapper toolWrapper,
126                                                           @NotNull InspectionManagerEx managerEx,
127                                                           PsiElement psiElement) {
128     final InspectionProfileImpl rootProfile = (InspectionProfileImpl)InspectionProfileManager.getInstance().getRootProfile();
129     LinkedHashSet<InspectionToolWrapper> allWrappers = new LinkedHashSet<InspectionToolWrapper>();
130     allWrappers.add(toolWrapper);
131     rootProfile.collectDependentInspections(toolWrapper, allWrappers, managerEx.getProject());
132     InspectionToolWrapper[] toolWrappers = allWrappers.toArray(new InspectionToolWrapper[allWrappers.size()]);
133     final InspectionProfileImpl model = InspectionProfileImpl.createSimple(toolWrapper.getDisplayName(), managerEx.getProject(), toolWrappers);
134     try {
135       Element element = new Element("toCopy");
136       for (InspectionToolWrapper wrapper : toolWrappers) {
137         wrapper.getTool().writeSettings(element);
138         InspectionToolWrapper tw = psiElement == null ? model.getInspectionTool(wrapper.getShortName(), managerEx.getProject())
139                                                       : model.getInspectionTool(wrapper.getShortName(), psiElement);
140         tw.getTool().readSettings(element);
141       }
142     }
143     catch (WriteExternalException ignored) {
144     }
145     catch (InvalidDataException ignored) {
146     }
147     model.setEditable(toolWrapper.getDisplayName());
148     final GlobalInspectionContextImpl inspectionContext = managerEx.createNewGlobalContext(false);
149     inspectionContext.setExternalProfile(model);
150     return inspectionContext;
151   }
152
153   @Override
154   public boolean startInWriteAction() {
155     return false;
156   }
157 }