func scanForTypesAndExports(ctx context.Context, env *envctx.Env, cache *sysctx.SysPackageInfo, hash *PackageHasher) error {
// While we're scanning for types, we should use a custom unpacking env,
// because the env from the context is the one of the local package.
files := scanner.ScanDirToFiles(ctx, env.Dir, env.Recursive)
bytes := scanner.ScanFilesToBytes(ctx, files)
localContext := envctx.NewContext(ctx, env)
for b := range bytes {
if b.Err != nil {
return kerr.Wrap("JACKALTIGG", b.Err)
}
o := &system.ObjectStub{}
if err := system.Unmarshal(localContext, b.Bytes, o); err != nil {
return kerr.Wrap("HCYGNBDFFA", err)
}
if o.Type == nil {
return kerr.New("NUKWIHYFMQ", "%s has no type", b.File)
}
if o.Id == nil && *o.Type != *system.NewReference("kego.io/system", "package") {
// we tolerate missing ID only for system:package
return kerr.New("DLLMKTDYFW", "%s has no id", b.File)
}
relativeFile, err := filepath.Rel(env.Dir, b.File)
if err != nil {
return kerr.Wrap("AWYRJSCYQS", err)
}
switch *o.Type {
case *system.NewReference("kego.io/system", "type"):
if err := ProcessTypeFileBytes(ctx, env, relativeFile, b.Bytes, cache, hash); err != nil {
return kerr.Wrap("IVEFDDSKHE", err)
}
case *system.NewReference("kego.io/system", "package"):
cache.PackageBytes = b.Bytes
cache.PackageFilename = relativeFile
default:
cache.Globals.Set(o.Id.Name, relativeFile)
if o.Export {
cache.Exports.Set(o.Id.Name, o.Type.Name, o.Type.Package, b.Bytes)
if hash != nil {
hash.Exports[o.Id.Name+" "+o.Type.Name+" "+o.Type.Package] = cityhash.CityHash64(b.Bytes, uint32(len(b.Bytes)))
}
}
}
}
return nil
}
func TestNode_Label(t *testing.T) {
n := node.NewNode()
n.Parent = node.NewNode()
n.Key = ""
n.Value = ""
n.Index = -1
assert.Equal(t, "(?)", n.Label(context.Background()))
n.Index = 1
assert.Equal(t, "1", n.Label(context.Background()))
n.Value = &lab{}
assert.Equal(t, "b", n.Label(context.Background()))
n.Key = "a"
assert.Equal(t, "a", n.Label(context.Background()))
n.Value = &system.Object{Id: system.NewReference("a.b/c", "d")}
n.Parent = nil
assert.Equal(t, "d", n.Label(context.Background()))
n.Value = nil
assert.Equal(t, "root", n.Label(context.Background()))
n = nil
assert.Equal(t, "(nil)", n.Label(context.Background()))
}
func ProcessTypeFileBytes(ctx context.Context, env *envctx.Env, filename string, bytes []byte, cache *sysctx.SysPackageInfo, hash *PackageHasher) error {
t := new(system.Type)
if err := system.Unmarshal(envctx.NewContext(ctx, env), bytes, t); err != nil {
return kerr.Wrap("NLRRVIDVWM", err)
}
if hash != nil {
hash.Types[t.Id.Name] = cityhash.CityHash64(bytes, uint32(len(bytes)))
}
cache.Types.Set(t.Id.Name, filename, t)
cache.Files.Set(t.Id.Name, filename, bytes)
if t.Rule != nil {
id := system.NewReference(t.Id.Package, fmt.Sprint("@", t.Id.Name))
if t.Rule.Id != nil && *t.Rule.Id != *id {
return kerr.New("JKARKEDTIW", "Incorrect id for %v - it should be %v", t.Rule.Id.String(), id.String())
}
t.Rule.Id = id
// Check that the rule embeds system:rule
found := false
for _, em := range t.Rule.Embed {
if *em == *system.NewReference("kego.io/system", "rule") {
found = true
}
}
if !found {
return kerr.New("LMALEMKFDI", "%s does not embed system:rule", id.String())
}
cache.Types.Set(id.Name, filename, t.Rule)
} else {
// If the rule is missing, automatically create a default.
id := system.NewReference(t.Id.Package, fmt.Sprint("@", t.Id.Name))
rule := &system.Type{
Object: &system.Object{
Description: fmt.Sprintf("Automatically created basic rule for %s", t.Id.Name),
Type: system.NewReference("kego.io/system", "type"),
Id: id,
},
Embed: []*system.Reference{system.NewReference("kego.io/system", "rule")},
Native: system.NewString("object"),
Interface: false,
}
cache.Types.Set(id.Name, filename, rule)
}
return nil
}
func TestRuleWrapper_ZeroValue(t *testing.T) {
cb := tests.Context("kego.io/system").Jauto().Sauto(parser.Parse)
r := system.WrapRule(cb.Ctx(), &system.MapRule{
Object: &system.Object{Type: system.NewReference("kego.io/system", "@map")},
Rule: &system.Rule{},
Items: &system.StringRule{
Object: &system.Object{Type: system.NewReference("kego.io/system", "@string")},
Rule: &system.Rule{},
},
})
v, err := r.ZeroValue(true)
require.NoError(t, err)
assert.IsType(t, map[string]*system.String{}, v.Interface())
assert.Nil(t, v.Interface())
v, err = r.ZeroValue(false)
require.NoError(t, err)
assert.IsType(t, map[string]*system.String{}, v.Interface())
assert.NotNil(t, v.Interface())
vv := v.Interface().(map[string]*system.String)
vv["a"] = system.NewString("")
r = system.WrapRule(cb.Ctx(), &system.MapRule{
Object: &system.Object{Type: system.NewReference("kego.io/system", "@array")},
Rule: &system.Rule{},
Items: &system.StringRule{
Object: &system.Object{Type: system.NewReference("kego.io/system", "@string")},
Rule: &system.Rule{},
},
})
v, err = r.ZeroValue(true)
require.NoError(t, err)
assert.IsType(t, []*system.String{}, v.Interface())
assert.Nil(t, v.Interface())
v, err = r.ZeroValue(false)
require.NoError(t, err)
assert.IsType(t, []*system.String{}, v.Interface())
assert.NotNil(t, v.Interface())
va := v.Interface().([]*system.String)
va = append(va, system.NewString(""))
}
func TestKego(t *testing.T) {
ctx := ke.NewContext(context.Background(), "kego.io/system", nil)
_, err := ke.Open(ctx, "")
assert.IsError(t, err, "CXIULJCEBE")
systemDir, err := packages.GetDirFromPackage(ctx, "kego.io/system")
require.NoError(t, err)
i, err := ke.Open(ctx, filepath.Join(systemDir, "type.json"))
require.NoError(t, err)
_, ok := i.(*system.Type)
assert.True(t, ok)
b, err := ioutil.ReadFile(filepath.Join(systemDir, "type.json"))
require.NoError(t, err)
var i1 interface{}
err = ke.Unmarshal(ctx, b, &i1)
require.NoError(t, err)
_, ok = i1.(*system.Type)
assert.True(t, ok)
r := &system.Reference{}
err = ke.Unmarshal(ctx, []byte(`"type"`), r)
require.NoError(t, err)
assert.Equal(t, *system.NewReference("kego.io/system", "type"), *r)
b3, err := ke.Marshal(ctx, system.NewReference("kego.io/system", "type"))
require.NoError(t, err)
assert.Equal(t, "{\"type\":\"reference\",\"value\":\"type\"}", string(b3))
b4, err := ke.MarshalIndent(ctx, &system.Package{Recursive: true}, "", " ")
require.NoError(t, err)
assert.Equal(t, "{\n \"recursive\": true\n}", string(b4))
}
func mutateAppendBranch(s *BranchStore, p *node.Node, n *node.Node, name string, filename string) (child *models.BranchModel, parent *models.BranchModel, err error) {
var parentBranch *models.BranchModel
if p == nil {
if *n.Type.Id == *system.NewReference("kego.io/system", "type") {
parentBranch = s.types
} else {
parentBranch = s.data
}
} else {
var ok bool
if parentBranch, ok = s.nodeBranches[p]; !ok {
return nil, nil, nil
}
}
childBranch := s.AppendNodeBranchModelChild(parentBranch, n, name, filename)
return childBranch, parentBranch, nil
}
func TestNode_extractFields(t *testing.T) {
cb := tests.Context("a.b/c").Sempty()
ty := &system.Type{}
f := map[string]*system.Field{}
err := extractFields(cb.Ctx(), f, ty)
assert.IsError(t, err, "YRFWOTIGFT")
cb.Ssystem(parser.Parse)
ty = &system.Type{Embed: []*system.Reference{system.NewReference("a.b/c", "d")}}
err = extractFields(cb.Ctx(), f, ty)
assert.IsError(t, err, "SLIRILCARQ")
f = map[string]*system.Field{"a": nil}
ty = &system.Type{Fields: map[string]system.RuleInterface{"a": nil}}
err = extractFields(cb.Ctx(), f, ty)
assert.IsError(t, err, "BARXPFXQNB")
}
func Scan(ctx context.Context, path string) (*Package, error) {
p := new(Package)
// use a new system context for the duration of the scan
ctx = sysctx.NewContext(ctx)
env, err := parser.ScanForEnv(ctx, path)
if err != nil {
return nil, kerr.Wrap("SFPSTLPKMX", err)
}
p.Env = env
files := scanner.ScanDirToFiles(ctx, env.Dir, env.Recursive)
bytes := scanner.ScanFilesToBytes(ctx, files)
localContext := envctx.NewContext(ctx, env)
for b := range bytes {
f := new(File)
f.Package = p
if b.Err != nil {
return nil, kerr.Wrap("IPUHPBBWEA", b.Err)
}
o := &system.ObjectStub{}
if err := system.Unmarshal(localContext, b.Bytes, o); err != nil {
return nil, kerr.Wrap("DCAGIDLXRT", err)
}
if o.Type == nil {
return nil, kerr.New("AJPCEQTWPS", "%s has no type", b.File)
}
if o.Id == nil && *o.Type != *system.NewReference("kego.io/system", "package") {
// we tolerate missing ID only for system:package
return nil, kerr.New("YDKYLXTGYC", "%s has no id", b.File)
}
f.AbsoluteFilepath = b.File
f.Type = o.Type
f.Id = o.Id
if f.RelativeFilepath, err = filepath.Rel(env.Dir, b.File); err != nil {
return nil, kerr.Wrap("QDAEGOWTWP", err)
}
f.Directory, f.Filename = filepath.Split(b.File)
f.IsInRoot = DirEqual(f.Directory, env.Dir)
f.Extension = filepath.Ext(b.File)
f.Yaml = f.Extension == ".yaml" || f.Extension == ".yml"
p.Files = append(p.Files, f)
}
return p, nil
}
func newNonEmptyNode() *node.Node {
n := node.NewNode()
n.Parent = node.NewNode()
n.Array = []*node.Node{node.NewNode(), node.NewNode()}
n.Map = map[string]*node.Node{"a": node.NewNode(), "b": node.NewNode()}
n.Key = "a"
n.Index = 1
n.Origin = system.NewReference("a", "b")
n.ValueString = "a"
n.ValueNumber = 2.0
n.ValueBool = true
n.Value = "a"
n.Val = reflect.ValueOf("a")
n.Null = false
n.Missing = false
n.Rule = &system.RuleWrapper{}
n.Type = &system.Type{}
n.JsonType = system.J_OBJECT
return n
}
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 (v *Columns) Repack(ctx context.Context) (data interface{}, typePackage string, typeName string, jsonType system.JsonType, err error) {
if v == nil {
return nil, "kego.io/demo/site", "columns", system.J_NULL, nil
}
m := map[string]interface{}{}
if v.Object != nil {
ob, _, _, _, err := v.Object.Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
for key, val := range ob.(map[string]interface{}) {
m[key] = val
}
}
if v.Columns != nil {
ob0 := []interface{}{}
for i0 := range v.Columns {
var ob1 interface{}
ob1_value, pkg, name, typ, err := v.Columns[i0].(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/demo/site", "section") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob1 = map[string]interface{}{
"type": typeVal,
"value": ob1_value,
}
} else {
ob1 = ob1_value
}
ob0 = append(ob0, ob1)
}
m["columns"] = ob0
}
return m, "kego.io/demo/site", "columns", system.J_OBJECT, nil
}
func scanForPackage(ctx context.Context, env *envctx.Env) (*system.Package, error) {
localContext := envctx.NewContext(ctx, env)
files := scanner.ScanDirToFiles(ctx, env.Dir, false)
bytes := scanner.ScanFilesToBytes(ctx, files)
for b := range bytes {
if b.Err != nil {
return nil, kerr.Wrap("GATNNQKNHY", b.Err, b.File)
}
o := &system.ObjectStub{}
if err := system.Unmarshal(localContext, b.Bytes, o); err != nil {
switch kerr.Source(err).(type) {
case system.UnknownPackageError, system.UnknownTypeError:
// don't return error
default:
return nil, kerr.Wrap("MTDCXBYBEJ", err, b.File)
}
}
if o.Type == nil {
return nil, kerr.New("MSNIGTIDIO", "%s has no type", b.File)
}
switch *o.Type {
case *system.NewReference("kego.io/system", "package"):
var i interface{}
err := system.Unmarshal(localContext, b.Bytes, &i)
if err != nil {
switch kerr.Source(err).(type) {
case system.UnknownPackageError, system.UnknownTypeError:
// don't return error
default:
return nil, kerr.Wrap("XTEQCAYQJP", err)
}
}
if pkg, ok := i.(*system.Package); ok {
return pkg, nil
}
}
}
return nil, nil
}
func (v *D) Repack(ctx context.Context) (data interface{}, typePackage string, typeName string, jsonType system.JsonType, err error) {
if v == nil {
return nil, "kego.io/process/validate/tests", "d", system.J_NULL, nil
}
m := map[string]interface{}{}
if v.Object != nil {
ob, _, _, _, err := v.Object.Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
for key, val := range ob.(map[string]interface{}) {
m[key] = val
}
}
if v.A != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.A.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/process/validate/tests", "c") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["a"] = ob0
}
return m, "kego.io/process/validate/tests", "d", system.J_OBJECT, nil
}
func TestRuleWrapper_InnerType(t *testing.T) {
cb := tests.Context("kego.io/system").Jauto().Sauto(parser.Parse)
r := system.WrapRule(cb.Ctx(), &system.MapRule{
Object: &system.Object{Type: system.NewReference("kego.io/system", "@map")},
Rule: &system.Rule{},
Items: &system.StringRule{
Object: &system.Object{Type: system.NewReference("kego.io/system", "@string")},
Rule: &system.Rule{},
},
})
inner := r.InnerType(cb.Ctx())
assert.Equal(t, "kego.io/system:string", inner.Id.String())
kind, alias := r.Kind(cb.Ctx())
assert.False(t, alias)
assert.Equal(t, kind, system.KindMap)
assert.False(t, r.PassedAsPointer(cb.Ctx()))
r = system.WrapRule(cb.Ctx(), &system.DummyRule{
Object: &system.Object{Type: system.NewReference("kego.io/system", "@int")},
Rule: &system.Rule{},
})
assert.Equal(t, "kego.io/system:int", r.InnerType(cb.Ctx()).Id.String())
kind, alias = r.Kind(cb.Ctx())
assert.True(t, alias)
assert.Equal(t, kind, system.KindValue)
assert.True(t, r.PassedAsPointer(cb.Ctx()))
r = system.WrapRule(cb.Ctx(), &system.DummyRule{
Object: &system.Object{Type: system.NewReference("kego.io/system", "@int")},
Rule: &system.Rule{
Interface: true,
},
})
assert.Equal(t, "kego.io/system:int", r.InnerType(cb.Ctx()).Id.String())
kind, alias = r.Kind(cb.Ctx())
assert.False(t, alias)
assert.Equal(t, kind, system.KindInterface)
assert.False(t, r.PassedAsPointer(cb.Ctx()))
r = system.WrapRule(cb.Ctx(), &system.DummyRule{
Object: &system.Object{Type: system.NewReference("kego.io/json", "@string")},
Rule: &system.Rule{},
})
assert.Equal(t, "kego.io/json:string", r.InnerType(cb.Ctx()).Id.String())
assert.False(t, r.PassedAsPointer(cb.Ctx()))
r = system.WrapRule(cb.Ctx(), &system.DummyRule{
Object: &system.Object{Type: system.NewReference("kego.io/system", "@package")},
Rule: &system.Rule{},
})
assert.Equal(t, "kego.io/system:package", r.InnerType(cb.Ctx()).Id.String())
kind, alias = r.Kind(cb.Ctx())
assert.False(t, alias)
assert.Equal(t, kind, system.KindStruct)
assert.True(t, r.PassedAsPointer(cb.Ctx()))
}
func (v *ObjectEditorView) Render() *vecty.HTML {
sections := vecty.List{}
sections = append(sections,
views.NewPanelNavView(v.Ctx, v.branch).Contents(
func() vecty.MarkupOrComponentOrHTML {
return elem.UnorderedList(
prop.Class("nav navbar-nav navbar-right"),
elem.ListItem(
prop.Class("dropdown"),
elem.Anchor(
prop.Href("#"),
prop.Class("dropdown-toggle"),
vecty.Data("toggle", "dropdown"),
vecty.Property("role", "button"),
vecty.Property("aria-haspopup", "true"),
vecty.Property("aria-expanded", "false"),
vecty.Text("Options"),
elem.Span(
prop.Class("caret"),
),
),
elem.UnorderedList(
prop.Class("dropdown-menu"),
elem.ListItem(
elem.Anchor(
prop.Href("#"),
event.Click(func(ev *vecty.Event) {
v.App.Dispatch(&actions.ToggleSystemControls{
Node: v.model.Node,
})
}).PreventDefault(),
elem.Italic(
vecty.ClassMap{
"dropdown-icon": true,
"glyphicon": true,
"glyphicon-check": v.node.ShowSystemControls,
"glyphicon-unchecked": !v.node.ShowSystemControls,
},
),
vecty.Text("System controls"),
),
),
elem.ListItem(
prop.Class("divider"),
vecty.Property("role", "separator"),
),
elem.ListItem(
elem.Anchor(
prop.Href("#"),
vecty.Text("Delete"),
event.Click(func(e *vecty.Event) {
v.App.Dispatch(&actions.Delete{
Undoer: &actions.Undoer{},
Node: v.model.Node,
Parent: v.model.Node.Parent,
})
}).PreventDefault(),
),
),
),
),
)
},
),
)
d := v.model.Node.Map["description"]
if !d.Null && !d.Missing && d.ValueString != "" {
sections = append(sections, elem.Paragraph(
prop.Class("lead"),
vecty.Text(d.ValueString),
))
}
if v.App.Misc.Info() {
dt, err := v.node.Node.DisplayType(v.Ctx)
if err != nil {
v.App.Fail <- kerr.Wrap("KFKGCGFULR", err)
return nil
}
sections = append(sections,
elem.Paragraph(
prop.Class("lead"),
vecty.Text("type: "+dt),
),
)
}
if v.node.ShowSystemControls {
sections = append(sections,
elem.Div(
prop.Class("well object-editor"),
views.NewEditorListView(v.Ctx, v.model, system.NewReference("kego.io/system", "object"), []string{"id", "type"}),
),
)
}
return elem.Div(
sections,
)
}
func (s *FileStore) Handle(payload *flux.Payload) bool {
switch action := payload.Action.(type) {
case *actions.Add:
payload.Wait(s.app.Nodes)
if action.Parent != nil {
// only root nodes are files
break
}
switch action.Direction() {
case actions.New, actions.Redo:
n := action.Node
n.RecomputeHash(s.ctx, true)
fm := &models.FileModel{
Package: false,
Type: *action.Type.Id == *system.NewReference("kego.io/system", "type"),
Filename: action.BranchFile,
Node: n,
Hash: n.Hash(),
}
s.files[n] = fm
case actions.Undo:
delete(s.files, action.Node)
}
payload.Notify(nil, FileChangedStateChange)
case *actions.SaveFileSuccess:
for _, file := range action.Response.Files {
f := s.fileByName(file.File)
if f == nil {
s.app.Fail <- kerr.New("FPXNHFJNOR", "File %s not found", file.File)
}
f.SaveHash = file.Hash
}
payload.Notify(nil, FileChangedStateChange)
case *actions.InitialState:
payload.Wait(s.app.Nodes)
n := s.app.Package.Node()
fm := &models.FileModel{
Package: true,
Type: false,
Filename: s.app.Package.Filename(),
Node: n,
Hash: n.Hash(),
LoadHash: n.Hash(),
}
s.files[n] = fm
for _, ti := range s.app.Types.All() {
n := ti.Node
fm := &models.FileModel{
Package: false,
Type: true,
Filename: ti.File,
Node: n,
Hash: n.Hash(),
LoadHash: n.Hash(),
}
s.files[n] = fm
}
case *actions.LoadFileSuccess:
sci, ok := action.Branch.Contents.(models.FileContentsInterface)
if !ok {
break
}
n := sci.GetNode()
fm := &models.FileModel{
Package: false,
Type: false,
Filename: sci.GetFilename(),
Node: n,
Hash: n.Hash(),
LoadHash: n.Hash(),
}
s.files[n] = fm
}
if m, ok := payload.Action.(actions.Mutator); ok {
payload.Wait(s.app.Nodes)
n := m.CommonAncestor().Root()
f, ok := s.files[n]
if ok {
prevChanged := f.Changed()
f.Hash = n.Hash()
newChanged := f.Changed()
if prevChanged != newChanged {
// state changed!
payload.Notify(n, FileChangedStateChange)
}
}
}
return true
}
func (s *Server) Save(request *shared.SaveRequest, response *shared.SaveResponse) error {
if !s.auth.Auth([]byte(request.Path), request.Hash) {
return kerr.New("GIONMMGOWA", "Auth failed")
}
pkg, err := pkghelp.Scan(s.ctx, request.Path)
if err != nil {
return kerr.Wrap("YKYVDSDGNV", err)
}
localContext := envctx.NewContext(s.ctx, pkg.Env)
for _, info := range request.Files {
// Check we only have yml, yaml or json extension.
ext := filepath.Ext(info.File)
if ext != ".json" && ext != ".yml" && ext != ".yaml" {
return kerr.New("NDTPTCDOET", "Unsupported extension %s in %s", ext, info.File)
}
// Check the bytes are well formed json...
o := &system.ObjectStub{}
if err := system.Unmarshal(localContext, info.Bytes, o); err != nil {
return kerr.Wrap("QISVPOXTCJ", err)
}
// Check type field exists
if o.Type == nil {
return kerr.New("PHINYFTGEC", "%s has no type", info.File)
}
// Check id field exists apart from system:package type.
if o.Id == nil && *o.Type != *system.NewReference("kego.io/system", "package") {
return kerr.New("NNOEQPRQXS", "%s has no id", info.File)
}
// Convert output to YAML if needed.
output := info.Bytes
if ext == ".yaml" || ext == ".yml" {
var err error
if output, err = yaml.JSONToYAML(output); err != nil {
return kerr.Wrap("EAMEWSCAGB", err)
}
}
var mode os.FileMode
var full string
file := pkg.File(info.File)
if file != nil {
// The file already exists, so we should use the existing filemode
full = file.AbsoluteFilepath
fs, err := os.Stat(full)
if err != nil {
return kerr.Wrap("VLIJSSVSXU", err)
}
mode = fs.Mode()
} else {
if full, err = pkghelp.Check(pkg.Env.Dir, info.File, pkg.Env.Recursive); err != nil {
return kerr.Wrap("YSQEHPFIVF", err)
}
mode = 0644
if _, err := os.Stat(full); err == nil || !os.IsNotExist(err) {
return kerr.New("XOEPAUNCXB", "Can't overwrite %s - existing file is not a valid ke data file", info.File)
}
}
if err := ioutil.WriteFile(full, output, mode); err != nil {
return kerr.Wrap("KPDYGCYOYQ", err)
}
response.Files = append(response.Files, shared.SaveResponseFile{
File: info.File,
Hash: info.Hash,
})
}
return nil
}
func (v *Body) Repack(ctx context.Context) (data interface{}, typePackage string, typeName string, jsonType system.JsonType, err error) {
if v == nil {
return nil, "kego.io/demo/site", "body", system.J_NULL, nil
}
m := map[string]interface{}{}
if v.Object != nil {
ob, _, _, _, err := v.Object.Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
for key, val := range ob.(map[string]interface{}) {
m[key] = val
}
}
if v.Align != nil {
ob0, _, _, _, err := v.Align.Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
m["align"] = ob0
}
if v.Copy != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.Copy.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/system", "string") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["copy"] = ob0
}
if v.Title != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.Title.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/system", "string") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["title"] = ob0
}
return m, "kego.io/demo/site", "body", system.J_OBJECT, nil
}
func (v *Hero) Repack(ctx context.Context) (data interface{}, typePackage string, typeName string, jsonType system.JsonType, err error) {
if v == nil {
return nil, "kego.io/demo/site", "hero", system.J_NULL, nil
}
m := map[string]interface{}{}
if v.Object != nil {
ob, _, _, _, err := v.Object.Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
for key, val := range ob.(map[string]interface{}) {
m[key] = val
}
}
if v.Head != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.Head.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/system", "string") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["head"] = ob0
}
if v.Image != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.Image.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/demo/common/images", "image") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["image"] = ob0
}
if v.Subhead != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.Subhead.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/system", "string") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["subhead"] = ob0
}
return m, "kego.io/demo/site", "hero", system.J_OBJECT, nil
}