+ DateTimeCode (#91)

Author: ig-sinicyn

Build/T4/DebugCodeGenerator.ttinclude

@@ -4,9 +4,6 @@
 
 	private void Run()
 	{
-		WriteLine(@"using static CodeJam.DebugCode;");
-		WriteLine("");
-
 		const string message =
 			"The name of the template should follow the pattern 'Debug' + AssertionFile + '.tt'. " +
 			"The name of the assertion class should be suffixed with 'Code'. " +
@@ -21,8 +18,19 @@
 		}
 
 		var oldClassName = newClassName.Substring("Debug".Length);
-		Transform(
+		Run(
 			oldClassName + ".cs",
+			oldClassName,
+			newClassName);
+	}
+
+	private void Run(string fileName, string oldClassName, string newClassName)
+	{
+		WriteLine(@"using static CodeJam.DebugCode;");
+		WriteLine("");
+
+		Transform(
+			fileName,
 			new ReplaceInfo // Rename the class (add Debug prefix to the name)
 			{
 				Pattern = "class " + oldClassName,

Build/T4/Transform.ttinclude

@@ -10,17 +10,24 @@
 		Normal, Swap, Ignore
 	}
 
+	internal enum MatchMode
+	{
+		Normal, WholeWord, WholeLine
+	}
+
 	internal class ReplaceInfo
 	{
 		public string Pattern { get; set; }
 		public string Replacement { get; set; }
 		public bool ThrowOnFail { get; set; }
-		public bool WholeWord { get; set; }
 		public bool EscapePattern { get; set; }
-		public ReplaceMode Mode { get; set; }
+		public ReplaceMode Replace { get; set; }
+		public MatchMode Match { get; set; }
 
-		public bool SwapMode => Mode == ReplaceMode.Swap;
-		public bool IgnoreMode => Mode == ReplaceMode.Ignore;
+		public bool SwapMode => Replace == ReplaceMode.Swap;
+		public bool IgnoreMode => Replace == ReplaceMode.Ignore;
+		public bool WholeWordMode => Match == MatchMode.WholeWord;
+		public bool WholeLineMode => Match == MatchMode.WholeLine;
 	}
 
 	// ReSharper disable UnusedMember.Local
@@ -43,15 +50,10 @@
 		var placeholderReplaces = new ConcurrentDictionary<string, string>();
 		Func<string, ReplaceInfo, string> replaceWithPlaceholdersCore = (text, replaceInfo) =>
 		{
-			var pattern = replaceInfo.SwapMode ? replaceInfo.Replacement : replaceInfo.Pattern;
+			var pattern = PreparePattern(
+				replaceInfo.SwapMode ? replaceInfo.Replacement : replaceInfo.Pattern,
+				replaceInfo);
 			var replacement = replaceInfo.SwapMode ? replaceInfo.Pattern : null;
-			if (replaceInfo.SwapMode || replaceInfo.EscapePattern)
-			{
-				pattern = Regex.Escape(pattern);
-			}
-			pattern = replaceInfo.WholeWord
-				? @"(?<=\W|^)" +  pattern + @"(?=\W|$)"
-				: pattern;
 
 			var newText = Regex.Replace(
 				text,
@@ -66,16 +68,11 @@
 
 		Func<string, ReplaceInfo, string> replaceCore = (text, replaceInfo) =>
 		{
-			var pattern = replaceInfo.Pattern;
-			if (replaceInfo.SwapMode || replaceInfo.EscapePattern)
-			{
-				pattern = Regex.Escape(pattern);
-			}
-			pattern = replaceInfo.WholeWord
-				? @"(?<=\W|^)" +  pattern + @"(?=\W|$)"
-				: pattern;
-
-			var newText = Regex.Replace(text, pattern, replaceInfo.Replacement);
+			var pattern = PreparePattern(replaceInfo.Pattern, replaceInfo);
+			var replacement = replaceInfo.Replacement;
+
+			var newText = Regex.Replace(text, pattern, replacement);
+
 			if (replaceInfo.ThrowOnFail && newText == text)
 				throw new InvalidOperationException("The match for " + pattern + " not found");
 
@@ -104,4 +101,22 @@
 
 		Write(sourceText);
 	}
+
+	private string PreparePattern(string pattern, ReplaceInfo replaceInfo)
+	{
+		if (replaceInfo.SwapMode || replaceInfo.EscapePattern)
+		{
+			pattern = Regex.Escape(pattern);
+		}
+
+		pattern = replaceInfo.WholeWordMode
+			? @"(?<=\W|^)" + pattern + @"(?=\W|$)"
+			: pattern;
+
+		pattern = replaceInfo.WholeLineMode
+			? @".*" +  pattern + @".*[\r\n]+"
+			: pattern;
+
+		return pattern;
+	}
 #>

CodeJam.Main.Tests/Dates/DateTimeCodeTests.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+using NUnit.Framework;
+
+namespace CodeJam.Dates
+{
+	[TestFixture(Category = "Assertions")]
+	[SuppressMessage("ReSharper", "NotResolvedInText")]
+	public class DateTimeCodeTests
+	{
+		[Test]
+		public void TestDateOnlyAssertion()
+		{
+			var dateTimeNow = DateTime.Now;
+			var dateTimeOffsetNow = DateTimeOffset.Now;
+
+			var ex = Assert.Throws<ArgumentException>(() => DateTimeCode.DateOnly(dateTimeNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a date without time component"));
+
+			ex = Assert.Throws<ArgumentException>(() => DateTimeCode.DateOnly(dateTimeOffsetNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a date without time component"));
+
+			Assert.DoesNotThrow(() => DateTimeCode.DateOnly(dateTimeNow.Date, "arg00"));
+			Assert.DoesNotThrow(() => DateTimeCode.DateOnly(dateTimeOffsetNow.Date, "arg00"));
+		}
+
+		[Test]
+		public void TestDebugDateOnlyAssertion()
+		{
+			var dateTimeNow = DateTime.Now;
+			var dateTimeOffsetNow = DateTimeOffset.Now;
+#if DEBUG
+			var ex = Assert.Throws<ArgumentException>(() => DebugDateTimeCode.DateOnly(dateTimeNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a date without time component"));
+
+			ex = Assert.Throws<ArgumentException>(() => DebugDateTimeCode.DateOnly(dateTimeOffsetNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a date without time component"));
+#else
+			// ReSharper disable once InvocationIsSkipped
+			Assert.DoesNotThrow(() => DebugDateTimeCode.DateOnly(dateTimeNow, "arg00"));
+			Assert.DoesNotThrow(() => DebugDateTimeCode.DateOnly(dateTimeOffsetNow, "arg00"));
+#endif
+
+			// ReSharper disable once InvocationIsSkipped
+			Assert.DoesNotThrow(() => DebugDateTimeCode.DateOnly(dateTimeNow.Date, "arg00"));
+		}
+
+
+		[Test]
+		public void TestIsUtcAssertion()
+		{
+			var dateTimeNow = DateTime.Now;
+			var dateTimeOffsetNow = DateTimeOffset.Now.ToOffset(TimeSpan.FromHours(1));
+
+			var ex = Assert.Throws<ArgumentException>(() => DateTimeCode.IsUtc(dateTimeNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be in UTC"));
+
+			ex = Assert.Throws<ArgumentException>(() => DateTimeCode.IsUtc(dateTimeOffsetNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be in UTC"));
+
+			Assert.DoesNotThrow(() => DateTimeCode.IsUtc(dateTimeNow.ToUniversalTime(), "arg00"));
+			Assert.DoesNotThrow(() => DateTimeCode.IsUtc(dateTimeOffsetNow.ToUniversalTime(), "arg00"));
+		}
+
+		[Test]
+		public void TestIsUtcAndDateOnlyAssertion()
+		{
+			var dateTimeNow = DateTime.Now;
+			var dateTimeOffsetNow = DateTimeOffset.Now.ToOffset(TimeSpan.FromHours(1));
+
+			var ex = Assert.Throws<ArgumentException>(() => DateTimeCode.IsUtcAndDateOnly(dateTimeNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be in UTC"));
+
+			ex = Assert.Throws<ArgumentException>(() => DateTimeCode.IsUtcAndDateOnly(dateTimeOffsetNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be in UTC"));
+
+			ex = Assert.Throws<ArgumentException>(() => DateTimeCode.IsUtcAndDateOnly(dateTimeNow.ToUniversalTime(), "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a date without time component"));
+
+			ex = Assert.Throws<ArgumentException>(() => DateTimeCode.IsUtcAndDateOnly(dateTimeOffsetNow.ToUniversalTime(), "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a date without time component"));
+
+			Assert.DoesNotThrow(() => DateTimeCode.IsUtcAndDateOnly(dateTimeNow.ToUniversalTime().Date, "arg00"));
+			Assert.DoesNotThrow(() => DateTimeCode.IsUtcAndDateOnly(dateTimeOffsetNow.ToUniversalTime().TruncateTime(), "arg00"));
+		}
+
+		[Test]
+		public void TestFirstDayOfMonth()
+		{
+			var dateTimeNow = DateTime.Now;
+			var dateTimeOffsetNow = DateTimeOffset.Now;
+
+			var ex = Assert.Throws<ArgumentException>(() => DateTimeCode.FirstDayOfMonth(dateTimeNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a first day of month"));
+
+			ex = Assert.Throws<ArgumentException>(() => DateTimeCode.FirstDayOfMonth(dateTimeOffsetNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a first day of month"));
+
+			Assert.DoesNotThrow(() => DateTimeCode.DateOnly(dateTimeNow.Date.FirstDayOfMonth(), "arg00"));
+			Assert.DoesNotThrow(() => DateTimeCode.DateOnly(dateTimeOffsetNow.Date.FirstDayOfMonth(), "arg00"));
+		}
+
+		[Test]
+		public void TestFirstDayOfYear()
+		{
+			var dateTimeNow = DateTime.Now;
+			var dateTimeOffsetNow = DateTimeOffset.Now;
+
+			var ex = Assert.Throws<ArgumentException>(() => DateTimeCode.FirstDayOfYear(dateTimeNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a first day of year"));
+
+			ex = Assert.Throws<ArgumentException>(() => DateTimeCode.FirstDayOfYear(dateTimeOffsetNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a first day of year"));
+
+			Assert.DoesNotThrow(() => DateTimeCode.DateOnly(dateTimeNow.Date.FirstDayOfYear(), "arg00"));
+			Assert.DoesNotThrow(() => DateTimeCode.DateOnly(dateTimeOffsetNow.Date.FirstDayOfYear(), "arg00"));
+		}
+
+		[Test]
+		public void TestLastDayOfMonth()
+		{
+			var dateTimeNow = DateTime.Now;
+			var dateTimeOffsetNow = DateTimeOffset.Now;
+
+			var ex = Assert.Throws<ArgumentException>(() => DateTimeCode.LastDayOfMonth(dateTimeNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a last day of month"));
+
+			ex = Assert.Throws<ArgumentException>(() => DateTimeCode.LastDayOfMonth(dateTimeOffsetNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a last day of month"));
+
+			Assert.DoesNotThrow(() => DateTimeCode.DateOnly(dateTimeNow.Date.LastDayOfMonth(), "arg00"));
+			Assert.DoesNotThrow(() => DateTimeCode.DateOnly(dateTimeOffsetNow.Date.LastDayOfMonth(), "arg00"));
+		}
+
+		[Test]
+		public void TestLastDayOfYear()
+		{
+			var dateTimeNow = DateTime.Now;
+			var dateTimeOffsetNow = DateTimeOffset.Now;
+
+			var ex = Assert.Throws<ArgumentException>(() => DateTimeCode.LastDayOfYear(dateTimeNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a last day of year"));
+
+			ex = Assert.Throws<ArgumentException>(() => DateTimeCode.LastDayOfYear(dateTimeOffsetNow, "arg00"));
+			Assert.That(ex.Message, Does.Contain("arg00"));
+			Assert.That(ex.Message, Does.Contain("argument should be a last day of year"));
+
+			Assert.DoesNotThrow(() => DateTimeCode.DateOnly(dateTimeNow.Date.LastDayOfYear(), "arg00"));
+			Assert.DoesNotThrow(() => DateTimeCode.DateOnly(dateTimeOffsetNow.Date.LastDayOfYear(), "arg00"));
+		}
+	}
+}

CodeJam.Main.Tests/Dates/DateTimeExtensionsTests.cs

@@ -36,6 +36,25 @@ public static void TestDateTimeExtensions()
 			AreEqual(d.GetYearRange().CountOfDays(), d.DaysInYear());
 		}
 
+		[Test]
+		public static void TestIsUtc()
+		{
+			var now = DateTimeOffset.Now.ToOffset(TimeSpan.FromHours(1));
+			var utcNow = DateTimeOffset.UtcNow;
+			IsFalse(now.IsUtc());
+			IsTrue(utcNow.IsUtc());
+			IsTrue(now.ToUniversalTime().IsUtc());
+		}
+
+		[Test]
+		public static void TestTruncateTime()
+		{
+			var now = DateTimeOffset.Now.ToOffset(TimeSpan.FromHours(1));
+			var utcNow = DateTimeOffset.UtcNow;
+			AreEqual(now.TruncateTime(), now - now.TimeOfDay);
+			AreEqual(utcNow.TruncateTime(), utcNow - utcNow.TimeOfDay);
+		}
+
 		[Test]
 		public static void TestDateTimeOffsetExtensions()
 		{

CodeJam.Main/Assertions/CodeExceptions.cs

@@ -22,7 +22,7 @@ public static ArgumentNullException ArgumentNull([NotNull, InvokerParameterName]
 			return new ArgumentNullException(argumentName).LogToCodeTraceSourceBeforeThrow();
 		}
 
-		/// <summary>Creates <see cref="ArgumentNullException"/>.</summary>
+		/// <summary>Creates <see cref="ArgumentException"/> for null collection item.</summary>
 		/// <param name="argumentName">Name of the argument.</param>
 		/// <returns>Initialized instance of <see cref="ArgumentException"/>.</returns>
 		[DebuggerHidden, NotNull, MustUseReturnValue]