Update Id inference docs

This commit updates the Id inference docs to pull the disabling
of Id inference out into its own section

Author: russcam

docs/client-concepts/high-level/inference/ids-inference.asciidoc

@@ -28,7 +28,7 @@ This is a special type that you can implicitly convert to from the following typ
 
 * `Guid`
 
-Methods that take an `Id` can be passed any of these types and it will be implicitly converted to an instance of `Id`
+Methods that take an `Id` can be passed any of these types and they will be implicitly converted to an instance of `Id`
 
 [source,csharp]
 ----
@@ -43,9 +43,10 @@ Expect("hello-world").WhenSerializing(idFromString);
 Expect("d70bd3cf-4e38-46f3-91ca-fcbef29b148e").WhenSerializing(idFromGuid);
 ----
 
-==== Inferring from a type
+==== Inferring Id from a type
 
-Sometimes a method takes an object and we need an Id from that object to build up a path.
+Sometimes a method takes an object instance and the client requires an `Id` from that
+instance to build up a path.
 There is no implicit conversion from any object to `Id`, but we can call `Id.From`.
 
 Imagine your codebase has the following type that we want to index into Elasticsearch
@@ -114,7 +115,7 @@ WithConnectionSettings(x => x
 
 ==== Using the ElasticsearchType attribute
 
-Another way is to mark the type with an `ElasticsearchType` attribute, setting `IdProperty`
+Another way to control Id inference is to mark the type with an `ElasticsearchType` attribute, setting `IdProperty`
 to the name of the property that should be used for the document id
 
 [source,csharp]
@@ -144,8 +145,10 @@ Expect("x").WhenInferringIdOn(dto);
 
 ==== Using Mapping inference on ConnectionSettings
 
-This attribute *is* cached statically/globally, however an inference rule on the `ConnectionSettings` for the type will
-still win over the attribute. Here we demonstrate this by creating a different `ConnectionSettings` instance
+This attribute *is* cached statically/globally, however an inference rule on `ConnectionSettings` for the type will
+still win over the attribute.
+
+Here we demonstrate this by creating a different `ConnectionSettings` instance
 that will infer the document id from the property `OtherName`:
 
 [source,csharp]
@@ -157,3 +160,36 @@ WithConnectionSettings(x => x
 ).Expect("y").WhenInferringIdOn(dto);
 ----
 
+==== Disabling Id inference
+
+You can configure the client to disable Id inference on a CLR type basis
+
+[source,csharp]
+----
+WithConnectionSettings(x => x
+    .DefaultMappingFor<MyOtherDTO>(m => m
+        .DisableIdInference()
+    )
+).Expect(null).WhenInferringIdOn(dto);
+----
+
+or globally for all types
+
+[source,csharp]
+----
+WithConnectionSettings(x => x.DefaultDisableIdInference())
+    .Expect(null).WhenInferringIdOn(dto);
+----
+
+Once disabled globally, Id inference cannot be enabled per type
+
+[source,csharp]
+----
+WithConnectionSettings(x => x
+    .DefaultDisableIdInference()
+    .DefaultMappingFor<MyOtherDTO>(m => m
+        .DisableIdInference(disable: false)
+    )
+).Expect(null).WhenInferringIdOn(dto);
+----
+

docs/code-standards/descriptors.asciidoc

@@ -198,7 +198,8 @@ var methods = from d in YieldAllDescriptors()
     where !(m.Name == nameof(ScoreFunctionsDescriptor<object>.Weight) && dt == typeof(ScoreFunctionsDescriptor<>))
     where !(m.Name == nameof(SortDescriptor<object>.Ascending) && dt == typeof(SortDescriptor<>))
     where !(m.Name == nameof(SortDescriptor<object>.Descending) && dt == typeof(SortDescriptor<>))
-
+    where !(m.Name == nameof(ClrTypeMappingDescriptor<object>.DisableIdInference) && dt == typeof(ClrTypeMappingDescriptor<>))
+    where !(m.Name == nameof(ClrTypeMappingDescriptor.DisableIdInference) && dt == typeof(ClrTypeMappingDescriptor))
 
     select new {m, d, p};
 

docs/code-standards/naming-conventions.asciidoc

@@ -118,7 +118,9 @@ var exceptions = new[] <1>
     typeof(IndicesShardStoresRequest),
     typeof(RenderSearchTemplateRequest),
     typeof(MultiSearchTemplateRequest),
-    typeof(CreateRequest<>)
+    typeof(CreateRequest<>),
+    typeof(DeleteByQueryRethrottleRequest), // uses ListTasksResponse
+    typeof(UpdateByQueryRethrottleRequest) // uses ListTasksResponse
 };
 
 var types = typeof(IRequest).Assembly().GetTypes();

docs/query-dsl/full-text/match/match-usage.asciidoc

@@ -26,7 +26,7 @@ q
     .Boost(1.1)
     .CutoffFrequency(0.001)
     .Query("hello world")
-    .Fuzziness(Fuzziness.Auto)
+    .Fuzziness(Fuzziness.AutoLength(3, 6))
     .Lenient()
     .FuzzyTranspositions()
     .MinimumShouldMatch(2)
@@ -48,7 +48,7 @@ new MatchQuery
     Name = "named_query",
     CutoffFrequency = 0.001,
     Query = "hello world",
