fix #741 missing minimum_should_match on match queries

Author: Mpdreamz

Diff for: src/Nest/DSL/Query/MatchPhrasePrefixQueryDescriptor.cs

@@ -2,9 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-using System.Linq.Expressions;
 
 namespace Nest
 {

Diff for: src/Nest/DSL/Query/MatchQueryDescriptor.cs

@@ -50,6 +50,9 @@ public interface IMatchQuery : IFieldNameQuery
 		[JsonProperty(PropertyName = "lenient")]
 		bool? Lenient { get; set; }
 
+		[JsonProperty("minimum_should_match")]
+		string MinimumShouldMatch { get; set; }
+
 		[JsonProperty(PropertyName = "operator")]
 		[JsonConverter(typeof (StringEnumConverter))]
 		Operator? Operator { get; set; }
@@ -86,6 +89,7 @@ void IFieldNameQuery.SetFieldName(string fieldName)
 		public int? Slop { get; set; }
 		public double? Boost { get; set; }
 		public bool? Lenient { get; set; }
+		public string MinimumShouldMatch { get; set; }
 		public Operator? Operator { get; set; }
 		public PropertyPathMarker Field { get; set; }
 	}
@@ -96,12 +100,16 @@ public class MatchQueryDescriptor<T> : IMatchQuery where T : class
 	{
 		protected virtual string _type { get { return null; } }
 
+		private IMatchQuery Self { get { return this; } }
+
 		string IMatchQuery.Type { get { return _type; } }
 
 		string IMatchQuery.Query { get; set; }
 
 		string IMatchQuery.Analyzer { get; set; }
 
+		string IMatchQuery.MinimumShouldMatch { get; set; }
+
 		RewriteMultiTerm? IMatchQuery.Rewrite { get; set; }
 
 		double? IMatchQuery.Fuzziness { get; set; }
@@ -126,85 +134,101 @@ bool IQuery.IsConditionless
 		{
 			get
 			{
-				return ((IMatchQuery)this).Field.IsConditionless() || ((IMatchQuery)this).Query.IsNullOrEmpty();
+				return Self.Field.IsConditionless() || Self.Query.IsNullOrEmpty();
 			}
 		}
 		void IFieldNameQuery.SetFieldName(string fieldName)
 		{
-			((IMatchQuery)this).Field = fieldName;
+			Self.Field = fieldName;
 		}
 		PropertyPathMarker IFieldNameQuery.GetFieldName()
 		{
-			return ((IMatchQuery)this).Field;
+			return Self.Field;
 		}
 
 		public MatchQueryDescriptor<T> OnField(string field)
 		{
-			((IMatchQuery)this).Field = field;
+			Self.Field = field;
 			return this;
 		}
+
 		public MatchQueryDescriptor<T> OnField(Expression<Func<T, object>> objectPath)
 		{
-			((IMatchQuery)this).Field = objectPath;
+			Self.Field = objectPath;
 			return this;
 		}
 
 		public MatchQueryDescriptor<T> Query(string query)
 		{
-			((IMatchQuery)this).Query = query;
+			Self.Query = query;
 			return this;
 		}
+	
 		public MatchQueryDescriptor<T> Lenient(bool lenient = true)
 		{
-			((IMatchQuery)this).Lenient = lenient;
+			Self.Lenient = lenient;
 			return this;
 		}
+		
 		public MatchQueryDescriptor<T> Analyzer(string analyzer)
 		{
-			((IMatchQuery)this).Analyzer = analyzer;
+			Self.Analyzer = analyzer;
 			return this;
 		}
+		
 		public MatchQueryDescriptor<T> Fuzziness(double fuzziness)
 		{
-			((IMatchQuery)this).Fuzziness = fuzziness;
+			Self.Fuzziness = fuzziness;
 			return this;
 		}
+		
 		public MatchQueryDescriptor<T> CutoffFrequency(double cutoffFrequency)
 		{
-			((IMatchQuery)this).CutoffFrequency = cutoffFrequency;
+			Self.CutoffFrequency = cutoffFrequency;
 			return this;
 		}
 
 		public MatchQueryDescriptor<T> Rewrite(RewriteMultiTerm rewrite)
 		{
-			((IMatchQuery)this).Rewrite = rewrite;
+			Self.Rewrite = rewrite;
 			return this;
 		}
 
 		public MatchQueryDescriptor<T> Boost(double boost)
 		{
-			((IMatchQuery)this).Boost = boost;
+			Self.Boost = boost;
 			return this;
 		}
+		
 		public MatchQueryDescriptor<T> PrefixLength(int prefixLength)
 		{
-			((IMatchQuery)this).PrefixLength = prefixLength;
+			Self.PrefixLength = prefixLength;
 			return this;
 		}
+		
 		public MatchQueryDescriptor<T> MaxExpansions(int maxExpansions)
 		{
-			((IMatchQuery)this).MaxExpansions = maxExpansions;
+			Self.MaxExpansions = maxExpansions;
 			return this;
 		}
+		
 		public MatchQueryDescriptor<T> Slop(int slop)
 		{
-			((IMatchQuery)this).Slop = slop;
+			Self.Slop = slop;
+			return this;
+		}
+		
+		public MatchQueryDescriptor<T> MinimumShouldMatch(string minimumShouldMatch)
+		{
+			Self.MinimumShouldMatch = minimumShouldMatch;
 			return this;
 		}
+	
 		public MatchQueryDescriptor<T> Operator(Operator op)
 		{
-			((IMatchQuery)this).Operator = op;
+			Self.Operator = op;
 			return this;
 		}
+	
 	}
 }