eval

package
v0.14.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 16, 2020 License: BSD-2-Clause Imports: 44 Imported by: 0

Documentation

Overview

Package eval handles evaluation of parsed Elvish code and provides runtime facilities.

Index

Constants

View Source 
const (
	// FnSuffix is the suffix for the variable names of functions. Defining a
	// function "foo" is equivalent to setting a variable named "foo~", and vice
	// versa.
	FnSuffix = "~"
	// NsSuffix is the suffix for the variable names of namespaces. Defining a
	// namespace foo is equivalent to setting a variable named "foo:", and vice
	// versa.
	NsSuffix = ":"
)

Variables

View Source 
var (
	ErrBadGlobPattern          = errors.New("bad GlobPattern; elvish bug")
	ErrCannotDetermineUsername = errors.New("cannot determine user name from glob pattern")
)

Errors thrown when globbing.

View Source 
var (
	ErrCanOnlyAssignList          = errors.New("can only assign compatible values")
	ErrPathMustBeString           = errors.New("path must be string")
	ErrPathCannotContainColonZero = errors.New(`path cannot contain colon or \0`)
)

Errors

View Source 
var (
	// ErrExternalCmdOpts is thrown when an external command is passed Elvish
	// options.
	//
	// TODO: Catch this kind of errors at compilation time.
	ErrExternalCmdOpts = errors.New("external commands don't accept elvish options")
	// ErrImplicitCdNoArg is thrown when an implicit cd form is passed arguments.
	ErrImplicitCdNoArg = errors.New("implicit cd accepts no arguments")
)
View Source 
var (
	ErrMustFollowWildcard    = errors.New("must follow wildcard")
	ErrModifierMustBeString  = errors.New("modifier must be string")
	ErrWildcardNoMatch       = errors.New("wildcard has no match")
	ErrMultipleTypeModifiers = errors.New("only one type modifier allowed")
	ErrUnknownTypeModifier   = errors.New("unknown type modifier")
)
View Source 
var (
	// ErrArgs is thrown when a Go function gets erroneous arguments.
	//
	// TODO(xiaq): Replace this single error type with multiple types that carry
	// richer error information.
	ErrArgs = errors.New("args error")
	// ErrNoOptAccepted is thrown when a Go function that does not accept any
	// options gets passed options.
	ErrNoOptAccepted = errors.New("function does not accept any options")
)
View Source 
var (
	// ClosedChan is a closed channel, suitable for use as placeholder channel input.
	ClosedChan = getClosedChan()
	// BlackholeChan is channel writes onto which disappear, suitable for use as
	// placeholder channel output.
	BlackholeChan = getBlackholeChan()
	// DevNull is /dev/null.
	DevNull = getDevNull()
	// DevNullClosedChan is a port made up from DevNull and ClosedChan,
	// suitable as placeholder input port.
	DevNullClosedChan = &Port{File: DevNull, Chan: ClosedChan}
	// DevNullClosedChan is a port made up from DevNull and BlackholeChan,
	// suitable as placeholder output port.
	DevNullBlackholeChan = &Port{File: DevNull, Chan: BlackholeChan}
)
View Source 
var (
	// NoArgs is an empty argument list. It can be used as an argument to Call.
	NoArgs = []interface{}{}
	// NoOpts is an empty option map. It can be used as an argument to Call.
	NoOpts = map[string]interface{}{}
)
View Source 
var DevNullPorts = [3]*Port{
	DevNullClosedChan, DevNullBlackholeChan, DevNullBlackholeChan}

DevNullPorts is 3 placeholder ports.

View Source 
var ErrBadBase = errors.New("bad base")

ErrBadBase is thrown by the "base" builtin if the base is smaller than 2 or greater than 36.

View Source 
var ErrImpure = errors.New("expression is impure")
View Source 
var ErrInputOfEawkMustBeString = errors.New("input of eawk must be string")

