{-# Language TupleSections #-}
---------------------------------------------------------------------------
-- | Start the process of moving away from Document as the main internal
-- representation of information, to something more informative.
-- Over time, we'll want to have a cleaner separation, but doing that
-- all at once would break too much for too long.  So we start here
-- instead.
module Drasil.DocumentLanguage where

import Drasil.DocDecl (SRSDecl, mkDocDesc)
import Drasil.DocumentLanguage.Core (AppndxSec(..), AuxConstntSec(..),
  DerivationDisplay(..), DocDesc, DocSection(..), OffShelfSolnsSec(..), GSDSec(..),
  GSDSub(..), IntroSec(..), IntroSub(..), LCsSec(..), LFunc(..),
  PDSub(..), ProblemDescription(..), RefSec(..), RefTab(..), ReqrmntSec(..),
  ReqsSub(..), SCSSub(..), StkhldrSec(..), StkhldrSub(..), SolChSpec(..),
  SSDSec(..), SSDSub(..), TraceabilitySec(..), TraceConfig(..),
  TSIntro(..), UCsSec(..), getTraceConfigUID)
import Drasil.DocumentLanguage.Definitions (ddefn, derivation, instanceModel,
  gdefn, tmodel)
import Drasil.ExtractDocDesc (getDocDesc, egetDocDesc)
import Drasil.TraceTable (generateTraceMap)

import Language.Drasil hiding (kind)
import Language.Drasil.Display (compsy)

import Database.Drasil (ChunkDB, collectUnits, refbyTable, conceptinsTable, 
  idMap, conceptinsTable, traceTable, generateRefbyMap, refTable, labelledcontentTable, 
  theoryModelTable, insmodelTable, gendefTable, dataDefnTable)

import Drasil.System
import Drasil.GetChunks (ccss, ccss', citeDB)

import Drasil.Sections.TableOfAbbAndAcronyms (tableAbbAccGen)
import Drasil.Sections.TableOfContents (toToC, findToC)
import Drasil.Sections.TableOfSymbols (table, tsIntro)
import Drasil.Sections.TableOfUnits (tOfUnitSIName, tuIntro, defaultTUI)
import qualified Drasil.DocLang.SRS as SRS (appendix,
  genSysDes, likeChg, unlikeChg, reference, solCharSpec,
  stakeholder, tOfCont, tOfSymb, tOfUnit, userChar, offShelfSol, refMat,
  tOfAbbAcc)
import Drasil.DocLang.References (secRefs)
import qualified Drasil.Sections.AuxiliaryConstants as AC (valsOfAuxConstantsF)
import qualified Drasil.Sections.GeneralSystDesc as GSD (genSysIntro,
  systCon, usrCharsF, sysContxt)
import qualified Drasil.Sections.Introduction as Intro (charIntRdrF,
  introductionSection, orgSec, purposeOfDoc, scopeOfRequirements)
import qualified Drasil.Sections.Requirements as R (reqF, fReqF, nfReqF)
import qualified Drasil.Sections.SpecificSystemDescription as SSD (assumpF,
  datConF, dataDefnF, genDefnF, goalStmtF, inModelF, physSystDesc, probDescF,
  propCorSolF, solutionCharSpecIntro, specSysDescr, termDefnF, thModF, helperCI,
  tmStub, ddStub, gdStub, imStub, pdStub)
import qualified Drasil.Sections.Stakeholders as Stk (stakeholderIntro,
  tClientF, tCustomerF)
import qualified Drasil.DocumentLanguage.TraceabilityMatrix as TM (
  generateTraceTableView, traceMHeader, layoutUIDs)
import qualified Drasil.DocumentLanguage.TraceabilityGraph as TG (traceMGF)
import Drasil.DocumentLanguage.TraceabilityGraph (traceyGraphGetRefs)
import Drasil.Sections.TraceabilityMandGs (traceMatStandard)

import qualified Data.Drasil.Concepts.Documentation as Doc (likelyChg, section_,
  software, unlikelyChg)

import Control.Lens ((^.), set)
import Data.Function (on)
import Data.List (nub, sortBy, sortOn)
import qualified Data.Map as Map (elems, toList, assocs, keys)
import Data.Maybe (maybeToList)
import Drasil.Sections.ReferenceMaterial (emptySectSentPlu)


-- * Main Function
-- | Creates a document from a document description, a title combinator function, and system information.
mkDoc :: SRSDecl -> (IdeaDict -> IdeaDict -> Sentence) -> System -> Document
mkDoc :: SRSDecl -> (IdeaDict -> IdeaDict -> Sentence) -> System -> Document
mkDoc SRSDecl
dd IdeaDict -> IdeaDict -> Sentence
comb si :: System
si@SI {_sys :: ()
_sys = a
sys, _authors :: System -> People
_authors = People
docauthors} =
  Sentence
-> Sentence -> ShowTableOfContents -> [Section] -> Document
Document (System -> IdeaDict
whatsTheBigIdea System
si IdeaDict -> IdeaDict -> Sentence
`comb` a -> IdeaDict
forall c. Idea c => c -> IdeaDict
nw a
sys) (SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List ([Sentence] -> Sentence) -> [Sentence] -> Sentence
forall a b. (a -> b) -> a -> b
$ (Person -> Sentence) -> People -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map (String -> Sentence
S (String -> Sentence) -> (Person -> String) -> Person -> Sentence
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Person -> String
forall n. HasName n => n -> String
name) People
docauthors) ([DocSection] -> ShowTableOfContents
findToC [DocSection]
l) ([Section] -> Document) -> [Section] -> Document
forall a b. (a -> b) -> a -> b
$
  System -> [DocSection] -> [Section]
mkSections System
fullSI [DocSection]
l where
    fullSI :: System
fullSI = SRSDecl -> System -> System
fillcdbSRS SRSDecl
dd System
si
    l :: [DocSection]
l = System -> SRSDecl -> [DocSection]
mkDocDesc System
fullSI SRSDecl
dd

-- * Functions to Fill 'ChunkDB'

-- FIXME: None of these 'fill$x$InTheCDB' should exist here. Generating new
-- chunks and inserting them into the ChunkDB is not an issue, but:
-- - The traceability-stuff should be internal to ChunkDB.
-- - The References and LabelledContent entirely need to be rebuilt. Some will
--   be chunks that are manually written, others will not be chunks.

-- | Assuming a given 'ChunkDB' with no traces and minimal/no references, fill
-- in for rest of system information. Currently fills in references,
-- traceability matrix information and 'IdeaDict's.
fillcdbSRS :: SRSDecl -> System -> System
fillcdbSRS :: SRSDecl -> System -> System
fillcdbSRS SRSDecl
srsDec System
si = SRSDecl -> System -> System
fillSecAndLC SRSDecl
srsDec (System -> System) -> System -> System
forall a b. (a -> b) -> a -> b
$ SRSDecl -> System -> System
fillReferences SRSDecl
srsDec (System -> System) -> System -> System
forall a b. (a -> b) -> a -> b
$ SRSDecl -> System -> System
fillTraceSI SRSDecl
srsDec System
si

-- | Fill in the 'Section's and 'LabelledContent' maps of the 'ChunkDB' from the 'SRSDecl'.
fillSecAndLC :: SRSDecl -> System -> System
fillSecAndLC :: SRSDecl -> System -> System
fillSecAndLC SRSDecl
dd System
si = System
si2
  where
    -- Get current contents of si
    chkdb :: ChunkDB
chkdb = System
si System -> Getting ChunkDB System ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB System ChunkDB
forall c. HasSystem c => Lens' c ChunkDB
Lens' System ChunkDB
systemdb
    -- extract sections and labelledcontent
    allSections :: [Section]
allSections = (Section -> [Section]) -> [Section] -> [Section]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Section -> [Section]
findAllSec ([Section] -> [Section]) -> [Section] -> [Section]
forall a b. (a -> b) -> a -> b
$ System -> [DocSection] -> [Section]
mkSections System
si ([DocSection] -> [Section]) -> [DocSection] -> [Section]
forall a b. (a -> b) -> a -> b
$ System -> SRSDecl -> [DocSection]
mkDocDesc System
si SRSDecl
dd -- FIXME: `mkSections` on something particularly large that is immediately discarded is a sign that we're doing something wrong. That's in addition to `mkDocDesc`...
    allLC :: [LabelledContent]
allLC = (Section -> [LabelledContent]) -> [Section] -> [LabelledContent]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Section -> [LabelledContent]
findAllLC [Section]
allSections
    existingLC :: [LabelledContent]
existingLC = ((UID, (LabelledContent, Int)) -> LabelledContent)
-> [(UID, (LabelledContent, Int))] -> [LabelledContent]
forall a b. (a -> b) -> [a] -> [b]
map ((LabelledContent, Int) -> LabelledContent
forall a b. (a, b) -> a
fst((LabelledContent, Int) -> LabelledContent)
-> ((UID, (LabelledContent, Int)) -> (LabelledContent, Int))
-> (UID, (LabelledContent, Int))
-> LabelledContent
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (LabelledContent, Int)) -> (LabelledContent, Int)
forall a b. (a, b) -> b
snd) ([(UID, (LabelledContent, Int))] -> [LabelledContent])
-> [(UID, (LabelledContent, Int))] -> [LabelledContent]
forall a b. (a -> b) -> a -> b
$ Map UID (LabelledContent, Int) -> [(UID, (LabelledContent, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (LabelledContent, Int) -> [(UID, (LabelledContent, Int))])
-> Map UID (LabelledContent, Int)
-> [(UID, (LabelledContent, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (LabelledContent, Int))
     ChunkDB
     (Map UID (LabelledContent, Int))
-> Map UID (LabelledContent, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (LabelledContent, Int))
  ChunkDB
  (Map UID (LabelledContent, Int))
Lens' ChunkDB (Map UID (LabelledContent, Int))
labelledcontentTable
    -- fill in the appropriate chunkdb fields
    chkdb2 :: ChunkDB
chkdb2 = ASetter
  ChunkDB
  ChunkDB
  (Map UID (LabelledContent, Int))
  (Map UID (LabelledContent, Int))
-> Map UID (LabelledContent, Int) -> ChunkDB -> ChunkDB
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
  ChunkDB
  ChunkDB
  (Map UID (LabelledContent, Int))
  (Map UID (LabelledContent, Int))
Lens' ChunkDB (Map UID (LabelledContent, Int))
labelledcontentTable (String -> [LabelledContent] -> Map UID (LabelledContent, Int)
forall a. HasUID a => String -> [a] -> Map UID (a, Int)
idMap String
"LLCMap" ([LabelledContent] -> Map UID (LabelledContent, Int))
-> [LabelledContent] -> Map UID (LabelledContent, Int)
forall a b. (a -> b) -> a -> b
$ [LabelledContent] -> [LabelledContent]
forall a. Eq a => [a] -> [a]
nub ([LabelledContent] -> [LabelledContent])
-> [LabelledContent] -> [LabelledContent]
forall a b. (a -> b) -> a -> b
$ [LabelledContent]
existingLC [LabelledContent] -> [LabelledContent] -> [LabelledContent]
forall a. [a] -> [a] -> [a]
++ [LabelledContent]
allLC) ChunkDB
chkdb
    -- return the filled in system information
    si2 :: System
si2 = ASetter System System ChunkDB ChunkDB
-> ChunkDB -> System -> System
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter System System ChunkDB ChunkDB
forall c. HasSystem c => Lens' c ChunkDB
Lens' System ChunkDB
systemdb ChunkDB
chkdb2 System
si

    -- Helper and finder functions
    findAllSec :: Section -> [Section]
    findAllSec :: Section -> [Section]
findAllSec s :: Section
s@(Section Sentence
_ [SecCons]
cs Reference
_) = Section
s Section -> [Section] -> [Section]
forall a. a -> [a] -> [a]
: (SecCons -> [Section]) -> [SecCons] -> [Section]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SecCons -> [Section]
findAllSubSec [SecCons]
cs

    findAllSubSec :: SecCons -> [Section]
    findAllSubSec :: SecCons -> [Section]
findAllSubSec (Sub Section
s) = Section -> [Section]
findAllSec Section
s
    findAllSubSec SecCons
_ = []

    findAllLC :: Section -> [LabelledContent]
    findAllLC :: Section -> [LabelledContent]
findAllLC (Section Sentence
_ [SecCons]
cs Reference
_) = (SecCons -> [LabelledContent]) -> [SecCons] -> [LabelledContent]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SecCons -> [LabelledContent]
findLCSecCons [SecCons]
cs

    findLCSecCons :: SecCons -> [LabelledContent]
    findLCSecCons :: SecCons -> [LabelledContent]
findLCSecCons (Sub Section
s) = Section -> [LabelledContent]
findAllLC Section
s
    findLCSecCons (Con (LlC lblcons :: LabelledContent
lblcons@(LblC {_ctype :: LabelledContent -> RawContent
_ctype = Figure {}}))) = [LabelledContent
lblcons]
    findLCSecCons SecCons
_ = []

-- | Takes in existing information from the Chunk database to construct a database of references.
fillReferences :: SRSDecl -> System -> System
fillReferences :: SRSDecl -> System -> System
fillReferences SRSDecl
dd si :: System
si@SI{_sys :: ()
_sys = a
sys} = System
si2
  where
    -- get old chunk database + ref database
    chkdb :: ChunkDB
chkdb = System
si System -> Getting ChunkDB System ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB System ChunkDB
forall c. HasSystem c => Lens' c ChunkDB
Lens' System ChunkDB
systemdb
    cites :: BibRef
cites = System -> BibRef
citeDB System
si
    -- convert SRSDecl into a list of sections (to easily get at all the references used in the SRS)
    allSections :: [Section]
allSections = System -> [DocSection] -> [Section]
mkSections System
si ([DocSection] -> [Section]) -> [DocSection] -> [Section]
forall a b. (a -> b) -> a -> b
$ System -> SRSDecl -> [DocSection]
mkDocDesc System
si SRSDecl
dd
    -- get refs from SRSDecl. Should include all section labels and labelled content.
    refsFromSRS :: [Reference]
refsFromSRS = (Section -> [Reference]) -> [Section] -> [Reference]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Section -> [Reference]
findAllRefs [Section]
allSections
    -- get refs from the stuff already inside the chunk database
    ddefs :: [DataDefinition]
ddefs   = ((DataDefinition, Int) -> DataDefinition)
-> [(DataDefinition, Int)] -> [DataDefinition]
forall a b. (a -> b) -> [a] -> [b]
map (DataDefinition, Int) -> DataDefinition
forall a b. (a, b) -> a
fst ([(DataDefinition, Int)] -> [DataDefinition])
-> [(DataDefinition, Int)] -> [DataDefinition]
forall a b. (a -> b) -> a -> b
$ Map UID (DataDefinition, Int) -> [(DataDefinition, Int)]
forall k a. Map k a -> [a]
Map.elems (Map UID (DataDefinition, Int) -> [(DataDefinition, Int)])
-> Map UID (DataDefinition, Int) -> [(DataDefinition, Int)]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (DataDefinition, Int))
     ChunkDB
     (Map UID (DataDefinition, Int))
-> Map UID (DataDefinition, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (DataDefinition, Int))
  ChunkDB
  (Map UID (DataDefinition, Int))
Lens' ChunkDB (Map UID (DataDefinition, Int))
dataDefnTable
    gdefs :: [GenDefn]
gdefs   = ((GenDefn, Int) -> GenDefn) -> [(GenDefn, Int)] -> [GenDefn]
forall a b. (a -> b) -> [a] -> [b]
map (GenDefn, Int) -> GenDefn
forall a b. (a, b) -> a
fst ([(GenDefn, Int)] -> [GenDefn]) -> [(GenDefn, Int)] -> [GenDefn]
forall a b. (a -> b) -> a -> b
$ Map UID (GenDefn, Int) -> [(GenDefn, Int)]
forall k a. Map k a -> [a]
Map.elems (Map UID (GenDefn, Int) -> [(GenDefn, Int)])
-> Map UID (GenDefn, Int) -> [(GenDefn, Int)]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (GenDefn, Int)) ChunkDB (Map UID (GenDefn, Int))
-> Map UID (GenDefn, Int)
forall s a. s -> Getting a s a -> a
^. Getting (Map UID (GenDefn, Int)) ChunkDB (Map UID (GenDefn, Int))
Lens' ChunkDB (Map UID (GenDefn, Int))
gendefTable
    imods :: [InstanceModel]
imods   = ((InstanceModel, Int) -> InstanceModel)
-> [(InstanceModel, Int)] -> [InstanceModel]
forall a b. (a -> b) -> [a] -> [b]
map (InstanceModel, Int) -> InstanceModel
forall a b. (a, b) -> a
fst ([(InstanceModel, Int)] -> [InstanceModel])
-> [(InstanceModel, Int)] -> [InstanceModel]
forall a b. (a -> b) -> a -> b
$ Map UID (InstanceModel, Int) -> [(InstanceModel, Int)]
forall k a. Map k a -> [a]
Map.elems (Map UID (InstanceModel, Int) -> [(InstanceModel, Int)])
-> Map UID (InstanceModel, Int) -> [(InstanceModel, Int)]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (InstanceModel, Int))
     ChunkDB
     (Map UID (InstanceModel, Int))
-> Map UID (InstanceModel, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (InstanceModel, Int))
  ChunkDB
  (Map UID (InstanceModel, Int))
Lens' ChunkDB (Map UID (InstanceModel, Int))
insmodelTable
    tmods :: [TheoryModel]
tmods   = ((TheoryModel, Int) -> TheoryModel)
-> [(TheoryModel, Int)] -> [TheoryModel]
forall a b. (a -> b) -> [a] -> [b]
map (TheoryModel, Int) -> TheoryModel
forall a b. (a, b) -> a
fst ([(TheoryModel, Int)] -> [TheoryModel])
-> [(TheoryModel, Int)] -> [TheoryModel]
forall a b. (a -> b) -> a -> b
$ Map UID (TheoryModel, Int) -> [(TheoryModel, Int)]
forall k a. Map k a -> [a]
Map.elems (Map UID (TheoryModel, Int) -> [(TheoryModel, Int)])
-> Map UID (TheoryModel, Int) -> [(TheoryModel, Int)]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (TheoryModel, Int)) ChunkDB (Map UID (TheoryModel, Int))
-> Map UID (TheoryModel, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (TheoryModel, Int)) ChunkDB (Map UID (TheoryModel, Int))
Lens' ChunkDB (Map UID (TheoryModel, Int))
theoryModelTable
    concIns :: [ConceptInstance]
concIns = ((ConceptInstance, Int) -> ConceptInstance)
-> [(ConceptInstance, Int)] -> [ConceptInstance]
forall a b. (a -> b) -> [a] -> [b]
map (ConceptInstance, Int) -> ConceptInstance
forall a b. (a, b) -> a
fst ([(ConceptInstance, Int)] -> [ConceptInstance])
-> [(ConceptInstance, Int)] -> [ConceptInstance]
forall a b. (a -> b) -> a -> b
$ Map UID (ConceptInstance, Int) -> [(ConceptInstance, Int)]
forall k a. Map k a -> [a]
Map.elems (Map UID (ConceptInstance, Int) -> [(ConceptInstance, Int)])
-> Map UID (ConceptInstance, Int) -> [(ConceptInstance, Int)]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (ConceptInstance, Int))
     ChunkDB
     (Map UID (ConceptInstance, Int))
