chore: add CSharpier and apply one-time format pass

.config/dotnet-tools.json

@@ -0,0 +1,13 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "csharpier": {
+      "version": "1.2.6",
+      "commands": [
+        "csharpier"
+      ],
+      "rollForward": false
+    }
+  }
+}

.csharpierignore

@@ -0,0 +1 @@
+worktrees/

Directory.Build.props

@@ -1,5 +1,4 @@
 <Project>
-
   <PropertyGroup>
     <ImplicitUsings>enable</ImplicitUsings>
     <Version>2.0.1</Version>
@@ -19,5 +18,4 @@
     <None Include="$(MSBuildThisFileDirectory)README.md" Pack="true" PackagePath="\" />
     <None Include="$(MSBuildThisFileDirectory)assets/icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
-
 </Project>

Equibles.ParadeDB.EntityFrameworkCore.IntegrationTests/AdvancedQueryTests.cs

@@ -3,13 +3,15 @@
 namespace Equibles.ParadeDB.EntityFrameworkCore.IntegrationTests;
 
 [Collection(nameof(ParadeDbCollection))]
-public class AdvancedQueryTests(ParadeDbFixture fixture) {
+public class AdvancedQueryTests(ParadeDbFixture fixture)
+{
     [Fact]
-    public async Task Parse_TantivySyntax_FiltersByField() {
+    public async Task Parse_TantivySyntax_FiltersByField()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var results = await ctx.Articles
-            .Where(a => EF.Functions.Parse(a.Id, "title:transformer"))
+        var results = await ctx
+            .Articles.Where(a => EF.Functions.Parse(a.Id, "title:transformer"))
             .Select(a => a.Title)
             .ToListAsync();
 
@@ -18,13 +20,16 @@ public async Task Parse_TantivySyntax_FiltersByField() {
     }
 
     [Fact]
-    public async Task MoreLikeThis_ExecutesAndReturnsRelatedArticle() {
+    public async Task MoreLikeThis_ExecutesAndReturnsRelatedArticle()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var seed = await ctx.Articles.SingleAsync(a => a.Title == "Introduction to neural networks");
+        var seed = await ctx.Articles.SingleAsync(a =>
+            a.Title == "Introduction to neural networks"
+        );
 
-        var related = await ctx.Articles
-            .Where(a => EF.Functions.MoreLikeThis(a.Id, seed.Id))
+        var related = await ctx
+            .Articles.Where(a => EF.Functions.MoreLikeThis(a.Id, seed.Id))
             .Select(a => a.Title)
             .ToListAsync();
 
@@ -35,15 +40,19 @@ public async Task MoreLikeThis_ExecutesAndReturnsRelatedArticle() {
     }
 
     [Fact]
-    public async Task JsonSearch_BooleanQuery_CombinesParseAndTerm() {
+    public async Task JsonSearch_BooleanQuery_CombinesParseAndTerm()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var query = ParadeDbJsonQuery.Boolean(b => b.Must(
-            ParadeDbJsonQuery.Parse("neural"),
-            ParadeDbJsonQuery.Term("category", "machine-learning")));
+        var query = ParadeDbJsonQuery.Boolean(b =>
+            b.Must(
+                ParadeDbJsonQuery.Parse("neural"),
+                ParadeDbJsonQuery.Term("category", "machine-learning")
+            )
+        );
 
-        var results = await ctx.Articles
-            .JsonSearch(a => a.Id, query)
+        var results = await ctx
+            .Articles.JsonSearch(a => a.Id, query)
             .Select(a => a.Title)
             .ToListAsync();
 

Equibles.ParadeDB.EntityFrameworkCore.IntegrationTests/BasicSearchTests.cs

@@ -3,13 +3,15 @@
 namespace Equibles.ParadeDB.EntityFrameworkCore.IntegrationTests;
 
 [Collection(nameof(ParadeDbCollection))]
-public class BasicSearchTests(ParadeDbFixture fixture) {
+public class BasicSearchTests(ParadeDbFixture fixture)
+{
     [Fact]
-    public async Task Matches_OrOperator_ReturnsMatchingDocuments() {
+    public async Task Matches_OrOperator_ReturnsMatchingDocuments()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var results = await ctx.Articles
-            .Where(a => EF.Functions.Matches(a.Content, "neural networks"))
+        var results = await ctx
+            .Articles.Where(a => EF.Functions.Matches(a.Content, "neural networks"))
             .Select(a => a.Title)
             .ToListAsync();
 
@@ -18,11 +20,12 @@ public async Task Matches_OrOperator_ReturnsMatchingDocuments() {
     }
 
     [Fact]
-    public async Task MatchesAll_AndOperator_RequiresAllTerms() {
+    public async Task MatchesAll_AndOperator_RequiresAllTerms()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var results = await ctx.Articles
-            .Where(a => EF.Functions.MatchesAll(a.Content, "attention transformers"))
+        var results = await ctx
+            .Articles.Where(a => EF.Functions.MatchesAll(a.Content, "attention transformers"))
             .Select(a => a.Title)
             .ToListAsync();
 
@@ -31,38 +34,41 @@ public async Task MatchesAll_AndOperator_RequiresAllTerms() {
     }
 
     [Fact]
-    public async Task MatchesPhrase_RequiresExactOrder() {
+    public async Task MatchesPhrase_RequiresExactOrder()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var withExactPhrase = await ctx.Articles
-            .Where(a => EF.Functions.MatchesPhrase(a.Content, "neural networks"))
+        var withExactPhrase = await ctx
+            .Articles.Where(a => EF.Functions.MatchesPhrase(a.Content, "neural networks"))
             .CountAsync();
-        var withReversedPhrase = await ctx.Articles
-            .Where(a => EF.Functions.MatchesPhrase(a.Content, "networks neural"))
+        var withReversedPhrase = await ctx
+            .Articles.Where(a => EF.Functions.MatchesPhrase(a.Content, "networks neural"))
             .CountAsync();
 
         Assert.Equal(1, withExactPhrase);
         Assert.Equal(0, withReversedPhrase);
     }
 
     [Fact]
-    public async Task MatchesFuzzy_ToleratesTypos() {
+    public async Task MatchesFuzzy_ToleratesTypos()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var results = await ctx.Articles
-            .Where(a => EF.Functions.MatchesFuzzy(a.Content, "nueral", 2))
+        var results = await ctx
+            .Articles.Where(a => EF.Functions.MatchesFuzzy(a.Content, "nueral", 2))
             .Select(a => a.Title)
             .ToListAsync();
 
         Assert.Contains(results, t => t == "Introduction to neural networks");
     }
 
     [Fact]
-    public async Task MatchesTerm_RequiresExactToken() {
+    public async Task MatchesTerm_RequiresExactToken()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var hits = await ctx.Articles
-            .Where(a => EF.Functions.MatchesTerm(a.Content, "gpus"))
+        var hits = await ctx
+            .Articles.Where(a => EF.Functions.MatchesTerm(a.Content, "gpus"))
             .Select(a => a.Title)
             .ToListAsync();
 

Equibles.ParadeDB.EntityFrameworkCore.IntegrationTests/Equibles.ParadeDB.EntityFrameworkCore.IntegrationTests.csproj

@@ -1,5 +1,4 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
@@ -24,5 +23,4 @@
   <ItemGroup>
     <Using Include="Xunit" />
   </ItemGroup>
-
 </Project>

Equibles.ParadeDB.EntityFrameworkCore.IntegrationTests/FieldTypeTests.cs

@@ -3,18 +3,20 @@
 namespace Equibles.ParadeDB.EntityFrameworkCore.IntegrationTests;
 
 [Collection(nameof(ParadeDbCollection))]
-public class FieldTypeTests(ParadeDbFixture fixture) {
+public class FieldTypeTests(ParadeDbFixture fixture)
+{
     [Fact]
-    public async Task Bm25Boolean_IndexedFastColumn_FiltersByValue() {
+    public async Task Bm25Boolean_IndexedFastColumn_FiltersByValue()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var inStockNames = await ctx.Products
-            .Where(p => EF.Functions.Matches(p.Name, "keyboard"))
+        var inStockNames = await ctx
+            .Products.Where(p => EF.Functions.Matches(p.Name, "keyboard"))
             .Where(p => p.InStock)
             .Select(p => p.Name)
             .ToListAsync();
-        var outOfStockNames = await ctx.Products
-            .Where(p => EF.Functions.Matches(p.Name, "keyboard"))
+        var outOfStockNames = await ctx
+            .Products.Where(p => EF.Functions.Matches(p.Name, "keyboard"))
             .Where(p => !p.InStock)
             .Select(p => p.Name)
             .ToListAsync();
@@ -24,12 +26,13 @@ public async Task Bm25Boolean_IndexedFastColumn_FiltersByValue() {
     }
 
     [Fact]
-    public async Task Bm25DateTime_FastColumn_SupportsRangeFilter() {
+    public async Task Bm25DateTime_FastColumn_SupportsRangeFilter()
+    {
         await using var ctx = fixture.CreateDbContext();
         var cutoff = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
-        var recent = await ctx.Products
-            .Where(p => EF.Functions.Matches(p.Name, "laptop OR mouse OR keyboard"))
+        var recent = await ctx
+            .Products.Where(p => EF.Functions.Matches(p.Name, "laptop OR mouse OR keyboard"))
             .Where(p => p.ReleasedAt >= cutoff)
             .Select(p => p.Name)
             .ToListAsync();
@@ -40,11 +43,12 @@ public async Task Bm25DateTime_FastColumn_SupportsRangeFilter() {
     }
 
     [Fact]
-    public async Task Bm25Json_WithExpandDots_IndexesJsonField() {
+    public async Task Bm25Json_WithExpandDots_IndexesJsonField()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var hits = await ctx.Products
-            .Where(p => EF.Functions.Matches(p.Name, "laptop OR mouse OR keyboard"))
+        var hits = await ctx
+            .Products.Where(p => EF.Functions.Matches(p.Name, "laptop OR mouse OR keyboard"))
             .Select(p => p.Name)
             .ToListAsync();
 

Equibles.ParadeDB.EntityFrameworkCore.IntegrationTests/IndexConfigurationTests.cs

@@ -4,9 +4,11 @@
 namespace Equibles.ParadeDB.EntityFrameworkCore.IntegrationTests;
 
 [Collection(nameof(ParadeDbCollection))]
-public class IndexConfigurationTests(ParadeDbFixture fixture) {
+public class IndexConfigurationTests(ParadeDbFixture fixture)
+{
     [Fact]
-    public async Task PgSearchExtension_IsInstalled() {
+    public async Task PgSearchExtension_IsInstalled()
+    {
         await using var conn = new NpgsqlConnection(fixture.ConnectionString);
         await conn.OpenAsync();
         await using var cmd = conn.CreateCommand();
@@ -18,7 +20,8 @@ public async Task PgSearchExtension_IsInstalled() {
     }
 
     [Fact]
-    public async Task Bm25Index_IsCreatedWithStorageParameters() {
+    public async Task Bm25Index_IsCreatedWithStorageParameters()
+    {
         await using var conn = new NpgsqlConnection(fixture.ConnectionString);
         await conn.OpenAsync();
         await using var cmd = conn.CreateCommand();
@@ -37,11 +40,12 @@ SELECT indexdef FROM pg_indexes
     }
 
     [Fact]
-    public async Task EnglishStemmer_MatchesWordVariants() {
+    public async Task EnglishStemmer_MatchesWordVariants()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var hits = await ctx.Articles
-            .Where(a => EF.Functions.Matches(a.Content, "run"))
+        var hits = await ctx
+            .Articles.Where(a => EF.Functions.Matches(a.Content, "run"))
             .Select(a => a.Title)
             .ToListAsync();
 
@@ -50,14 +54,15 @@ public async Task EnglishStemmer_MatchesWordVariants() {
     }
 
     [Fact]
-    public async Task RawTokenizer_KeepsExactCategoryValue() {
+    public async Task RawTokenizer_KeepsExactCategoryValue()
+    {
         await using var ctx = fixture.CreateDbContext();
 
-        var exactHits = await ctx.Articles
-            .Where(a => EF.Functions.MatchesTerm(a.Category, "machine-learning"))
+        var exactHits = await ctx
+            .Articles.Where(a => EF.Functions.MatchesTerm(a.Category, "machine-learning"))
             .CountAsync();
-        var tokenizedAttempt = await ctx.Articles
-            .Where(a => EF.Functions.MatchesTerm(a.Category, "machine"))
+        var tokenizedAttempt = await ctx
+            .Articles.Where(a => EF.Functions.MatchesTerm(a.Category, "machine"))
             .CountAsync();
 
         Assert.Equal(2, exactHits);