ErrInputOfEawkMustBeString is thrown when eawk gets a non-string input.

View Source 
var ErrInterrupted = errors.New("interrupted")

ErrInterrupted is thrown when the execution is interrupted by a signal.

View Source 
var ErrMoreThanOneRest = errors.New("more than one @ lvalue")

ErrMoreThanOneRest is returned when the LHS of an assignment contains more than one rest variables.

View Source 
var ErrNotInSameProcessGroup = errors.New("not in the same process group")

ErrNotInSameProcessGroup is thrown when the process IDs passed to fg are not in the same process group.

View Source 
var ErrStoreNotConnected = errors.New("store not connected")

ErrStoreNotConnected is thrown by dir-history when the store is not connected.

View Source 
var IsBuiltinSpecial = map[string]bool{}

IsBuiltinSpecial is the set of all names of builtin special forms. It is intended for external consumption, e.g. the syntax highlighter.

View Source 
var OK = &Exception{}

OK is a pointer to the zero value of Exception, representing the absence of exception.

Functions

func Cause 

func Cause(err error) error

Cause returns the Cause field if err is an *Exception. Otherwise it returns err itself.

func ChopLineEnding added in v0.14.0 

func ChopLineEnding(s string) string

ChopLineEnding removes any line ending ("\r\n" or "\n") from the end of s.

func EachExternal 

func EachExternal(f func(string))

EachExternal calls f for each name that can resolve to an external command. TODO(xiaq): Windows support

func GetCompilationError 

func GetCompilationError(e interface{}) (*diag.Error, bool)

GetCompilationError returns a *diag.Error and true if the given value is a compilation error. Otherwise it returns nil and false.

func InTempHome 

func InTempHome() (string, func())

InTempHome is like util.InTestDir, but it also sets HOME to the temporary directory and restores the original HOME in cleanup.

TODO(xiaq): Move this into the util package.

func ListenInterrupts added in v0.14.0 

func ListenInterrupts() (<-chan struct{}, func())

ListenInterrupts returns a channel that is closed when SIGINT or SIGQUIT has been received by the process. It also returns a function that should be called when the channel is no longer needed.

func NewCompilationError 

func NewCompilationError(message string, context diag.Context) error

NewCompilationError creates a new compilation error.

func NewExternalCmdExit 

func NewExternalCmdExit(name string, ws syscall.WaitStatus, pid int) error

NewExternalCmdExit constructs an error for representing a non-zero exit from an external command.

func PurelyEvalCompound 

func PurelyEvalCompound(cn *parse.Compound) (string, error)

func SplitIncompleteQNameFirstNs 

func SplitIncompleteQNameFirstNs(qname string) (ns, rest string)

SplitIncompleteQNameNsFirst splits an incomplete qualified variable name into the first part and the rest.

func SplitQNameNs 

func SplitQNameNs(qname string) (ns, name string)

SplitQNameNs splits a qualified variable name into the namespace part and the name part.

func SplitQNameNsFirst 

func SplitQNameNsFirst(qname string) (ns, rest string)

SplitQNameNs splits a qualified variable name into the first part and the rest.

func SplitQNameNsIncomplete 

func SplitQNameNsIncomplete(qname string) (ns, name string)

SplitQNameNs splits an incomplete qualified variable name into the namespace part and the name part.

func SplitQNameNsSegs 

func SplitQNameNsSegs(qname string) []string

SplitQNameNsSegs splits a qualified name into namespace segments.

func SplitVariableRef 

func SplitVariableRef(ref string) (sigil string, qname string)

SplitVariableRef splits a variable reference into the sigil and the (qualified) name.

func Styled 

func Styled(fm *Frame, input interface{}, stylings ...interface{}) (ui.Text, error)

Styled turns a string, a ui.Segment or a ui.Text into a ui.Text by applying the given stylings.

func Test 

func Test(t *testing.T, tests ...TestCase)

Test runs test cases. For each test case, a new Evaler is created with NewEvaler.

func TestWithSetup 

func TestWithSetup(t *testing.T, setup func(*Evaler), tests ...TestCase)

TestWithSetup runs test cases. For each test case, a new Evaler is created with NewEvaler and passed to the setup function.

Types

type Approximately added in v0.14.0 

type Approximately struct{ F float64 }

type Callable 

type Callable interface {
	// Call calls the receiver in a Frame with arguments and options.
	Call(fm *Frame, args []interface{}, opts map[string]interface{}) error
}

Callable wraps the Call method.

type Closure 

type Closure struct {
	ArgNames []string
	// The name for the rest argument. If empty, the function has fixed arity.
	RestArg     string
	OptNames    []string
	OptDefaults []interface{}
	Op          effectOp
	Captured    Ns
	SrcMeta     parse.Source
	DefFrom     int
	DefTo       int
}

Closure is a closure defined in Elvish script. Each closure has its unique identity.

func (*Closure) Call 

func (c *Closure) Call(fm *Frame, args []interface{}, opts map[string]interface{}) error

Call calls a closure.

func (*Closure) Equal 

func (c *Closure) Equal(rhs interface{}) bool

Equal compares by address.

func (*Closure) Fields added in v0.14.0 

func (c *Closure) Fields() vals.StructMap

func (*Closure) Hash 

func (c *Closure) Hash() uint32

Hash returns the hash of the address of the closure.

func (*Closure) Kind 

func (*Closure) Kind() string

Kind returns "fn".

func (*Closure) Repr 

func (c *Closure) Repr(int) string

Repr returns an opaque representation "<closure 0x23333333>".

type Editor 

type Editor interface {
	Notify(string, ...interface{})
}

Editor is the interface that the line editor has to satisfy. It is needed so that this package does not depend on the edit package.

type EnvList 

type EnvList struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

EnvList is a variable whose value is constructed from an environment variable by splitting at pathListSeparator. Changes to it are also propagated to the corresponding environment variable. Its elements cannot contain pathListSeparator or \0; attempting to put any in its elements will result in an error.

func (*EnvList) Get 

func (envli *EnvList) Get() interface{}

Get returns a Value for an EnvPathList.

func (*EnvList) Set 

func (envli *EnvList) Set(v interface{}) error

Set sets an EnvPathList. The underlying environment variable is set.

type EvalCfg added in v0.14.0 

type EvalCfg struct {
	// Ports used in evaluation. Must contain at least 3 elements; the Eval
	// method panics otherwise.
	Ports []*Port
	// Callback to get a channel of interrupt signals and a function to call
	// when the channel is no longer needed.
	Interrupt func() (<-chan struct{}, func())
	// Whether the Eval method should try to put the Elvish in the foreground
	// after evaluating the Op.
	PutInFg bool
}

EvalCfg keeps configuration for the (*Evaler).Eval method.

type Evaler 

type Evaler struct {

	// Dependencies.
	//
	// TODO: Remove these dependency by providing more general extension points.
	DaemonClient daemon.Client
	Editor       Editor
	// contains filtered or unexported fields
}

Evaler is used to evaluate elvish sources. It maintains runtime context shared among all evalCtx instances.

func NewEvaler 

func NewEvaler() *Evaler

NewEvaler creates a new Evaler.

func (*Evaler) AddAfterChdir 

func (ev *Evaler) AddAfterChdir(f func(string))

AddAfterChdir adds a function to run after changing directory.

func (*Evaler) AddBeforeChdir 

func (ev *Evaler) AddBeforeChdir(f func(string))

AddBeforeChdir adds a function to run before changing directory.

func (*Evaler) Chdir 

func (ev *Evaler) Chdir(path string) error

Chdir changes the current directory. On success it also updates the PWD environment variable and records the new directory in the directory history. It runs the functions in beforeChdir immediately before changing the directory, and the functions in afterChdir immediately after (if chdir was successful). It returns nil as long as the directory changing part succeeds.