-> Map UID (ConceptInstance, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (ConceptInstance, Int))
  ChunkDB
  (Map UID (ConceptInstance, Int))
Lens' ChunkDB (Map UID (ConceptInstance, Int))
conceptinsTable
    lblCon :: [LabelledContent]
lblCon  = ((LabelledContent, Int) -> LabelledContent)
-> [(LabelledContent, Int)] -> [LabelledContent]
forall a b. (a -> b) -> [a] -> [b]
map (LabelledContent, Int) -> LabelledContent
forall a b. (a, b) -> a
fst ([(LabelledContent, Int)] -> [LabelledContent])
-> [(LabelledContent, Int)] -> [LabelledContent]
forall a b. (a -> b) -> a -> b
$ Map UID (LabelledContent, Int) -> [(LabelledContent, Int)]
forall k a. Map k a -> [a]
Map.elems (Map UID (LabelledContent, Int) -> [(LabelledContent, Int)])
-> Map UID (LabelledContent, Int) -> [(LabelledContent, Int)]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (LabelledContent, Int))
     ChunkDB
     (Map UID (LabelledContent, Int))
-> Map UID (LabelledContent, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (LabelledContent, Int))
  ChunkDB
  (Map UID (LabelledContent, Int))
Lens' ChunkDB (Map UID (LabelledContent, Int))
labelledcontentTable
    -- search the old reference table just in case the user wants to manually add in some references
    refs :: [Reference]
