fix #2683 allow inline definitions in the Analyze API

Author: Mpdreamz

src/Nest/CommonAbstractions/Fluent/DescriptorBase.cs

@@ -25,13 +25,17 @@ protected DescriptorBase()
 		/// </summary>
 		[Browsable(false)]
 		[EditorBrowsable(EditorBrowsableState.Never)]
+		// ReSharper disable once BaseObjectEqualsIsObjectEquals
+		//only used to hide by default
 		public override bool Equals(object obj) => base.Equals(obj);
 
 		/// <summary>
 		/// Hides the <see cref="GetHashCode"/> method.
 		/// </summary>
 		[Browsable(false)]
 		[EditorBrowsable(EditorBrowsableState.Never)]
+		// ReSharper disable once BaseObjectGetHashCodeCallInGetHashCode
+		//only used to hide by default
 		public override int GetHashCode() => base.GetHashCode();
 
 		/// <summary>

src/Nest/CommonAbstractions/Fluent/SelectorBase.cs

@@ -0,0 +1,35 @@
+using System;
+using System.ComponentModel;
+
+namespace Nest
+{
+	public interface ISelector { }
+
+	public abstract class SelectorBase<TInterface> : ISelector where TInterface : class
+	{
+		/// <summary>
+		/// Hides the <see cref="Equals"/> method.
+		/// </summary>
+		[Browsable(false)]
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		// ReSharper disable once BaseObjectEqualsIsObjectEquals
+		//only used to hide by default
+		public override bool Equals(object obj) => base.Equals(obj);
+
+		/// <summary>
+		/// Hides the <see cref="GetHashCode"/> method.
+		/// </summary>
+		[Browsable(false)]
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		// ReSharper disable once BaseObjectGetHashCodeCallInGetHashCode
+		//only used to hide by default
+		public override int GetHashCode() => base.GetHashCode();
+
+		/// <summary>
+		/// Hides the <see cref="ToString"/> method.
+		/// </summary>
+		[Browsable(false)]
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		public override string ToString() => base.ToString();
+	}
+}

src/Nest/Indices/Analyze/AnalyzeCharFilters.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+
+namespace Nest
+{
+	public class AnalyzeCharFilters : List<Union<string, ICharFilter>>
+	{
+		public AnalyzeCharFilters() { }
+		public AnalyzeCharFilters(List<Union<string, ICharFilter>> tokenFilters)
+		{
+			if (tokenFilters == null) return;
+			foreach (var v in tokenFilters) this.AddIfNotNull(v);
+		}
+		public AnalyzeCharFilters(string[] tokenFilters)
+		{
+			if (tokenFilters == null) return;
+			foreach (var v in tokenFilters) this.AddIfNotNull(v);
+		}
+
+		public void Add(ICharFilter filter) => this.Add(new Union<string, ICharFilter>(filter));
+
+		public static implicit operator AnalyzeCharFilters(CharFilterBase tokenFilter) => tokenFilter == null ? null : new AnalyzeCharFilters { tokenFilter };
+		public static implicit operator AnalyzeCharFilters(string tokenFilter) => tokenFilter == null ? null : new AnalyzeCharFilters { tokenFilter };
+		public static implicit operator AnalyzeCharFilters(string[] tokenFilters) => tokenFilters == null ? null : new AnalyzeCharFilters(tokenFilters);
+	}
+
+	public class AnalyzeCharFiltersDescriptor : DescriptorPromiseBase<AnalyzeCharFiltersDescriptor, AnalyzeCharFilters>
+	{
+		public AnalyzeCharFiltersDescriptor() : base(new AnalyzeCharFilters()) { }
+
+		/// <summary>
+		/// A reference to a token filter that is part of the mapping
+		/// </summary>
+		public AnalyzeCharFiltersDescriptor Name(string tokenFilter) => Assign(a => a.AddIfNotNull(tokenFilter));
+
+		private AnalyzeCharFiltersDescriptor AssignIfNotNull(ICharFilter filter) =>
+			Assign(a =>
+			{
+				if (filter != null) a.Add(filter);
+			});
+
+		/// <summary>
+		/// The pattern_replace char filter allows the use of a regex to manipulate the characters in a string before analysis.
+		/// </summary>
+		public AnalyzeCharFiltersDescriptor PatternReplace(Func<PatternReplaceCharFilterDescriptor, IPatternReplaceCharFilter> selector) =>
+			AssignIfNotNull(selector?.Invoke(new PatternReplaceCharFilterDescriptor()));
+
+		/// <summary>
+		/// A char filter of type html_strip stripping out HTML elements from an analyzed text.
+		/// </summary>
+		public AnalyzeCharFiltersDescriptor HtmlStrip(Func<HtmlStripCharFilterDescriptor, IHtmlStripCharFilter> selector = null) =>
+			AssignIfNotNull(selector.InvokeOrDefault(new HtmlStripCharFilterDescriptor()));
+
+		/// <summary>
+		/// A char filter of type mapping replacing characters of an analyzed text with given mapping.
+		/// </summary>
+		public AnalyzeCharFiltersDescriptor Mapping(Func<MappingCharFilterDescriptor, IMappingCharFilter> selector) =>
+			AssignIfNotNull(selector?.Invoke(new MappingCharFilterDescriptor()));
+
+		/// <summary>
+		/// The kuromoji_iteration_mark normalizes Japanese horizontal iteration marks (odoriji) to their expanded form.
+		/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+		/// </summary>
+		public AnalyzeCharFiltersDescriptor KuromojiIterationMark(Func<KuromojiIterationMarkCharFilterDescriptor, IKuromojiIterationMarkCharFilter> selector = null) =>
+			AssignIfNotNull(selector?.InvokeOrDefault(new KuromojiIterationMarkCharFilterDescriptor()));
+
+		/// <summary>
+		/// Normalizes as defined here: http://userguide.icu-project.org/transforms/normalization
+		/// Part of the `analysis-icu` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-icu.html
+		/// </summary>
+		public AnalyzeCharFiltersDescriptor IcuNormalization(Func<IcuNormalizationCharFilterDescriptor, IIcuNormalizationCharFilter> selector) =>
+			AssignIfNotNull(selector?.Invoke(new IcuNormalizationCharFilterDescriptor()));
+	}
+}

