Fix completion of command when there is more text after

Author: thinkbeforecoding

src/Fargo/Fargo.fs

@@ -127,7 +127,7 @@ module Fargo =
             if Usage.isStop pos x then
                 Usage.complete usage x.Text 
             elif Usage.isMatch usage x  then
-                    if pos <= y.Extent.End then
+                    if pos > x.Extent.End && pos <= y.Extent.End then
                         (complete y.Text tokens, true)
                     else
                         [], false
@@ -376,11 +376,15 @@ module Fargo =
         let complete pos tokens =
             match px tokens with
             | Ok x, restx, usagex ->
-                let pf, cf = f x
-                cf pos restx
+                if not (Tokens.contains pos tokens) || Tokens.contains pos restx then
+                    let _pf, cf = f x
+                    cf pos restx
+                else
+                    cx pos tokens
             | Error _, _, _ ->
                 cx pos tokens
         parse, complete
+
     let ret (x: 'a) : Arg<'a> =
         let parse tokens =
             Ok x, tokens, Usages.empty
@@ -804,7 +808,7 @@ Register-ArgumentCompleter -Native  -CommandName %s -ScriptBlock {
         }
 
 
-    let run appName ((p,c): Arg<'a>) (cmdLine: string[]) (f: CancellationToken ->'a  -> Task<int>) : int =
+    let run appName ((p,c): Arg<'a>) (cmdLine: string[]) (f: CancellationToken -> 'a  -> Task<int>) : int =
         use cts = new CancellationTokenSource()
         let mutable graceful = true
         Console.CancelKeyPress
@@ -817,15 +821,15 @@ Register-ArgumentCompleter -Native  -CommandName %s -ScriptBlock {
             else
                 printfn $"{Colors.red}[Ctrl+C]Force stop{Colors.def}"
             )
-        let tokens = Token.ofCmdLine cmdLine
+        let tokens = Tokens.ofCmdLine cmdLine
         let runner = 
             innerRun (pRun appName) tokens (fun cmd ->
                 task {
                     match cmd with
                     | TopComplete(pos, rest)  ->
                         let cmdTokens = 
                             match rest with
-                            | [x] -> Token.ofString x.Text
+                            | [x] -> Tokens.ofString x.Text
                             | _ -> rest
                         for result in complete (fargo { do! pRemoveAppName appName
                                                         return! (p,c)}) pos cmdTokens do

src/Fargo/Token.fs

@@ -37,7 +37,6 @@ module Extent =
         pos >= extent.Start && pos <= extent.End
 
 module Token =
-    open Microsoft.FSharp.Core.CompilerServices
 
     let inline extent s e = { Start = s; End = e}
 
@@ -54,41 +53,44 @@ module Token =
         | Quotes q -> Some q
         | StartQuote _ | NoQuotes -> None
 
+
+module Tokens =
+    open Microsoft.FSharp.Core.CompilerServices
     let rec private loop (input: string) (pos: int) (result: ListCollector<_> byref) =
-            if pos >= input.Length then
-                result.Close()
+        if pos >= input.Length then
+            result.Close()
+        else
+            if input[pos] = '"' then
+                loopQuote '"' input pos &result 
+            elif input[pos] = '\'' then
+                loopQuote '\'' input pos &result 
             else
-                if input[pos] = '"' then
-                    loopQuote '"' input pos &result 
-                elif input[pos] = '\'' then
-                    loopQuote '\'' input pos &result 
-                else
-                    match input.IndexOf(' ', pos) with
-                    | -1 ->
-                        result.Add { Text = input.Substring(pos)
-                                     Extent = extent pos input.Length
-                                     Quotes = NoQuotes}
-                        result.Close()
-                    | n -> 
-                        let txt = input.Substring(pos, n-pos)
-                        if txt <> "" then
-                            result.Add { Text = txt
-                                         Extent = extent pos n
-                                         Quotes = NoQuotes }
-                        loop input (n+1) &result
+                match input.IndexOf(' ', pos) with
+                | -1 ->
+                    result.Add { Text = input.Substring(pos)
+                                 Extent = Token.extent pos input.Length
+                                 Quotes = NoQuotes}
+                    result.Close()
+                | n -> 
+                    let txt = input.Substring(pos, n-pos)
+                    if txt <> "" then
+                        result.Add { Text = txt
+                                     Extent = Token.extent pos n
+                                     Quotes = NoQuotes }
+                    loop input (n+1) &result
     and loopQuote quote (input: string) (pos: int) (result: ListCollector<_> byref) =
-            match input.IndexOf(quote, pos+1) with
-            | -1 ->
-                result.Add { Text = input.Substring(pos+1)
-                             Extent = extent (pos+1) input.Length
-                             Quotes = StartQuote quote}
-                result.Close()
-            | n -> 
-                let txt = input.Substring(pos+1, n-pos-1)
-                result.Add { Text = txt
-                             Extent = extent (pos+1) n
-                             Quotes = Quotes quote }
-                loop input (n+1) &result
+        match input.IndexOf(quote, pos+1) with
+        | -1 ->
+            result.Add { Text = input.Substring(pos+1)
+                         Extent = Token.extent (pos+1) input.Length
+                         Quotes = StartQuote quote}
+            result.Close()
+        | n -> 
+            let txt = input.Substring(pos+1, n-pos-1)
+            result.Add { Text = txt
+                         Extent = Token.extent (pos+1) n
+                         Quotes = Quotes quote }
+            loop input (n+1) &result
 
     let ofString (input: string) =
         if isNull input then
@@ -109,7 +111,7 @@ module Token =
                         Quotes '\''
                     else
                         NoQuotes
-                result.Add({Text = token; Extent = extent pos (pos + token.Length); Quotes = quotes} )
+                result.Add({Text = token; Extent = Token.extent pos (pos + token.Length); Quotes = quotes} )
                 pos <- pos + token.Length + 1
 
         result.Close()
@@ -124,20 +126,23 @@ module Token =
         let rec loop pos tokens =
             match tokens with
             | token :: rest ->
-                let extent = outerExtent token
+                let extent = Token.outerExtent token
                 let startPad = max (extent.Start - pos) 0
                 builder.Append(' ', startPad) |> ignore
 
-                startQuote token
+                Token.startQuote token
                 |> Option.iter (fun q -> builder.Append(q) |> ignore)
 
                 builder.Append(token.Text) |> ignore
 
-                endQuote token
+                Token.endQuote token
                 |> Option.iter (fun q -> builder.Append(q) |> ignore)
 
 
                 loop extent.End rest
             | [] -> builder.ToString()
         loop 0 (tokens |> List.sortBy (fun t -> t.Extent))
-
+ 
+    let contains pos (tokens: Token list) =
+        tokens
+        |> List.exists (Token.outerExtent >> (Extent.contains pos))

tests/Fargo.Test/AllAtOnce.fs

@@ -65,11 +65,11 @@ let p =
 
 
 let parse input =
-    tryParseTokens p (Token.ofString input)
+    tryParseTokens p (Tokens.ofString input)
     |> Result.mapError (fun (errs,usages) -> errs, [ for u in usages.Options -> u.Name |> Option.defaultValue "" ])
 
 let complete pos input =
-    Fargo.Run.complete p pos (Token.ofString input)
+    Fargo.Run.complete p pos (Tokens.ofString input)
 
 let complete2 pos input =
     Testing.withStdout (fun _ ->
@@ -217,3 +217,16 @@ let ``completion of command complete``() =
     =! """select"""
 
 
+[<Fact>]
+let ``completion of command on a token in the middle``() =
+    complete2 10 "voice sele --voice funny"
+    =! "select"
+
+[<Fact>]
+let ``completion of command on a full token in the middle``() =
+    complete2 12 "voice select --voice funny"
+    =! "select"
+
+
+
+

tests/Fargo.Test/Completion.fs

@@ -8,7 +8,7 @@ open FsCheck.Xunit
 open DEdge.Diffract
 
 let complete (arg: Arg<_>) pos cmdLine =
-    complete arg pos (Token.ofString cmdLine)
+    complete arg pos (Tokens.ofString cmdLine)
 
 let (=!) (actual:'a) (expected: 'a) = Differ.Assert(expected, actual )
 

tests/Fargo.Test/Parsing.fs

@@ -10,15 +10,15 @@ let (=!) (actual:'a) (expected: 'a) = Differ.Assert(expected, actual )
 
 
 let parse ((p,_): Arg<'t>) input =
-    let result, _, _ = p (Token.ofString input)
+    let result, _, _ = p (Tokens.ofString input)
     result
 
 let rest ((p,c): Arg<'t>) input =
-    let _, tokens, _ = p (Token.ofString input)
-    Token.toString tokens
+    let _, tokens, _ = p (Tokens.ofString input)
+    Tokens.toString tokens
 
 let usage ((p,c): Arg<'t>) input =
-    let _, _, usages = p (Token.ofString input)
+    let _, _, usages = p (Tokens.ofString input)
     usages.Options
 
 
@@ -904,6 +904,6 @@ module Error =
 
     [<Property>]
     let ``Errorf always fails``(NonNull fargo) =
-        let p = errorf (fun tokens -> Token.toString tokens ) 
+        let p = errorf (fun tokens -> Tokens.toString tokens ) 
         parse p fargo
         =! Error [ fargo.TrimEnd(' ')]

tests/Fargo.Test/Token.fs

@@ -17,98 +17,98 @@ let qtoken q text s e = { Text = text; Extent = {  Start = s; End = e}; Quotes =
 let sqtoken q text s e = { Text = text; Extent = { Start = s; End = e}; Quotes = StartQuote q} 
 
 [<Fact>]
-let ``Token.ofList should produce correst Start and End``() = 
-    Token.ofList ["cmd";"--arg";"value"]
+let ``Tokens.ofList should produce correst Start and End``() = 
+    Tokens.ofList ["cmd";"--arg";"value"]
     =! [ token "cmd" 0 3  
          token "--arg" 4 9
          token "value" 10 15]
 
 [<Fact>]
-let ``Token.ofList should skip null entries``() = 
-    Token.ofList ["cmd";null;"value"]
+let ``Tokens.ofList should skip null entries``() = 
+    Tokens.ofList ["cmd";null;"value"]
     =! [ token "cmd" 0 3
          token "value" 4 9 ]
 [<Fact>]
-let ``Token.ofString should accept null``() = 
-    Token.ofString null
+let ``Tokens.ofString should accept null``() = 
+    Tokens.ofString null
     =! []
 
 [<Fact>]
-let ``Token.ofString should split spaces``() = 
-    Token.ofString "cmd --arg value"
+let ``Tokens.ofString should split spaces``() = 
+    Tokens.ofString "cmd --arg value"
     =! [ token "cmd" 0 3
          token "--arg" 4 9
          token "value" 10 15 ]
 
 [<Fact>]
-let ``Token.ofString should accept multiple spaces and produce Start and End accordingly``() = 
-    Token.ofString "cmd   --arg  value"
+let ``Tokens.ofString should accept multiple spaces and produce Start and End accordingly``() = 
+    Tokens.ofString "cmd   --arg  value"
     =! [ token "cmd" 0 3
          token "--arg" 6 11
          token "value" 13 18 ]
 
 [<Fact>]
-let ``Token.ofString should treat double quotes as a single token and remove quotes``() = 
-    Token.ofString """cmd --arg "some value" --flag"""
+let ``Tokens.ofString should treat double quotes as a single token and remove quotes``() = 
+    Tokens.ofString """cmd --arg "some value" --flag"""
     =! [ token "cmd" 0 3
          token "--arg" 4 9
          qtoken '"' "some value" 11 21 
          token "--flag" 23 29 ]
 
 [<Fact>]
-let ``Token.ofString should not fail on missing end double quote``() = 
-    Token.ofString """cmd --arg "some value --flag"""
+let ``Tokens.ofString should not fail on missing end double quote``() = 
+    Tokens.ofString """cmd --arg "some value --flag"""
     =! [ token "cmd" 0 3
          token "--arg" 4 9
          sqtoken '"' "some value --flag" 11 28 ]
 
 [<Fact>]
-let ``Token.ofString should treat single quotes as a single token and remove quotes``() = 
-    Token.ofString """cmd --arg 'some value' --flag"""
+let ``Tokens.ofString should treat single quotes as a single token and remove quotes``() = 
+    Tokens.ofString """cmd --arg 'some value' --flag"""
     =! [ token "cmd" 0 3
          token "--arg" 4 9
          qtoken '\'' "some value" 11 21
          token "--flag" 23 29]
 
 [<Fact>]
-let ``Token.ofString should not fail on missing end single quote``() = 
-    Token.ofString """cmd --arg 'some value --flag"""
+let ``Tokens.ofString should not fail on missing end single quote``() = 
+    Tokens.ofString """cmd --arg 'some value --flag"""
     =! [ token "cmd" 0 3
          token "--arg" 4 9
          sqtoken '\'' "some value --flag" 11 28 ]
 
 [<Fact>]
-let ``Token.ofString should accept single quotes in double quotes``() = 
-    Token.ofString """cmd --arg "some 'value" --flag"""
+let ``Tokens.ofString should accept single quotes in double quotes``() = 
+    Tokens.ofString """cmd --arg "some 'value" --flag"""
     =! [ token "cmd" 0 3
          token "--arg" 4 9
          qtoken '"' "some 'value" 11 22
          token "--flag" 24 30]
 
 [<Fact>]
-let ``Token.ofString should accept double quotes in single quotes``() = 
-    Token.ofString """cmd --arg 'some "value' --flag"""
+let ``Tokens.ofString should accept double quotes in single quotes``() = 
+    Tokens.ofString """cmd --arg 'some "value' --flag"""
     =! [ token "cmd" 0 3
          token "--arg" 4 9
          qtoken '\'' """some "value""" 11 22
          token "--flag" 24 30 ]
 
 [<Property>]
-let ``Token.ofCmdLine should behave as Token.ofString for single argument, Token.ofList otherwhise`` (args: string[]) =
+let ``Tokens.ofCmdLine should behave as Tokens.ofString for single argument, Tokens.ofList otherwhise`` (args: string[]) =
     match args with
-    | [| x |] -> Token.ofCmdLine args = Token.ofString x
-    | _ -> Token.ofCmdLine args = Token.ofList (Array.toList args)
+    | [| x |] -> Tokens.ofCmdLine args = Tokens.ofString x
+    | _ -> Tokens.ofCmdLine args = Tokens.ofList (Array.toList args)
 
 [<Property>]
-let ``Token.ofString then Token.toString should give same result`` (NonNull (args: string)) =
+let ``Tokens.ofString then Token.toString should give same result`` (NonNull (args: string)) =
     let trimmed = args.TrimEnd()
-    let result = trimmed |> Token.ofString |> Token.toString
+    let result = trimmed |> Tokens.ofString |> Tokens.toString
     result =! trimmed
 
 
 [<Fact>]
-let ``Token.ofString then Token.toString should give same result with empty quotes `` () =
+let ``Tokens.ofString then Token.toString should give same result with empty quotes `` () =
     let trimmed = "\"\""
-    let result = trimmed |> Token.ofString |> Token.toString
+    let result = trimmed |> Tokens.ofString |> Tokens.toString
     result =! trimmed
 

tests/Fargo.Test/Usage.fs

@@ -11,7 +11,7 @@ open System.Threading.Tasks
 let (=!) (actual:'a) (expected: 'a) = Differ.Assert(expected, actual )
 
 let outUsage (p,c) input =
-    let _,_,usages = p (Token.ofString input)
+    let _,_,usages = p (Tokens.ofString input)
     Testing.withStdout(fun _ -> printHelp usages)
 
 let outRun p input =