BaseSpecification

abstract def is: Fragments

declaration of Fragments from the user

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

implicit def ToFormattingTagParameter(condition: Boolean): Option[FormattingTagParameter]

implicit def argumentsFragment(a: Arguments): FragmentsFragment

Arguments creation

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit def exampleFactory: ExampleFactory

def finalize(): Unit

implicit def forExample(s: String): ExampleDesc

Example creation

def formatFragments: (Fragments) ⇒ Fragments

format a list of fragments according to their formatting tags

def formatSection(markdown: Option[FormattingTagParameter] = None, flow: Option[FormattingTagParameter] = None, verbatim: Option[FormattingTagParameter] = None): TaggingFragment

add a tagging section with special tag names specifying the formatting options

def formatTag(markdown: Option[FormattingTagParameter] = None, flow: Option[FormattingTagParameter] = None, verbatim: Option[FormattingTagParameter] = None): TaggingFragment

add a tag with special tag names specifying the formatting options

implicit def fragmentFragments(f: ⇒ Fragment): FragmentsFragment

implicit def fragments(f: ⇒ Fragment): Fragments

implicit def fragmentsFragmentToFragments(fs: FragmentsFragment): Fragments

reverse conversion from a Fragment containing a Fragments object to the Fragments object

implicit def fragmentsFragments(fs: ⇒ Fragments): FragmentsFragment

final def getClass(): Class[_]

def hashCode(): Int

def identification: SpecIdentification

specName provides useful information identifying the specification: title, className, url.

implicit def identifySpecificationStructure(s: SpecificationStructure): SpecIdentification

automatically convert a specification to its identification

implicit lazy val implicitParam: ImplicitParam

implicit lazy val implicitParam1: ImplicitParam1

implicit lazy val implicitParam10: ImplicitParam10

implicit lazy val implicitParam2: ImplicitParam2

implicit lazy val implicitParam3: ImplicitParam3

implicit lazy val implicitParam4: ImplicitParam4

implicit lazy val implicitParam5: ImplicitParam5

implicit lazy val implicitParam6: ImplicitParam6

implicit lazy val implicitParam7: ImplicitParam7

implicit lazy val implicitParam8: ImplicitParam8

implicit lazy val implicitParam9: ImplicitParam9

def include(args: Arguments, f: Fragments, fs: Fragments*): FragmentsFragment

def include(args: Arguments, f: Fragments): FragmentsFragment

def include(args: Arguments, s: SpecificationStructure, ss: SpecificationStructure*): FragmentsFragment

def include(args: Arguments, s: SpecificationStructure): FragmentsFragment

def include(s: SpecificationStructure, ss: SpecificationStructure*): FragmentsFragment

implicit def include(s: SpecificationStructure): FragmentsFragment

def include(f: Fragments, fs: Fragments*): FragmentsFragment

def include(f: Fragments): FragmentsFragment

def inline(specs: SpecificationStructure*): Fragments

add the fragments of another specification without start and end

final def isInstanceOf[T0]: Boolean

def link(htmlLink: HtmlLink, f: Fragments): Fragments

def link(htmlLink: HtmlLink, s: SpecificationStructure): Fragments

create a link directly on a specification, with a given link

def link(fss: Seq[Fragments]): Fragments

def link(fs: Fragments, fss: Fragments*): Fragments

def link(fs: Fragments): Fragments

def link(ss: Seq[SpecificationStructure], dummy: Int = 0): Fragments

def link(s: SpecificationStructure, ss: SpecificationStructure*): Fragments

def link(s: SpecificationStructure): Fragments

create a link directly on a specification

def map(fs: ⇒ Fragments): Fragments

this method can be overridden to map additional behavior in the user-defined fragments

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def section(names: String*): TaggingFragment

create a AsSection fragment

def see(htmlLink: HtmlLink, fs: Fragments): Fragments

def see(htmlLink: HtmlLink, s: SpecificationStructure): Fragments

create a see-only link directly on a specification, with a given link

def see(fss: Seq[Fragments]): Fragments

def see(fs: Fragments, fss: Fragments*): Fragments

def see(fs: Fragments): Fragments

def see(s: SpecificationStructure): Fragments

def see(ss: Seq[SpecificationStructure])(implicit p1: ImplicitParam1): Fragments

def see(s: SpecificationStructure, ss: SpecificationStructure*): Fragments

create a html link without including the other specification fragments

implicit def specIdentificationMarkdownLink(s: String): SpecIdentificationMarkdownLink

create markdown links from string + spec identification

implicit def specificationStructureToFragments(s: SpecificationStructure): AsFragments

this implicit allows to call some functions directly on a specification, like 'hide'

implicit def stringToHtmlLinkFragments(s: String): HtmlLinkFragments

Links to other specifications creation

implicit def stringToHtmlLinkFragments2(s: String): HtmlLinkFragments2

final def synchronized[T0](arg0: ⇒ T0): T0

def tag(names: String*): TaggingFragment

create a TaggedAs fragment

implicit def textFragment(s: String): FragmentsFragment

implicit def textStart(s: String): Fragments

implicit def title(s: String): SpecTitle

This method allows to add a title to the Specification.

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit