Issue #101: Draft for precision-based calculator

src/Humanizer.Tests/AmbientCulture.cs

@@ -6,11 +6,11 @@ namespace Humanizer.Tests
 {
     public class AmbientCulture : IDisposable
     {
-        private readonly CultureInfo _culture;
+        private readonly CultureInfo _callerCulture;
 
         public AmbientCulture(CultureInfo culture)
         {
-            _culture = Thread.CurrentThread.CurrentUICulture;
+            _callerCulture = Thread.CurrentThread.CurrentUICulture;
             Thread.CurrentThread.CurrentCulture = culture;
             Thread.CurrentThread.CurrentUICulture = culture;
         }
@@ -22,7 +22,8 @@ public AmbientCulture(string cultureName)
 
         public void Dispose()
         {
-            Thread.CurrentThread.CurrentUICulture = _culture;
+            Thread.CurrentThread.CurrentCulture = _callerCulture;
+            Thread.CurrentThread.CurrentUICulture = _callerCulture;
         }
     }
 }

src/Humanizer.Tests/ApiApprover/PublicApiApprovalTest.approve_public_api.approved.txt

@@ -65,6 +65,8 @@ public class CasingExtensions
 
 public class Configurator
 {
+    public double DefaultPrecision { get; }
+    public Humanizer.DistanceOfTimeCalculators.IDistanceOfTimeInWords DistanceOfTimeInWords { get; set; }
     public Humanizer.Localisation.IFormatter Formatter { get; }
 }
 
@@ -73,6 +75,33 @@ public class DateHumanizeExtensions
     public string Humanize(System.DateTime input, bool utcDate, System.Nullable<System.DateTime> dateToCompareAgainst) { }
 }
 
+public class DefaultDistanceOfTime
+{
+    public DefaultDistanceOfTime() { }
+    public string Calculate(System.DateTime date1, System.DateTime date2) { }
+}
+
+public class DistanceOfTime
+{
+    public DistanceOfTime() { }
+    public int Count { get; set; }
+    public Humanizer.Localisation.TimeStructure Structure { get; set; }
+    public Humanizer.Localisation.TimeUnitTense Tense { get; set; }
+    public Humanizer.Localisation.TimeUnit Unit { get; set; }
+    public Humanizer.DistanceOfTimeCalculators.DistanceOfTime Create(Humanizer.Localisation.TimeUnit timeUnit, Humanizer.Localisation.TimeUnitTense timeUnitTense, Humanizer.Localisation.TimeStructure timeStructure, int count) { }
+}
+
+public interface IDistanceOfTimeInWords
+{
+    string Calculate(System.DateTime date1, System.DateTime date2);
+}
+
+public class PrecisionBasedDistanceOfTime
+{
+    public PrecisionBasedDistanceOfTime() { }
+    public string Calculate(System.DateTime date1, System.DateTime date2) { }
+}
+
 public class EnumDehumanizeExtensions
 {
     public TTargetEnum DehumanizeTo(string input) { }
@@ -151,6 +180,7 @@ public class DefaultFormatter
     public DefaultFormatter() { }
     public string DateHumanize(Humanizer.Localisation.TimeUnit timeUnit, Humanizer.Localisation.TimeUnitTense timeUnitTense, int unit) { }
     public string DateHumanize_Now() { }
+    public string Humanize(Humanizer.DistanceOfTimeCalculators.DistanceOfTime distanceOfTime) { }
     public string TimeSpanHumanize(Humanizer.Localisation.TimeUnit timeUnit, int unit) { }
     public string TimeSpanHumanize_Zero() { }
 }
@@ -159,6 +189,7 @@ public interface IFormatter
 {
     string DateHumanize(Humanizer.Localisation.TimeUnit timeUnit, Humanizer.Localisation.TimeUnitTense timeUnitTense, int unit);
     string DateHumanize_Now();
+    string Humanize(Humanizer.DistanceOfTimeCalculators.DistanceOfTime timeUnit);
     string TimeSpanHumanize(Humanizer.Localisation.TimeUnit timeUnit, int unit);
     string TimeSpanHumanize_Zero();
 }
