Merge branch 'main' into separatePackageStuff

Author: B-rando1

code/drasil-code/lib/Language/Drasil/Code/PackageData.hs

@@ -1,5 +1,6 @@
+{-# LANGUAGE PatternSynonyms #-}
 module Language.Drasil.Code.PackageData (PackageData(packageProg, packageAux),
-  package
+  pattern PackageData, package
 ) where
 
 import Language.Drasil.Code.FileData (FileAndContents(..))
@@ -9,9 +10,11 @@ import Drasil.GOOL (ProgData, onCodeList)
 -- | The underlying data type for packages in all renderers.
 data PackageData = PackD {packageProg :: ProgData, packageAux :: [FileAndContents]}
 
--- | Constructor for package data.
-packageData :: ProgData -> [FileAndContents] -> PackageData
-packageData p as = PackD p (filter (not . isEmpty . fileDoc) as)
+pattern PackageData :: ProgData -> [FileAndContents] -> PackageData
+pattern PackageData prog aux <- PackD prog aux
+  where
+    PackageData prog aux = PackD prog (filter (not . isEmpty . fileDoc) aux)
+{-# COMPLETE PackageData #-}
 
 package :: (Monad r) => ProgData -> [r FileAndContents] -> r PackageData
-package p = onCodeList (packageData p)
+package p = onCodeList (PackageData p)

code/drasil-code/lib/Language/Drasil/GOOL.hs

@@ -1,13 +1,18 @@
+{-# LANGUAGE PatternSynonyms #-}
+
 -- | Re-export code-related smart constructors for external code writing and generation.
 module Language.Drasil.GOOL (
   AuxiliarySym(..), package,
-  FileAndContents(..), PackageData(..),
+  FileAndContents(..), hasPathAndDocToFileAndContents,
+  PackageData(..), pattern PackageData,
   unPP, unJP, unCSP, unCPPP, unSP, unJLP
 ) where
 
 import Language.Drasil.Code.Imperative.GOOL.ClassInterface (AuxiliarySym(..))
-import Language.Drasil.Code.FileData (FileAndContents(..))
-import Language.Drasil.Code.PackageData (PackageData(..), package)
+import Language.Drasil.Code.FileData (FileAndContents(..),
+  hasPathAndDocToFileAndContents)
+import Language.Drasil.Code.PackageData (PackageData(..), pattern PackageData,
+  package)
 
 import Language.Drasil.Code.Imperative.GOOL.LanguageRenderer.PythonRenderer (unPP)
 import Language.Drasil.Code.Imperative.GOOL.LanguageRenderer.JavaRenderer (unJP)

code/drasil-code/test/Main.hs

@@ -1,27 +1,29 @@
+{-# LANGUAGE PatternSynonyms, TupleSections #-}
+
 -- | Main module to gather all the GOOL tests and generate them.
 module Main (main) where
 
-import Drasil.GOOL (Label, OOProg, unJC, unPC, unCSC,
-  unCPPC, unSC, initialState, FileData(..), ProgData(..), ModData(..),
-  headers, sources, mainMod)
+import Drasil.GOOL (Label, OOProg, unJC, unPC, unCSC, unCPPC, unSC,
+  initialState, ProgData(..), headers, sources, mainMod)
 import qualified Drasil.GOOL as OO (unCI, ProgramSym(..))
 import Drasil.GProc (ProcProg, unJLC)
 import qualified Drasil.GProc as Proc (unCI, ProgramSym(..))
 
 import Language.Drasil.Code (ImplementationType(..), makeSds)
 import Language.Drasil.GOOL (AuxiliarySym(..), package,
-  FileAndContents(fileDoc), PackageData(..), unPP, unJP, unCSP, unCPPP, unSP,
-  unJLP)
-import qualified Language.Drasil.GOOL as D (filePath)
+  hasPathAndDocToFileAndContents, PackageData(..), pattern PackageData,
+  unPP, unJP, unCSP, unCPPP, unSP, unJLP)
+import qualified Language.Drasil.GOOL as D (filePath, FileAndContents(..))
 
-import Utils.Drasil (createDirIfMissing)
+import Utils.Drasil (createDirIfMissing, createFile)
 
-import Text.PrettyPrint.HughesPJ (Doc, render)
+import Text.PrettyPrint.HughesPJ (render)
 import Control.Monad.State (evalState, runState)
 import Control.Lens ((^.))
+import Data.Functor ((<&>))
+import Data.Foldable (traverse_)
 import System.Directory (setCurrentDirectory, getCurrentDirectory)
-import System.FilePath.Posix (takeDirectory)
-import System.IO (hClose, hPutStrLn, openFile, IOMode(WriteMode))
+import System.FilePath ((</>))
 import Prelude hiding (return,print,log,exp,sin,cos,tan)
 
 import HelloWorld (helloWorldOO, helloWorldProc)
@@ -62,14 +64,14 @@ main = do
 
 -- | Gathers all information needed to generate code, sorts it, and calls the renderers.
 genCode :: [PackageData] -> IO()
-genCode files = createCodeFiles (concatMap (\p -> replicate (length (progMods
-  (packageProg p)) + length (packageAux p)) (progName $ packageProg p)) files) $
-    makeCode (map (progMods . packageProg) files) (map packageAux files)
+genCode files =
+  createCodeFiles $ files >>= \(PackageData prog aux) ->
+    let label = progName prog
+        modCode = progMods prog <&> \modFileData ->
+          (label, hasPathAndDocToFileAndContents modFileData)
+        auxCode = aux <&> (label,)
+    in modCode ++ auxCode
 
--- Cannot assign the list of tests in a where clause and re-use it because the
--- "r" type variable needs to be instantiated to two different types
--- (CodeInfo and a renderer) each time this function is called
--- | Gathers the GOOL file tests and prepares them for rendering
 classes :: (OOProg r, AuxiliarySym r', Monad r') => (r (OO.Program r) -> ProgData) ->
   (r' PackageData -> PackageData) -> [PackageData]
 classes unRepr unRepr' = zipWith
@@ -95,31 +97,12 @@ jlClasses unRepr unRepr' = zipWith
   (map (Proc.unCI . (`evalState` initialState)) [helloWorldProc,
     fileTestsProc, vectorTestProc, nameGenTestProc])
 
--- | Formats code to be rendered.
-makeCode :: [[FileData]] -> [[FileAndContents]] -> [(FilePath, Doc)]
-makeCode files auxs = concat $ zipWith (++)
-  (map (map (\fd -> (filePath fd, modDoc $ fileMod fd))) files)
-  (map (map (\fileAndContents ->
-      (D.filePath fileAndContents, fileDoc fileAndContents))) auxs)
-
-  -- zip (map filePath files) (map (modDoc . fileMod) files)
-  -- ++ zip (map D.filePath auxs) (map fileDoc auxs)
-
 ------------------
 -- IO Functions --
 ------------------
 
 -- | Creates the requested 'Code' by producing files.
-createCodeFiles :: [Label] -> [(FilePath, Doc)] -> IO () -- [(FilePath, Doc)] -> IO ()
-createCodeFiles ns cs = mapM_ createCodeFile (zip ns cs)
-
--- | Helper that creates the file and renders code.
-createCodeFile :: (Label, (FilePath, Doc)) -> IO ()
-createCodeFile (n, (path, code)) = do
-    createDirIfMissing False n
-    setCurrentDirectory n
-    createDirIfMissing True (takeDirectory path)
-    h <- openFile path WriteMode
-    hPutStrLn h (render code)
-    hClose h
-    setCurrentDirectory ".."
+createCodeFiles :: [(Label, D.FileAndContents)] -> IO ()
+createCodeFiles = traverse_ $ \(name, file) -> do
+  let path = name </> D.filePath file -- FIXME [Brandon Bosman, Feb. 10, 2026]: make GOOL allow us to add name to path internally
+  createFile path (render $ D.fileDoc file)