Always read shipped config file (#133)

Upon installation a configuration file will always be created if missing. But if a user already installed jbeam-edit, a configuration was created, then the user updates to a new version, then the new installation would use older configuration which was in AppData. This patch will load the shipped configuration file and the AppData version if it exists, preferring the the AppData settings if availabale.

Since jbeam-edit now both loads a config file in AppData as well as the shipped minimal configuration, I added a test which proves that combining the configurations at runtime works. I also improved logging in the test suite to be able debug issues easier.

Author: webdevred

.github/workflows/build-and-release.yaml

@@ -73,8 +73,11 @@ jobs:
       - name: Build dependencies, good to do separate for caching
         run: cabal build --project-file cabal.project.release --only-dependencies
       - name: Build LSP executable
+        shell: bash
         run: |
           cabal build exe:jbeam-lsp-server --project-file cabal.project.release || true
+          LSP_FOLDER=$(find dist-newstyle -path '*/build/jbeam-lsp-server')
+          cp -r examples $LSP_FOLDER/
       - name: Build main executable
         run: cabal build exe:jbeam-edit --project-file cabal.project.release
       - name: Run tests (GHC ${{ matrix.ghc }})

cabal.project

@@ -1,5 +1,6 @@
 packages: .
 optimization: False
+test-options: --diff-context=0 --color
 
 package *
   tests: False

src/JbeamEdit/Formatting.hs

@@ -2,7 +2,6 @@ module JbeamEdit.Formatting (
   formatNode,
   formatWithCursor,
   formatScalarNode,
-  newRuleSet,
   RuleSet (..),
 ) where
 
@@ -30,7 +29,6 @@ import JbeamEdit.Formatting.Rules (
   findPropertiesForCursor,
   forceComplexNewLine,
   lookupIndentProperty,
-  newRuleSet,
   noComplexNewLine,
  )
 

src/JbeamEdit/Formatting/Config.hs

@@ -2,6 +2,8 @@
 
 module JbeamEdit.Formatting.Config (localRuleFile, readFormattingConfig, copyToConfigDir, ConfigType (..)) where
 
+import Data.Foldable (traverse_)
+import Data.Text qualified as T
 import GHC.IO.Exception (IOErrorType (NoSuchThing))
 import JbeamEdit.Formatting.Rules
 import JbeamEdit.IOUtils
@@ -59,8 +61,12 @@ copyConfigFile :: OsPath -> ConfigType -> IO ()
 copyConfigFile dest configType = do
   createDirectoryIfMissing True (takeDirectory dest)
   source <- getJbflSourcePath configType
-  destPath <- decodeUtf dest
-  putStrLn ("installing " ++ show configType ++ " config file to " ++ destPath)
+  putErrorLine
+    ( "installing "
+        <> T.pack (show configType)
+        <> " config file to "
+        <> T.pack (show dest)
+    )
   copyFile source dest
 
 copyToConfigDir :: ConfigType -> IO ()
@@ -76,14 +82,18 @@ createRuleFileIfDoesNotExist configPath =
 readFormattingConfig :: Maybe OsPath -> IO RuleSet
 readFormattingConfig maybeJbflPath = do
   configDir <- getConfigDir
-  case maybeJbflPath of
-    Just jbfl ->
-      decodeUtf jbfl
-        >>= (\a -> putErrorStringLn $ "Loading jbfl: " ++ a)
-    Nothing ->
-      createRuleFileIfDoesNotExist (configDir </> userRuleFile)
+  traverse_
+    (\jbfl -> putErrorLine $ "Loading jbfl: " <> T.pack (show jbfl))
+    maybeJbflPath
+  createRuleFileIfDoesNotExist (configDir </> userRuleFile)
   configPath <- getConfigPath maybeJbflPath configDir
-  contents <- tryReadFile [NoSuchThing] configPath
-  case contents >>= parseDSL of
-    Right rs -> pure rs
-    Left err -> putErrorLine err $> newRuleSet
+  userCfg <- tryReadFile [NoSuchThing] configPath
+  defaultRulesetPath <- getJbflSourcePath MinimalConfig
+  defaultCfg <- tryReadFile [] defaultRulesetPath
+  case (userCfg >>= parseDSL, defaultCfg >>= parseDSL) of
+    (Right rs, Right defaultRs) -> pure (rs <> defaultRs)
+    (Left err, Right defaultRs) -> putErrorLine err $> defaultRs
+    (_, Left err) ->
+      let err' =
+            "Failed to parse default ruleset. Please consider making bugreport. \n" <> err
+       in putErrorLine err' >> mempty

src/JbeamEdit/Formatting/Rules.hs

@@ -19,7 +19,6 @@ module JbeamEdit.Formatting.Rules (
   noComplexNewLine,
   forceComplexNewLine,
   lookupIndentProperty,
-  newRuleSet,
   findPropertiesForCursor,
 ) where
 
@@ -57,6 +56,12 @@ newtype NodePattern
   = NodePattern (Seq NodePatternSelector)
   deriving stock (Eq, Read, Show)
 
+instance Monoid RuleSet where
+  mempty = RuleSet M.empty
+
+instance Semigroup RuleSet where
+  (RuleSet rs1) <> (RuleSet rs2) = RuleSet (M.unionWith M.union rs1 rs2)
+
 instance Ord NodePattern where
   compare (NodePattern a) (NodePattern b) =
     case on compare (Down . Seq.length) a b of
@@ -161,9 +166,6 @@ newtype RuleSet
   = RuleSet (Map NodePattern Rule)
   deriving stock (Eq, Read, Show)
 
-newRuleSet :: RuleSet
-newRuleSet = RuleSet M.empty
-
 lookupProp :: (Eq a, Read a, Show a) => PropertyKey a -> Rule -> Maybe a
 lookupProp targetKey m =
   case M.lookup (SomeKey targetKey) m of

src/JbeamEdit/IOUtils.hs

@@ -9,7 +9,7 @@ import Data.Text (Text)
 import Data.Text qualified as T (append, pack, unpack)
 import GHC.IO.Exception (IOErrorType, IOException (IOError))
 import JbeamEdit.Core.Node (Node)
-import JbeamEdit.Formatting (formatNode, newRuleSet)
+import JbeamEdit.Formatting (formatNode)
 import System.File.OsPath qualified as OS
 import System.IO (hPutStrLn, stderr)
 import System.OsPath
@@ -24,7 +24,7 @@ reportInvalidNodes :: Text -> [Node] -> IO ()
 reportInvalidNodes msg nodes =
   unless (null nodes) $ do
     putErrorLine msg
-    mapM_ (putErrorLine . formatNode newRuleSet) nodes
+    mapM_ (putErrorLine . formatNode mempty) nodes
 
 ioErrorMsg
   :: [IOErrorType]

src/JbeamEdit/Parsing/DSL.hs

@@ -142,7 +142,7 @@ ruleSetParser = RuleSet . M.fromListWith M.union . separateRulesets <$> MP.some
 
 parseDSL :: LBS.ByteString -> Either Text RuleSet
 parseDSL input
-  | LBS.null input = pure newRuleSet
+  | LBS.null input = pure mempty
   | otherwise =
       first formatErrors . MP.parse (ruleSetParser <* MP.eof) "<input>" $
         input

test-extra/language-server/WorkspaceLspSpec.hs

@@ -4,35 +4,21 @@ import Control.Monad.IO.Class (liftIO)
 import Data.Text qualified as T (pack)
 import Language.LSP.Protocol.Types as LSP
 import Language.LSP.Test
-import System.Directory (getCurrentDirectory)
 import System.FilePath ((</>))
 import System.IO qualified as IO (readFile)
 import Test.Hspec
 
-exampleJbflFilepath :: FilePath -> FilePath
-exampleJbflFilepath cwd =
-  cwd
-    </> "examples"
-    </> "jbfl"
-    </> "minimal.jbfl"
-
-spec :: Spec
-spec = do
-  cwd <- runIO getCurrentDirectory
-  workspaceSpec cwd
-
 runJbeamSession :: FilePath -> Session a -> IO a
-runJbeamSession cwd =
-  runSession
-    ("jbeam-lsp-server -c " <> exampleJbflFilepath cwd)
-    fullLatestClientCaps
-    "examples"
-
-formatVerify :: Session ()
-formatVerify = do
-  let jbeamFile = "jbeam" </> "fender.jbeam"
-      expectedFile = "examples" </> "formatted_jbeam" </> "fender-minimal-jbfl.jbeam"
-
+runJbeamSession jbflFile = runSessionWithConfig cfg cmd fullLatestClientCaps "examples"
+  where
+    cmd = "jbeam-lsp-server -c " <> jbflFile
+    cfg =
+      defaultConfig
+        { logStdErr = True
+        }
+
+formatVerify :: FilePath -> FilePath -> Session ()
+formatVerify jbeamFile expectedFile = do
   doc <- openDoc jbeamFile "jbeam"
 
   formatDoc doc (LSP.FormattingOptions 0 False Nothing Nothing Nothing)
@@ -42,9 +28,29 @@ formatVerify = do
 
   liftIO $ formatted `shouldBe` expected
 
-workspaceSpec :: FilePath -> Spec
-workspaceSpec cwd =
-  let label =
-        describe "JBeam LSP Formatter"
-          . it "formats a single JBeam file with a single JBFL rule correctly"
-   in label . runJbeamSession cwd $ formatVerify
+jbflTests :: [(FilePath, FilePath, FilePath)]
+jbflTests =
+  [
+    ( "jbeam" </> "fender.jbeam"
+    , "examples" </> "formatted_jbeam" </> "fender-minimal-jbfl.jbeam"
+    , "examples" </> "jbfl" </> "minimal.jbfl"
+    )
+  ,
+    ( "jbeam" </> "fender.jbeam"
+    , "test-extra/language-server/data/fender-custom-minimal-jbfl.jbeam"
+    , "test-extra/language-server/data/custom-minimal.jbfl"
+    )
+  ]
+
+workspaceSpec :: Spec
+workspaceSpec =
+  describe "JBeam LSP Formatter" $
+    mapM_
+      ( \(jbeam, expected, jbfl) ->
+          it ("formats " <> jbeam <> " correctly") $
+            runJbeamSession jbfl (formatVerify jbeam expected)
+      )
+      jbflTests
+
+spec :: Spec
+spec = workspaceSpec

test-extra/language-server/data/custom-minimal.jbfl

@@ -0,0 +1,3 @@
+.*.nodes[*][*] {
+    PadAmount: 8;
+}

test/FormattingSpec.hs

@@ -87,7 +87,7 @@ spec = do
       applySpecOnInput
         descFun
         shouldBe
-        (formatWithCursor newRuleSet newCursor node)
+        (formatWithCursor mempty newCursor node)
         (T.pack jbeam)
     descFun jbeam node = "should format " ++ show node ++ " as " ++ jbeam
     specs =