plugins/git4idea/src/git4idea/GitUtil.java

   1 package git4idea;
   2 /*
   3  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
   4  * with the License. You may obtain a copy of the License at:
   5  *
   6  *   http://www.apache.org/licenses/LICENSE-2.0
   7  *
   8  * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
   9  * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for
  10  * the specific language governing permissions and limitations under the License.
  11  *
  12  * Copyright 2007 Decentrix Inc
  13  * Copyright 2007 Aspiro AS
  14  * Copyright 2008 MQSoftware
  15  * Copyright 2008 JetBrains s.r.o.
  16  *
  17  * Authors: gevession, Erlend Simonsen & Mark Scott
  18  *
  19  * This code was originally derived from the MKS & Mercurial IDEA VCS plugins
  20  */
  21
  22 import com.intellij.openapi.diagnostic.Logger;
  23 import com.intellij.openapi.project.Project;
  24 import com.intellij.openapi.util.SystemInfo;
  25 import com.intellij.openapi.util.io.FileUtil;
  26 import com.intellij.openapi.vcs.FilePath;
  27 import com.intellij.openapi.vcs.VcsException;
  28 import com.intellij.openapi.vcs.changes.VcsDirtyScopeManager;
  29 import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList;
  30 import com.intellij.openapi.vcs.vfs.AbstractVcsVirtualFile;
  31 import com.intellij.openapi.vfs.LocalFileSystem;
  32 import com.intellij.openapi.vfs.VfsUtil;
  33 import com.intellij.openapi.vfs.VirtualFile;
  34 import com.intellij.util.Consumer;
  35 import com.intellij.vcsUtil.VcsUtil;
  36 import git4idea.changes.GitChangeUtils;
  37 import git4idea.commands.GitHandler;
  38 import git4idea.commands.GitSimpleHandler;
  39 import git4idea.commands.StringScanner;
  40 import git4idea.config.GitConfigUtil;
  41 import org.jetbrains.annotations.NotNull;
  42 import org.jetbrains.annotations.Nullable;
  43
  44 import java.io.File;
  45 import java.io.UnsupportedEncodingException;
  46 import java.util.*;
  47
  48 /**
  49  * Git utility/helper methods
  50  */
  51 public class GitUtil {
  52   /**
  53    * The logger instance
  54    */
  55   private final static Logger LOG = Logger.getInstance("#git4idea.GitUtil");
  56   /**
  57    * Comparator for virtual files by name
  58    */
  59   public static final Comparator<VirtualFile> VIRTUAL_FILE_COMPARATOR = new Comparator<VirtualFile>() {
  60     public int compare(final VirtualFile o1, final VirtualFile o2) {
  61       if (o1 == null && o2 == null) {
  62         return 0;
  63       }
  64       if (o1 == null) {
  65         return -1;
  66       }
  67       if (o2 == null) {
  68         return 1;
  69       }
  70       return o1.getPresentableUrl().compareTo(o2.getPresentableUrl());
  71     }
  72   };
  73
  74   /**
  75    * A private constructor to suppress instance creation
  76    */
  77   private GitUtil() {
  78     // do nothing
  79   }
  80
  81   /**
  82    * Sort files by Git root
  83    *
  84    * @param virtualFiles files to sort
  85    * @return sorted files
  86    * @throws VcsException if non git files are passed
  87    */
  88   @NotNull
  89   public static Map<VirtualFile, List<VirtualFile>> sortFilesByGitRoot(@NotNull Collection<VirtualFile> virtualFiles) throws VcsException {
  90     return sortFilesByGitRoot(virtualFiles, false);
  91   }
  92
  93   /**
  94    * Sort files by Git root
  95    *
  96    * @param virtualFiles files to sort
  97    * @param ignoreNonGit if true, non-git files are ignored
  98    * @return sorted files
  99    * @throws VcsException if non git files are passed when {@code ignoreNonGit} is false
 100    */
 101   public static Map<VirtualFile, List<VirtualFile>> sortFilesByGitRoot(Collection<VirtualFile> virtualFiles, boolean ignoreNonGit)
 102     throws VcsException {
 103     Map<VirtualFile, List<VirtualFile>> result = new HashMap<VirtualFile, List<VirtualFile>>();
 104     for (VirtualFile file : virtualFiles) {
 105       final VirtualFile vcsRoot = gitRootOrNull(file);
 106       if (vcsRoot == null) {
 107         if (ignoreNonGit) {
 108           continue;
 109         }
 110         else {
 111           throw new VcsException("The file " + file.getPath() + " is not under Git");
 112         }
 113       }
 114       List<VirtualFile> files = result.get(vcsRoot);
 115       if (files == null) {
 116         files = new ArrayList<VirtualFile>();
 117         result.put(vcsRoot, files);
 118       }
 119       files.add(file);
 120     }
 121     return result;
 122   }
 123
 124   public static String getRelativeFilePath(VirtualFile file, @NotNull final VirtualFile baseDir) {
 125     return getRelativeFilePath(file.getPath(), baseDir);
 126   }
 127
 128   public static String getRelativeFilePath(FilePath file, @NotNull final VirtualFile baseDir) {
 129     return getRelativeFilePath(file.getPath(), baseDir);
 130   }
 131
 132   public static String getRelativeFilePath(String file, @NotNull final VirtualFile baseDir) {
 133     if (SystemInfo.isWindows) {
 134       file = file.replace('\\', '/');
 135     }
 136     final String basePath = baseDir.getPath();
 137     if (!file.startsWith(basePath)) {
 138       return file;
 139     }
 140     else if (file.equals(basePath)) return ".";
 141     return file.substring(baseDir.getPath().length() + 1);
 142   }
 143
 144   /**
 145    * Sort files by vcs root
 146    *
 147    * @param files files to sort.
 148    * @return the map from root to the files under the root
 149    * @throws VcsException if non git files are passed
 150    */
 151   public static Map<VirtualFile, List<FilePath>> sortFilePathsByGitRoot(final Collection<FilePath> files) throws VcsException {
 152     return sortFilePathsByGitRoot(files, false);
 153   }
 154
 155   /**
 156    * Sort files by vcs root
 157    *
 158    * @param files        files to sort.
 159    * @param ignoreNonGit if true, non-git files are ignored
 160    * @return the map from root to the files under the root
 161    * @throws VcsException if non git files are passed when {@code ignoreNonGit} is false
 162    */
 163   public static Map<VirtualFile, List<FilePath>> sortFilePathsByGitRoot(Collection<FilePath> files, boolean ignoreNonGit)
 164     throws VcsException {
 165     Map<VirtualFile, List<FilePath>> rc = new HashMap<VirtualFile, List<FilePath>>();
 166     for (FilePath p : files) {
 167       VirtualFile root = getGitRootOrNull(p);
 168       if (root == null) {
 169         if (ignoreNonGit) {
 170           continue;
 171         }
 172         else {
 173           throw new VcsException("The file " + p.getPath() + " is not under Git");
 174         }
 175       }
 176       List<FilePath> l = rc.get(root);
 177       if (l == null) {
 178         l = new ArrayList<FilePath>();
 179         rc.put(root, l);
 180       }
 181       l.add(p);
 182     }
 183     return rc;
 184   }
 185
 186   /**
 187    * Unescape path returned by the Git
 188    *
 189    * @param path a path to unescape
 190    * @return unescaped path
 191    * @throws VcsException if the path in invalid
 192    */
 193   public static String unescapePath(String path) throws VcsException {
 194     final int l = path.length();
 195     StringBuilder rc = new StringBuilder(l);
 196     for (int i = 0; i < path.length(); i++) {
 197       char c = path.charAt(i);
 198       if (c == '\\') {
 199         //noinspection AssignmentToForLoopParameter
 200         i++;
 201         if (i >= l) {
 202           throw new VcsException("Unterminated escape sequence in the path: " + path);
 203         }
 204         final char e = path.charAt(i);
 205         switch (e) {
 206           case '\\':
 207             rc.append('\\');
 208             break;
 209           case 't':
 210             rc.append('\t');
 211             break;
 212           case 'n':
 213             rc.append('\n');
 214             break;
 215           default:
 216             if (isOctal(e)) {
 217               // collect sequence of characters as a byte array.
 218               // count bytes first
 219               int n = 0;
 220               for (int j = i; j < l;) {
 221                 if (isOctal(path.charAt(j))) {
 222                   n++;
 223                   for (int k = 0; k < 3 && j < l && isOctal(path.charAt(j)); k++) {
 224                     //noinspection AssignmentToForLoopParameter
 225                     j++;
 226                   }
 227                 }
 228                 if (j + 1 >= l || path.charAt(j) != '\\' || !isOctal(path.charAt(j + 1))) {
 229                   break;
 230                 }
 231                 //noinspection AssignmentToForLoopParameter
 232                 j++;
 233               }
 234               // convert to byte array
 235               byte[] b = new byte[n];
 236               n = 0;
 237               while (i < l) {
 238                 if (isOctal(path.charAt(i))) {
 239                   int code = 0;
 240                   for (int k = 0; k < 3 && i < l && isOctal(path.charAt(i)); k++) {
 241                     code = code * 8 + (path.charAt(i) - '0');
 242                     //noinspection AssignmentToForLoopParameter
 243                     i++;
 244                   }
 245                   b[n++] = (byte)code;
 246                 }
 247                 if (i + 1 >= l || path.charAt(i) != '\\' || !isOctal(path.charAt(i + 1))) {
 248                   break;
 249                 }
 250                 //noinspection AssignmentToForLoopParameter
 251                 i++;
 252               }
 253               assert n == b.length;
 254               // add them to string
 255               final String encoding = GitConfigUtil.getFileNameEncoding();
 256               try {
 257                 rc.append(new String(b, encoding));
 258               }
 259               catch (UnsupportedEncodingException e1) {
 260                 throw new IllegalStateException("The file name encoding is unsuported: " + encoding);
 261               }
 262             }
 263             else {
 264               throw new VcsException("Unknown escape sequence '\\" + path.charAt(i) + "' in the path: " + path);
 265             }
 266         }
 267       }
 268       else {
 269         rc.append(c);
 270       }
 271     }
 272     return rc.toString();
 273   }
 274
 275   /**
 276    * Check if character is octal digit
 277    *
 278    * @param ch a character to test
 279    * @return true if the octal digit, false otherwise
 280    */
 281   private static boolean isOctal(char ch) {
 282     return '0' <= ch && ch <= '7';
 283   }
 284
 285   /**
 286    * Parse UNIX timestamp as it is returned by the git
 287    *
 288    * @param value a value to parse
 289    * @return timestamp as {@link Date} object
 290    */
 291   public static Date parseTimestamp(String value) {
 292     return new Date(Long.parseLong(value.trim()) * 1000);
 293   }
 294
 295   /**
 296    * Get git roots from content roots
 297    *
 298    * @param roots git content roots
 299    * @return a content root
 300    */
 301   public static Set<VirtualFile> gitRootsForPaths(final Collection<VirtualFile> roots) {
 302     HashSet<VirtualFile> rc = new HashSet<VirtualFile>();
 303     for (VirtualFile root : roots) {
 304       VirtualFile f = root;
 305       do {
 306         if (f.findFileByRelativePath(".git") != null) {
 307           rc.add(f);
 308           break;
 309         }
 310         f = f.getParent();
 311       }
 312       while (f != null);
 313     }
 314     return rc;
 315   }
 316
 317   /**
 318    * Return a git root for the file path (the parent directory with ".git" subdirectory)
 319    *
 320    * @param filePath a file path
 321    * @return git root for the file
 322    * @throws IllegalArgumentException if the file is not under git
 323    * @throws VcsException             if the file is not under git
 324    */
 325   public static VirtualFile getGitRoot(final FilePath filePath) throws VcsException {
 326     VirtualFile root = getGitRootOrNull(filePath);
 327     if (root != null) {
 328       return root;
 329     }
 330     throw new VcsException("The file " + filePath + " is not under git.");
 331   }
 332
 333   /**
 334    * Return a git root for the file path (the parent directory with ".git" subdirectory)
 335    *
 336    * @param filePath a file path
 337    * @return git root for the file or null if the file is not under git
 338    */
 339   @Nullable
 340   public static VirtualFile getGitRootOrNull(final FilePath filePath) {
 341     File file = filePath.getIOFile();
 342     while (file != null && (!file.exists() || !file.isDirectory() || !new File(file, ".git").exists())) {
 343       file = file.getParentFile();
 344     }
 345     if (file == null) {
 346       return null;
 347     }
 348     return LocalFileSystem.getInstance().findFileByIoFile(file);
 349   }
 350
 351   /**
 352    * Return a git root for the file (the parent directory with ".git" subdirectory)
 353    *
 354    * @param file the file to check
 355    * @return git root for the file
 356    * @throws VcsException if the file is not under git
 357    */
 358   public static VirtualFile getGitRoot(@NotNull final VirtualFile file) throws VcsException {
 359     final VirtualFile root = gitRootOrNull(file);
 360     if (root != null) {
 361       return root;
 362     }
 363     else {
 364       throw new VcsException("The file " + file.getPath() + " is not under git.");
 365     }
 366   }
 367
 368   /**
 369    * Return a git root for the file (the parent directory with ".git" subdirectory)
 370    *
 371    * @param file the file to check
 372    * @return git root for the file or null if the file is not not under Git
 373    */
 374   @Nullable
 375   public static VirtualFile gitRootOrNull(final VirtualFile file) {
 376     if (file instanceof AbstractVcsVirtualFile) {
 377       return getGitRootOrNull(VcsUtil.getFilePath(file.getPath()));
 378     }
 379     VirtualFile root = file;
 380     while (root != null) {
 381       if (root.findFileByRelativePath(".git") != null) {
 382         return root;
 383       }
 384       root = root.getParent();
 385     }
 386     return root;
 387   }
 388
 389
 390   /**
 391    * Check if the virtual file under git
 392    *
 393    * @param vFile a virtual file
 394    * @return true if the file is under git
 395    */
 396   public static boolean isUnderGit(final VirtualFile vFile) {
 397     return gitRootOrNull(vFile) != null;
 398   }
 399
 400   /**
 401    * Get relative path
 402    *
 403    * @param root a root path
 404    * @param path a path to file (possibly deleted file)
 405    * @return a relative path
 406    * @throws IllegalArgumentException if path is not under root.
 407    */
 408   public static String relativePath(final VirtualFile root, FilePath path) {
 409     return relativePath(VfsUtil.virtualToIoFile(root), path.getIOFile());
 410   }
 411
 412
 413   /**
 414    * Get relative path
 415    *
 416    * @param root a root path
 417    * @param path a path to file (possibly deleted file)
 418    * @return a relative path
 419    * @throws IllegalArgumentException if path is not under root.
 420    */
 421   public static String relativePath(final File root, FilePath path) {
 422     return relativePath(root, path.getIOFile());
 423   }
 424
 425   /**
 426    * Get relative path
 427    *
 428    * @param root a root path
 429    * @param file a virtual file
 430    * @return a relative path
 431    * @throws IllegalArgumentException if path is not under root.
 432    */
 433   public static String relativePath(final File root, VirtualFile file) {
 434     return relativePath(root, VfsUtil.virtualToIoFile(file));
 435   }
 436
 437   /**
 438    * Get relative path
 439    *
 440    * @param root a root file
 441    * @param file a virtual file
 442    * @return a relative path
 443    * @throws IllegalArgumentException if path is not under root.
 444    */
 445   public static String relativePath(final VirtualFile root, VirtualFile file) {
 446     return relativePath(VfsUtil.virtualToIoFile(root), VfsUtil.virtualToIoFile(file));
 447   }
 448
 449   /**
 450    * Get relative path
 451    *
 452    * @param root a root path
 453    * @param path a path to file (possibly deleted file)
 454    * @return a relative path
 455    * @throws IllegalArgumentException if path is not under root.
 456    */
 457   public static String relativePath(final File root, File path) {
 458     String rc = FileUtil.getRelativePath(root, path);
 459     if (rc == null) {
 460       throw new IllegalArgumentException("The file " + path + " cannot be made relative to " + root);
 461     }
 462     return rc.replace(File.separatorChar, '/');
 463   }
 464
 465   /**
 466    * Refresh files
 467    *
 468    * @param project       a project
 469    * @param affectedFiles affected files and directories
 470    */
 471   public static void refreshFiles(@NotNull final Project project, @NotNull final Collection<VirtualFile> affectedFiles) {
 472     final VcsDirtyScopeManager dirty = VcsDirtyScopeManager.getInstance(project);
 473     for (VirtualFile file : affectedFiles) {
 474       if (!file.isValid()) {
 475         continue;
 476       }
 477       file.refresh(false, true);
 478       if (file.isDirectory()) {
 479         dirty.dirDirtyRecursively(file);
 480       }
 481       else {
 482         dirty.fileDirty(file);
 483       }
 484     }
 485   }
 486
 487   /**
 488    * Refresh files
 489    *
 490    * @param project       a project
 491    * @param affectedFiles affected files and directories
 492    */
 493   public static void markFilesDirty(@NotNull final Project project, @NotNull final Collection<VirtualFile> affectedFiles) {
 494     final VcsDirtyScopeManager dirty = VcsDirtyScopeManager.getInstance(project);
 495     for (VirtualFile file : affectedFiles) {
 496       if (!file.isValid()) {
 497         continue;
 498       }
 499       if (file.isDirectory()) {
 500         dirty.dirDirtyRecursively(file);
 501       }
 502       else {
 503         dirty.fileDirty(file);
 504       }
 505     }
 506   }
 507
 508
 509   /**
 510    * Mark files dirty
 511    *
 512    * @param project       a project
 513    * @param affectedFiles affected files and directories
 514    */
 515   public static void markFilesDirty(Project project, List<FilePath> affectedFiles) {
 516     final VcsDirtyScopeManager dirty = VcsDirtyScopeManager.getInstance(project);
 517     for (FilePath file : affectedFiles) {
 518       if (file.isDirectory()) {
 519         dirty.dirDirtyRecursively(file);
 520       }
 521       else {
 522         dirty.fileDirty(file);
 523       }
 524     }
 525   }
 526
 527   /**
 528    * Refresh files
 529    *
 530    * @param project       a project
 531    * @param affectedFiles affected files and directories
 532    */
 533   public static void refreshFiles(Project project, List<FilePath> affectedFiles) {
 534     final VcsDirtyScopeManager dirty = VcsDirtyScopeManager.getInstance(project);
 535     for (FilePath file : affectedFiles) {
 536       VirtualFile vFile = VcsUtil.getVirtualFile(file.getIOFile());
 537       if (vFile != null) {
 538         vFile.refresh(false, true);
 539       }
 540       if (file.isDirectory()) {
 541         dirty.dirDirtyRecursively(file);
 542       }
 543       else {
 544         dirty.fileDirty(file);
 545       }
 546     }
 547   }
 548
 549   /**
 550    * Return committer name based on author name and committer name
 551    *
 552    * @param authorName    the name of author
 553    * @param committerName the name of committer
 554    * @return just a name if they are equal, or name that includes both author and committer
 555    */
 556   public static String adjustAuthorName(final String authorName, String committerName) {
 557     if (!authorName.equals(committerName)) {
 558       //noinspection HardCodedStringLiteral
 559       committerName = authorName + ", via " + committerName;
 560     }
 561     return committerName;
 562   }
 563
 564   /**
 565    * Check if the file path is under git
 566    *
 567    * @param path the path
 568    * @return true if the file path is under git
 569    */
 570   public static boolean isUnderGit(final FilePath path) {
 571     return getGitRootOrNull(path) != null;
 572   }
 573
 574   /**
 575    * Get git roots for the selected paths
 576    *
 577    * @param filePaths the context paths
 578    * @return a set of git roots
 579    */
 580   public static Set<VirtualFile> gitRoots(final Collection<FilePath> filePaths) {
 581     HashSet<VirtualFile> rc = new HashSet<VirtualFile>();
 582     for (FilePath path : filePaths) {
 583       final VirtualFile root = getGitRootOrNull(path);
 584       if (root != null) {
 585         rc.add(root);
 586       }
 587     }
 588     return rc;
 589   }
 590
 591   /**
 592    * Get git time (UNIX time) basing on the date object
 593    *
 594    * @param time the time to convert
 595    * @return the time in git format
 596    */
 597   public static String gitTime(Date time) {
 598     long t = time.getTime() / 1000;
 599     return Long.toString(t);
 600   }
 601
 602   /**
 603    * Format revision number from long to 16-digit abbreviated revision
 604    *
 605    * @param rev the abbreviated revision number as long
 606    * @return the revision string
 607    */
 608   public static String formatLongRev(long rev) {
 609     return String.format("%015x%x", (rev >>> 4), rev & 0xF);
 610   }
 611
 612   /**
 613    * The get the possible base for the path. It tries to find the parent for the provided path, if it fails, it looks for the path without last member.
 614    *
 615    * @param file the file to get base for
 616    * @param path the path to to check
 617    * @return the file base
 618    */
 619   @Nullable
 620   public static VirtualFile getPossibleBase(VirtualFile file, String... path) {
 621     return getPossibleBase(file, path.length, path);
 622   }
 623
 624   /**
 625    * The get the possible base for the path. It tries to find the parent for the provided path, if it fails, it looks for the path without last member.
 626    *
 627    * @param file the file to get base for
 628    * @param n    the length of the path to check
 629    * @param path the path to to check
 630    * @return the file base
 631    */
 632   @Nullable
 633   private static VirtualFile getPossibleBase(VirtualFile file, int n, String... path) {
 634     if (file == null || n <= 0 || n > path.length) {
 635       return null;
 636     }
 637     int i = 1;
 638     VirtualFile c = file;
 639     for (; c != null && i < n; i++, c = c.getParent()) {
 640       if (!path[n - i].equals(c.getName())) {
 641         break;
 642       }
 643     }
 644     if (i == n && c != null) {
 645       // all components matched
 646       return c.getParent();
 647     }
 648     // try shorter paths paths
 649     return getPossibleBase(file, n - 1, path);
 650   }
 651
 652   public static List<CommittedChangeList> getLocalCommittedChanges(final Project project,
 653                                                                    final VirtualFile root,
 654                                                                    final Consumer<GitSimpleHandler> parametersSpecifier)
 655     throws VcsException {
 656     final List<CommittedChangeList> rc = new ArrayList<CommittedChangeList>();
 657
 658     GitSimpleHandler h = new GitSimpleHandler(project, root, GitHandler.LOG);
 659     h.setNoSSH(true);
 660     h.addParameters("--pretty=format:%x0C%n" + GitChangeUtils.COMMITTED_CHANGELIST_FORMAT, "--name-status");
 661     parametersSpecifier.consume(h);
 662
 663     String output = h.run();
 664     LOG.debug("getLocalCommittedChanges output: '" + output + "'");
 665     StringScanner s = new StringScanner(output);
 666     while (s.hasMoreData() && s.startsWith('\u000C')) {
 667       s.nextLine();
 668       rc.add(GitChangeUtils.parseChangeList(project, root, s));
 669     }
 670     if (s.hasMoreData()) {
 671       throw new IllegalStateException("More input is avaialble: " + s.line());
 672     }
 673     return rc;
 674   }
 675
 676   /**
 677    * Cast or wrap exception into a vcs exception, errors and runtime exceptions are just thrown throw.
 678    *
 679    * @param t an exception to throw
 680    * @return a wrapped exception
 681    */
 682   public static VcsException rethrowVcsException(Throwable t) {
 683     if (t instanceof Error) {
 684       throw (Error)t;
 685     }
 686     if (t instanceof RuntimeException) {
 687       throw (RuntimeException)t;
 688     }
 689     if (t instanceof VcsException) {
 690       return (VcsException)t;
 691     }
 692     return new VcsException(t.getMessage(), t);
 693   }
 694 }