78f03e8a7e4dc50692016f197eeb0bd1128503f2
[idea/community.git] / plugins / git4idea / src / git4idea / changes / ChangeCollector.java
1 /*
2  * Copyright 2000-2007 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package git4idea.changes;
17
18 import com.intellij.openapi.project.Project;
19 import com.intellij.openapi.vcs.FilePath;
20 import com.intellij.openapi.vcs.FileStatus;
21 import com.intellij.openapi.vcs.VcsException;
22 import com.intellij.openapi.vcs.changes.Change;
23 import com.intellij.openapi.vcs.changes.ChangeListManager;
24 import com.intellij.openapi.vcs.changes.ContentRevision;
25 import com.intellij.openapi.vcs.changes.VcsDirtyScope;
26 import com.intellij.openapi.vfs.VirtualFile;
27 import com.intellij.vcsUtil.VcsUtil;
28 import git4idea.GitContentRevision;
29 import git4idea.GitRevisionNumber;
30 import git4idea.GitUtil;
31 import git4idea.commands.GitHandler;
32 import git4idea.commands.GitSimpleHandler;
33 import git4idea.commands.StringScanner;
34
35 import java.util.*;
36
37 /**
38  * A collector for changes in the Git. It is introduced because changes are not
39  * cannot be got as a sum of stateless operations.
40  */
41 class ChangeCollector {
42   /**
43    * The dirty scope used in the collector
44    */
45   private VcsDirtyScope myDirtyScope;
46   /**
47    * a vcs root for changes
48    */
49   private final VirtualFile myVcsRoot;
50   /**
51    * a project for change collection
52    */
53   private final Project myProject;
54   /**
55    * Unversioned files
56    */
57   private final List<VirtualFile> myUnversioned = new ArrayList<VirtualFile>();
58   /**
59    * Names that are listed as unmerged
60    */
61   private final Set<String> myUnmergedNames = new HashSet<String>();
62   /**
63    * Names that are listed as unmerged
64    */
65   private final List<Change> myChanges = new ArrayList<Change>();
66   /**
67    * This flag indicates that collecting changes has been failed.
68    */
69   private boolean myIsFailed = true;
70   /**
71    * This flag indicates that collecting changes has been started
72    */
73   private boolean myIsCollected = false;
74
75   /**
76    * A constructor
77    *
78    * @param project    a project
79    * @param dirtyScope the dirty scope to check
80    * @param vcsRoot    a vcs root
81    */
82   public ChangeCollector(final Project project, VcsDirtyScope dirtyScope, final VirtualFile vcsRoot) {
83     myDirtyScope = dirtyScope;
84     myVcsRoot = vcsRoot;
85     myProject = project;
86   }
87
88   /**
89    * Get unversioned files
90    *
91    * @return an unversioned files
92    * @throws VcsException if there is a problem with executing Git
93    */
94   public Collection<VirtualFile> unversioned() throws VcsException {
95     ensureCollected();
96     return myUnversioned;
97   }
98
99   /**
100    * Get changes
101    *
102    * @return an unversioned files
103    * @throws VcsException if there is a problem with executing Git
104    */
105   public Collection<Change> changes() throws VcsException {
106     ensureCollected();
107     return myChanges;
108   }
109
110
111   /**
112    * Ensure that changes has been collected.
113    *
114    * @throws VcsException an exception
115    */
116   private void ensureCollected() throws VcsException {
117     if (myIsCollected) {
118       if (myIsFailed) {
119         throw new IllegalStateException("The method should not be called after after exception has been thrown.");
120       }
121       else {
122         return;
123       }
124     }
125     myIsCollected = true;
126     collectUnmergedAndUnversioned();
127     collectDiffChanges();
128     myIsFailed = false;
129   }
130
131   /**
132    * Collect dirty file paths
133    *
134    * @param includeChanges if true, previous changes are included in collection
135    * @return the set of dirty paths to check, the paths are automatically collapsed if the summary length more than limit
136    */
137   private Collection<FilePath> dirtyPaths(boolean includeChanges) {
138     // TODO collapse paths with common prefix
139     ArrayList<FilePath> paths = new ArrayList<FilePath>();
140     FilePath rootPath = VcsUtil.getFilePath(myVcsRoot.getPath(), true);
141     for (FilePath p : myDirtyScope.getRecursivelyDirtyDirectories()) {
142       addToPaths(rootPath, paths, p);
143     }
144     ArrayList<FilePath> candidatePaths = new ArrayList<FilePath>();
145     candidatePaths.addAll(myDirtyScope.getDirtyFilesNoExpand());
146     if (includeChanges) {
147       try {
148         ChangeListManager cm = ChangeListManager.getInstance(myProject);
149         for (Change c : cm.getChangesIn(myVcsRoot)) {
150           switch (c.getType()) {
151             case NEW:
152             case DELETED:
153             case MOVED:
154               if (c.getAfterRevision() != null) {
155                 addToPaths(rootPath, paths, c.getAfterRevision().getFile());
156               }
157               if (c.getBeforeRevision() != null) {
158                 addToPaths(rootPath, paths, c.getBeforeRevision().getFile());
159               }
160             default:
161               // do nothing
162           }
163         }
164       }
165       catch (Exception t) {
166         // ignore exceptions
167       }
168     }
169     for (FilePath p : candidatePaths) {
170       addToPaths(rootPath, paths, p);
171     }
172     return paths;
173   }
174
175   /**
176    * Add path to the collection of the paths to check for this vcs root
177    *
178    * @param root  the root path
179    * @param paths the existing paths
180    * @param toAdd the path to add
181    */
182   void addToPaths(FilePath root, Collection<FilePath> paths, FilePath toAdd) {
183     if (GitUtil.getGitRootOrNull(toAdd) != myVcsRoot) {
184       return;
185     }
186     if (root.isUnder(toAdd, true)) {
187       toAdd = root;
188     }
189     for (Iterator<FilePath> i = paths.iterator(); i.hasNext();) {
190       FilePath p = i.next();
191       if (p.isUnder(toAdd, true)) {
192         i.remove();
193       }
194       if (toAdd.isUnder(p, false)) {
195         return;
196       }
197     }
198     paths.add(toAdd);
199   }
200
201   /**
202    * Collect diff with head
203    *
204    * @throws VcsException if there is a problem with running git
205    */
206   private void collectDiffChanges() throws VcsException {
207     GitSimpleHandler handler = new GitSimpleHandler(myProject, myVcsRoot, GitHandler.DIFF);
208     handler.addParameters("--name-status", "--diff-filter=ADCMRUX", "-M", "HEAD");
209     handler.setNoSSH(true);
210     handler.setSilent(true);
211     handler.setStdoutSuppressed(true);
212     handler.endOptions();
213     handler.addRelativePaths(dirtyPaths(true));
214     try {
215       String output = handler.run();
216       GitChangeUtils.parseChanges(myProject, myVcsRoot, null, GitChangeUtils.loadRevision(myProject, myVcsRoot, "HEAD"), output, myChanges,
217                                   myUnmergedNames);
218     }
219     catch (VcsException ex) {
220       if (!GitChangeUtils.isHeadMissing(ex)) {
221         throw ex;
222       }
223       handler = new GitSimpleHandler(myProject, myVcsRoot, GitHandler.LS_FILES);
224       handler.addParameters("--cached");
225       handler.setNoSSH(true);
226       handler.setSilent(true);
227       handler.setStdoutSuppressed(true);
228       // During init diff does not works because HEAD
229       // will appear only after the first commit.
230       // In that case added files are cached in index.
231       String output = handler.run();
232       if (output.length() > 0) {
233         StringTokenizer tokenizer = new StringTokenizer(output, "\n\r");
234         while (tokenizer.hasMoreTokens()) {
235           final String s = tokenizer.nextToken();
236           Change ch = new Change(null, GitContentRevision.createRevision(myVcsRoot, s, null, myProject, false), FileStatus.ADDED);
237           myChanges.add(ch);
238         }
239       }
240     }
241   }
242
243   /**
244    * Collect unversioned and unmerged files
245    *
246    * @throws VcsException if there is a problem with running git
247    */
248   private void collectUnmergedAndUnversioned() throws VcsException {
249     // prepare handler
250     GitSimpleHandler handler = new GitSimpleHandler(myProject, myVcsRoot, GitHandler.LS_FILES);
251     handler.addParameters("-v", "--others", "--unmerged", "--exclude-standard");
252     handler.setSilent(true);
253     handler.setNoSSH(true);
254     handler.setStdoutSuppressed(true);
255     handler.addRelativePaths(dirtyPaths(false));
256     // run handler and collect changes
257     String list = handler.run();
258     for (StringScanner sc = new StringScanner(list); sc.hasMoreData();) {
259       if (sc.isEol()) {
260         sc.nextLine();
261         continue;
262       }
263       char status = sc.peek();
264       sc.skipChars(2);
265       if ('?' == status) {
266         VirtualFile file = myVcsRoot.findFileByRelativePath(GitUtil.unescapePath(sc.line()));
267         if (GitUtil.gitRootOrNull(file) == myVcsRoot) {
268           myUnversioned.add(file);
269         }
270       }
271       else { //noinspection HardCodedStringLiteral
272         if ('M' == status) {
273           sc.boundedToken('\t');
274           String file = GitUtil.unescapePath(sc.line());
275           VirtualFile vFile = myVcsRoot.findFileByRelativePath(GitUtil.unescapePath(sc.line()));
276           if (GitUtil.gitRootOrNull(vFile) != myVcsRoot) {
277             continue;
278           }
279           if (!myUnmergedNames.add(file)) {
280             continue;
281           }
282           // TODO handle conflict rename-modify
283           // TODO handle conflict copy-modify
284           // TODO handle conflict delete-modify
285           // TODO handle conflict rename-delete
286           // assume modify-modify conflict
287           ContentRevision before = GitContentRevision.createRevision(myVcsRoot, file, new GitRevisionNumber("orig_head"), myProject, false);
288           ContentRevision after = GitContentRevision.createRevision(myVcsRoot, file, null, myProject, false);
289           myChanges.add(new Change(before, after, FileStatus.MERGED_WITH_CONFLICTS));
290         }
291         else {
292           throw new VcsException("Unsupported type of the merge conflict detected: " + status);
293         }
294       }
295     }
296   }
297 }