Easy dotnet conventions to verify

src/FileConventions.Test/DummyFiles/DummyScriptWithConventionalEmptyString.fsx

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S dotnet fsi
+
+open System
+open System.IO
+
+let emptyString = String.Empty

src/FileConventions.Test/DummyFiles/DummyScriptWithNonConventionalEmptyString.fsx

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S dotnet fsi
+
+open System
+open System.IO
+
+let emptyString = ""

src/FileConventions.Test/DummyFiles/src/Foo/Bar/DummyFileUnderBarWithRightNamespace.fs

@@ -0,0 +1 @@
+namespace Foo.Bar

src/FileConventions.Test/DummyFiles/src/Foo/Bar/DummyFileUnderBarWithWrongNamespace.fs

@@ -0,0 +1 @@
+namespace Foo.Baz

src/FileConventions.Test/DummyFiles/src/Foo/Bar/DummyFileUnderBarWithWrongNamespace2.fs

@@ -0,0 +1 @@
+namespace Bar

src/FileConventions.Test/DummyFiles/src/Foo/DummyFileUnderFooWithRightNamespace.cs

@@ -0,0 +1,3 @@
+using System;
+
+namespace Foo;

src/FileConventions.Test/DummyFiles/src/Foo/DummyFileUnderFooWithRightNamespace.fs

@@ -0,0 +1 @@
+namespace Foo

src/FileConventions.Test/DummyFiles/src/Foo/DummyFileUnderFooWithWrongNamespace.fs

@@ -0,0 +1 @@
+namespace Baz

src/FileConventions.Test/DummyFiles/src/Foo/DummyFileUnderFooWithWrongNamespace2.fs

@@ -0,0 +1 @@
+namespace FooBuzz

src/FileConventions.Test/FileConventions.Test.fs

@@ -586,3 +586,165 @@ let IsExecutableTest2() =
         ))
 
     Assert.That(IsExecutable fileInfo, Is.EqualTo false)
+
+
+[<Test>]
+let DefiningEmptyStringsWithDoubleQuotes1() =
+    let fileInfo =
+        (FileInfo(
+            Path.Combine(
+                dummyFilesDirectory.FullName,
+                "DummyScriptWithConventionalEmptyString.fsx"
+            )
+        ))
+
+    Assert.That(DefiningEmptyStringsWithDoubleQuotes fileInfo, Is.EqualTo false)
+
+
+[<Test>]
+let DefiningEmptyStringsWithDoubleQuotes2() =
+    let fileInfo =
+        (FileInfo(
+            Path.Combine(
+                dummyFilesDirectory.FullName,
+                "DummyScriptWithNonConventionalEmptyString.fsx"
+            )
+        ))
+
+    Assert.That(DefiningEmptyStringsWithDoubleQuotes fileInfo, Is.EqualTo true)
+
+
+[<Test>]
+let ProjFilesNamingConvention1() =
+    let fileInfo =
+        (FileInfo(
+            Path.Combine(
+                dummyFilesDirectory.FullName,
+                "DummyProjFileWithTheSameNameAsItsParentFolder",
+                "DummyProjFileWithTheSameNameAsItsParentFolder.fsproj"
+            )
+        ))
+
+    Assert.That(ProjFilesNamingConvention fileInfo, Is.EqualTo false)
+
+
+[<Test>]
+let ProjFilesNamingConvention2() =
+    let fileInfo =
+        (FileInfo(
+            Path.Combine(
+                dummyFilesDirectory.FullName,
+                "DummyProject",
+                "DummyProjFileWithoutTheSameNameAsItsParentFolder.fsproj"
+            )
+        ))
+
+    Assert.That(ProjFilesNamingConvention fileInfo, Is.EqualTo true)
+
+
+[<Test>]
+let NamespaceConvention1() =
+    let fileInfo =
+        (FileInfo(
+            Path.Combine(
+                dummyFilesDirectory.FullName,
+                "src",
+                "Foo",
+                "DummyFileUnderFooWithRightNamespace.fs"
+            )
+        ))
+
+    Assert.That(NotFollowingNamespaceConvention fileInfo, Is.EqualTo false)
+
+
+[<Test>]
+let NamespaceConvention2() =
+    let fileInfo =
+        (FileInfo(
+            Path.Combine(
+                dummyFilesDirectory.FullName,
+                "src",
+                "Foo",
+                "DummyFileUnderFooWithWrongNamespace.fs"
+            )
+        ))
+
+    Assert.That(NotFollowingNamespaceConvention fileInfo, Is.EqualTo true)
+
+
+[<Test>]
+let NamespaceConvention3() =
+    let fileInfo =
+        (FileInfo(
+            Path.Combine(
+                dummyFilesDirectory.FullName,
+                "src",
+                "Foo",
+                "Bar",
+                "DummyFileUnderBarWithRightNamespace.fs"
+            )
+        ))
+
+    Assert.That(NotFollowingNamespaceConvention fileInfo, Is.EqualTo false)
+
+
+[<Test>]
+let NamespaceConvention4() =
+    let fileInfo =
+        (FileInfo(
+            Path.Combine(
+                dummyFilesDirectory.FullName,
+                "src",
+                "Foo",
+                "Bar",
+                "DummyFileUnderBarWithWrongNamespace.fs"
+            )
+        ))
+
+    Assert.That(NotFollowingNamespaceConvention fileInfo, Is.EqualTo true)
+
+
+[<Test>]
+let NamespaceConvention5() =
+    let fileInfo =
+        (FileInfo(
+            Path.Combine(
+                dummyFilesDirectory.FullName,
+                "src",
+                "Foo",
+                "Bar",
+                "DummyFileUnderBarWithWrongNamespace2.fs"
+            )
+        ))
+
+    Assert.That(NotFollowingNamespaceConvention fileInfo, Is.EqualTo true)
+
+
+[<Test>]
+let NamespaceConvention6() =
+    let fileInfo =
+        (FileInfo(
+            Path.Combine(
+                dummyFilesDirectory.FullName,
+                "src",
+                "Foo",
+                "DummyFileUnderFooWithRightNamespace.cs"
+            )
+        ))
+
+    Assert.That(NotFollowingNamespaceConvention fileInfo, Is.EqualTo false)
+
+
+[<Test>]
+let NamespaceConvention7() =
+    let fileInfo =
+        (FileInfo(
+            Path.Combine(
+                dummyFilesDirectory.FullName,
+                "src",
+                "Foo",
+                "DummyFileUnderFooWithWrongNamespace2.fs"
+            )
+        ))
+
+    Assert.That(NotFollowingNamespaceConvention fileInfo, Is.EqualTo true)