src/Nest/Indices/Analyze/AnalyzeRequest.cs

@@ -11,19 +11,19 @@ public partial interface IAnalyzeRequest
 	{
 		///<summary>The name of the analyzer to use</summary>
 		[JsonProperty("analyzer")]
-		string Analyzer { get; set; }
+		Union<string, IAnalyzer> Analyzer { get; set; }
 
 		///<summary>The name of the normalizer to use</summary>
 		[JsonProperty("normalizer")]
 		string Normalizer { get; set; }
 
 		///<summary>A collection of character filters to use for the analysis</summary>
 		[JsonProperty("char_filter")]
-		string[] CharFilter { get; set; }
+		AnalyzeCharFilters CharFilter { get; set; }
 
 		///<summary>A collection of filters to use for the analysis</summary>
 		[JsonProperty("filter")]
-		string[] Filter { get; set; }
+		AnalyzeTokenFilters Filter { get; set; }
 
 		///<summary>Use the analyzer configured for this field (instead of passing the analyzer name)</summary>
 		[JsonProperty("field")]
@@ -35,7 +35,7 @@ public partial interface IAnalyzeRequest
 
 		///<summary>The name of the tokenizer to use for the analysis</summary>
 		[JsonProperty("tokenizer")]
-		string Tokenizer { get; set; }
+		Union<string, ITokenizer> Tokenizer { get; set; }
 	}
 
 	public partial class AnalyzeRequest
@@ -47,56 +47,84 @@ public AnalyzeRequest(IndexName indices, string textToAnalyze)
 		}
 
 		/// <inheritdoc />
-		public string Analyzer { get; set; }
+		public Union<string, ITokenizer> Tokenizer { get; set; }
+
+		/// <inheritdoc />
+		public Union<string, IAnalyzer> Analyzer { get; set; }
 
 		/// <inheritdoc />
 		public string Normalizer { get; set; }
 
 	    /// <inheritdoc />
-		public string[] CharFilter { get; set; }
+		public AnalyzeCharFilters CharFilter { get; set; }
 
 	    /// <inheritdoc />
-	    public string[] Filter { get; set; }
+		public AnalyzeTokenFilters Filter { get; set; }
 
 		/// <inheritdoc />
 		public Field Field { get; set; }
 
 		/// <inheritdoc />
 		public string[] Text { get; set; }
 
