Fix styling

Author: HirotoShioi

src/CLI.hs

@@ -16,41 +16,41 @@ data CLI
     | ProcessTickets    -- ^ Procss all the tickets in the Zendesk
     | RawRequest String -- ^ Raw request to the given url
     | ShowStatistics    -- ^ Show statistics
-    deriving (Show)
+    deriving Show
 
 -- | Parser for ProcessTicket
 cmdProcessTicket :: Parser CLI
 cmdProcessTicket = ProcessTicket <$> argument auto
-                       ( metavar "TICKET_ID"
-                      <> help "Ticket id to analyze")
+                       (metavar "TICKET_ID"
+                       <> help "Ticket id to analyze")
 
 -- | Parser for RawRequest
 cmdRawRequest :: Parser CLI
 cmdRawRequest = RawRequest <$> strOption
-                    ( metavar "URL"
-                   <> help "Url to request")
+                    (metavar "URL"
+                    <> help "Url to request")
 
 -- | Parser for CLI commands
 cli :: Parser CLI
 cli = hsubparser $ mconcat
-        [
-          command "collect-emails" (info (pure CollectEmails)
-            (progDesc "Collect emails requested by single user"))
-        , command "process-tickets" (info (pure ProcessTickets)
-            (progDesc "Process all the tickets i.e add comments, tags."))
-        , command "process-ticket" (info cmdProcessTicket
-            (progDesc "Process Zendesk ticket of an given ticket id"))
-        , command "raw-request" (info cmdRawRequest
-            (progDesc "Raw request to the given url"))
-        , command "show-stats" (info (pure ShowStatistics)
-            (progDesc "Print list of ticket Ids that agent has been assigned"))
-        ]
+    [
+      command "collect-emails" (info (pure CollectEmails)
+          (progDesc "Collect emails requested by single user"))
+    , command "process-tickets" (info (pure ProcessTickets)
+          (progDesc "Process all the tickets i.e add comments, tags."))
+    , command "process-ticket" (info cmdProcessTicket
+          (progDesc "Process Zendesk ticket of an given ticket id"))
+    , command "raw-request" (info cmdRawRequest
+          (progDesc "Raw request to the given url"))
+    , command "show-stats" (info (pure ShowStatistics)
+          (progDesc "Print list of ticket Ids that agent has been assigned"))
+    ]
 
 getCliArgs :: IO CLI
 getCliArgs = execParser opts
       where
         opts = info (cli <**> helper <**> versionHelper)
