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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
/*
* Copyright 2000-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.idea.svn.update;
import com.intellij.openapi.options.Configurable;
import com.intellij.openapi.progress.ProgressIndicator;
import com.intellij.openapi.ui.Messages;
import com.intellij.openapi.vcs.FilePath;
import com.intellij.openapi.vcs.VcsException;
import com.intellij.openapi.vcs.update.UpdatedFiles;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.idea.svn.*;
import org.jetbrains.idea.svn.commandLine.SvnBindException;
import org.jetbrains.idea.svn.info.Info;
import org.tmatesoft.svn.core.SVNURL;
import org.tmatesoft.svn.core.wc.SVNRevision;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
public class SvnUpdateEnvironment extends AbstractSvnUpdateIntegrateEnvironment {
public SvnUpdateEnvironment(SvnVcs vcs) {
super(vcs);
}
protected AbstractUpdateIntegrateCrawler createCrawler(final UpdateEventHandler eventHandler,
final boolean totalUpdate,
final ArrayList<VcsException> exceptions, final UpdatedFiles updatedFiles) {
return new UpdateCrawler(myVcs, eventHandler, totalUpdate, exceptions, updatedFiles);
}
public Configurable createConfigurable(final Collection<FilePath> collection) {
if (collection.isEmpty()) return null;
return new SvnUpdateConfigurable(myVcs.getProject()){
public String getDisplayName() {
return SvnBundle.message("update.switch.configurable.name");
}
protected AbstractSvnUpdatePanel createPanel() {
return new SvnUpdatePanel(myVcs, collection);
}
};
}
protected static class UpdateCrawler extends AbstractUpdateIntegrateCrawler {
public UpdateCrawler(SvnVcs vcs, UpdateEventHandler handler, boolean totalUpdate,
Collection<VcsException> exceptions, UpdatedFiles postUpdateFiles) {
super(totalUpdate, postUpdateFiles, exceptions, handler, vcs);
}
protected void showProgressMessage(final ProgressIndicator progress, final File root) {
progress.setText(SvnBundle.message("progress.text.updating", root.getAbsolutePath()));
}
protected long doUpdate(final File root) throws SvnBindException {
final long rev;
final SvnConfiguration configuration = SvnConfiguration.getInstance(myVcs.getProject());
final UpdateRootInfo rootInfo = configuration.getUpdateRootInfo(root, myVcs);
final SVNURL sourceUrl = getSourceUrl(myVcs, root);
final boolean isSwitch = rootInfo != null && rootInfo.getUrl() != null && ! rootInfo.getUrl().equals(sourceUrl);
final SVNRevision updateTo = rootInfo != null && rootInfo.isUpdateToRevision() ? rootInfo.getRevision() : SVNRevision.HEAD;
if (isSwitch) {
final UpdateClient updateClient = createUpdateClient(configuration, root, true, sourceUrl);
myHandler.addToSwitch(root, sourceUrl);
rev = updateClient.doSwitch(root, rootInfo.getUrl(), SVNRevision.UNDEFINED, updateTo, configuration.getUpdateDepth(),
configuration.isForceUpdate(), false);
} else {
final UpdateClient updateClient = createUpdateClient(configuration, root, false, sourceUrl);
rev = updateClient.doUpdate(root, updateTo, configuration.getUpdateDepth(), configuration.isForceUpdate(), false);
}
return rev;
}
private UpdateClient createUpdateClient(SvnConfiguration configuration, File root, boolean isSwitch, SVNURL sourceUrl) {
final UpdateClient updateClient = myVcs.getFactory(root).createUpdateClient();
if (! isSwitch) {
updateClient.setIgnoreExternals(configuration.isIgnoreExternals());
}
updateClient.setEventHandler(myHandler);
updateClient.setUpdateLocksOnDemand(configuration.isUpdateLockOnDemand());
return updateClient;
}
protected boolean isMerge() {
return false;
}
}
@Nullable
private static SVNURL getSourceUrl(final SvnVcs vcs, final File root) {
final Info svnInfo = vcs.getInfo(root);
return svnInfo != null ? svnInfo.getURL() : null;
}
public boolean validateOptions(final Collection<FilePath> roots) {
// TODO: Check if this logic is useful and needs to be uncommented.
// TODO: Also Check if setXxx() in UpdateRootInfo are thread safe.
/*final SvnConfiguration configuration = SvnConfiguration.getInstance(myVcs.getProject());
final Map<File,UpdateRootInfo> map = configuration.getUpdateInfosMap();
try {
for (FilePath root : roots) {
final File ioFile = root.getIOFile();
final UpdateRootInfo value = map.get(ioFile);
if (value == null) {
continue;
}
final SVNURL url = value.getUrl();
if (url != null && (! url.equals(getSourceUrl(myVcs, root.getIOFile())))) {
// switch
final SVNRevision updateRevision = correctRevision(value);
return true;
// should be turned on after bugfix with copy url
//return checkAncestry(ioFile, url, updateRevision);
}
}
}
catch (SvnBindException e) {
Messages.showErrorDialog(myVcs.getProject(), e.getMessage(), SvnBundle.message("switch.target.problem.title"));
return false;
}*/
return true;
}
private SVNRevision correctRevision(@NotNull UpdateRootInfo value) throws SvnBindException {
if (SVNRevision.HEAD.equals(value.getRevision())) {
// find acual revision to update to (a bug if just say head in switch)
value.setRevision(SvnUtil.getHeadRevision(myVcs, value.getUrl()));
}
return value.getRevision();
}
// false - do not do update
private boolean checkAncestry(final File sourceFile, final SVNURL targetUrl, final SVNRevision targetRevision) throws SvnBindException {
final Info sourceSvnInfo = myVcs.getInfo(sourceFile);
final Info targetSvnInfo = myVcs.getInfo(targetUrl, targetRevision);
if (sourceSvnInfo == null || targetSvnInfo == null) {
// cannot check
return true;
}
final SVNURL copyFromTarget = targetSvnInfo.getCopyFromURL();
final SVNURL copyFromSource = sourceSvnInfo.getCopyFromURL();
if ((copyFromSource != null) || (copyFromTarget != null)) {
if (sourceSvnInfo.getURL().equals(copyFromTarget) || targetUrl.equals(copyFromSource)) {
return true;
}
}
final int result = Messages.showYesNoDialog(myVcs.getProject(), SvnBundle.message("switch.target.not.copy.current"),
SvnBundle.message("switch.target.problem.title"), Messages.getWarningIcon());
return (Messages.YES == result);
}
}
|