func (*Evaler) Close 

func (ev *Evaler) Close() error

Close releases resources allocated when creating this Evaler. Currently this does nothing and always returns a nil error.

func (*Evaler) Compile 

func (ev *Evaler) Compile(tree parse.Tree, w io.Writer) (Op, error)

Compile compiles Elvish code in the global scope. If the error is not nil, it can be passed to GetCompilationError to retrieve more details.

func (*Evaler) CompileWithGlobal 

func (ev *Evaler) CompileWithGlobal(tree parse.Tree, g Ns, w io.Writer) (Op, error)

CompileWithGlobal compiles Elvish code in an alternative global scope. If the error is not nil, it can be passed to GetCompilationError to retrieve more details.

TODO(xiaq): To use the Op created, the caller must create a Frame and mutate its local scope manually. Consider restructuring the API to make that unnecessary.

func (*Evaler) EachNsInTop 

func (ev *Evaler) EachNsInTop(f func(s string))

EachNsInTop calls the passed function for each namespace that can be used from the top context.

func (*Evaler) EachVariableInTop 

func (ev *Evaler) EachVariableInTop(ns string, f func(s string))

EachVariableInTop calls the passed function for each variable name in namespace ns that can be found from the top context.

func (*Evaler) Eval 

func (ev *Evaler) Eval(op Op, cfg EvalCfg) error

Eval evaluates an Op with the specified configuration.

func (*Evaler) InstallBundled 

func (ev *Evaler) InstallBundled(name, src string)

InstallBundled installs a bundled module to the Evaler.

func (*Evaler) InstallDaemonClient 

func (ev *Evaler) InstallDaemonClient(client daemon.Client)

InstallDaemonClient installs a daemon client to the Evaler.

func (*Evaler) InstallModule 

func (ev *Evaler) InstallModule(name string, mod Ns)

InstallModule installs a module to the Evaler so that it can be used with "use $name" from script.

func (*Evaler) ParseAndCompile added in v0.14.0 

func (ev *Evaler) ParseAndCompile(src parse.Source, w io.Writer) (Op, error)

ParseAndCompile parses and compiles a Source.

func (*Evaler) PurelyEvalCompound 

func (ev *Evaler) PurelyEvalCompound(cn *parse.Compound) (string, error)

func (*Evaler) PurelyEvalPartialCompound 

func (ev *Evaler) PurelyEvalPartialCompound(cn *parse.Compound, upto int) (string, error)

func (*Evaler) PurelyEvalPrimary 

func (ev *Evaler) PurelyEvalPrimary(pn *parse.Primary) interface{}

PurelyEvalPrimary evaluates a primary node without causing any side effects. If this cannot be done, it returns nil.

Currently, only string literals and variables with no @ can be evaluated.

func (*Evaler) SetArgs 

func (ev *Evaler) SetArgs(args []string)

SetArgs replaces the $args builtin variable with a vector built from the argument.

func (*Evaler) SetLibDir 

func (ev *Evaler) SetLibDir(libDir string)

SetLibDir sets the library directory, in which external modules are to be found.

type Exception 

type Exception struct {
	Reason     error
	StackTrace *stackTrace
}

Exception represents an elvish exception. It is both a Value accessible to elvishscript, and the type of error returned by public facing evaluation methods like (*Evaler)PEval.

func (*Exception) Bool 

func (exc *Exception) Bool() bool

Bool returns whether this exception has a nil cause; that is, it is $ok.

func (*Exception) Equal 

func (exc *Exception) Equal(rhs interface{}) bool

Equal compares by address.

func (*Exception) Error 

func (exc *Exception) Error() string

Error returns the message of the cause of the exception.

func (*Exception) Fields added in v0.14.0 

func (exc *Exception) Fields() vals.StructMap

func (*Exception) Hash 

