public SvnVcs(
final Project project,
MessageBus bus,
SvnConfiguration svnConfiguration,
final SvnLoadedBrachesStorage storage) {
super(project, VCS_NAME);
myLoadedBranchesStorage = storage;
LOG.debug("ct");
myRootsToWorkingCopies = new RootsToWorkingCopies(this);
myConfiguration = svnConfiguration;
myAuthNotifier = new SvnAuthenticationNotifier(this);
dumpFileStatus(FileStatus.ADDED);
dumpFileStatus(FileStatus.DELETED);
dumpFileStatus(FileStatus.MERGE);
dumpFileStatus(FileStatus.MODIFIED);
dumpFileStatus(FileStatus.NOT_CHANGED);
dumpFileStatus(FileStatus.UNKNOWN);
dumpFileStatus(SvnFileStatus.REPLACED);
dumpFileStatus(SvnFileStatus.EXTERNAL);
dumpFileStatus(SvnFileStatus.OBSTRUCTED);
final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(project);
myAddConfirmation =
vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.ADD, this);
myDeleteConfirmation =
vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.REMOVE, this);
myCheckoutOptions =
vcsManager.getStandardOption(VcsConfiguration.StandardOption.CHECKOUT, this);
if (myProject.isDefault()) {
myChangeListListener = null;
myEntriesFileListener = null;
} else {
myEntriesFileListener = new SvnEntriesFileListener(project);
upgradeIfNeeded(bus);
myChangeListListener = new SvnChangelistListener(myProject, this);
myVcsListener =
new VcsListener() {
@Override
public void directoryMappingChanged() {
invokeRefreshSvnRoots(true);
}
};
}
myFrameStateListener =
project.isDefault()
? null
: new MyFrameStateListener(
ChangeListManager.getInstance(project), VcsDirtyScopeManager.getInstance(project));
myWorkingCopiesContent = new WorkingCopiesContent(this);
// remove used some time before old notification group ids
correctNotificationIds();
myChecker = new SvnExecutableChecker(myProject);
}
@Override
public void deactivate() {
FrameStateManager.getInstance().removeListener(myFrameStateListener);
final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
if (myVcsListener != null) {
vcsManager.removeVcsListener(myVcsListener);
}
if (myEntriesFileListener != null) {
VirtualFileManager.getInstance().removeVirtualFileListener(myEntriesFileListener);
}
SvnApplicationSettings.getInstance().svnDeactivated();
if (myCommittedChangesProvider != null) {
myCommittedChangesProvider.deactivate();
}
if (myChangeListListener != null && !myProject.isDefault()) {
ChangeListManager.getInstance(myProject).removeChangeListListener(myChangeListListener);
}
vcsManager.removeVcsListener(myRootsToWorkingCopies);
myRootsToWorkingCopies.clear();
myAuthNotifier.stop();
myAuthNotifier.clear();
mySvnBranchPointsCalculator.deactivate();
mySvnBranchPointsCalculator = null;
myWorkingCopiesContent.deactivate();
myLoadedBranchesStorage.deactivate();
myPool.dispose();
myPool = null;
}
public void processChangeLists(final List<LocalChangeList> lists) {
final ProjectLevelVcsManager plVcsManager =
ProjectLevelVcsManager.getInstanceChecked(myProject);
plVcsManager.startBackgroundVcsOperation();
try {
final SVNChangelistClient client = createChangelistClient();
for (LocalChangeList list : lists) {
if (!list.isDefault()) {
final Collection<Change> changes = list.getChanges();
for (Change change : changes) {
correctListForRevision(
plVcsManager, change.getBeforeRevision(), client, list.getName());
correctListForRevision(plVcsManager, change.getAfterRevision(), client, list.getName());
}
}
}
} finally {
final Application appManager = ApplicationManager.getApplication();
if (appManager.isDispatchThread()) {
appManager.executeOnPooledThread(
new Runnable() {
@Override
public void run() {
plVcsManager.stopBackgroundVcsOperation();
}
});
} else {
plVcsManager.stopBackgroundVcsOperation();
}
}
}
private void returnConfirmationBack() {
if (mySystemOperation) {
final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
final VcsShowConfirmationOption addConfirmation =
vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.ADD, null);
addConfirmation.setValue(myAddconfirmationvalue);
final VcsShowConfirmationOption deleteConfirmation =
vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.REMOVE, null);
deleteConfirmation.setValue(myDeleteconfirmationvalue);
}
}
private void setConfirmationToDefault() {
if (mySystemOperation) {
final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
final VcsShowConfirmationOption addConfirmation =
vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.ADD, null);
myAddconfirmationvalue = addConfirmation.getValue();
addConfirmation.setValue(VcsShowConfirmationOption.Value.DO_ACTION_SILENTLY);
final VcsShowConfirmationOption deleteConfirmation =
vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.REMOVE, null);
myDeleteconfirmationvalue = deleteConfirmation.getValue();
deleteConfirmation.setValue(VcsShowConfirmationOption.Value.DO_ACTION_SILENTLY);
}
}
@NotNull
public Change[] getSelectedChanges() {
Set<Change> changes = new LinkedHashSet<Change>();
final TreePath[] paths = getSelectionPaths();
if (paths == null) {
return new Change[0];
}
for (TreePath path : paths) {
ChangesBrowserNode<?> node = (ChangesBrowserNode) path.getLastPathComponent();
changes.addAll(node.getAllChangesUnder());
}
if (changes.isEmpty()) {
final List<VirtualFile> selectedModifiedWithoutEditing = getSelectedModifiedWithoutEditing();
if (selectedModifiedWithoutEditing != null && !selectedModifiedWithoutEditing.isEmpty()) {
for (VirtualFile file : selectedModifiedWithoutEditing) {
AbstractVcs vcs = ProjectLevelVcsManager.getInstance(myProject).getVcsFor(file);
if (vcs == null) continue;
final VcsCurrentRevisionProxy before =
VcsCurrentRevisionProxy.create(file, myProject, vcs.getKeyInstanceMethod());
if (before != null) {
ContentRevision afterRevision = new CurrentContentRevision(new FilePathImpl(file));
changes.add(new Change(before, afterRevision, FileStatus.HIJACKED));
}
}
}
}
return changes.toArray(new Change[changes.size()]);
}
public RootsCalculator(
final Project project, final AbstractVcs vcs, final RepositoryLocationCache locationCache) {
myProject = project;
myLocationCache = locationCache;
myPlManager = ProjectLevelVcsManager.getInstance(myProject);
myVcs = vcs;
}
RemoteRevisionsStateCache(final Project project) {
myVcsManager = ProjectLevelVcsManager.getInstance(project);
myChanged = new HashMap<String, Pair<Boolean, VcsRoot>>();
myQueries = new MultiMap<VcsRoot, String>();
myTs = new HashMap<VcsRoot, Long>();
myLock = new Object();
myVcsConfiguration = VcsConfiguration.getInstance(project);
}
@Nullable
private static SvnVcs getVCS(VirtualFile file) {
Project[] projects = ProjectManager.getInstance().getOpenProjects();
for (Project project : projects) {
AbstractVcs vcs = ProjectLevelVcsManager.getInstance(project).getVcsFor(file);
if (vcs instanceof SvnVcs) {
return (SvnVcs) vcs;
}
}
return null;
}
private void baseRevisionsOfDvcsIntoContext(
List<Change> textChanges, CommitContext commitContext) {
ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
if (vcsManager.dvcsUsedInProject()
&& VcsConfiguration.getInstance(myProject).INCLUDE_TEXT_INTO_SHELF) {
final Set<Change> big = SelectFilesToAddTextsToPatchPanel.getBig(textChanges);
final ArrayList<FilePath> toKeep = new ArrayList<FilePath>();
for (Change change : textChanges) {
if (change.getBeforeRevision() == null || change.getAfterRevision() == null) continue;
if (big.contains(change)) continue;
FilePath filePath = ChangesUtil.getFilePath(change);
final AbstractVcs vcs = vcsManager.getVcsFor(filePath);
if (vcs != null && VcsType.distibuted.equals(vcs.getType())) {
toKeep.add(filePath);
}
}
commitContext.putUserData(BaseRevisionTextPatchEP.ourPutBaseRevisionTextKey, true);
commitContext.putUserData(BaseRevisionTextPatchEP.ourBaseRevisionPaths, toKeep);
}
}
public Map<VirtualFile, RepositoryLocation> getRoots() {
myContentRoots = myPlManager.getRootsUnderVcs(myVcs);
List<VirtualFile> roots = new ArrayList<>();
final List<VcsDirectoryMapping> mappings = myPlManager.getDirectoryMappings(myVcs);
for (VcsDirectoryMapping mapping : mappings) {
if (mapping.isDefaultMapping()) {
if (myVcs.equals(myPlManager.getVcsFor(myProject.getBaseDir()))) {
roots.add(myProject.getBaseDir());
}
} else {
VirtualFile newFile = LocalFileSystem.getInstance().findFileByPath(mapping.getDirectory());
if (newFile == null) {
newFile = LocalFileSystem.getInstance().refreshAndFindFileByPath(mapping.getDirectory());
}
if (newFile != null) {
roots.add(newFile);
} else {
LOG.info("Can not file virtual file for root: " + mapping.getDirectory());
}
}
}
ContainerUtil.addAll(roots, myContentRoots);
final Map<VirtualFile, RepositoryLocation> result = new HashMap<>();
for (Iterator<VirtualFile> iterator = roots.iterator(); iterator.hasNext(); ) {
final VirtualFile vf = iterator.next();
final RepositoryLocation location =
myLocationCache.getLocation(myVcs, VcsUtil.getFilePath(vf), false);
if (location != null) {
result.put(vf, location);
} else {
iterator.remove();
}
}
roots = myVcs.filterUniqueRoots(roots, IntoSelfVirtualFileConvertor.getInstance());
result.keySet().retainAll(roots);
logRoots(roots);
return result;
}
@Override
public void doAction(int lineNum) {
LastRevision revision = myRevisions.get(lineNum);
if (revision == null) return;
VirtualFile file = getHyperlinkVirtualFile(myHyperlinks.findAllHyperlinksOnLine(lineNum));
if (file == null) return;
AbstractVcs vcs = ProjectLevelVcsManager.getInstance(myProject).getVcsFor(file);
if (vcs != null) {
VcsRevisionNumber number = revision.getNumber();
VcsKey vcsKey = vcs.getKeyInstanceMethod();
ShowAllAffectedGenericAction.showSubmittedFiles(myProject, number, file, vcsKey);
}
}
private static void correctListForRevision(
final ProjectLevelVcsManager plVcsManager,
final ContentRevision revision,
final SVNChangelistClient client,
final String name) {
if (revision != null) {
final FilePath path = revision.getFile();
final AbstractVcs vcs = plVcsManager.getVcsFor(path);
if (vcs != null && VCS_NAME.equals(vcs.getName())) {
try {
client.doAddToChangelist(new File[] {path.getIOFile()}, SVNDepth.EMPTY, name, null);
} catch (SVNException e) {
// left in default list
}
}
}
}
@Nullable
private VirtualFile getRootForPath(final String s) {
return myVcsManager.getVcsRootFor(new FilePathImpl(new File(s), false));
}
public static SvnVcs getInstance(Project project) {
return (SvnVcs) ProjectLevelVcsManager.getInstance(project).findVcsByName(VCS_NAME);
}
@Override
public void activate() {
createPool();
final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
if (!myProject.isDefault()) {
ChangeListManager.getInstance(myProject).addChangeListListener(myChangeListListener);
vcsManager.addVcsListener(myVcsListener);
}
SvnApplicationSettings.getInstance().svnActivated();
if (myEntriesFileListener != null) {
VirtualFileManager.getInstance().addVirtualFileListener(myEntriesFileListener);
}
// this will initialize its inner listener for committed changes upload
LoadedRevisionsCache.getInstance(myProject);
FrameStateManager.getInstance().addListener(myFrameStateListener);
myAuthNotifier.init();
mySvnBranchPointsCalculator = new SvnBranchPointsCalculator(myProject);
mySvnBranchPointsCalculator.activate();
if (SystemInfo.isWindows) {
if (!SVNJNAUtil.isJNAPresent()) {
Notifications.Bus.notify(
new Notification(
getDisplayName(),
"Subversion plugin: no JNA",
"A problem with JNA initialization for svnkit library. Encryption is not available.",
NotificationType.WARNING),
NotificationDisplayType.BALLOON,
myProject);
} else if (!SVNJNAUtil.isWinCryptEnabled()) {
Notifications.Bus.notify(
new Notification(
getDisplayName(),
"Subversion plugin: no encryption",
"A problem with encryption module (Crypt32.dll) initialization for svnkit library. Encryption is not available.",
NotificationType.WARNING),
NotificationDisplayType.BALLOON,
myProject);
}
}
final SvnConfiguration.UseAcceleration accelerationType =
SvnConfiguration.getInstance(myProject).myUseAcceleration;
if (SvnConfiguration.UseAcceleration.javaHL.equals(accelerationType)) {
CheckJavaHL.runtimeCheck(myProject);
} else if (SvnConfiguration.UseAcceleration.commandLine.equals(accelerationType)
&& !ApplicationManager.getApplication().isHeadlessEnvironment()) {
myChecker.checkExecutableAndNotifyIfNeeded();
}
// do one time after project loaded
StartupManager.getInstance(myProject)
.runWhenProjectIsInitialized(
new DumbAwareRunnable() {
@Override
public void run() {
postStartup();
// for IDEA, it takes 2 minutes - and anyway this can be done in background, no
// sense...
// once it could be mistaken about copies for 2 minutes on start...
/*if (! myMapping.getAllWcInfos().isEmpty()) {
invokeRefreshSvnRoots();
return;
}
ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() {
public void run() {
myCopiesRefreshManager.getCopiesRefresh().ensureInit();
}
}, SvnBundle.message("refreshing.working.copies.roots.progress.text"), true, myProject);*/
}
});
vcsManager.addVcsListener(myRootsToWorkingCopies);
myLoadedBranchesStorage.activate();
}
@Nullable
private VirtualFile getRootForPath(final String s) {
return myVcsManager.getVcsRootFor(VcsUtil.getFilePath(s, false));
}
