Support for include/exclude as arrays on terms aggregation

Closes #1430

Author: gmarz

src/Nest/DSL/Aggregations/TermsAggregationDescriptor.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using Nest.Resolvers.Converters;
 using Newtonsoft.Json;
@@ -152,12 +153,25 @@ public TermsAggregationDescriptor<T> Include(string includePattern, string regex
 			Self.Include = new TermsIncludeExclude() { Pattern = includePattern, Flags = regexFlags };
 			return this;
 		}
+
+		public TermsAggregationDescriptor<T> Include(IEnumerable<string> values)
+		{
+			Self.Include = new TermsIncludeExclude { Values = values };
+			return this;
+		}
 
 		public TermsAggregationDescriptor<T> Exclude(string excludePattern, string regexFlags = null)
 		{
 			Self.Exclude = new TermsIncludeExclude() { Pattern = excludePattern, Flags = regexFlags };
 			return this;
 		}
+
+		public TermsAggregationDescriptor<T> Exclude(IEnumerable<string> values)
+		{
+			Self.Exclude = new TermsIncludeExclude { Values = values };
+			return this;
+		}
+
 		public TermsAggregationDescriptor<T> CollectMode(TermsAggregationCollectMode collectMode)
 		{
 			Self.CollectMode = collectMode;

src/Nest/Domain/Aggregations/TermsIncludeExclude.cs

@@ -1,12 +1,19 @@
+using Nest.Resolvers.Converters;
 using Newtonsoft.Json;
+using System.Collections.Generic;
 
 namespace Nest
 {
+	[JsonConverter(typeof(TermsIncludeExcludeConverter))]
 	public class TermsIncludeExclude
 	{
 		[JsonProperty("pattern")]
 		public string Pattern { get; set; }
+		
 		[JsonProperty("flags")]
 		public string Flags { get; set; }
+		
+		[JsonIgnore]
+		public IEnumerable<string> Values { get; set; }
 	}
 }

src/Nest/Nest.csproj

@@ -993,6 +993,7 @@
     <Compile Include="Resolvers\Converters\DynamicMappingOptionConverter.cs" />
     <Compile Include="Resolvers\Converters\DictionaryKeysAreNotPropertyNamesJsonConverter.cs" />
     <Compile Include="Resolvers\Converters\IndexNameMarkerConverter.cs" />
+    <Compile Include="Resolvers\Converters\TermsIncludeExcludeConverter.cs" />
     <Compile Include="Resolvers\Converters\TokenFilterCollectionConverter.cs" />
     <Compile Include="Resolvers\Converters\TokenizerCollectionConverter.cs" />
     <Compile Include="Resolvers\Converters\TypeNameMarkerConverter.cs" />

src/Nest/Resolvers/Converters/TermsIncludeExcludeConverter.cs

@@ -0,0 +1,45 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest.Resolvers.Converters
+{
+	public class TermsIncludeExcludeConverter : JsonConverter
+	{
+		public override bool CanConvert(Type objectType)
+		{
+			return (objectType == typeof(TermsIncludeExcludeConverter));
+		}
+
+		public override bool CanRead { get { return false; } }
+
+		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+		{
+			var termsIncludeExclude = value as TermsIncludeExclude;
+
+			if (termsIncludeExclude.Values != null)
+			{
+				serializer.Serialize(writer, termsIncludeExclude.Values);
+			}
+			else
+			{
+				writer.WriteStartObject();
+				writer.WritePropertyName("pattern");
+				writer.WriteValue(termsIncludeExclude.Pattern);
+				if (!termsIncludeExclude.Flags.IsNullOrEmpty())
+				{
+					writer.WritePropertyName("flags");
+					writer.WriteValue(termsIncludeExclude.Flags);
+				}
+				writer.WriteEndObject();
+			}
+		}
+	}
+}

src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj

@@ -420,7 +420,7 @@
     <Compile Include="Reproduce\Reproduce926Tests.cs" />
     <Compile Include="Search\Aggregations\ScriptedMetricJson.cs" />
     <Compile Include="Search\Aggregations\SingleBucketAggregationTests.cs" />
-    <Compile Include="Search\Aggregations\Terms\TermAggregationTests.cs" />
+    <Compile Include="Search\Aggregations\Terms\TermsAggregationTests.cs" />
     <Compile Include="Search\Failures\ShardFailureTests.cs" />
     <Compile Include="Search\Fields\FieldsTests.cs" />
     <Compile Include="Search\Filter\Modes\ConditionlessFilterJson.cs" />
@@ -857,7 +857,7 @@
     <None Include="Reproduce\PatchedTermsAggSort.json">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
-    <None Include="Search\Aggregations\Terms\TermAggregationSerializes.json">
+    <None Include="Search\Aggregations\Terms\TermsAggregationSerializes.json">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
     <None Include="Search\Failures\ShardFailuresResult.json">

src/Tests/Nest.Tests.Unit/Search/Aggregations/Terms/TermAggregationTests.cs

@@ -0,0 +1,64 @@
+using System.Reflection;
+using Nest.Tests.MockData.Domain;
+using NUnit.Framework;
+
+namespace Nest.Tests.Unit.Search.Aggregations.Terms
+{
+	[TestFixture]
+	public class TermsAggregationTests : BaseJsonTests
+	{
+		[Test]
+		public void TermsAggregationSerializes()
+		{
+			var s = new TermsAggregationDescriptor<ElasticsearchProject>()
+				.CollectMode(TermsAggregationCollectMode.BreadthFirst)
+				.ExecutionHint(TermsAggregationExecutionHint.GlobalOrdinalsLowCardinality)
+				.Field(p => p.Country)
+				.MinimumDocumentCount(1)
+				.OrderAscending("_count");
+
+			this.JsonEquals(s, MethodBase.GetCurrentMethod());
+		}
+
+		[Test]
+		public void TermsAggregation_IncludeExclude_Array_Serializes()
+		{
+			var s = new TermsAggregationDescriptor<ElasticsearchProject>()
+				.Field(p => p.Name)
+				.Include(new[] { "value1", "value2" })
+				.Exclude(new[] { "value3" });
+
+			var expected = @"{
+				field: ""name"",
+				include: [ ""value1"", ""value2"" ],
+				exclude: [ ""value3"" ]
+			}";
+
+			var actual = TestElasticClient.Serialize(s);
+			Assert.True(actual.JsonEquals(expected));
+		}
+
+		[Test]
+		public void TermsAggregation_IncludeExclude_Pattern_Serializes()
+		{
+			var s = new TermsAggregationDescriptor<ElasticsearchProject>()
+				.Field(p => p.Name)
+				.Include("elastic*", "CANON_EQ|CASE_INSENSITIVE")
+				.Exclude("nest*");
+
+			var expected = @"{
+				field: ""name"",
+				include: {
+					pattern: ""elastic*"",
+					flags: ""CANON_EQ|CASE_INSENSITIVE""
+				},
+				exclude: {
+					pattern: ""nest*""
+				}
+			}";
+
+			var actual = TestElasticClient.Serialize(s);
+			Assert.True(actual.JsonEquals(expected));
+		}
+	}
+}