mirror of
https://github.com/go-gitea/gitea
synced 2024-07-07 10:35:48 +00:00
* Use vendored go-swagger * vendor go-swagger * revert un wanteed change * remove un-needed GO111MODULE * Update Makefile Co-Authored-By: techknowlogick <matti@mdranta.net>
118 lines
3.0 KiB
Go
118 lines
3.0 KiB
Go
package parser
|
|
|
|
import "github.com/hashicorp/hcl/hcl/ast"
|
|
|
|
// flattenObjects takes an AST node, walks it, and flattens
|
|
func flattenObjects(node ast.Node) {
|
|
ast.Walk(node, func(n ast.Node) (ast.Node, bool) {
|
|
// We only care about lists, because this is what we modify
|
|
list, ok := n.(*ast.ObjectList)
|
|
if !ok {
|
|
return n, true
|
|
}
|
|
|
|
// Rebuild the item list
|
|
items := make([]*ast.ObjectItem, 0, len(list.Items))
|
|
frontier := make([]*ast.ObjectItem, len(list.Items))
|
|
copy(frontier, list.Items)
|
|
for len(frontier) > 0 {
|
|
// Pop the current item
|
|
n := len(frontier)
|
|
item := frontier[n-1]
|
|
frontier = frontier[:n-1]
|
|
|
|
switch v := item.Val.(type) {
|
|
case *ast.ObjectType:
|
|
items, frontier = flattenObjectType(v, item, items, frontier)
|
|
case *ast.ListType:
|
|
items, frontier = flattenListType(v, item, items, frontier)
|
|
default:
|
|
items = append(items, item)
|
|
}
|
|
}
|
|
|
|
// Reverse the list since the frontier model runs things backwards
|
|
for i := len(items)/2 - 1; i >= 0; i-- {
|
|
opp := len(items) - 1 - i
|
|
items[i], items[opp] = items[opp], items[i]
|
|
}
|
|
|
|
// Done! Set the original items
|
|
list.Items = items
|
|
return n, true
|
|
})
|
|
}
|
|
|
|
func flattenListType(
|
|
ot *ast.ListType,
|
|
item *ast.ObjectItem,
|
|
items []*ast.ObjectItem,
|
|
frontier []*ast.ObjectItem) ([]*ast.ObjectItem, []*ast.ObjectItem) {
|
|
// If the list is empty, keep the original list
|
|
if len(ot.List) == 0 {
|
|
items = append(items, item)
|
|
return items, frontier
|
|
}
|
|
|
|
// All the elements of this object must also be objects!
|
|
for _, subitem := range ot.List {
|
|
if _, ok := subitem.(*ast.ObjectType); !ok {
|
|
items = append(items, item)
|
|
return items, frontier
|
|
}
|
|
}
|
|
|
|
// Great! We have a match go through all the items and flatten
|
|
for _, elem := range ot.List {
|
|
// Add it to the frontier so that we can recurse
|
|
frontier = append(frontier, &ast.ObjectItem{
|
|
Keys: item.Keys,
|
|
Assign: item.Assign,
|
|
Val: elem,
|
|
LeadComment: item.LeadComment,
|
|
LineComment: item.LineComment,
|
|
})
|
|
}
|
|
|
|
return items, frontier
|
|
}
|
|
|
|
func flattenObjectType(
|
|
ot *ast.ObjectType,
|
|
item *ast.ObjectItem,
|
|
items []*ast.ObjectItem,
|
|
frontier []*ast.ObjectItem) ([]*ast.ObjectItem, []*ast.ObjectItem) {
|
|
// If the list has no items we do not have to flatten anything
|
|
if ot.List.Items == nil {
|
|
items = append(items, item)
|
|
return items, frontier
|
|
}
|
|
|
|
// All the elements of this object must also be objects!
|
|
for _, subitem := range ot.List.Items {
|
|
if _, ok := subitem.Val.(*ast.ObjectType); !ok {
|
|
items = append(items, item)
|
|
return items, frontier
|
|
}
|
|
}
|
|
|
|
// Great! We have a match go through all the items and flatten
|
|
for _, subitem := range ot.List.Items {
|
|
// Copy the new key
|
|
keys := make([]*ast.ObjectKey, len(item.Keys)+len(subitem.Keys))
|
|
copy(keys, item.Keys)
|
|
copy(keys[len(item.Keys):], subitem.Keys)
|
|
|
|
// Add it to the frontier so that we can recurse
|
|
frontier = append(frontier, &ast.ObjectItem{
|
|
Keys: keys,
|
|
Assign: item.Assign,
|
|
Val: subitem.Val,
|
|
LeadComment: item.LeadComment,
|
|
LineComment: item.LineComment,
|
|
})
|
|
}
|
|
|
|
return items, frontier
|
|
}
|