Add field_masking_span query (#2241)

Forward port of #2231

Author: russcam

docs/query-dsl-usage.asciidoc

@@ -86,6 +86,8 @@ include::query-dsl/nest-specific/raw/raw-query-usage.asciidoc[]
 
 include::query-dsl/span/container/span-containing-query-usage.asciidoc[]
 
+include::query-dsl/span/field-masking/span-field-masking-usage.asciidoc[]
+
 include::query-dsl/span/first/span-first-query-usage.asciidoc[]
 
 include::query-dsl/span/multi-term/span-multi-term-query-usage.asciidoc[]

docs/query-dsl.asciidoc

@@ -93,6 +93,8 @@ NEST exposes all of the query DSL endpoints available in Elasticsearch
 
 * <<span-containing-query-usage,Span Containing Query Usage>>
 
+* <<span-field-masking-usage,Span Field Masking Usage>>
+
 * <<span-first-query-usage,Span First Query Usage>>
 
 * <<span-multi-term-query-usage,Span Multi Term Query Usage>>

docs/query-dsl/span/field-masking/span-field-masking-usage.asciidoc

@@ -0,0 +1,71 @@
+:ref_current: https://www.elastic.co/guide/en/elasticsearch/reference/2.3
+
+:github: https://github.com/elastic/elasticsearch-net
+
+:nuget: https://www.nuget.org/packages
+
+////
+IMPORTANT NOTE
+==============
+This file has been generated from https://github.com/elastic/elasticsearch-net/tree/2.x/src/Tests/QueryDsl/Span/FieldMasking/SpanFieldMaskingUsageTests.cs. 
+If you wish to submit a PR for any spelling mistakes, typos or grammatical errors for this file,
+please modify the original csharp file found at the link and submit the PR with that change. Thanks!
+////
+
+[[span-field-masking-usage]]
+== Span Field Masking Usage
+
+=== Fluent DSL Example
+
+[source,csharp]
+----
+q
+.SpanFieldMasking(c => c
+    .Name("named_query")
+    .Boost(1.1)
+    .Field(p => p.Name)
+    .Query(sq=>sq
+        .SpanTerm(st=>st.Field(p=>p.Description).Value("dolorem"))
+    )
+)
+----
+
+=== Object Initializer Syntax Example
+
+[source,csharp]
+----
+new SpanFieldMaskingQuery
+{
+    Name = "named_query",
+    Boost = 1.1,
+    Field = Infer.Field<Project>(p => p.Name),
+    Query = new SpanQuery
+    {
+        SpanTerm = new SpanTermQuery
+        {
+            Field = Infer.Field<Project>(p => p.Description),
+            Value = "dolorem"
+        }
+    }
+}
+----
+
+[source,javascript]
+.Example json output
+----
+{
+  "field_masking_span": {
+    "_name": "named_query",
+    "boost": 1.1,
+    "field": "name",
+    "query": {
+      "span_term": {
+        "description": {
+          "value": "dolorem"
+        }
+      }
+    }
+  }
+}
+----
+

src/Nest/Nest.csproj

@@ -1024,6 +1024,7 @@
     <Compile Include="QueryDsl\Operator.cs" />
     <Compile Include="QueryDsl\Query.cs" />
     <Compile Include="QueryDsl\Span\Containing\SpanContainingQuery.cs" />
+    <Compile Include="QueryDsl\Span\FieldMasking\SpanFieldMaskingQuery.cs" />
     <Compile Include="QueryDsl\Span\First\SpanFirstQuery.cs" />
     <Compile Include="QueryDsl\Span\ISpanSubQuery.cs" />
     <Compile Include="QueryDsl\Span\MultiTerm\SpanMultiTermQuery.cs" />

src/Nest/QueryDsl/Abstractions/Container/IQueryContainer.cs

@@ -111,6 +111,9 @@ public interface IQueryContainer
 		[JsonProperty("span_multi")]
 		ISpanMultiTermQuery SpanMultiTerm { get; set; }
 
+		[JsonProperty("field_masking_span")]
+		ISpanFieldMaskingQuery SpanFieldMasking { get; set; }
+
 		[JsonProperty("nested")]
 		INestedQuery Nested { get; set; }
 

src/Nest/QueryDsl/Abstractions/Container/QueryContainer-Assignments.cs

@@ -43,6 +43,7 @@ public partial class QueryContainer : IQueryContainer, IDescriptor
 		private ISpanContainingQuery _spanContaining;
 		private ISpanWithinQuery _spanWithin;
 		private ISpanMultiTermQuery _spanMultiTerm;
+		private ISpanFieldMaskingQuery _spanFieldMasking;
 		private INestedQuery _nested;
 		private IIndicesQuery _indices;
 		private IFunctionScoreQuery _functionScore;
@@ -109,6 +110,7 @@ private T Set<T>(T value) where T : IQuery
 		ISpanContainingQuery IQueryContainer.SpanContaining { get { return _spanContaining; } set { _spanContaining = Set(value); } }
 		ISpanWithinQuery IQueryContainer.SpanWithin { get { return _spanWithin; } set { _spanWithin = Set(value); } }
 		ISpanMultiTermQuery IQueryContainer.SpanMultiTerm { get { return _spanMultiTerm; } set { _spanMultiTerm = Set(value); } }
+		ISpanFieldMaskingQuery IQueryContainer.SpanFieldMasking { get { return _spanFieldMasking; } set { _spanFieldMasking = Set(value); } }
 		INestedQuery IQueryContainer.Nested { get { return _nested; } set { _nested = Set(value); } }
 		IIndicesQuery IQueryContainer.Indices { get { return _indices; } set { _indices = Set(value); } }
 		IFunctionScoreQuery IQueryContainer.FunctionScore { get { return _functionScore; } set { _functionScore = Set(value); } }
@@ -122,8 +124,5 @@ private T Set<T>(T value) where T : IQuery
 		IExistsQuery IQueryContainer.Exists { get { return _exists; } set { _exists = Set(value); } }
 		IMissingQuery IQueryContainer.Missing { get { return _missing; } set { _missing = Set(value); } }
 		ITypeQuery IQueryContainer.Type { get { return _type; } set { _type = Set(value); } }
-
-
 	}
