Fix exitCodes for Fix command

return exitCode 1 if rulename is disabled or doesn't exist and add exitCode 2 if the rulename has no suggested fix.

Author: parhamsaremi

src/FSharpLint.Console/Program.fs

@@ -6,6 +6,7 @@ open System.IO
 open System.Text
 open FSharpLint.Framework
 open FSharpLint.Application
+open System.Linq
 
 /// Output format the linter will use.
 type private OutputFormat =
@@ -19,6 +20,12 @@ type private FileType =
     | File = 3
     | Source = 4
 
+type private ExitCode = 
+    | Error = -1
+    | Success = 0
+    | NoSuchRuleName = 1
+    | NoSuggestedFix = 2
+
 let fileTypeHelp = "Input type the linter will run against. If this is not set, the file type will be inferred from the file extension."
 
 // Allowing underscores in union case names for proper Argu command line option formatting.
@@ -90,7 +97,7 @@ let private inferFileType (target:string) =
         FileType.Source
 
 let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.Types.ToolsPath) =
-    let mutable exitCode = 0
+    let mutable exitCode = ExitCode.Success
 
     let output =
         match arguments.TryGetResult Format with
@@ -99,9 +106,9 @@ let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.
         | Some _
         | None -> Output.StandardOutput() :> Output.IOutput
 
-    let handleError (str:string) =
+    let handleError (status:ExitCode) (str:string) =
         output.WriteError str
-        exitCode <- -1
+        exitCode <- status
 
     let outputWarnings (warnings: List<Suggestion.LintWarning>) =
         String.Format(Resources.GetString "ConsoleFinished", List.length warnings)
@@ -111,25 +118,45 @@ let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.
         | LintResult.Success warnings ->
             outputWarnings warnings
             if List.isEmpty warnings |> not then 
-               exitCode <- -1
-        | LintResult.Failure failure -> handleError failure.Description
+               exitCode <- ExitCode.Error
+        | LintResult.Failure failure -> handleError ExitCode.Error failure.Description
 
     let handleFixResult (ruleName: string) = function
         | LintResult.Success warnings ->
             Resources.GetString "ConsoleApplyingSuggestedFixFile" |> output.WriteInfo
-            List.iter (fun (element: Suggestion.LintWarning) ->
-                let sourceCode = File.ReadAllText element.FilePath
-                match element.Details.SuggestedFix with
-                | Some suggestedFix when String.Equals(ruleName, element.RuleName, StringComparison.InvariantCultureIgnoreCase) ->
-                    suggestedFix.Force()
-                    |> Option.map (fun suggestedFix ->
-                        let updatedSourceCode = sourceCode.Replace(suggestedFix.FromText, suggestedFix.ToText)
-                        File.WriteAllText(element.FilePath, updatedSourceCode, Encoding.UTF8)) |> ignore
-                | _ -> ()) warnings
+            let increment = 1
+            let noFixIncrement = 0
+            let countSuggestedFix = 
+                List.fold (fun acc elem -> acc + elem) 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
+                                        )
+                                    File.WriteAllText(
+                                        element.FilePath,
+                                        updatedSourceCode,
+                                        Encoding.UTF8)
+                                    ) 
+                                    |> ignore |> fun () -> increment
+                            | None -> noFixIncrement
+                        else
+                            noFixIncrement) warnings)
             outputWarnings warnings
-            if List.isEmpty warnings |> not then 
-                exitCode <- 0
-        | LintResult.Failure failure -> handleError failure.Description
+
+            if countSuggestedFix > 0 then
+                exitCode <- ExitCode.Success
+            else
+                exitCode <- ExitCode.NoSuggestedFix
+
+        | LintResult.Failure failure -> handleError ExitCode.Error failure.Description
 
     let linting fileType lintParams target toolsPath shouldFix maybeRuleName =
         try
@@ -143,14 +170,14 @@ let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.
             if shouldFix then
                 match maybeRuleName with
                 | Some ruleName -> handleFixResult ruleName lintResult
-                | None -> exitCode <- 1
+                | None -> exitCode <- ExitCode.NoSuchRuleName
             else
                 handleLintResult lintResult
         with
         | e ->
             let target = if fileType = FileType.Source then "source" else target
             sprintf "Lint failed while analysing %s.\nFailed with: %s\nStack trace: %s" target e.Message e.StackTrace
-            |> handleError
+            |> (handleError ExitCode.Error)
 
     let getParams config =
         let paramConfig =
@@ -176,15 +203,33 @@ let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.
         let fixParams = getParams None
         let ruleName, target = fixArgs.GetResult Fix_Target
         let fileType = fixArgs.TryGetResult Fix_File_Type |> Option.defaultValue (inferFileType target)
-
-        linting fileType fixParams target toolsPath true (Some ruleName)
+        
+        let allRules = 
+            match getConfig fixParams.Configuration with
+            | Ok config -> Some (Configuration.flattenConfig config false)
+            | _ -> None
+
+        let allRuleNames =
+            match allRules with
+            | Some rules ->  (fun (loadedRules:Configuration.LoadedRules) -> ([|
+                loadedRules.LineRules.IndentationRule |> Option.map (fun rule -> rule.Name) |> Option.toArray
+                loadedRules.LineRules.NoTabCharactersRule |> Option.map (fun rule -> rule.Name) |> Option.toArray
+                loadedRules.LineRules.GenericLineRules |> Array.map (fun rule -> rule.Name)
+                loadedRules.AstNodeRules |> Array.map (fun rule -> rule.Name)
+                |] |> Array.concat |> Set.ofArray)) rules
+            | _ -> Set.empty
+
+        if allRuleNames.Any(fun aRuleName -> String.Equals(aRuleName, ruleName, StringComparison.InvariantCultureIgnoreCase)) then
+            linting fileType fixParams target toolsPath true (Some ruleName)
+        else
+            sprintf "Rule '%s' does not exist." ruleName |> (handleError ExitCode.NoSuchRuleName)
 
     match arguments.GetSubCommand() with
     | Lint lintArgs -> applyLint lintArgs
     | Fix fixArgs -> applySuggestedFix fixArgs
     | _ -> ()
 
