1
0
mirror of https://github.com/osmarks/mycorrhiza.git synced 2024-12-13 14:00:25 +00:00
mycorrhiza/tree/tree.go
Elias Bomberger e4cd5e4a5f oops, missed a spot before
run gofmt, remove an unused bit
2021-10-22 22:15:48 -04:00

194 lines
5.2 KiB
Go

package tree
import (
"fmt"
"path"
"sort"
"strings"
"sync"
"github.com/bouncepaw/mycorrhiza/hyphae"
"github.com/bouncepaw/mycorrhiza/util"
)
func findSiblings(hyphaName string) []*sibling {
hyphaDir := ""
if hyphaRawDir := path.Dir(hyphaName); hyphaRawDir != "." {
hyphaDir = hyphaRawDir
}
var (
siblingsMap = make(map[string]bool)
siblingCheck = func(h *hyphae.Hypha) hyphae.CheckResult {
// I don't like this double comparison, but it is only the way to circumvent some flickups
if strings.HasPrefix(h.Name, hyphaDir) && h.Name != hyphaDir && h.Name != hyphaName {
var (
rawSubPath = strings.TrimPrefix(h.Name, hyphaDir)[1:]
slashIdx = strings.IndexRune(rawSubPath, '/')
)
if slashIdx > -1 {
var sibPath = h.Name[:slashIdx+len(hyphaDir)+1]
if _, exists := siblingsMap[sibPath]; !exists {
siblingsMap[sibPath] = false
}
} else { // it is a straight sibling
siblingsMap[h.Name] = true
}
}
return hyphae.CheckContinue
}
i7n = hyphae.NewIteration()
)
siblingsMap[hyphaName] = true
i7n.AddCheck(siblingCheck)
i7n.Ignite()
siblings := make([]*sibling, len(siblingsMap))
sibIdx := 0
for sibName, exists := range siblingsMap {
siblings[sibIdx] = &sibling{sibName, 0, 0, exists}
sibIdx++
}
sort.Slice(siblings, func(i, j int) bool {
return siblings[i].name < siblings[j].name
})
return siblings
}
func countSubhyphae(siblings []*sibling) {
var (
subhyphaCheck = func(h *hyphae.Hypha) hyphae.CheckResult {
for _, s := range siblings {
if path.Dir(h.Name) == s.name {
s.directSubhyphaeCount++
return hyphae.CheckContinue
} else if strings.HasPrefix(h.Name, s.name+"/") {
s.indirectSubhyphaeCount++
return hyphae.CheckContinue
}
}
return hyphae.CheckContinue
}
i7n = hyphae.NewIteration()
)
i7n.AddCheck(subhyphaCheck)
i7n.Ignite()
}
// Tree generates a tree for `hyphaName` as html and returns next and previous hyphae if any.
func Tree(hyphaName string) (siblingsHTML, childrenHTML, prev, next string) {
children := make([]child, 0)
I := 0
// The tree is generated in two iterations of hyphae storage:
// 1. Find all siblings (sorted)
// 2. Count how many subhyphae siblings have
//
// We also have to figure out what is going on with the descendants: who is a child of whom. We do that in parallel with (2) because we can.
// One of the siblings is the hypha with name `hyphaName`
var siblings []*sibling
wg := sync.WaitGroup{}
wg.Add(2)
go func() {
siblings = findSiblings(hyphaName)
countSubhyphae(siblings)
wg.Done()
}()
go func() {
children = figureOutChildren(hyphaName).children
wg.Done()
}()
wg.Wait()
for i, s := range siblings {
if s.name == hyphaName {
I = i
siblingsHTML += fmt.Sprintf(`<li class="sibling-hyphae__entry sibling-hyphae__entry_this"><span>%s</span></li>`, util.BeautifulName(path.Base(hyphaName)))
} else {
siblingsHTML += siblingHTML(s)
}
}
if I != 0 && len(siblings) > 1 {
prev = siblings[I-1].name
}
if I != len(siblings)-1 && len(siblings) > 1 {
next = siblings[I+1].name
}
return fmt.Sprintf(`<ul class="sibling-hyphae__list">%s</ul>`, siblingsHTML), subhyphaeMatrix(children), prev, next
}
type child struct {
name string
exists bool
children []child
}
func figureOutChildren(hyphaName string) child {
var (
descPrefix = hyphaName + "/"
child = child{hyphaName, true, make([]child, 0)}
)
for desc := range hyphae.YieldExistingHyphae() {
var descName = desc.Name
if strings.HasPrefix(descName, descPrefix) {
var subPath = strings.TrimPrefix(descName, descPrefix)
addHyphaToChild(descName, subPath, &child)
}
}
return child
}
func addHyphaToChild(hyphaName, subPath string, child *child) {
// when hyphaName = "root/a/b", subPath = "a/b", and child.name = "root"
// addHyphaToChild("root/a/b", "b", child{"root/a"})
// when hyphaName = "root/a/b", subPath = "b", and child.name = "root/a"
// set .exists=true for "root/a/b", and create it if it isn't there already
var exists = !strings.Contains(subPath, "/")
if exists {
var subchild = findOrCreateSubchild(subPath, child)
subchild.exists = true
} else {
var (
firstSlash = strings.IndexRune(subPath, '/')
firstDir = subPath[:firstSlash]
restOfPath = subPath[firstSlash+1:]
subchild = findOrCreateSubchild(firstDir, child)
)
addHyphaToChild(hyphaName, restOfPath, subchild)
}
}
func findOrCreateSubchild(name string, baseChild *child) *child {
// when name = "a", and baseChild.name = "root"
// if baseChild.children contains "root/a", return it
// else create it and return that
var fullName = baseChild.name + "/" + name
for i := range baseChild.children {
if baseChild.children[i].name == fullName {
return &baseChild.children[i]
}
}
baseChild.children = append(baseChild.children, child{fullName, false, make([]child, 0)})
return &baseChild.children[len(baseChild.children)-1]
}
type sibling struct {
name string
directSubhyphaeCount int
indirectSubhyphaeCount int
exists bool
}
func subhyphaeMatrix(children []child) (html string) {
sort.Slice(children, func(i, j int) bool {
return children[i].name < children[j].name
})
for _, child := range children {
html += childHTML(&child)
}
return html
}