public void actionPerformed(AnActionEvent e) {
final PackageDependenciesNode leftNode = myLeftTree.getSelectedNode();
final PackageDependenciesNode rightNode = myRightTree.getSelectedNode();
if (leftNode != null && rightNode != null) {
boolean hasDirectDependencies = myTransitiveBorder == 0;
if (myTransitiveBorder > 0) {
final Set<PsiFile> searchIn = getSelectedScope(myLeftTree);
final Set<PsiFile> searchFor = getSelectedScope(myRightTree);
for (DependenciesBuilder builder : myBuilders) {
if (hasDirectDependencies) break;
for (PsiFile from : searchIn) {
if (hasDirectDependencies) break;
for (PsiFile to : searchFor) {
if (hasDirectDependencies) break;
final List<List<PsiFile>> paths = builder.findPaths(from, to);
for (List<PsiFile> path : paths) {
if (path.isEmpty()) {
hasDirectDependencies = true;
break;
}
}
}
}
}
}
final PatternDialectProvider provider =
PatternDialectProvider.getInstance(mySettings.SCOPE_TYPE);
PackageSet leftPackageSet = provider.createPackageSet(leftNode, true);
if (leftPackageSet == null) {
leftPackageSet = provider.createPackageSet(leftNode, false);
}
LOG.assertTrue(leftPackageSet != null);
PackageSet rightPackageSet = provider.createPackageSet(rightNode, true);
if (rightPackageSet == null) {
rightPackageSet = provider.createPackageSet(rightNode, false);
}
LOG.assertTrue(rightPackageSet != null);
if (hasDirectDependencies) {
DependencyValidationManager.getInstance(myProject)
.addRule(
new DependencyRule(
new NamedScope.UnnamedScope(leftPackageSet),
new NamedScope.UnnamedScope(rightPackageSet),
true));
rebuild();
} else {
Messages.showErrorDialog(
DependenciesPanel.this,
"Rule was not added.\n There is no direct dependency between \'"
+ leftPackageSet.getText()
+ "\' and \'"
+ rightPackageSet.getText()
+ "\'",
AnalysisScopeBundle.message("mark.dependency.illegal.text"));
}
}
}
public void actionPerformed(final AnActionEvent e) {
final AnalysisScope scope = getScope();
LOG.assertTrue(scope != null);
final DependenciesBuilder builder;
if (!myForward) {
builder = new BackwardDependenciesBuilder(myProject, scope, myScopeOfInterest);
} else {
builder = new ForwardDependenciesBuilder(myProject, scope, myTransitiveBorder);
}
ProgressManager.getInstance()
.runProcessWithProgressAsynchronously(
myProject,
AnalysisScopeBundle.message("package.dependencies.progress.title"),
new Runnable() {
public void run() {
builder.analyze();
}
},
new Runnable() {
public void run() {
myBuilders.add(builder);
myDependencies.putAll(builder.getDependencies());
myIllegalDependencies.putAll(builder.getIllegalDependencies());
exclude(myExcluded);
rebuild();
}
},
null,
new PerformAnalysisInBackgroundOption(myProject));
}
@Nullable
private AnalysisScope getScope() {
final Set<PsiFile> selectedScope = getSelectedScope(myRightTree);
Set<PsiFile> result = new HashSet<PsiFile>();
((PackageDependenciesNode) myLeftTree.getModel().getRoot())
.fillFiles(result, !mySettings.UI_FLATTEN_PACKAGES);
selectedScope.removeAll(result);
if (selectedScope.isEmpty()) return null;
List<VirtualFile> files = new ArrayList<VirtualFile>();
final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(myProject).getFileIndex();
for (PsiFile psiFile : selectedScope) {
final VirtualFile file = psiFile.getVirtualFile();
LOG.assertTrue(file != null);
if (fileIndex.isInContent(file)) {
files.add(file);
}
}
if (!files.isEmpty()) {
return new AnalysisScope(myProject, files);
}
return null;
}