engine

Type Members

1. trait ABuilderFactory1[P, R, FullR] extends EngineUniverse[R, FullR] with Engine1Types[P, R, FullR]

2. trait ABuilderFactory2[P1, P2, R, FullR] extends EngineUniverse[R, FullR] with Engine2Types[P1, P2, R, FullR]

3. trait ABuilderFactory3[P1, P2, P3, R, FullR] extends EngineUniverse[R, FullR] with Engine3Types[P1, P2, P3, R, FullR]

4. abstract class AbstractStructuredMap[V, I] extends AnyRef

   This class is designed to support the production of documents with keys like 1.

5. class BecauseClauseException extends EngineException

6. class BuilderFactory1[P, R, FullR] extends ABuilderFactory1[P, R, FullR]

7. class BuilderFactory2[P1, P2, R, FullR] extends ABuilderFactory2[P1, P2, R, FullR]

8. class BuilderFactory3[P1, P2, P3, R, FullR] extends ABuilderFactory3[P1, P2, P3, R, FullR]

9. class ByReferenceDocumentPrinterStrategy extends DocumentPrinterStrategy

10. class CanAddChildEngineAfterUseCaseOrScenarioException extends Exception

11. class CanOnlyAddDocumentToBuilderException extends Exception

12. class CannotFindDocumentException extends Exception

13. class CannotHaveChildEnginesWithoutFolderException extends Exception

14. class CannotHaveFolderWithoutChildEnginesException extends Exception

15. trait ChildEngine[R] extends EngineBuiltFromTests[R] with ReportableWithTemplate

    A child engine is an engine that 'belongs' to a full engine.

16. class ChildReportWalker extends ReportWalker

17. case class ClassFunction[C, T](clazz: Class[C], fn: (C) ⇒ T) extends Product with Serializable

18. case class ClassFunctionList[T](list: List[ClassFunction[_, T]] = immutable.this.Nil) extends Product with Serializable

19. trait Conclusion extends ConclusionOrDecision

    This represents a conclusion in the decision tree

20. trait ConclusionOrDecision extends Reportable

    The decision tree inside an engine with tests is made of nodes that either a conclusion or a decision.

21. class ConsoleLogger extends SimpleTddLogger

22. case class DataAndChildren[V, I](key: Key, data: I, children: List[DataAndChildren[V, I]])(implicit toIterable: (I) ⇒ Iterable[V]) extends Product with Serializable

23. trait Decision extends ConclusionOrDecision

    This represents a decision in the decision tree

24. trait DecisionTreeFolder[Acc] extends AnyRef

    This is the visitor when folding a decision tree.

25. class DefaultDocumentMergeStrategy extends DocumentMergeStrategy

26. class DefaultIfThenPrinter extends IfThenPrinter

27. class DelegatingLogger extends TddLogger

28. case class Document(title: Option[String] = scala.None, description: Option[String] = scala.None, priority: Option[Int] = scala.None, url: Option[String] = scala.None, mergeStrategy: DocumentMergeStrategy = DocumentMergeStrategy.default) extends Requirement with Product with Serializable

    Documents are external documents such as requirements specifications, emails and so on.

29. case class DocumentHolder(children: List[Document]) extends ReportableHolder with Product with Serializable

30. trait DocumentMergeStrategy extends AnyRef

31. class DocumentPrinter extends AnyRef

32. trait DocumentPrinterStrategy extends AnyRef

33. class DocumentThenEngineWalker extends ReportWalker

34. class DuplicateKeyException extends Exception

35. trait Engine extends RequirementAndHolder with ReportableWithTextOrder

    This is the core object that describes an Engine.

36. trait Engine1[P, R] extends Engine with (P) ⇒ R

37. trait Engine1Types[P, R, FullR] extends EngineTypes[R, FullR]

38. trait Engine2[P1, P2, R] extends Engine with (P1, P2) ⇒ R

39. trait Engine2Types[P1, P2, R, FullR] extends EngineTypes[R, FullR]

40. trait Engine3[P1, P2, P3, R] extends Engine with (P1, P2, P3) ⇒ R

41. trait Engine3Types[P1, P2, P3, R, FullR] extends EngineTypes[R, FullR]

42. trait EngineBuiltFromTests[R] extends EngineWithResult[R]

    This is the 'normal' engine.

43. class EngineConclusionWalker extends ReportWalker

