func testGenerated(t *testing.T, path string) { cb := tests.New().Path(path).Jauto().Sauto(parser.Parse) pi, err := parser.Parse(cb.Ctx(), path) require.NoError(t, err) generatedBytes, err := generate.Structs(cb.Ctx(), pi.Env) require.NoError(t, err) generatedString := string(generatedBytes) existingFilePath := filepath.Join(pi.Dir, "generated.go") existingBytes, err := ioutil.ReadFile(existingFilePath) require.NoError(t, err) existingString := string(existingBytes) // TODO: The "goimports" tool will often re-order the imports, so this is // a kludge to remove it before comparing. This is not ideal! importsRegex := regexp.MustCompile(`(?ms:\nimport \(\n.*\n\)\n)`) generatedString = importsRegex.ReplaceAllString(generatedString, "-") existingString = importsRegex.ReplaceAllString(existingString, "-") if generatedString != existingString { fmt.Println("Generated code for " + path + " is not what is present:") fmt.Println(generatedString) } require.Equal(t, generatedString, existingString) }
func Initialise(ctx context.Context, overrides OptionsInterface) (context.Context, context.CancelFunc, error) { if overrides == nil { overrides = Flags{} } options := overrides.getOptions() ctx, cancel := context.WithCancel(ctx) ctx = jsonctx.AutoContext(ctx) ctx = wgctx.NewContext(ctx) ctx = sysctx.NewContext(ctx) cmd := &cmdctx.Cmd{} vos := vosctx.FromContext(ctx) path := "" cmd.Edit = options.Edit cmd.Validate = options.Validate cmd.Update = options.Update cmd.Log = options.Log cmd.Debug = options.Debug cmd.Port = options.Port if options.Path == "" { dir, err := vos.Getwd() if err != nil { return nil, nil, kerr.Wrap("OKOLXAMBSJ", err) } p, err := packages.GetPackageFromDir(ctx, dir) if err != nil { return nil, nil, kerr.Wrap("ADNJKTLAWY", err) } path = p } else { path = options.Path } ctx = cmdctx.NewContext(ctx, cmd) pcache, err := parser.Parse(ctx, path) if err != nil { return nil, nil, kerr.Wrap("EBMBIBIKUF", err) } ctx = envctx.NewContext(ctx, pcache.Env) return ctx, cancel, nil }
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 }