tools/opentf/Command.cs

   1 //
   2 // Command.cs
   3 //
   4 // Authors:
   5 //      Joel Reed (joelwreed@gmail.com)
   6 //
   7
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System;
  30 using System.IO;
  31 using System.Text;
  32 using System.Text.RegularExpressions;
  33 using System.Collections.Generic;
  34 using Microsoft.TeamFoundation.Client;
  35 using Microsoft.TeamFoundation.VersionControl.Client;
  36 using Microsoft.TeamFoundation.VersionControl.Common;
  37 using OpenTF.Common;
  38
  39 abstract class Command : CommandOptions
  40 {
  41         private static bool runningOnUnix = true;
  42         private string[] arguments;
  43         private Driver driver;
  44         private static Regex fileExcludes;
  45         private static Regex dirExcludes;
  46
  47         public bool RunningOnUnix
  48         {
  49                 get { return runningOnUnix; }
  50         }
  51
  52         public Driver Driver
  53         {
  54                 get { return driver; }
  55         }
  56
  57         public string[] Arguments
  58         {
  59                 get { return arguments; }
  60         }
  61
  62         static Command()
  63         {
  64                 int p = (int) Environment.OSVersion.Platform;
  65                 if (!((p == 4) || (p == 128))) runningOnUnix = false;
  66
  67                 ReadFileExcludes();
  68         }
  69
  70         public static StringComparer PathComparer
  71         {
  72                 get {
  73                         if (!runningOnUnix) return StringComparer.CurrentCultureIgnoreCase;
  74                         return StringComparer.CurrentCulture;
  75                 }
  76         }
  77
  78         public Command(Driver driver, string[] args)
  79         {
  80                 this.driver = driver;
  81                 ProcessArgs(args);
  82                 this.arguments = RemainingArguments;
  83         }
  84
  85         public Workspace GetWorkspaceFromServer()
  86         {
  87                 string name = OptionWorkspace;
  88
  89                 // if option passed use it
  90                 if (String.IsNullOrEmpty(name))
  91                         {
  92                                 // guess based on current working directory
  93                                 WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(Environment.CurrentDirectory);
  94                                 if (info != null) name = info.Name;
  95                         }
  96
  97                 if (String.IsNullOrEmpty(name))
  98                                 name = Settings.Current.Get("Workspace.Default");
  99
 100                 if (String.IsNullOrEmpty(name))
 101                         {
 102                                 Console.WriteLine("Unable to determine the workspace");
 103                                 Console.WriteLine("      hint: try adding /workspace:<name>");
 104                                 Environment.Exit((int)ExitCode.Failure);
 105                         }
 106
 107                 return VersionControlServer.GetWorkspace(name, Driver.Username);
 108         }
 109
 110         public WorkspaceInfo GetWorkspaceInfoFromCache()
 111         {
 112                 string path = Environment.CurrentDirectory;
 113                 if (Arguments.Length > 0)
 114                         {
 115                                 path = Path.GetFullPath(Arguments[0]);
 116                         }
 117
 118                 WorkspaceInfo info = Workstation.Current.GetLocalWorkspaceInfo(path);
 119                 if (info != null) return info;
 120
 121                 if (String.IsNullOrEmpty(OptionWorkspace))
 122                                 OptionWorkspace = Settings.Current.Get("Workspace.Default");
 123
 124                 if (String.IsNullOrEmpty(OptionWorkspace))
 125                         {
 126                                 Console.WriteLine("Unable to determine the workspace.");
 127                                 Console.WriteLine("  Path: " + path);
 128                                 return null;
 129                         }
 130
 131                 string ownerName = String.Format("{0}\\{1}", Driver.Domain, Driver.Username).ToUpper();
 132                 info = Workstation.Current.GetLocalWorkspaceInfo(Driver.VersionControlServer,
 133                                                                                                                                                                                                                  OptionWorkspace, ownerName);
 134
 135                 if (info == null)
 136                         {
 137                                 Console.WriteLine("Unable to determine the workspace.");
 138                                 Console.WriteLine("  Workspace Name:  " + OptionWorkspace);
 139                                 Console.WriteLine("  Workspace Owner: " + ownerName);
 140                         }
 141
 142                 return info;
 143         }
 144
 145         public Workspace GetWorkspaceFromCache()
 146         {
 147                 WorkspaceInfo info = GetWorkspaceInfoFromCache();
 148
 149                 if (info == null)
 150                         {
 151                                 Console.WriteLine();
 152                                 Console.WriteLine("Hints:");
 153                                 Console.WriteLine("  Try adding /workspace:<name>");
 154                                 Console.WriteLine("  Review command options prefixed with '/'. Invalid options are mistaken for paths.");
 155                                 Environment.Exit((int)ExitCode.Failure);
 156                         }
 157
 158                 return VersionControlServer.GetWorkspace(info);
 159         }
 160
 161         public VersionSpec VersionFromString(string version)
 162         {
 163                 if (!String.IsNullOrEmpty(version))
 164                         return VersionSpec.ParseSingleSpec(version, Driver.Username);
 165                 else
 166                         return VersionSpec.Latest;
 167         }
 168
 169         static public string ChangeTypeToString(ChangeType change)
 170         {
 171                 string ctype = "edit";
 172
 173                 if ((change & ChangeType.Add) == ChangeType.Add) ctype = "add";
 174                 else if ((change & ChangeType.Delete) == ChangeType.Delete) ctype = "delete";
 175                 else if ((change & ChangeType.Rename) == ChangeType.Rename) ctype = "rename";
 176
 177                 return ctype;
 178         }
 179
 180         public int WindowWidth
 181         {
 182                 get {
 183                         // if output piped to a file, we don't want 0!
 184                         // this also throws on weird terminals on msclr
 185                         try
 186                                 {
 187                                         int w = Console.WindowWidth;
 188                                         if (w != 0) return w - 1;
 189                                 }
 190                         catch (IOException) {}
 191                         return 143;
 192                 }
 193         }
 194
 195         public string OwnerFromString(string owner)
 196         {
 197                 if (String.IsNullOrEmpty(owner)) return Driver.Username;
 198                 if (owner == "*") return null;
 199                 return owner;
 200         }
 201
 202         public VersionControlServer VersionControlServer
 203         {
 204                 get { return Driver.VersionControlServer; }
 205         }
 206
 207         public List<string> UnVerifiedFullPaths(string[] args)
 208         {
 209                 List<string> paths = new List<string>();
 210                 for (int i = 0; i < args.Length; i++)
 211                         {
 212                                 string fullPath = Path.GetFullPath(args[i]);
 213                                 paths.Add(fullPath);
 214                         }
 215
 216                 return paths;
 217         }
 218
 219         public List<string> VerifiedFullPaths(string[] args)
 220         {
 221                 List<string> paths = UnVerifiedFullPaths(args);
 222                 char[] wildcards = { '*', '?' };
 223
 224                 foreach (string path in paths)
 225                         {
 226                                 // skip wildcarded paths
 227                                 if (-1 != path.IndexOfAny(wildcards)) continue;
 228
 229                                 if (!File.Exists(path) && !Directory.Exists(path))
 230                                         {
 231                                                 Console.WriteLine("{0}: No such file or directory.", path);
 232                                                 Environment.Exit((int)ExitCode.Failure);
 233                                         }
 234                         }
 235
 236                 return paths;
 237         }
 238
 239         public void DeleteReadOnlyFile(string fullName)
 240         {
 241                 File.SetAttributes(fullName, FileAttributes.Normal);
 242                 File.Delete(fullName);
 243         }
 244
 245         static public void ReadFileExcludes()
 246         {
 247                 string exclusionList = Settings.Current.Get("File.Excludes");
 248                 if (String.IsNullOrEmpty(exclusionList)) return;
 249
 250                 string separatorChar = Path.DirectorySeparatorChar.ToString();
 251                 string[] wildcards = exclusionList.Split(',');
 252
 253                 StringBuilder dirRegexs = new StringBuilder();
 254                 StringBuilder fileRegexs = new StringBuilder();
 255
 256                 foreach (string wildcard in wildcards)
 257                         {
 258                                 if (-1 == wildcard.IndexOf(separatorChar))
 259                                         {
 260                                                 if (0 != fileRegexs.Length) fileRegexs.Append("|");
 261
 262                                                 fileRegexs.Append("^");
 263                                                 fileRegexs.Append(Regex.Escape(wildcard).Replace("\\*", ".*").Replace("\\?", "."));
 264                                                 fileRegexs.Append("$");
 265                                         }
 266                                 else
 267                                         {
 268                                                 if (0 != dirRegexs.Length) dirRegexs.Append("|");
 269
 270                                                 dirRegexs.Append("^.*");
 271                                                 dirRegexs.Append(Regex.Escape(wildcard));
 272                                                 dirRegexs.Append(".*$");
 273                                         }
 274                         }
 275
 276                 if (0 != fileRegexs.Length)
 277                         fileExcludes = new Regex(fileRegexs.ToString());
 278
 279                 if (0 != dirRegexs.Length)
 280                         dirExcludes = new Regex(dirRegexs.ToString());
 281         }
 282
 283         public bool IsExcludedFile(string path)
 284         {
 285                 if ((fileExcludes != null) &&
 286                                 (fileExcludes.IsMatch(Path.GetFileName(path))))
 287                         return true;
 288
 289                 if ((dirExcludes != null) && (dirExcludes.IsMatch(path)))
 290                         return true;
 291
 292                 return false;
 293         }
 294
 295         public void ConfirmFilesSpecified()
 296         {
 297                 if (Arguments.Length < 1)
 298                         {
 299                                 Console.WriteLine("No files specified.");
 300                                 Environment.Exit((int)ExitCode.Failure);
 301                         }
 302         }
 303
 304         public string CanonicalPath(string p)
 305         {
 306                 return p;
 307                 // maybe this feature is only interesting to me?
 308                 //if (runningOnUnix) return p;
 309                 //return p.Replace('\\', '/');
 310         }
 311
 312         public abstract void Run ();
 313 }
 314