fmt: apply dotnet csharpier . to entire code base (switch from dotnet-format to csharpier) (#109)

---------

Co-authored-by: Konstantin <[email protected]>

Author: hf-kklein

.github/workflows/formatter.yml

@@ -1,4 +1,4 @@
-name: dotnet-format
+name: csharpier
 
 on: [push, pull_request]
 
@@ -7,13 +7,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - name: Setup .NET 3.1
+      - name: Setup .NET 9
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.0.100
-      - name: Install dotnet-format
-        run: |
-          dotnet tool install -g dotnet-format
-      - name: Run dotnet-format
+          dotnet-version: 9
+      - name: Restore .NET tools
         working-directory: ./ChronoJsonDiffPatch
-        run: dotnet-format ChronoJsonDiffPatch.sln --check
+        run: dotnet tool restore
+      - name: Run CSharpier
+        working-directory: ./ChronoJsonDiffPatch
+        run: dotnet csharpier . --check

.gitignore

@@ -10,3 +10,11 @@ ChronoJsonDiffPatch/ChronoJsonDiffPatch/bin/Debug/net7.0/
 ChronoJsonDiffPatch/ChronoJsonDiffPatch.sln.DotSettings.user
 
 ChronoJsonDiffPatch/ChronoJsonDiffPatch/bin/Debug/ChronoJsonDiffPatch.xml
+
+*.dll
+
+*.pdb
+
+*.exe
+
+*.xml

ChronoJsonDiffPatch/.config/dotnet-tools.json

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

ChronoJsonDiffPatch/ChronoJsonDiffPatch/FuturePatchBehaviour.cs

@@ -20,4 +20,4 @@ public enum FuturePatchBehaviour
     /// The future (>= dtB) shall have state B: the second patchA only lasts in the interval between [A,B)
     /// </summary>
     KeepTheFuture,
-}
+}

ChronoJsonDiffPatch/ChronoJsonDiffPatch/GenericTimeRangePatchChainProduct.cs

@@ -12,12 +12,14 @@ namespace ChronoJsonDiffPatch;
 /// </remarks>
 /// <typeparam name="TProductEntity">type that holds the state of n different types at a given point in time</typeparam>
 /// <typeparam name="TChainsAndEntities">the initial state and respective chains of a the different types</typeparam>
-public abstract class GenericTimeRangePatchChainProduct<TChainsAndEntities, TProductEntity> where TChainsAndEntities : IChainsAndEntities<TProductEntity>
+public abstract class GenericTimeRangePatchChainProduct<TChainsAndEntities, TProductEntity>
+    where TChainsAndEntities : IChainsAndEntities<TProductEntity>
 {
     /// <summary>
     /// the relevant initial states and chains
     /// </summary>
     private readonly TChainsAndEntities _chainsAndEntities;
+
     /// <summary>
     /// instantiate the generic chain product by providing an instance of a type that holds all chains and respective initial entities.
     /// </summary>
@@ -26,14 +28,16 @@ public GenericTimeRangePatchChainProduct(TChainsAndEntities chainsAndEntities)
     {
         _chainsAndEntities = chainsAndEntities;
     }
+
     /// <summary>
     /// returns the joint history of all chains involved in <typeparamref name="TChainsAndEntities"/>
     /// </summary>
     /// <returns>an enumerable that contains entries for every relevant date which there is in either or both of the chains</returns>
     [Pure]
     public IEnumerable<TProductEntity> GetAll()
     {
-        var result = _chainsAndEntities.GetPatchingDates()
+        var result = _chainsAndEntities
+            .GetPatchingDates()
             .Where(dt => dt != DateTime.MinValue)
             .Where(dt => dt != DateTime.MaxValue)
             .Distinct()

ChronoJsonDiffPatch/ChronoJsonDiffPatch/PatchingDirection.cs

@@ -21,7 +21,7 @@ public enum PatchingDirection
     /// </summary>
     /// <remarks>
     /// Although this doesn't feel as natural as <see cref="ParallelWithTime"/>, it might useful if you store changes to an entity in a database and you always want to have the most recent/youngest state as "full" entity and persist the past as patches.
-    /// Then you always start with the youngest entity and patch "backwards" until you reach the point in time/in the past in which you're interested. 
+    /// Then you always start with the youngest entity and patch "backwards" until you reach the point in time/in the past in which you're interested.
     /// </remarks>
     AntiParallelWithTime,
-}
+}

ChronoJsonDiffPatch/ChronoJsonDiffPatch/ProductEntity.cs

@@ -1,7 +1,7 @@
 namespace ChronoJsonDiffPatch;
 
 /// <summary>
-/// A ProductEntity is a composite of both an <typeparamref name="TEntityA"/> and a <typeparamref name="TEntityB"/>. 
+/// A ProductEntity is a composite of both an <typeparamref name="TEntityA"/> and a <typeparamref name="TEntityB"/>.
 /// </summary>
 /// <remarks>This is a shortcut for a <see cref="Tuple{TEntityA, TEntityB, DateTimeOffset}"/></remarks>
 /// <typeparam name="TEntityA"></typeparam>
