Migrate to fourmolu.yaml

Author: webdevred

.github/workflows/haskell.yml

@@ -22,6 +22,8 @@ jobs:
 
     - name: Run fourmolu
       uses: haskell-actions/run-fourmolu@v11
+      with:
+        version: "latest"
 
     - name: Cache Stack and binaries
       uses: actions/cache@v3

app/Main.hs

@@ -1,30 +1,30 @@
-module Main
-  ( main
-  ) where
+module Main (
+  main,
+) where
 
 import Control.Exception
 import Core.Node (Node)
 import Core.NodeCursor (newCursor)
-import qualified Data.ByteString.Lazy as BL
-  ( ByteString
-  , readFile
-  , toStrict
-  , writeFile
-  )
 import Data.Functor (($>))
-import qualified Data.List as L (uncons)
-import qualified Data.Text as T (append, pack)
 import Data.Text (Text)
-import qualified Data.Text.IO as TIO (putStrLn)
-import qualified Data.Text.Lazy as TL (fromStrict)
 import Data.Text.Lazy.Encoding (encodeUtf8)
-import GHC.IO.Exception (IOErrorType(NoSuchThing), IOException(IOError))
-import System.Environment (getArgs)
-import Transformation (transform)
-
 import Formatting (RuleSet, formatNode, newRuleSet)
+import GHC.IO.Exception (IOErrorType (NoSuchThing), IOException (IOError))
 import Parsing.DSL (parseDSL)
 import Parsing.Jbeam (parseNodes)
+import System.Environment (getArgs)
+import Transformation (transform)
+
+import Data.ByteString.Lazy qualified as BL (
+  ByteString,
+  readFile,
+  toStrict,
+  writeFile,
+ )
+import Data.List qualified as L (uncons)
+import Data.Text qualified as T (append, pack)
+import Data.Text.IO qualified as TIO (putStrLn)
+import Data.Text.Lazy qualified as TL (fromStrict)
 
 main :: IO ()
 main = do
@@ -54,8 +54,8 @@ readFormattingConfig = do
     Right rs -> pure rs
     Left err -> TIO.putStrLn err $> newRuleSet
 
-ioErrorMsg ::
-     [IOErrorType]
+ioErrorMsg
+  :: [IOErrorType]
   -> Either IOException BL.ByteString
   -> Either Text BL.ByteString
 ioErrorMsg noerrs (Left (IOError _ ioe_type _ ioe_desc _ filename)) =

fourmolu.yaml

@@ -0,0 +1,22 @@
+indentation: 2
+column-limit: 80
+import-export-style: diff-friendly
+import-grouping: by-qualified
+function-arrows: leading
+comma-style: leading
+indent-wheres: true
+let-style: inline
+in-style: right-align
+record-brace-space: true
+newlines-between-decls: 1
+haddock-style: multi-line
+haddock-style-module: multi-line
+single-constraint-parens: never
+single-deriving-parens: always
+sort-constraints: true
+sort-derived-classes: true
+sort-deriving-clauses: true
+trailing-section-operators: true
+fixities: []
+reexports: []
+local-modules: []

src/Core/Node.hs

@@ -1,7 +1,7 @@
-module Core.Node
-  ( isCommentNode
-  , Node(..)
-  ) where
+module Core.Node (
+  isCommentNode,
+  Node (..),
+) where
 
 import Data.Scientific (Scientific)
 import Data.Text (Text)
@@ -23,7 +23,7 @@ data Node
   | SinglelineComment Text
   | MultilineComment Text
   | Null
-  deriving (Show, Eq)
+  deriving (Eq, Show)
 
 isCommentNode :: Node -> Bool
 isCommentNode (MultilineComment _) = True

src/Core/NodeCursor.hs

@@ -1,18 +1,19 @@
-module Core.NodeCursor
-  ( NodeCursor(..)
-  , NodeBreadcrumb(..)
-  , applyCrumb
-  , applyObjCrumb
-  , compareSB
-  , comparePathAndCursor
-  , newCursor
-  ) where
+module Core.NodeCursor (
+  NodeCursor (..),
+  NodeBreadcrumb (..),
+  applyCrumb,
+  applyObjCrumb,
+  compareSB,
+  comparePathAndCursor,
+  newCursor,
+) where
+
+import Core.Node (Node (..))
+import Data.Sequence (Seq (..))
+import Data.Text (Text)
 
-import Core.Node (Node(..))
 import Core.NodePath qualified as NP
-import Data.Sequence (Seq(..))
 import Data.Sequence qualified as Seq (empty, null)
-import Data.Text (Text)
 import Data.Text qualified as T
 
 data NodeBreadcrumb
@@ -23,8 +24,8 @@ instance Show NodeBreadcrumb where
   show (ArrayIndex i) = "[" <> show i <> "]"
   show (ObjectIndexAndKey (_, k)) = "." <> T.unpack k
 
-newtype NodeCursor =
-  NodeCursor (Seq NodeBreadcrumb)
+newtype NodeCursor
+  = NodeCursor (Seq NodeBreadcrumb)
 
 instance Show NodeCursor where
   show (NodeCursor (b :<| bs)) = show b <> show (NodeCursor bs)

src/Core/NodePath.hs