-
 }

src/Nest/QueryDsl/Abstractions/Container/QueryContainerDescriptor.cs

@@ -475,6 +475,15 @@ public QueryContainer SpanContaining(Func<SpanContainingQueryDescriptor<T>, ISpa
 		public QueryContainer SpanWithin(Func<SpanWithinQueryDescriptor<T>, ISpanWithinQuery> selector) =>
 			WrapInContainer(selector, (query, container) => container.SpanWithin = query);
 
+		/// <summary>
+		/// Wraps span queries to allow them to participate in composite single-field Span queries by 'lying' about their search field.
+		/// That is, the masked span query will function as normal, but the field points back to the set field of the query.
+		/// This can be used to support queries like SpanNearQuery or SpanOrQuery across different fields,
+		/// which is not ordinarily permitted.
+		/// </summary>
+		public QueryContainer SpanFieldMasking(Func<SpanFieldMaskingQueryDescriptor<T>, ISpanFieldMaskingQuery> selector) =>
+			WrapInContainer(selector, (query, container) => container.SpanFieldMasking = query);
+
 		/// <summary>
 		/// custom_score query allows to wrap another query and customize the scoring of it optionally with a
 		/// computation derived from other field values in the doc (numeric ones) using script or boost expression

src/Nest/QueryDsl/Query.cs

@@ -1,11 +1,8 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
 using System.Linq.Expressions;
 
 namespace Nest
 {
-	// TODO: Write a unit test for these using reflection to make sure all queries are covered
 	public static class Query<T> where T : class
 	{
 		public static QueryContainer Bool(Func<BoolQueryDescriptor<T>, IBoolQuery> selector) =>
@@ -161,8 +158,11 @@ public static QueryContainer SpanTerm(Func<SpanTermQueryDescriptor<T>, ISpanTerm
 		public static QueryContainer SpanWithin(Func<SpanWithinQueryDescriptor<T>, ISpanWithinQuery> selector) =>
 			new QueryContainerDescriptor<T>().SpanWithin(selector);
 
+		public static QueryContainer SpanFieldMasking(Func<SpanFieldMaskingQueryDescriptor<T>, ISpanFieldMaskingQuery> selector) =>
+			new QueryContainerDescriptor<T>().SpanFieldMasking(selector);
+
 #pragma warning disable 618
-		[Obsolete("Scheduled to be removed in 5.0.  Setting Strict() at the container level does is a noop and must be set on each individual query.")]
+		[Obsolete("Scheduled to be removed in 5.0.  Setting Strict() at the container level is a noop and must be set on each individual query.")]
 		public static QueryContainerDescriptor<T> Strict(bool strict = true) =>
 			new QueryContainerDescriptor<T>().Strict(strict);
 #pragma warning restore 618

src/Nest/QueryDsl/Span/FieldMasking/SpanFieldMaskingQuery.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	[JsonConverter(typeof(ReadAsTypeJsonConverter<SpanFieldMaskingQueryDescriptor<object>>))]
+	public interface ISpanFieldMaskingQuery : ISpanSubQuery
+	{
+		[JsonProperty("field")]
+		Field Field { get; set; }
+
+		[JsonProperty("query")]
+		ISpanQuery Query { get; set; }
+	}
+
+	public class SpanFieldMaskingQuery : QueryBase, ISpanFieldMaskingQuery
+	{
+		protected override bool Conditionless => IsConditionless(this);
+		public ISpanQuery Query { get; set; }
+		public Field Field { get; set; }
+
+		internal override void InternalWrapInContainer(IQueryContainer c) => c.SpanFieldMasking = this;
+		internal static bool IsConditionless(ISpanFieldMaskingQuery q) =>
+			q.Field.IsConditionless() || q.Query == null || q.Query.Conditionless;
+	}
+
+	public class SpanFieldMaskingQueryDescriptor<T>
+		: QueryDescriptorBase<SpanFieldMaskingQueryDescriptor<T>, ISpanFieldMaskingQuery>
+		, ISpanFieldMaskingQuery where T : class
+	{
+		protected override bool Conditionless => SpanFieldMaskingQuery.IsConditionless(this);
+		ISpanQuery ISpanFieldMaskingQuery.Query { get; set; }
+		Field ISpanFieldMaskingQuery.Field { get; set; }
+
+		public SpanFieldMaskingQueryDescriptor<T> Field(Field field) => Assign(a => a.Field = field);
+
+		public SpanFieldMaskingQueryDescriptor<T> Field(Expression<Func<T, object>> objectPath) =>
+			Assign(a => a.Field = objectPath);
+
+		public SpanFieldMaskingQueryDescriptor<T> Query(Func<SpanQueryDescriptor<T>, ISpanQuery> selector) =>
+			Assign(a => a.Query = selector?.Invoke(new SpanQueryDescriptor<T>()));
+	}
+}

src/Nest/QueryDsl/Span/SpanQuery.cs

@@ -8,30 +8,33 @@ namespace Nest
 	[JsonConverter(typeof(ReadAsTypeJsonConverter<SpanQueryDescriptor<object>>))]
 	public interface ISpanQuery : IQuery
 	{
-		[JsonProperty(PropertyName = "span_term")]
+		[JsonProperty("span_term")]
 		ISpanTermQuery SpanTerm { get; set; }
 
-		[JsonProperty(PropertyName = "span_first")]
+		[JsonProperty("span_first")]
 		ISpanFirstQuery SpanFirst { get; set; }
 
-		[JsonProperty(PropertyName = "span_near")]
+		[JsonProperty("span_near")]
 		ISpanNearQuery SpanNear { get; set; }
 
-		[JsonProperty(PropertyName = "span_or")]
+		[JsonProperty("span_or")]
 		ISpanOrQuery SpanOr { get; set; }
 
-		[JsonProperty(PropertyName = "span_not")]
+		[JsonProperty("span_not")]
 		ISpanNotQuery SpanNot { get; set; }
 
-		[JsonProperty(PropertyName = "span_containing")]
+		[JsonProperty("span_containing")]
 		ISpanContainingQuery SpanContaining { get; set; }
 
-		[JsonProperty(PropertyName = "span_within")]
+		[JsonProperty("span_within")]
 		ISpanWithinQuery SpanWithin { get; set; }
 
-		[JsonProperty(PropertyName = "span_multi")]
+		[JsonProperty("span_multi")]
 		ISpanMultiTermQuery SpanMultiTerm { get; set; }
 
+		[JsonProperty("field_masking_span")]
+		ISpanFieldMaskingQuery SpanFieldMasking { get; set; }
+
 		void Accept(IQueryVisitor visitor);
 	}
 
@@ -52,6 +55,8 @@ public class SpanQuery : ISpanQuery
 		public ISpanMultiTermQuery SpanMultiTerm { get; set; }
 		public ISpanContainingQuery SpanContaining{ get; set; }
 		public ISpanWithinQuery SpanWithin { get; set; }
+		public ISpanFieldMaskingQuery SpanFieldMasking { get; set; }
+
 		public void Accept(IQueryVisitor visitor) => new QueryWalker().Walk(this, visitor);
 
 		internal static bool IsConditionless(ISpanQuery q) => new[]
@@ -61,7 +66,8 @@ internal static bool IsConditionless(ISpanQuery q) => new[]
 			q.SpanNear,
 			q.SpanOr ,
 			q.SpanNot,
-			q.SpanMultiTerm
+			q.SpanMultiTerm,
+			q.SpanFieldMasking
 		}.All(sq => sq == null || sq.Conditionless);
 	}
 
@@ -77,6 +83,7 @@ public class SpanQueryDescriptor<T> : QueryDescriptorBase<SpanQueryDescriptor<T>
 		ISpanMultiTermQuery ISpanQuery.SpanMultiTerm { get; set; }
 		ISpanContainingQuery ISpanQuery.SpanContaining{ get; set; }
 		ISpanWithinQuery ISpanQuery.SpanWithin { get; set; }
+		ISpanFieldMaskingQuery ISpanQuery.SpanFieldMasking { get; set; }
 
 		public SpanQueryDescriptor<T> SpanTerm(Func<SpanTermQueryDescriptor<T>, ISpanTermQuery> selector) =>
 			Assign(a => a.SpanTerm = selector?.Invoke(new SpanTermQueryDescriptor<T>()));
@@ -102,6 +109,9 @@ public SpanQueryDescriptor<T> SpanContaining(Func<SpanContainingQueryDescriptor<
 		public SpanQueryDescriptor<T> SpanWithin(Func<SpanWithinQueryDescriptor<T>, ISpanWithinQuery> selector) =>
 			Assign(a => a.SpanWithin = selector?.Invoke(new SpanWithinQueryDescriptor<T>()));
 
+		public SpanQueryDescriptor<T> SpanFieldMasking(Func<SpanFieldMaskingQueryDescriptor<T>, ISpanFieldMaskingQuery> selector) =>
+			Assign(a => a.SpanFieldMasking = selector?.Invoke(new SpanFieldMaskingQueryDescriptor<T>()));
+
 		void ISpanQuery.Accept(IQueryVisitor visitor) => new QueryWalker().Walk(this, visitor);
 
 	}