private List<String> getAvailableScopes(Project project, List<Descriptor> descriptors) {
final ArrayList<NamedScope> scopes = new ArrayList<NamedScope>();
for (NamedScopesHolder holder : NamedScopesHolder.getAllNamedScopeHolders(project)) {
Collections.addAll(scopes, holder.getScopes());
}
scopes.remove(DefaultScopesProvider.getAllScope());
CustomScopesProviderEx.filterNoSettingsScopes(project, scopes);
final Set<NamedScope> used = new HashSet<NamedScope>();
for (Descriptor descriptor : descriptors) {
final List<ScopeToolState> nonDefaultTools =
getSelectedProfile().getNonDefaultTools(descriptor.getKey().toString());
if (nonDefaultTools != null) {
for (ScopeToolState state : nonDefaultTools) {
used.add(state.getScope(project));
}
}
}
scopes.removeAll(used);
final List<String> availableScopes = new ArrayList<String>();
for (NamedScope scope : scopes) {
availableScopes.add(scope.getName());
}
return availableScopes;
}
private DefaultComboBoxModel createModel() {
final DefaultComboBoxModel model = new DefaultComboBoxModel();
createPredefinedScopeDescriptors(model);
model.addElement(new ScopeSeparator("VCS Scopes"));
final List<NamedScope> changeLists =
ChangeListsScopesProvider.getInstance(myProject).getCustomScopes();
for (NamedScope changeListScope : changeLists) {
final GlobalSearchScope scope = GlobalSearchScopes.filterScope(myProject, changeListScope);
model.addElement(new ScopeDescriptor(scope));
}
final List<ScopeDescriptor> customScopes = new ArrayList<ScopeDescriptor>();
final NamedScopesHolder[] holders = NamedScopesHolder.getAllNamedScopeHolders(myProject);
for (NamedScopesHolder holder : holders) {
final NamedScope[] scopes = holder.getEditableScopes(); // predefined scopes already included
for (NamedScope scope : scopes) {
final GlobalSearchScope searchScope = GlobalSearchScopes.filterScope(myProject, scope);
customScopes.add(new ScopeDescriptor(searchScope));
}
}
if (!customScopes.isEmpty()) {
model.addElement(new ScopeSeparator("Custom Scopes"));
for (ScopeDescriptor scope : customScopes) {
model.addElement(scope);
}
}
return model;
}
private static void initScopesDescriptors(
@NotNull List<EditorSchemeAttributeDescriptor> descriptions, @NotNull MyColorScheme scheme) {
Set<Pair<NamedScope, NamedScopesHolder>> namedScopes =
new THashSet<Pair<NamedScope, NamedScopesHolder>>(
new TObjectHashingStrategy<Pair<NamedScope, NamedScopesHolder>>() {
@Override
public int computeHashCode(
@NotNull final Pair<NamedScope, NamedScopesHolder> object) {
return object.getFirst().getName().hashCode();
}
@Override
public boolean equals(
@NotNull final Pair<NamedScope, NamedScopesHolder> o1,
@NotNull final Pair<NamedScope, NamedScopesHolder> o2) {
return o1.getFirst().getName().equals(o2.getFirst().getName());
}
});
Project[] projects = ProjectManager.getInstance().getOpenProjects();
for (Project project : projects) {
DependencyValidationManagerImpl validationManager =
(DependencyValidationManagerImpl) DependencyValidationManager.getInstance(project);
List<Pair<NamedScope, NamedScopesHolder>> cachedScopes =
validationManager.getScopeBasedHighlightingCachedScopes();
namedScopes.addAll(cachedScopes);
}
List<Pair<NamedScope, NamedScopesHolder>> list =
new ArrayList<Pair<NamedScope, NamedScopesHolder>>(namedScopes);
Collections.sort(
list,
new Comparator<Pair<NamedScope, NamedScopesHolder>>() {
@Override
public int compare(
@NotNull final Pair<NamedScope, NamedScopesHolder> o1,
@NotNull final Pair<NamedScope, NamedScopesHolder> o2) {
return o1.getFirst().getName().compareToIgnoreCase(o2.getFirst().getName());
}
});
for (Pair<NamedScope, NamedScopesHolder> pair : list) {
NamedScope namedScope = pair.getFirst();
String name = namedScope.getName();
TextAttributesKey textAttributesKey = ScopeAttributesUtil.getScopeTextAttributeKey(name);
if (scheme.getAttributes(textAttributesKey) == null) {
scheme.setAttributes(textAttributesKey, new TextAttributes());
}
NamedScopesHolder holder = pair.getSecond();
PackageSet value = namedScope.getValue();
String toolTip = holder.getDisplayName() + (value == null ? "" : ": " + value.getText());
addSchemedDescription(
descriptions, name, SCOPES_GROUP, textAttributesKey, scheme, holder.getIcon(), toolTip);
}
}
private static void addScopesToList(
final List<Pair<NamedScope, NamedScopesHolder>> scopeList, final NamedScopesHolder holder) {
NamedScope[] scopes = holder.getScopes();
for (NamedScope scope : scopes) {
scopeList.add(Pair.create(scope, holder));
}
}
private Collection<String> getValidScopeNames() {
List<String> result = new ArrayList<String>();
result.add(SCOPE_PROJECT);
result.add(SCOPE_TEST);
result.add(SCOPE_ALL);
result.add(SCOPE_CLASS);
final NamedScopesHolder[] holders = NamedScopesHolder.getAllNamedScopeHolders(myProject);
for (NamedScopesHolder holder : holders) {
NamedScope[] scopes = holder.getEditableScopes(); // predefined scopes already included
for (NamedScope scope : scopes) {
result.add(scope.getName());
}
}
return result;
}
@Override
public void actionPerformed(AnActionEvent e) {
final List<Descriptor> descriptors = new ArrayList<Descriptor>();
final InspectionConfigTreeNode[] selectedNodes =
myTree.getSelectedNodes(InspectionConfigTreeNode.class, null);
LOG.assertTrue(selectedNodes != null);
final List<InspectionConfigTreeNode> nodes =
new ArrayList<InspectionConfigTreeNode>(Arrays.asList(selectedNodes));
for (InspectionConfigTreeNode node : selectedNodes) {
collect(descriptors, nodes, node);
}
final Project project = PlatformDataKeys.PROJECT.getData(e.getDataContext());
final List<String> availableScopes = getAvailableScopes(project, descriptors);
final int idx =
Messages.showChooseDialog(
myTree,
"Scope:",
"Choose Scope",
ArrayUtil.toStringArray(availableScopes),
availableScopes.get(0),
Messages.getQuestionIcon());
if (idx == -1) return;
final NamedScope chosenScope = NamedScopesHolder.getScope(project, availableScopes.get(idx));
for (InspectionConfigTreeNode node : nodes) {
final Descriptor descriptor = node.getDesriptor();
if (node.getScopeName() != null || descriptor == null) continue;
final InspectionProfileEntry tool = descriptor.getTool(); // copy
final ScopeToolState scopeToolState =
getSelectedProfile()
.addScope(
tool,
chosenScope,
getSelectedProfile().getErrorLevel(descriptor.getKey(), chosenScope),
getSelectedProfile().isToolEnabled(descriptor.getKey()));
final Descriptor addedDescriptor = new Descriptor(scopeToolState, getSelectedProfile());
if (node.getChildCount() == 0) {
node.add(
new InspectionConfigTreeNode(
descriptor,
getSelectedProfile().getToolDefaultState(descriptor.getKey().toString()),
true,
true,
false));
}
node.insert(new InspectionConfigTreeNode(addedDescriptor, scopeToolState, false, false), 0);
node.setInspectionNode(false);
node.dropCache();
((DefaultTreeModel) myTree.getModel()).reload(node);
myTree.expandPath(new TreePath(node.getPath()));
}
myTree.revalidate();
}
private void addRemoveTestsScope(Project project, boolean add) {
final InspectionProjectProfileManager profileManager =
InspectionProjectProfileManager.getInstance(project);
final InspectionProfileImpl profile =
(InspectionProfileImpl) profileManager.getCurrentProfile();
final String shortName = myInspection.getShortName();
final InspectionToolWrapper tool = profile.getInspectionTool(shortName, project);
if (tool == null) {
return;
}
if (add) {
final NamedScope namedScope = NamedScopesHolder.getScope(project, "Tests");
final HighlightDisplayKey key = HighlightDisplayKey.find(shortName);
final HighlightDisplayLevel level = profile.getErrorLevel(key, namedScope, project);
profile.addScope(tool, namedScope, level, false, project);
} else {
profile.removeScope(shortName, "Tests", project);
}
profile.scopesChanged();
}
void readExternal(
@NotNull Element toolElement,
@NotNull InspectionProfile profile,
Map<String, List<String>> dependencies)
throws InvalidDataException {
final String levelName = toolElement.getAttributeValue(LEVEL_ATTRIBUTE);
final ProfileManager profileManager = profile.getProfileManager();
final SeverityRegistrar registrar =
((SeverityProvider) profileManager).getOwnSeverityRegistrar();
HighlightDisplayLevel level =
levelName != null ? HighlightDisplayLevel.find(registrar.getSeverity(levelName)) : null;
if (level == null) {
level = HighlightDisplayLevel.WARNING;
}
myDefaultState.setLevel(level);
final String enabled = toolElement.getAttributeValue(ENABLED_ATTRIBUTE);
final boolean isEnabled = enabled != null && Boolean.parseBoolean(enabled);
final String enabledTool = toolElement.getAttributeValue(ENABLED_BY_DEFAULT_ATTRIBUTE);
myDefaultState.setEnabled(enabledTool != null ? Boolean.parseBoolean(enabledTool) : isEnabled);
final InspectionToolWrapper toolWrapper = myDefaultState.getTool();
final List scopeElements = toolElement.getChildren(ProfileEx.SCOPE);
final List<String> scopeNames = new ArrayList<String>();
for (Object sO : scopeElements) {
final Element scopeElement = (Element) sO;
final String scopeName = scopeElement.getAttributeValue(ProfileEx.NAME);
if (scopeName == null) {
continue;
}
final NamedScopesHolder scopesHolder = profileManager.getScopesManager();
NamedScope namedScope = null;
if (scopesHolder != null) {
namedScope = scopesHolder.getScope(scopeName);
}
final String errorLevel = scopeElement.getAttributeValue(LEVEL_ATTRIBUTE);
final String enabledInScope = scopeElement.getAttributeValue(ENABLED_ATTRIBUTE);
final InspectionToolWrapper copyToolWrapper = toolWrapper.createCopy();
// check if unknown children exists
if (scopeElement.getAttributes().size() > 3 || !scopeElement.getChildren().isEmpty()) {
copyToolWrapper.getTool().readSettings(scopeElement);
}
HighlightDisplayLevel scopeLevel =
errorLevel != null ? HighlightDisplayLevel.find(registrar.getSeverity(errorLevel)) : null;
if (scopeLevel == null) {
scopeLevel = level;
}
if (namedScope != null) {
addTool(
namedScope,
copyToolWrapper,
enabledInScope != null && Boolean.parseBoolean(enabledInScope),
scopeLevel);
} else {
addTool(
scopeName,
copyToolWrapper,
enabledInScope != null && Boolean.parseBoolean(enabledInScope),
scopeLevel);
}
scopeNames.add(scopeName);
}
for (int i = 0; i < scopeNames.size(); i++) {
String scopeName = scopeNames.get(i);
List<String> order = dependencies.get(scopeName);
if (order == null) {
order = new ArrayList<String>();
dependencies.put(scopeName, order);
}
for (int j = i + 1; j < scopeNames.size(); j++) {
order.add(scopeNames.get(j));
}
}
// check if unknown children exists
if (toolElement.getAttributes().size() > 4
|| toolElement.getChildren().size() > scopeElements.size()) {
toolWrapper.getTool().readSettings(toolElement);
}
myEnabled = isEnabled;
}