@@ -1,33 +1,34 @@
 {-# LANGUAGE TypeFamilies #-}
 
-module Core.NodePath
-  ( NodePath(..)
-  , NodeSelector(..)
-  , queryNodes
-  , select
-  ) where
-
-import Core.Node qualified as N (Node(..))
-import Data.Sequence (Seq(..))
+module Core.NodePath (
+  NodePath (..),
+  NodeSelector (..),
+  queryNodes,
+  select,
+) where
+
+import Data.Sequence (Seq (..))
 import Data.Text (Text)
-import Data.Text qualified as T
 import Data.Vector ((!?))
+import GHC.IsList (IsList (..))
+
+import Core.Node qualified as N (Node (..))
+import Data.Text qualified as T
 import Data.Vector qualified as V
-import GHC.IsList (IsList(..))
 
 data NodeSelector
   = ArrayIndex Int
   | ObjectKey Text
   | ObjectIndex Int
-  deriving (Ord, Eq)
+  deriving (Eq, Ord)
 
 instance Show NodeSelector where
   show (ArrayIndex i) = "[" <> show i <> "]"
   show (ObjectKey k) = "." <> T.unpack k
   show (ObjectIndex k) = "." <> show k
 
-newtype NodePath =
-  NodePath (Seq NodeSelector)
+newtype NodePath
+  = NodePath (Seq NodeSelector)
 
 instance Show NodePath where
   show (NodePath (b :<| bs)) = show b <> show (NodePath bs)

src/Formatting.hs

@@ -1,43 +1,44 @@
-module Formatting
-  ( formatNode
-  , newRuleSet
-  , RuleSet(..)
-  ) where
+module Formatting (
+  formatNode,
+  newRuleSet,
+  RuleSet (..),
+) where
 
-import Core.Node (Node(..), isCommentNode)
-import Core.NodeCursor qualified as NC
+import Core.Node (Node (..), isCommentNode)
 import Data.Bool (bool)
 import Data.Char (isSpace)
-import Data.Scientific (FPFormat(Fixed), formatScientific)
-import Data.Text qualified as T
+import Data.Scientific (FPFormat (Fixed), formatScientific)
 import Data.Text (Text)
 import Data.Vector (Vector)
+import Formatting.Rules (
+  RuleSet (..),
+  applyPadLogic,
+  findPropertiesForCursor,
+  newRuleSet,
+  noComplexNewLine,
+ )
+
+import Core.NodeCursor qualified as NC
+import Data.Text qualified as T
 import Data.Vector qualified as V (null, toList)
-import Formatting.Rules
-  ( RuleSet(..)
-  , applyPadLogic
-  , findPropertiesForCursor
-  , newRuleSet
-  , noComplexNewLine
-  )
 
-addDelimiters ::
-     RuleSet -> Int -> NC.NodeCursor -> Bool -> [Text] -> [Node] -> [Text]
+addDelimiters
+  :: RuleSet -> Int -> NC.NodeCursor -> Bool -> [Text] -> [Node] -> [Text]
 addDelimiters _ _ _ _ acc [] = acc
-addDelimiters rs index c complexChildren acc ns@(node:rest)
+addDelimiters rs index c complexChildren acc ns@(node : rest)
   | complexChildren && null acc =
-    addDelimiters rs index c complexChildren ["\n"] ns
+      addDelimiters rs index c complexChildren ["\n"] ns
   | isCommentNode node =
-    addDelimiters
-      rs
-      newIndex
-      c
-      complexChildren
-      (formatNode rs c node <> "\n" : acc)
-      rest
+      addDelimiters
+        rs
+        newIndex
+        c
+        complexChildren
+        (formatNode rs c node <> "\n" : acc)
+        rest
   | otherwise =
-    let new_acc = T.concat [applyCrumbAndFormat, comma, space, newline] : acc
-     in addDelimiters rs newIndex c complexChildren new_acc rest
+      let new_acc = T.concat [applyCrumbAndFormat, comma, space, newline] : acc
+       in addDelimiters rs newIndex c complexChildren new_acc rest
   where
     applyCrumbAndFormat =
       NC.applyCrumb (NC.ArrayIndex index) c (formatNode rs) node
@@ -64,8 +65,8 @@ indent s
 doFormatNode :: RuleSet -> NC.NodeCursor -> Vector Node -> Text
 doFormatNode rs cursor nodes =
   let formatted =
-        reverse . addDelimiters rs 0 cursor complexChildren [] . V.toList
-          $ nodes
+        reverse . addDelimiters rs 0 cursor complexChildren [] . V.toList $
+          nodes
    in if complexChildren
         then T.unlines . map indent . concatMap T.lines $ formatted
         else T.concat formatted
@@ -76,9 +77,9 @@ doFormatNode rs cursor nodes =
 padLogic :: (Node -> Text) -> Int -> Bool -> Node -> Text
 padLogic f padAmount padZeros n
   | not (isComplexNode n) =
-    if padZeros && isNumberNode n
-      then T.justifyLeft padAmount '0' $ f n
-      else T.justifyRight padAmount ' ' $ f n
+      if padZeros && isNumberNode n
+        then T.justifyLeft padAmount '0' $ f n
+        else T.justifyRight padAmount ' ' $ f n
   | otherwise = f n
 
 formatScalarNode :: Node -> Text