tools/tf/DiffCommand.cs

   1 using System;
   2 using System.IO;
   3 using System.Collections;
   4 using System.Collections.Generic;
   5 using System.Text;
   6 using Microsoft.TeamFoundation.Client;
   7 using Microsoft.TeamFoundation.VersionControl.Common;
   8 using Microsoft.TeamFoundation.VersionControl.Client;
   9 using Mono.GetOptions;
  10
  11 [Command("difference", "Show pending changes, latest on server, a changeset, or local changes not pended as a unified diff.", "diff")]
  12 class DifferenceCommand : Command
  13 {
  14         [Option("Output only whether files differ", "q", "brief")]
  15                 public bool OptionBrief = false;
  16
  17         [Option("Look for modified files", "", "modified")]
  18                 public bool OptionModified = false;
  19
  20         [Option("Show out of date files (newer version on server)", "", "old")]
  21                 public bool OptionOld = false;
  22
  23         [Option("Owner name", "O", "owner")]
  24                 public string OptionOwner;
  25
  26         public DifferenceCommand(Driver driver, string[] args): base(driver, args)
  27                 {
  28                 }
  29
  30         protected DiffOptions GetDiffOptions()
  31         {
  32                 DiffOptions options = new DiffOptions();
  33                 options.UseThirdPartyTool = false;
  34                 options.Flags = DiffOptionFlags.EnablePreambleHandling;
  35                 options.OutputType = DiffOutputType.Unified;
  36                 options.TargetEncoding = Console.OutputEncoding;
  37                 options.SourceEncoding = Console.OutputEncoding;
  38                 options.StreamWriter = new StreamWriter(Console.OpenStandardOutput(),
  39                                                                                                                                                                                 Console.OutputEncoding);
  40                 options.StreamWriter.AutoFlush = true;
  41
  42                 return options;
  43         }
  44
  45         public void ShowModifiedFiles(Workspace workspace, string path)
  46         {
  47                 char[] charsToTrim = { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar};
  48                 string itemPath = path.TrimEnd(charsToTrim);
  49
  50                 workspace.RefreshMappings();
  51                 string serverPath = workspace.GetServerItemForLocalItem(itemPath);
  52
  53                 // pull item list based on WorkspaceVersion. otherwise might get
  54                 // new items on server that haven't been pulled yet in the list returned
  55                 WorkspaceVersionSpec version = new WorkspaceVersionSpec(workspace);
  56
  57                 // get item list from TFS server
  58                 ItemSpec itemSpec = new ItemSpec(itemPath, RecursionType.Full);
  59                 ItemSet itemSet = VersionControlServer.GetItems(itemSpec, version, DeletedState.NonDeleted, ItemType.Any, true);
  60                 Item[] items = itemSet.Items;
  61
  62                 foreach (Item item in items)
  63                         {
  64                                 if (item.ItemType != ItemType.File) continue;
  65                                 if (item.ServerItem.Length == serverPath.Length) continue;
  66                                 string serverItem = item.ServerItem.Remove(0, serverPath.Length+1);
  67
  68                                 // server item paths are separated with '/', but on windows the file list below has '\' separated paths
  69                                 if (Path.DirectorySeparatorChar != '/')
  70                                         serverItem = serverItem.Replace('/', Path.DirectorySeparatorChar);
  71
  72                                 // only looking for modifications, not deletes or adds
  73                                 string fname = Path.Combine(itemPath, serverItem);
  74                                 if (!File.Exists(fname)) continue;
  75                                 if (FileAttributes.ReadOnly == (File.GetAttributes(fname) & FileAttributes.ReadOnly))
  76                                         continue;
  77
  78                                 string p = fname.Substring(path.Length+1);
  79                                 if (OptionBrief)
  80                                         {
  81                                                 Console.WriteLine(CanonicalPath(p));
  82                                                 continue;
  83                                         }
  84
  85                                 string tnameA = Path.GetTempFileName();
  86                                 item.DownloadFile(tnameA);
  87                                 IDiffItem a = new DiffItemLocalFile(tnameA, item.Encoding, DateTime.Now, false);
  88
  89                                 IDiffItem b = new DiffItemLocalFile(fname, item.Encoding, DateTime.Now, false);
  90
  91                                 Difference.DiffFiles(VersionControlServer, a, b,
  92                                                                                                                  GetDiffOptions(), p, true);
  93
  94                                 if (!String.IsNullOrEmpty(tnameA)) File.Delete(tnameA);
  95                         }
  96         }
  97
  98         public void ShowOldFiles(Workspace workspace, string path)
  99         {
 100                 // process command options
 101                 ItemSpec itemSpec = new ItemSpec(path, RecursionType.Full);
 102
 103                 List<ItemSpec> itemSpecs = new List<ItemSpec>();
 104                 itemSpecs.Add(itemSpec);
 105
 106                 ExtendedItem[][] items = workspace.GetExtendedItems(itemSpecs.ToArray(),
 107                                                                                                                                                                                                                                 DeletedState.NonDeleted, ItemType.Any);
 108
 109                 foreach (ExtendedItem[] itemArray in items)
 110                         {
 111                                 foreach (ExtendedItem item in itemArray)
 112                                         {
 113                                                 if (item.IsLatest) continue;
 114
 115                                                 string p = item.LocalItem.Substring(path.Length);
 116                                                 if (OptionBrief)
 117                                                         {
 118                                                                 Console.WriteLine(p);
 119                                                                 continue;
 120                                                         }
 121
 122                                                 IDiffItem a = new DiffItemNull();
 123                                                 IDiffItem b = new DiffItemNull();
 124
 125                                                 if ((item.ChangeType & ChangeType.Add) != ChangeType.Add)
 126                                                         {
 127                                                                 a = new DiffItemLocalFile(item.LocalItem, item.Encoding,
 128                                                                                                                                                                         DateTime.Now, false);
 129                                                         }
 130
 131                                                 if ((item.ChangeType & ChangeType.Delete) != ChangeType.Delete)
 132                                                         {
 133                                                                 b = new DiffItemVersionedFile(VersionControlServer,
 134                                                                                                                                                                                         item.ItemId, item.VersionLatest, item.LocalItem);
 135                                                         }
 136
 137                                                 Difference.DiffFiles(VersionControlServer, a, b,
 138                                                                                                                                  GetDiffOptions(), p, true);
 139                                         }
 140                         }
 141         }
 142
 143         void ShowPendingChanges(Workspace workspace, string path)
 144         {
 145                 PendingChange[] pendingChanges = workspace.GetPendingChanges(path, RecursionType.Full, true);
 146                 if (pendingChanges.Length == 0)
 147                         {
 148                                 Console.WriteLine("No pending changes.");
 149                                 Environment.Exit(0);
 150                         }
 151
 152                 string cwd = Environment.CurrentDirectory;
 153                 foreach (PendingChange change in pendingChanges)
 154                         {
 155                                 string p = change.LocalItem;
 156                                 if (p.StartsWith(cwd)) p = p.Substring(cwd.Length+1);
 157
 158                                 if (OptionBrief)
 159                                         {
 160                                                 Console.WriteLine(CanonicalPath(p));
 161                                                 continue;
 162                                         }
 163
 164                                 IDiffItem a = new DiffItemNull();
 165                                 IDiffItem b = new DiffItemNull();
 166
 167                                 string tname = null;
 168                                 if (!change.IsAdd)
 169                                         {
 170                                                 tname = Path.GetTempFileName();
 171                                                 change.DownloadBaseFile(tname);
 172
 173                                                 a = new DiffItemLocalFile(tname, change.Encoding,
 174                                                                                                                                                         change.CreationDate, true);
 175                                         }
 176
 177                                 if (!change.IsDelete)
 178                                         {
 179                                                 b = new DiffItemLocalFile(change.LocalItem, change.Encoding,
 180                                                                                                                                                         change.CreationDate, false);
 181                                         }
 182
 183                                 Difference.DiffFiles(VersionControlServer, a, b,
 184                                                                                                                  GetDiffOptions(), p, true);
 185
 186                                 if (!String.IsNullOrEmpty(tname))
 187                                         File.Delete(tname);
 188                         }
 189         }
 190
 191         public override void Run()
 192         {
 193                 string path = Environment.CurrentDirectory;
 194                 if (Arguments.Length > 0)
 195                         {
 196                                 path = Path.GetFullPath(Arguments[0]);
 197                         }
 198
 199                 Workspace workspace = GetWorkspaceFromCache();
 200
 201                 if (OptionOld)
 202                         {
 203                                 ShowOldFiles(workspace, path);
 204                                 Environment.Exit(0);
 205                         }
 206
 207                 if (OptionModified)
 208                         {
 209                                 ShowModifiedFiles(workspace, path);
 210                                 Environment.Exit(0);
 211                         }
 212
 213                 if (File.Exists(path) || Directory.Exists(path))
 214                         ShowPendingChanges(workspace, path);
 215                 else
 216                         {
 217                                 VersionSpec versionSpec = VersionSpec.ParseSingleSpec(Arguments[0], OwnerFromString(OptionOwner));
 218                                 if (versionSpec is ChangesetVersionSpec)
 219                                         DiffHelper.ShowChangeset(VersionControlServer,
 220                                                                                                                                          versionSpec as ChangesetVersionSpec,
 221                                                                                                                                          OptionBrief, GetDiffOptions());
 222                         }
 223         }
 224 }