src/FileConventions/Library.fs

@@ -390,3 +390,55 @@ let NonVerboseFlags(fileInfo: FileInfo) =
 let IsExecutable(fileInfo: FileInfo) =
     let hasExecuteAccess = Syscall.access(fileInfo.FullName, AccessModes.X_OK)
     hasExecuteAccess = 0
+
+let DefiningEmptyStringsWithDoubleQuotes(fileInfo: FileInfo) =
+    let fileText = File.ReadAllText fileInfo.FullName
+    fileText.Contains "\"\""
+
+let ProjFilesNamingConvention(fileInfo: FileInfo) =
+    let regex = new Regex("(.*)\..*proj$")
+    assert (regex.IsMatch fileInfo.FullName)
+    let fileName = Path.GetFileNameWithoutExtension fileInfo.FullName
+
+    let parentDirectoryName =
+        Path.GetDirectoryName fileInfo.FullName |> Path.GetFileName
+
+    printfn
+        "File name: %s, Parent directory name: %s"
+        fileName
+        parentDirectoryName
+
+    fileName <> parentDirectoryName
+
+let DoesNamespaceInclude (fileInfo: FileInfo) (word: string) =
+    let fileText = File.ReadLines fileInfo.FullName
+
+    if fileText.Any() then
+        let rightNamespace =
+            fileText |> Seq.find(fun x -> x.Contains "namespace")
+
+        rightNamespace.Split().[1].Equals(word)
+        || rightNamespace.Split().[1].Equals(word + ";")
+    else
+        false
+
+let NotFollowingNamespaceConvention(fileInfo: FileInfo) =
+    assert
+        (fileInfo.FullName.EndsWith(".fs") || fileInfo.FullName.EndsWith(".cs"))
+
+    let fileName = Path.GetFileNameWithoutExtension fileInfo.FullName
+    let parentDir = Path.GetDirectoryName fileInfo.FullName |> DirectoryInfo
+
+    printfn "File name: %s, Parent directory name: %s" fileName parentDir.Name
+
+    if parentDir.Parent.Name = "src" then
+        DoesNamespaceInclude fileInfo parentDir.Name |> not
+
+    elif parentDir.Parent.Parent.Name = "src" then
+        DoesNamespaceInclude
+            fileInfo
+            $"{parentDir.Parent.Name}.{parentDir.Name}"
+        |> not
+
+    else
+        false