@@ -12,10 +12,12 @@ public class ProductEntity<TEntityA, TEntityB>
     /// describes the date at which <typeparamref name="TEntityA"/> has state <see cref="EntityA"/> and <typeparamref name="TEntityB"/> has state <see cref="EntityB"/>
     /// </summary>
     public DateTimeOffset KeyDate { get; }
+
     /// <summary>
     /// an instance of <typeparamref name="TEntityA"/> @ <see cref="KeyDate"/>
     /// </summary>
     public TEntityA EntityA { get; }
+
     /// <summary>
     /// an instance of <typeparamref name="TEntityB"/> @ <see cref="KeyDate"/>
     /// </summary>
@@ -33,4 +35,4 @@ public ProductEntity(TEntityA entityA, TEntityB entityB, DateTimeOffset keyDate)
         EntityB = entityB;
         KeyDate = keyDate;
     }
-}
+}

ChronoJsonDiffPatch/ChronoJsonDiffPatch/SkipCondition.cs

@@ -21,5 +21,9 @@ public interface ISkipCondition<in TEntity>
     /// <param name="errorWhilePatching">any error that occurred</param>
     /// <param name="failedPatch">the patch that lead to the exception <paramref name="errorWhilePatching"/></param>
     /// <returns>true if the patch should be skipped</returns>
-    public bool ShouldSkipPatch(TEntity initialEntity, TimeRangePatch failedPatch, Exception errorWhilePatching);
+    public bool ShouldSkipPatch(
+        TEntity initialEntity,
+        TimeRangePatch failedPatch,
+        Exception errorWhilePatching
+    );
 }

ChronoJsonDiffPatch/ChronoJsonDiffPatch/SkipPatchesWithUnmatchedListItems.cs

@@ -21,7 +21,11 @@ public SkipPatchesWithUnmatchedListItems(Func<TEntity, List<TListItem>?> listAcc
     /// <summary>
     /// <inheritdoc cref="ISkipCondition{TEntity}"/>
     /// </summary>
-    public virtual bool ShouldSkipPatch(TEntity initialEntity, TimeRangePatch failedPatch, Exception errorWhilePatching)
+    public virtual bool ShouldSkipPatch(
+        TEntity initialEntity,
+        TimeRangePatch failedPatch,
+        Exception errorWhilePatching
+    )
     {
         if (errorWhilePatching is not ArgumentOutOfRangeException)
         {

ChronoJsonDiffPatch/ChronoJsonDiffPatch/TimeRangePatch.cs

@@ -31,7 +31,11 @@ public class TimeRangePatch : TimeRange
     public DateTimeOffset From
     {
         get => Start == DateTime.MinValue ? DateTimeOffset.MinValue : new DateTimeOffset(Start);
-        set => Start = value == DateTimeOffset.MinValue ? DateTimeOffset.MinValue.UtcDateTime : value.UtcDateTime;
+        set =>
+            Start =
+                value == DateTimeOffset.MinValue
+                    ? DateTimeOffset.MinValue.UtcDateTime
+                    : value.UtcDateTime;
     }
 
     /// <summary>
@@ -50,7 +54,9 @@ public DateTimeOffset? To
             {
                 if (value.Value < From)
                 {
-                    throw new ArgumentException($"{nameof(value)} ({value.Value:o}) must not be lower than {nameof(From)} ({From:o})");
+                    throw new ArgumentException(
+                        $"{nameof(value)} ({value.Value:o}) must not be lower than {nameof(From)} ({From:o})"
+                    );
                 }
 
                 End = value.Value.UtcDateTime;
@@ -73,6 +79,7 @@ public DateTimeOffset? To
     public DateTime? Timestamp { get; set; }
 
     private readonly PatchingDirection _patchingDirection;
+
     /// <summary>
     /// Describes of this patch shall be applied "left to right" or "right to left".
     /// For details see <see cref="PatchingDirection"/>
@@ -91,14 +98,18 @@ public TimeRangePatch()
     /// by default: assume the From-date is now
     /// </summary>
     /// <param name="patch"></param>
-    public TimeRangePatch(JsonDocument? patch) : this(DateTimeOffset.UtcNow, patch)
-    {
-    }
+    public TimeRangePatch(JsonDocument? patch)
+        : this(DateTimeOffset.UtcNow, patch) { }
 
     /// <summary>
     /// instantiate with given "from" date and open end
     /// </summary>
-    public TimeRangePatch(DateTimeOffset from, JsonDocument? patch, DateTimeOffset? to = null, PatchingDirection patchingDirection = PatchingDirection.ParallelWithTime)
+    public TimeRangePatch(
+        DateTimeOffset from,
+        JsonDocument? patch,
+        DateTimeOffset? to = null,
+        PatchingDirection patchingDirection = PatchingDirection.ParallelWithTime
+    )
     {
         To = to;
         From = from;