44. trait EngineFull[R, FullR] extends EngineWithResult[FullR]

    An engine with child engines and a folding function for aggregating the results

45. case class EngineHolder(children: List[Reportable]) extends ReportableHolder with Product with Serializable

46. trait EngineTypes[R, FullR] extends AnyRef

    R is the type returned by the child engines, or the engine if there are no child enginers.

47. trait EngineUniverse[R, FullR] extends EngineTypes[R, FullR]

48. trait EngineWithLogger extends Engine

49. trait EngineWithResult[R] extends Engine

50. trait EngineWithScenarioExceptionMap extends Engine

51. class ExceptionAddingScenario extends EngineException

52. class FieldSet[T] extends AnyRef

53. class FileReportCreator extends ReportCreator[FileSystemReportableToUrl]

54. class FileSystemReportableToUrl extends ReportableToUrl

55. case class Fold[T, A](initial: A, fn: (A, T) ⇒ A) extends Product with Serializable

56. trait FragStrategy[S, Result] extends AnyRef

57. case class Fragment[S, Result, T, A](fragStrategy: FragStrategy[S, Result], raw: S, paths: List[Path] = immutable.this.Nil, convertor: Option[(Result) ⇒ Option[T]], fold: Option[Fold[T, A]] = scala.None) extends Product with Serializable

58. class FullHtmlPage extends IfThenPrinter

59. trait HtmlDisplay extends AnyRef

    Classes implementing this are displayed using htmlDisplay, rather than toString when shown on a website, or in HTML pages.

60. trait HtmlForIfThenPrinter extends IfThenPrinter

61. class HtmlIfThenPrinter extends HtmlForIfThenPrinter

62. class HtmlRenderer extends AnyRef

63. class HtmlWithTestIfThenPrinter extends HtmlForIfThenPrinter

64. trait IfThenPrinter extends AnyRef

65. case class IndentAndString(indent: String, string: String) extends Product with Serializable

66. case class Key(key: String, path: List[String]) extends Product with Serializable

67. case class KeyOrder[V, I](depth: Int) extends Ordering[DataAndChildren[V, I]] with Product with Serializable

68. trait KeyStrategy extends AnyRef

69. class Lists[A] extends AnyRef

70. class Log4JLogger extends SimpleTddLogger

71. trait LoggerDisplay extends AnyRef

72. trait LoggerDisplayProcessor extends (Any) ⇒ String

73. case class MapOfList[K, V](map: Map[K, List[V]] = ...) extends Product with Serializable

74. class Maps extends AnyRef

75. case class MergedDescription(description: Option[String], children: ReportableList) extends ReportableHolder with MergedShortDescription with Product with Serializable

76. case class MergedReportable(key: String, titles: List[MergedTitle], children: ReportableList) extends ReportableHolder with MergedShortDescription with ReportableWithTemplate with Product with Serializable

    A merged requirement is used to handle the fact that many reportables may implement a '2.

77. trait MergedShortDescription extends AnyRef

78. case class MergedTitle(title: Option[String], children: List[MergedDescription]) extends ReportableHolder with MergedShortDescription with Product with Serializable

79. class NeedScenarioException extends Exception

80. class NeedUseCaseException extends Exception

81. class NestedTraceBuilder extends TraceBuilder

82. class NoLogger extends SimpleTddLogger

83. class NoReportableToUrl extends ReportableToUrl

84. trait NodeComparator[R, FullR] extends EngineUniverse[R, FullR]

85. case class ParamDetail(displayName: String, parser: Function1[String, _], testValue: Option[String]) extends Product with Serializable

    The details about the parameters to an engine, including a parser for the live website and a default string value that allows the live website to be be tested by a selenium test easily

86. trait ParamDetails extends AnyRef

87. case class Path(linked: Boolean, element: String) extends Product with Serializable

88. case class PathMap[S, Result](map: Map[S, MapOfList[List[Path], List[Path]]], roots: Map[S, List[Path]], fullPaths: Map[S, List[Fragment[S, Result, _, _]]]) extends Product with Serializable

    So this is all the ends in a parent / child map.

89. case class Project(projectTitle: String, engines: ReportableHolder*) extends RequirementAndHolder with Product with Serializable

    A project is basically a list of the engines that are used on a software project

90. case class ROrException[R](value: Option[R], exception: Option[Throwable]) extends Product with Serializable

