mirror of
https://github.com/osmarks/mycorrhiza.git
synced 2024-12-13 14:00:25 +00:00
e4cd5e4a5f
run gofmt, remove an unused bit
194 lines
5.2 KiB
Go
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
|
|
}
|