mirror of
https://codeberg.org/june64/mrvc.git
synced 2026-01-10 16:06:33 +01:00
111 lines
3.4 KiB
Go
111 lines
3.4 KiB
Go
package output
|
|
|
|
import (
|
|
"fmt"
|
|
"slices"
|
|
"sort"
|
|
"strings"
|
|
|
|
"github.com/hashicorp/go-version"
|
|
|
|
"codeberg.org/june64/mrvc/roominfotree"
|
|
)
|
|
|
|
func compareVersionStrings(a, b string) int {
|
|
// Try to parse a and b as versions.
|
|
// Use only the first part of the version string as sometimes there are suffixes after a space, like " (<commit>)", which then can't be parsed.
|
|
aStart := strings.Split(a, " ")[0]
|
|
bStart := strings.Split(b, " ")[0]
|
|
aVersion, aErr := version.NewVersion(aStart)
|
|
bVersion, bErr := version.NewVersion(bStart)
|
|
// An input, which can't be parsed as a version, should be interpreted as being smaller than an input, which can be parsed as a version.
|
|
switch {
|
|
case aErr != nil && bErr == nil:
|
|
return -1
|
|
case aErr == nil && bErr != nil:
|
|
return 1
|
|
case aErr != nil && bErr != nil:
|
|
return strings.Compare(a, b)
|
|
}
|
|
|
|
if cmpResult := aVersion.Compare(bVersion); cmpResult != 0 {
|
|
return cmpResult
|
|
} else {
|
|
// When the versions are equal, look at the potential suffixes in the version string.
|
|
aEnd := strings.TrimPrefix(a, aStart)
|
|
bEnd := strings.TrimPrefix(b, bStart)
|
|
|
|
return strings.Compare(aEnd, bEnd)
|
|
}
|
|
}
|
|
|
|
func Print(roomInfoTree roominfotree.RoomInfoTree, outputHomeserverMemberCount bool) {
|
|
for roomID, roomInfo := range roomInfoTree {
|
|
fmt.Println("Room:")
|
|
fmt.Printf(" %s -> %d\n", roomID, roomInfo.MemberCount)
|
|
givenAliases := roomInfo.GivenAliases
|
|
if len(givenAliases) > 0 {
|
|
fmt.Println("Given Aliases:")
|
|
for _, alias := range givenAliases {
|
|
fmt.Printf(" %s\n", alias)
|
|
}
|
|
}
|
|
aliases := roomInfo.Aliases
|
|
if len(aliases) > 0 {
|
|
fmt.Println("Aliases:")
|
|
for _, alias := range aliases {
|
|
fmt.Printf(" %s\n", alias)
|
|
}
|
|
}
|
|
|
|
fmt.Println("Version Support:")
|
|
|
|
maxRoomVersionKeys := make([]string, 0, len(roomInfo.MaxRoomVersions))
|
|
for key := range roomInfo.MaxRoomVersions {
|
|
maxRoomVersionKeys = append(maxRoomVersionKeys, key)
|
|
}
|
|
slices.SortFunc(maxRoomVersionKeys, compareVersionStrings)
|
|
for _, maxRoomVersionKey := range maxRoomVersionKeys {
|
|
maxRoomVersionInfo := roomInfo.MaxRoomVersions[maxRoomVersionKey]
|
|
|
|
fmt.Printf(" %s -> %d\n", maxRoomVersionKey, maxRoomVersionInfo.MemberCount)
|
|
|
|
serverKeys := make([]string, 0, len(maxRoomVersionInfo.Servers))
|
|
for key := range maxRoomVersionInfo.Servers {
|
|
serverKeys = append(serverKeys, key)
|
|
}
|
|
sort.Strings(serverKeys)
|
|
for _, serverKey := range serverKeys {
|
|
serverInfo := maxRoomVersionInfo.Servers[serverKey]
|
|
|
|
fmt.Printf(" %s -> %d\n", serverKey, serverInfo.MemberCount)
|
|
|
|
versionKeys := make([]string, 0, len(serverInfo.Versions))
|
|
for key := range serverInfo.Versions {
|
|
versionKeys = append(versionKeys, key)
|
|
}
|
|
slices.SortFunc(versionKeys, compareVersionStrings)
|
|
for _, versionKey := range versionKeys {
|
|
versionInfo := serverInfo.Versions[versionKey]
|
|
|
|
fmt.Printf(" %s -> %d\n", versionKey, versionInfo.MemberCount)
|
|
|
|
if outputHomeserverMemberCount {
|
|
homeserverKeys := make([]string, 0, len(versionInfo.Homeservers))
|
|
for key := range versionInfo.Homeservers {
|
|
homeserverKeys = append(homeserverKeys, key)
|
|
}
|
|
sort.Strings(homeserverKeys)
|
|
for _, homeserverKey := range homeserverKeys {
|
|
homeserverInfo := versionInfo.Homeservers[homeserverKey]
|
|
|
|
fmt.Printf(" %s -> %d\n", homeserverKey, homeserverInfo.MemberCount)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fmt.Println()
|
|
}
|
|
}
|