-    exitCode
+    int exitCode
 
 /// Must be called only once per process.
 /// We're calling it globally so we can call main multiple times from our tests.

src/FSharpLint.Core/Application/Configuration.fs

@@ -129,13 +129,20 @@ type RuleConfig<'Config> = {
 
 type EnabledConfig = RuleConfig<unit>
 
-let constructRuleIfEnabled rule ruleConfig = if ruleConfig.Enabled then Some rule else None
+let constructRuleIfEnabledBase (onlyEnabled: bool) rule ruleConfig = 
+    if not onlyEnabled || ruleConfig.Enabled then Some rule else None
 
-let constructRuleWithConfig rule ruleConfig =
-    if ruleConfig.Enabled then
-        ruleConfig.Config |> Option.map rule
-    else
-        None
+let constructRuleIfEnabled rule ruleConfig = 
+    constructRuleIfEnabledBase true rule ruleConfig
+
+let constructRuleWithConfigBase (onlyEnabled: bool) (rule: 'TRuleConfig -> 'TRule) (ruleConfig: RuleConfig<'TRuleConfig>): Option<'TRule> =
+     if not onlyEnabled || ruleConfig.Enabled then
+         ruleConfig.Config |> Option.map rule
+     else
+         None
+ 
+let constructRuleWithConfig (rule: 'TRuleConfig -> 'TRule) (ruleConfig: RuleConfig<'TRuleConfig>): Option<'TRule> =
+    constructRuleWithConfigBase true rule ruleConfig
 
 type TupleFormattingConfig =
     { tupleCommaSpacing:EnabledConfig option
@@ -600,7 +607,7 @@ let private parseHints (hints:string []) =
     |> Array.toList
     |> MergeSyntaxTrees.mergeHints
 
-let flattenConfig (config:Configuration) =
+let flattenConfig (config:Configuration) (onlyEnabled:bool) =
     let deprecatedAllRules =
         [|
             config.formatting |> Option.map (fun config -> config.Flatten()) |> Option.toArray |> Array.concat
@@ -609,6 +616,12 @@ let flattenConfig (config:Configuration) =
             config.Hints |> Option.map (fun config -> HintMatcher.rule { HintMatcher.Config.HintTrie = parseHints (getOrEmptyList config.add) }) |> Option.toArray
         |] |> Array.concat
 
+    let constructRuleIfEnabled rule ruleConfig = 
+        constructRuleIfEnabledBase onlyEnabled rule ruleConfig
+
+    let constructRuleWithConfig (rule: 'TRuleConfig -> 'TRule) (ruleConfig: RuleConfig<'TRuleConfig>): Option<'TRule> =
+        constructRuleWithConfigBase onlyEnabled rule ruleConfig
+    
     let allRules =
         [|
             config.TypedItemSpacing |> Option.bind (constructRuleWithConfig TypedItemSpacing.rule)

src/FSharpLint.Core/Application/Lint.fs

@@ -206,7 +206,7 @@ module Lint =
             | Some(x) -> not x.IsCancellationRequested
             | None -> true
 
-        let enabledRules = Configuration.flattenConfig lintInfo.Configuration
+        let enabledRules = Configuration.flattenConfig lintInfo.Configuration true
 
         let lines = String.toLines fileInfo.Text |> Array.map (fun (line, _, _) -> line)
         let allRuleNames =
@@ -371,7 +371,7 @@ module Lint =
     }
 
     /// Gets a FSharpLint Configuration based on the provided ConfigurationParam.
-    let private getConfig (configParam:ConfigurationParam) =
+    let getConfig (configParam:ConfigurationParam) =
         match configParam with
         | Configuration config -> Ok config
         | FromFile filePath ->

src/FSharpLint.Core/Application/Lint.fsi

@@ -144,4 +144,6 @@ module Lint =
 
     /// Lints an F# file that has already been parsed using
     /// `FSharp.Compiler.Services` in the calling application.
-    val lintParsedFile : optionalParams:OptionalLintParameters -> parsedFileInfo:ParsedFileInformation -> filePath:string -> LintResult
+    val lintParsedFile : optionalParams:OptionalLintParameters -> parsedFileInfo:ParsedFileInformation -> filePath:string -> LintResult
+
+    val getConfig : ConfigurationParam -> Result<Configuration,string>

tests/FSharpLint.Console.Tests/TestApp.fs

@@ -126,3 +126,34 @@ module Fall =
         Assert.AreEqual(0, exitCode)
         Assert.AreEqual(set ["Usage of `new` keyword here is redundant."], errors)
         Assert.AreEqual(expected, File.ReadAllText input.FileName)
+
+    [<Test>]
+    member __.``Lint source with fix 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 |]
+
+        Assert.AreEqual(1, exitCode)
+
+    [<Test>]
+    member __.``Lint source with fix option no need for fix``() =
+        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 |]
+
+        Assert.AreEqual(2, exitCode)
+        Assert.AreEqual(sourceCode, File.ReadAllText input.FileName)