Add new tag --check to fix command

Add --check functionality to fix command. When passed will ignore fixes and will only check if passed rule has suggested fixes.

Author: parhamsaremi

src/FSharpLint.Console/Program.fs

@@ -22,9 +22,10 @@ type private FileType =
 
 type private ExitCode = 
     | Error = -1
-    | Success = 0
+    | Success = 0 // for `fix` when the file is changed and for `fix --check` when there are no fixes available. 
     | NoSuchRuleName = 1
-    | NoSuggestedFix = 2
+    | NoSuggestedFix = 2 // only for fix (without --check)
+    | FixExists = 3 //only for fix --check
 
 let fileTypeHelp = "Input type the linter will run against. If this is not set, the file type will be inferred from the file extension."
 
@@ -63,13 +64,15 @@ with
 and private FixArgs =
     | [<MainCommand; Mandatory>] Fix_Target of ruleName:string * target:string
     | Fix_File_Type of FileType
+    | Check
 // fsharplint:enable UnionDefinitionIndentation
 with
     interface IArgParserTemplate with
         member this.Usage =
             match this with
             | Fix_Target _ -> "Rule name to be applied with suggestedFix and input to lint."
             | Fix_File_Type _ -> fileTypeHelp
+            | Check _ -> "If passed to the fix command, the linter will only check if the fix is needed."
 // fsharplint:enable UnionCasesNames
 
 let private parserProgress (output:Output.IOutput) = function
@@ -106,7 +109,7 @@ let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.
         | Some _
         | None -> Output.StandardOutput() :> Output.IOutput
 
-    let handleError (status:ExitCode) (str:string) =
+    let handleError (status: ExitCode) (str: string) =
         output.WriteError str
         exitCode <- status
 
@@ -121,44 +124,64 @@ let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.
                exitCode <- ExitCode.Error
         | LintResult.Failure failure -> handleError ExitCode.Error failure.Description
 
-    let handleFixResult (ruleName: string) = function
+    let handleFixResult (ruleName: string) (checkFlag: bool) = function
         | LintResult.Success warnings ->
-            Resources.GetString "ConsoleApplyingSuggestedFixFile" |> output.WriteInfo
-            let increment = 1
+            if checkFlag |> not then
+                Resources.GetString "ConsoleApplyingSuggestedFixFile" |> output.WriteInfo
             let noFixIncrement = 0