refs    = ((Reference, Int) -> Reference)
-> [(Reference, Int)] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map (Reference, Int) -> Reference
forall a b. (a, b) -> a
fst ([(Reference, Int)] -> [Reference])
-> [(Reference, Int)] -> [Reference]
forall a b. (a -> b) -> a -> b
$ Map UID (Reference, Int) -> [(Reference, Int)]
forall k a. Map k a -> [a]
Map.elems (Map UID (Reference, Int) -> [(Reference, Int)])
-> Map UID (Reference, Int) -> [(Reference, Int)]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (Reference, Int)) ChunkDB (Map UID (Reference, Int))
-> Map UID (Reference, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (Reference, Int)) ChunkDB (Map UID (Reference, Int))
Lens' ChunkDB (Map UID (Reference, Int))
refTable
    -- set new reference table in the chunk database
    chkdb2 :: ChunkDB
chkdb2 = ASetter
  ChunkDB
  ChunkDB
  (Map UID (Reference, Int))
  (Map UID (Reference, Int))
-> Map UID (Reference, Int) -> ChunkDB -> ChunkDB
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
  ChunkDB
  ChunkDB
  (Map UID (Reference, Int))
  (Map UID (Reference, Int))
Lens' ChunkDB (Map UID (Reference, Int))
refTable (String -> [Reference] -> Map UID (Reference, Int)
forall a. HasUID a => String -> [a] -> Map UID (a, Int)
idMap String
"RefMap" ([Reference] -> Map UID (Reference, Int))
-> [Reference] -> Map UID (Reference, Int)
forall a b. (a -> b) -> a -> b
$ [Reference] -> [Reference]
forall a. Eq a => [a] -> [a]
nub ([Reference] -> [Reference]) -> [Reference] -> [Reference]
forall a b. (a -> b) -> a -> b
$ [Reference]
refsFromSRS
      [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (TraceConfig -> Reference) -> [TraceConfig] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map (Reference -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref (Reference -> Reference)
-> (TraceConfig -> Reference) -> TraceConfig -> Reference
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UID -> Reference
makeTabRef' (UID -> Reference)
-> (TraceConfig -> UID) -> TraceConfig -> Reference
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TraceConfig -> UID
getTraceConfigUID) (System -> [TraceConfig]
traceMatStandard System
si)
      [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ [Reference]
secRefs -- secRefs can be removed once #946 is complete
      [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ String -> [Reference]
traceyGraphGetRefs (a -> String
forall c. CommonIdea c => c -> String
programName a
sys) [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (Citation -> Reference) -> BibRef -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map Citation -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref BibRef
cites
      [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (DataDefinition -> Reference) -> [DataDefinition] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map DataDefinition -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [DataDefinition]
ddefs [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (GenDefn -> Reference) -> [GenDefn] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map GenDefn -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [GenDefn]
gdefs [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (InstanceModel -> Reference) -> [InstanceModel] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map InstanceModel -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [InstanceModel]
imods
      [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (TheoryModel -> Reference) -> [TheoryModel] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map TheoryModel -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [TheoryModel]
tmods [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (ConceptInstance -> Reference) -> [ConceptInstance] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map ConceptInstance -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [ConceptInstance]
concIns [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (LabelledContent -> Reference) -> [LabelledContent] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map LabelledContent -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [LabelledContent]
lblCon
      [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ [Reference]
refs) ChunkDB
chkdb
    -- set new chunk database into system information
    si2 :: System
si2 = ASetter System System ChunkDB ChunkDB
-> ChunkDB -> System -> System
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter System System ChunkDB ChunkDB
forall c. HasSystem c => Lens' c ChunkDB
Lens' System ChunkDB
systemdb ChunkDB
chkdb2 System
si

-- | Helper that gets references from definitions and models.
dRefToRef :: HasDecRef a => a -> [Reference]
dRefToRef :: forall a. HasDecRef a => a -> [Reference]
dRefToRef a
r = (DecRef -> Reference) -> [DecRef] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map DecRef -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref ([DecRef] -> [Reference]) -> [DecRef] -> [Reference]
forall a b. (a -> b) -> a -> b
$ a
r a -> Getting [DecRef] a [DecRef] -> [DecRef]
forall s a. s -> Getting a s a -> a
^. Getting [DecRef] a [DecRef]
forall c. HasDecRef c => Lens' c [DecRef]
Lens' a [DecRef]
getDecRefs

-- | Recursively find all references in a section (meant for getting at 'LabelledContent').
findAllRefs :: Section -> [Reference]
findAllRefs :: Section -> [Reference]
findAllRefs (Section Sentence
_ [SecCons]
cs Reference
r) = Reference
rReference -> [Reference] -> [Reference]
forall a. a -> [a] -> [a]
: (SecCons -> [Reference]) -> [SecCons] -> [Reference]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SecCons -> [Reference]
findRefSecCons [SecCons]
cs
  where
    findRefSecCons :: SecCons -> [Reference]
    findRefSecCons :: SecCons -> [Reference]
findRefSecCons (Sub Section
s) = Section -> [Reference]
findAllRefs Section
s
    findRefSecCons (Con (LlC (LblC Reference
rf RawContent
_))) = [Reference
rf]
    findRefSecCons SecCons
_ = []

-- | Helper for filling in the traceability matrix and graph information into the system.
fillTraceSI :: SRSDecl -> System -> System
fillTraceSI :: SRSDecl -> System -> System
fillTraceSI SRSDecl
dd System
si = [DocSection] -> System -> System
fillTraceMaps [DocSection]
l (System -> System) -> System -> System
forall a b. (a -> b) -> a -> b
$ [DocSection] -> System -> System
fillReqs [DocSection]
l System
si
  where
    l :: [DocSection]
l = System -> SRSDecl -> [DocSection]
mkDocDesc System
si SRSDecl
dd

-- | Fills in the traceabiliy matrix and graphs section of the system information using the document description.
fillTraceMaps :: DocDesc -> System -> System
fillTraceMaps :: [DocSection] -> System -> System
fillTraceMaps [DocSection]
dd si :: System
si@SI{_systemdb :: System -> ChunkDB
_systemdb = ChunkDB
db} = System
si {_systemdb =
  set refbyTable (generateRefbyMap tdb) $ set traceTable tdb db} where
  tdb :: Map UID [UID]
tdb = [DocSection] -> Map UID [UID]
generateTraceMap [DocSection]
dd

-- | Fills in the requirements section of the system information using the document description.
fillReqs :: DocDesc -> System -> System
fillReqs :: [DocSection] -> System -> System
fillReqs [] System
si = System
si
fillReqs (ReqrmntSec (ReqsProg [ReqsSub]
x):[DocSection]
_) si :: System
si@SI{_systemdb :: System -> ChunkDB
_systemdb = ChunkDB
db} = [ReqsSub] -> System
genReqs [ReqsSub]
x
  where
    genReqs :: [ReqsSub] -> System
genReqs [] = System
si
    genReqs (FReqsSub [ConceptInstance]
c [LabelledContent]
_:[ReqsSub]
_) = System
si {_systemdb = set conceptinsTable newCI db} where
        newCI :: Map UID (ConceptInstance, Int)
newCI = String -> [ConceptInstance] -> Map UID (ConceptInstance, Int)
forall a. HasUID a => String -> [a] -> Map UID (a, Int)
idMap String
"ConcInsMap" ([ConceptInstance] -> Map UID (ConceptInstance, Int))
-> [ConceptInstance] -> Map UID (ConceptInstance, Int)
forall a b. (a -> b) -> a -> b
$ [ConceptInstance] -> [ConceptInstance]
forall a. Eq a => [a] -> [a]
nub ([ConceptInstance] -> [ConceptInstance])
-> [ConceptInstance] -> [ConceptInstance]
forall a b. (a -> b) -> a -> b
$ [ConceptInstance]
c [ConceptInstance] -> [ConceptInstance] -> [ConceptInstance]
forall a. [a] -> [a] -> [a]
++ ((ConceptInstance, Int) -> ConceptInstance)
-> [(ConceptInstance, Int)] -> [ConceptInstance]
forall a b. (a -> b) -> [a] -> [b]
map (ConceptInstance, Int) -> ConceptInstance
forall a b. (a, b) -> a
fst (((ConceptInstance, Int) -> Int)
-> [(ConceptInstance, Int)] -> [(ConceptInstance, Int)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (ConceptInstance, Int) -> Int
forall a b. (a, b) -> b
snd ([(ConceptInstance, Int)] -> [(ConceptInstance, Int)])
-> [(ConceptInstance, Int)] -> [(ConceptInstance, Int)]
forall a b. (a -> b) -> a -> b
$ ((UID, (ConceptInstance, Int)) -> (ConceptInstance, Int))
-> [(UID, (ConceptInstance, Int))] -> [(ConceptInstance, Int)]
forall a b. (a -> b) -> [a] -> [b]
map (UID, (ConceptInstance, Int)) -> (ConceptInstance, Int)
forall a b. (a, b) -> b
snd ([(UID, (ConceptInstance, Int))] -> [(ConceptInstance, Int)])
-> [(UID, (ConceptInstance, Int))] -> [(ConceptInstance, Int)]
forall a b. (a -> b) -> a -> b
$ Map UID (ConceptInstance, Int) -> [(UID, (ConceptInstance, Int))]
forall k a. Map k a -> [(k, a)]
Map.toList (Map UID (ConceptInstance, Int) -> [(UID, (ConceptInstance, Int))])
-> Map UID (ConceptInstance, Int)
-> [(UID, (ConceptInstance, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
db ChunkDB
-> Getting
     (Map UID (ConceptInstance, Int))
     ChunkDB
     (Map UID (ConceptInstance, Int))
-> Map UID (ConceptInstance, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (ConceptInstance, Int))
  ChunkDB
  (Map UID (ConceptInstance, Int))
Lens' ChunkDB (Map UID (ConceptInstance, Int))
conceptinsTable)
    genReqs (ReqsSub
_:[ReqsSub]
xs) = [ReqsSub] -> System
genReqs [ReqsSub]
xs
fillReqs (DocSection
_:[DocSection]
xs) System
si = [DocSection] -> System -> System
fillReqs [DocSection]
xs System
si

-- | Constructs the unit definitions ('UnitDefn's) found in the document description ('DocDesc') from a database ('ChunkDB').
extractUnits :: DocDesc -> ChunkDB -> [UnitDefn]
extractUnits :: [DocSection] -> ChunkDB -> [UnitDefn]
extractUnits [DocSection]
dd ChunkDB
cdb = ChunkDB -> [DefinedQuantityDict] -> [UnitDefn]
forall c. Quantity c => ChunkDB -> [c] -> [UnitDefn]
collectUnits ChunkDB
cdb ([DefinedQuantityDict] -> [UnitDefn])
-> [DefinedQuantityDict] -> [UnitDefn]
forall a b. (a -> b) -> a -> b
$ [Sentence] -> [ModelExpr] -> ChunkDB -> [DefinedQuantityDict]
ccss' ([DocSection] -> [Sentence]
getDocDesc [DocSection]
dd) ([DocSection] -> [ModelExpr]
egetDocDesc [DocSection]
dd) ChunkDB
cdb

-- * Section Creator Functions

-- | Helper for creating the different document sections.
mkSections :: System -> DocDesc -> [Section]
mkSections :: System -> [DocSection] -> [Section]
mkSections System
si [DocSection]
dd = (DocSection -> Section) -> [DocSection] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map DocSection -> Section
doit [DocSection]
dd
  where
    doit :: DocSection -> Section
    doit :: DocSection -> Section
doit DocSection
TableOfContents      = [DocSection] -> Section
mkToC [DocSection]
dd
    doit (RefSec RefSec
rs)          = System -> [DocSection] -> RefSec -> Section
mkRefSec System
si [DocSection]
dd RefSec
rs
    doit (IntroSec IntroSec
is)        = System -> IntroSec -> Section
mkIntroSec System
si IntroSec
is
    doit (StkhldrSec StkhldrSec
sts)     = StkhldrSec -> Section
mkStkhldrSec StkhldrSec
sts
    doit (SSDSec SSDSec
ss)          = System -> SSDSec -> Section
mkSSDSec System
si SSDSec
ss
    doit (AuxConstntSec AuxConstntSec
acs)  = AuxConstntSec -> Section
mkAuxConsSec AuxConstntSec
acs
    doit DocSection
Bibliography         = BibRef -> Section
mkBib (System -> BibRef
citeDB System
si)
    doit (GSDSec GSDSec
gs')         = GSDSec -> Section
mkGSDSec GSDSec
gs'
    doit (ReqrmntSec ReqrmntSec
r)       = ReqrmntSec -> Section
mkReqrmntSec ReqrmntSec
r
    doit (LCsSec LCsSec
lc)          = LCsSec -> Section
mkLCsSec LCsSec
lc
    doit (UCsSec UCsSec
ulcs)        = UCsSec -> Section
mkUCsSec UCsSec
ulcs
    doit (TraceabilitySec TraceabilitySec
t)  = TraceabilitySec -> System -> Section
mkTraceabilitySec TraceabilitySec
t System
si
    doit (AppndxSec AppndxSec
a)        = AppndxSec -> Section
mkAppndxSec AppndxSec
a
    doit (OffShelfSolnsSec OffShelfSolnsSec
o) = OffShelfSolnsSec -> Section
mkOffShelfSolnSec OffShelfSolnsSec
o

-- ** Table of Contents

-- | Helper for making the Table of Contents section.
mkToC :: DocDesc -> Section
mkToC :: [DocSection] -> Section
mkToC [DocSection]
dd = [Contents] -> [Section] -> Section
SRS.tOfCont [Contents
intro, UnlabelledContent -> Contents
UlC (UnlabelledContent -> Contents) -> UnlabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ RawContent -> UnlabelledContent
ulcc (RawContent -> UnlabelledContent)
-> RawContent -> UnlabelledContent
forall a b. (a -> b) -> a -> b
$ ListType -> RawContent
Enumeration (ListType -> RawContent) -> ListType -> RawContent
forall a b. (a -> b) -> a -> b
$ [(ItemType, Maybe String)] -> ListType
Bullet ([(ItemType, Maybe String)] -> ListType)
-> [(ItemType, Maybe String)] -> ListType
forall a b. (a -> b) -> a -> b
$ (DocSection -> (ItemType, Maybe String))
-> [DocSection] -> [(ItemType, Maybe String)]
forall a b. (a -> b) -> [a] -> [b]
map ((, Maybe String
forall a. Maybe a
Nothing) (ItemType -> (ItemType, Maybe String))
-> (DocSection -> ItemType)
-> DocSection
-> (ItemType, Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DocSection -> ItemType
toToC) [DocSection]
dd] []
  where
    intro :: Contents
intro = Sentence -> Contents
mkParagraph (Sentence -> Contents) -> Sentence -> Contents
forall a b. (a -> b) -> a -> b
$ String -> Sentence
S String
"An outline of all sections included in this SRS is recorded here for easy reference."

-- ** Reference Materials

-- | Helper for creating the reference section and subsections.
-- Includes Table of Symbols, Units and Abbreviations and Acronyms.
mkRefSec :: System -> DocDesc -> RefSec -> Section
mkRefSec :: System -> [DocSection] -> RefSec -> Section
mkRefSec System
si [DocSection]
dd (RefProg Contents
c [RefTab]
l) = [Contents] -> [Section] -> Section
SRS.refMat [Contents
c] ((RefTab -> Section) -> [RefTab] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map (System -> RefTab -> Section
mkSubRef System
si) [RefTab]
l)
  where
    mkSubRef :: System -> RefTab -> Section
    mkSubRef :: System -> RefTab -> Section
mkSubRef System
si' RefTab
TUnits = System -> RefTab -> Section
mkSubRef System
si' (RefTab -> Section) -> RefTab -> Section
forall a b. (a -> b) -> a -> b
$ [TUIntro] -> ([UnitDefn] -> LabelledContent) -> RefTab
TUnits' [TUIntro]
defaultTUI [UnitDefn] -> LabelledContent
forall s. IsUnit s => [s] -> LabelledContent
tOfUnitSIName
    mkSubRef SI {_systemdb :: System -> ChunkDB
_systemdb = ChunkDB
db} (TUnits' [TUIntro]
con [UnitDefn] -> LabelledContent
f) =
        [Contents] -> [Section] -> Section
SRS.tOfUnit [[TUIntro] -> Contents
tuIntro [TUIntro]
con, LabelledContent -> Contents
LlC (LabelledContent -> Contents) -> LabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ [UnitDefn] -> LabelledContent
f ([UnitDefn] -> [UnitDefn]
forall a. Eq a => [a] -> [a]
nub ([UnitDefn] -> [UnitDefn]) -> [UnitDefn] -> [UnitDefn]
forall a b. (a -> b) -> a -> b
$ (UnitDefn -> UnitDefn -> Ordering) -> [UnitDefn] -> [UnitDefn]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy UnitDefn -> UnitDefn -> Ordering
compUnitDefn ([UnitDefn] -> [UnitDefn]) -> [UnitDefn] -> [UnitDefn]
forall a b. (a -> b) -> a -> b
$ [DocSection] -> ChunkDB -> [UnitDefn]
extractUnits [DocSection]
dd ChunkDB
db)] []
    -- FIXME: _quants = v should be removed from this binding and symbols should
    -- be acquired solely through document traversal, however #1658. If we do
    -- just the doc traversal here, then we lose some symbols which only appear
    -- in a table in GlassBR. If we grab symbols from tables (by removing the `isVar`)
    -- in ExtractDocDesc, then the passes which extract `DefinedQuantityDict`s will
    -- error out because some of the symbols in tables are only `QuantityDict`s, and thus
    -- missing a `Concept`.
    mkSubRef SI {_quants :: ()
_quants = [e]
v, _systemdb :: System -> ChunkDB
_systemdb = ChunkDB
cdb} (TSymb [TSIntro]
con) =
      [Contents] -> [Section] -> Section
SRS.tOfSymb
      [[TSIntro] -> Contents
tsIntro [TSIntro]
con,
                LabelledContent -> Contents
LlC (LabelledContent -> Contents) -> LabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ Stage
-> [DefinedQuantityDict]
-> (DefinedQuantityDict -> Sentence)
-> LabelledContent
forall s.
(Quantity s, MayHaveUnit s) =>
Stage -> [s] -> (s -> Sentence) -> LabelledContent
table Stage
Equational ([DefinedQuantityDict] -> [DefinedQuantityDict]
forall a. HasSymbol a => [a] -> [a]
sortBySymbol
                ([DefinedQuantityDict] -> [DefinedQuantityDict])
-> [DefinedQuantityDict] -> [DefinedQuantityDict]
forall a b. (a -> b) -> a -> b
$ (DefinedQuantityDict -> Bool)
-> [DefinedQuantityDict] -> [DefinedQuantityDict]
forall a. (a -> Bool) -> [a] -> [a]
filter (DefinedQuantityDict -> Stage -> Bool
forall q. HasSymbol q => q -> Stage -> Bool
`hasStageSymbol` Stage
Equational)
                ([DefinedQuantityDict] -> [DefinedQuantityDict]
forall a. Eq a => [a] -> [a]
nub ([DefinedQuantityDict] -> [DefinedQuantityDict])
-> [DefinedQuantityDict] -> [DefinedQuantityDict]
forall a b. (a -> b) -> a -> b
$ (e -> DefinedQuantityDict) -> [e] -> [DefinedQuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map e -> DefinedQuantityDict
forall c.
(Quantity c, Concept c, MayHaveUnit c) =>
c -> DefinedQuantityDict
dqdWr [e]
v [DefinedQuantityDict]
-> [DefinedQuantityDict] -> [DefinedQuantityDict]
forall a. [a] -> [a] -> [a]
++ [Sentence] -> [ModelExpr] -> ChunkDB -> [DefinedQuantityDict]
ccss' ([DocSection] -> [Sentence]
getDocDesc [DocSection]
dd) ([DocSection] -> [ModelExpr]
egetDocDesc [DocSection]
dd) ChunkDB
cdb))
                DefinedQuantityDict -> Sentence
forall n. NamedIdea n => n -> Sentence
atStart] []
    mkSubRef SI {_systemdb :: System -> ChunkDB
_systemdb = ChunkDB
cdb} (TSymb' LFunc
f [TSIntro]
con) =
      [DefinedQuantityDict] -> LFunc -> [TSIntro] -> Section
forall e.
(Quantity e, Concept e, Eq e, MayHaveUnit e) =>
[e] -> LFunc -> [TSIntro] -> Section
mkTSymb ([Sentence] -> [ModelExpr] -> ChunkDB -> [DefinedQuantityDict]
ccss ([DocSection] -> [Sentence]
getDocDesc [DocSection]
dd) ([DocSection] -> [ModelExpr]
egetDocDesc [DocSection]
dd) ChunkDB
cdb) LFunc
f [TSIntro]
con

    mkSubRef System
_ (TAandA [IdeaDict]
ideas) =
      [Contents] -> [Section] -> Section
SRS.tOfAbbAcc
        [LabelledContent -> Contents
LlC (LabelledContent -> Contents) -> LabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ [IdeaDict] -> LabelledContent
forall s. Idea s => [s] -> LabelledContent
tableAbbAccGen ([IdeaDict] -> LabelledContent) -> [IdeaDict] -> LabelledContent
forall a b. (a -> b) -> a -> b
$ [IdeaDict] -> [IdeaDict]
forall a. Eq a => [a] -> [a]
nub [IdeaDict]
ideas]
        []



-- | Helper for creating the table of symbols.
mkTSymb :: (Quantity e, Concept e, Eq e, MayHaveUnit e) =>
  [e] -> LFunc -> [TSIntro] -> Section
mkTSymb :: forall e.
(Quantity e, Concept e, Eq e, MayHaveUnit e) =>
[e] -> LFunc -> [TSIntro] -> Section
mkTSymb [e]
v LFunc
f [TSIntro]
c = [Contents] -> [Section] -> Section
SRS.tOfSymb [[TSIntro] -> Contents
tsIntro [TSIntro]
c,
  LabelledContent -> Contents
LlC (LabelledContent -> Contents) -> LabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ Stage -> [e] -> (e -> Sentence) -> LabelledContent
forall s.
(Quantity s, MayHaveUnit s) =>
Stage -> [s] -> (s -> Sentence) -> LabelledContent
table Stage
Equational
    ((e -> e -> Ordering) -> [e] -> [e]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (Symbol -> Symbol -> Ordering
compsy (Symbol -> Symbol -> Ordering)
-> (e -> Symbol) -> e -> e -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` e -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb) ([e] -> [e]) -> [e] -> [e]
forall a b. (a -> b) -> a -> b
$ (e -> Bool) -> [e] -> [e]
forall a. (a -> Bool) -> [a] -> [a]
filter (e -> Stage -> Bool
forall q. HasSymbol q => q -> Stage -> Bool
`hasStageSymbol` Stage
Equational) ([e] -> [e]
forall a. Eq a => [a] -> [a]
nub [e]
v))
    (LFunc -> e -> Sentence
forall {n}. (NamedIdea n, Definition n) => LFunc -> n -> Sentence
lf LFunc
f)]
    []
  where lf :: LFunc -> n -> Sentence
lf LFunc
Term = n -> Sentence
forall n. NamedIdea n => n -> Sentence
atStart
        lf LFunc
Defn = Sentence -> Sentence
capSent (Sentence -> Sentence) -> (n -> Sentence) -> n -> Sentence
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (n -> Getting Sentence n Sentence -> Sentence
forall s a. s -> Getting a s a -> a
^. Getting Sentence n Sentence
forall c. Definition c => Lens' c Sentence
Lens' n Sentence
defn)
        lf (TermExcept [DefinedQuantityDict]
cs) = \n
x -> if (n
x n -> Getting UID n UID -> UID
forall s a. s -> Getting a s a -> a
^. Getting UID n UID
forall c. HasUID c => Getter c UID
Getter n UID
uid) UID -> [UID] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (DefinedQuantityDict -> UID) -> [DefinedQuantityDict] -> [UID]
forall a b. (a -> b) -> [a] -> [b]
map (DefinedQuantityDict -> Getting UID DefinedQuantityDict UID -> UID
forall s a. s -> Getting a s a -> a
^. Getting UID DefinedQuantityDict UID
forall c. HasUID c => Getter c UID
Getter DefinedQuantityDict UID
uid) [DefinedQuantityDict]
cs then
          Sentence -> Sentence
capSent (n
x n -> Getting Sentence n Sentence -> Sentence
forall s a. s -> Getting a s a -> a
^. Getting Sentence n Sentence
forall c. Definition c => Lens' c Sentence
Lens' n Sentence
defn) else n -> Sentence
forall n. NamedIdea n => n -> Sentence
atStart n
x --Compare chunk uids, since we don't
          --actually care about the chunks themselves in LFunc.
        lf (DefnExcept [DefinedQuantityDict]
cs) = \n
x -> if (n
x n -> Getting UID n UID -> UID
forall s a. s -> Getting a s a -> a
^. Getting UID n UID
forall c. HasUID c => Getter c UID
Getter n UID
uid) UID -> [UID] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (DefinedQuantityDict -> UID) -> [DefinedQuantityDict] -> [UID]
forall a b. (a -> b) -> [a] -> [b]
map (DefinedQuantityDict -> Getting UID DefinedQuantityDict UID -> UID
forall s a. s -> Getting a s a -> a
^.Getting UID DefinedQuantityDict UID
forall c. HasUID c => Getter c UID
Getter DefinedQuantityDict UID
uid) [DefinedQuantityDict]
cs then
          n -> Sentence
forall n. NamedIdea n => n -> Sentence
atStart n
x else Sentence -> Sentence
capSent (n
x n -> Getting Sentence n Sentence -> Sentence
forall s a. s -> Getting a s a -> a
^. Getting Sentence n Sentence
forall c. Definition c => Lens' c Sentence
Lens' n Sentence
defn)
        lf LFunc
TAD = \n
tDef -> n -> Sentence
forall n. NamedIdea n => n -> Sentence
titleize n
tDef Sentence -> Sentence -> Sentence
+: Sentence
EmptyS Sentence -> Sentence -> Sentence
+:+. Sentence -> Sentence
capSent (n
tDef n -> Getting Sentence n Sentence -> Sentence
forall s a. s -> Getting a s a -> a
^. Getting Sentence n Sentence
forall c. Definition c => Lens' c Sentence
Lens' n Sentence
defn)

-- ** Introduction

-- | Makes the Introduction section into a 'Section'.
mkIntroSec :: System -> IntroSec -> Section
mkIntroSec :: System -> IntroSec -> Section
mkIntroSec System
si (IntroProg Sentence
probIntro Sentence
progDefn [IntroSub]
l) =
  Sentence -> Sentence -> [Section] -> Section
Intro.introductionSection Sentence
probIntro Sentence
progDefn ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$ (IntroSub -> Section) -> [IntroSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map (System -> IntroSub -> Section
mkSubIntro System
si) [IntroSub]
l
  where
    mkSubIntro :: System -> IntroSub -> Section
    mkSubIntro :: System -> IntroSub -> Section
mkSubIntro System
_ (IPurpose [Sentence]
intro) = [Sentence] -> Section
Intro.purposeOfDoc [Sentence]
intro
    mkSubIntro System
_ (IScope Sentence
main) = Sentence -> Section
Intro.scopeOfRequirements Sentence
main
    mkSubIntro SI {_sys :: ()
_sys = a
sys} (IChar [Sentence]
assumed [Sentence]
topic [Sentence]
asset) =
      a -> [Sentence] -> [Sentence] -> [Sentence] -> Section -> Section
forall a.
Idea a =>
a -> [Sentence] -> [Sentence] -> [Sentence] -> Section -> Section
Intro.charIntRdrF a
sys [Sentence]
assumed [Sentence]
topic [Sentence]
asset ([Contents] -> [Section] -> Section
SRS.userChar [] [])
    mkSubIntro System
_ (IOrgSec CI
b Section
s Sentence
t) = CI -> Section -> Sentence -> Section
forall c. NamedIdea c => c -> Section -> Sentence -> Section
Intro.orgSec CI
b Section
s Sentence
t
    -- FIXME: s should be "looked up" using "b" once we have all sections being generated

-- ** Stakeholders

-- | Helper for making the Stakeholders section.
mkStkhldrSec :: StkhldrSec -> Section
mkStkhldrSec :: StkhldrSec -> Section
mkStkhldrSec (StkhldrProg [StkhldrSub]
l) = [Contents] -> [Section] -> Section
SRS.stakeholder [Contents
Stk.stakeholderIntro] ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$ (StkhldrSub -> Section) -> [StkhldrSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map StkhldrSub -> Section
mkSubs [StkhldrSub]
l
  where
    mkSubs :: StkhldrSub -> Section
    mkSubs :: StkhldrSub -> Section
mkSubs (Client CI
kWrd Sentence
details) = CI -> Sentence -> Section
forall a. Idea a => a -> Sentence -> Section
Stk.tClientF CI
kWrd Sentence
details
    mkSubs (Cstmr CI
kWrd)          = CI -> Section
forall a. Idea a => a -> Section
Stk.tCustomerF CI
kWrd

-- ** General System Description

-- | Helper for making the General System Description section.
mkGSDSec :: GSDSec -> Section
mkGSDSec :: GSDSec -> Section
mkGSDSec (GSDProg [GSDSub]
l) = [Contents] -> [Section] -> Section
SRS.genSysDes [Contents
GSD.genSysIntro] ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$ (GSDSub -> Section) -> [GSDSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map GSDSub -> Section
mkSubs [GSDSub]
l
   where
     mkSubs :: GSDSub -> Section
     mkSubs :: GSDSub -> Section
mkSubs (SysCntxt [Contents]
cs)            = [Contents] -> Section
GSD.sysContxt [Contents]
cs
     mkSubs (UsrChars [Contents]
intro)         = [Contents] -> Section
GSD.usrCharsF [Contents]
intro
     mkSubs (SystCons [Contents]
cntnts [Section]
subsec) = [Contents] -> [Section] -> Section
GSD.systCon [Contents]
cntnts [Section]
subsec

-- ** Specific System Description

-- | Helper for making the Specific System Description section.
mkSSDSec :: System -> SSDSec -> Section
mkSSDSec :: System -> SSDSec -> Section
mkSSDSec System
si (SSDProg [SSDSub]
l) =
  [Section] -> Section
SSD.specSysDescr ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$ (SSDSub -> Section) -> [SSDSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map (System -> SSDSub -> Section
mkSubSSD System
si) [SSDSub]
l
  where
    mkSubSSD :: System -> SSDSub -> Section
    mkSubSSD :: System -> SSDSub -> Section
mkSubSSD System
sysi (SSDProblem ProblemDescription
pd)    = System -> ProblemDescription -> Section
mkSSDProb System
sysi ProblemDescription
pd
    mkSubSSD System
sysi (SSDSolChSpec SolChSpec
scs) = System -> SolChSpec -> Section
mkSolChSpec System
sysi SolChSpec
scs

-- | Helper for making the Specific System Description Problem section.
mkSSDProb :: System -> ProblemDescription -> Section
mkSSDProb :: System -> ProblemDescription -> Section
mkSSDProb System
_ (PDProg Sentence
prob [Section]
subSec [PDSub]
subPD) = Sentence -> [Section] -> Section
SSD.probDescF Sentence
prob ([Section]
subSec [Section] -> [Section] -> [Section]
forall a. [a] -> [a] -> [a]
++ (PDSub -> Section) -> [PDSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map PDSub -> Section
mkSubPD [PDSub]
subPD)
  where mkSubPD :: PDSub -> Section
mkSubPD (TermsAndDefs Maybe Sentence
sen [c]
concepts) = Maybe Sentence -> [c] -> Section
forall c. Concept c => Maybe Sentence -> [c] -> Section
SSD.termDefnF Maybe Sentence
sen [c]
concepts
        mkSubPD (PhySysDesc a
prog [Sentence]
parts LabelledContent
dif [Contents]
extra) = a -> [Sentence] -> LabelledContent -> [Contents] -> Section
forall a.
Idea a =>
a -> [Sentence] -> LabelledContent -> [Contents] -> Section
SSD.physSystDesc a
prog [Sentence]
parts LabelledContent
dif [Contents]
extra
        mkSubPD (Goals [Sentence]
ins [ConceptInstance]
g) = [Sentence] -> [Contents] -> Int -> Section
SSD.goalStmtF [Sentence]
ins ([ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
g) ([ConceptInstance] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [ConceptInstance]
g)


-- | Helper for making the Solution Characteristics Specification section.
mkSolChSpec :: System -> SolChSpec -> Section
mkSolChSpec :: System -> SolChSpec -> Section
mkSolChSpec System
si (SCSProg [SCSSub]
l) =
  [Contents] -> [Section] -> Section
SRS.solCharSpec [IdeaDict -> Section -> Contents
forall a. Idea a => a -> Section -> Contents
SSD.solutionCharSpecIntro (System -> IdeaDict
siSys System
si) Section
SSD.imStub] ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$
    (SCSSub -> Section) -> [SCSSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map (System -> SCSSub -> Section
mkSubSCS System
si) [SCSSub]
l
  where
    mkSubSCS :: System -> SCSSub -> Section
    mkSubSCS :: System -> SCSSub -> Section
mkSubSCS System
si' (TMs [Sentence]
intro Fields
fields [TheoryModel]
ts) =
      IdeaDict -> [Contents] -> Section
forall a. Idea a => a -> [Contents] -> Section
SSD.thModF (System -> IdeaDict
siSys System
si') ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (TheoryModel -> Contents) -> [TheoryModel] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map (LabelledContent -> Contents
LlC (LabelledContent -> Contents)
-> (TheoryModel -> LabelledContent) -> TheoryModel -> Contents
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fields -> System -> TheoryModel -> LabelledContent
tmodel Fields
fields System
si') [TheoryModel]
ts
    mkSubSCS System
si' (DDs [Sentence]
intro Fields
fields [DataDefinition]
dds DerivationDisplay
ShowDerivation) = --FIXME: need to keep track of DD intro.
      Sentence -> [Contents] -> Section
SSD.dataDefnF Sentence
EmptyS ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (DataDefinition -> [Contents]) -> [DataDefinition] -> [Contents]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap DataDefinition -> [Contents]
f [DataDefinition]
dds
      where f :: DataDefinition -> [Contents]
f DataDefinition
e = LabelledContent -> Contents
LlC (Fields -> System -> DataDefinition -> LabelledContent
ddefn Fields
fields System
si' DataDefinition
e) Contents -> [Contents] -> [Contents]
forall a. a -> [a] -> [a]
: Maybe Contents -> [Contents]
forall a. Maybe a -> [a]
maybeToList (DataDefinition -> Maybe Contents
forall c.
(MayHaveDerivation c, HasShortName c, Referable c) =>
c -> Maybe Contents
derivation DataDefinition
e)
    mkSubSCS System
si' (DDs [Sentence]
intro Fields
fields [DataDefinition]
dds DerivationDisplay
_) =
      Sentence -> [Contents] -> Section
SSD.dataDefnF Sentence
EmptyS ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (DataDefinition -> Contents) -> [DataDefinition] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map DataDefinition -> Contents
f [DataDefinition]
dds
      where f :: DataDefinition -> Contents
f DataDefinition
e = LabelledContent -> Contents
LlC (LabelledContent -> Contents) -> LabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ Fields -> System -> DataDefinition -> LabelledContent
ddefn Fields
fields System
si' DataDefinition
e
    mkSubSCS System
si' (GDs [Sentence]
intro Fields
fields [GenDefn]
gs' DerivationDisplay
ShowDerivation) =
      [Contents] -> Section
SSD.genDefnF ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (GenDefn -> [Contents]) -> [GenDefn] -> [Contents]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\GenDefn
x -> LabelledContent -> Contents
LlC (Fields -> System -> GenDefn -> LabelledContent
gdefn Fields
fields System
si' GenDefn
x) Contents -> [Contents] -> [Contents]
forall a. a -> [a] -> [a]
: Maybe Contents -> [Contents]
forall a. Maybe a -> [a]
maybeToList (GenDefn -> Maybe Contents
forall c.
(MayHaveDerivation c, HasShortName c, Referable c) =>
c -> Maybe Contents
derivation GenDefn
x)) [GenDefn]
gs'
    mkSubSCS System
si' (GDs [Sentence]
intro Fields
fields [GenDefn]
gs' DerivationDisplay
_) =
      [Contents] -> Section
SSD.genDefnF ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (GenDefn -> Contents) -> [GenDefn] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map (LabelledContent -> Contents
LlC (LabelledContent -> Contents)
-> (GenDefn -> LabelledContent) -> GenDefn -> Contents
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fields -> System -> GenDefn -> LabelledContent
gdefn Fields
fields System
si') [GenDefn]
gs'
    mkSubSCS System
si' (IMs [Sentence]
intro Fields
fields [InstanceModel]
ims DerivationDisplay
ShowDerivation) =
      Section -> Section -> Section -> Section -> [Contents] -> Section
SSD.inModelF Section
SSD.pdStub Section
SSD.ddStub Section
SSD.tmStub Section
SSD.gdStub ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++
      (InstanceModel -> [Contents]) -> [InstanceModel] -> [Contents]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\InstanceModel
x -> LabelledContent -> Contents
LlC (Fields -> System -> InstanceModel -> LabelledContent
instanceModel Fields
fields System
si' InstanceModel
x) Contents -> [Contents] -> [Contents]
forall a. a -> [a] -> [a]
: Maybe Contents -> [Contents]
forall a. Maybe a -> [a]
maybeToList (InstanceModel -> Maybe Contents
forall c.
(MayHaveDerivation c, HasShortName c, Referable c) =>
c -> Maybe Contents
derivation InstanceModel
x)) [InstanceModel]
ims
    mkSubSCS System
si' (IMs [Sentence]
intro Fields
fields [InstanceModel]
ims DerivationDisplay
_) =
      Section -> Section -> Section -> Section -> [Contents] -> Section
SSD.inModelF Section
SSD.pdStub Section
SSD.ddStub Section
SSD.tmStub Section
SSD.gdStub ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++
      (InstanceModel -> Contents) -> [InstanceModel] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map (LabelledContent -> Contents
LlC (LabelledContent -> Contents)
-> (InstanceModel -> LabelledContent) -> InstanceModel -> Contents
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fields -> System -> InstanceModel -> LabelledContent
instanceModel Fields
fields System
si') [InstanceModel]
ims
    mkSubSCS System
si' (Assumptions [ConceptInstance]
ci) =
      [Contents] -> Section
SSD.assumpF ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ [ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD ([ConceptInstance] -> [Contents])
-> [ConceptInstance] -> [Contents]
forall a b. (a -> b) -> a -> b
$ (ConceptInstance -> ConceptInstance)
-> [ConceptInstance] -> [ConceptInstance]
forall a b. (a -> b) -> [a] -> [b]
map (ConceptInstance -> System -> ConceptInstance
`SSD.helperCI` System
si') [ConceptInstance]
ci
    mkSubSCS System
_ (Constraints Sentence
end [c]
cs)  = Sentence -> [c] -> Section
forall c.
(HasUncertainty c, Quantity c, Constrained c, HasReasVal c,
 MayHaveUnit c) =>
Sentence -> [c] -> Section
SSD.datConF Sentence
end [c]
cs
    mkSubSCS System
_ (CorrSolnPpties [c]
c [Contents]
cs) = [c] -> [Contents] -> Section
forall c.
(Quantity c, Constrained c) =>
[c] -> [Contents] -> Section
SSD.propCorSolF [c]
c [Contents]
cs
    siSys :: System -> IdeaDict
    siSys :: System -> IdeaDict
siSys SI {_sys :: ()
_sys = a
sys} = a -> IdeaDict
forall c. Idea c => c -> IdeaDict
nw a
sys

-- ** Requirements

-- | Helper for making the Requirements section.
mkReqrmntSec :: ReqrmntSec -> Section
mkReqrmntSec :: ReqrmntSec -> Section
mkReqrmntSec (ReqsProg [ReqsSub]
l) = [Section] -> Section
R.reqF ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$ (ReqsSub -> Section) -> [ReqsSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map ReqsSub -> Section
mkSubs [ReqsSub]
l
  where
    mkSubs :: ReqsSub -> Section
    mkSubs :: ReqsSub -> Section
mkSubs (FReqsSub  [ConceptInstance]
frs [LabelledContent]
tbs) = [Contents] -> Section
R.fReqF ([ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
frs [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (LabelledContent -> Contents) -> [LabelledContent] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map LabelledContent -> Contents
LlC [LabelledContent]
tbs)
    mkSubs (FReqsSub' [ConceptInstance]
frs [LabelledContent]
tbs) = [Contents] -> Section
R.fReqF ([ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
frs [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (LabelledContent -> Contents) -> [LabelledContent] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map LabelledContent -> Contents
LlC [LabelledContent]
tbs)
    mkSubs (NonFReqsSub [ConceptInstance]
nfrs) = [Contents] -> Section
R.nfReqF ([ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
nfrs)

-- ** Likely Changes

-- | Helper for making the Likely Changes section.
mkLCsSec :: LCsSec -> Section
mkLCsSec :: LCsSec -> Section
mkLCsSec (LCsProg [ConceptInstance]
c) = [Contents] -> [Section] -> Section
SRS.likeChg (CI -> [ConceptInstance] -> Contents
forall n. NamedIdea n => n -> [ConceptInstance] -> Contents
introChgs CI
Doc.likelyChg [ConceptInstance]
cContents -> [Contents] -> [Contents]
forall a. a -> [a] -> [a]
: [ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
c) []

-- ** Unlikely Changes

-- | Helper for making the Unikely Changes section.
mkUCsSec :: UCsSec -> Section
mkUCsSec :: UCsSec -> Section
mkUCsSec (UCsProg [ConceptInstance]
c) = [Contents] -> [Section] -> Section
SRS.unlikeChg (CI -> [ConceptInstance] -> Contents
forall n. NamedIdea n => n -> [ConceptInstance] -> Contents
introChgs CI
Doc.unlikelyChg  [ConceptInstance]
c Contents -> [Contents] -> [Contents]
forall a. a -> [a] -> [a]
: [ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
c) []

-- | Intro paragraph for likely and unlikely changes
introChgs :: NamedIdea n => n -> [ConceptInstance] -> Contents
introChgs :: forall n. NamedIdea n => n -> [ConceptInstance] -> Contents
introChgs n
xs [] = Sentence -> Contents
mkParagraph (Sentence -> Contents) -> Sentence -> Contents
forall a b. (a -> b) -> a -> b
$ [n] -> Sentence
forall n. NamedIdea n => [n] -> Sentence
emptySectSentPlu [n
xs]
introChgs n
xs [ConceptInstance]
_ = [Sentence] -> Contents
foldlSP [String -> Sentence
S String
"This", IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
Doc.section_, String -> Sentence
S String
"lists the",
  n -> Sentence
forall n. NamedIdea n => n -> Sentence
plural n
xs, String -> Sentence
S String
"to be made to the", IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
Doc.software]

-- ** Traceability

-- | Helper for making the Traceability Matrices and Graphs section.
mkTraceabilitySec :: TraceabilitySec -> System -> Section
mkTraceabilitySec :: TraceabilitySec -> System -> Section
mkTraceabilitySec (TraceabilityProg [TraceConfig]
progs) si :: System
si@SI{_sys :: ()
_sys = a
sys} = [LabelledContent]
-> [Sentence] -> [Contents] -> String -> [Section] -> Section
TG.traceMGF [LabelledContent]
trace
  ((TraceConfig -> Sentence) -> [TraceConfig] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map (\(TraceConfig UID
_ [Sentence]
pre Sentence
_ [TraceViewCat]
_ [TraceViewCat]
_) -> SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List [Sentence]
pre) [TraceConfig]
fProgs)
  ((LabelledContent -> Contents) -> [LabelledContent] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map LabelledContent -> Contents
LlC [LabelledContent]
trace) (a -> String
forall c. CommonIdea c => c -> String
programName a
sys) []
  where
    trace :: [LabelledContent]
trace = (TraceConfig -> LabelledContent)
-> [TraceConfig] -> [LabelledContent]
forall a b. (a -> b) -> [a] -> [b]
map (\(TraceConfig UID
u [Sentence]
_ Sentence
desc [TraceViewCat]
cols [TraceViewCat]
rows) ->
      UID
-> Sentence
-> [TraceViewCat]
-> [TraceViewCat]
-> System
-> LabelledContent
TM.generateTraceTableView UID
u Sentence
desc [TraceViewCat]
cols [TraceViewCat]
rows System
si) [TraceConfig]
fProgs
    fProgs :: [TraceConfig]
fProgs = (TraceConfig -> Bool) -> [TraceConfig] -> [TraceConfig]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(TraceConfig UID
_ [Sentence]
_ Sentence
_ [TraceViewCat]
cols [TraceViewCat]
rows) ->
      Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ [Sentence] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (([UID] -> [UID]) -> System -> [Sentence]
header ([TraceViewCat] -> ChunkDB -> [UID] -> [UID]
TM.layoutUIDs [TraceViewCat]
rows ChunkDB
sidb) System
si)
         Bool -> Bool -> Bool
|| [Sentence] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (([UID] -> [UID]) -> System -> [Sentence]
header ([TraceViewCat] -> ChunkDB -> [UID] -> [UID]
TM.layoutUIDs [TraceViewCat]
cols ChunkDB
sidb) System
si)) [TraceConfig]
progs
    sidb :: ChunkDB
sidb = System
si System -> Getting ChunkDB System ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB System ChunkDB
forall c. HasSystem c => Lens' c ChunkDB
Lens' System ChunkDB
systemdb

-- | Helper to get headers of rows and columns
header :: ([UID] -> [UID]) -> System -> [Sentence]
header :: ([UID] -> [UID]) -> System -> [Sentence]
header [UID] -> [UID]
f = (ChunkDB -> [UID]) -> System -> [Sentence]
TM.traceMHeader ([UID] -> [UID]
f ([UID] -> [UID]) -> (ChunkDB -> [UID]) -> ChunkDB -> [UID]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map UID [UID] -> [UID]
forall k a. Map k a -> [k]
Map.keys (Map UID [UID] -> [UID])
-> (ChunkDB -> Map UID [UID]) -> ChunkDB -> [UID]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ChunkDB
-> Getting (Map UID [UID]) ChunkDB (Map UID [UID]) -> Map UID [UID]
forall s a. s -> Getting a s a -> a
^. Getting (Map UID [UID]) ChunkDB (Map UID [UID])
Lens' ChunkDB (Map UID [UID])
refbyTable))

-- ** Off the Shelf Solutions

-- | Helper for making the Off-the-Shelf Solutions section.
mkOffShelfSolnSec :: OffShelfSolnsSec -> Section
mkOffShelfSolnSec :: OffShelfSolnsSec -> Section
mkOffShelfSolnSec (OffShelfSolnsProg [Contents]
cs) = [Contents] -> [Section] -> Section
SRS.offShelfSol [Contents]
cs []

-- ** Auxiliary Constants

-- | Helper for making the Values of Auxiliary Constants section.
mkAuxConsSec :: AuxConstntSec -> Section
mkAuxConsSec :: AuxConstntSec -> Section
mkAuxConsSec (AuxConsProg CI
key [ConstQDef]
listOfCons) = CI -> [ConstQDef] -> Section
forall a. Idea a => a -> [ConstQDef] -> Section
AC.valsOfAuxConstantsF CI
key ([ConstQDef] -> Section) -> [ConstQDef] -> Section
forall a b. (a -> b) -> a -> b
$ [ConstQDef] -> [ConstQDef]
forall a. HasSymbol a => [a] -> [a]
sortBySymbol [ConstQDef]
listOfCons

-- ** References

-- | Helper for making the References section.
mkBib :: BibRef -> Section
mkBib :: BibRef -> Section
mkBib BibRef
bib = [Contents] -> [Section] -> Section
SRS.reference [UnlabelledContent -> Contents
UlC (UnlabelledContent -> Contents) -> UnlabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ RawContent -> UnlabelledContent
ulcc (BibRef -> RawContent
Bib BibRef
bib)] []

-- ** Appendix

-- | Helper for making the Appendix section.
mkAppndxSec :: AppndxSec -> Section
mkAppndxSec :: AppndxSec -> Section
mkAppndxSec (AppndxProg [Contents]
cs) = [Contents] -> [Section] -> Section
SRS.appendix [Contents]
cs []