Remove dependency on System.IO.Abstractions (#116)

Author: Smaug123

ApiSurface/ApiSurface.fs

@@ -1,12 +1,11 @@
 namespace ApiSurface
 
 open System
-open System.IO.Abstractions
+open System.IO
 open System.Text.RegularExpressions
 open System.Runtime.CompilerServices
 open System.Runtime.InteropServices
 open System.Reflection
-open System.IO
 
 type ApiSurface = internal | ApiSurface of string list
 
@@ -176,37 +175,33 @@ module ApiSurface =
 
         assembly |> ofAssembly |> toString |> writer.Write
 
-    let private readCurrentVersion (version : IFileInfo) =
-        use stream = version.OpenRead ()
-        use reader = new StreamReader (stream)
+    let private readCurrentVersion (version : Stream) =
+        use reader = new StreamReader (version)
         let versionFile = VersionFile.read reader
 
         let versionParts = versionFile.Version.Split '.'
 
-        try
-            {
-                Major = int versionParts.[0]
-                Minor = int versionParts.[1]
-            }
-        with _ ->
-            // GitVersioning will verify the json file during build, before the test runs, so it's not expected that anyone will see this error.
-            failwithf
-                "Version in the version.json file must be of the form 'x.x' when x represents a whole number; it was %s."
-                versionFile.Version
-
-
-    let private writeUpdatedVersion (version : Version) (versionFile : IFileInfo) =
+        let parsedVersion =
+            try
+                {
+                    Major = int versionParts.[0]
+                    Minor = int versionParts.[1]
+                }
+            with _ ->
+                // GitVersioning will verify the json file during build, before the test runs, so it's not expected that anyone will see this error.
+                failwithf
+                    "Version in the version.json file must be of the form 'x.x' when x represents a whole number; it was %s."
+                    versionFile.Version
+
+        versionFile, parsedVersion
+
+    let private writeUpdatedVersion (oldVersionFile : VersionFile) (newVersion : Version) (versionFile : Stream) =
         let updatedFile =
-            use stream = versionFile.OpenRead ()
-            use reader = new StreamReader (stream)
-            let versionFile = VersionFile.read reader
-
-            { versionFile with
-                Version = sprintf "%d.%d" version.Major version.Minor
+            { oldVersionFile with
+                Version = sprintf "%d.%d" newVersion.Major newVersion.Minor
             }
 
-        use writer = versionFile.Open FileMode.Create
-        use writer = new StreamWriter (writer)
+        use writer = new StreamWriter (versionFile)
         updatedFile |> VersionFile.write writer
 
     let internal findNewVersion currentVersion (ApiSurface baseline) (ApiSurface target) =
@@ -228,8 +223,17 @@ module ApiSurface =
         // If the api was not changed, then GitVersioning will handle the patch version
         | _ -> currentVersion
 
-    let updateVersionJson (baseline : ApiSurface) (assembly : Assembly) (versionFile : IFileInfo) : unit =
-        let currentVersion = readCurrentVersion versionFile
+    let updateVersionJson<'fileInfo>
+        (baseline : ApiSurface)
+        (assembly : Assembly)
+        (versionFile : 'fileInfo)
+        (openVersionFile : 'fileInfo -> FileMode * FileAccess -> Stream)
+        : unit
+        =
+        let oldVersionFile, currentVersion =
+            use versionFile = openVersionFile versionFile (FileMode.Open, FileAccess.Read)
+            readCurrentVersion versionFile
+
         printfn "Current version %d.%d" currentVersion.Major currentVersion.Minor
 
         let updatedVersion = findNewVersion currentVersion baseline (ofAssembly assembly)
@@ -239,12 +243,14 @@ module ApiSurface =
         else
             printfn "Updated version to %d.%d" updatedVersion.Major updatedVersion.Minor
 
-        writeUpdatedVersion updatedVersion versionFile
+        do
+            use versionFile = openVersionFile versionFile (FileMode.Truncate, FileAccess.Write)
+            writeUpdatedVersion oldVersionFile updatedVersion versionFile
 
     let writeAssembly
         (baseline : ApiSurface)
         (possibleBaselineResources : string list)
-        (versionFiles : IFileInfo list)
+        (versionFiles : FileInfo list)
         (assembly : Assembly)
         : unit
         =
@@ -275,7 +281,7 @@ module ApiSurface =
         match versionFile with
         | Some versionFile ->
             printfn "Updating version.json file: %s" versionFile.FullName
-            updateVersionJson baseline assembly versionFile
+            updateVersionJson baseline assembly versionFile (fun f (mode, access) -> f.Open (mode, access))
         | None -> ()
 
         printfn "Updating baseline file: %s" baselinePath
@@ -285,13 +291,12 @@ module ApiSurface =
     let writeAssemblyBaselineWithDirectory (dir : string) (assembly : Assembly) : unit =
         let possibleBaselineResources = findBaselineResourcesWithDirectory dir assembly
 
-        let versionFiles =
-            VersionFile.findVersionFilesWithDirectory (FileSystem ()) dir assembly
+        let versionFiles = VersionFile.findVersionFilesWithDirectory FileInfo dir assembly
 
         writeAssembly (ofAssemblyBaseline assembly) possibleBaselineResources versionFiles assembly
 
     [<CompiledName "WriteAssemblyBaseline">]
     let writeAssemblyBaseline (assembly : Assembly) : unit =
         let possibleBaselineResources = findBaselineResources assembly
-        let versionFiles = VersionFile.findVersionFiles (FileSystem ()) assembly
+        let versionFiles = VersionFile.findVersionFiles FileInfo assembly
         writeAssembly (ofAssemblyBaseline assembly) possibleBaselineResources versionFiles assembly

ApiSurface/ApiSurface.fsi

@@ -1,5 +1,6 @@
 namespace ApiSurface
 
+open System.IO
 open System.Reflection
 
 /// Represents the public API surface of an assembly.
@@ -46,18 +47,26 @@ module ApiSurface =
     [<CompiledName "AssertIdentical">]
     val assertIdentical : Assembly -> unit
 
-    /// Updates an assembly's SurfaceBaseline.txt file on the disk.
-    /// Expects to find '../<AssemblyName>/SurfaceBaseline.txt' somewhere in
+    /// <summary>Updates an assembly's SurfaceBaseline.txt file on the disk.</summary>
+    /// <remarks>
+    /// Expects to find '../&lt;AssemblyName&gt;/SurfaceBaseline.txt' somewhere in
     /// the directory ancestry tree.
+    /// </remarks>
     [<CompiledName "WriteAssemblyBaseline">]
     val writeAssemblyBaseline : Assembly -> unit
 
-    /// Updates an assembly's SurfaceBaseline.txt file on the disk.
-    /// Expects to find '../<supplied directory>/SurfaceBaseline.txt' somewhere in the directory tree.
+    /// <summary>Updates an assembly's SurfaceBaseline.txt file on the disk.</summary>
+    /// <remarks>
+    /// Expects to find <c>../&lt;supplied directory&gt;/SurfaceBaseline.txt</c> somewhere in the directory tree.
+    /// </remarks>
     [<CompiledName "WriteAssemblyBaselineWithDirectory">]
     val writeAssemblyBaselineWithDirectory : string -> Assembly -> unit
 
     val internal findNewVersion : Version -> baseline : ApiSurface -> target : ApiSurface -> Version
 
-    val internal updateVersionJson :
-        baseline : ApiSurface -> Assembly -> versionFile : System.IO.Abstractions.IFileInfo -> unit
+    val internal updateVersionJson<'fileInfo> :
+        baseline : ApiSurface ->
+        Assembly ->
+        versionFile : 'fileInfo ->
+        openVersionFile : ('fileInfo -> FileMode * FileAccess -> Stream) ->
+            unit

ApiSurface/ApiSurface.fsproj

@@ -44,6 +44,5 @@
     <PackageReference Include="System.Text.Json" Version="8.0.5" NoWarn="%(NoWarn);NU1903" />
     <PackageReference Include="NuGet.Packaging" Version="6.14.0" />
     <PackageReference Include="NuGet.Protocol" Version="6.14.0" />
-    <PackageReference Include="System.IO.Abstractions" Version="4.2.13" />
   </ItemGroup>
 </Project>

ApiSurface/Assembly.fs

@@ -4,11 +4,12 @@ open System
 open System.IO
 open System.Reflection
 
+/// Helper functions for dealing with the Assembly type.
 [<RequireQualifiedAccess>]
-module internal Assembly =
+module Assembly =
 
     /// Attempt to retrieve an embedded resource from an assembly.
-    let tryReadEmbeddedResource (assembly : Assembly) (resourcePath : string) : Stream option =
+    let internal tryReadEmbeddedResource (assembly : Assembly) (resourcePath : string) : Stream option =
         let resourcePath = resourcePath.Replace ("/", ".")
         let assemblyResourceName ns = sprintf "%s.%s" ns resourcePath
 
@@ -26,6 +27,8 @@ module internal Assembly =
         |> Set.add resourcePath
         |> Seq.tryPick (assembly.GetManifestResourceStream >> Option.ofObj)
 
+    /// You are not expected to use this function directly.
+    ///
     /// Finds all 'fileNames' in ancestor directories of the assembly's location, where
     /// we specifically look for the given parentDir.
     let findProjectFilesWithDirectory (parentDir : string) fileNames (assembly : Assembly) =
@@ -56,6 +59,8 @@ module internal Assembly =
         fileNames assembly
         |> List.map (fun f -> Path.Combine (findParentDir parentDir (FileInfo assembly.Location).Directory, f))
 
-    /// Finds all 'fileNames' in ancestor directories of 'assembly'
-    let findProjectFiles fileNames (assembly : Assembly) =
+    /// You are not expected to use this function directly.
+    ///
+    /// Finds all 'fileNames' in ancestor directories of 'assembly'.
+    let findProjectFiles (fileNames : Assembly -> string list) (assembly : Assembly) =
         findProjectFilesWithDirectory (assembly.GetName().Name) fileNames assembly

ApiSurface/SurfaceBaseline.txt

@@ -24,6 +24,9 @@ ApiSurface.ApiSurfaceModule.FromAssemblyCustomPrint [static method]: (ApiSurface
 ApiSurface.ApiSurfaceModule.ToString [static method]: ApiSurface.ApiSurface -> string
 ApiSurface.ApiSurfaceModule.WriteAssemblyBaseline [static method]: System.Reflection.Assembly -> unit
 ApiSurface.ApiSurfaceModule.WriteAssemblyBaselineWithDirectory [static method]: string -> System.Reflection.Assembly -> unit
+ApiSurface.Assembly inherit obj
+ApiSurface.Assembly.findProjectFiles [static method]: (System.Reflection.Assembly -> string list) -> System.Reflection.Assembly -> string list
+ApiSurface.Assembly.findProjectFilesWithDirectory [static method]: string -> (System.Reflection.Assembly -> string list) -> System.Reflection.Assembly -> string list
 ApiSurface.DocCoverage inherit obj, implements ApiSurface.DocCoverage System.IEquatable, System.Collections.IStructuralEquatable, ApiSurface.DocCoverage System.IComparable, System.IComparable, System.Collections.IStructuralComparable
 ApiSurface.DocCoverageModule inherit obj
 ApiSurface.DocCoverageModule.AssertFullyDocumented [static method]: System.Reflection.Assembly -> unit
@@ -111,7 +114,7 @@ ApiSurface.VersionFile.PathFilters [property]: [read-only] string list option
 ApiSurface.VersionFile.PublicReleaseRefSpec [property]: [read-only] string list
 ApiSurface.VersionFile.Version [property]: [read-only] string
 ApiSurface.VersionFileModule inherit obj
-ApiSurface.VersionFileModule.findVersionFiles [static method]: System.IO.Abstractions.IFileSystem -> System.Reflection.Assembly -> System.IO.Abstractions.IFileInfo list
-ApiSurface.VersionFileModule.findVersionFilesWithDirectory [static method]: System.IO.Abstractions.IFileSystem -> string -> System.Reflection.Assembly -> System.IO.Abstractions.IFileInfo list
+ApiSurface.VersionFileModule.findVersionFiles [static method]: (string -> 'fileInfo) -> System.Reflection.Assembly -> 'fileInfo list
+ApiSurface.VersionFileModule.findVersionFilesWithDirectory [static method]: (string -> 'fileInfo) -> string -> System.Reflection.Assembly -> 'fileInfo list
 ApiSurface.VersionFileModule.read [static method]: System.IO.StreamReader -> ApiSurface.VersionFile
-ApiSurface.VersionFileModule.write [static method]: System.IO.StreamWriter -> ApiSurface.VersionFile -> unit
+ApiSurface.VersionFileModule.write [static method]: System.IO.StreamWriter -> ApiSurface.VersionFile -> unit

ApiSurface/Test/TestVersionFile.fs

@@ -159,7 +159,7 @@ module TestVersionFile =
             |> fun s -> fs.File.WriteAllText (location.FullName, s)
 
             let baseline = ApiSurface [ "something" ; "something else" ]
-            ApiSurface.updateVersionJson baseline typeof<ApiSurface>.Assembly location
+            ApiSurface.updateVersionJson baseline typeof<ApiSurface>.Assembly location _.Open
 
             let output = fs.File.ReadAllText location.FullName
 

ApiSurface/VersionFile.fs

@@ -1,10 +1,8 @@
 namespace ApiSurface
 
 open System.IO
-open System.IO.Abstractions
 open System.Text.Json
 open System.Reflection
-open System.Text.Json.Serialization
 
 /// A record representing the layout of a version.json file, e.g. as consumed by NerdBank.GitVersioning.
 type VersionFile =
@@ -40,15 +38,33 @@ module VersionFile =
         JsonSerializer.Serialize (versionFile, writeOptions) |> writer.Write
 
     /// Find version.json files referenced within this assembly.
-    let findVersionFiles (fs : IFileSystem) (assembly : Assembly) : IFileInfo list =
+    /// Pass e.g. `fs.FileInfo.FromFileName` (from System.IO.Abstractions) or `FileInfo` (from System.IO)
+    /// as the `fromFileName` argument.
+    let inline findVersionFiles< ^fileInfo when ^fileInfo : (member Exists : bool)>
+        (fromFileName : string -> 'fileInfo)
+        (assembly : Assembly)
+        : 'fileInfo list
+        =
         let filenames = assembly |> Assembly.findProjectFiles (fun _ -> [ "version.json" ])
-        filenames |> List.filter File.Exists |> List.map fs.FileInfo.FromFileName
+
+        filenames
+        |> List.map fromFileName
+        |> List.filter (fun f -> (^fileInfo : (member Exists : bool) f))
 
     /// Find version.json files above this assembly, but stopping when we hit a directory with
     /// the given name.
-    let findVersionFilesWithDirectory (fs : IFileSystem) (dir : string) (assembly : Assembly) : IFileInfo list =
+    /// Pass e.g. `fs.FileInfo.FromFileName` (from System.IO.Abstractions) or `FileInfo` (from System.IO)
+    /// as the `fromFileName` argument.
+    let inline findVersionFilesWithDirectory<'fileInfo when ^fileInfo : (member Exists : bool)>
+        (fromFileName : string -> 'fileInfo)
+        (dir : string)
+        (assembly : Assembly)
+        : 'fileInfo list
+        =
         let filenames =
             assembly
             |> Assembly.findProjectFilesWithDirectory dir (fun _ -> [ "version.json" ])
 
-        filenames |> List.filter File.Exists |> List.map fs.FileInfo.FromFileName
+        filenames
+        |> List.map fromFileName
+        |> List.filter (fun f -> (^fileInfo : (member Exists : bool) f))

ApiSurface/version.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.1",
+  "version": "5.0",
   "publicReleaseRefSpec": [
     "^refs/heads/main$"
   ],
@@ -17,4 +17,4 @@
     ":^/.git-blame-ignore-revs",
     ":^/.gitignore"
   ]
-}
+}