func (exc *Exception) Hash() uint32

Hash returns the hash of the address.

func (*Exception) Kind 

func (exc *Exception) Kind() string

Kind returns "exception".

func (*Exception) Repr 

func (exc *Exception) Repr(indent int) string

Repr returns a representation of the exception. It is lossy in that it does not preserve the stacktrace.

func (*Exception) Show added in v0.14.0 

func (exc *Exception) Show(indent string) string

Show shows the exception.

type ExternalCmd 

type ExternalCmd struct {
	Name string
}

ExternalCmd is an external command.

func (ExternalCmd) Call 

func (e ExternalCmd) Call(fm *Frame, argVals []interface{}, opts map[string]interface{}) error

Call calls an external command.

func (ExternalCmd) Equal 

func (e ExternalCmd) Equal(a interface{}) bool

func (ExternalCmd) Hash 

func (e ExternalCmd) Hash() uint32

func (ExternalCmd) Kind 

func (ExternalCmd) Kind() string

func (ExternalCmd) Repr 

func (e ExternalCmd) Repr(int) string

type ExternalCmdExit 

type ExternalCmdExit struct {
	syscall.WaitStatus
	CmdName string
	Pid     int
}

ExternalCmdExit contains the exit status of external commands.

func (ExternalCmdExit) Error 

func (exit ExternalCmdExit) Error() string

func (ExternalCmdExit) Fields added in v0.14.0 

func (exit ExternalCmdExit) Fields() vals.StructMap

type FailError added in v0.14.0 

type FailError struct{ Content interface{} }

FailError is an error returned by the "fail" command.

func (FailError) Error added in v0.14.0 

func (e FailError) Error() string

Error returns the string representation of the cause.

func (FailError) Fields added in v0.14.0 

func (e FailError) Fields() vals.StructMap

Fields returns a structmap for accessing fields from Elvish.

type Flow 

type Flow uint

Flow is a special type of error used for control flows. 

const (
	Return Flow = iota
	Break
	Continue
)

Control flows.

func (Flow) Error 

func (f Flow) Error() string

func (Flow) Fields added in v0.14.0 

func (f Flow) Fields() vals.StructMap

func (Flow) Show added in v0.14.0 

func (f Flow) Show(string) string

Show shows the flow "error".

type Frame 

type Frame struct {
	*Evaler
	// contains filtered or unexported fields
}

Frame contains information of the current running function, aknin to a call frame in native CPU execution. A Frame is only modified during and very shortly after creation; new Frame's are "forked" when needed.

func NewTopFrame 

func NewTopFrame(ev *Evaler, src parse.Source, ports []*Port) *Frame

NewTopFrame creates a top-level Frame.

TODO(xiaq): This should be a method on the Evaler.

func (*Frame) CaptureOutput 

func (fm *Frame) CaptureOutput(f func(*Frame) error) ([]interface{}, error)

CaptureOutput captures the output of a given callback that operates on a Frame.

func (*Frame) Close 

func (fm *Frame) Close() error

Close releases resources allocated for this frame. It always returns a nil error. It may be called only once.

func (*Frame) Deprecate added in v0.14.0 

func (fm *Frame) Deprecate(msg string)

Deprecate shows a deprecation message. The message is not shown if the same deprecation message has been shown for the same location before.

func (Frame) EachNsInTop 

func (ev Frame) EachNsInTop(f func(s string))

EachNsInTop calls the passed function for each namespace that can be used from the top context.

func (Frame) EachVariableInTop 

func (ev Frame) EachVariableInTop(ns string, f func(s string))

EachVariableInTop calls the passed function for each variable name in namespace ns that can be found from the top context.

func (*Frame) Eval 

func (fm *Frame) Eval(op Op) error

Eval evaluates an Op. It is like eval except that it sets fm.srcMeta temporarily to op.src during the evaluation.

func (*Frame) InputChan 

func (fm *Frame) InputChan() chan interface{}