@@ -173,6 +204,13 @@ public class Resources
     public string GetResource(string resourceKey) { }
 }
 
+public enum TimeStructure
+{
+    DateTime,
+    TimeSpan,
+    value__,
+}
+
 public enum TimeUnit
 {
     Day,

src/Humanizer.Tests/DateHumanizeTests.cs

@@ -4,33 +4,8 @@
 
 namespace Humanizer.Tests
 {
-    public class DateHumanizeTests
+    public class DateHumanizeTests : DateHumanizeTestsBase
     {
-        static void VerifyWithCurrentDate(string expectedString, TimeSpan deltaFromNow)
-        {
-            var utcNow = DateTime.UtcNow;
-            var localNow = DateTime.Now;
-
-            // feels like the only way to avoid breaking tests because CPU ticks over is to inject the base date
-            Assert.Equal(expectedString, utcNow.Add(deltaFromNow).Humanize(utcDate: true, dateToCompareAgainst: utcNow));
-            Assert.Equal(expectedString, localNow.Add(deltaFromNow).Humanize(utcDate: false, dateToCompareAgainst: localNow));
-        }
-
-        static void VerifyWithDateInjection(string expectedString, TimeSpan deltaFromNow)
-        {
-            var utcNow = new DateTime(2013, 6, 20, 9, 58, 22, DateTimeKind.Utc);
-            var now = new DateTime(2013, 6, 20, 11, 58, 22, DateTimeKind.Local);
-
-            Assert.Equal(expectedString, utcNow.Add(deltaFromNow).Humanize(dateToCompareAgainst: utcNow));
-            Assert.Equal(expectedString, now.Add(deltaFromNow).Humanize(false, now));
-        }
-
-        static void Verify(string expectedString, TimeSpan deltaFromNow)
-        {
-            VerifyWithCurrentDate(expectedString, deltaFromNow);
-            VerifyWithDateInjection(expectedString, deltaFromNow);
-        }
-
         [Fact]
         public void OneSecondFromNow()
         {

src/Humanizer.Tests/DateHumanizeTestsBase.cs

@@ -0,0 +1,43 @@
+using System;
+using Humanizer.Configuration;
+using Humanizer.DistanceOfTimeCalculators;
+using Xunit;
+
+namespace Humanizer.Tests
+{
+    public abstract class DateHumanizeTestsBase : IDisposable
+    {
+        private readonly IDistanceOfTimeInWords previousCalculator;
+
+        protected DateHumanizeTestsBase()
+        {
+            previousCalculator = Configurator.DistanceOfTimeInWords;
+        }
+
+        public void Dispose()
+        {
+            Configurator.DistanceOfTimeInWords = previousCalculator;
+        }
+
+        protected static void Verify(string expectedString, TimeSpan deltaFromNow)
+        {
+            VerifyWithCurrentDate(expectedString, deltaFromNow);
+            VerifyWithDateInjection(expectedString, deltaFromNow);
+        }
+
+        private static void VerifyWithCurrentDate(string expectedString, TimeSpan deltaFromNow)
+        {
+            Assert.Equal(expectedString, DateTime.UtcNow.Add(deltaFromNow).Humanize());
+            Assert.Equal(expectedString, DateTime.Now.Add(deltaFromNow).Humanize(false));
+        }
+
+        private static void VerifyWithDateInjection(string expectedString, TimeSpan deltaFromNow)
+        {
+            var utcNow = new DateTime(2013, 6, 20, 9, 58, 22, DateTimeKind.Utc);
+            var now = new DateTime(2013, 6, 20, 11, 58, 22, DateTimeKind.Local);
+
+            Assert.Equal(expectedString, utcNow.Add(deltaFromNow).Humanize(dateToCompareAgainst: utcNow));
+            Assert.Equal(expectedString, now.Add(deltaFromNow).Humanize(false, now));
+        }
+    }
+}

src/Humanizer.Tests/DistanceOfTimeCalculators/DefaultPrecisionBoundaries.cs

@@ -0,0 +1,99 @@
+using System;
+using Humanizer.DistanceOfTimeCalculators;
+using Humanizer.Localisation;
+using Xunit;
+
+namespace Humanizer.Tests.DistanceOfTimeCalculators
+{
+    public class DefaultPrecisionBoundaries
+    {
+        readonly PrecisionBasedDistanceOfTime _calculator = new PrecisionBasedDistanceOfTime();
+
+        private readonly string justNow = GetJustNow();
+        private readonly string secondFromNow = GetResource(TimeUnit.Second, 1);
+        private readonly string minuteFromNow = GetResource(TimeUnit.Minute, 1);
+        private readonly string hourFromNow = GetResource(TimeUnit.Hour, 1);
+        private readonly string dayFromNow = GetResource(TimeUnit.Day, 1);
+        private readonly string monthFromNow = GetResource(TimeUnit.Month, 1);
+        private readonly string yearFromNow = GetResource(TimeUnit.Year, 1);
+
+        [Fact]
+        public void MillisecondsBorder()
+        {
+            const int millisecondsBoder = 750;
+            VerifyBorder(TimeSpan.FromMilliseconds, millisecondsBoder, justNow, secondFromNow);
+        }
+
+        [Fact]
+        public void FourtyFiveSecondsBorder()
+        {
+            const int secondsBorder = 45;
+            VerifyBorder(TimeSpan.FromSeconds, secondsBorder,
+                GetResource(TimeUnit.Second, secondsBorder - 1),
+                minuteFromNow);
+        }
+
+        [Fact]
+        public void FourtyFiveMinutesBorder()
+        {
+            const int minutesBorder = 45;
+            VerifyBorder(TimeSpan.FromMinutes, minutesBorder,
+                GetResource(TimeUnit.Minute, minutesBorder - 1),
+                hourFromNow);
+        }
+
+        [Fact]
+        public void EighteenHoursBorder()
+        {
+            const int hoursBorder = 18;
+            VerifyBorder(TimeSpan.FromHours, 18,
+                GetResource(TimeUnit.Hour, hoursBorder - 1),
+                dayFromNow);
+        }
+
+        [Fact]
+        public void TwentyThreeDaysBorder()
+        {
+            const int monthBorderInDays = 23;
+            VerifyBorder(TimeSpan.FromDays, monthBorderInDays,
+                GetResource(TimeUnit.Day, monthBorderInDays - 1),
+                monthFromNow);
+        }
+
+        [Fact]
+        public void TwoHundredAndFourDaysBorder()
+        {
+            const int yearBorderInDays = 274;
+            VerifyBorder(TimeSpan.FromDays, yearBorderInDays,
+                GetResource(TimeUnit.Month, 9),
+                yearFromNow);
+        }
+
+        private void VerifyBorder(Func<double, TimeSpan> timeSpanFunc, int border, string beforeBorder, string afterBorder)
+        {
+            var date = DateTime.UtcNow;
+            var date1 = date.Add(timeSpanFunc(border - 1));
+            var date2 = date.Add(timeSpanFunc(border));
+            var date3 = date.Add(timeSpanFunc(border + 1));
+
+            var actual1 = _calculator.Calculate(date1, date);
+            var actual2 = _calculator.Calculate(date2, date);
+            var actual3 = _calculator.Calculate(date3, date);
+
+            Assert.Equal(beforeBorder, actual1);
+            Assert.Equal(afterBorder, actual2);
+            Assert.Equal(afterBorder, actual3);
+        }
+
+        private static string GetResource(TimeUnit timeUnit, int count)
+        {
+            string resourceKey = ResourceKeys.DateHumanize.GetResourceKey(timeUnit, TimeUnitTense.Future, count);
+            return Resources.GetResource(resourceKey).FormatWith(count);
+        }
+
+        private static string GetJustNow()
+        {
+            return Resources.GetResource(ResourceKeys.DateHumanize.Now);
+        }
+    }
+}