-            ( fullDesc
+            (fullDesc
             <> header "Log classifier"
             <> progDesc "Client for peforming analysis on Zendesk"
             )

src/Classify.hs

@@ -4,7 +4,13 @@
 {-# LANGUAGE RankNTypes        #-}
 
 -- Currenty not used..
-module Classify (classifyZip, ErrorCode(..), ErrorName, postProcessError, ConfirmedError(..)) where
+module Classify
+       ( ConfirmedError(..)
+       , ErrorCode(..)
+       , ErrorName
+       , classifyZip
+       , postProcessError
+       ) where
 
 import           Universum
 
@@ -19,8 +25,7 @@ import           Regex (MatchWithCaptures, Regex, RegexCompileError, RegexString
 
 type ErrorName = Text
 
-data ErrorHandler
-  = ErrorHandler
+data ErrorHandler = ErrorHandler
     { errorHandlerFileRegex :: !Regex
     , errorHandlerRegex     :: !Regex
     , errorHandlerMessage   :: LByteString -> [MatchWithCaptures] -> Maybe ErrorCode
@@ -33,53 +38,50 @@ data ErrorCode =
   | NetworkError [ LByteString ]
   deriving Show
 
-newtype  ConfirmedError =
-    ConfirmedStaleLockFile LText
+newtype  ConfirmedError = ConfirmedStaleLockFile LText
 
-newtype Behavior
-  = Behavior (Map ErrorName ErrorHandler)
+newtype Behavior = Behavior (Map ErrorName ErrorHandler)
 
-compileBehavior :: [(ErrorName, (RegexString, RegexString, LByteString -> [MatchWithCaptures] -> Maybe ErrorCode))]
+compileBehavior :: [(ErrorName, (RegexString, RegexString,
+                   LByteString -> [MatchWithCaptures] -> Maybe ErrorCode))]
                 -> Either RegexCompileError Behavior
 compileBehavior input = do
-  pairs <- forM input $ \(errName, (frx, rx, toErrorCode)) -> do
-    frxCompiled <- compileRegex frx
-    rxCompiled  <- compileRegex rx
-    let errHandler = ErrorHandler
+    pairs <- forM input $ \(errName, (frx, rx, toErrorCode)) -> do
+        frxCompiled <- compileRegex frx
+        rxCompiled  <- compileRegex rx
+        let errHandler = ErrorHandler
                      { errorHandlerFileRegex = frxCompiled
                      , errorHandlerRegex     = rxCompiled
                      , errorHandlerMessage   = toErrorCode
                      }
-    pure (errName, errHandler)
-  pure (Behavior (Map.fromList pairs))
+        pure (errName, errHandler)
+    pure (Behavior (Map.fromList pairs))
 
 runBehavior :: HasCallStack => Behavior
             -> Map FilePath LByteString
             -> IO (Map FilePath [(ErrorName, ErrorCode)])
 runBehavior (Behavior behavior) files = do
-  let
-    checkFile :: FilePath -> LByteString -> IO (Maybe [(ErrorName, ErrorCode)])
-    checkFile fp contents = do
-      hits <- Map.traverseMaybeWithKey (checkBehaviorOnFile fp contents) behavior
-      if length hits > 0 then
-        pure $ Just $ Map.toList hits
-      else
-        pure Nothing
-    checkBehaviorOnFile :: FilePath
-                        -> LByteString
-                        -> ErrorName
-                        -> ErrorHandler
-                        -> IO (Maybe ErrorCode)
-    checkBehaviorOnFile fp contents _ errhandler =
-      if matchTest (errorHandlerFileRegex errhandler) (LBSC.pack fp) then do
-        let
-          matches = matchAll (errorHandlerRegex errhandler) contents
-        if (length matches) == 0 then
-          pure Nothing
-        else
-          pure $ errorHandlerMessage errhandler contents matches
-      else pure Nothing
-  Map.traverseMaybeWithKey checkFile files
+    let
+        checkFile :: FilePath -> LByteString -> IO (Maybe [(ErrorName, ErrorCode)])
+        checkFile fp contents = do
+            hits <- Map.traverseMaybeWithKey (checkBehaviorOnFile fp contents) behavior
+            if length hits > 0 
+            then pure $ Just $ Map.toList hits
+            else pure Nothing
+        checkBehaviorOnFile :: FilePath
+                            -> LByteString
+                            -> ErrorName
+                            -> ErrorHandler
+                            -> IO (Maybe ErrorCode)
+        checkBehaviorOnFile fp contents _ errhandler =
+            if matchTest (errorHandlerFileRegex errhandler) (LBSC.pack fp) then do
+                let matches = matchAll (errorHandlerRegex errhandler) contents
+                if (length matches) == 0 then
+                  pure Nothing
+                else
+                  pure $ errorHandlerMessage errhandler contents matches
+          else pure Nothing
+    Map.traverseMaybeWithKey checkFile files
 
 readZip :: HasCallStack => LByteString -> Either String (Map FilePath LByteString)
 readZip rawzip = case Zip.toArchiveOrFail rawzip of
@@ -104,40 +106,41 @@ getMatches :: LByteString -> [MatchWithCaptures] -> [LByteString]
 getMatches fullBS = map (getOneMatch fullBS)
 
 getOneMatch :: LByteString -> MatchWithCaptures -> LByteString
-getOneMatch bs ((start, len), _) = LBSC.take (fromIntegral len) $ LBSC.drop (fromIntegral start) bs
+getOneMatch bs ((start, len), _) =
+    LBSC.take (fromIntegral len) $ LBSC.drop (fromIntegral start) bs
 
 classifyZip :: HasCallStack
             => LByteString
             -> IO (Either String (Map FilePath [(ErrorName, ErrorCode)]))
 classifyZip rawzip = do
   --zip <- readZip <$> LreadFile "logs.zip"
-  let
-    zipmap' = readZip rawzip
-  let
-    behaviorList :: [ (ErrorName, (RegexString, RegexString, LByteString -> [MatchWithCaptures] -> Maybe ErrorCode) ) ]
-    behaviorList
-        = [ ( "conn-refused"
-            , ( "Daedalus.log"
-              , "\"message\": \"connect ECONNREFUSED [^\"]*\""
-              , countRefused ) )
-          , ( "stale-lock-file"
-            , ( "node.pub$"
-              , "[^\n]*Wallet[^\n]*/open.lock: Locked by [0-9]+: resource busy"
-              , \contents matches -> Just $ StateLockFile $ decodeUtf8 $ last $ N.fromList $ getMatches contents matches ) )
-          , ( "file-not-found"
-            , ( "node.pub$"
-              , ": [^ ]*: openBinaryFile: does not exist \\(No such file or directory\\)"
-              , \contents matches -> Just $ FileNotFound $ getMatches contents matches ) )
-          , ( "TransportError"
-            , ( "node"
-              , "TransportError[^\n]*"
-              , \contents matches -> Just $ NetworkError $ getMatches contents matches ) )
-          ]
+  let zipmap' = readZip rawzip
+      behaviorList :: [(ErrorName, (RegexString, RegexString,
+                        LByteString -> [MatchWithCaptures] -> Maybe ErrorCode))]
+      behaviorList
+          = [ ( "conn-refused"
+              , ( "Daedalus.log"
+                , "\"message\": \"connect ECONNREFUSED [^\"]*\""
+                , countRefused ) )
+            , ( "stale-lock-file"
+              , ( "node.pub$"
+                , "[^\n]*Wallet[^\n]*/open.lock: Locked by [0-9]+: resource busy"
+                , \contents matches -> Just $ StateLockFile $ decodeUtf8
+                      $ last $ N.fromList $ getMatches contents matches ) )
+            , ( "file-not-found"
+              , ( "node.pub$"
+                , ": [^ ]*: openBinaryFile: does not exist \\(No such file or directory\\)"
+                , \contents matches -> Just $ FileNotFound $ getMatches contents matches ) )
+            , ( "TransportError"
+              , ( "node"
+                , "TransportError[^\n]*"
+                , \contents matches -> Just $ NetworkError $ getMatches contents matches ) )
+            ]
   behavior <- either (fail . toString) pure
               $ compileBehavior behaviorList
   case zipmap' of
-    Left err     -> pure $ Left err
-    Right zipmap -> Right <$> classifyLogs behavior zipmap
+      Left err     -> pure $ Left err
+      Right zipmap -> Right <$> classifyLogs behavior zipmap
 
 isStaleLockFile :: Map FilePath [(ErrorName, ErrorCode)] -> Maybe LText
 isStaleLockFile = Map.foldl' checkFile Nothing
@@ -155,5 +158,5 @@ postProcessError :: Map FilePath [(ErrorName, ErrorCode)]
 postProcessError input = finalAnswer
   where
     finalAnswer = case isStaleLockFile input of
-      Just msg -> Right $ ConfirmedStaleLockFile msg
-      Nothing  -> Left input
+        Just msg -> Right $ ConfirmedStaleLockFile msg
+        Nothing  -> Left input

src/Lib.hs

@@ -1,6 +1,6 @@
 module Lib
-    ( someFunc
-    ) where
+       ( someFunc
+       ) where
 
 import           Universum
 -- TODO(ks): Here we want to import the functionality we require in cardano-report-server.

src/LogAnalysis/Classifier.hs

@@ -3,8 +3,8 @@
 {-# LANGUAGE RecordWildCards   #-}
 
 module LogAnalysis.Classifier
-       ( extractIssuesFromLogs
-       , extractErrorCodes
+       ( extractErrorCodes
+       , extractIssuesFromLogs
        , prettyFormatAnalysis
        ) where
 
@@ -47,8 +47,8 @@ filterAnalysis :: Analysis -> Either Text Analysis
 filterAnalysis as = do
     let filteredAnalysis = Map.filter (/=[]) as
     if null filteredAnalysis
-      then Left "Cannot find any known issues"
-      else return $ Map.map (take numberOfErrorText) filteredAnalysis
+    then Left "Cannot find any known issues"
+    else return $ Map.map (take numberOfErrorText) filteredAnalysis
 
 extractErrorCodes :: Analysis -> [ Text ]
 extractErrorCodes as = map (\(Knowledge{..}, _) -> renderErrorCode kErrorCode) $ Map.toList as
@@ -58,11 +58,11 @@ prettyFormatAnalysis :: Analysis -> LText
 prettyFormatAnalysis as =
     let aList = Map.toList as
     in foldr (\(Knowledge{..}, txts) acc ->
-         "\n" <> show kErrorCode
-      <> "\n" <> kProblem
-      <> "\n **" <> kSolution
-      <> "** \n"
-      <> foldr1 (\txt ts -> "\n" <> txt <> "\n" <> ts) txts -- List errors
-      <> "\n" <> acc
-      <> "\n\n"
-      ) "" aList
+                "\n" <> show kErrorCode
+             <> "\n" <> kProblem
+             <> "\n **" <> kSolution
+             <> "** \n"
+             <> foldr1 (\txt ts -> "\n" <> txt <> "\n" <> ts) txts -- List errors
+             <> "\n" <> acc
+             <> "\n\n"
+             ) "" aList

src/LogAnalysis/KnowledgeCSVParser.hs

@@ -17,10 +17,9 @@ insideQuotes =
     LT.append <$> (LT.fromStrict <$> ALT.takeWhile (/= '"'))
               <*> (LT.concat <$> many (LT.cons <$> dquotes <*> insideQuotes))
     <?> "inside of double quotes"
-    where
-      dquotes =
-        string "\"\"" >> return '"'
-        <?> "paired double quotes"
+  where
+    dquotes = string "\"\"" >> return '"'
+             <?> "paired double quotes"
 
 -- | Parse quoted field
 quotedField :: Parser LText