module_runtime.go

package ember

import (
	"context"
	"fmt"
	"strings"
)

func (r *Runtime) runModuleWithContextGlobalsController(ctx context.Context, key moduleKey, globals map[string]Value, controller *executionController, inherited []ScriptFrame) ([]Value, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	if err := ctx.Err(); err != nil {
		return nil, err
	}
	if value, ok := r.loaded[key]; ok {
		return []Value{value}, nil
	}
	if r.active[key] {
		return nil, fmt.Errorf("module runtime: active-loading cycle %s", runtimeModuleCyclePath(r.stack, key))
	}
	proto, ok := r.program.protos[key]
	if !ok {
		return nil, fmt.Errorf("module runtime: missing proto for %s", key.String())
	}
	if err := controller.chargeModuleInitialization(); err != nil {
		return nil, err
	}

	r.active[key] = true
	r.stack = append(r.stack, key)
	defer func() {
		delete(r.active, key)
		r.stack = r.stack[:len(r.stack)-1]
	}()

	call := r.newInvocationScope(ctx, key, globals, controller)
	results, err := executeProtoWithInvocationScope(ctx, proto, call, executeOptions{
		controller:            controller,
		inheritedScriptFrames: inherited,
	})
	if err != nil {
		return nil, err
	}
	r.loaded[key] = firstRuntimeResult(results)
	return results, nil
}

func runtimeModuleCyclePath(stack []moduleKey, key moduleKey) string {
	start := 0
	for i, active := range stack {
		if active == key {
			start = i
			break
		}
	}
	path := make([]string, 0, len(stack)-start+1)
	for _, active := range stack[start:] {
		path = append(path, active.String())
	}
	path = append(path, key.String())
	return strings.Join(path, " -> ")
}

func removeRuntimeModuleStackKey(stack []moduleKey, key moduleKey) []moduleKey {
	for index := len(stack) - 1; index >= 0; index-- {
		if stack[index] != key {
			continue
		}
		copy(stack[index:], stack[index+1:])
		stack[len(stack)-1] = moduleKey{}
		return stack[:len(stack)-1]
	}
	return stack
}