Merge branch 'main' into cleanup-main

Author: B-rando1

.github/workflows/Build.yaml

@@ -65,7 +65,7 @@ jobs:
           stack-version: 'latest'
 
       - name: "Cache dependencies"
-        uses: actions/[email protected].2
+        uses: actions/[email protected].3
         with:
           path: |
             ~/.stack

code/drasil-code/lib/Language/Drasil/Chunk/CodeDefinition.hs

@@ -5,7 +5,7 @@ module Language.Drasil.Chunk.CodeDefinition (
 
 import Control.Lens ((^.), makeLenses, view)
 
-import Drasil.Database (HasUID (..))
+import Drasil.Database (HasUID(..), HasChunkRefs(..))
 import Language.Drasil
 
 import Drasil.Code.CodeExpr.Development (CodeExpr, expr, CanGenCode(..))
@@ -23,6 +23,9 @@ data CodeDefinition = CD { _cchunk   :: CodeChunk
                          }
 makeLenses ''CodeDefinition
 
+instance HasChunkRefs CodeDefinition where
+  chunkRefs = const mempty -- FIXME: `chunkRefs` should actually collect the referenced chunks.
+
 -- | Finds the 'UID' of the 'CodeChunk' used to make the 'CodeDefinition'.
 instance HasUID           CodeDefinition where uid = cchunk . uid
 -- | Finds the term ('NP') of the 'CodeChunk' used to make the 'CodeDefinition'.

code/drasil-code/lib/Language/Drasil/Chunk/NamedArgument.hs

@@ -8,17 +8,21 @@ module Language.Drasil.Chunk.NamedArgument (
 
 import Control.Lens ((^.), makeLenses, view)
 
-import Drasil.Database (HasUID(..))
+import Drasil.Database (HasUID(..), HasChunkRefs(..))
 import Language.Drasil (HasSpace(..), HasSymbol(..),
   Idea(..), MayHaveUnit(..), NamedIdea(..), Quantity,
   DefinedQuantityDict, Concept, dqdWr, Definition (defn), ConceptDomain (cdom))
 
 import Drasil.Code.Classes (IsArgumentName)
+
 -- | Any quantity can be a named argument (wrapper for 'DefinedQuantityDict'),
 -- but with more of a focus on generating code arguments.
 newtype NamedArgument = NA {_qtd :: DefinedQuantityDict}
 makeLenses ''NamedArgument
 
+instance HasChunkRefs NamedArgument where
+  chunkRefs = const mempty -- FIXME: `chunkRefs` should actually collect the referenced chunks.
+
 -- | Finds the 'UID' of the 'DefinedQuantityDict' used to make the 'NamedArgument'.
 instance HasUID         NamedArgument where uid = qtd . uid
 -- | Finds the term ('NP') of the 'DefinedQuantityDict' used to make the 'NamedArgument'.

code/drasil-code/lib/Language/Drasil/Chunk/Parameter.hs

@@ -5,7 +5,7 @@ module Language.Drasil.Chunk.Parameter (
 
 import Control.Lens ((^.), makeLenses, view)
 
-import Drasil.Database (HasUID(..))
+import Drasil.Database (HasUID(..), HasChunkRefs(..))
 import Language.Drasil hiding (Ref)
 
 import Language.Drasil.Chunk.Code (CodeIdea(..), CodeChunk)
@@ -18,6 +18,9 @@ data ParameterChunk = PC {_pcc :: CodeChunk
                          , passBy :: PassBy}
 makeLenses ''ParameterChunk
 
+instance HasChunkRefs ParameterChunk where
+  chunkRefs = const mempty -- FIXME: `chunkRefs` should actually collect the referenced chunks.
+
 -- | Finds the 'UID' of the 'CodeChunk' used to make the 'ParameterChunk'.
 instance HasUID      ParameterChunk where uid = pcc . uid
 -- | Finds the term ('NP') of the 'CodeChunk' used to make the 'ParameterChunk'.

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

@@ -1,13 +1,14 @@
 {-# LANGUAGE  PatternSynonyms #-}
-
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FlexibleContexts #-}
 -- | Defines the underlying data types used in the package extension.
 module Language.Drasil.Code.FileData (FileAndContents(filePath, fileDoc),
-  fileAndContents, fileDataToFileAndContents,
+  fileAndContents, hasPathAndDocToFileAndContents,
   PackageData(packageProg, packageAux), pattern PackageData
   ) where
 
 import Text.PrettyPrint.HughesPJ (Doc, isEmpty)
-import qualified Drasil.GOOL as G (FileData(..), ModData(..))
+import Utils.Drasil (HasPathAndDoc(..))
 
 -- | The underlying data type for auxiliary files in all renderers.
 data FileAndContents = FileAndContents {filePath :: FilePath, fileDoc :: Doc}
@@ -16,8 +17,12 @@ data FileAndContents = FileAndContents {filePath :: FilePath, fileDoc :: Doc}
 fileAndContents :: FilePath -> Doc -> FileAndContents
 fileAndContents = FileAndContents
 
-fileDataToFileAndContents :: G.FileData -> FileAndContents
-fileDataToFileAndContents file = fileAndContents (G.filePath file) ((G.modDoc . G.fileMod) file)
+instance HasPathAndDoc FileAndContents Doc where
+  getPath = filePath
+  getDoc = fileDoc
+
+hasPathAndDocToFileAndContents :: (HasPathAndDoc a Doc) => a -> FileAndContents
+hasPathAndDocToFileAndContents file = fileAndContents (getPath file) (getDoc file)
 
 -- | The underlying data type for packages in all renderers.
 data PackageData a = PackD {packageProg :: a, packageAux :: [FileAndContents]}

code/drasil-code/lib/Language/Drasil/Code/Imperative/Generator.hs

@@ -10,8 +10,6 @@ import Data.Map (fromList, member, keys, elems)
 import Data.Maybe (maybeToList, catMaybes)
 import Data.Foldable (traverse_)
 import System.Directory (setCurrentDirectory, getCurrentDirectory)
-import System.FilePath.Posix (takeDirectory)
-import System.IO (hPutStrLn, hClose, openFile, IOMode(WriteMode))
 import Text.PrettyPrint.HughesPJ (isEmpty, vcat, render)
 
 import Language.Drasil
@@ -23,7 +21,7 @@ import qualified Drasil.GProc as Proc (GSProgram, SFile, ProgramSym(..), unCI)
 import Language.Drasil.Printers (SingleLine(OneLine), sentenceDoc, piSys, plainConfiguration)
 import Language.Drasil.Printing.Import (spec)
 import Drasil.System
-import Utils.Drasil (createDirIfMissing)
+import Utils.Drasil (createDirIfMissing, createFile)
 
 import Language.Drasil.Code.Imperative.ConceptMatch (chooseConcept)
 import Language.Drasil.Code.Imperative.Descriptions (unmodularDesc)
@@ -47,7 +45,7 @@ import Language.Drasil.Code.Imperative.GOOL.ClassInterface (
   makeSds, AuxiliarySym(..), package)
 import Language.Drasil.Code.Imperative.README (ReadMeInfo(..))
 import Language.Drasil.Code.FileData (PackageData(..), FileAndContents(..),
-  fileAndContents, fileDataToFileAndContents)
+  fileAndContents, hasPathAndDocToFileAndContents)
 import Language.Drasil.Code.FileNames(sampleInputName)
 import Language.Drasil.Code.ExtLibImport (auxMods, imports, modExports)
 import Language.Drasil.Code.Lang (Lang(..))
@@ -131,8 +129,10 @@ generateCode l unReprProg unReprPack g = do
       aux
         | l == Python = fileAndContents "__init__.py" mempty : baseAux
         | otherwise   = baseAux
-      packageFiles = map fileDataToFileAndContents (progMods $ packageProg $ unReprPack pckg) ++ aux
-  traverse_ createFile packageFiles
+      packageFiles = map
+        hasPathAndDocToFileAndContents (progMods $ packageProg $ unReprPack pckg)
+        ++ aux
+  traverse_ (\file -> createFile (filePath file) (render $ fileDoc file)) packageFiles
   setCurrentDirectory workingDir
 
 -- | Generates a package, including a Makefile, sample input file, and Doxygen
@@ -243,8 +243,10 @@ generateCodeProc l unReprProg unReprPack g = do
   let (pckg, ds) = runState (genPackageProc unReprProg) g
       baseAux = [fileAndContents "designLog.txt" (ds ^. designLog) |
           not $ isEmpty $ ds ^. designLog] ++ packageAux (unReprPack pckg)
-      packageFiles = map fileDataToFileAndContents (progMods (packageProg $ unReprPack pckg)) ++ baseAux
-  traverse_ createFile packageFiles
+      packageFiles = map
+        hasPathAndDocToFileAndContents (progMods (packageProg $ unReprPack pckg))
+        ++ baseAux
+  traverse_ (\file -> createFile (filePath file) (render $ fileDoc file)) packageFiles
   setCurrentDirectory workingDir
 
 -- | Generates a package, including a Makefile, sample input file, and Doxygen
@@ -338,17 +340,6 @@ genModulesProc = do
   if con then error "genModulesProc: Procedural renderers do not support classes"
   else return $ mn : inp ++ cal : out ++ moddef
 
--- | Helper to convert a FileAndContents into a real file with the given document
--- at the given FilePath
-createFile :: FileAndContents -> IO ()
-createFile file = do
-  let path     = filePath file
-      contents = fileDoc file
-  createDirIfMissing True (takeDirectory path)
-  h <- openFile path WriteMode
-  hPutStrLn h (render contents)
-  hClose h
-
 -- | Private utilities used in 'generateCode'.
 getDir :: Lang -> String
 getDir Cpp = "cpp"

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

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

code/drasil-code/test/Main.hs

@@ -11,8 +11,8 @@ import qualified Drasil.GProc as Proc (unCI, ProgramSym(..))
 
 import Language.Drasil.Code (ImplementationType(..), makeSds)
 import Language.Drasil.GOOL (AuxiliarySym(..), package,
-  fileDataToFileAndContents, PackageData(..), pattern PackageData, unPP, unJP,
-  unCSP, unCPPP, unSP, unJLP)
+  hasPathAndDocToFileAndContents, PackageData(..), pattern PackageData,
+  unPP, unJP, unCSP, unCPPP, unSP, unJLP)
 import qualified Language.Drasil.GOOL as D (filePath, FileAndContents(..))
 
 import Utils.Drasil (createDirIfMissing)
@@ -68,7 +68,8 @@ genCode :: [PackageData ProgData] -> IO()
 genCode files =
   createCodeFiles $ files >>= \(PackageData prog aux) ->
     let label = progName prog
-        modCode = progMods prog <&> \modFileData -> (label, fileDataToFileAndContents modFileData)
+        modCode = progMods prog <&> \modFileData ->
+          (label, hasPathAndDocToFileAndContents modFileData)
         auxCode = aux <&> (label,)
     in modCode ++ auxCode
 

code/drasil-data/lib/Data/Drasil/Theories/Physics.hs

@@ -6,7 +6,7 @@ import Utils.Drasil (weave)
 import Theory.Drasil
 import qualified Language.Drasil.Sentence.Combinators as S
 
-import Data.Drasil.Citations (velocityWiki, accelerationWiki)
+import Data.Drasil.Citations (velocityWiki, accelerationWiki, hibbeler2004)
 import Data.Drasil.Concepts.Documentation (component, material_, value, constant)
 import Data.Drasil.Concepts.Math (cartesian, equation, vector)
 import Data.Drasil.Concepts.Physics (gravity, twoD, rigidBody)
@@ -25,9 +25,9 @@ physicsTMs = [newtonSL]
 -- * Newton's Second Law of Motion
 
 newtonSL :: TheoryModel
-newtonSL = tmNoRefs (equationalModelU "newtonSL" newtonSLQD)
+newtonSL = tm (equationalModelU "newtonSL" newtonSLQD)
   [dqdWr QP.force, dqdWr QPP.mass, dqdWr QP.acceleration] ([] :: [ConceptChunk])
-  [newtonSLQD] [] [] "NewtonSecLawMot" [newtonSLDesc]
+  [newtonSLQD] [] [] [dRef hibbeler2004] "NewtonSecLawMot" [newtonSLDesc]
 
 -- * Weight
 
@@ -123,9 +123,10 @@ vecMag = ddENoRefs vecMagQD Nothing "vecMag" [magNote]
 -- * Newton's Second Law of Rotational Motion
 
 newtonSLR :: TheoryModel
-newtonSLR = tmNoRefs (equationalModelU "newtonSLR" newtonSLRQD)
+newtonSLR = tm (equationalModelU "newtonSLR" newtonSLRQD)
   [dqdWr QP.torque, dqdWr QP.momentOfInertia, dqdWr QP.angularAccel]
-  ([] :: [ConceptChunk]) [newtonSLRQD] [] [] "NewtonSecLawRotMot" newtonSLRNotes
+  ([] :: [ConceptChunk]) [newtonSLRQD] [] [] [dRef hibbeler2004]
+  "NewtonSecLawRotMot" newtonSLRNotes
 
 newtonSLRQD :: ModelQDef
 newtonSLRQD = mkQuantDef' QP.torque (nounPhraseSP "Newton's second law for rotational motion") newtonSLRExpr

code/drasil-database/lib/Drasil/Database/Chunk.hs

@@ -9,6 +9,7 @@
 module Drasil.Database.Chunk (
   Chunk,
   IsChunk,
+  TypeableChunk,
   HasChunkRefs(..),
   mkChunk, -- FIXME: mkChunk should not be exported but is temporarily because this module is NOT in `drasil-database`
   unChunk,
@@ -24,11 +25,21 @@ import GHC.Generics (Generic (Rep, from), M1 (..), K1 (..), type (:*:) (..),
 import Drasil.Database.UID (HasUID (..), UID)
 
 -- | Constraint for anything that may be considered a valid chunk type.
-type IsChunk a = (HasUID a, HasChunkRefs a, Typeable a)
+type IsChunk a = (HasUID a, HasChunkRefs a)
+
+-- | Constraint for anything that may be considered a valid chunk type, and is
+-- also 'Typeable'. Type-ability is necessary for storing/retrieving chunks
+-- in/from the 'ChunkDB'.
+--
+-- 'TypeableChunk' is meant to be a purely /internal/ concept; users of Drasil
+-- should only ever need to use 'IsChunk'. 'Typeable' is automatically derived
+-- by GHC, but can cause issues with type inference if used directly in user
+-- code, especially when involving parameterized chunk types.
+type TypeableChunk a = (IsChunk a, Typeable a)
 
 -- | A piece of reusable knowledge, with an internal identifier ('UID'),
 -- possibly dependant on other chunks.
-data Chunk = forall a. IsChunk a => Chunk a
+data Chunk = forall a. TypeableChunk a => Chunk a
 
 instance Eq Chunk where
   (==) :: Chunk -> Chunk -> Bool
@@ -43,7 +54,7 @@ instance HasChunkRefs Chunk where
   chunkRefs (Chunk c) = chunkRefs c
 
 -- | Create a 'Chunk', ensuring that 'Chunk's are never placed within 'Chunk's.
-mkChunk :: IsChunk a => a -> Chunk
+mkChunk :: TypeableChunk a => a -> Chunk
 mkChunk a
   | typeOf a == typeRep (Proxy @Chunk) = error "Cannot place a Chunk inside of a Chunk"
   | otherwise = Chunk a