cmdargs 0.9.7 → 0.10

raw patch · 10 files changed

+57/−10 lines, 10 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• System/Console/CmdArgs/Explicit.hs +1/−1
• System/Console/CmdArgs/Explicit/ExpandArgsAt.hs +7/−1
• System/Console/CmdArgs/Explicit/Type.hs +8/−2
• System/Console/CmdArgs/Helper.hs +4/−2
• System/Console/CmdArgs/Implicit/Ann.hs +1/−0
• System/Console/CmdArgs/Implicit/Global.hs +7/−1
• System/Console/CmdArgs/Implicit/Local.hs +3/−1
• System/Console/CmdArgs/Implicit/UI.hs +10/−0
• System/Console/CmdArgs/Test/Implicit/Tests.hs +13/−1
• cmdargs.cabal +3/−1

@@ -112,7 +112,7 @@             let var = mplus (lookup ("CMDARGS_HELPER_" ++ show (map toUpper $ head $ modeNames m ++ [nam])) env)                             (lookup "CMDARGS_HELPER" env)             case var of-                Nothing -> run =<< expandArgsAt =<< getArgs+                Nothing -> run =<< (if modeExpandAt m then expandArgsAt else return) =<< getArgs                 Just cmd -> do                     res <- execute cmd m []                     case res of

@@ -11,9 +11,15 @@ -- --   Any @\@@ directives in the files will be recursively expanded (raising an error --   if there is infinite recursion).+--+--   To supress @\@@ expansion, pass any @\@@ arguments after @--@. expandArgsAt :: [String] -> IO [String]-expandArgsAt = fmap concat . mapM (f [] ".")+expandArgsAt args = do+        ebefore <- mapM (f [] ".") before+        return $ concat ebefore ++ after     where+        (before,after) = break (== "--") args+         f seen dir ('@':x)             | x `elem` seen = error $ unlines $                 "System.Console.CmdArgs.Explicit.expandArgsAt, recursion in @ directives:" :

@@ -63,19 +63,25 @@ --------------------------------------------------------------------- -- TYPES --- | A mode. Each mode has three main features:+-- | A mode. Do not use the 'Mode' constructor directly, instead+--   use 'mode' to construct the 'Mode' and then record updates.+--   Each mode has three main features: -- --   * A list of submodes ('modeGroupModes') -- --   * A list of flags ('modeGroupFlags') -- --   * Optionally an unnamed argument ('modeArgs')+--+--  To produce the help information for a mode, either use 'helpText' or 'show'. data Mode a = Mode     {modeGroupModes :: Group (Mode a) -- ^ The available sub-modes     ,modeNames :: [Name] -- ^ The names assigned to this mode (for the root mode, this name is used as the program name)     ,modeValue :: a -- ^ Value to start with     ,modeCheck :: a -> Either String a -- ^ Check the value reprsented by a mode is correct, after applying all flags     ,modeReform :: a -> Maybe [String] -- ^ Given a value, try to generate the input arguments.+    ,modeExpandAt :: Bool -- ^ Expand @\@@ arguments with 'expandArgsAt', defaults to 'True', only applied if using an 'IO' processing function.+                          --   Only the root 'Mode's value will be used.     ,modeHelp :: Help -- ^ Help text     ,modeHelpSuffix :: [String] -- ^ A longer help suffix displayed after a mode     ,modeArgs :: ([Arg a], Maybe (Arg a)) -- ^ The unnamed arguments, a series of arguments, followed optionally by one for all remaining slots@@ -204,7 +210,7 @@ -- | Create an empty mode specifying only 'modeValue'. All other fields will usually be populated --   using record updates. modeEmpty :: a -> Mode a-modeEmpty x = Mode mempty [] x Right (const Nothing) "" [] ([],Nothing) mempty+modeEmpty x = Mode mempty [] x Right (const Nothing) True "" [] ([],Nothing) mempty  -- | Create a mode with a name, an initial value, some help text, a way of processing arguments --   and a list of flags.

@@ -276,7 +276,8 @@         ,add "modeGroupFlags" modeGroupFlags         ,add "modeValue" modeValue         ,add "modeCheck" modeCheck-        ,add "modeReform" modeReform]+        ,add "modeReform" modeReform+        ,add "modeExpandAt" modeExpandAt]     unpack x = let y = ctor "Mode" x in Mode         {modeGroupModes = get "modeGroupModes" y         ,modeNames = get "modeNames" y@@ -286,7 +287,8 @@         ,modeGroupFlags = get "modeGroupFlags" y         ,modeValue = get "modeValue" y         ,modeCheck = get "modeCheck" y-        ,modeReform = get "modeReform" y}+        ,modeReform = get "modeReform" y+        ,modeExpandAt = get "modeExpandAt" y}  instance Packer a => Packer (Flag a) where     pack Flag{..} = Ctor "Flag"