91. case class Reference(ref: String = "", document: Option[Document] = scala.None) extends Comparable[Reference] with Product with Serializable

    A reference is usually a link to a document.

92. class ReferenceRenderer extends AttributeRenderer

93. trait RenderAttributeConfigurer extends AnyRef

94. trait Renderer extends AnyRef

95. case class RendererContext[R <: Reportable](reportableToUrl: ReportableToUrl, loggerDisplayProcessor: LoggerDisplayProcessor, urlMap: UrlMap, path: List[Reportable], r: R, stringTemplate: StringTemplate, rootUrl: Option[String]) extends Product with Serializable

96. case class Report(reportTitle: String, reportables: Reportable*) extends RequirementAndHolder with Product with Serializable

    A report is what it says: the object representation of a (usually) html report

97. class ReportCreator[RtoUrl <: ReportableToUrl] extends AnyRef

98. trait ReportWalker extends AnyRef

99. trait Reportable extends AnyRef

    Reportables are things that appear in reports.

100. trait ReportableHolder extends Reportable with Traversable[Reportable]

     Quite a lot of reportables have 'child' reportables.

101. case class ReportableRenderer(loggerDisplayProcessor: LoggerDisplayProcessor, restrict: Set[Reportable], configurers: List[RenderAttributeConfigurer] = immutable.this.Nil, templates: Map[String, Renderer] = ..., walker: ReportWalker, rootUrl: Option[String]) extends Product with Serializable

102. trait ReportableToUrl extends AnyRef

103. trait ReportableWithTemplate extends AnyRef

     Templates was used to control the text is generated.

104. trait ReportableWithTextOrder extends Reportable

105. trait ReportableWrapper extends Reportable

     A reportable with a wrapper is used in the reports when making a projection of an original report.

106. trait Requirement extends Reportable

     Very little is known about Reportables: no methods are implemented.

107. case class RequirementAndEngine(reportable: RequirementAndHolder, engine: Option[Engine]) extends RequirementAndHolder with ReportableWrapper with Product with Serializable

108. trait RequirementAndHolder extends ReportableHolder with Requirement

     As the name suggests this is both a requirement and a reportableholder

109. case class ScenarioExceptionMap(map: Map[Test, Throwable] = ..., first: Option[Throwable] = scala.None) extends Product with Serializable

110. class SimpleDocumentPrinterStrategy extends DocumentPrinterStrategy

111. class SimpleKeyStrategy extends KeyStrategy

112. class SimpleLoggerDisplayProcessor extends LoggerDisplayProcessor

113. class SimpleReportableToUrl extends ReportableToUrl

114. case class SimpleRequirementAndHolder(delegate: Option[Reportable], title: Option[String], description: Option[String], priority: Option[Int], references: Set[Reference], children: ReportableList) extends RequirementAndHolder with ReportableWrapper with ReportableWithTextOrder with Product with Serializable

115. trait SimpleTddLogger extends TddLogger

116. class StringCleaner extends AnyRef

117. case class StringTemplateRenderer(template: String) extends Renderer with Product with Serializable

118. trait Structure[S, Result] extends HtmlDisplay

119. class StructuredMap[V] extends AbstractStructuredMap[V, Option[V]]

120. class StructuredMapOfList[V] extends AbstractStructuredMap[V, List[V]]

121. trait TddLogger extends LoggerDisplayProcessor

122. trait Test extends Requirement with ReportableWithTextOrder

     This is a full 'test + optional reason why + optional code to implement the behaviour that will make the test past

123. class TestLogger extends SimpleTddLogger

124. class TraceBuilder extends AnyRef

125. case class TraceItem(engine: Engine, params: List[Any], nested: List[TraceItem], conclusion: Conclusion, result: ROrException[Any], took: Long) extends Product with Serializable

126. class UndecidedException extends Exception

127. case class UrlMap(toUrl: Map[Reportable, String], fromUrl: Map[String, List[Reportable]]) extends Product with Serializable

     When reporting, this keeps track of what url a reportable is associated with.

128. trait UseCase extends RequirementAndHolder with ReportableWithTextOrder

     Usecases are at the moment mostly 'just text'.

129. class ValueForRender extends AnyRef

130. class ValueForRenderer extends AttributeRenderer

131. trait XmlSituation extends Structure[Elem, NodeSeq]