From ca93157c6e9650af9d33cb251ba38c362c8114b4 Mon Sep 17 00:00:00 2001 From: Lennart Spitzner Date: Mon, 12 Dec 2022 18:48:28 +0100 Subject: [PATCH] Support second-level headers --- src-hxbrief/Main.hs | 68 +++++++++++++++++++++++++-------------------- 1 file changed, 38 insertions(+), 30 deletions(-) diff --git a/src-hxbrief/Main.hs b/src-hxbrief/Main.hs index 6ae7f52..b9f94c8 100644 --- a/src-hxbrief/Main.hs +++ b/src-hxbrief/Main.hs @@ -98,13 +98,14 @@ data JoinMode | JoinAllKeep -- join with any other JoinAll-tagged lines/patterns, override headers | JoinAllDrop -- join with any other JoinAll-tagged lines/patterns, drop before headers, dont output | JoinSpecific -- join with this pattern only - | JoinHeader -- join with nothing, stays, only gets replaced by next yield/header + | JoinHeader1 -- join with nothing, stays, only gets replaced by next yield/header + | JoinHeader2 | JoinErrorStart | JoinErrorStop data JoinedInfo = JoinedNot Bool -- yield or drop, not to be merged. bool determines whether to forward - | JoinedHeader Bool Int Int -- header, not to be merged. bool determines whether to forward. Int is count stdout/stderr + | JoinedHeader Bool (Maybe Text) Int Int -- header, not to be merged. bool determines whether to forward. Int is count stdout/stderr | JoinedAll Bool Int -- bool determines whether to forward | Joined Int Text [Text] -- pattern, prefix @@ -237,9 +238,10 @@ dispatchPat oldKind i pat prefix = do StdOut -> when (c_keepStdout conf /= Drop) $ outputConcurrent prettyPat StdErr -> when (c_keepStderr conf /= Drop) $ errorConcurrent prettyPat -showHeader :: Text -> Int -> Int -> Text -showHeader header countOut countErr = +showHeader :: Text -> Maybe Text -> Int -> Int -> Text +showHeader header mLevel2 countOut countErr = header + <> (maybe (t "") (\l2 -> t " " <> l2) mLevel2) <> fGrey <> t " (" <> t (show countOut) @@ -250,7 +252,7 @@ showHeader header countOut countErr = dispatchHeader :: StreamKind -> Int -> Int -> Text -> StateT State IO () dispatchHeader oldKind countOut countErr header = do - let prettyPat = showHeader header countOut countErr <> t "\n" + let prettyPat = showHeader header Nothing countOut countErr <> t "\n" conf <- gets s_config liftIO $ case oldKind of StdOut -> when (c_keepStdout conf /= Drop) $ outputConcurrent prettyPat @@ -281,7 +283,7 @@ dispatchSummary = \case SummaryNone -> pure () SummaryNorm kind line (JoinedNot keep) -> when keep $ dispatchYielded (kind, line) - SummaryNorm kind line (JoinedHeader keep iOut iErr) -> + SummaryNorm kind line (JoinedHeader keep _mLevel2 iOut iErr) -> when keep $ dispatchHeader kind iOut iErr line SummaryNorm kind _ (JoinedAll keep i ) -> when keep $ dispatchSkipped kind i SummaryNorm kind _ (Joined i pat prefix) -> dispatchPat kind i pat prefix @@ -319,7 +321,9 @@ summarizeLines (kind, line, _linetime) = do (JoinAllDrop, _) -> SummaryNorm kind line (JoinedAll False 1) (JoinSpecific, pat) -> SummaryNorm kind line (Joined 1 pat (Text.words line)) - (JoinHeader , _) -> SummaryNorm kind line (JoinedHeader False 0 0) + (JoinHeader1, _) -> + SummaryNorm kind line (JoinedHeader False Nothing 0 0) + (JoinHeader2 , _) -> SummaryNorm kind line (JoinedNot False) (JoinDrop , _) -> SummaryNorm kind line (JoinedNot False) (JoinErrorStart, _) -> SummaryErr kind line (JoinErrorStop, _) -> @@ -361,14 +365,15 @@ summarizeLines (kind, line, _linetime) = do (SummaryNorm oldKind oldLine (JoinedNot keep), _joiner) -> do when keep $ dispatchYielded (oldKind, oldLine) defaultReplace - (SummaryNorm oldKind oldLine (JoinedHeader keep countOut countErr), joiner) + (SummaryNorm oldKind oldLine (JoinedHeader keep mLevel2 countOut countErr), joiner) -> do let replaceMay = case joiner of (JoinYield , _pat) -> Just (JoinedNot True) (JoinAllKeep , _ ) -> Just (JoinedAll True 1) (JoinAllDrop , _ ) -> Nothing (JoinSpecific , pat ) -> Just (Joined 1 pat (Text.words line)) - (JoinHeader , _ ) -> Just (JoinedHeader False 0 0) + (JoinHeader1 , _ ) -> Just (JoinedHeader False Nothing 0 0) + (JoinHeader2 , _ ) -> Nothing (JoinDrop , _ ) -> Nothing (JoinErrorStart, _ ) -> Nothing (JoinErrorStop , _ ) -> Nothing @@ -377,27 +382,26 @@ summarizeLines (kind, line, _linetime) = do when keep $ dispatchHeader oldKind countOut countErr oldLine put s { s_summary = SummaryNorm kind line replace } Nothing -> do + let newLevel2 = case joiner of + (JoinHeader2, _) -> Just line + _ -> mLevel2 put s { s_summary = SummaryNorm - oldKind - oldLine - (case kind of - StdOut -> - JoinedHeader keep (countOut + 1) countErr - StdErr -> - JoinedHeader keep countOut (countErr + 1) - ) + oldKind + oldLine + (case kind of + StdOut -> JoinedHeader keep newLevel2 (countOut + 1) countErr + StdErr -> JoinedHeader keep newLevel2 countOut (countErr + 1) + ) } (SummaryNorm oldKind _ (JoinedAll keep i), joiner) -> case joiner of - (JoinAllKeep, _) - | kind == oldKind -> do - put s { s_summary = SummaryNorm kind line (JoinedAll True (i + 1)) } - (JoinAllDrop, _) - | kind == oldKind -> do - put s { s_summary = SummaryNorm kind line (JoinedAll False (i + 1)) } + (JoinAllKeep, _) | kind == oldKind -> do + put s { s_summary = SummaryNorm kind line (JoinedAll True (i + 1)) } + (JoinAllDrop, _) | kind == oldKind -> do + put s { s_summary = SummaryNorm kind line (JoinedAll False (i + 1)) } _ -> do when keep $ dispatchSkipped oldKind i - defaultReplace + defaultReplace (SummaryNorm oldKind _ (Joined i oldPat oldPrefix), joiner) -> case joiner of (JoinSpecific, pat) | oldPat == pat && kind == oldKind -> do @@ -461,10 +465,10 @@ processLine newKind newLine = execStateT $ do SummaryNone -> prettyLines SummaryNorm StdOut line (JoinedNot _) -> (fWhiteDis <> t "│ " <> fReset <> ellipse conf line) : prettyLines - SummaryNorm StdOut line (JoinedHeader _ countOut countErr) -> + SummaryNorm StdOut line (JoinedHeader _ mLevel2 countOut countErr) -> (fWhiteDis <> t "│ " <> fReset <> ellipse conf - (showHeader line countOut countErr) + (showHeader line mLevel2 countOut countErr) ) : prettyLines SummaryNorm StdOut line (JoinedAll _ 1) -> @@ -497,10 +501,10 @@ processLine newKind newLine = execStateT $ do (fWhiteDis <> t "│ " <> fReset <> ellipse conf line) : prettyLines SummaryNorm StdErr line (JoinedNot _) -> (fRedDis <> t "│ " <> fReset <> ellipse conf line) : prettyLines - SummaryNorm StdErr line (JoinedHeader _ countOut countErr) -> + SummaryNorm StdErr line (JoinedHeader _ mLevel2 countOut countErr) -> (fRedDis <> t "│ " <> fReset <> ellipse conf - (showHeader line countOut countErr) + (showHeader line mLevel2 countOut countErr) ) : prettyLines SummaryNorm StdErr line (JoinedAll _ 1) -> @@ -648,6 +652,8 @@ main = B.mainFromCmdParser $ do yieldFull <- B.addFlagStringParams "" ["yield-any"] "REGEX" (B.flagHelpStr "always fully retain lines containing this pattern, disregarding skip/summarize") header <- B.addFlagStringParams "h" ["header"] "REGEX" (B.flagHelpStr "starting with this pattern: always replaces summary, then gets dropped") headerFull <- B.addFlagStringParams "" ["header-any"] "REGEX" (B.flagHelpStr "containing this pattern: always replaces summary, then gets dropped") + header2 <- B.addFlagStringParams "" ["header2"] "REGEX" (B.flagHelpStr "starting with this pattern: always replaces summary, then gets dropped") + header2Full <- B.addFlagStringParams "" ["header2-any"] "REGEX" (B.flagHelpStr "containing this pattern: always replaces summary, then gets dropped") errorStart <- B.addFlagStringParams "" ["error-start"] "REGEX" mempty errorStartFull <- B.addFlagStringParams "" ["error-start-any"] "REGEX" mempty errorStop <- B.addFlagStringParams "" ["error-stop"] "REGEX" mempty @@ -739,8 +745,10 @@ main = B.mainFromCmdParser $ do , yieldFull <&> compiler JoinYield , summarize <&> compiler JoinSpecific . (\x -> "^(" ++ x ++ ")") , summarizeFull <&> compiler JoinSpecific - , header <&> compiler JoinHeader . (\x -> "^(" ++ x ++ ")") - , headerFull <&> compiler JoinHeader + , header <&> compiler JoinHeader1 . (\x -> "^(" ++ x ++ ")") + , headerFull <&> compiler JoinHeader1 + , header2 <&> compiler JoinHeader2 . (\x -> "^(" ++ x ++ ")") + , header2Full <&> compiler JoinHeader2 , dropArg <&> compiler JoinAllDrop . (\x -> "^(" ++ x ++ ")") , dropFull <&> compiler JoinAllDrop , errorStart <&> compiler JoinErrorStart . (\x -> "^(" ++ x ++ ")")