static int Main(string[] raw)
		{
			ArgumentList args = new ArgumentList(raw);

			using (Log.AppStart(Environment.CommandLine))
			{
				if (args.Contains("nologo") == false)
				{
					Console.WriteLine("StampVersion.exe");
					Console.WriteLine("Copyright 2009 by Roger Knapp, Licensed under the Apache License, Version 2.0");
					Console.WriteLine("");
				}

				if ((args.Unnamed.Count == 0 && args.Count == 0) || args.Contains("?") || args.Contains("help"))
					return DoHelp();

				try
				{
                    string major = null, minor = null, build = null, revision = null;
				    string version;
                    if(args.TryGetValue("version", out version))
                    {
                        string[] dotted = version.Split('.');
                        major = dotted[0];
                        minor = dotted.Length >= 1 ? dotted[1] : null;
                        build = dotted.Length >= 2 ? dotted[2] : null;
                        revision = dotted.Length >= 3 ? dotted[3] : null;
                    }

				    major = GetNumber("Major", args, major);
					minor = GetNumber("Minor", args, minor);
					build = GetNumber("Build", args, build);
					revision = GetNumber("Revision", args, revision);

					if (major == null && minor == null && build == null && revision == null)
						return DoHelp();

				    string fileversion = args.SafeGet("fileversion");

					FileList files = new FileList(@"AssemblyInfo.cs");

					Regex versionPattern = new Regex(@"[^a-z,A-Z,0-9](?<Type>AssemblyVersion|AssemblyFileVersion)\s*\(\s*\" + '\"' +
						@"(?<Version>[0-2]?[0-9]{1,9}\.[0-2]?[0-9]{1,9}(?:(?:\.[0-2]?[0-9]{1,9}(?:(?:\.[0-2]?[0-9]{1,9})|(?:\.\*))?)|(?:\.\*))?)\" + '\"' +
						@"\s*\)");

					foreach (FileInfo file in files.ToArray())
					{
						StringBuilder content = new StringBuilder();
						int lastpos = 0;
						string text = File.ReadAllText(file.FullName);
						foreach (Match match in versionPattern.Matches(text))
						{
							Group verMatch = match.Groups["Version"];
							content.Append(text, lastpos, verMatch.Index - lastpos);
							lastpos = verMatch.Index + verMatch.Length;

							string[] parts = verMatch.Value.Split('.');
							if( parts.Length < 2 )//regex should prevent us getting here
								throw new ApplicationException(String.Format("Bad version string: {0} on line {1}", verMatch.Value, content.ToString().Split('\n').Length));
							if (parts.Length < 3)
								parts = new string[] { parts[0], parts[1], "0" };
							else if( parts.Length == 3 && parts[2] == "*" )
								parts = new string[] { parts[0], parts[1], "0", "*" };
							if (parts.Length == 3 && revision != null)
								parts = new string[] { parts[0], parts[1], parts[2], "0" };
							if( build != null && build == "*" )
								parts = new string[] { parts[0], parts[1], "*" };

							if (major != null && parts.Length > 0)
								parts[0] = major;
							if (minor != null && parts.Length > 1)
								parts[1] = minor;
							if (build != null && parts.Length > 2)
								parts[2] = build;
							if (revision != null && parts.Length > 3)
								parts[3] = revision;

							//AssemblyFileVersion doesn't use '*', so trim off the build and/or revision
							if (match.Groups["Type"].Value == "AssemblyFileVersion")
							{
								if (parts.Length >= 4 && parts[3] == "*")
									parts = new string[] { parts[0], parts[1], parts[2] };
								if (parts.Length >= 3 && parts[2] == "*")
									parts = new string[] { parts[0], parts[1] };

							    if (!String.IsNullOrEmpty(fileversion))
							    {
							        parts = fileversion.Split('.');
							    }
							}

							string newVersion = String.Join(".", parts);
							//Console.WriteLine("Changed '{0}' to '{1}'", verMatch.Value, newVersion);
							content.Append(newVersion);
						}
						content.Append(text, lastpos, text.Length - lastpos);

					    if ((file.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
					        file.Attributes = file.Attributes & ~FileAttributes.ReadOnly;
                            
						File.WriteAllText(file.FullName, content.ToString());
					}
				}
				catch (ApplicationException ae)
				{
					Log.Error(ae);
					Console.Error.WriteLine();
					Console.Error.WriteLine(ae.Message);
					Environment.ExitCode = -1;
				}
				catch (Exception e)
				{
					Log.Error(e);
					Console.Error.WriteLine();
					Console.Error.WriteLine(e.ToString());
					Environment.ExitCode = -1;
				}
			}

			if (args.Contains("wait"))
			{
				Console.WriteLine();
				Console.WriteLine("Press [Enter] to continue...");
				Console.ReadLine();
			}

			return Environment.ExitCode;
		}
示例#2
0
        public void Testv2()
        {
            DirectoryInfo root = new DirectoryInfo(BaseDirectory);

            FileList files = new FileList();
            files.AddRange(root.GetFiles("*", SearchOption.AllDirectories));
            Assert.AreEqual(7, files.Count);

            FileList txtFiles = new FileList(root.GetFiles("*.txt", SearchOption.AllDirectories));
            Assert.AreEqual(3, txtFiles.Count);
            Assert.IsTrue(files.Contains(txtFiles[0]));
            Assert.IsTrue(files.Contains(txtFiles[1]));
            Assert.IsTrue(files.Contains(txtFiles[2]));

            files.Remove(txtFiles.ToArray());
            Assert.AreEqual(4, files.Count);
            Assert.IsFalse(files.Contains(txtFiles[0]));
            Assert.IsFalse(files.Contains(txtFiles[1]));

            string[] names = files.GetFileNames();
            Assert.AreEqual(4, names.Length);
            foreach(string fpath in names)
                Assert.IsTrue(files.Contains(new FileInfo(fpath)));
        }
示例#3
0
		public void Test()
		{
			FileList files = new FileList(BaseDirectory);
			Assert.AreEqual(3, files.Count);

			files = new FileList(Path.Combine(BaseDirectory, "file?.*"));
			Assert.AreEqual(3, files.Count);

			files = new FileList();
			files.Add(BaseDirectory);
			Assert.AreEqual(3, files.Count);

			files = new FileList(0, BaseDirectory);
			Assert.AreEqual(0, (int)files.ProhibitedAttributes);
			Assert.AreEqual(7, files.Count);

			files = new FileList();
			files.IgnoreFolderAttributes = true;
			Assert.IsTrue(files.IgnoreFolderAttributes);
			files.Add(BaseDirectory);
			Assert.AreEqual(7, files.Count);

			files = new FileList();
			files.RecurseFolders = false;
			Assert.IsFalse(files.RecurseFolders);
			files.Add(BaseDirectory);
			Assert.AreEqual(1, files.Count);

			files = new FileList();
			files.IgnoreFolderAttributes = true;
			files.FileFound += new EventHandler<FileList.FileFoundEventArgs>(
				delegate(object sender, FileList.FileFoundEventArgs e) { if(e.File.Extension != ".ini") e.Ignore = true; } );
			files.Add(BaseDirectory);
			Assert.AreEqual(new FileList(0, Path.Combine(BaseDirectory, "*.ini")).Count, files.Count);
			Assert.AreEqual(".ini", files[0].Extension);

			files = new FileList();
			files.ProhibitedAttributes = FileAttributes.Hidden;
			files.Add(BaseDirectory);
			Assert.AreEqual(3, files.Count);

			files = new FileList();
			files.ProhibitedAttributes = FileAttributes.ReadOnly;
			files.Add(BaseDirectory);
			Assert.AreEqual(5, files.Count);
			files.Add(Path.Combine(BaseDirectory, "file1.txt"));
			Assert.AreEqual(5, files.Count);
			Assert.AreEqual(5, files.ToArray().Length);

			string restoredDir = Environment.CurrentDirectory;
			try
			{
				Environment.CurrentDirectory = BaseDirectory;
				files = new FileList();
				files.ProhibitedAttributes = FileAttributes.ReadOnly;
				files.Add(".");
				Assert.AreEqual(5, files.Count);
				files.Add("file1.txt");
				Assert.AreEqual(5, files.Count);
				Assert.AreEqual(5, files.ToArray().Length);
			}
			finally { Environment.CurrentDirectory = restoredDir; }

			files = new FileList(Path.Combine(BaseDirectory, "*.none"));
			Assert.AreEqual(0, files.Count);//nothing matching wildcard - does not throw FileNotFound
		}
		static int Main(string[] raw)
        {
            String temp;
		    bool wait = ArgumentList.Remove(ref raw, "wait", out temp);
            bool addMissing = ArgumentList.Remove(ref raw, "add-missing", out temp);

            try
		    {
		        var entryAssembly = Assembly.GetEntryAssembly();
		        if (entryAssembly != null && !ArgumentList.Remove(ref raw, "nologo", out temp))
		        {
		            var aname = entryAssembly.GetName();
		            aname.CultureInfo = null;
		            Console.WriteLine("{0}", aname);
		            foreach (
		                AssemblyCopyrightAttribute a in
		                    entryAssembly.GetCustomAttributes(typeof (AssemblyCopyrightAttribute), false))
		                Console.WriteLine("{0}", a.Copyright);
		            Console.WriteLine();
		        }

		        if (ArgumentList.Remove(ref raw, "verbose", out temp) || ArgumentList.Remove(ref raw, "verbosity", out temp))
		        {
		            SourceLevels traceLevel;
		            try
		            {
		                traceLevel = (SourceLevels) Enum.Parse(typeof (SourceLevels), temp);
		            }
		            catch
		            {
		                traceLevel = SourceLevels.All;
		            }

		            Trace.Listeners.Add(new ConsoleTraceListener()
		            {
		                Filter = new EventTypeFilter(traceLevel),
		                IndentLevel = 0,
		                TraceOutputOptions = TraceOptions.None
		            });
		        }

		        var argsList = new List<string>();
		        foreach (string arg in raw)
		        {
		            if (arg.StartsWith("@"))
		            {
		                foreach (var line in File.ReadAllLines(arg.Substring(1)))
		                {
		                    if (!String.IsNullOrEmpty(line) && line.Trim().Length > 0)
		                        argsList.Add(line.Trim());
		                }
		            }
		            else
		            {
		                argsList.Add(arg);
		            }
		        }

		        raw = argsList.ToArray();
		        if (ArgumentList.Remove(ref raw, "?", out temp) || ArgumentList.Remove(ref raw, "help", out temp))
		            return DoHelp();

                var args = new ArgumentList(StringComparer.Ordinal, raw);
		        if (args.Unnamed.Count == 0 || args.Count == 0)
		            return DoHelp();

		        var files = new FileList();
		        files.ProhibitedAttributes = FileAttributes.Hidden | FileAttributes.System;
		        files.RecurseFolders = true;
		        files.FileFound +=
		            delegate(object sender, FileList.FileFoundEventArgs eventArgs)
		            {
		                eventArgs.Ignore = !eventArgs.File.Name.StartsWith("AssemblyInfo");
		            };

		        foreach (var arg in args.Unnamed)
		            files.Add(arg);

		        var processor = new AssemblyFileProcessor(args, addMissing);
		        foreach (FileInfo file in files.ToArray())
		        {
		            processor.ProcessFile(file);
		        }
		    }
		    catch (ApplicationException ae)
		    {
		        Trace.TraceError("{0}", ae);
		        Console.Error.WriteLine();
		        Console.Error.WriteLine(ae.Message);
		        Environment.ExitCode = -1;
		    }
		    catch (Exception e)
		    {
		        Trace.TraceError("{0}", e);
		        Console.Error.WriteLine();
		        Console.Error.WriteLine(e.ToString());
		        Environment.ExitCode = -1;
		    }
		    finally
		    {
		        if (wait)
		        {
		            Console.WriteLine();
		            Console.WriteLine("Press [Enter] to continue...");
		            Console.ReadLine();
		        }
		    }
		    return Environment.ExitCode;
		}