-		/// <inheritdoc />
-		public string Tokenizer { get; set; }
 	}
 
 	[DescriptorFor("IndicesAnalyze")]
 	public partial class AnalyzeDescriptor
 	{
-		string IAnalyzeRequest.Analyzer { get; set; }
+		Union<string, ITokenizer> IAnalyzeRequest.Tokenizer { get; set; }
+		Union<string, IAnalyzer> IAnalyzeRequest.Analyzer { get; set; }
 		string IAnalyzeRequest.Normalizer { get; set; }
-		string[] IAnalyzeRequest.CharFilter { get; set; }
-		string[] IAnalyzeRequest.Filter { get; set; }
+		AnalyzeCharFilters IAnalyzeRequest.CharFilter { get; set; }
+		AnalyzeTokenFilters IAnalyzeRequest.Filter { get; set; }
 		Field IAnalyzeRequest.Field { get; set; }
 		string[] IAnalyzeRequest.Text { get; set; }
-		string IAnalyzeRequest.Tokenizer { get; set; }
+
+		///<summary>The name of the tokenizer to use for the analysis</summary>
+		public AnalyzeDescriptor Tokenizer(string tokenizer) => Assign(a => a.Tokenizer = tokenizer);
+
+		///<summary>An inline definition of a tokenizer</summary>
+		public AnalyzeDescriptor Tokenizer(Func<AnalyzeTokenizersSelector, ITokenizer> tokenizer) =>
+			Assign(a =>
+			{
+				var v = tokenizer?.Invoke(new AnalyzeTokenizersSelector());
+				if (v != null) a.Tokenizer = new Union<string, ITokenizer>(v);
+			});
 
 		///<summary>The name of the analyzer to use</summary>
 		public AnalyzeDescriptor Analyzer(string analyser) => Assign(a => a.Analyzer = analyser);
 
 		///<summary>The name of the normalizer to use</summary>
 		public AnalyzeDescriptor Normalizer(string normalizer) => Assign(a => a.Normalizer = normalizer);
 
+		///<summary>An inline definition of an analyzer</summary>
+		public AnalyzeDescriptor Analyzer(Func<AnalyzersDescriptor, IAnalyzer> analyzer) =>
+			Assign(a =>
+			{
+				var v = analyzer?.Invoke(new AnalyzersDescriptor());
+				if (v != null) a.Analyzer = new Union<string, IAnalyzer>(v);
+			});
+
 		///<summary>A collection of character filters to use for the analysis</summary>
 		public AnalyzeDescriptor CharFilter(params string[] charFilter) => Assign(a => a.CharFilter = charFilter);
 
 		///<summary>A collection of character filters to use for the analysis</summary>
 		public AnalyzeDescriptor CharFilter(IEnumerable<string> charFilter) => Assign(a => a.CharFilter = charFilter.ToArray());
 
+		///<summary>A collection of character filters to use for the analysis</summary>
+		public AnalyzeDescriptor CharFilter(Func<AnalyzeCharFiltersDescriptor, IPromise<AnalyzeCharFilters>> charFilters) =>
+			Assign(a => a.CharFilter = charFilters?.Invoke(new AnalyzeCharFiltersDescriptor())?.Value);
+
 		///<summary>A collection of filters to use for the analysis</summary>
 		public AnalyzeDescriptor Filter(params string[] filter) => Assign(a => a.Filter = filter);
 
 		///<summary>A collection of filters to use for the analysis</summary>
 		public AnalyzeDescriptor Filter(IEnumerable<string> filter) => Assign(a => a.Filter = filter.ToArray());
 
+		///<summary>A collection of filters to use for the analysis</summary>
+		public AnalyzeDescriptor Filter(Func<AnalyzeTokenFiltersDescriptor, IPromise<AnalyzeTokenFilters>> tokenFilters) =>
+			Assign(a => a.Filter = tokenFilters?.Invoke(new AnalyzeTokenFiltersDescriptor())?.Value);
+
 		///<summary>Use the analyzer configured for this field (instead of passing the analyzer name)</summary>
 		public AnalyzeDescriptor Field(Field field) => Assign(a => a.Field = field);
 
@@ -109,7 +137,5 @@ public partial class AnalyzeDescriptor
 		///<summary>The text on which the analysis should be performed</summary>
 		public AnalyzeDescriptor Text(IEnumerable<string> text) => Assign(a => a.Text = text.ToArray());
 
-		///<summary>The name of the tokenizer to use for the analysis</summary>
-		public AnalyzeDescriptor Tokenizer(string tokenizer) => Assign(a => a.Tokenizer = tokenizer);
 	}
 }