Updated NFR for maintainability to refer to code, not SRS: #3288

code/drasil-docLang/lib/Drasil/DocLang.hs

@@ -55,7 +55,8 @@ module Drasil.DocLang (
   unitTableRef, tunit, tunit', tunitNone,
   -- ** Requirements
   -- Drasil.Sections.Requirements
-  inReq, inTable, mkInputPropsTable, mkQRTuple, mkQRTupleRef, mkValsSourceTable, reqInputsRef,
+  inReq, inTable, mkInputPropsTable, mkQRTuple, mkQRTupleRef, 
+  mkValsSourceTable, reqInputsRef, mkMaintainableNFR,
   -- ** Specific System Description
   -- Drasil.Sections.SpecificSystemDescription
   auxSpecSent, termDefnF', inDataConstTbl, outDataConstTbl,
@@ -91,7 +92,7 @@ import Drasil.Sections.AuxiliaryConstants (tableOfConstants)
 import Drasil.Sections.Introduction (purpDoc)
 import Drasil.Sections.ReferenceMaterial (intro, emptySectSentPlu, emptySectSentSing)
 import Drasil.Sections.Requirements (inReq, inTable, mkInputPropsTable,
-  mkQRTuple, mkQRTupleRef, mkValsSourceTable, reqInputsRef)
+  mkQRTuple, mkQRTupleRef, mkValsSourceTable, reqInputsRef, mkMaintainableNFR)
 import Drasil.Sections.SpecificSystemDescription (auxSpecSent, termDefnF', inDataConstTbl, outDataConstTbl)
 --import Drasil.Sections.Stakeholders
 --import Drasil.Sections.TableOfAbbAndAcronyms

code/drasil-docLang/lib/Drasil/Sections/Requirements.hs

@@ -8,7 +8,7 @@ module Drasil.Sections.Requirements (
   fullReqs, fullTables, inReq, inTable,
   mkInputPropsTable, mkQRTuple, mkQRTupleRef, mkValsSourceTable,
   -- * Non-functional Requirements
-  nfReqF
+  nfReqF, mkMaintainableNFR
   ) where
 
 import Language.Drasil
@@ -17,7 +17,7 @@ import qualified Language.Drasil.Sentence.Combinators as S
 import Drasil.Sections.ReferenceMaterial(emptySectSentPlu)
 import Theory.Drasil (HasOutput(output))
 
-import Data.Drasil.Concepts.Documentation (description, funcReqDom,
+import Data.Drasil.Concepts.Documentation (description, funcReqDom, nonFuncReqDom,
   functionalRequirement, input_, nonfunctionalRequirement, {-output_,-} section_,
   software, symbol_, value, reqInput)
 import Data.Drasil.Concepts.Math (unit_)
@@ -100,6 +100,17 @@ nfReqIntro :: [Contents] -> Contents
 nfReqIntro [] = mkParagraph $ emptySectSentPlu [nonfunctionalRequirement]
 nfReqIntro _  = mkParagraph $ reqIntroStart +:+. nfrReqIntroBody
 
+-- | Common Non-Functional Requirement for Maintainability.
+-- Takes in a Reference Address ('String'), a percent value ('Integer'), 
+-- and a label ('String').
+mkMaintainableNFR :: String -> Integer -> String -> ConceptInstance
+mkMaintainableNFR refAddress percent lbl = cic refAddress (foldlSent [
+  S "If a likely change is made" `S.toThe` 
+  S "finished software, it will take at most", addPercent percent `S.ofThe`
+  S "original development time,",
+  S "assuming the same development resources are available"
+  ]) lbl nonFuncReqDom
+
 -- | Creates an Input Data Table for use in the Functional Requirments section. Takes a list of wrapped variables and something that is 'Referable'.
 mkInputPropsTable :: (Quantity i, MayHaveUnit i, HasShortName r, Referable r) => 
                           [i] -> r -> LabelledContent

code/drasil-example/gamephysics/lib/Drasil/GamePhysics/Requirements.hs

@@ -6,6 +6,7 @@ import Language.Drasil.Chunk.Concept.NamedCombinators
 import qualified Language.Drasil.Sentence.Combinators as S
 
 import qualified Drasil.DocLang.SRS as SRS (solCharSpec)
+import Drasil.DocLang (mkMaintainableNFR)
 import Data.Drasil.Concepts.Documentation as Doc (body, funcReqDom, input_, 
   nonFuncReqDom, output_, physicalConstraint, physicalSim, property, solutionCharSpec)
 
@@ -131,8 +132,4 @@ understandability = cic "understandability" (foldlSent [
   ]) "Understandability" nonFuncReqDom
 
 maintainability :: ConceptInstance
-maintainability = cic "maintainability" (foldlSent [
-  S "development time for any" `S.the_ofTheC` S "likely changes should not exceed", 
-  addPercent (10 :: Integer), S "percent of the original development time"
-  ]) "Maintainability" nonFuncReqDom
-
+maintainability = mkMaintainableNFR "maintainability" 10 "Maintainability"

code/drasil-example/glassbr/lib/Drasil/GlassBR/Requirements.hs

@@ -3,24 +3,21 @@ module Drasil.GlassBR.Requirements (funcReqs, funcReqsTables, inReqDesc, nonfunc
 import Control.Lens ((^.))
 
 import Language.Drasil
-import Drasil.DocLang (inReq, mkQRTuple, mkQRTupleRef, mkValsSourceTable)
+import Drasil.DocLang (inReq, mkQRTuple, mkQRTupleRef, mkValsSourceTable, mkMaintainableNFR)
 import Drasil.DocLang.SRS (datCon, propCorSol)
 import Language.Drasil.Chunk.Concept.NamedCombinators
 import qualified Language.Drasil.NounPhrase.Combinators as NP
 import qualified Language.Drasil.Sentence.Combinators as S
 import Theory.Drasil (DataDefinition)
 
 import Data.Drasil.Concepts.Computation (inValue)
-import Data.Drasil.Concepts.Documentation (assumption, characteristic, code,
-  condition, datumConstraint, environment, funcReqDom, likelyChg, message, mg,
-  mis, module_, nonFuncReqDom, output_, property, requirement, srs, system,
-  traceyMatrix, type_, unlikelyChg, value, vavPlan)
+import Data.Drasil.Concepts.Documentation (characteristic, code,
+  condition, datumConstraint, environment, funcReqDom, message, mg,
+  mis, nonFuncReqDom, output_, property, system, type_, value, vavPlan)
 import Data.Drasil.Concepts.Math (calculation)
 import Data.Drasil.Concepts.PhysicalProperties (dimension)
 import Data.Drasil.Concepts.Software (errMsg)
 
-import Data.Drasil.TheoryConcepts (dataDefn, genDefn, inModel, thModel)
-
 import Drasil.GlassBR.Assumptions (assumpSV, assumpGL, assumptionConstants)
 import Drasil.GlassBR.Concepts (glass)
 import Drasil.GlassBR.DataDefs (aspRat, glaTyFac, hFromt, loadDF, standOffDis)
@@ -116,11 +113,7 @@ reusable = cic "reusable" (foldlSent [
   atStartNP (the code), S "is modularized"]) "Reusable" nonFuncReqDom
 
 maintainable :: ConceptInstance
-maintainable = cic "maintainable" (foldlSent [
-  S "The traceability between", foldlList Comma List [plural requirement,
-  plural assumption, plural thModel, plural genDefn, plural dataDefn, plural inModel,
-  plural likelyChg, plural unlikelyChg, plural module_], S "is completely recorded in",
-  plural traceyMatrix `S.inThe` getAcc srs `S.and_` phrase mg]) "Maintainable" nonFuncReqDom
+maintainable = mkMaintainableNFR "maintainable" 10 "Maintainable"
 
 portable :: ConceptInstance
 portable = cic "portable" (foldlSent [

code/drasil-example/pdcontroller/lib/Drasil/PDController/Requirements.hs

@@ -2,8 +2,8 @@
 module Drasil.PDController.Requirements where
 
 import Data.Drasil.Concepts.Documentation (funcReqDom, nonFuncReqDom, datumConstraint)
-
 import Drasil.DocLang.SRS (datCon)
+import Drasil.DocLang (mkMaintainableNFR)
 
 import Drasil.PDController.Concepts
 import Drasil.PDController.IModel
@@ -60,14 +60,7 @@ security
       nonFuncReqDom
 
 maintainability :: ConceptInstance
-maintainability
-  = cic "maintainability"
-      (foldlSent
-         [S "The dependencies among the instance models, requirements,",
-            S "likely changes, assumptions and all other relevant sections of",
-            S "this document shall be traceable to each other in the trace matrix"])
-      "Maintainable"
-      nonFuncReqDom
+maintainability = mkMaintainableNFR "maintainability" 10 "Maintainable"
 
 verifiability :: ConceptInstance
 verifiability

code/drasil-example/projectile/lib/Drasil/Projectile/Requirements.hs

@@ -4,14 +4,14 @@ import Language.Drasil
 import Drasil.DocLang.SRS (datCon, propCorSol)
 import Language.Drasil.Chunk.Concept.NamedCombinators
 import qualified Language.Drasil.Sentence.Combinators as S
+import Drasil.DocLang (mkMaintainableNFR)
 
 import Data.Drasil.Concepts.Computation (inValue)
-import Data.Drasil.Concepts.Documentation (assumption, code, datumConstraint,
-  environment, funcReqDom, likelyChg, mg, mis, module_, nonFuncReqDom, output_,
-  property, requirement, srs, traceyMatrix, unlikelyChg, value, vavPlan, propOfCorSol)
+import Data.Drasil.Concepts.Documentation (code, datumConstraint,
+  environment, funcReqDom, mg, mis, nonFuncReqDom, output_,
+  property, value, vavPlan, propOfCorSol)
 import Data.Drasil.Concepts.Math (calculation)
 import Data.Drasil.Concepts.Software (errMsg)
-import Data.Drasil.TheoryConcepts (dataDefn, genDefn, inModel, thModel)
 
 import Drasil.Projectile.IMods (landPosIM, messageIM, offsetIM, timeIM)
 import Drasil.Projectile.Unitals (flightDur, landPos, message, offset)
@@ -72,13 +72,10 @@ reusable :: ConceptInstance
 reusable = cic "reusable" (foldlSent [atStartNP (the code), S "is modularized"]) "Reusable" nonFuncReqDom
 
 maintainable :: ConceptInstance
-maintainable = cic "maintainable" (foldlSent [
-  S "The traceability between", foldlList Comma List [plural requirement,
-  plural assumption, plural thModel, plural genDefn, plural dataDefn, plural inModel,
-  plural likelyChg, plural unlikelyChg, plural module_], S "is completely recorded in",
-  plural traceyMatrix, S "in the", getAcc srs `S.and_` phrase mg]) "Maintainable" nonFuncReqDom
+maintainable = mkMaintainableNFR "maintainable" 10 "Maintainable"
 
 portable :: ConceptInstance
 portable = cic "portable" (foldlSent [
   atStartNP (the code), S "is able to be run in different", plural environment])
-  "Portable" nonFuncReqDom
+  "Portable" nonFuncReqDom
+

code/drasil-example/ssp/lib/Drasil/SSP/Requirements.hs

@@ -4,16 +4,14 @@ import Language.Drasil
 import Language.Drasil.Chunk.Concept.NamedCombinators
 import qualified Language.Drasil.Sentence.Combinators as S
 
-import Drasil.DocLang (mkInputPropsTable)
+import Drasil.DocLang (mkInputPropsTable, mkMaintainableNFR)
 import Drasil.DocLang.SRS (datCon, propCorSol) 
 
 import Data.Drasil.Concepts.Computation (inDatum)
-import Data.Drasil.Concepts.Documentation (assumption, code,
-  datum, funcReqDom, input_, likelyChg, mg, mis, module_, name_, nonFuncReqDom,
-  output_, physicalConstraint, property, requirement, srs, symbol_,
-  traceyMatrix, unlikelyChg, user, value, propOfCorSol)
+import Data.Drasil.Concepts.Documentation (code,
+  datum, funcReqDom, input_, mg, mis, name_, nonFuncReqDom,
+  output_, physicalConstraint, property, symbol_, user, value, propOfCorSol)
 import Data.Drasil.Concepts.Physics (twoD)
-import Data.Drasil.TheoryConcepts (dataDefn, genDefn, inModel, thModel)
 
 import Drasil.SSP.Defs (crtSlpSrf, slope, slpSrf)
 import Drasil.SSP.IMods (fctSfty, nrmShrFor, intsliceFs, crtSlpId)
@@ -125,8 +123,4 @@ reusable = cic "reusable" (foldlSent [
   atStartNP (the code), S "is modularized"]) "Reusable" nonFuncReqDom
 
 maintainable :: ConceptInstance
-maintainable = cic "maintainable" (foldlSent [
-  S "The traceability between", foldlList Comma List [plural requirement,
-  plural assumption, plural thModel, plural genDefn, plural dataDefn, plural inModel,
-  plural likelyChg, plural unlikelyChg, plural module_], S "is completely recorded in",
-  plural traceyMatrix `S.inThe` getAcc srs `S.and_` phrase mg]) "Maintainable" nonFuncReqDom
+maintainable = mkMaintainableNFR "maintainable" 10 "Maintainable"

code/drasil-example/swhs/lib/Drasil/SWHS/Requirements.hs

@@ -6,23 +6,20 @@ import qualified Language.Drasil.NounPhrase.Combinators as NP
 import qualified Language.Drasil.Sentence.Combinators as S
 import Theory.Drasil (InstanceModel, HasOutput(output))
 
-import Drasil.DocLang (inReq)
+import Drasil.DocLang (inReq, mkMaintainableNFR)
 import Drasil.DocLang.SRS (datCon, propCorSol) 
 
 import Data.Drasil.Concepts.Computation (inValue)
-import Data.Drasil.Concepts.Documentation (assumption, code, condition,
-  funcReqDom, input_, likelyChg, mg, mis, module_, nonFuncReqDom, output_,
-  physicalConstraint, property, propOfCorSol, requirement, srs, traceyMatrix,
-  unlikelyChg, value, vavPlan)
+import Data.Drasil.Concepts.Documentation (code, condition,
+  funcReqDom, input_, mg, mis, nonFuncReqDom, output_,
+  physicalConstraint, property, propOfCorSol, value, vavPlan)
 import Data.Drasil.Concepts.Math (parameter)
 import Data.Drasil.Concepts.PhysicalProperties (materialProprty)
 import Data.Drasil.Concepts.Thermodynamics as CT (lawConsEnergy, melting)
 
 import Data.Drasil.Quantities.PhysicalProperties (mass)
 import Data.Drasil.Quantities.Physics (energy, time)
 
-import Data.Drasil.TheoryConcepts (dataDefn, genDefn, inModel, thModel)
-
 import Drasil.SWHS.DataDefs (waterMass, waterVolume, tankVolume, 
   balanceDecayRate, balanceDecayTime, balanceSolidPCM, balanceLiquidPCM)
 import Drasil.SWHS.Concepts (phsChgMtrl, tank)
@@ -159,14 +156,4 @@ reusable = cic "reusable" (foldlSent [
   atStartNP (the code), S "is modularized"]) "Reusable" nonFuncReqDom
 
 maintainable :: ConceptInstance
-maintainable = cic "maintainable" (foldlSent [
-  S "The traceability between", foldlList Comma List [plural requirement,
-  plural assumption, plural thModel, plural genDefn, plural dataDefn, plural inModel,
-  plural likelyChg, plural unlikelyChg, plural module_], S "is completely recorded in",
-  plural traceyMatrix, S "in the", getAcc srs `S.and_` phrase mg]) "Maintainable" nonFuncReqDom
-
--- The second sentence of the above paragraph is repeated in all examples (not
--- exactly, but the general idea is). The first sentence is not always
--- repeated, but it is always either stating that performance is a priority or
--- performance is not a priority. This is probably something that can be
--- abstracted out.
+maintainable = mkMaintainableNFR "maintainable" 10 "Maintainable"