494 lines
14 KiB
Go
494 lines
14 KiB
Go
package main
|
|
|
|
import (
|
|
_ "embed"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
"text/template"
|
|
|
|
"github.com/PuerkitoBio/goquery"
|
|
)
|
|
|
|
//go:embed class.tmpl
|
|
var templatestr string
|
|
var classTemplate *template.Template
|
|
|
|
var fns = template.FuncMap{
|
|
"plus1": func(x int) int {
|
|
return x + 1
|
|
},
|
|
}
|
|
|
|
func init() {
|
|
var err error
|
|
classTemplate, err = template.New("class").Funcs(fns).Parse(templatestr)
|
|
if err != nil {
|
|
Error.Printf("Error parsing template: %v", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
type (
|
|
Class struct {
|
|
ClassName string
|
|
Description string
|
|
Fields []Field
|
|
Methods []Method
|
|
Constructors []Constructor
|
|
}
|
|
Field struct {
|
|
Name string
|
|
Type string
|
|
Comment string
|
|
}
|
|
Method struct {
|
|
Name string
|
|
Params []Param
|
|
Returns []Return
|
|
Comment string
|
|
}
|
|
Param struct {
|
|
Name string
|
|
Type string
|
|
Comment string
|
|
}
|
|
Return struct {
|
|
Type string
|
|
Comment string
|
|
}
|
|
Constructor struct {
|
|
Params []Param
|
|
Returns string
|
|
Comment string
|
|
}
|
|
)
|
|
|
|
func (c *Class) GetOutFile(root string) (*os.File, error) {
|
|
if c.ClassName == "" {
|
|
return nil, fmt.Errorf("ClassName is empty")
|
|
}
|
|
filename := fmt.Sprintf("%s.lua", c.ClassName)
|
|
filename = strings.ReplaceAll(filename, " ", "")
|
|
filename = strings.ReplaceAll(filename, "-", "")
|
|
filename = strings.ReplaceAll(filename, ",", "")
|
|
filename = strings.ReplaceAll(filename, ":", "")
|
|
filePath := filepath.Join(root, filename)
|
|
filePath = filepath.Clean(filePath)
|
|
log.Printf("Writing file to '%s'", filePath)
|
|
f, err := os.Create(filePath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return f, nil
|
|
}
|
|
|
|
func (c *Class) Write(root string, tmpl *template.Template) error {
|
|
outfile, err := c.GetOutFile(root)
|
|
if err != nil {
|
|
return fmt.Errorf("error creating output file %v: %v", c.ClassName, err)
|
|
}
|
|
// spew.Dump(c)
|
|
err = tmpl.Execute(outfile, c)
|
|
if err != nil {
|
|
return fmt.Errorf("error writing output file %v: %v", c.ClassName, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ClassParser struct {
|
|
log *log.Logger
|
|
inputfile string
|
|
}
|
|
|
|
func NewClassParser(file string) *ClassParser {
|
|
return &ClassParser{
|
|
log: log.New(io.MultiWriter(os.Stdout, os.Stderr), fmt.Sprintf("%s[ClassParser] %s%s", GenerateRandomAnsiColor(), file, Reset), log.Lmicroseconds|log.Lshortfile),
|
|
inputfile: file,
|
|
}
|
|
}
|
|
|
|
func (p *ClassParser) Parse() (*Class, error) {
|
|
p.log.Printf("Parsing file: '%s'", p.inputfile)
|
|
res := Class{
|
|
Fields: []Field{},
|
|
Methods: []Method{},
|
|
Constructors: []Constructor{},
|
|
}
|
|
filehandle, err := os.Open(p.inputfile)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error opening file: %w", err)
|
|
}
|
|
defer filehandle.Close()
|
|
|
|
doc, err := goquery.NewDocumentFromReader(filehandle)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error parsing file: %w", err)
|
|
}
|
|
p.log.Printf("Document loaded")
|
|
|
|
dataContainer := doc.Find("div.floatright")
|
|
if dataContainer.Length() == 0 {
|
|
return nil, fmt.Errorf("no data container found")
|
|
}
|
|
p.log.Printf("Data container found")
|
|
|
|
className, err := p.getClassName(dataContainer)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error getting class name: %w", err)
|
|
}
|
|
res.ClassName = className
|
|
p.log.Printf("Class name resolved as '%s'", res.ClassName)
|
|
|
|
classDescription, err := p.getClassDescription(dataContainer)
|
|
if err == nil {
|
|
// return nil, fmt.Errorf("error getting class description: %w", err)
|
|
res.Description = classDescription
|
|
p.log.Printf("Class description resolved as '%s'", res.Description)
|
|
}
|
|
|
|
constructor, err := p.getConstructor(dataContainer)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error getting constructor: %w", err)
|
|
}
|
|
res.Constructors = append(res.Constructors, constructor)
|
|
p.log.Printf("Constructor resolved")
|
|
|
|
// Doing div+div specifically skips only the constructor which is usually the first div
|
|
// So the constructor would then be located at h1 + p + div OR h1 + div if there is no description (no p)
|
|
dataElements := dataContainer.ChildrenFiltered("div + div")
|
|
if dataElements.Length() == 0 {
|
|
return nil, fmt.Errorf("no data elements found")
|
|
}
|
|
p.log.Printf("Data elements (%d) found", dataElements.Length())
|
|
|
|
dataElements.Each(func(i int, s *goquery.Selection) {
|
|
id, ok := s.Attr("id")
|
|
if !ok {
|
|
return
|
|
}
|
|
if id == "Properties" {
|
|
s.Children().Each(func(i int, s *goquery.Selection) {
|
|
p.log.Printf("Parsing field")
|
|
field, err := p.parseField(s)
|
|
if err != nil {
|
|
Error.Printf("Error parsing field: %v", err)
|
|
return
|
|
}
|
|
res.Fields = append(res.Fields, field)
|
|
})
|
|
} else {
|
|
p.log.Printf("Parsing method")
|
|
method, err := p.parseMethod(s)
|
|
if err != nil {
|
|
Error.Printf("Error parsing method: %v", err)
|
|
return
|
|
}
|
|
res.Methods = append(res.Methods, method)
|
|
}
|
|
})
|
|
|
|
p.log.Printf("Class parsed")
|
|
return &res, nil
|
|
}
|
|
|
|
func (p *ClassParser) getClassName(dataContainer *goquery.Selection) (string, error) {
|
|
p.log.Printf("Getting class name")
|
|
class := dataContainer.ChildrenFiltered("h1")
|
|
if class.Length() == 0 {
|
|
return "", fmt.Errorf("no class found")
|
|
}
|
|
res := CleanUp(class.Text())
|
|
p.log.Printf("Class name resolved as '%s'", res)
|
|
return res, nil
|
|
}
|
|
|
|
var manySpaceRe = regexp.MustCompile(`\s{2,}`)
|
|
|
|
func (p *ClassParser) getClassDescription(dataContainer *goquery.Selection) (string, error) {
|
|
p.log.Printf("Getting class description")
|
|
class := dataContainer.ChildrenFiltered("h1 + p")
|
|
if class.Length() == 0 {
|
|
return "", fmt.Errorf("no class description found")
|
|
}
|
|
res := CleanUp(class.Text())
|
|
p.log.Printf("Class description resolved as '%s'", res)
|
|
return res, nil
|
|
}
|
|
|
|
func (p *ClassParser) getConstructor(dataContainer *goquery.Selection) (Constructor, error) {
|
|
resConstructor := Constructor{}
|
|
p.log.Printf("Getting constructor")
|
|
|
|
constructorBlock := dataContainer.Find("h1 + p + div")
|
|
if constructorBlock.Length() == 0 {
|
|
p.log.Printf("No constructor block found, trying fallback (h1 + div)")
|
|
constructorBlock = dataContainer.Find("h1 + div")
|
|
if constructorBlock.Length() == 0 {
|
|
return resConstructor, fmt.Errorf("no constructor found")
|
|
}
|
|
p.log.Printf("Fallback constructor block found")
|
|
}
|
|
|
|
types := constructorBlock.Find("div.function span.type")
|
|
if types.Length() == 0 {
|
|
return resConstructor, fmt.Errorf("no types found")
|
|
}
|
|
p.log.Printf("Constructor types found")
|
|
params := constructorBlock.Find("div.function span.parameter")
|
|
if params.Length() == 0 {
|
|
return resConstructor, fmt.Errorf("no params found")
|
|
}
|
|
p.log.Printf("Constructor params found")
|
|
|
|
types.Each(func(i int, s *goquery.Selection) {
|
|
resConstructor.Params = append(resConstructor.Params, Param{
|
|
Name: CleanUp(params.Eq(i).Text()),
|
|
Type: MapType(CleanUp(types.Eq(i).Text())),
|
|
Comment: "",
|
|
})
|
|
})
|
|
p.log.Printf("Constructor params resolved")
|
|
|
|
descriptor := constructorBlock.Find("div:not(.function)")
|
|
if descriptor.Length() == 0 {
|
|
return resConstructor, fmt.Errorf("no descriptor found")
|
|
}
|
|
p.log.Printf("Constructor descriptor found")
|
|
|
|
// 0 nothing
|
|
// 1 parameters
|
|
// 2 returns
|
|
state := 0
|
|
children := descriptor.Eq(0).Children()
|
|
childrenLength := children.Length()
|
|
children.Each(func(i int, s *goquery.Selection) {
|
|
if i == childrenLength-1 {
|
|
// For some stupid reason the last child is always a mispalced </p> tag that does not close any open <p>
|
|
// I assume this is a bug with their documentation generator
|
|
// So we just ignore it
|
|
return
|
|
}
|
|
text := CleanUp(s.Text())
|
|
if text == "" {
|
|
return
|
|
}
|
|
if s.Is("p") {
|
|
switch text {
|
|
case "Parameters":
|
|
state = 1
|
|
return
|
|
case "Returns":
|
|
state = 2
|
|
return
|
|
}
|
|
} else {
|
|
switch state {
|
|
case 0:
|
|
return
|
|
case 1:
|
|
param := s.ChildrenFiltered("span.parameter").Text()
|
|
paramTrimmed := CleanUp(param)
|
|
p.log.Printf("Parameter '%s' found", paramTrimmed)
|
|
for i := range resConstructor.Params {
|
|
cparam := &resConstructor.Params[i]
|
|
if paramTrimmed == cparam.Name {
|
|
cleanText := strings.TrimPrefix(text, param)
|
|
cparam.Comment = CleanUp(cleanText)
|
|
}
|
|
}
|
|
case 2:
|
|
cleaned := CleanUp(s.Text())
|
|
p.log.Printf("Return value '%s' found", cleaned)
|
|
if resConstructor.Returns != "" {
|
|
resConstructor.Returns += "\n"
|
|
}
|
|
resConstructor.Returns = cleaned
|
|
}
|
|
}
|
|
})
|
|
|
|
p.log.Printf("Constructor resolved")
|
|
// spew.Dump(resConstructor)
|
|
return resConstructor, nil
|
|
}
|
|
|
|
func (p *ClassParser) parseField(s *goquery.Selection) (Field, error) {
|
|
res := Field{}
|
|
p.log.Printf("Parsing field")
|
|
|
|
id, ok := s.Attr("id")
|
|
if !ok {
|
|
return res, fmt.Errorf("no id found")
|
|
}
|
|
res.Name = id
|
|
p.log.Printf("Field name resolved as '%s'", res.Name)
|
|
|
|
typeElement := s.Find("span.type")
|
|
if typeElement.Length() == 0 {
|
|
return res, fmt.Errorf("no type found")
|
|
}
|
|
res.Type = MapType(CleanUp(typeElement.Text()))
|
|
p.log.Printf("Field type resolved as '%s'", res.Type)
|
|
|
|
readonlyElement := s.Find("td[align='right']")
|
|
if readonlyElement.Length() != 0 {
|
|
// return res, fmt.Errorf("no readonly found")
|
|
res.Comment = CleanUp(readonlyElement.Text())
|
|
p.log.Printf("Field comment resolved as '%s'", res.Comment)
|
|
}
|
|
|
|
comments := s.ChildrenFiltered("div")
|
|
if comments.Length() == 0 {
|
|
return res, fmt.Errorf("no comments found")
|
|
}
|
|
comments.Each(func(i int, s *goquery.Selection) {
|
|
text := CleanUp(s.Text())
|
|
if text == "" {
|
|
return
|
|
}
|
|
p.log.Printf("Field comment resolved as '%s'", text)
|
|
if res.Comment != "" {
|
|
res.Comment += ". "
|
|
}
|
|
res.Comment += text
|
|
})
|
|
res.Comment = strings.ReplaceAll(res.Comment, "\n--", ". ")
|
|
|
|
p.log.Printf("Field resolved")
|
|
return res, nil
|
|
}
|
|
|
|
func (p *ClassParser) parseMethod(s *goquery.Selection) (Method, error) {
|
|
res := Method{}
|
|
p.log.Printf("Parsing method")
|
|
|
|
id, ok := s.Attr("id")
|
|
if !ok {
|
|
return res, fmt.Errorf("no id found")
|
|
}
|
|
res.Name = id
|
|
p.log.Printf("Method name resolved as '%s'", res.Name)
|
|
|
|
signatureData := s.Children().Eq(0)
|
|
returns := signatureData.Find("span.keyword")
|
|
if returns.Length() != 0 {
|
|
returnsText := CleanUp(returns.Text())
|
|
returnsText = strings.ReplaceAll(returnsText, "function", "")
|
|
returnsText = CleanUp(returnsText)
|
|
|
|
res.Returns = append(res.Returns, Return{
|
|
Type: MapType(returnsText),
|
|
Comment: "",
|
|
})
|
|
p.log.Printf("Method return value resolved as '%s'", res.Returns[0].Type)
|
|
}
|
|
|
|
types := signatureData.Find("span.type")
|
|
parameters := signatureData.Find("span.parameter")
|
|
types.Each(func(i int, s *goquery.Selection) {
|
|
res.Params = append(res.Params, Param{
|
|
Name: MapName(CleanUp(parameters.Eq(i).Text())),
|
|
Type: MapType(CleanUp(types.Eq(i).Text())),
|
|
Comment: "",
|
|
})
|
|
p.log.Printf("Method parameter resolved as '%s'", res.Params[i].Name)
|
|
})
|
|
|
|
// 0 nothing
|
|
// 1 parameters
|
|
// 2 returns
|
|
state := 0
|
|
signatureDetails := s.Children().Eq(1)
|
|
signatureDetailsChildren := signatureDetails.Children()
|
|
signatureDetailsChildrenLength := signatureDetailsChildren.Length()
|
|
signatureDetailsChildren.Each(func(i int, s *goquery.Selection) {
|
|
if s.Is("p") && i == 0 {
|
|
methodDescription := CleanUp(s.Text())
|
|
methodDescription = strings.ReplaceAll(methodDescription, "\n--", "<br>\n\t---")
|
|
res.Comment = methodDescription
|
|
p.log.Printf("Method description resolved as '%s'", res.Comment)
|
|
}
|
|
if i == signatureDetailsChildrenLength-1 {
|
|
// For some stupid reason the last child is always a mispalced </p> tag that does not close any open <p>
|
|
// I assume this is a bug with their documentation generator
|
|
// So we just ignore it
|
|
return
|
|
}
|
|
text := CleanUp(s.Text())
|
|
if text == "" {
|
|
return
|
|
}
|
|
if s.Is("p") {
|
|
switch text {
|
|
case "Parameters":
|
|
state = 1
|
|
case "Returns":
|
|
state = 2
|
|
return
|
|
}
|
|
} else {
|
|
if s.Is("div.indented") {
|
|
if state == 1 {
|
|
parameter := ""
|
|
html, err := s.Html()
|
|
if err != nil {
|
|
Error.Printf("Error parsing html: %v", err)
|
|
return
|
|
}
|
|
html = strings.ReplaceAll(html, "\t", "")
|
|
htmlLines := strings.Split(html, "\n")
|
|
for _, line := range htmlLines {
|
|
if strings.Contains(line, "<span class=\"parameter\">") {
|
|
line = strings.TrimSpace(line)
|
|
line = strings.ReplaceAll(line, "<span class=\"parameter\">", "")
|
|
line = strings.ReplaceAll(line, "</span>", "")
|
|
parameter = line
|
|
p.log.Printf("Parameter '%s' found", parameter)
|
|
continue
|
|
}
|
|
if strings.Contains(line, "<br/>") {
|
|
comment := strings.TrimSpace(line)
|
|
comment = strings.ReplaceAll(comment, "<br/>", "")
|
|
for i := range res.Params {
|
|
if res.Params[i].Name == parameter {
|
|
res.Params[i].Comment = comment
|
|
p.log.Printf("Parameter '%s' comment resolved as '%s'", parameter, comment)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if state == 2 {
|
|
text := CleanUp(s.Text())
|
|
if text == "" {
|
|
return
|
|
}
|
|
p.log.Printf("Return value comment '%s' found", text)
|
|
// TODO: Figure out what to do when a function
|
|
if res.Returns[0].Comment != "" {
|
|
res.Returns[0].Comment += "\n"
|
|
}
|
|
res.Returns[0].Comment += text
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
p.log.Printf("Method resolved")
|
|
return res, nil
|
|
}
|
|
|
|
func CleanUp(s string) string {
|
|
s = strings.TrimSpace(s)
|
|
s = strings.ReplaceAll(s, "\t", " ")
|
|
s = strings.ReplaceAll(s, "\n", "")
|
|
s = manySpaceRe.ReplaceAllString(s, " ")
|
|
s = strings.ReplaceAll(s, ". ", "\n--")
|
|
return s
|
|
}
|