Java InspectionProjectProfileManager类代码示例

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
  if (myTag == null) return;
  if (!myAdditionalJavadocTags.isEmpty()) {
    myAdditionalJavadocTags += "," + myTag;
  }
  else {
    myAdditionalJavadocTags = myTag;
  }
  final InspectionProfile inspectionProfile =
    InspectionProjectProfileManager.getInstance(project).getInspectionProfile();
  //correct save settings
  InspectionProfileManager.getInstance().fireProfileChanged(inspectionProfile);
  //TODO lesya

  /*

  try {
    inspectionProfile.save();
  }
  catch (IOException e) {
    Messages.showErrorDialog(project, e.getMessage(), CommonBundle.getErrorTitle());
  }

  */
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
static void doQuickFixInternal(@NotNull Project project, @NotNull List<String> targetList, @NotNull String qualifiedName) {
  targetList.add(qualifiedName);
  Collections.sort(targetList);
  final InspectionProfile inspectionProfile = InspectionProjectProfileManager.getInstance(project).getInspectionProfile();
  //correct save settings

  //TODO lesya
  InspectionProfileManager.getInstance().fireProfileChanged(inspectionProfile);
  /*
  try {
    inspectionProfile.save();
  }
  catch (IOException e) {
    Messages.showErrorDialog(project, e.getMessage(), CommonBundle.getErrorTitle());
  }

  */
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
@Override
public void registerFixesForUnusedParameter(@NotNull PsiParameter parameter, @NotNull Object highlightInfo) {
  Project myProject = parameter.getProject();
  InspectionProfile profile = InspectionProjectProfileManager.getInstance(myProject).getInspectionProfile();
  UnusedParametersInspection unusedParametersInspection =
    (UnusedParametersInspection)profile.getUnwrappedTool(UnusedSymbolLocalInspectionBase.UNUSED_PARAMETERS_SHORT_NAME, parameter);
  LOG.assertTrue(ApplicationManager.getApplication().isUnitTestMode() || unusedParametersInspection != null);
  List<IntentionAction> options = new ArrayList<IntentionAction>();
  HighlightDisplayKey myUnusedSymbolKey = HighlightDisplayKey.find(UnusedSymbolLocalInspectionBase.SHORT_NAME);
  options.addAll(IntentionManager.getInstance().getStandardIntentionOptions(myUnusedSymbolKey, parameter));
  if (unusedParametersInspection != null) {
    SuppressQuickFix[] batchSuppressActions = unusedParametersInspection.getBatchSuppressActions(parameter);
    Collections.addAll(options, SuppressIntentionActionFromFix.convertBatchToSuppressIntentionActions(batchSuppressActions));
  }
  //need suppress from Unused Parameters but settings from Unused Symbol
  QuickFixAction.registerQuickFixAction((HighlightInfo)highlightInfo, new SafeDeleteFix(parameter),
                                        options, HighlightDisplayKey.getDisplayNameByKey(myUnusedSymbolKey));
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
private static void doTest(final String dirName) throws Exception {
  InspectionProfileImpl.INIT_INSPECTIONS = true;
  try {
    final String relativePath = "/inspection/converter/";
    final File projectFile = new File(JavaTestUtil.getJavaTestDataPath() + relativePath + dirName + "/options.ipr");
    for (Element element : JDOMUtil.loadDocument(projectFile).getRootElement().getChildren("component")) {
      if (Comparing.strEqual(element.getAttributeValue("name"), "InspectionProjectProfileManager")) {
        final InspectionProjectProfileManager profileManager = InspectionProjectProfileManager.getInstance(getProject());
        profileManager.loadState(element);

        Element configElement = profileManager.getState();
        final File file = new File(JavaTestUtil.getJavaTestDataPath() + relativePath + dirName + "/options.after.xml");
        PlatformTestUtil.assertElementsEqual(JDOMUtil.loadDocument(file).getRootElement(), configElement);
        break;
      }
    }
  }
  finally {
    InspectionProfileImpl.INIT_INSPECTIONS = false;
  }
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
public void testPreserveCompatibility() throws Exception {
  InspectionProfileImpl foo = new InspectionProfileImpl("foo", InspectionToolRegistrar.getInstance(), InspectionProjectProfileManager.getInstance(getProject()));
  String test = "<profile version=\"1.0\" is_locked=\"false\">\n" +
               "  <option name=\"myName\" value=\"idea.default\" />\n" +
               "  <option name=\"myLocal\" value=\"false\" />\n" +
               "  <inspection_tool class=\"AbstractMethodCallInConstructor\" enabled=\"true\" level=\"WARNING\" enabled_by_default=\"true\" />\n" +
               "  <inspection_tool class=\"AssignmentToForLoopParameter\" enabled=\"true\" level=\"WARNING\" enabled_by_default=\"true\">\n" +
               "    <option name=\"m_checkForeachParameters\" value=\"false\" />\n" +
               "  </inspection_tool>\n" +
               "</profile>";
  foo.readExternal(JDOMUtil.loadDocument(test).getRootElement());
  foo.initInspectionTools(getProject());
  Element serialized = new Element("profile");
  foo.writeExternal(serialized);
  assertEquals(test, JDOMUtil.writeElement(serialized));
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
public void testSettingsModification() throws Exception {
  Project project = ProjectManager.getInstance().getDefaultProject();
  InspectionProjectProfileManager profileManager = InspectionProjectProfileManager.getInstance(project);
  InspectionProfileImpl profile = (InspectionProfileImpl)profileManager.getProfile(PROFILE);
  profile.initInspectionTools(project);

  InspectionProfileImpl model = (InspectionProfileImpl)profile.getModifiableModel();
  SingleInspectionProfilePanel panel = new SingleInspectionProfilePanel(profileManager, PROFILE, model, profile);
  panel.setVisible(true);
  panel.reset();

  JavaDocLocalInspection tool = getInspection(model);
  assertEquals("", tool.myAdditionalJavadocTags);
  tool.myAdditionalJavadocTags = "foo";
  model.setModified(true);
  panel.apply();
  assertEquals(1, InspectionProfileTest.countInitializedTools(model));

  assertEquals("foo", getInspection(profile).myAdditionalJavadocTags);
  panel.disposeUI();
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
public void testModifyInstantiatedTool() throws Exception {
  Project project = ProjectManager.getInstance().getDefaultProject();
  InspectionProjectProfileManager profileManager = InspectionProjectProfileManager.getInstance(project);
  InspectionProfileImpl profile = (InspectionProfileImpl)profileManager.getProfile(PROFILE);
  profile.initInspectionTools(project);

  JavaDocLocalInspection originalTool = getInspection(profile);
  originalTool.myAdditionalJavadocTags = "foo";

  InspectionProfileImpl model = (InspectionProfileImpl)profile.getModifiableModel();

  SingleInspectionProfilePanel panel = new SingleInspectionProfilePanel(profileManager, PROFILE, model, profile);
  panel.setVisible(true);
  panel.reset();
  assertEquals(InspectionProfileTest.getInitializedTools(model).toString(), 1, InspectionProfileTest.countInitializedTools(model));

  JavaDocLocalInspection copyTool = getInspection(model);
  copyTool.myAdditionalJavadocTags = "bar";

  model.setModified(true);
  panel.apply();
  assertEquals(1, InspectionProfileTest.countInitializedTools(model));

  assertEquals("bar", getInspection(profile).myAdditionalJavadocTags);
  panel.disposeUI();
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
public void testDoNotChangeSettingsOnCancel() throws Exception {
  Project project = ProjectManager.getInstance().getDefaultProject();
  InspectionProjectProfileManager profileManager = InspectionProjectProfileManager.getInstance(project);
  InspectionProfileImpl profile = (InspectionProfileImpl)profileManager.getProfile(PROFILE);
  profile.initInspectionTools(project);

  JavaDocLocalInspection originalTool = getInspection(profile);
  assertEquals("", originalTool.myAdditionalJavadocTags);

  InspectionProfileImpl model = (InspectionProfileImpl)profile.getModifiableModel();
  JavaDocLocalInspection copyTool = getInspection(model);
  copyTool.myAdditionalJavadocTags = "foo";
  // this change IS NOT COMMITTED

  assertEquals("", getInspection(profile).myAdditionalJavadocTags);
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
public static InspectionToolWrapper findTool2RunInBatch(@NotNull Project project, @Nullable PsiElement element, @NotNull String name) {
  final InspectionProfile inspectionProfile = InspectionProjectProfileManager.getInstance(project).getInspectionProfile();
  final InspectionToolWrapper toolWrapper = element == null
                                         ? inspectionProfile.getInspectionTool(name, project)
                                         : inspectionProfile.getInspectionTool(name, element);
  if (toolWrapper instanceof LocalInspectionToolWrapper && ((LocalInspectionToolWrapper)toolWrapper).isUnfair()) {
    final LocalInspectionTool inspectionTool = ((LocalInspectionToolWrapper)toolWrapper).getTool();
    if (inspectionTool instanceof PairedUnfairLocalInspectionTool) {
      final String oppositeShortName = ((PairedUnfairLocalInspectionTool)inspectionTool).getInspectionForBatchShortName();
      return element == null
                       ? inspectionProfile.getInspectionTool(oppositeShortName, project)
                       : inspectionProfile.getInspectionTool(oppositeShortName, element);
    }
    return null;
  }
  return toolWrapper;
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
public InspectionProfile getCurrentProfile() {
  if (myExternalProfile != null) return myExternalProfile;
  InspectionManagerBase managerEx = (InspectionManagerBase)InspectionManager.getInstance(myProject);
  String currentProfile = managerEx.getCurrentProfile();
  final InspectionProjectProfileManager inspectionProfileManager = InspectionProjectProfileManager.getInstance(myProject);
  Profile profile = inspectionProfileManager.getProfile(currentProfile, false);
  if (profile == null) {
    profile = InspectionProfileManager.getInstance().getProfile(currentProfile);
    if (profile != null) return (InspectionProfile)profile;

    final String[] availableProfileNames = inspectionProfileManager.getAvailableProfileNames();
    if (availableProfileNames.length == 0) {
      //can't be
      return null;
    }
    profile = inspectionProfileManager.getProfile(availableProfileNames[0]);
  }
  return (InspectionProfile)profile;
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
public static void enableInspectionTool(@NotNull final Project project, @NotNull final InspectionToolWrapper toolWrapper) {
  final InspectionProfile profile = InspectionProjectProfileManager.getInstance(project).getInspectionProfile();
  final String shortName = toolWrapper.getShortName();
  final HighlightDisplayKey key = HighlightDisplayKey.find(shortName);
  if (key == null) {
    HighlightDisplayKey.register(shortName, toolWrapper.getDisplayName(), toolWrapper.getID());
  }
  InspectionProfileImpl.initAndDo(new Computable() {
    @Override
    public Object compute() {
      InspectionProfileImpl impl = (InspectionProfileImpl)profile;
      InspectionToolWrapper existingWrapper = impl.getInspectionTool(shortName, project);
      if (existingWrapper == null || existingWrapper.isInitialized() != toolWrapper.isInitialized() || toolWrapper.isInitialized() && toolWrapper.getTool() != existingWrapper.getTool()) {
        impl.addTool(project, toolWrapper, new THashMap<String, List<String>>());
      }
      impl.enableTool(shortName, project);
      return null;
    }
  });
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
@Nullable
private Profile loadProfileByName(final String profileName) {
  Profile inspectionProfile = InspectionProjectProfileManager.getInstance(myProject).getProfile(profileName, false);
  if (inspectionProfile != null) {
    logMessageLn(1, "Loaded shared project profile \'" + profileName + "\'");
  }
  else {
    //check if ide profile is used for project
    final Collection<Profile> profiles = InspectionProjectProfileManager.getInstance(myProject).getProfiles();
    for (Profile profile : profiles) {
      if (Comparing.strEqual(profile.getName(), profileName)) {
        inspectionProfile = profile;
        logMessageLn(1, "Loaded local profile \'" + profileName + "\'");
        break;
      }
    }
  }

  return inspectionProfile;
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
protected HighlightSeverity getSeverity(@NotNull RefElement element) {
  final PsiElement psiElement = element.getPointer().getContainingFile();
  if (psiElement != null) {
    final GlobalInspectionContextImpl context = getContext();
    final String shortName = getSeverityDelegateName();
    final Tools tools = context.getTools().get(shortName);
    if (tools != null) {
      for (ScopeToolState state : tools.getTools()) {
        InspectionToolWrapper toolWrapper = state.getTool();
        if (toolWrapper == getToolWrapper()) {
          return context.getCurrentProfile().getErrorLevel(HighlightDisplayKey.find(shortName), psiElement).getSeverity();
        }
      }
    }

    final InspectionProfile profile = InspectionProjectProfileManager.getInstance(context.getProject()).getInspectionProfile();
    final HighlightDisplayLevel level = profile.getErrorLevel(HighlightDisplayKey.find(shortName), psiElement);
    return level.getSeverity();
  }
  return null;
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
private InspectionProfile guessProfileToSelect(final InspectionProjectProfileManager profileManager) {
  final Set<InspectionProfile> profiles = new HashSet<InspectionProfile>();
  final RefEntity[] selectedElements = myTree.getSelectedElements();
  for (RefEntity selectedElement : selectedElements) {
    if (selectedElement instanceof RefElement) {
      final RefElement refElement = (RefElement)selectedElement;
      final PsiElement element = refElement.getElement();
      if (element != null) {
        profiles.add(profileManager.getInspectionProfile());
      }
    }
  }
  if (profiles.isEmpty()) {
    return (InspectionProfile)profileManager.getProjectProfileImpl();
  }
  return profiles.iterator().next();
}
 

import com.intellij.profile.codeInspection.InspectionProjectProfileManager; //导入依赖的package包/类
@Override
public void actionPerformed(AnActionEvent e) {
  final InspectionProjectProfileManager profileManager = InspectionProjectProfileManager.getInstance(myProject);
  final InspectionToolWrapper toolWrapper = myTree.getSelectedToolWrapper();
  InspectionProfile inspectionProfile = myInspectionProfile;
  final boolean profileIsDefined = isProfileDefined();
  if (!profileIsDefined) {
    inspectionProfile = guessProfileToSelect(profileManager);
  }

  if (toolWrapper != null) {
    final HighlightDisplayKey key = HighlightDisplayKey.find(toolWrapper.getShortName()); //do not search for dead code entry point tool
    if (key != null){
      if (new EditInspectionToolsSettingsAction(key).editToolSettings(myProject, (InspectionProfileImpl)inspectionProfile, profileIsDefined)
          && profileIsDefined){
        updateCurrentProfile();
      }
      return;
    }
  }
  if (EditInspectionToolsSettingsAction.editToolSettings(myProject, inspectionProfile, profileIsDefined, null) && profileIsDefined) {
    updateCurrentProfile();
  }
}