Merge branch 'fix/1880'

Author: gmarz

src/Nest/CommonAbstractions/Extensions/Extensions.cs

@@ -72,7 +72,7 @@ internal static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> items, Fu
 		}
 
 		internal static ConcurrentDictionary<string, object> _enumCache = new ConcurrentDictionary<string, object>();
-		internal static T? ToEnum<T>(this string str) where T : struct
+		internal static T? ToEnum<T>(this string str, StringComparison comparison = StringComparison.OrdinalIgnoreCase) where T : struct
 		{
 			var enumType = typeof(T);
 			var key = $"{enumType.Name}.{str}";
@@ -82,7 +82,7 @@ internal static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> items, Fu
 
 			foreach (var name in Enum.GetNames(enumType))
 			{
-				if (name.Equals(str, StringComparison.OrdinalIgnoreCase))
+				if (name.Equals(str, comparison))
 				{
 					var v = (T)Enum.Parse(enumType, name, true);
 					_enumCache.TryAdd(key, v);
@@ -99,7 +99,6 @@ internal static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> items, Fu
 				}
 
 				var alternativeEnumMemberAttribute = enumFieldInfo.GetCustomAttribute<AlternativeEnumMemberAttribute>();
-
 				if (alternativeEnumMemberAttribute?.Value == str)
 				{
 					var v = (T) Enum.Parse(enumType, name);

src/Nest/CommonOptions/DateMath/DateMath.cs

@@ -71,7 +71,7 @@ public static DateMath FromString(string dateMath)
 
 			if (match.Groups["rounding"].Success)
 			{
-				var rounding = match.Groups["rounding"].Value.Substring(1).ToEnum<TimeUnit>();
+				var rounding = match.Groups["rounding"].Value.Substring(1).ToEnum<TimeUnit>(StringComparison.Ordinal);
 				if (rounding.HasValue)
 					return math.RoundTo(rounding.Value);
 			}

src/Nest/CommonOptions/TimeUnit/Time.cs

@@ -8,9 +8,10 @@ namespace Nest
 	[JsonConverter(typeof(TimeJsonConverter))]
 	public class Time : IComparable<Time>, IEquatable<Time>
 	{
-		private static readonly Regex _expressionRegex = new Regex(@"^(?<factor>\d+(?:\.\d+)?)(?<interval>(?:y|M|w|d|h|m|s|ms))?$", RegexOptions.Compiled | RegexOptions.ExplicitCapture);
+		private static readonly Regex _expressionRegex = new Regex(@"^(?<factor>[-+]?\d+(?:\.\d+)?)(?<interval>(?:y|M|w|d|h|m|s|ms))?$", RegexOptions.Compiled | RegexOptions.ExplicitCapture);
 
-		private static readonly double _year = TimeSpan.FromDays(365).TotalMilliseconds;
+		private static readonly double _yearApproximate = TimeSpan.FromDays(365).TotalMilliseconds;
+		private static readonly double _monthApproximate = TimeSpan.FromDays(30).TotalMilliseconds;
 		private static readonly double _week = TimeSpan.FromDays(7).TotalMilliseconds;
 		private static readonly double _day = TimeSpan.FromDays(1).TotalMilliseconds;
 		private static readonly double _hour = TimeSpan.FromHours(1).TotalMilliseconds;
@@ -19,33 +20,15 @@ public class Time : IComparable<Time>, IEquatable<Time>
 
 		public double? Factor { get; private set; }
 		public TimeUnit? Interval { get; private set; }
+
+		// TODO make nullable in 3.0
 		public double Milliseconds { get; private set; }
+		private double ApproximateMilliseconds { get; set; }
 
 		public static implicit operator Time(TimeSpan span) => new Time(span);
 		public static implicit operator Time(double milliseconds) => new Time(milliseconds);
 		public static implicit operator Time(string expression) => new Time(expression);
 
-		public Time(double factor, TimeUnit interval)
-		{
-			this.Factor = factor;
-			this.Interval = interval;
-
-			if (interval == TimeUnit.Year)
-				Milliseconds = (long)factor * _year;
-			else if (interval == TimeUnit.Week)
-				Milliseconds = (long)factor * _week;
-			else if (interval == TimeUnit.Day)
-				Milliseconds = (long)factor * _day;
-			else if (interval == TimeUnit.Hour)
-				Milliseconds = (long)factor * _hour;
-			else if (interval == TimeUnit.Minute)
-				Milliseconds = (long)factor * _minute;
-			else if (interval == TimeUnit.Second)
-				Milliseconds = (long)factor * _second;
-			else //ms
-				Milliseconds = (long)factor;
-		}
-
 		public Time(TimeSpan timeSpan)
 		{
 			Reduce(timeSpan.TotalMilliseconds);
@@ -56,38 +39,36 @@ public Time(double milliseconds)
 			Reduce(milliseconds);
 		}
 
+		public Time(double factor, TimeUnit interval)
+		{
+			this.Factor = factor;
+			this.Interval = interval;
+			SetMilliseconds(this.Interval, this.Factor.Value);
+		}
+
 		public Time(string timeUnit)
 		{
 			if (timeUnit.IsNullOrEmpty()) throw new ArgumentException("Time expression string is empty", nameof(timeUnit));
 			var match = _expressionRegex.Match(timeUnit);
 			if (!match.Success) throw new ArgumentException($"Time expression '{timeUnit}' string is invalid", nameof(timeUnit));
 
 			this.Factor = double.Parse(match.Groups["factor"].Value, CultureInfo.InvariantCulture);
-			this.Interval = match.Groups["interval"].Success
-				? match.Groups["interval"].Value.ToEnum<TimeUnit>()
-				: TimeUnit.Millisecond;
-
-			if (this.Interval == TimeUnit.Year)
-				Milliseconds = (long)(this.Factor * _year);
-			else if (this.Interval == TimeUnit.Week)
-				Milliseconds = (long)(this.Factor * _week);
-			else if (this.Interval == TimeUnit.Day)
-				Milliseconds = (long)(this.Factor * _day);
-			else if (this.Interval == TimeUnit.Hour)
-				Milliseconds = (long)(this.Factor * _hour);
-			else if (this.Interval == TimeUnit.Minute)
-				Milliseconds = (long)(this.Factor * _minute);
-			else if (this.Interval == TimeUnit.Second)
-				Milliseconds = (long)(this.Factor * _second);
-			else //ms
-				Milliseconds = (long)this.Factor;
+
+			if (this.Factor > 0)
+			{
+				this.Interval = match.Groups["interval"].Success
+					? match.Groups["interval"].Value.ToEnum<TimeUnit>(StringComparison.Ordinal)
+					: TimeUnit.Millisecond;
+			}
+
+			SetMilliseconds(this.Interval, this.Factor.Value);
 		}
 
 		public int CompareTo(Time other)
 		{
 			if (other == null) return 1;
-			if (this.Milliseconds == other.Milliseconds) return 0;
-			if (this.Milliseconds < other.Milliseconds) return -1;
+			if (this.ApproximateMilliseconds == other.ApproximateMilliseconds) return 0;
+			if (this.ApproximateMilliseconds < other.ApproximateMilliseconds) return -1;
 			return 1;
 		}
 
@@ -115,7 +96,7 @@ public bool Equals(Time other)
 		{
 			if (ReferenceEquals(null, other)) return false;
 			if (ReferenceEquals(this, other)) return true;
-			return Milliseconds == other.Milliseconds;
+			return (this.ApproximateMilliseconds == other.ApproximateMilliseconds);
 		}
 
 		public override bool Equals(object obj)
@@ -126,18 +107,57 @@ public override bool Equals(object obj)
 			return Equals((Time)obj);
 		}
 
-		public override int GetHashCode() => this.Milliseconds.GetHashCode();
+		public override int GetHashCode() => this.ApproximateMilliseconds.GetHashCode();
 
-		private void Reduce(double ms)
+		private void SetMilliseconds(TimeUnit? interval, double factor)
 		{
-			this.Milliseconds = ms;
+			this.Milliseconds = interval.HasValue ? GetExactMilliseconds(interval.Value, factor) : factor;
+			this.ApproximateMilliseconds = interval.HasValue ? GetApproximateMilliseconds(interval.Value, factor) : factor;
+		}
 
-			if (ms >= _year)
+		private double GetExactMilliseconds(TimeUnit interval, double factor)
+		{
+			switch (interval)
 			{
-				Factor = ms / _year;
-				Interval = TimeUnit.Year;
+
+				case TimeUnit.Week:
+					return factor * _week;
+				case TimeUnit.Day:
+					return factor * _day;
+				case TimeUnit.Hour:
+					return factor * _hour;
+				case TimeUnit.Minute:
+					return factor * _minute;
+				case TimeUnit.Second:
+					return factor * _second;
+				case TimeUnit.Year:
+				case TimeUnit.Month:
+					// Cannot calculate exact milliseconds for non-fixed intervals
+					return -1;
+				default: // ms
+					return factor;
 			}
-			else if (ms >= _week)
+		}
+
+		private double GetApproximateMilliseconds(TimeUnit interval, double factor)
+		{
+			switch (interval)
+			{
+				case TimeUnit.Year:
+					return factor * _yearApproximate;
+				case TimeUnit.Month:
+					return factor * _monthApproximate;
+				default:
+					return GetExactMilliseconds(interval, factor);
+			}
+		}
+
+		private void Reduce(double ms)
+		{
+			this.Milliseconds = ms;
+			this.ApproximateMilliseconds = ms;
+
+			if (ms >= _week)
 			{
 				Factor = ms / _week;
 				Interval = TimeUnit.Week;
@@ -165,10 +185,9 @@ private void Reduce(double ms)
 			else
 			{
 				Factor = ms;
-				// If milliseconds is < 0 then don't set an interval.
+				// If milliseconds is <= 0 then don't set an interval.
 				// This is used when setting things like index.refresh_interval = -1 (the only case where a unit isn't required)
-				if (ms > 0)
-					Interval = TimeUnit.Millisecond;
+				Interval = (ms > 0) ? (TimeUnit?)TimeUnit.Millisecond : null;
 			}
 		}
 	}

src/Tests/CommonOptions/TimeUnit/TimeUnits.doc.cs

@@ -69,13 +69,20 @@ public void EqualityAndComparable()
 			Time oneAndHalfYear = "1.5y";
 			Time twoWeeks = TimeSpan.FromDays(14);
 			Time twoDays = 1000*60*60*24*2;
-
+	
 			/**
 			* Milliseconds are calculated even when values are not passed as long
 			*/
-			oneAndHalfYear.Milliseconds.Should().BeGreaterThan(1);
 			twoWeeks.Milliseconds.Should().BeGreaterThan(1);
 
+			/**
+			* Except when dealing with years or months, whose millsecond value cannot
+			* be calculated *accurately*, since they are not fixed durations. For instance,
+			* 30 vs 31 vs 28 days in a month, or 366 vs 365 days in a year.
+			* In this instance, Milliseconds will be -1.
+			*/
+			oneAndHalfYear.Milliseconds.Should().Be(-1);
+
 			/**
 			* This allows you to do comparisons on the expressions
 			*/
@@ -96,6 +103,8 @@ public void EqualityAndComparable()
 			(twoDays == new Time("2d")).Should().BeTrue();
 			(twoDays != new Time("2.1d")).Should().BeTrue();
 			(new Time("2.1d") == new Time(TimeSpan.FromDays(2.1))).Should().BeTrue();
+			(new Time("1") == new Time(1)).Should().BeTrue();
+			(new Time("-1") == new Time(-1)).Should().BeTrue();
 		}
 
 		[U]
@@ -117,5 +126,80 @@ public void UsingInterval()
 			Expect("2d").WhenSerializing<Union<DateInterval, Time>>((Time)"2d");
 			Expect("1.16w").WhenSerializing<Union<DateInterval, Time>>((Time)TimeSpan.FromDays(8.1));
 		}
+
+		[U]
+		public void MillisecondsNeverSerializeToMonthsOrYears()
+		{
+			double millisecondsInAMonth = 2592000000;
+			Expect("4.29w").WhenSerializing(new Time(millisecondsInAMonth));
+			Expect("8.57w").WhenSerializing(new Time(millisecondsInAMonth * 2));
+			Expect("51.43w").WhenSerializing(new Time(millisecondsInAMonth * 12));
+			Expect("102.86w").WhenSerializing(new Time(millisecondsInAMonth * 24));
+		}
+
+		[U]
+		public void ExpectedValues()
+		{
+			Expect("-1").WhenSerializing(new Time(-1));
+			Expect("-1").WhenSerializing(new Time("-1"));
+
+			Assert(
+				1, Nest.TimeUnit.Year, -1, "1y",
+				new Time(1, Nest.TimeUnit.Year),
+				new Time("1y")
+			);
+
+			Assert(
+				1, Nest.TimeUnit.Month, -1, "1M",
+				new Time(1, Nest.TimeUnit.Month),
+				new Time("1M")
+			);
+
+			Assert(
+				1, Nest.TimeUnit.Week, TimeSpan.FromDays(7).TotalMilliseconds, "1w",
+				new Time(1, Nest.TimeUnit.Week),
+				new Time("1w"),
+				new Time(TimeSpan.FromDays(7).TotalMilliseconds)
+			);
+
+			Assert(
+				1, Nest.TimeUnit.Day, TimeSpan.FromDays(1).TotalMilliseconds, "1d",
+				new Time(1, Nest.TimeUnit.Day),
+				new Time("1d"),
+				new Time(TimeSpan.FromDays(1).TotalMilliseconds)
+			);
+
+			Assert(
+				1, Nest.TimeUnit.Hour, TimeSpan.FromHours(1).TotalMilliseconds, "1h",
+				new Time(1, Nest.TimeUnit.Hour),
+				new Time("1h"),
+				new Time(TimeSpan.FromHours(1).TotalMilliseconds)
+			);
+
+			Assert(
+				1, Nest.TimeUnit.Minute, TimeSpan.FromMinutes(1).TotalMilliseconds, "1m",
+				new Time(1, Nest.TimeUnit.Minute),
+				new Time("1m"),
+				new Time(TimeSpan.FromMinutes(1).TotalMilliseconds)
+			);
+
+			Assert(
+				1, Nest.TimeUnit.Second, TimeSpan.FromSeconds(1).TotalMilliseconds, "1s",
+				new Time(1, Nest.TimeUnit.Second),
+				new Time("1s"),
+				new Time(TimeSpan.FromSeconds(1).TotalMilliseconds)
+			);
+		}
+
+		private void Assert(double expectedFactor, Nest.TimeUnit expectedInterval, double expectedMilliseconds, string expectedSerialized, params Time[] times)
+		{
+			foreach (var time in times)
+			{
+				time.Factor.Should().Be(expectedFactor);
+				time.Interval.Should().Be(expectedInterval);
+				time.Milliseconds.Should().Be(expectedMilliseconds);
+				Expect(expectedSerialized).WhenSerializing(time);
+			}
+		}
 	}
 }

src/Tests/tests.yaml

@@ -1,5 +1,5 @@
 # mode either u (unit test), i (integration test) or m (mixed mode)
-mode: m
+mode: u
 # the elasticsearch version that should be started
 elasticsearch_version: 2.2.0
 # whether we want to forcefully reseed on the node, if you are starting the tests with a node already running