-            let countSuggestedFix = 
-                List.fold (fun acc elem -> acc + elem) 0 (
+            let foundFixIncrement = 1
+            let noSuggestedFixIncrement = 2
+            let countFixStatus = 
+                List.fold (fun (accNoFix, accFoundFix, accNoSuggestedFix) elem -> 
+                    if elem = noFixIncrement then
+                        (accNoFix + 1, accFoundFix, accNoSuggestedFix)
+                    elif elem = foundFixIncrement then
+                        (accNoFix, accFoundFix + 1, accNoSuggestedFix)
+                    elif elem = noSuggestedFixIncrement then
+                        (accNoFix, accFoundFix, accNoSuggestedFix + 1)
+                    else
+                        failwith "Code should never reach here!") (0, 0, 0) (
                     List.map (fun (element: Suggestion.LintWarning) ->
                         let sourceCode = File.ReadAllText element.FilePath
                         if String.Equals(ruleName, element.RuleName, StringComparison.InvariantCultureIgnoreCase) then
                             match element.Details.SuggestedFix with
                             | Some suggestedFix ->
-                                suggestedFix.Force()
-                                |> Option.map (fun suggestedFix ->
-                                    let updatedSourceCode = 
-                                        sourceCode.Replace(
-                                            suggestedFix.FromText,
-                                            suggestedFix.ToText
+                                ((fun checkFlag ->
+                                if not checkFlag then
+                                    (suggestedFix.Force()
+                                    |> Option.map (fun suggestedFix ->
+                                        let updatedSourceCode = 
+                                            sourceCode.Replace(
+                                                suggestedFix.FromText,
+                                                suggestedFix.ToText
+                                            )
+                                        File.WriteAllText(
+                                            element.FilePath,
+                                            updatedSourceCode,
+                                            Encoding.UTF8)
                                         )
-                                    File.WriteAllText(
-                                        element.FilePath,
-                                        updatedSourceCode,
-                                        Encoding.UTF8)
-                                    ) 
-                                    |> ignore |> fun () -> increment
-                            | None -> noFixIncrement
+                                    ) |> ignore
+                                else
+                                    ()
+                                ) checkFlag)
+                                |> ignore |> fun () -> foundFixIncrement
+                            | None -> noSuggestedFixIncrement
                         else
                             noFixIncrement) warnings)
             outputWarnings warnings
-
-            if countSuggestedFix > 0 then
+            let (accNoFix, accFoundFix, accNoSuggestedFix) = countFixStatus
+            if not checkFlag && accFoundFix > 0 then
                 exitCode <- ExitCode.Success
-            else
+            elif not checkFlag then
                 exitCode <- ExitCode.NoSuggestedFix
+            elif checkFlag && accFoundFix > 0 then
+                exitCode <- ExitCode.FixExists
+            elif checkFlag then
+                exitCode <- ExitCode.Success
 
         | LintResult.Failure failure -> handleError ExitCode.Error failure.Description
 
-    let linting fileType lintParams target toolsPath shouldFix maybeRuleName =
+    let linting fileType lintParams target toolsPath shouldFix maybeRuleName checkFlag =
         try
             let lintResult =
                 match fileType with
@@ -169,7 +192,7 @@ let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.
                 | _ -> Lint.lintProject lintParams target toolsPath
             if shouldFix then
                 match maybeRuleName with
-                | Some ruleName -> handleFixResult ruleName lintResult
+                | Some ruleName -> handleFixResult ruleName checkFlag lintResult
                 | None -> exitCode <- ExitCode.NoSuchRuleName
             else
                 handleLintResult lintResult
@@ -197,12 +220,13 @@ let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.
         let target = lintArgs.GetResult Target
         let fileType = lintArgs.TryGetResult File_Type |> Option.defaultValue (inferFileType target)
 
-        linting fileType lintParams target toolsPath false None
+        linting fileType lintParams target toolsPath false None false
 
     let applySuggestedFix (fixArgs: ParseResults<FixArgs>) =
         let fixParams = getParams None
         let ruleName, target = fixArgs.GetResult Fix_Target
         let fileType = fixArgs.TryGetResult Fix_File_Type |> Option.defaultValue (inferFileType target)
+        let checkFlag = fixArgs.Contains Check
 
         let allRules = 
             match getConfig fixParams.Configuration with
@@ -220,7 +244,7 @@ let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.
             | _ -> Set.empty
 
         if allRuleNames.Any(fun aRuleName -> String.Equals(aRuleName, ruleName, StringComparison.InvariantCultureIgnoreCase)) then
-            linting fileType fixParams target toolsPath true (Some ruleName)
+            linting fileType fixParams target toolsPath true (Some ruleName) checkFlag
         else
             sprintf "Rule '%s' does not exist." ruleName |> (handleError ExitCode.NoSuchRuleName)
 

tests/FSharpLint.Console.Tests/TestApp.fs

@@ -139,6 +139,39 @@ printfn "Hello"
 
         Assert.AreEqual(1, exitCode)
 
+    [<Test>]
+    member __.``Lint source with fix check option with wrong rulename``() =
+        let sourceCode = """
+printfn "Hello"
+        """
+
+        let ruleName = "ssrffss"
+        use input = new TemporaryFile(sourceCode, "fs")
+        let (exitCode, errors) = main [| "fix"; ruleName; input.FileName; "--check" |]
+
+        Assert.AreEqual(1, exitCode)
+
+    [<Test>]
+    member __.``Lint source with fix check option``() =
+        let sourceCode = """
+module Fass =
+    let foo = new System.Collections.Generic.Dictionary<string, string>() |> ignore
+    let goo = new Guid() |> ignore
+    let ntoo = new Int32() |> ignore
+module Fall =
+    let uoo = new Uid() |> ignore
+    let version =  new System.Version()
+    let xoo = new Uint32() |> ignore
+        """
+
+        let ruleName = "RedundantNewKeyword"
+        use input = new TemporaryFile(sourceCode, "fs")
+        let (exitCode, errors) = main [| "fix"; ruleName; input.FileName; "--check" |]
+
+        Assert.AreEqual(3, exitCode)
+        Assert.AreEqual(set ["Usage of `new` keyword here is redundant."], errors)
+        Assert.AreEqual(sourceCode, File.ReadAllText input.FileName)
+
     [<Test>]
     member __.``Lint source with fix option no need for fix``() =
         let sourceCode = """
@@ -157,3 +190,23 @@ module Fall =
 
         Assert.AreEqual(2, exitCode)
         Assert.AreEqual(sourceCode, File.ReadAllText input.FileName)
+
+        Assert.AreEqual(sourceCode, File.ReadAllText input.FileName)
+
+    [<Test>]
+    member __.``Lint source with fix option no need for fix with check option``() =
+        let sourceCode = """
+module Fass =
+    let foo = System.Collections.Generic.Dictionary<string, string>() |> ignore
+    let goo = Guid() |> ignore
+    let ntoo = Int32() |> ignore
+module Fall =
+    let uoo = Uid() |> ignore
+    let version =  System.Version()
+    let xoo = Uint32() |> ignore
+        """
+        let ruleName = "RedundantNewKeyword"
+        use input = new TemporaryFile(sourceCode, "fs")
+        let (exitCode, errors) = main [| "fix"; ruleName; input.FileName; "--check" |]
+
+        Assert.AreEqual(0, exitCode)