Add Circle processor (#4161)

* Implement circle processor.
* Make parameters nullable.

(cherry picked from commit a1b5c7e)

Author: codebrain

src/Nest/Ingest/ProcessorFormatter.cs

@@ -39,6 +39,7 @@ internal class ProcessorFormatter : IJsonFormatter<IProcessor>
 			{ "set_security_user", 27 },
 			{ "pipeline", 28 },
 			{ "drop", 29 },
+			{ "circle", 30 },
 		};
 
 		public IProcessor Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
@@ -149,6 +150,9 @@ public IProcessor Deserialize(ref JsonReader reader, IJsonFormatterResolver form
 					case 29:
 						processor = Deserialize<DropProcessor>(ref reader, formatterResolver);
 						break;
+					case 30:
+						processor = Deserialize<CircleProcessor>(ref reader, formatterResolver);
+						break;
 				}
 			}
 			else
@@ -260,6 +264,9 @@ public void Serialize(ref JsonWriter writer, IProcessor value, IJsonFormatterRes
 				case "drop":
 					Serialize<IDropProcessor>(ref writer, value, formatterResolver);
 					break;
+				case "circle":
+					Serialize<ICircleProcessor>(ref writer, value, formatterResolver);
+					break;
 				default:
 					var formatter = DynamicObjectResolver.ExcludeNullCamelCase.GetFormatter<IProcessor>();
 					formatter.Serialize(ref writer, value, formatterResolver);

src/Nest/Ingest/Processors/CircleProcessor.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Runtime.Serialization;
+using Elasticsearch.Net;
+using Elasticsearch.Net.Utf8Json;
+
+namespace Nest
+{
+	[StringEnum]
+	public enum ShapeType
+	{
+		[EnumMember(Value = "geo_shape")]
+		GeoShape,
+
+		[EnumMember(Value = "shape")]
+		Shape
+	}
+
+	[InterfaceDataContract]
+	public interface ICircleProcessor : IProcessor
+	{
+		/// <summary>
+		/// The string-valued field to trim whitespace from.
+		/// </summary>
+		[DataMember(Name ="field")]
+		Field Field { get; set; }
+
+		/// <summary>
+		/// The field to assign the polygon shape to, by default field is updated in-place.
+		/// </summary>
+		[DataMember(Name ="target_field")]
+		Field TargetField { get; set; }
+
+		/// <summary>
+		/// If true and field does not exist, the processor quietly exits without modifying the document.
+		/// </summary>
+		[DataMember(Name = "ignore_missing")]
+		bool? IgnoreMissing { get; set; }
+
+		/// <summary>
+		///  The difference between the resulting inscribed distance from center to side and the circle’s radius
+		/// (measured in meters for geo_shape, unit-less for shape)
+		/// </summary>
+		[DataMember(Name = "error_distance")]
+		double? ErrorDistance { get; set; }
+
+		/// <summary>
+		/// Which field mapping type is to be used when processing the circle.
+		/// </summary>
+		[DataMember(Name = "shape_type")]
+		ShapeType? ShapeType { get; set; }
+	}
+
+	public class CircleProcessor : ProcessorBase, ICircleProcessor
+	{
+		/// <inheritdoc />
+		public Field Field { get; set; }
+
+		/// <inheritdoc />
+		public Field TargetField { get; set; }
+
+		/// <inheritdoc />
+		public bool? IgnoreMissing { get; set; }
+
+		/// <inheritdoc />
+		public double? ErrorDistance { get; set; }
+
+		/// <inheritdoc />
+		public ShapeType? ShapeType { get; set; }
+
+		/// <inheritdoc />
+		protected override string Name => "circle";
+	}
+
+	public class CircleProcessorDescriptor<T>
+		: ProcessorDescriptorBase<CircleProcessorDescriptor<T>, ICircleProcessor>, ICircleProcessor
+		where T : class
+	{
+		protected override string Name => "circle";
+
+		Field ICircleProcessor.Field { get; set; }
+		Field ICircleProcessor.TargetField { get; set; }
+		bool? ICircleProcessor.IgnoreMissing { get; set; }
+		double? ICircleProcessor.ErrorDistance { get; set; }
+		ShapeType? ICircleProcessor.ShapeType { get; set; }
+
+		/// <inheritdoc cref="ICircleProcessor.Field" />
+		public CircleProcessorDescriptor<T> Field(Field field) => Assign(field, (a, v) => a.Field = v);
+
+		/// <inheritdoc cref="ICircleProcessor.Field" />
+		public CircleProcessorDescriptor<T> Field<TValue>(Expression<Func<T, TValue>> objectPath) =>
+			Assign(objectPath, (a, v) => a.Field = v);
+
+		/// <inheritdoc cref="ICircleProcessor.TargetField" />
+		public CircleProcessorDescriptor<T> TargetField(Field field) => Assign(field, (a, v) => a.TargetField = v);
+
+		/// <inheritdoc cref="ICircleProcessor.TargetField" />
+		public CircleProcessorDescriptor<T> TargetField<TValue>(Expression<Func<T, TValue>> objectPath) =>
+			Assign(objectPath, (a, v) => a.TargetField = v);
+
+		/// <inheritdoc cref="ICircleProcessor.IgnoreMissing">
+		public CircleProcessorDescriptor<T> IgnoreMissing(bool? ignoreMissing = true) =>
+			Assign(ignoreMissing, (a, v) => a.IgnoreMissing = v);
+
+		/// <inheritdoc cref="ICircleProcessor.IgnoreMissing">
+		public CircleProcessorDescriptor<T> ErrorDistance(double? errorDistance) =>
+			Assign(errorDistance, (a, v) => a.ErrorDistance = v);
+
+		/// <inheritdoc cref="ICircleProcessor.ShapeType">
+		public CircleProcessorDescriptor<T> ShapeType(ShapeType? shapeType) =>
+			Assign(shapeType, (a, v) => a.ShapeType = v);
+	}
+}

src/Nest/Ingest/Processors/DissectProcessor.cs

@@ -73,6 +73,7 @@ public DissectProcessorDescriptor<T> Field<TValue>(Expression<Func<T, TValue>> o
 		public DissectProcessorDescriptor<T> Pattern(string pattern) =>
 			Assign(pattern, (a, v) => a.Pattern = v);
 
+		// TODO! rename the parameter in 8.0
 		/// <inheritdoc cref="IDissectProcessor.IgnoreMissing">
 		public DissectProcessorDescriptor<T> IgnoreMissing(bool? traceMatch = true) =>
 			Assign(traceMatch, (a, v) => a.IgnoreMissing = v);

src/Nest/Ingest/ProcessorsDescriptor.cs

@@ -154,5 +154,8 @@ public ProcessorsDescriptor SetSecurityUser<T>(Func<SetSecurityUserProcessorDesc
 		public ProcessorsDescriptor Pipeline(Func<PipelineProcessorDescriptor, IPipelineProcessor> selector) =>
 			Assign(selector, (a, v) => a.AddIfNotNull(v?.Invoke(new PipelineProcessorDescriptor())));
 
+		/// <inheritdoc cref="IPipelineProcessor" />
+		public ProcessorsDescriptor Circle<T>(Func<CircleProcessorDescriptor<T>, ICircleProcessor> selector) where T : class  =>
+			Assign(selector, (a, v) => a.AddIfNotNull(v?.Invoke(new CircleProcessorDescriptor<T>())));
 	}
 }

src/Tests/Tests/Ingest/ProcessorAssertions.cs

@@ -386,6 +386,38 @@ public class Attachment : ProcessorAssertion
 			public override string Key => "attachment";
 		}
 
+		[SkipVersion("<7.4.0", "Circle processor added in 7.4.0")]
+		public class Circle : ProcessorAssertion
+		{
+			public override Func<ProcessorsDescriptor, IPromise<IList<IProcessor>>> Fluent => d => d
+				.Circle<Project>(ud => ud
+					.Field(p => p.Description)
+					.TargetField(p => p.ArbitraryShape)
+					.ShapeType(ShapeType.Shape)
+					.ErrorDistance(10d)
+					.IgnoreMissing()
+				);
+
+			public override IProcessor Initializer => new CircleProcessor
+			{
+				Field = "description",
+				TargetField = "arbitraryShape",
+				ShapeType = ShapeType.Shape,
+				ErrorDistance = 10d,
+				IgnoreMissing = true
+			};
+
+			public override object Json => new
+			{
+				field = "description",
+				target_field = "arbitraryShape",
+				shape_type = "shape",
+				error_distance = 10.0,
+				ignore_missing = true,
+			};
+
+			public override string Key => "circle";
+		}
 
 		[SkipVersion("<6.4.0", "")]
 		public class Bytes : ProcessorAssertion