TemplateEngine

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (TemplateEngine, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

var allowCaching: Boolean

Set to false if you don't want the template engine to ever cache any of the compiled templates.

var allowReload: Boolean

If true, then the template engine will check to see if the template has been updated since last compiled so that it can be reloaded.

final def asInstanceOf[T0]: T0

var bindings: List[Binding]

By default lets bind the context so we get to reuse its methods in a template

def boot(): Unit

var bootClassName: String

var bootInjections: List[AnyRef]

def buildSourceMap(stratumName: String, uri: String, scalaFile: File, positions: TreeMap[OffsetPosition, OffsetPosition]): String

def bytecodeDirectory: File

def cacheHits: Int

The number of times a template load request was serviced from the cache.

def cacheMisses: Int

The number of times a template load request could not be serviced from the cache and was loaded from disk.

def canLoad(uri: String, extraBindings: Traversable[Binding]): Boolean

Returns true if the URI can be loaded as a template

def canLoad(uri: String): Boolean

Returns true if the URI can be loaded as a template

def canLoad(source: TemplateSource, extraBindings: Traversable[Binding] = Nil): Boolean

Returns true if the URI can be loaded as a template

def classFileName(uri: String): File

var classLoader: ClassLoader

var classpath: String

def clone(): AnyRef

var codeGenerators: Map[String, CodeGenerator]

The supported template engines and their default extensions

var combinedClassPath: Boolean

Whether a custom classpath should be combined with the deduced classpath

def compile(source: TemplateSource, extraBindings: Traversable[Binding] = Nil): Template

Compiles a template source without placing it in the template cache.

def compileMoustache(text: String, extraBindings: Traversable[Binding] = Nil): Template

Compiles the given Moustache template text and returns the template

def compileScaml(text: String, extraBindings: Traversable[Binding] = Nil): Template

Compiles the given SSP template text and returns the template

def compileSsp(text: String, extraBindings: Traversable[Binding] = Nil): Template

Compiles the given SSP template text and returns the template

def compileText(extension: String, text: String, extraBindings: Traversable[Binding] = Nil): Template

Compiles the given text using the given extension (such as ssp or scaml for example to denote what parser to use) and return the template

lazy val compiler: Compiler

var compilerInitialized: Boolean

def createCompiler: Compiler

Factory method to create a compiler for this TemplateEngine.

def createRenderContext(uri: String, out: PrintWriter): RenderContext

Factory method used by the layout helper methods that should be overloaded by template engine implementations if they wish to customize the render context implementation

def ensuring(cond: (TemplateEngine) ⇒ Boolean, msg: ⇒ Any): TemplateEngine

def ensuring(cond: (TemplateEngine) ⇒ Boolean): TemplateEngine

def ensuring(cond: Boolean, msg: ⇒ Any): TemplateEngine

def ensuring(cond: Boolean): TemplateEngine

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

var escapeMarkup: Boolean

Whether or not markup sensitive characters for HTML/XML elements like & > < are escaped or not

def expireAndCompile(source: TemplateSource, extraBindings: Traversable[Binding] = Nil): Unit

Expire specific template source and then compile and cache again

def extension(source: TemplateSource): Option[String]

Extracts the extension from the source's uri though derived engines could override this behaviour to auto default missing extensions or performing custom mappings etc.

var extensionToTemplateExtension: Map[String, Set[String]]

Maps file extensions to possible template extensions for custom mappins such as for Map("js" -> Set("coffee"), "css" => Set("sass", "scss"))

def extensions: Set[String]

Returns the file extensions understood by Scalate; all the template engines and pipelines including the wiki markup languages.

def filter(name: String): Option[Filter]

var filters: Map[String, Filter]

def finalize(): Unit

val finderCache: ConcurrentHashMap[String, String]

def formatted(fmtstr: String): String

def generateScala(uri: String): Code

Generates the Scala code for a template.

def generateScala(uri: String, extraBindings: Traversable[Binding]): Code

Generates the Scala code for a template.

def generateScala(source: TemplateSource, extraBindings: Traversable[Binding] = Nil): Code

Generates the Scala code for a template.

def generator(source: TemplateSource): CodeGenerator

Gets the code generator to use for the give uri string by looking up the uri's extension in the the codeGenerators map.

def generatorForExtension(extension: String): CodeGenerator

Returns the code generator for the given file extension

final def getClass(): Class[_]

def hashCode(): Int

var importStatements: List[String]

Sets the import statements used in each generated template class

def invalidateCachedTemplates(): Boolean

Invalidates all cached Templates.

def isDevelopmentMode: Boolean

Returns true if this template engine is being used in development mode.

final def isInstanceOf[T0]: Boolean

def layout(source: TemplateSource, context: RenderContext): Unit

Renders the given template source using the current layoutStrategy

def layout(source: TemplateSource, context: RenderContext, extraBindings: Traversable[Binding]): Unit

Renders the given template source using the current layoutStrategy

def layout(source: TemplateSource, attributes: Map[String, Any]): String

Renders the given template source using the current layoutStrategy

def layout(source: TemplateSource): String

Renders the given template source using the current layoutStrategy

def layout(uri: String, template: Template): String

def layout(uri: String, context: RenderContext): Unit

def layout(uri: String, template: Template, attributes: Map[String, Any]): String

Renders the given template returning the output

def layout(uri: String, template: Template, out: PrintWriter, attributes: Map[String, Any]): Unit

def layout(uri: String, out: PrintWriter, attributes: Map[String, Any]): Unit

def layout(uri: String, attributes: Map[String, Any] = Map(), extraBindings: Traversable[Binding] = Nil): String

Renders the given template URI returning the output

def layout(template: Template, context: RenderContext): Unit

Renders the given template using the current layoutStrategy

def layout(uri: String, context: RenderContext, extraBindings: Traversable[Binding]): Unit

Renders the given template URI using the current layoutStrategy

def layoutAsNodes(uri: String, template: Template): NodeSeq

def layoutAsNodes(uri: String, template: Template, attributes: Map[String, Any]): NodeSeq

Renders the given template returning the output

def layoutAsNodes(uri: String, attributes: Map[String, Any] = Map(), extraBindings: Traversable[Binding] = Nil): NodeSeq

Renders the given template URI returning the output

var layoutStrategy: LayoutStrategy

def libraryDirectory: File

def load(uri: String): Template

Compiles and then caches the specified template.

def load(uri: String, extraBindings: Traversable[Binding]): Template

Compiles and then caches the specified template.

def load(file: File): Template

Compiles and then caches the specified template.

def load(file: File, extraBindings: Traversable[Binding]): Template

Compiles and then caches the specified template.

def load(source: TemplateSource, extraBindings: Traversable[Binding] = Nil): Template

Compiles and then caches the specified template.

var mode: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var packagePrefix: String

def pipeline(source: TemplateSource): Option[List[Filter]]

Gets a pipeline to use for the give uri string by looking up the uri's extension in the the pipelines map.

var pipelines: Map[String, List[Filter]]

var resourceLoader: ResourceLoader

Loads resources such as the templates based on URIs

def shutdown(): Unit

def source(uri: String, templateType: String): TemplateSource

Returns a template source of the given type of template for the given URI and current resourceLoader

def source(uri: String): TemplateSource

Returns a template source for the given URI and current resourceLoader

var sourceDirectories: Traversable[File]

def sourceDirectoriesForwarder: TraversableForwarder[File]

A forwarder so we can refer to whatever the current latest value of sourceDirectories is even if the value is mutated after the TemplateEngine is constructed

def sourceDirectory: File

def sourceFileName(uri: String): File

Returns the source file of the template URI

val sourceMapLog: Log

def storeSourceMap(classFile: File, sourceMap: String): Unit

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

var templateDirectories: List[String]

A list of directories which are searched to load requested templates.

def templateExtensionsFor(extension: String): Set[String]

Returns the mutable set of template extensions which are mapped to the given URI extension.

def tmpDirectory: File

def toString(): String

def uriToSource(uri: String): UriTemplateSource

Creates a org.fusesource.scalate.TemplateSource from a URI

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def workingDirectory: File

If not explicitly configured this will default to using the scalate.workdir system property to specify the directory used for generating the scala source code and compiled bytecode - otherwise a temporary directory is used

def workingDirectory_=(value: File): Unit

def →[B](y: B): (TemplateEngine, B)

val self: Any

val self: Any

def x: TemplateEngine

def x: TemplateEngine