{-# LANGUAGE PatternGuards #-}

-- | This module does command line completion
module System.Console.CmdArgs.Explicit.Complete(
    Complete(..), complete,
    completeBash, completeZsh
    ) where

import System.Console.CmdArgs.Explicit.Type
import Control.Monad
import Data.List
import Data.Maybe


-- | How to complete a command line option.
--   The 'Show' instance is suitable for parsing from shell scripts.
data Complete
    = CompleteValue String -- ^ Complete to a particular value
    | CompleteFile String FilePath -- ^ Complete to a prefix, and a file
    | CompleteDir String FilePath -- ^ Complete to a prefix, and a directory
      deriving (Complete -> Complete -> Bool
(Complete -> Complete -> Bool)
-> (Complete -> Complete -> Bool) -> Eq Complete
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Complete -> Complete -> Bool
== :: Complete -> Complete -> Bool
$c/= :: Complete -> Complete -> Bool
/= :: Complete -> Complete -> Bool
Eq,Eq Complete
Eq Complete =>
(Complete -> Complete -> Ordering)
-> (Complete -> Complete -> Bool)
-> (Complete -> Complete -> Bool)
-> (Complete -> Complete -> Bool)
-> (Complete -> Complete -> Bool)
-> (Complete -> Complete -> Complete)
-> (Complete -> Complete -> Complete)
-> Ord Complete
Complete -> Complete -> Bool
Complete -> Complete -> Ordering
Complete -> Complete -> Complete
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Complete -> Complete -> Ordering
compare :: Complete -> Complete -> Ordering
$c< :: Complete -> Complete -> Bool
< :: Complete -> Complete -> Bool
$c<= :: Complete -> Complete -> Bool
<= :: Complete -> Complete -> Bool
$c> :: Complete -> Complete -> Bool
> :: Complete -> Complete -> Bool
$c>= :: Complete -> Complete -> Bool
>= :: Complete -> Complete -> Bool
$cmax :: Complete -> Complete -> Complete
max :: Complete -> Complete -> Complete
$cmin :: Complete -> Complete -> Complete
min :: Complete -> Complete -> Complete
Ord)

instance Show Complete where
    show :: Complete -> [Char]
show (CompleteValue [Char]
a) = [Char]
"VALUE " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
a
    show (CompleteFile [Char]
a [Char]
b) = [Char]
"FILE " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
a [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
b
    show (CompleteDir [Char]
a [Char]
b) = [Char]
"DIR " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
a [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
b

    showList :: [Complete] -> ShowS
showList [Complete]
xs = [Char] -> ShowS
showString ([Char] -> ShowS) -> [Char] -> ShowS
forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unlines ((Complete -> [Char]) -> [Complete] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map Complete -> [Char]
forall a. Show a => a -> [Char]
show [Complete]
xs)


prepend :: String -> Complete -> Complete
prepend :: [Char] -> Complete -> Complete
prepend [Char]
a (CompleteFile [Char]
b [Char]
c) = [Char] -> [Char] -> Complete
CompleteFile ([Char]
a[Char] -> ShowS
forall a. [a] -> [a] -> [a]
++[Char]
b) [Char]
c
prepend [Char]
a (CompleteDir [Char]
b [Char]
c) = [Char] -> [Char] -> Complete
CompleteDir ([Char]
a[Char] -> ShowS
forall a. [a] -> [a] -> [a]
++[Char]
b) [Char]
c
prepend [Char]
a (CompleteValue [Char]
b) = [Char] -> Complete
CompleteValue ([Char]
a[Char] -> ShowS
forall a. [a] -> [a] -> [a]
++[Char]
b)


-- | Given a current state, return the set of commands you could type now, in preference order.
complete
    :: Mode a -- ^ Mode specifying which arguments are allowed
    -> [String] -- ^ Arguments the user has already typed
    -> (Int,Int) -- ^ 0-based index of the argument they are currently on, and the position in that argument
    -> [Complete]
-- Roll forward looking at modes, and if you match a mode, enter it
-- If the person just before is a flag without arg, look at how you can complete that arg
-- If your prefix is a complete flag look how you can complete that flag
-- If your prefix looks like a flag, look for legitimate flags
-- Otherwise give a file/dir if they are arguments to this mode, and all flags
-- If you haven't seen any args/flags then also autocomplete to any child modes
complete :: forall a. Mode a -> [[Char]] -> (Int, Int) -> [Complete]
complete Mode a
mode_ [[Char]]
args_ (Int
i,Int
_) = [Complete] -> [Complete]
forall a. Eq a => [a] -> [a]
nub ([Complete] -> [Complete]) -> [Complete] -> [Complete]
forall a b. (a -> b) -> a -> b
$ Mode a -> [[Char]] -> [Char] -> [Complete]
forall a. Mode a -> [[Char]] -> [Char] -> [Complete]
followArgs Mode a
mode [[Char]]
args [Char]
now
    where
        ([[Char]]
seen,[[Char]]
next) = Int -> [[Char]] -> ([[Char]], [[Char]])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
i [[Char]]
args_
        now :: [Char]
now = [[Char]] -> [Char]
forall a. HasCallStack => [a] -> a
head ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ [[Char]]
next [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [[Char]
""]
        (Mode a
mode,[[Char]]
args) = Mode a -> [[Char]] -> (Mode a, [[Char]])
forall a. Mode a -> [[Char]] -> (Mode a, [[Char]])
followModes Mode a
mode_ [[Char]]
seen


-- | Given a mode and some arguments, try and drill down into the mode
followModes :: Mode a -> [String] -> (Mode a, [String])
followModes :: forall a. Mode a -> [[Char]] -> (Mode a, [[Char]])
followModes Mode a
m ([Char]
x:[[Char]]
xs) | Just Mode a
m2 <- (Mode a -> [[Char]]) -> [Char] -> [Mode a] -> Maybe (Mode a)
forall a. (a -> [[Char]]) -> [Char] -> [a] -> Maybe a
pickBy Mode a -> [[Char]]
forall a. Mode a -> [[Char]]
modeNames [Char]
x ([Mode a] -> Maybe (Mode a)) -> [Mode a] -> Maybe (Mode a)
forall a b. (a -> b) -> a -> b
$ Mode a -> [Mode a]
forall a. Mode a -> [Mode a]
modeModes Mode a
m = Mode a -> [[Char]] -> (Mode a, [[Char]])
forall a. Mode a -> [[Char]] -> (Mode a, [[Char]])
followModes Mode a
m2 [[Char]]
xs
followModes Mode a
m [[Char]]
xs = (Mode a
m,[[Char]]
xs)


pickBy :: (a -> [String]) -> String -> [a] -> Maybe a
pickBy :: forall a. (a -> [[Char]]) -> [Char] -> [a] -> Maybe a
pickBy a -> [[Char]]
f [Char]
name [a]
xs = (a -> Bool) -> [a] -> Maybe a
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (\a
x -> [Char]
name [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` a -> [[Char]]
f a
x) [a]
xs Maybe a -> Maybe a -> Maybe a
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
                   (a -> Bool) -> [a] -> Maybe a
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (\a
x -> ([Char] -> Bool) -> [[Char]] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ([Char]
name [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf`) (a -> [[Char]]
f a
x)) [a]
xs


-- | Follow args deals with all seen arguments, then calls on to deal with the next one
followArgs :: Mode a -> [String] -> (String -> [Complete])
followArgs :: forall a. Mode a -> [[Char]] -> [Char] -> [Complete]
followArgs Mode a
m = [[Char]] -> [Char] -> [Complete]
first
    where
        first :: [[Char]] -> [Char] -> [Complete]
first [] = [Mode a] -> Maybe (Arg a) -> [Flag a] -> [Char] -> [Complete]
forall a.
[Mode a] -> Maybe (Arg a) -> [Flag a] -> [Char] -> [Complete]
expectArgFlagMode (Mode a -> [Mode a]
forall a. Mode a -> [Mode a]
modeModes Mode a
m) (Int -> Maybe (Arg a)
argsPick Int
0) (Mode a -> [Flag a]
forall a. Mode a -> [Flag a]
modeFlags Mode a
m)
        first [[Char]]
xs = Int -> [[Char]] -> [Char] -> [Complete]
norm Int
0 [[Char]]
xs

        -- i is the number of arguments that have gone past
        norm :: Int -> [[Char]] -> [Char] -> [Complete]
norm Int
i [] = Maybe (Arg a) -> [Flag a] -> [Char] -> [Complete]
forall a. Maybe (Arg a) -> [Flag a] -> [Char] -> [Complete]
expectArgFlag (Int -> Maybe (Arg a)
argsPick Int
i) (Mode a -> [Flag a]
forall a. Mode a -> [Flag a]
modeFlags Mode a
m)
        norm Int
i ([Char]
"--":[[Char]]
xs) = Maybe (Arg a) -> [Char] -> [Complete]
forall a. Maybe (Arg a) -> [Char] -> [Complete]
expectArg (Maybe (Arg a) -> [Char] -> [Complete])
-> Maybe (Arg a) -> [Char] -> [Complete]
forall a b. (a -> b) -> a -> b
$ Int -> Maybe (Arg a)
argsPick (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ [[Char]] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Char]]
xs)
        norm Int
i ((Char
'-':Char
'-':[Char]
x):[[Char]]
xs) | [Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
b, Flag a -> FlagInfo
forall a. Flag a -> FlagInfo
flagInfo Flag a
flg FlagInfo -> FlagInfo -> Bool
forall a. Eq a => a -> a -> Bool
== FlagInfo
FlagReq = Int -> Flag a -> [[Char]] -> [Char] -> [Complete]
val Int
i Flag a
flg [[Char]]
xs
                                | Bool
otherwise = Int -> [[Char]] -> [Char] -> [Complete]
norm Int
i [[Char]]
xs
            where ([Char]
a,[Char]
b) = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'=') [Char]
x
                  flg :: Flag a
flg = [Char] -> Flag a
getFlag [Char]
a
        norm Int
i ((Char
'-':Char
x:[Char]
y):[[Char]]
xs) = case Flag a -> FlagInfo
forall a. Flag a -> FlagInfo
flagInfo Flag a
flg of
            FlagInfo
FlagReq | [Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
y -> Int -> Flag a -> [[Char]] -> [Char] -> [Complete]
val Int
i Flag a
flg [[Char]]
xs
                    | Bool
otherwise -> Int -> [[Char]] -> [Char] -> [Complete]
norm Int
i [[Char]]
xs
            FlagOpt{} -> Int -> [[Char]] -> [Char] -> [Complete]
norm Int
i [[Char]]
xs
            FlagInfo
_ | [Char]
"=" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` [Char]
y -> Int -> [[Char]] -> [Char] -> [Complete]
norm Int
i [[Char]]
xs
              | [Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
y -> Int -> [[Char]] -> [Char] -> [Complete]
norm Int
i [[Char]]
xs
              | Bool
otherwise -> Int -> [[Char]] -> [Char] -> [Complete]
norm Int
i ((Char
'-'Char -> ShowS
forall a. a -> [a] -> [a]
:[Char]
y)[Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
:[[Char]]
xs)
            where flg :: Flag a
flg = [Char] -> Flag a
getFlag [Char
x]
        norm Int
i ([Char]
x:[[Char]]
xs) = Int -> [[Char]] -> [Char] -> [Complete]
norm (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) [[Char]]
xs

        val :: Int -> Flag a -> [[Char]] -> [Char] -> [Complete]
val Int
i Flag a
flg [] = Flag a -> [Char] -> [Complete]
forall a. Flag a -> [Char] -> [Complete]
expectVal Flag a
flg
        val Int
i Flag a
flg ([Char]
x:[[Char]]
xs) = Int -> [[Char]] -> [Char] -> [Complete]
norm Int
i [[Char]]
xs

        argsPick :: Int -> Maybe (Arg a)
argsPick Int
i = let ([Arg a]
lst,Maybe (Arg a)
end) = Mode a -> ([Arg a], Maybe (Arg a))
forall a. Mode a -> ([Arg a], Maybe (Arg a))
modeArgs Mode a
m in if Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< [Arg a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Arg a]
lst then Arg a -> Maybe (Arg a)
forall a. a -> Maybe a
Just (Arg a -> Maybe (Arg a)) -> Arg a -> Maybe (Arg a)
forall a b. (a -> b) -> a -> b
$ [Arg a]
lst [Arg a] -> Int -> Arg a
forall a. HasCallStack => [a] -> Int -> a
!! Int
i else Maybe (Arg a)
end

        -- if you can't find the flag, pick one that is FlagNone (has all the right fallback)
        getFlag :: [Char] -> Flag a
getFlag [Char]
x = Flag a -> Maybe (Flag a) -> Flag a
forall a. a -> Maybe a -> a
fromMaybe ([[Char]] -> (a -> a) -> [Char] -> Flag a
forall a. [[Char]] -> (a -> a) -> [Char] -> Flag a
flagNone [] a -> a
forall a. a -> a
id [Char]
"") (Maybe (Flag a) -> Flag a) -> Maybe (Flag a) -> Flag a
forall a b. (a -> b) -> a -> b
$ (Flag a -> [[Char]]) -> [Char] -> [Flag a] -> Maybe (Flag a)
forall a. (a -> [[Char]]) -> [Char] -> [a] -> Maybe a
pickBy Flag a -> [[Char]]
forall a. Flag a -> [[Char]]
flagNames [Char]
x ([Flag a] -> Maybe (Flag a)) -> [Flag a] -> Maybe (Flag a)
forall a b. (a -> b) -> a -> b
$ Mode a -> [Flag a]
forall a. Mode a -> [Flag a]
modeFlags Mode a
m


expectArgFlagMode :: [Mode a] -> Maybe (Arg a) -> [Flag a] -> String -> [Complete]
expectArgFlagMode :: forall a.
[Mode a] -> Maybe (Arg a) -> [Flag a] -> [Char] -> [Complete]
expectArgFlagMode [Mode a]
mode Maybe (Arg a)
arg [Flag a]
flag [Char]
x =
    (if [Char]
"-" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` [Char]
x then [] else [Mode a] -> [Char] -> [Complete]
forall a. [Mode a] -> [Char] -> [Complete]
expectMode [Mode a]
mode [Char]
x) [Complete] -> [Complete] -> [Complete]
forall a. [a] -> [a] -> [a]
++
    Maybe (Arg a) -> [Flag a] -> [Char] -> [Complete]
forall a. Maybe (Arg a) -> [Flag a] -> [Char] -> [Complete]
expectArgFlag Maybe (Arg a)
arg [Flag a]
flag [Char]
x

expectArgFlag :: Maybe (Arg a) -> [Flag a] -> String -> [Complete]
expectArgFlag :: forall a. Maybe (Arg a) -> [Flag a] -> [Char] -> [Complete]
expectArgFlag Maybe (Arg a)
arg [Flag a]
flag [Char]
x
    | [Char]
"-" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` [Char]
x = [Flag a] -> [Char] -> [Complete]
forall a. [Flag a] -> [Char] -> [Complete]
expectFlag [Flag a]
flag [Char]
x [Complete] -> [Complete] -> [Complete]
forall a. [a] -> [a] -> [a]
++ [[Char] -> Complete
CompleteValue [Char]
"-" | [Char]
x [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"-", Maybe (Arg a) -> Bool
forall a. Maybe a -> Bool
isJust Maybe (Arg a)
arg]
    | Bool
otherwise = Maybe (Arg a) -> [Char] -> [Complete]
forall a. Maybe (Arg a) -> [Char] -> [Complete]
expectArg Maybe (Arg a)
arg [Char]
x [Complete] -> [Complete] -> [Complete]
forall a. [a] -> [a] -> [a]
++ [Flag a] -> [Char] -> [Complete]
forall a. [Flag a] -> [Char] -> [Complete]
expectFlag [Flag a]
flag [Char]
x

expectMode :: [Mode a] -> String -> [Complete]
expectMode :: forall a. [Mode a] -> [Char] -> [Complete]
expectMode [Mode a]
mode = [[[Char]]] -> [Char] -> [Complete]
expectStrings ((Mode a -> [[Char]]) -> [Mode a] -> [[[Char]]]
forall a b. (a -> b) -> [a] -> [b]
map Mode a -> [[Char]]
forall a. Mode a -> [[Char]]
modeNames [Mode a]
mode)

expectArg :: Maybe (Arg a) -> String -> [Complete]
expectArg :: forall a. Maybe (Arg a) -> [Char] -> [Complete]
expectArg Maybe (Arg a)
Nothing [Char]
x = []
expectArg (Just Arg a
arg) [Char]
x = [Char] -> [Char] -> [Complete]
expectFlagHelp (Arg a -> [Char]
forall a. Arg a -> [Char]
argType Arg a
arg) [Char]
x

expectFlag :: [Flag a] -> String -> [Complete]
expectFlag :: forall a. [Flag a] -> [Char] -> [Complete]
expectFlag [Flag a]
flag [Char]
x
    | ([Char]
a,Char
_:[Char]
b) <- (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'=') [Char]
x = case (Flag a -> [[Char]]) -> [Char] -> [Flag a] -> Maybe (Flag a)
forall a. (a -> [[Char]]) -> [Char] -> [a] -> Maybe a
pickBy (ShowS -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ShowS
f ([[Char]] -> [[Char]])
-> (Flag a -> [[Char]]) -> Flag a -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Flag a -> [[Char]]
forall a. Flag a -> [[Char]]
flagNames) [Char]
a [Flag a]
flag of
        Maybe (Flag a)
Nothing -> []
        Just Flag a
flg -> (Complete -> Complete) -> [Complete] -> [Complete]
forall a b. (a -> b) -> [a] -> [b]
map ([Char] -> Complete -> Complete
prepend ([Char]
a [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"=")) ([Complete] -> [Complete]) -> [Complete] -> [Complete]
forall a b. (a -> b) -> a -> b
$ Flag a -> [Char] -> [Complete]
forall a. Flag a -> [Char] -> [Complete]
expectVal Flag a
flg [Char]
b
    | Bool
otherwise = [[[Char]]] -> [Char] -> [Complete]
expectStrings ((Flag a -> [[Char]]) -> [Flag a] -> [[[Char]]]
forall a b. (a -> b) -> [a] -> [b]
map (ShowS -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ShowS
f ([[Char]] -> [[Char]])
-> (Flag a -> [[Char]]) -> Flag a -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Flag a -> [[Char]]
forall a. Flag a -> [[Char]]
flagNames) [Flag a]
flag) [Char]
x
    where f :: ShowS
f [Char]
x = [Char]
"-" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
'-' | [Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1] [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
x

expectVal :: Flag a -> String -> [Complete]
expectVal :: forall a. Flag a -> [Char] -> [Complete]
expectVal Flag a
flg = [Char] -> [Char] -> [Complete]
expectFlagHelp (Flag a -> [Char]
forall a. Flag a -> [Char]
flagType Flag a
flg)

expectStrings :: [[String]] -> String -> [Complete]
expectStrings :: [[[Char]]] -> [Char] -> [Complete]
expectStrings [[[Char]]]
xs [Char]
x = ([Char] -> Complete) -> [[Char]] -> [Complete]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> Complete
CompleteValue ([[Char]] -> [Complete]) -> [[Char]] -> [Complete]
forall a b. (a -> b) -> a -> b
$ ([[Char]] -> [[Char]]) -> [[[Char]]] -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Int -> [[Char]] -> [[Char]]
forall a. Int -> [a] -> [a]
take Int
1 ([[Char]] -> [[Char]])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter ([Char]
x [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf`)) [[[Char]]]
xs