-    Fuzziness = Fuzziness.Auto,
+    Fuzziness = Fuzziness.AutoLength(3, 6),
     FuzzyTranspositions = true,
     MinimumShouldMatch = 2,
     FuzzyRewrite = MultiTermQueryRewrite.TopTermsBlendedFreqs(10),
@@ -68,7 +68,7 @@ new MatchQuery
       "query": "hello world",
       "analyzer": "standard",
       "fuzzy_rewrite": "top_terms_blended_freqs_10",
-      "fuzziness": "AUTO",
+      "fuzziness": "AUTO:3,6",
       "fuzzy_transpositions": true,
       "cutoff_frequency": 0.001,
       "lenient": true,

src/Tests/Tests/ClientConcepts/HighLevel/Inference/IdsInference.doc.cs

@@ -21,7 +21,7 @@ public class IdsInference
 		 * - `String`
 		 * - `Guid`
 		 *
-		 * Methods that take an `Id` can be passed any of these types and it will be implicitly converted to an instance of `Id`
+		 * Methods that take an `Id` can be passed any of these types and they will be implicitly converted to an instance of `Id`
 		*/
 		[U] public void CanImplicitlyConvertToId()
 		{
@@ -37,9 +37,10 @@ [U] public void CanImplicitlyConvertToId()
 		}
 
 		/**
-		* ==== Inferring from a type
+		* ==== Inferring Id from a type
 		*
-		* Sometimes a method takes an object and we need an Id from that object to build up a path.
+		* Sometimes a method takes an object instance and the client requires an `Id` from that
+		* instance to build up a path.
 		* There is no implicit conversion from any object to `Id`, but we can call `Id.From`.
 		*
 		* Imagine your codebase has the following type that we want to index into Elasticsearch
@@ -94,38 +95,12 @@ [U] public void CanGetIdFromDocument()
 					.IdProperty(typeof(MyDTO).GetProperty(nameof(MyDTO.Name)).Name)
 				)
 			).Expect("x").WhenInferringIdOn(dto);
-
-			/**
-			 * You can configure the client to disable this Id inference behaviour per type:
-			*/
-			WithConnectionSettings(x => x
-				.DefaultMappingFor<MyDTO>(m => m
-					.DisableIdInference()
-				)
-			).Expect(null).WhenInferringIdOn(dto);
-
-			/**
-			 * or globally type:
-			*/
-			WithConnectionSettings(x => x.DefaultDisableIdInference())
-				.Expect(null).WhenInferringIdOn(dto);
-
-			/**
-			 * Once disabled globally the id inference can not be enabled per type.
-			*/
-			WithConnectionSettings(x => x
-				.DefaultDisableIdInference()
-				.DefaultMappingFor<MyDTO>(m => m
-					.DisableIdInference(disable: false)
-				)
-			).Expect(null).WhenInferringIdOn(dto);
-
 		}
 
 		/**
 		* ==== Using the ElasticsearchType attribute
 		*
-		* Another way is to mark the type with an `ElasticsearchType` attribute, setting `IdProperty`
+		* Another way to control Id inference is to mark the type with an `ElasticsearchType` attribute, setting `IdProperty`
 		* to the name of the property that should be used for the document id
 		*/
 		[ElasticsearchType(IdProperty = nameof(Name))]
@@ -151,8 +126,10 @@ [U] public void CanGetIdFromAttribute()
 			/**
 			* ==== Using Mapping inference on ConnectionSettings
 			*
-			* This attribute *is* cached statically/globally, however an inference rule on the `ConnectionSettings` for the type will
-			* still win over the attribute. Here we demonstrate this by creating a different `ConnectionSettings` instance
+			* This attribute *is* cached statically/globally, however an inference rule on `ConnectionSettings` for the type will
+			* still win over the attribute.
+			 *
+			 * Here we demonstrate this by creating a different `ConnectionSettings` instance
 			* that will infer the document id from the property `OtherName`:
 			*/
 			WithConnectionSettings(x => x
@@ -161,5 +138,43 @@ [U] public void CanGetIdFromAttribute()
 				)
 			).Expect("y").WhenInferringIdOn(dto);
 		}
+
+		/** ==== Disabling Id inference
+		 */
+		[U] public void DisablingIdInference()
+		{
+			// hide
+			var dto = new MyOtherDTO
+			{
+				Id = new Guid("D70BD3CF-4E38-46F3-91CA-FCBEF29B148E"),
+				Name = "x",
+				OtherName = "y"
+			};
+
+			/**
+			 * You can configure the client to disable Id inference on a CLR type basis
+			*/
+			WithConnectionSettings(x => x
+				.DefaultMappingFor<MyOtherDTO>(m => m
+					.DisableIdInference()
+				)
+			).Expect(null).WhenInferringIdOn(dto);
+
+			/**
+			 * or globally for all types
+			*/
+			WithConnectionSettings(x => x.DefaultDisableIdInference())
+				.Expect(null).WhenInferringIdOn(dto);
+
+			/**
+			 * Once disabled globally, Id inference cannot be enabled per type
+			*/
+			WithConnectionSettings(x => x
+				.DefaultDisableIdInference()
+				.DefaultMappingFor<MyOtherDTO>(m => m
+					.DisableIdInference(disable: false)
+				)
+			).Expect(null).WhenInferringIdOn(dto);
+		}
 	}
 }