1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
package com.intellij.openapi.vcs.roots;
import com.intellij.openapi.components.ServiceManager;
import com.intellij.openapi.extensions.Extensions;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Condition;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vcs.*;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* @author Nadya Zabrodina
*/
public class VcsRootErrorsFinder {
private final @NotNull Project myProject;
private final @NotNull ProjectLevelVcsManager myVcsManager;
public VcsRootErrorsFinder(@NotNull Project project) {
myProject = project;
myVcsManager = ProjectLevelVcsManager.getInstance(project);
}
@NotNull
public Collection<VcsRootError> find() {
List<VcsDirectoryMapping> mappings = myVcsManager.getDirectoryMappings();
Collection<VcsRoot> vcsRoots = ServiceManager.getService(myProject, VcsRootDetector.class).detect();
Collection<VcsRootError> errors = new ArrayList<VcsRootError>();
errors.addAll(findExtraMappings(mappings));
errors.addAll(findUnregisteredRoots(mappings, vcsRoots));
return errors;
}
@NotNull
private Collection<VcsRootError> findUnregisteredRoots(@NotNull List<VcsDirectoryMapping> mappings,
@NotNull Collection<VcsRoot> vcsRoots) {
Collection<VcsRootError> errors = new ArrayList<VcsRootError>();
List<String> mappedPaths = mappingsToPathsWithSelectedVcs(mappings);
for (VcsRoot root : vcsRoots) {
VirtualFile virtualFileFromRoot = root.getPath();
if (virtualFileFromRoot == null) {
continue;
}
String vcsPath = virtualFileFromRoot.getPath();
if (!mappedPaths.contains(vcsPath) && root.getVcs() != null) {
errors.add(new VcsRootErrorImpl(VcsRootError.Type.UNREGISTERED_ROOT, vcsPath, root.getVcs().getName()));
}
}
return errors;
}
@NotNull
private Collection<VcsRootError> findExtraMappings(@NotNull List<VcsDirectoryMapping> mappings) {
Collection<VcsRootError> errors = new ArrayList<VcsRootError>();
for (VcsDirectoryMapping mapping : mappings) {
if (!hasVcsChecker(mapping.getVcs())) {
continue;
}
if (mapping.isDefaultMapping()) {
if (!isRoot(mapping)) {
errors.add(new VcsRootErrorImpl(VcsRootError.Type.EXTRA_MAPPING, VcsDirectoryMapping.PROJECT_CONSTANT, mapping.getVcs()));
}
}
else {
String mappedPath = mapping.systemIndependentPath();
if (!isRoot(mapping)) {
errors.add(new VcsRootErrorImpl(VcsRootError.Type.EXTRA_MAPPING, mappedPath, mapping.getVcs()));
}
}
}
return errors;
}
private static boolean hasVcsChecker(String vcs) {
if (StringUtil.isEmptyOrSpaces(vcs)) {
return false;
}
VcsRootChecker[] checkers = Extensions.getExtensions(VcsRootChecker.EXTENSION_POINT_NAME);
for (VcsRootChecker checker : checkers) {
if (vcs.equalsIgnoreCase(checker.getSupportedVcs().getName())) {
return true;
}
}
return false;
}
@NotNull
public static Collection<VirtualFile> vcsRootsToVirtualFiles(@NotNull Collection<VcsRoot> vcsRoots) {
return ContainerUtil.map(vcsRoots, new Function<VcsRoot, VirtualFile>() {
@Override
public VirtualFile fun(VcsRoot root) {
return root.getPath();
}
});
}
private List<String> mappingsToPathsWithSelectedVcs(@NotNull List<VcsDirectoryMapping> mappings) {
List<String> paths = new ArrayList<String>();
for (VcsDirectoryMapping mapping : mappings) {
if (StringUtil.isEmptyOrSpaces(mapping.getVcs())) {
continue;
}
if (!mapping.isDefaultMapping()) {
paths.add(mapping.systemIndependentPath());
}
else {
String basePath = myProject.getBasePath();
if (basePath != null) {
paths.add(FileUtil.toSystemIndependentName(basePath));
}
}
}
return paths;
}
public static VcsRootErrorsFinder getInstance(Project project) {
return new VcsRootErrorsFinder(project);
}
private boolean isRoot(@NotNull final VcsDirectoryMapping mapping) {
VcsRootChecker[] checkers = Extensions.getExtensions(VcsRootChecker.EXTENSION_POINT_NAME);
final String pathToCheck = mapping.isDefaultMapping() ? myProject.getBasePath() : mapping.getDirectory();
return ContainerUtil.find(checkers, new Condition<VcsRootChecker>() {
@Override
public boolean value(VcsRootChecker checker) {
return checker.getSupportedVcs().getName().equalsIgnoreCase(mapping.getVcs()) && checker.isRoot(pathToCheck);
}
}) != null;
}
}
|
