func (n *Node) Print(ctx context.Context) string {
b, err := system.Marshal(ctx, n.Value)
if err != nil {
// ke: {"block": {"notest": true}}
return err.Error()
}
return string(b)
}
func setupForSuccessfulFileLoad(t *testing.T, cb *ctests.ClientContextBuilder) {
// We have to unmarshal the received object, so we'll have to load some types.
cb.Base.Path("").Jauto().Sauto(parser.Parse)
done := make(chan error, 1)
do := func(method shared.Method, args interface{}, reply interface{}, fail chan error) chan error {
// Create a simple ke object and marshal it to a []byte
var bytes []byte
bytes, err := system.Marshal(cb.Ctx(), &system.Object{Type: system.NewReference("system", "object")})
require.NoError(t, err)
reply.(*shared.DataResponse).Found = true
reply.(*shared.DataResponse).Data = bytes
close(done)
return done
}
cb.GetConnection().EXPECT().Go(shared.Data, gomock.Any(), gomock.Any(), gomock.Any()).Do(do).Return(done)
}
func root(ctx context.Context, w http.ResponseWriter, req *http.Request, auth auther.Auther) error {
wgctx.Add(ctx, "root")
defer wgctx.Done(ctx, "root")
if b, err := static.Asset(req.URL.Path[1:]); err == nil {
if strings.HasSuffix(req.URL.Path, ".css") {
w.Header().Set("Content-Type", "text/css")
}
if err := writeWithTimeout(w, b); err != nil {
return kerr.Wrap("PVPCXBIUJT", err)
}
return nil
}
path := req.URL.Path[1:]
if strings.HasSuffix(path, "/") {
path = path[0 : len(path)-1]
}
// use a new context with a blank sysctx for the duration of this function
// to prevent caching
ctx = sysctx.NewContext(ctx)
scache := sysctx.FromContext(ctx)
env, err := parser.ScanForEnv(ctx, path)
if err != nil {
if _, ok := kerr.Source(err).(gopackages.NotFoundError); ok {
w.WriteHeader(404)
return nil
}
return kerr.Wrap("ALINBMKDRP", err)
}
pcache, err := parser.Parse(ctx, path)
if err != nil {
return kerr.Wrap("HIHWJRPUKE", err)
}
if err := process.GenerateAll(ctx, env.Path, map[string]bool{}); err != nil {
return kerr.Wrap("LVGHABDYNQ", err)
}
data := map[string]string{}
for _, name := range pcache.Globals.Keys() {
if g, ok := pcache.Globals.Get(name); ok {
data[name] = g.File
}
}
pkgBytes := pcache.PackageBytes
pkgFilename := pcache.PackageFilename
if pkgBytes == nil {
b, err := system.Marshal(ctx, system.EmptyPackage())
if err != nil {
return kerr.Wrap("OUBOTYGPKU", err)
}
pkgBytes = b
pkgFilename = "package.ke.json"
}
imports := map[string]shared.ImportInfo{}
var scan func(string) error
scan = func(path string) error {
if _, ok := imports[path]; ok {
return nil
}
syspi, ok := scache.Get(path)
if !ok {
return kerr.New("VIGKIUPNCF", "%s not found in sys ctx", path)
}
info := shared.ImportInfo{
Path: path,
Aliases: syspi.Aliases,
Types: map[string]shared.TypeInfo{},
}
for _, name := range syspi.Files.Keys() {
if b, ok := syspi.Files.Get(name); ok {
info.Types[name] = shared.TypeInfo{
File: b.File,
Bytes: b.Bytes,
}
}
}
imports[path] = info
for _, child := range syspi.Aliases {
if err := scan(child); err != nil {
return kerr.Wrap("NCULMUUUOT", err)
}
}
return nil
}
// First we always import system
if err := scan("kego.io/system"); err != nil {
return kerr.Wrap("KRXSLOJKWV", err)
}
if err := scan(env.Path); err != nil {
return kerr.Wrap("EELKQDCJGN", err)
}
info := shared.Info{
Path: env.Path,
Aliases: env.Aliases,
Data: data,
Package: pkgBytes,
PackageFilename: pkgFilename,
Imports: imports,
Hash: auth.Sign([]byte(env.Path)),
}
buf := bytes.NewBuffer([]byte{})
err = gob.NewEncoder(buf).Encode(info)
if err != nil {
return kerr.Wrap("OHBYTULHUQ", err)
}
base64EncodedString := base64.StdEncoding.EncodeToString(buf.Bytes())
attrib := base64EncodedString
source := []byte(`
<html>
<head>
<meta charset="utf-8">
<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
<link rel="stylesheet" href="/bootstrap/css/bootstrap-theme.min.css">
<link rel="stylesheet" href="/split.css">
<link rel="stylesheet" href="/editors.css">
<link rel="stylesheet" href="/tree.css">
<script src="/jquery-2.2.4.min.js"></script>
<script src="/jquery-ui/jquery-ui.min.js"></script>
<script src="/split.min.js"></script>
<script src="/bootstrap/js/bootstrap.min.js"></script>
<link rel="icon" type="image/png" href="data:image/png;base64,iVBORw0KGgo=">
</head>
<body id="body" info="` + attrib + `"></body>
<script src="/` + env.Path + `/script.js"></script>
</html>`)
if err := writeWithTimeout(w, source); err != nil {
return kerr.Wrap("ICJSAIMDRF", err)
}
return nil
}
