Fix awkward grammar (#1918)

bkoelman · web-flow · commit 0731f4652fe2 · 2026-02-06T03:37:31.000+01:00
* Fix awkward grammar enables to allows to with gerund forms

* Run code cleanup
diff --git a/benchmarks/Tools/FakeRequestQueryStringAccessor.cs b/benchmarks/Tools/FakeRequestQueryStringAccessor.cs
@@ -5,7 +5,7 @@
 namespace Benchmarks.Tools;
 
 /// <summary>
-/// Enables to inject a query string, instead of obtaining it from <see cref="HttpContext" />.
+/// Enables injecting a query string, instead of obtaining it from <see cref="HttpContext" />.
 /// </summary>
 internal sealed class FakeRequestQueryStringAccessor : IRequestQueryStringAccessor
 {
diff --git a/docs/usage/faq.md b/docs/usage/faq.md
@@ -22,7 +22,7 @@ You'll need to build the resource graph on the client and rely on internal imple
 Due to auto-generated controllers, you may find it hard to determine where to put your breakpoints.
 In Visual Studio, controllers are accessible below **Solution Explorer > Project > Dependencies > Analyzers > JsonApiDotNetCore.SourceGenerators**.
 
-After turning on [Source Link](https://devblogs.microsoft.com/dotnet/improving-debug-time-productivity-with-source-link/#enabling-source-link) (which enables to download the JsonApiDotNetCore source code from GitHub), you can step into our source code and add breakpoints there too.
+After turning on [Source Link](https://devblogs.microsoft.com/dotnet/improving-debug-time-productivity-with-source-link/#enabling-source-link) (which enables downloading the JsonApiDotNetCore source code from GitHub), you can step into our source code and add breakpoints there too.
 
 Here are some key places in the execution pipeline to set a breakpoint:
 - `JsonApiRoutingConvention.Apply`: Controllers are registered here (executes once at startup)
diff --git a/docs/usage/openapi-documentation.md b/docs/usage/openapi-documentation.md
@@ -7,7 +7,7 @@ After [enabling OpenAPI](~/usage/openapi.md), you can expose a documentation web
 
 ## SwaggerUI
 
-[SwaggerUI](https://swagger.io/tools/swagger-ui/) enables to visualize and interact with the JSON:API endpoints through a web page.
+[SwaggerUI](https://swagger.io/tools/swagger-ui/) enables visualizing and interacting with the JSON:API endpoints through a web page.
 While it conveniently provides the ability to execute requests, it doesn't show properties of derived types when component schema inheritance is used.
 
 SwaggerUI can be enabled by installing the `Swashbuckle.AspNetCore.SwaggerUI` NuGet package and adding the following to your `Program.cs` file:
diff --git a/docs/usage/openapi.md b/docs/usage/openapi.md
@@ -3,8 +3,8 @@
 
 # OpenAPI
 
-Exposing an [OpenAPI document](https://swagger.io/specification/) for your JSON:API endpoints enables to provide a
-[documentation website](https://swagger.io/tools/swagger-ui/) and to generate typed
+Exposing an [OpenAPI document](https://swagger.io/specification/) for your JSON:API endpoints enables providing a
+[documentation website](https://swagger.io/tools/swagger-ui/) and generating typed
 [client libraries](https://openapi-generator.tech/docs/generators/) in various languages.
 
 The [JsonApiDotNetCore.OpenApi.Swashbuckle](https://github.com/json-api-dotnet/JsonApiDotNetCore/pkgs/nuget/JsonApiDotNetCore.OpenApi.Swashbuckle) NuGet package
diff --git a/docs/usage/resources/inheritance.md b/docs/usage/resources/inheritance.md
@@ -289,7 +289,7 @@ Resource definitions provide a better solution, see below.
 ### Resource definitions
 
 In contrast to the request pipeline, JsonApiDotNetCore always executes the resource definition that matches the *stored* type.
-This enables to implement business logic in a central place, irrespective of which endpoint was used or whether base types were used in relationships.
+This enables implementing business logic in a central place, irrespective of which endpoint was used or whether base types were used in relationships.
 
 To delegate logic for base types to their matching resource type, you can build a chain of resource definitions. And because you'll always get the
 actually stored types (for relationships too), you can type-check left-side and right-side types in resources definitions.
diff --git a/src/Examples/DapperExample/TranslationToSql/Builders/SelectStatementBuilder.cs b/src/Examples/DapperExample/TranslationToSql/Builders/SelectStatementBuilder.cs
@@ -746,7 +746,7 @@ private sealed class QueryState
 
         public ILoggerFactory LoggerFactory { get; }
 
-        // Prevents importing a table multiple times and enables to reference a table imported by an inner/outer query.
+        // Prevents importing a table multiple times and enables referencing a table imported by an inner/outer query.
         // In case of sub-queries, this may include temporary tables that won't survive in the final query.
         public Dictionary<TableAccessorNode, Dictionary<RelationshipAttribute, TableAccessorNode>> RelatedTables { get; } = [];
 
diff --git a/src/Examples/OpenApiKiotaClientExample/Worker.cs b/src/Examples/OpenApiKiotaClientExample/Worker.cs
@@ -93,7 +93,7 @@ private async Task UpdatePersonAsync(CancellationToken cancellationToken)
                 Id = "1",
                 Attributes = new AttributesInUpdatePersonRequest
                 {
-                    // The --backing-store switch enables to send null and default values.
+                    // The --backing-store switch enables sending null and default values.
                     FirstName = null,
                     LastName = "Doe"
                 }
@@ -145,7 +145,7 @@ private async Task SendOperationsRequestAsync(CancellationToken cancellationToke
                         Lid = "new-person",
                         Attributes = new AttributesInUpdatePersonRequest
                         {
-                            // The --backing-store switch enables to send null and default values.
+                            // The --backing-store switch enables sending null and default values.
                             FirstName = null
                         }
                     }
diff --git a/src/JsonApiDotNetCore.Annotations/Resources/RuntimeTypeConverter.cs b/src/JsonApiDotNetCore.Annotations/Resources/RuntimeTypeConverter.cs
@@ -38,7 +38,7 @@ public static class RuntimeTypeConverter
         // Earlier versions of JsonApiDotNetCore failed to pass CultureInfo.InvariantCulture in the parsing below, which resulted in the 'current'
         // culture being used. Unlike parsing JSON request/response bodies, this effectively meant that query strings were parsed based on the
         // OS-level regional settings of the web server.
-        // Because this was fixed in a non-major release, the switch below enables to revert to the old behavior.
+        // Because this was fixed in a non-major release, the switch below enables reverting to the old behavior.
 
         // With the switch activated, API developers can still choose between:
         // - Requiring localized date/number formats: parsing occurs using the OS-level regional settings (the default).
diff --git a/src/JsonApiDotNetCore.Annotations/TypeExtensions.cs b/src/JsonApiDotNetCore.Annotations/TypeExtensions.cs
@@ -11,7 +11,7 @@ public static bool IsOrImplementsInterface<TInterface>(this Type? source)
     }
 
     /// <summary>
-    /// Whether the specified source type implements or equals the specified interface. This overload enables to test for an open generic interface.
+    /// Whether the specified source type implements or equals the specified interface. This overload enables testing for an open generic interface.
     /// </summary>
     private static bool IsOrImplementsInterface(this Type? source, Type interfaceType)
     {
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerationTracer.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerationTracer.cs
@@ -6,7 +6,7 @@
 namespace JsonApiDotNetCore.OpenApi.Swashbuckle;
 
 /// <summary>
-/// Enables to log recursive component schema generation at trace level.
+/// Enables logging recursive component schema generation at trace level.
 /// </summary>
 internal sealed partial class SchemaGenerationTracer
 {
diff --git a/src/JsonApiDotNetCore/AtomicOperations/IOperationsTransaction.cs b/src/JsonApiDotNetCore/AtomicOperations/IOperationsTransaction.cs
@@ -14,12 +14,12 @@ public interface IOperationsTransaction : IAsyncDisposable
     string TransactionId { get; }
 
     /// <summary>
-    /// Enables to execute custom logic before processing of an operation starts.
+    /// Enables executing custom logic before processing of an operation starts.
     /// </summary>
     Task BeforeProcessOperationAsync(CancellationToken cancellationToken);
 
     /// <summary>
-    /// Enables to execute custom logic after processing of an operation succeeds.
+    /// Enables executing custom logic after processing of an operation succeeds.
     /// </summary>
     Task AfterProcessOperationAsync(CancellationToken cancellationToken);
 
diff --git a/src/JsonApiDotNetCore/Configuration/IJsonApiOptions.cs b/src/JsonApiDotNetCore/Configuration/IJsonApiOptions.cs
@@ -170,8 +170,8 @@ public interface IJsonApiOptions
     int? MaximumOperationsPerRequest { get; }
 
     /// <summary>
-    /// Enables to override the default isolation level for database transactions, enabling to balance between consistency and performance. Defaults to
-    /// <c>null</c>, which leaves this up to Entity Framework Core to choose (and then it varies per database provider).
+    /// Enables overriding the default isolation level for database transactions to balance between consistency and performance. Defaults to <c>null</c>,
+    /// which leaves this up to Entity Framework Core to choose (and then it varies per database provider).
     /// </summary>
     IsolationLevel? TransactionIsolationLevel { get; }
 
@@ -188,7 +188,7 @@ public interface IJsonApiOptions
     IReadOnlySet<JsonApiMediaTypeExtension> Extensions { get; }
 
     /// <summary>
-    /// Enables to customize the settings that are used by the <see cref="JsonSerializer" />.
+    /// Enables customizing the settings that are used by the <see cref="JsonSerializer" />.
     /// </summary>
     /// <example>
     /// The following example sets the naming convention to camel casing.
diff --git a/src/JsonApiDotNetCore/Configuration/ResourceGraphBuilder.cs b/src/JsonApiDotNetCore/Configuration/ResourceGraphBuilder.cs
@@ -302,7 +302,7 @@ private Dictionary<string, AttrAttribute>.ValueCollection GetAttributes(Type res
                 if (property.Name == nameof(Identifiable<>.Id))
                 {
                     // Although strictly not correct, 'id' is added to the list of attributes for convenience.
-                    // For example, it enables to filter on ID, without the need to special-case existing logic.
+                    // For example, it enables filtering on ID, without the need to special-case existing logic.
                     // And when using sparse fieldsets, it silently adds 'id' to the set of attributes to retrieve.
 
                     attribute = new AttrAttribute();
diff --git a/src/JsonApiDotNetCore/Errors/InvalidModelStateException.cs b/src/JsonApiDotNetCore/Errors/InvalidModelStateException.cs
@@ -214,7 +214,7 @@ private abstract class ModelStateKeySegment
         // The right part of the full key, which nested segments are produced from.
         private readonly string _nextKey;
 
-        // Enables to resolve the runtime-type of a collection element, such as the resource type in an atomic:operation.
+        // Enables resolving the runtime-type of a collection element, such as the resource type in an atomic:operation.
         protected Func<Type, int, Type?>? GetCollectionElementTypeCallback { get; }
 
         // In case of a property, its declaring type. In case of an indexer, the collection type or collection element type (in case the parent is a relationship).
diff --git a/src/JsonApiDotNetCore/Middleware/IJsonApiEndpointFilter.cs b/src/JsonApiDotNetCore/Middleware/IJsonApiEndpointFilter.cs
@@ -6,7 +6,7 @@
 namespace JsonApiDotNetCore.Middleware;
 
 /// <summary>
-/// Enables to remove JSON:API controller action methods at startup. For atomic:operation requests, see <see cref="IAtomicOperationFilter" />.
+/// Enables removing JSON:API controller action methods at startup. For atomic:operation requests, see <see cref="IAtomicOperationFilter" />.
 /// </summary>
 [PublicAPI]
 public interface IJsonApiEndpointFilter
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/AnyExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/AnyExpression.cs
@@ -6,8 +6,8 @@
 namespace JsonApiDotNetCore.Queries.Expressions;
 
 /// <summary>
-/// This expression allows to test if an attribute value equals any of the specified constants. It represents the "any" filter function, resulting from
-/// text such as:
+/// This expression tests if an attribute value equals any of the specified constants. It represents the "any" filter function, resulting from text such
+/// as:
 /// <c>
 /// any(owner.name,'Jack','Joe','John')
 /// </c>
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/ComparisonExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/ComparisonExpression.cs
@@ -4,7 +4,7 @@
 namespace JsonApiDotNetCore.Queries.Expressions;
 
 /// <summary>
-/// This expression allows to compare two operands using a comparison operator. It represents comparison filter functions, resulting from text such as:
+/// This expression compares two operands using a comparison operator. It represents comparison filter functions, resulting from text such as:
 /// <c>
 /// equals(name,'Joe')
 /// </c>
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/CountExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/CountExpression.cs
@@ -4,8 +4,8 @@
 namespace JsonApiDotNetCore.Queries.Expressions;
 
 /// <summary>
-/// This expression allows to determine the number of related resources in a to-many relationship. It represents the "count" function, resulting from
-/// text such as:
+/// This expression determines the number of related resources in a to-many relationship. It represents the "count" function, resulting from text such
+/// as:
 /// <c>
 /// count(articles)
 /// </c>
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/HasExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/HasExpression.cs
@@ -5,7 +5,7 @@
 namespace JsonApiDotNetCore.Queries.Expressions;
 
 /// <summary>
-/// This expression allows to test if a to-many relationship has related resources, optionally with a condition. It represents the "has" filter function,
+/// This expression tests if a to-many relationship has related resources, optionally with a condition. It represents the "has" filter function,
 /// resulting from text such as:
 /// <c>
 /// has(articles)
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/IsTypeExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/IsTypeExpression.cs
@@ -6,8 +6,8 @@
 namespace JsonApiDotNetCore.Queries.Expressions;
 
 /// <summary>
-/// This expression allows to test if a resource in an inheritance hierarchy can be upcast to a derived type, optionally with a condition where the
-/// derived type is accessible. It represents the "isType" filter function, resulting from text such as:
+/// This expression tests if a resource in an inheritance hierarchy can be upcast to a derived type, optionally with a condition where the derived type
+/// is accessible. It represents the "isType" filter function, resulting from text such as:
 /// <c>
 /// isType(,men)
 /// </c>
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/LogicalExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/LogicalExpression.cs
@@ -6,8 +6,8 @@
 namespace JsonApiDotNetCore.Queries.Expressions;
 
 /// <summary>
-/// This expression allows to test whether one or all of its boolean operands are true. It represents the logical AND/OR filter functions, resulting from
-/// text such as:
+/// This expression tests whether one or all of its boolean operands are true. It represents the logical AND/OR filter functions, resulting from text
+/// such as:
 /// <c>
 /// and(equals(title,'Work'),has(articles))
 /// </c>
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/NotExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/NotExpression.cs
@@ -4,7 +4,7 @@
 namespace JsonApiDotNetCore.Queries.Expressions;
 
 /// <summary>
-/// This expression allows to test for the logical negation of its operand. It represents the "not" filter function, resulting from text such as:
+/// This expression tests for the logical negation of its operand. It represents the "not" filter function, resulting from text such as:
 /// <c>
 /// not(equals(title,'Work'))
 /// </c>
diff --git a/src/JsonApiDotNetCore/Queries/QueryableBuilding/QueryClauseBuilderContext.cs b/src/JsonApiDotNetCore/Queries/QueryableBuilding/QueryClauseBuilderContext.cs
@@ -47,7 +47,7 @@ public sealed class QueryClauseBuilderContext
     public IQueryableBuilder QueryableBuilder { get; }
 
     /// <summary>
-    /// Enables to pass custom state that you'd like to transfer between calls.
+    /// Enables passing custom state that you'd like to transfer between calls.
     /// </summary>
     public object? State { get; }
 
diff --git a/src/JsonApiDotNetCore/Queries/QueryableBuilding/QueryableBuilderContext.cs b/src/JsonApiDotNetCore/Queries/QueryableBuilding/QueryableBuilderContext.cs
@@ -37,7 +37,7 @@ public sealed class QueryableBuilderContext
     public LambdaScopeFactory LambdaScopeFactory { get; }
 
     /// <summary>
-    /// Enables to pass custom state that you'd like to transfer between calls.
+    /// Enables passing custom state that you'd like to transfer between calls.
     /// </summary>
     public object? State { get; }
 
diff --git a/src/JsonApiDotNetCore/Resources/IResourceDefinition.cs b/src/JsonApiDotNetCore/Resources/IResourceDefinition.cs
diff --git a/src/JsonApiDotNetCore/Services/JsonApiResourceService.cs b/src/JsonApiDotNetCore/Services/JsonApiResourceService.cs
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/CustomFunctions/Decrypt/DecryptExpression.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/CustomFunctions/Decrypt/DecryptExpression.cs
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/CustomFunctions/IsUpperCase/IsUpperCaseExpression.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/CustomFunctions/IsUpperCase/IsUpperCaseExpression.cs
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/CustomFunctions/StringLength/LengthExpression.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/CustomFunctions/StringLength/LengthExpression.cs
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/CustomFunctions/Sum/SumExpression.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/CustomFunctions/Sum/SumExpression.cs
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/RemoveFromToManyRelationshipTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Updating/Relationships/RemoveFromToManyRelationshipTests.cs
diff --git a/test/OpenApiNSwagClientTests/FakeHttpClientWrapper.cs b/test/OpenApiNSwagClientTests/FakeHttpClientWrapper.cs
diff --git a/test/TestBuildingBlocks/IntegrationTest.cs b/test/TestBuildingBlocks/IntegrationTest.cs

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`namespace Benchmarks.Tools;`
`6`	`6`
`7`	`7`	`/// <summary>`
`8`		`-/// Enables to inject a query string, instead of obtaining it from <see cref="HttpContext" />.`
	`8`	`+/// Enables injecting a query string, instead of obtaining it from <see cref="HttpContext" />.`
`9`	`9`	`/// </summary>`
`10`	`10`	`internal sealed class FakeRequestQueryStringAccessor : IRequestQueryStringAccessor`
`11`	`11`	`{`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ private async Task UpdatePersonAsync(CancellationToken cancellationToken)`
`93`	`93`	`Id = "1",`
`94`	`94`	`Attributes = new AttributesInUpdatePersonRequest`
`95`	`95`	`{`
`96`		`- // The --backing-store switch enables to send null and default values.`
	`96`	`+ // The --backing-store switch enables sending null and default values.`
`97`	`97`	`FirstName = null,`
`98`	`98`	`LastName = "Doe"`
`99`	`99`	`}`
`@@ -145,7 +145,7 @@ private async Task SendOperationsRequestAsync(CancellationToken cancellationToke`
`145`	`145`	`Lid = "new-person",`
`146`	`146`	`Attributes = new AttributesInUpdatePersonRequest`
`147`	`147`	`{`
`148`		`- // The --backing-store switch enables to send null and default values.`
	`148`	`+ // The --backing-store switch enables sending null and default values.`
`149`	`149`	`FirstName = null`
`150`	`150`	`}`
`151`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ public static bool IsOrImplementsInterface<TInterface>(this Type? source)`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`/// <summary>`
`14`		`- /// Whether the specified source type implements or equals the specified interface. This overload enables to test for an open generic interface.`
	`14`	`+ /// Whether the specified source type implements or equals the specified interface. This overload enables testing for an open generic interface.`
`15`	`15`	`/// </summary>`
`16`	`16`	`private static bool IsOrImplementsInterface(this Type? source, Type interfaceType)`
`17`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`namespace JsonApiDotNetCore.OpenApi.Swashbuckle;`
`7`	`7`
`8`	`8`	`/// <summary>`
`9`		`-/// Enables to log recursive component schema generation at trace level.`
	`9`	`+/// Enables logging recursive component schema generation at trace level.`
`10`	`10`	`/// </summary>`
`11`	`11`	`internal sealed partial class SchemaGenerationTracer`
`12`	`12`	`{`