@@ -26,4 +26,5 @@     | ProgHelpArg [Ann]     | ProgVersionArg [Ann]     | ProgVerbosityArgs [Ann] [Ann]+    | ProgNoAtExpand       deriving (Eq,Ord,Show,Data,Typeable)

@@ -19,8 +19,14 @@   global :: Prog_ -> Mode (CmdArgs Any)-global x = setReform (reform y) $ setHelp y $ collapse $ assignGroups y+global x = setReform (reform y) $ setHelp y $ setProgOpts x $ collapse $ assignGroups y     where y = assignNames $ extraFlags x+++setProgOpts :: Prog_ -> Mode a -> Mode a+setProgOpts p m = m{modeExpandAt = False -- not $ progNoAtExpand p+                   ,modeGroupModes = fmap (setProgOpts p) $ modeGroupModes m}+  --------------------------------------------------------------------- -- COLLAPSE THE FLAGS/MODES UPWARDS

@@ -30,9 +30,10 @@     ,progVerbosityArgs :: (Maybe Builtin_, Maybe Builtin_) -- (verbose, quiet)     ,progHelpArg :: Maybe Builtin_     ,progVersionArg :: Maybe Builtin_+    ,progNoAtExpand :: Bool     } deriving Show instance Default Prog_ where-    def = Prog_ def def def def def (Just def) (Just def)+    def = Prog_ def def def def def (Just def) (Just def) def  progOutput f x = fromMaybe ["The " ++ progProgram x ++ " program"] $     (builtinSummary =<< f x) `mplus` progSummary x@@ -153,6 +154,7 @@ progAnn (ProgHelpArg a) x = x{progHelpArg = builtinAnns (progHelpArg x) a} progAnn (ProgVersionArg a) x = x{progVersionArg = builtinAnns (progVersionArg x) a} progAnn (ProgVerbosityArgs a b) x = x{progVerbosityArgs=(builtinAnns (Just $ fromMaybe def $ fst $ progVerbosityArgs x) a, builtinAnns (Just $ fromMaybe def $ snd $ progVerbosityArgs x) b)}+progAnn ProgNoAtExpand x = x{progNoAtExpand=True} progAnn a x | length (progModes x) == 1 = x{progModes = map (modeAnn a) $ progModes x} progAnn a x = err "program" $ show a 

@@ -208,3 +208,13 @@ -- > Sample{..} &= verbosityArgs [ignore] [name "silent", explicit] verbosityArgs :: [Ann] -> [Ann] -> Ann verbosityArgs = ProgVerbosityArgs+++-- | Program: \"Turn off \@ expansion.\"+--+--   Usually arguments starting with \@ are treated as a file containing+--   a set of arguments. This annotation turns off that behaviour.+--+-- > Sample{..} &= noAtExpand+noAtExpand :: Ann+noAtExpand = ProgNoAtExpand

@@ -301,7 +301,19 @@     ["--test16a=5"] === Test16 (MyInt 5) []     ["--test16b=5","--test16b=82"] === Test16 (MyInt 12) [MyInt 5, MyInt 82] +-- #552, @ directives not expanded after -- symbols+-- not actually checked because this path doesn't go through processArgs+data Test17 = Test17 {test17_ :: [String]} deriving (Eq,Show,Data,Typeable) +mode17 = cmdArgsMode $ Test17 ([] &= args) &= noAtExpand++test17 = do+    let Tester{..} = tester "Test17" mode17+    [] === Test17 []+    ["test","of","this"] === Test17 ["test","of","this"]+    ["test","--","@foo"] === Test17 ["test","@foo"]++ -- For some reason, these must be at the end, otherwise the Template Haskell -- stage restriction kicks in. @@ -310,7 +322,7 @@ demos = zipWith f [1..]         [toDemo mode1, toDemo mode2, toDemo mode3, toDemo mode4, toDemo mode5, toDemo mode6         ,toDemo mode7, toDemo mode8, toDemo mode9, toDemo mode10, toDemo mode11, toDemo mode12-        ,toDemo mode13, toDemo mode14, toDemo mode15, toDemo mode16]+        ,toDemo mode13, toDemo mode14, toDemo mode15, toDemo mode16, toDemo mode17]     where f i x = x{modeHelp = "Testing various corner cases (" ++ show i ++ ")"}  

@@ -1,7 +1,7 @@ cabal-version:      >= 1.6 build-type:         Simple name:               cmdargs-version:            0.9.7+version:            0.10 license:            BSD3 license-file:       LICENSE category:           Console@@ -88,6 +88,8 @@  executable cmdargs     main-is: Main.hs+    if flag(quotation)+        extensions: TemplateHaskell     if flag(testprog) && flag(quotation)         buildable: True     else