package util
- Alphabetic
- Public
- Protected
Type Members
- case class Bind[T](name: String, value: T)(implicit typeName: TypeName[T]) extends Product with Serializable
Models a binding of a value to a typed name, and is passed into the REPL so it can re-create the bindings inside the REPL's scope
- case class Catching(handler: PartialFunction[Throwable, Failing]) extends Product with Serializable
Fake for-comprehension generator to catch errors and turn them into Res.Failures
- trait CodeColors extends AnyRef
- case class Colors(prompt: Ref[Attrs], ident: Ref[Attrs], type: Ref[Attrs], literal: Ref[Attrs], prefix: Ref[Attrs], comment: Ref[Attrs], keyword: Ref[Attrs], selected: Ref[Attrs], error: Ref[Attrs], warning: Ref[Attrs], info: Ref[Attrs]) extends Product with Serializable
A set of colors used to highlight the miscellaneous bits of the REPL.
A set of colors used to highlight the miscellaneous bits of the REPL. Re-used all over the place in PPrint, TPrint, syntax highlighting, command-echoes, etc. in order to keep things consistent
- prompt
The command prompt
- ident
Definition of top-level identifiers
- literal
Strings, integers and other literal expressions
- prefix
The Seq/Foo when printing a Seq(...) or case class Foo(...)
- selected
The color of text selected in the line-editor
- error
The color used to print error messages of all kinds
- class CompilationError extends Exception
Exception for reporting script compilation failures
- case class Evaluated(wrapper: Seq[Name], imports: Imports) extends Product with Serializable
- trait Frame extends AnyRef
- case class ImportData(fromName: Name, toName: Name, prefix: Seq[Name], importType: ImportType) extends Product with Serializable
Represents the importing of a single name in the Ammonite REPL, of the form
Represents the importing of a single name in the Ammonite REPL, of the form
import $prefix.{$fromName => $toName}
All imports are reduced to this form;
import $prefix.$name
is results in thefromName
andtoName
being the same, whileimport $prefix._
orimport $prefix.{foo, bar, baz}
are split into multiple distinct ImportData objects.Note that imports can be of one of three distinct
ImportType
s: importing a type, a term, or both. This lets us properly deal with shadowing correctly if we import the type and term of the same name from different places - case class ImportHookInfo(imports: Imports, stmts: Seq[String], trees: Seq[ImportTree]) extends Product with Serializable
- case class ImportTree(prefix: Seq[String], mappings: Option[ImportMapping], start: Int, end: Int) extends Product with Serializable
- class Imports extends AnyRef
Represents the imports that occur before a piece of user code in the Ammonite REPL.
Represents the imports that occur before a piece of user code in the Ammonite REPL. It's basically a
Seq[ImportData]
, except we really want it to be always in a "canonical" form without shadowed/duplicate imports.Thus we only expose an
apply
method which performs this de-duplication, and a++
operator that combines two sets of imports while performing de-duplication. - case class Name(raw: String) extends Product with Serializable
Represents a single identifier in Scala source code, e.g.
Represents a single identifier in Scala source code, e.g. "scala" or "println" or "
Hello-World
".Holds the value "raw", with all special characters intact, e.g. "Hello-World". Can be used backticked e.g. "
Hello-World
", useful for embedding in Scala source code, or encoded e.g. "Hello$minusWorld", useful for accessing names as-seen-from the Java/JVM side of things - final case class Position(line: Int, char: Int) extends Product with Serializable
- case class PredefInfo(name: Name, code: String, hardcoded: Boolean, path: Option[Path]) extends Product with Serializable
Information about a particular predef file or snippet.
Information about a particular predef file or snippet. hardcoded represents whether or not we cache the snippet forever regardless of classpath, which is true for many "internal" predefs which only do imports from Ammonite's own packages and don't rely on external code
- case class Printer(outStream: PrintStream, errStream: PrintStream, resultStream: PrintStream, warning: (String) => Unit, error: (String) => Unit, info: (String) => Unit) extends Product with Serializable
Encapsulates the ways the Ammonite REPL prints things.
Encapsulates the ways the Ammonite REPL prints things. Does not print a trailing newline by default; you have to add one yourself.
- outStream
Direct access to print to stdout
- errStream
Direct access to print to stderr
- resultStream
Direct access to print the result of the entered code
- warning
How you want it to print a compile warning
- error
How you want it to print a compile error
- info
How you want to print compile info logging. *Not* the same as
out
, which is used to print runtime output.
- trait Ref[T] extends StableRef[T]
- abstract class ReplClassLoader extends URLClassLoader
- sealed abstract class Res[+T] extends AnyRef
The result of a single pass through the ammonite REPL.
The result of a single pass through the ammonite REPL. Results in a single T, or of one of a fixed number of failures that are common for anyone who is evaluating code via the REPL.
- case class ScriptOutput(processed: Metadata, classFiles: Seq[ClassFiles]) extends Product with Serializable
The serialized output of running a script, including both metadata and the classfile binaries
- trait StableRef[T] extends AnyRef
Encapsulates a read-write cell that can be passed around
- case class Tag(code: String, env: String, classPathWhitelistHash: String) extends Product with Serializable
A unique key for a piece of code that gets run in a particular environment; contains the hash of the code and the hash of the environment stored separately, so you can e.g.
A unique key for a piece of code that gets run in a particular environment; contains the hash of the code and the hash of the environment stored separately, so you can e.g. compare the env hash even if you don't have the code available
- class WhiteListClassLoader extends URLClassLoader
Value Members
- object Bind extends Serializable
- object Classpath
Loads the jars that make up the classpath of the scala-js-fiddle compiler and re-shapes it into the correct structure to satisfy scala-compile and scalajs-tools
- object Colors extends Serializable
- object Ex
Nice pattern matching for chained exceptions
- object Frame
- object ImportData extends Serializable
- object ImportTree extends Serializable
- object Imports
- object Name extends Serializable
- object PositionOffsetConversion
- object Ref
- object Res
- object ScriptOutput extends Serializable
- object Util