InputChan returns a channel from which input can be read.

func (*Frame) InputFile 

func (fm *Frame) InputFile() *os.File

InputFile returns a file from which input can be read.

func (*Frame) Interrupts 

func (fm *Frame) Interrupts() <-chan struct{}

Interrupts returns a channel that is closed when an interrupt signal comes.

func (*Frame) IsInterrupted 

func (fm *Frame) IsInterrupted() bool

IsInterrupted reports whether there has been an interrupt.

func (*Frame) IterateInputs 

func (fm *Frame) IterateInputs(f func(interface{}))

IterateInputs calls the passed function for each input element.

func (*Frame) OutputChan 

func (fm *Frame) OutputChan() chan<- interface{}

OutputChan returns a channel onto which output can be written.

func (*Frame) OutputFile 

func (fm *Frame) OutputFile() *os.File

OutputFile returns a file onto which output can be written.

func (*Frame) PipeOutput added in v0.14.0 

func (fm *Frame) PipeOutput(f func(*Frame) error, valuesCb func(<-chan interface{}), bytesCb func(*os.File)) error

PipeOutput calls a callback with output piped to the given output handlers.

func (*Frame) ResolveVar 

func (fm *Frame) ResolveVar(qname string) vars.Var

ResolveVar resolves a variable. When the variable cannot be found, nil is returned.

func (*Frame) SetLocal 

func (fm *Frame) SetLocal(ns Ns)

SetLocal changes the local scope of the Frame.

type GlobFlag 

type GlobFlag uint
const (
	NoMatchOK GlobFlag = 1 << iota
)

func (GlobFlag) Has 

func (f GlobFlag) Has(g GlobFlag) bool

type GlobPattern 

type GlobPattern struct {
	glob.Pattern
	Flags  GlobFlag
	Buts   []string
	TypeCb func(os.FileMode) bool
}

GlobPattern is en ephemeral Value generated when evaluating tilde and wildcards.

func (GlobPattern) Concat 

func (gp GlobPattern) Concat(v interface{}) (interface{}, error)

func (GlobPattern) Index 

func (gp GlobPattern) Index(k interface{}) (interface{}, error)

func (GlobPattern) RConcat 

func (gp GlobPattern) RConcat(v interface{}) (interface{}, error)

type GoFn 

type GoFn struct {
	// contains filtered or unexported fields
}

GoFn uses reflection to wrap arbitrary Go functions into Elvish functions.

Parameters are passed following these rules:

1. If the first parameter of function has type *Frame, it gets the current call frame.

2. If (possibly after a *Frame parameter) the first parameter has type RawOptions, it gets a map of options. If the function has not declared an RawOptions parameter but is passed options, an error is thrown.

Alternatively, a (non-pointer) struct argument whose type implements the Options interface can also be declared, in which case options will be scanned into it using RawOptions.Scan. If the pointer type of the struct implements a SetDefault method, it will be called before scanning.

3. If the last parameter is non-variadic and has type Inputs, it represents an optional parameter that contains the input to this function. If the argument is not supplied, the input channel of the Frame will be used to supply the inputs.

4. Other parameters are converted using elvToGo.

Return values go to the channel part of the stdout port, after being converted using goToElv. If the last return value has type error and is not nil, it is turned into an exception and no ouputting happens. If the last return value is a nil error, it is ignored.

func NewGoFn 

func NewGoFn(name string, impl interface{}) *GoFn

NewGoFn creates a new GoFn instance.

func (*GoFn) Call 

func (b *GoFn) Call(f *Frame, args []interface{}, opts map[string]interface{}) error

Call calls the implementation using reflection.

func (*GoFn) Equal 

func (b *GoFn) Equal(rhs interface{}) bool

Equal compares identity.

func (*GoFn) Hash 

func (b *GoFn) Hash() uint32

Hash hashes the address.

func (*GoFn) Kind 