expectFlagHelp :: FlagHelp -> String -> [Complete]
expectFlagHelp :: [Char] -> [Char] -> [Complete]
expectFlagHelp [Char]
typ [Char]
x = case [Char]
typ of
    [Char]
"FILE" -> [[Char] -> [Char] -> Complete
CompleteFile [Char]
"" [Char]
x]
    [Char]
"DIR" -> [[Char] -> [Char] -> Complete
CompleteDir [Char]
"" [Char]
x]
    [Char]
"FILE/DIR" -> [[Char] -> [Char] -> Complete
CompleteFile [Char]
"" [Char]
x, [Char] -> [Char] -> Complete
CompleteDir [Char]
"" [Char]
x]
    [Char]
"DIR/FILE" -> [[Char] -> [Char] -> Complete
CompleteDir [Char]
"" [Char]
x, [Char] -> [Char] -> Complete
CompleteFile [Char]
"" [Char]
x]
    Char
'[':[Char]
s | [Char]
"]" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isSuffixOf` [Char]
s -> [Char] -> [Char] -> [Complete]
expectFlagHelp (ShowS
forall a. HasCallStack => [a] -> [a]
init [Char]
s) [Char]
x
    [Char]
_ -> []


---------------------------------------------------------------------
-- BASH SCRIPT

completeBash :: String -> [String]
completeBash :: [Char] -> [[Char]]
completeBash [Char]
prog =
    [[Char]
"# Completion for " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
prog
    ,[Char]
"# Generated by CmdArgs: http://community.haskell.org/~ndm/cmdargs/"
    ,[Char]
"_" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
prog [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"()"
    ,[Char]
"{"
    ,[Char]
"    # local CMDARGS_DEBUG=1 # uncomment to debug this script"
    ,[Char]
""
    ,[Char]
"    COMPREPLY=()"
    ,[Char]
"    function add { COMPREPLY[((${#COMPREPLY[@]} + 1))]=$1 ; }"
    ,[Char]
"    IFS=$'\\n\\r'"
    ,[Char]
""
    ,[Char]
"    export CMDARGS_COMPLETE=$((${COMP_CWORD} - 1))"
    ,[Char]
"    result=`" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
prog [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" ${COMP_WORDS[@]:1}`"
    ,[Char]
""
    ,[Char]
"    if [ -n $CMDARGS_DEBUG ]; then"
    ,[Char]
"        echo Call \\(${COMP_WORDS[@]:1}, $CMDARGS_COMPLETE\\) > cmdargs.tmp"
    ,[Char]
"        echo $result >> cmdargs.tmp"
    ,[Char]
"    fi"
    ,[Char]
"    unset CMDARGS_COMPLETE"
    ,[Char]
"    unset CMDARGS_COMPLETE_POS"
    ,[Char]
""
    ,[Char]
"    for x in $result ; do"
    ,[Char]
"        case $x in"
    ,[Char]
"            VALUE\\ *)"
    ,[Char]
"                add ${x:6}"
    ,[Char]
"                ;;"
    ,[Char]
"            FILE\\ *)"
    ,[Char]
"                local prefix=`expr match \"${x:5}\" '\\([^ ]*\\)'`"
    ,[Char]
"                local match=`expr match \"${x:5}\" '[^ ]* \\(.*\\)'`"
    ,[Char]
"                for x in `compgen -f -- \"$match\"`; do"
    ,[Char]
"                    add $prefix$x"
    ,[Char]
"                done"
    ,[Char]
"                ;;"
    ,[Char]
"            DIR\\ *)"
    ,[Char]
"                local prefix=`expr match \"${x:4}\" '\\([^ ]*\\)'`"
    ,[Char]
"                local match=`expr match \"${x:4}\" '[^ ]* \\(.*\\)'`"
    ,[Char]
"                for x in `compgen -d -- \"$match\"`; do"
    ,[Char]
"                    add $prefix$x"
    ,[Char]
"                done"
    ,[Char]
"                ;;"
    ,[Char]
"        esac"
    ,[Char]
"    done"
    ,[Char]
"    unset IFS"
    ,[Char]
""
    ,[Char]
"    if [ -n $CMDARGS_DEBUG ]; then"
    ,[Char]
"        echo echo COMPREPLY: ${#COMPREPLY[@]} = ${COMPREPLY[@]} >> cmdargs.tmp"
    ,[Char]
"    fi"
    ,[Char]
"}"
    ,[Char]
"complete -o bashdefault -F _" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
prog [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
prog
    ]


---------------------------------------------------------------------
-- ZSH SCRIPT

completeZsh :: String -> [String]
completeZsh :: [Char] -> [[Char]]
completeZsh [Char]
_ = [[Char]
"echo TODO: help add Zsh completions to cmdargs programs"]