Port the ytt generator from SubChat

Co-authored-by: Kamikadze <40305144+Kam1k4dze@users.noreply.github.com>

Author: rexim

markut.go

@@ -1004,7 +1004,8 @@ var Subcommands = map[string]Subcommand{
 		Run: func(name string, args []string) bool {
 			chatFlag := flag.NewFlagSet(name, flag.ContinueOnError)
 			markutPtr := chatFlag.String("markut", "MARKUT", "Path to the MARKUT file")
-			csvPtr := chatFlag.Bool("csv", false, "Generate the chat using the stupid Twich Chat Downloader CSV format. You can then feed this output to tools like SubChat https://github.com/Kam1k4dze/SubChat")
+			csvPtr := chatFlag.Bool("csv", false, "Generate the chat in the stupid Twich Chat Downloader CSV format. You can then feed this output to tools like SubChat https://github.com/Kam1k4dze/SubChat")
+			yttPtr := chatFlag.Bool("ytt", false, "Generate the chat in ytt format using the SubChat's algorithm: https://github.com/Kam1k4dze/SubChat")
 
 			err := chatFlag.Parse(args)
 
@@ -1017,6 +1018,12 @@ var Subcommands = map[string]Subcommand{
 				return false
 			}
 
+			// It's kinda stupid, but I also want to kinda preserve backward compatibility with my reflexes - rexim
+			if *csvPtr && *yttPtr {
+				fmt.Printf("ERROR: -csv and -ytt cannot be enabled simultaneously\n")
+				return false
+			}
+
 			context, ok := defaultContext()
 			ok = ok && context.evalMarkutFile(nil, *markutPtr, false) && context.finishEval()
 			if !ok {
@@ -1035,6 +1042,32 @@ var Subcommands = map[string]Subcommand{
 					}
 					cursor += chunk.End - chunk.Start
 				}
+			} else if *yttPtr {
+				chat := []YttChatMessage{}
+				var cursor Millis = 0
+				for _, chunk := range context.chunks {
+					for _, messageGroup := range chunk.ChatLog {
+						timestamp := cursor + messageGroup.TimeOffset - chunk.Start
+						for _, message := range messageGroup.Messages {
+							chat = append(chat, YttChatMessage{
+								time: timestamp,
+								user: User{
+									name: message.Nickname,
+									color: parseHexColor(message.Color),
+								},
+								message: message.Text,
+							})
+						}
+					}
+					cursor += chunk.End - chunk.Start
+				}
+
+				params := DefaultChatParams
+				xml := generateXML(generateBatches(chat, params), params)
+				outputPath := "chat.ytt"
+				ioutil.WriteFile(outputPath, []byte(xml), 0644)
+				fmt.Printf("Generated %v\n", outputPath)
+				// fmt.Print(xml)
 			} else {
 				capacity := 1
 				ring := []ChatMessageGroup{}

xml.go

@@ -0,0 +1,131 @@
+// Mimics API of tinyxml2
+package main
+
+import (
+	"log"
+	"strings"
+)
+
+const XMLTrace = false
+
+type XMLDocument struct {
+	root XMLNode
+}
+
+type XMLNode interface {
+	Print(sb *strings.Builder, level int)
+}
+
+type XMLElement struct {
+	name string
+	attributes map[string]string
+	children []XMLNode
+}
+
+func (element *XMLElement) Print(sb *strings.Builder, level int) {
+	sb.WriteString("<")
+	sb.WriteString(element.name)
+	for name, value := range element.attributes {
+		sb.WriteString(" ")
+		sb.WriteString(name)
+		sb.WriteString("=")
+		sb.WriteString("\"")
+		WriteXmlEscapedStringIntoBuilder(sb, value)
+		sb.WriteString("\"")
+	}
+	if len(element.children) == 0 {
+		sb.WriteString("/>")
+		return
+	}
+	sb.WriteString(">")
+	for _, child := range element.children {
+		child.Print(sb, level + 1)
+	}
+	sb.WriteString("</")
+	sb.WriteString(element.name)
+	sb.WriteString(">")
+}
+
+type XMLText struct {
+	value string
+}
+
+func WriteXmlEscapedStringIntoBuilder(sb *strings.Builder, s string) {
+	for _, x := range s {
+		// https://stackoverflow.com/a/1091955
+		switch x {
+		case '"':	sb.WriteString("&quot;");
+		case '&':	sb.WriteString("&amp;");
+		case '\'':  sb.WriteString("&apos;");
+		case '<':	sb.WriteString("&lt;");
+		case '>':	sb.WriteString("&gt;");
+		default:    sb.WriteRune(x);
+		}
+	}
+}
+
+func (text *XMLText) Print(sb *strings.Builder, level int) {
+	WriteXmlEscapedStringIntoBuilder(sb, text.value)
+}
+
+func (doc *XMLDocument) NewElement(name string) *XMLElement {
+	if XMLTrace {
+		log.Printf("XMLTrace: XMLDocument.NewElement(name = %#v)\n", name)
+	}
+	element := new(XMLElement)
+	element.name = name
+	element.attributes = map[string]string{}
+	return element
+}
+
+func (doc *XMLDocument) NewText(value string) *XMLText {
+	if XMLTrace {
+		log.Printf("XMLTrace: XMLDocument.NewText(value = %#v)\n", value)
+	}
+	text := new(XMLText)
+	text.value = value
+	return text
+}
+
+func (doc *XMLDocument) InsertFirstChild(child XMLNode) {
+	if XMLTrace {
+		log.Printf("XMLTrace: XMLDocument.InsertFirstChild(child)\n")
+	}
+	doc.root = child
+}
+
+func (doc *XMLDocument) String() string {
+	sb := strings.Builder{}
+	doc.root.Print(&sb, 0)
+	return sb.String()
+}
+
+func (element *XMLElement) SetAttribute(name string, value string) {
+	if XMLTrace {
+		log.Printf("XMLTrace: XMLElement.SetAttribute(name = %#v, value = %#v)\n", name, value)
+	}
+	element.attributes[name] = value
+}
+
+func (element *XMLElement) SetText(value string) {
+	if XMLTrace {
+		log.Printf("XMLTrace: XMLElement.SetText(value = %#v)\n", value)
+	}
+	if len(element.children) > 0 {
+		panic("XMLElement.SetText: expected not children")
+	}
+	text := new(XMLText)
+	text.value = value
+	element.InsertEndChild(text)
+}
+
+func (element *XMLElement) InsertEndChild(child XMLNode) {
+	if XMLTrace {
+		log.Printf("XMLTrace: XMLElement.InsertEndChild(child)")
+	}
+	element.children = append(element.children, child)
+}
+
+func (element *XMLElement) LinkEndChild(child XMLNode) {
+	element.InsertEndChild(child)
+}