func (*GoFn) Kind() string

Kind returns "fn".

func (*GoFn) Repr 

func (b *GoFn) Repr(int) string

Repr returns an opaque representation "<builtin $name>".

type Inputs 

type Inputs func(func(interface{}))

Inputs is the type that the last parameter of a Go-native function can take. When that is the case, it is a callback to get inputs. See the doc of GoFn for details.

type Ns 

type Ns map[string]vars.Var

Ns is a map from names to variables.

func (Ns) Add 

func (ns Ns) Add(name string, v vars.Var) Ns

Add adds a variable to the namespace and returns the namespace itself.

func (Ns) AddFn 

func (ns Ns) AddFn(name string, v Callable) Ns

AddFn adds a function to a namespace. It returns the namespace itself.

func (Ns) AddGoFn 

func (ns Ns) AddGoFn(nsName, name string, impl interface{}) Ns

AddGoFn adds a Go function to a namespace. It returns the namespace itself.

func (Ns) AddGoFns 

func (ns Ns) AddGoFns(nsName string, fns map[string]interface{}) Ns

AddGoFns adds Go functions to a namespace. It returns the namespace itself.

func (Ns) AddNs 

func (ns Ns) AddNs(name string, v Ns) Ns

AddNs adds a sub-namespace to a namespace. It returns the namespace itself.

func (Ns) Clone 

func (ns Ns) Clone() Ns

Clone returns a shallow copy of the namespace.

func (Ns) Equal 

func (ns Ns) Equal(rhs interface{}) bool

func (Ns) HasName 

func (ns Ns) HasName(name string) bool

HasName reports the namespace contains the given name.

func (Ns) Hash 

func (ns Ns) Hash() uint32

func (Ns) Index 

func (ns Ns) Index(k interface{}) (interface{}, bool)

func (Ns) IterateKeys 

func (ns Ns) IterateKeys(f func(interface{}) bool)

func (Ns) Kind 

func (Ns) Kind() string

func (Ns) PopName 

func (ns Ns) PopName(name string) vars.Var

PopName removes a name from the namespace and returns the variable it used to contain.

func (Ns) Repr 

func (ns Ns) Repr(int) string

type Op 

type Op struct {
	Inner effectOp
	Src   parse.Source
}

Op represents an operation on a Frame. It is the result of compiling a piece of source.

type PipelineError 

type PipelineError struct {
	Errors []*Exception
}

PipelineError represents the errors of pipelines, in which multiple commands may error.

func (PipelineError) Error 

func (pe PipelineError) Error() string

Error returns a plain text representation of the pipeline error.

func (PipelineError) Fields added in v0.14.0 

func (pe PipelineError) Fields() vals.StructMap

type Port 

type Port struct {
	File      *os.File
	Chan      chan interface{}
	CloseFile bool
	CloseChan bool
}

Port conveys data stream. It always consists of a byte band and a channel band.

func PortsFromFiles added in v0.14.0 

func PortsFromFiles(files [3]*os.File, ev *Evaler) ([3]*Port, func())

PortsFromFiles builds 3 ports from 3 files. It also returns a function that should be called when the ports are no longer needed.

func (*Port) Close 

func (p *Port) Close()

Close closes a Port.

func (*Port) Fork 

func (p *Port) Fork() *Port

Fork returns a copy of a Port with the Close* flags unset.

type PwdVariable 

type PwdVariable struct {
	// contains filtered or unexported fields
}

PwdVariable is a variable whose value always reflects the current working directory. Setting it changes the current working directory.

func (PwdVariable) Get 

func (PwdVariable) Get() interface{}

Get returns the current working directory. It returns /unknown/pwd when it cannot be determined.

func (PwdVariable) Set 

func (pwd PwdVariable) Set(v interface{}) error

Set changes the current working directory.

type RawOptions 

type RawOptions map[string]interface{}

RawOptions is the type of an argument a Go-native function can take to declare that it wants to parse options itself. See the doc of GoFn for details.

type TestCase 

type TestCase struct {
	// contains filtered or unexported fields
}

TestCase is a test case for Test.

func That 

func That(lines ...string) TestCase

That returns a new Test with the specified source code. Multiple arguments are joined with newlines.

func (TestCase) DoesNotCompile added in v0.14.0 

func (t TestCase) DoesNotCompile() TestCase

DoesNotCompile returns an altered TestCase that requires the source code to fail compilation.

func (TestCase) DoesNothing 

func (t TestCase) DoesNothing() TestCase

DoesNothing returns t unchanged. It is used to mark that a piece of code should simply does nothing. In particular, it shouldn't have any output and does not error.

func (TestCase) Prints 

func (t TestCase) Prints(s string) TestCase

Prints returns an altered TestCase that requires the source code to produce the specified output in the byte pipe when evaluated.

func (TestCase) PrintsStderrWith added in v0.14.0 

func (t TestCase) PrintsStderrWith(s string) TestCase

PrintsStderr returns an altered TestCase that requires the stderr output to contain the given text.

func (TestCase) Puts 

func (t TestCase) Puts(vs ...interface{}) TestCase

Puts returns an altered TestCase that requires the source code to produce the specified values in the value channel when evaluated.

func (TestCase) PutsStrings 

func (t TestCase) PutsStrings(ss []string) TestCase

PutsStrings returns an altered TestCase that requires the source code to produce the specified strings in the value channel when evaluated.

func (TestCase) Throws added in v0.14.0 

func (t TestCase) Throws(cause error, stacks ...string) TestCase

Throws returns an altered TestCase that requires the source code to throw an exception that has the given cause, and has stacktraces that match the given source fragments (innermost first).

func (TestCase) ThrowsAny added in v0.14.0 

func (t TestCase) ThrowsAny() TestCase

ThrowsAny returns an altered TestCase that requires the source code to throw any exception when evaluated.

func (TestCase) ThrowsCause added in v0.14.0 

func (t TestCase) ThrowsCause(err error) TestCase

ThrowsCause returns an altered TestCase that requires the source code to throw an exception with the given cause when evaluated.

func (TestCase) ThrowsMessage added in v0.14.0 

func (t TestCase) ThrowsMessage(msg string) TestCase

ThrowsMessage returns an altered TestCase that requires the source code to throw an error with the specified message when evaluted.

Notes

Bugs

  • When evaluating closures, async access to global variables and ports can be problematic.

Source Files

View all Source files

Directories

Path Synopsis
Package bundled manages modules written in Elvish that are bundled with the elvish binary.
 Package bundled manages modules written in Elvish that are bundled with the elvish binary.
Package daemon implements the builtin daemon: module.
 Package daemon implements the builtin daemon: module.
Package errs declares error types used as exception causes.
 Package errs declares error types used as exception causes.
Package math exposes functionality from Go's math package as an elvish module.
 Package math exposes functionality from Go's math package as an elvish module.
Package platform exposes variables and functions that deal with the specific platform being run on, such as the OS name and CPU architecture.
 Package platform exposes variables and functions that deal with the specific platform being run on, such as the OS name and CPU architecture.
Package re implements a regular expression module.
 Package re implements a regular expression module.
Package str exposes functionality from Go's strings package as an Elvish module.
 Package str exposes functionality from Go's strings package as an Elvish module.
Package unix exports an Elvish namespace that contains variables and functions that deal with features unique to UNIX-like operating systems.
 Package unix exports an Elvish namespace that contains variables and functions that deal with features unique to UNIX-like operating systems.
Package vals contains basic facilities for manipulating values used in the Elvish runtime.
 Package vals contains basic facilities for manipulating values used in the Elvish runtime.
Package vars contains basic types for manipulating Elvish variables.
 Package vars contains basic types for manipulating Elvish variables.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.