f41c281e43
The themes are still going to be a little broken for a while, but here's the progress I've made. Renamed the topics_trow_assign hook to topics_topic_row_assign. Added more debug code to the generated router. Added a robots.txt file. Gosora now responds to favicon.ico requests with a 404 rather than the topic list. Fixed the tests and some of the benchmarks. Changed the default UserCacheCapacity from 100 to 120. Changed the default TopicCacheCapacity from 100 to 200. Added the last replyer to the topics list and the forum pages. Added the BulkCascadeGetMap method to the UserStore. Refactored the topics list and forum page to load the users with a call to the UserStore rather than via a join. WebSockets now work on SSL. Fixed a race condition when the user permissions are initialised at the start of a request. Fixed a race condition when the user permissions for the OP of a topic are initialised. The rows.Close() calls are deferred once more, so that we can catch problems with recover() Improved support for struct pointers in the template compiler. Added a pin emoji to pinned topics to make them stand-out on the Shadow theme, we have some other ideas in mind for this, but I'd like to get Shadow fully functional for this commit. Fixed a bug an issue with Chrome not detecting XHTML style closes on <form>s. Fixed a visual issue with `color` not being set for textarea elements for the Shadow theme. Fixed a function which wasn't getting renamed for PGSQL. Added seven new UserStore tests.
1060 lines
30 KiB
Go
1060 lines
30 KiB
Go
package main
|
|
|
|
import (
|
|
"log"
|
|
"fmt"
|
|
"bytes"
|
|
"strings"
|
|
"strconv"
|
|
//"regexp"
|
|
"reflect"
|
|
"path/filepath"
|
|
"io/ioutil"
|
|
"text/template/parse"
|
|
)
|
|
|
|
// TO-DO: Turn this file into a library
|
|
var ctemplates []string
|
|
var tmpl_ptr_map map[string]interface{} = make(map[string]interface{})
|
|
var text_overlap_list map[string]int
|
|
|
|
func init() {
|
|
text_overlap_list = make(map[string]int)
|
|
}
|
|
|
|
type VarItem struct
|
|
{
|
|
Name string
|
|
Destination string
|
|
Type string
|
|
}
|
|
|
|
type VarItemReflect struct
|
|
{
|
|
Name string
|
|
Destination string
|
|
Value reflect.Value
|
|
}
|
|
|
|
type CTemplateSet struct
|
|
{
|
|
tlist map[string]*parse.Tree
|
|
dir string
|
|
funcMap map[string]interface{}
|
|
importMap map[string]string
|
|
Fragments map[string]int
|
|
FragmentCursor map[string]int
|
|
FragOut string
|
|
varList map[string]VarItem
|
|
localVars map[string]map[string]VarItemReflect
|
|
stats map[string]int
|
|
pVarList string
|
|
pVarPosition int
|
|
previousNode parse.NodeType
|
|
currentNode parse.NodeType
|
|
nextNode parse.NodeType
|
|
//tempVars map[string]string
|
|
doImports bool
|
|
expectsInt interface{}
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_template(name string, dir string, expects string, expectsInt interface{}, varList map[string]VarItem) (out string) {
|
|
if dev.DebugMode {
|
|
fmt.Println("Compiling template '" + name + "'")
|
|
}
|
|
|
|
c.dir = dir
|
|
c.doImports = true
|
|
c.funcMap = map[string]interface{}{
|
|
"and": "&&",
|
|
"not": "!",
|
|
"or": "||",
|
|
"eq": true,
|
|
"ge": true,
|
|
"gt": true,
|
|
"le": true,
|
|
"lt": true,
|
|
"ne": true,
|
|
"add": true,
|
|
"subtract": true,
|
|
"multiply": true,
|
|
"divide": true,
|
|
}
|
|
|
|
c.importMap = map[string]string{
|
|
"io":"io",
|
|
}
|
|
c.varList = varList
|
|
//c.pVarList = ""
|
|
//c.pVarPosition = 0
|
|
c.stats = make(map[string]int)
|
|
c.expectsInt = expectsInt
|
|
holdreflect := reflect.ValueOf(expectsInt)
|
|
|
|
res, err := ioutil.ReadFile(dir + name)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
content := string(res)
|
|
if config.MinifyTemplates {
|
|
content = minify(content)
|
|
}
|
|
|
|
tree := parse.New(name, c.funcMap)
|
|
var treeSet map[string]*parse.Tree = make(map[string]*parse.Tree)
|
|
tree, err = tree.Parse(content,"{{","}}", treeSet, c.funcMap)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
if dev.SuperDebug {
|
|
fmt.Println(name)
|
|
}
|
|
|
|
out = ""
|
|
fname := strings.TrimSuffix(name, filepath.Ext(name))
|
|
c.tlist = make(map[string]*parse.Tree)
|
|
c.tlist[fname] = tree
|
|
varholder := "tmpl_" + fname + "_vars"
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println(c.tlist)
|
|
}
|
|
c.localVars = make(map[string]map[string]VarItemReflect)
|
|
c.localVars[fname] = make(map[string]VarItemReflect)
|
|
c.localVars[fname]["."] = VarItemReflect{".",varholder,holdreflect}
|
|
if c.Fragments == nil {
|
|
c.Fragments = make(map[string]int)
|
|
}
|
|
c.FragmentCursor = make(map[string]int)
|
|
c.FragmentCursor[fname] = 0
|
|
|
|
subtree := c.tlist[fname]
|
|
if dev.SuperDebug {
|
|
fmt.Println(subtree.Root)
|
|
}
|
|
|
|
treeLength := len(subtree.Root.Nodes)
|
|
for index, node := range subtree.Root.Nodes {
|
|
if dev.SuperDebug {
|
|
fmt.Println("Node: " + node.String())
|
|
}
|
|
|
|
c.previousNode = c.currentNode
|
|
c.currentNode = node.Type()
|
|
if treeLength != (index + 1) {
|
|
c.nextNode = subtree.Root.Nodes[index + 1].Type()
|
|
}
|
|
out += c.compile_switch(varholder, holdreflect, fname, node)
|
|
}
|
|
|
|
var importList string
|
|
if c.doImports {
|
|
for _, item := range c.importMap {
|
|
importList += "import \"" + item + "\"\n"
|
|
}
|
|
}
|
|
|
|
var varString string
|
|
for _, varItem := range c.varList {
|
|
varString += "var " + varItem.Name + " " + varItem.Type + " = " + varItem.Destination + "\n"
|
|
}
|
|
|
|
fout := "// Code generated by Gosora. More below:\n/* This file was automatically generated by the software. Please don't edit it as your changes may be overwritten at any moment. */\n"
|
|
fout += "// +build !no_templategen\npackage main\n" + importList + c.pVarList + "\n"
|
|
fout += "func init() {\n\ttemplate_" + fname +"_handle = template_" + fname + "\n\t//o_template_" + fname +"_handle = template_" + fname + "\n\tctemplates = append(ctemplates,\"" + fname + "\")\n\ttmpl_ptr_map[\"" + fname + "\"] = &template_" + fname + "_handle\n\ttmpl_ptr_map[\"o_" + fname + "\"] = template_" + fname + "\n}\n\n"
|
|
fout += "func template_" + fname + "(tmpl_" + fname + "_vars " + expects + ", w io.Writer) {\n" + varString + out + "}\n"
|
|
|
|
fout = strings.Replace(fout,`))
|
|
w.Write([]byte(`," + ",-1)
|
|
fout = strings.Replace(fout,"` + `","",-1)
|
|
//spstr := "`([:space:]*)`"
|
|
//whitespace_writes := regexp.MustCompile(`(?s)w.Write\(\[\]byte\(`+spstr+`\)\)`)
|
|
//fout = whitespace_writes.ReplaceAllString(fout,"")
|
|
|
|
if dev.DebugMode {
|
|
for index, count := range c.stats {
|
|
fmt.Println(index + ": " + strconv.Itoa(count))
|
|
}
|
|
fmt.Println(" ")
|
|
}
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("Output!")
|
|
fmt.Println(fout)
|
|
}
|
|
return fout
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_switch(varholder string, holdreflect reflect.Value, template_name string, node interface{}) (out string) {
|
|
if dev.SuperDebug {
|
|
fmt.Println("in compile_switch")
|
|
}
|
|
switch node := node.(type) {
|
|
case *parse.ActionNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Action Node")
|
|
}
|
|
if node.Pipe == nil {
|
|
break
|
|
}
|
|
for _, cmd := range node.Pipe.Cmds {
|
|
out += c.compile_subswitch(varholder, holdreflect, template_name, cmd)
|
|
}
|
|
return out
|
|
case *parse.IfNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("If Node:")
|
|
fmt.Println("node.Pipe",node.Pipe)
|
|
}
|
|
|
|
var expr string
|
|
for _, cmd := range node.Pipe.Cmds {
|
|
if dev.SuperDebug {
|
|
fmt.Println("If Node Bit:",cmd)
|
|
fmt.Println("If Node Bit Type:",reflect.ValueOf(cmd).Type().Name())
|
|
}
|
|
expr += c.compile_varswitch(varholder, holdreflect, template_name, cmd)
|
|
if dev.SuperDebug {
|
|
fmt.Println("If Node Expression Step:",c.compile_varswitch(varholder, holdreflect, template_name, cmd))
|
|
}
|
|
}
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("If Node Expression:",expr)
|
|
}
|
|
|
|
c.previousNode = c.currentNode
|
|
c.currentNode = parse.NodeList
|
|
c.nextNode = -1
|
|
if node.ElseList == nil {
|
|
if dev.SuperDebug {
|
|
fmt.Println("Selected Branch 1")
|
|
}
|
|
return "if " + expr + " {\n" + c.compile_switch(varholder, holdreflect, template_name, node.List) + "}\n"
|
|
} else {
|
|
if dev.SuperDebug {
|
|
fmt.Println("Selected Branch 2")
|
|
}
|
|
return "if " + expr + " {\n" + c.compile_switch(varholder, holdreflect, template_name, node.List) + "} else {\n" + c.compile_switch(varholder, holdreflect, template_name, node.ElseList) + "}\n"
|
|
}
|
|
case *parse.ListNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("List Node")
|
|
}
|
|
for _, subnode := range node.Nodes {
|
|
out += c.compile_switch(varholder, holdreflect, template_name, subnode)
|
|
}
|
|
return out
|
|
case *parse.RangeNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Range Node!")
|
|
fmt.Println(node.Pipe)
|
|
}
|
|
|
|
var outVal reflect.Value
|
|
for _, cmd := range node.Pipe.Cmds {
|
|
if dev.SuperDebug {
|
|
fmt.Println("Range Bit:",cmd)
|
|
}
|
|
out, outVal = c.compile_reflectswitch(varholder, holdreflect, template_name, cmd)
|
|
}
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("Returned:",out)
|
|
fmt.Println("Range Kind Switch!")
|
|
}
|
|
|
|
switch outVal.Kind() {
|
|
case reflect.Map:
|
|
var item reflect.Value
|
|
for _, key := range outVal.MapKeys() {
|
|
item = outVal.MapIndex(key)
|
|
}
|
|
|
|
if node.ElseList != nil {
|
|
out = "if len(" + out + ") != 0 {\nfor _, item := range " + out + " {\n" + c.compile_switch("item", item, template_name, node.List) + "}\n} else {\n" + c.compile_switch("item", item, template_name, node.ElseList) + "}\n"
|
|
} else {
|
|
out = "if len(" + out + ") != 0 {\nfor _, item := range " + out + " {\n" + c.compile_switch("item", item, template_name, node.List) + "}\n}"
|
|
}
|
|
case reflect.Slice:
|
|
if outVal.Len() == 0 {
|
|
panic("The sample data needs at-least one or more elements for the slices. We're looking into removing this requirement at some point!")
|
|
}
|
|
item := outVal.Index(0)
|
|
out = "if len(" + out + ") != 0 {\nfor _, item := range " + out + " {\n" + c.compile_switch("item", item, template_name, node.List) + "}\n}"
|
|
case reflect.Invalid:
|
|
return ""
|
|
}
|
|
|
|
if node.ElseList != nil {
|
|
out += " else {\n" + c.compile_switch(varholder, holdreflect, template_name, node.ElseList) + "}\n"
|
|
} else {
|
|
out += "\n"
|
|
}
|
|
return out
|
|
case *parse.TemplateNode:
|
|
return c.compile_subtemplate(varholder, holdreflect, node)
|
|
case *parse.TextNode:
|
|
c.previousNode = c.currentNode
|
|
c.currentNode = node.Type()
|
|
c.nextNode = 0
|
|
tmpText := bytes.TrimSpace(node.Text)
|
|
if len(tmpText) == 0 {
|
|
return ""
|
|
} else {
|
|
//return "w.Write([]byte(`" + string(node.Text) + "`))\n"
|
|
fragment_name := template_name + "_" + strconv.Itoa(c.FragmentCursor[template_name])
|
|
_, ok := c.Fragments[fragment_name]
|
|
if !ok {
|
|
c.Fragments[fragment_name] = len(node.Text)
|
|
c.FragOut += "var " + fragment_name + " []byte = []byte(`" + string(node.Text) + "`)\n"
|
|
}
|
|
c.FragmentCursor[template_name] = c.FragmentCursor[template_name] + 1
|
|
return "w.Write(" + fragment_name + ")\n"
|
|
}
|
|
default:
|
|
panic("Unknown Node in main switch")
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_subswitch(varholder string, holdreflect reflect.Value, template_name string, node *parse.CommandNode) (out string) {
|
|
if dev.SuperDebug {
|
|
fmt.Println("in compile_subswitch")
|
|
}
|
|
firstWord := node.Args[0]
|
|
switch n := firstWord.(type) {
|
|
case *parse.FieldNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Field Node:",n.Ident)
|
|
}
|
|
|
|
/* Use reflect to determine if the field is for a method, otherwise assume it's a variable. Variable declarations are coming soon! */
|
|
cur := holdreflect
|
|
|
|
var varbit string
|
|
if cur.Kind() == reflect.Interface {
|
|
cur = cur.Elem()
|
|
varbit += ".(" + cur.Type().Name() + ")"
|
|
}
|
|
|
|
for _, id := range n.Ident {
|
|
if dev.SuperDebug {
|
|
fmt.Println("Data Kind:",cur.Kind().String())
|
|
fmt.Println("Field Bit:",id)
|
|
}
|
|
|
|
if cur.Kind() == reflect.Ptr {
|
|
if dev.SuperDebug {
|
|
fmt.Println("Looping over pointer")
|
|
}
|
|
for cur.Kind() == reflect.Ptr {
|
|
cur = cur.Elem()
|
|
}
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("Data Kind:",cur.Kind().String())
|
|
fmt.Println("Field Bit:",id)
|
|
}
|
|
}
|
|
|
|
if !cur.IsValid() {
|
|
panic(varholder + varbit + "^\n" + "Invalid value. Maybe, it doesn't exist?")
|
|
}
|
|
|
|
cur = cur.FieldByName(id)
|
|
if cur.Kind() == reflect.Interface {
|
|
cur = cur.Elem()
|
|
// TO-DO: Surely, there's a better way of detecting this?
|
|
/*if cur.Kind() == reflect.String && cur.Type().Name() != "string" {
|
|
varbit = "string(" + varbit + "." + id + ")"*/
|
|
//if cur.Kind() == reflect.String && cur.Type().Name() != "string" {
|
|
if cur.Type().PkgPath() != "main" && cur.Type().PkgPath() != "" {
|
|
c.importMap["html/template"] = "html/template"
|
|
varbit += "." + id + ".(" + strings.TrimPrefix(cur.Type().PkgPath(),"html/") + "." + cur.Type().Name() + ")"
|
|
} else {
|
|
varbit += "." + id + ".(" + cur.Type().Name() + ")"
|
|
}
|
|
} else {
|
|
varbit += "." + id
|
|
}
|
|
if dev.SuperDebug {
|
|
fmt.Println("End Cycle")
|
|
}
|
|
}
|
|
out = c.compile_varsub(varholder + varbit, cur)
|
|
|
|
for _, varItem := range c.varList {
|
|
if strings.HasPrefix(out, varItem.Destination) {
|
|
out = strings.Replace(out, varItem.Destination, varItem.Name, 1)
|
|
}
|
|
}
|
|
return out
|
|
case *parse.DotNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Dot Node:",node.String())
|
|
}
|
|
return c.compile_varsub(varholder, holdreflect)
|
|
case *parse.NilNode:
|
|
panic("Nil is not a command x.x")
|
|
case *parse.VariableNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Variable Node:",n.String())
|
|
fmt.Println(n.Ident)
|
|
}
|
|
varname, reflectVal := c.compile_if_varsub(n.String(), varholder, template_name, holdreflect)
|
|
return c.compile_varsub(varname, reflectVal)
|
|
case *parse.StringNode:
|
|
return n.Quoted
|
|
case *parse.IdentifierNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Identifier Node:",node)
|
|
fmt.Println("Identifier Node Args:",node.Args)
|
|
}
|
|
return c.compile_varsub(c.compile_identswitch(varholder, holdreflect, template_name, node))
|
|
default:
|
|
fmt.Println("Unknown Kind:",reflect.ValueOf(firstWord).Elem().Kind())
|
|
fmt.Println("Unknown Type:",reflect.ValueOf(firstWord).Elem().Type().Name())
|
|
panic("I don't know what node this is")
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_varswitch(varholder string, holdreflect reflect.Value, template_name string, node *parse.CommandNode) (out string) {
|
|
if dev.SuperDebug {
|
|
fmt.Println("in compile_varswitch")
|
|
}
|
|
firstWord := node.Args[0]
|
|
switch n := firstWord.(type) {
|
|
case *parse.FieldNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Field Node:",n.Ident)
|
|
for _, id := range n.Ident {
|
|
fmt.Println("Field Bit:",id)
|
|
}
|
|
}
|
|
|
|
/* Use reflect to determine if the field is for a method, otherwise assume it's a variable. Coming Soon. */
|
|
return c.compile_boolsub(n.String(), varholder, template_name, holdreflect)
|
|
case *parse.ChainNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Chain Node:",n.Node)
|
|
fmt.Println("Chain Node Args:",node.Args)
|
|
}
|
|
break
|
|
case *parse.IdentifierNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Identifier Node:",node)
|
|
fmt.Println("Identifier Node Args:",node.Args)
|
|
}
|
|
return c.compile_identswitch_n(varholder, holdreflect, template_name, node)
|
|
case *parse.DotNode:
|
|
return varholder
|
|
case *parse.VariableNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Variable Node:",n.String())
|
|
fmt.Println("Variable Node Identifier:",n.Ident)
|
|
}
|
|
out, _ = c.compile_if_varsub(n.String(), varholder, template_name, holdreflect)
|
|
return out
|
|
case *parse.NilNode:
|
|
panic("Nil is not a command x.x")
|
|
case *parse.PipeNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Pipe Node!")
|
|
fmt.Println(n)
|
|
fmt.Println("Args:",node.Args)
|
|
}
|
|
out += c.compile_identswitch_n(varholder, holdreflect, template_name, node)
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("Out:",out)
|
|
}
|
|
return out
|
|
default:
|
|
fmt.Println("Unknown Kind:",reflect.ValueOf(firstWord).Elem().Kind())
|
|
fmt.Println("Unknown Type:",reflect.ValueOf(firstWord).Elem().Type().Name())
|
|
panic("I don't know what node this is! Grr...")
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_identswitch_n(varholder string, holdreflect reflect.Value, template_name string, node *parse.CommandNode) (out string) {
|
|
if dev.SuperDebug {
|
|
fmt.Println("in compile_identswitch_n")
|
|
}
|
|
out, _ = c.compile_identswitch(varholder, holdreflect, template_name, node)
|
|
return out
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_identswitch(varholder string, holdreflect reflect.Value, template_name string, node *parse.CommandNode) (out string, val reflect.Value) {
|
|
if dev.SuperDebug {
|
|
fmt.Println("in compile_identswitch")
|
|
}
|
|
|
|
//var outbuf map[int]string
|
|
ArgLoop:
|
|
for pos := 0; pos < len(node.Args); pos++ {
|
|
id := node.Args[pos]
|
|
if dev.SuperDebug {
|
|
fmt.Println("pos:",pos)
|
|
fmt.Println("ID:",id)
|
|
}
|
|
switch id.String() {
|
|
case "not":
|
|
out += "!"
|
|
case "or":
|
|
if dev.SuperDebug {
|
|
fmt.Println("Building or function")
|
|
}
|
|
if pos == 0 {
|
|
fmt.Println("pos:",pos)
|
|
panic("or is missing a left operand")
|
|
return out, val
|
|
}
|
|
if len(node.Args) <= pos {
|
|
fmt.Println("post pos:",pos)
|
|
fmt.Println("len(node.Args):",len(node.Args))
|
|
panic("or is missing a right operand")
|
|
return out, val
|
|
}
|
|
|
|
left := c.compile_boolsub(node.Args[pos - 1].String(), varholder, template_name, holdreflect)
|
|
_, funcExists := c.funcMap[node.Args[pos + 1].String()]
|
|
|
|
var right string
|
|
if !funcExists {
|
|
right = c.compile_boolsub(node.Args[pos + 1].String(), varholder, template_name, holdreflect)
|
|
}
|
|
|
|
out += left + " || " + right
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("Left operand:",node.Args[pos - 1])
|
|
fmt.Println("Right operand:",node.Args[pos + 1])
|
|
}
|
|
|
|
if !funcExists {
|
|
pos++
|
|
}
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("pos:",pos)
|
|
fmt.Println("len(node.Args):",len(node.Args))
|
|
}
|
|
case "and":
|
|
if dev.SuperDebug {
|
|
fmt.Println("Building and function")
|
|
}
|
|
if pos == 0 {
|
|
fmt.Println("pos:",pos)
|
|
panic("and is missing a left operand")
|
|
return out, val
|
|
}
|
|
if len(node.Args) <= pos {
|
|
fmt.Println("post pos:",pos)
|
|
fmt.Println("len(node.Args):",len(node.Args))
|
|
panic("and is missing a right operand")
|
|
return out, val
|
|
}
|
|
|
|
left := c.compile_boolsub(node.Args[pos - 1].String(), varholder, template_name, holdreflect)
|
|
_, funcExists := c.funcMap[node.Args[pos + 1].String()]
|
|
|
|
var right string
|
|
if !funcExists {
|
|
right = c.compile_boolsub(node.Args[pos + 1].String(), varholder, template_name, holdreflect)
|
|
}
|
|
|
|
out += left + " && " + right
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("Left operand:",node.Args[pos - 1])
|
|
fmt.Println("Right operand:",node.Args[pos + 1])
|
|
}
|
|
|
|
if !funcExists {
|
|
pos++
|
|
}
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("pos:",pos)
|
|
fmt.Println("len(node.Args):",len(node.Args))
|
|
}
|
|
case "le":
|
|
out += c.compile_if_varsub_n(node.Args[pos + 1].String(), varholder, template_name, holdreflect) + " <= " + c.compile_if_varsub_n(node.Args[pos + 2].String(), varholder, template_name, holdreflect)
|
|
if dev.SuperDebug {
|
|
fmt.Println(node.Args[pos + 1])
|
|
fmt.Println(node.Args[pos + 2])
|
|
}
|
|
break ArgLoop
|
|
case "lt":
|
|
out += c.compile_if_varsub_n(node.Args[pos + 1].String(), varholder, template_name, holdreflect) + " < " + c.compile_if_varsub_n(node.Args[pos + 2].String(), varholder, template_name, holdreflect)
|
|
if dev.SuperDebug {
|
|
fmt.Println(node.Args[pos + 1])
|
|
fmt.Println(node.Args[pos + 2])
|
|
}
|
|
break ArgLoop
|
|
case "gt":
|
|
out += c.compile_if_varsub_n(node.Args[pos + 1].String(), varholder, template_name, holdreflect) + " > " + c.compile_if_varsub_n(node.Args[pos + 2].String(), varholder, template_name, holdreflect)
|
|
if dev.SuperDebug {
|
|
fmt.Println(node.Args[pos + 1])
|
|
fmt.Println(node.Args[pos + 2])
|
|
}
|
|
break ArgLoop
|
|
case "ge":
|
|
out += c.compile_if_varsub_n(node.Args[pos + 1].String(), varholder, template_name, holdreflect) + " >= " + c.compile_if_varsub_n(node.Args[pos + 2].String(), varholder, template_name, holdreflect)
|
|
if dev.SuperDebug {
|
|
fmt.Println(node.Args[pos + 1])
|
|
fmt.Println(node.Args[pos + 2])
|
|
}
|
|
break ArgLoop
|
|
case "eq":
|
|
out += c.compile_if_varsub_n(node.Args[pos + 1].String(), varholder, template_name, holdreflect) + " == " + c.compile_if_varsub_n(node.Args[pos + 2].String(), varholder, template_name, holdreflect)
|
|
if dev.SuperDebug {
|
|
fmt.Println(node.Args[pos + 1])
|
|
fmt.Println(node.Args[pos + 2])
|
|
}
|
|
break ArgLoop
|
|
case "ne":
|
|
out += c.compile_if_varsub_n(node.Args[pos + 1].String(), varholder, template_name, holdreflect) + " != " + c.compile_if_varsub_n(node.Args[pos + 2].String(), varholder, template_name, holdreflect)
|
|
if dev.SuperDebug {
|
|
fmt.Println(node.Args[pos + 1])
|
|
fmt.Println(node.Args[pos + 2])
|
|
}
|
|
break ArgLoop
|
|
case "add":
|
|
param1, val2 := c.compile_if_varsub(node.Args[pos + 1].String(), varholder, template_name, holdreflect)
|
|
param2, val3 := c.compile_if_varsub(node.Args[pos + 2].String(), varholder, template_name, holdreflect)
|
|
|
|
if val2.IsValid() {
|
|
val = val2
|
|
} else if val3.IsValid() {
|
|
val = val3
|
|
} else {
|
|
numSample := 1
|
|
val = reflect.ValueOf(numSample)
|
|
}
|
|
|
|
out += param1 + " + " + param2
|
|
if dev.SuperDebug {
|
|
fmt.Println("add")
|
|
fmt.Println(node.Args[pos + 1])
|
|
fmt.Println(node.Args[pos + 2])
|
|
}
|
|
break ArgLoop
|
|
case "subtract":
|
|
param1, val2 := c.compile_if_varsub(node.Args[pos + 1].String(), varholder, template_name, holdreflect)
|
|
param2, val3 := c.compile_if_varsub(node.Args[pos + 2].String(), varholder, template_name, holdreflect)
|
|
|
|
if val2.IsValid() {
|
|
val = val2
|
|
} else if val3.IsValid() {
|
|
val = val3
|
|
} else {
|
|
numSample := 1
|
|
val = reflect.ValueOf(numSample)
|
|
}
|
|
|
|
out += param1 + " - " + param2
|
|
if dev.SuperDebug {
|
|
fmt.Println("subtract")
|
|
fmt.Println(node.Args[pos + 1])
|
|
fmt.Println(node.Args[pos + 2])
|
|
}
|
|
break ArgLoop
|
|
case "divide":
|
|
param1, val2 := c.compile_if_varsub(node.Args[pos + 1].String(), varholder, template_name, holdreflect)
|
|
param2, val3 := c.compile_if_varsub(node.Args[pos + 2].String(), varholder, template_name, holdreflect)
|
|
|
|
if val2.IsValid() {
|
|
val = val2
|
|
} else if val3.IsValid() {
|
|
val = val3
|
|
} else {
|
|
numSample := 1
|
|
val = reflect.ValueOf(numSample)
|
|
}
|
|
|
|
out += param1 + " / " + param2
|
|
if dev.SuperDebug {
|
|
fmt.Println("divide")
|
|
fmt.Println(node.Args[pos + 1])
|
|
fmt.Println(node.Args[pos + 2])
|
|
}
|
|
break ArgLoop
|
|
case "multiply":
|
|
param1, val2 := c.compile_if_varsub(node.Args[pos + 1].String(), varholder, template_name, holdreflect)
|
|
param2, val3 := c.compile_if_varsub(node.Args[pos + 2].String(), varholder, template_name, holdreflect)
|
|
|
|
if val2.IsValid() {
|
|
val = val2
|
|
} else if val3.IsValid() {
|
|
val = val3
|
|
} else {
|
|
numSample := 1
|
|
val = reflect.ValueOf(numSample)
|
|
}
|
|
|
|
out += param1 + " * " + param2
|
|
if dev.SuperDebug {
|
|
fmt.Println("multiply")
|
|
fmt.Println(node.Args[pos + 1])
|
|
fmt.Println(node.Args[pos + 2])
|
|
}
|
|
break ArgLoop
|
|
default:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Variable!")
|
|
}
|
|
if len(node.Args) > (pos + 1) {
|
|
next_node := node.Args[pos + 1].String()
|
|
if next_node == "or" || next_node == "and" {
|
|
continue
|
|
}
|
|
}
|
|
out += c.compile_if_varsub_n(id.String(), varholder, template_name, holdreflect)
|
|
}
|
|
}
|
|
|
|
//for _, outval := range outbuf {
|
|
// out += outval
|
|
//}
|
|
return out, val
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_reflectswitch(varholder string, holdreflect reflect.Value, template_name string, node *parse.CommandNode) (out string, outVal reflect.Value) {
|
|
if dev.SuperDebug {
|
|
fmt.Println("in compile_reflectswitch")
|
|
}
|
|
firstWord := node.Args[0]
|
|
switch n := firstWord.(type) {
|
|
case *parse.FieldNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Field Node:",n.Ident)
|
|
for _, id := range n.Ident {
|
|
fmt.Println("Field Bit:",id)
|
|
}
|
|
}
|
|
/* Use reflect to determine if the field is for a method, otherwise assume it's a variable. Coming Soon. */
|
|
return c.compile_if_varsub(n.String(), varholder, template_name, holdreflect)
|
|
case *parse.ChainNode:
|
|
if dev.SuperDebug {
|
|
fmt.Println("Chain Node: ")
|
|
fmt.Println(n.Node)
|
|
fmt.Println(node.Args)
|
|
}
|
|
return "", outVal
|
|
case *parse.DotNode:
|
|
return varholder, holdreflect
|
|
case *parse.NilNode:
|
|
panic("Nil is not a command x.x")
|
|
default:
|
|
//panic("I don't know what node this is")
|
|
}
|
|
return "", outVal
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_if_varsub_n(varname string, varholder string, template_name string, cur reflect.Value) (out string) {
|
|
if dev.SuperDebug {
|
|
fmt.Println("in compile_if_varsub_n")
|
|
}
|
|
out, _ = c.compile_if_varsub(varname, varholder, template_name, cur)
|
|
return out
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_if_varsub(varname string, varholder string, template_name string, cur reflect.Value) (out string, val reflect.Value) {
|
|
if dev.SuperDebug {
|
|
fmt.Println("in compile_if_varsub")
|
|
}
|
|
if varname[0] != '.' && varname[0] != '$' {
|
|
return varname, cur
|
|
}
|
|
|
|
bits := strings.Split(varname,".")
|
|
if varname[0] == '$' {
|
|
var res VarItemReflect
|
|
if varname[1] == '.' {
|
|
res = c.localVars[template_name]["."]
|
|
} else {
|
|
res = c.localVars[template_name][strings.TrimPrefix(bits[0],"$")]
|
|
}
|
|
out += res.Destination
|
|
cur = res.Value
|
|
|
|
if cur.Kind() == reflect.Interface {
|
|
cur = cur.Elem()
|
|
}
|
|
} else {
|
|
if cur.Kind() == reflect.Interface {
|
|
cur = cur.Elem()
|
|
out += varholder + ".(" + cur.Type().Name() + ")"
|
|
} else {
|
|
out += varholder
|
|
}
|
|
}
|
|
bits[0] = strings.TrimPrefix(bits[0],"$")
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("Cur Kind:",cur.Kind())
|
|
fmt.Println("Cur Type:",cur.Type().Name())
|
|
}
|
|
|
|
for _, bit := range bits {
|
|
if dev.SuperDebug {
|
|
fmt.Println("Variable Field!")
|
|
fmt.Println(bit)
|
|
}
|
|
if bit == "" {
|
|
continue
|
|
}
|
|
|
|
// TO-DO: Fix this up so that it works for regular pointers and not just struct pointers. Ditto for the other cur.Kind() == reflect.Ptr we have in this file
|
|
if cur.Kind() == reflect.Ptr {
|
|
if dev.SuperDebug {
|
|
fmt.Println("Looping over pointer")
|
|
}
|
|
for cur.Kind() == reflect.Ptr {
|
|
cur = cur.Elem()
|
|
}
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("Data Kind:",cur.Kind().String())
|
|
fmt.Println("Field Bit:",bit)
|
|
}
|
|
}
|
|
|
|
cur = cur.FieldByName(bit)
|
|
if cur.Kind() == reflect.Interface {
|
|
cur = cur.Elem()
|
|
out += "." + bit + ".(" + cur.Type().Name() + ")"
|
|
} else {
|
|
out += "." + bit
|
|
}
|
|
|
|
if !cur.IsValid() {
|
|
panic(out + "^\n" + "Invalid value. Maybe, it doesn't exist?")
|
|
}
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("Data Kind:",cur.Kind())
|
|
fmt.Println("Data Type:",cur.Type().Name())
|
|
}
|
|
}
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("Out Value:",out)
|
|
fmt.Println("Out Kind:",cur.Kind())
|
|
fmt.Println("Out Type:",cur.Type().Name())
|
|
}
|
|
|
|
for _, varItem := range c.varList {
|
|
if strings.HasPrefix(out, varItem.Destination) {
|
|
out = strings.Replace(out, varItem.Destination, varItem.Name, 1)
|
|
}
|
|
}
|
|
|
|
if dev.SuperDebug {
|
|
fmt.Println("Out Value:",out)
|
|
fmt.Println("Out Kind:",cur.Kind())
|
|
fmt.Println("Out Type:",cur.Type().Name())
|
|
}
|
|
|
|
_, ok := c.stats[out]
|
|
if ok {
|
|
c.stats[out]++
|
|
} else {
|
|
c.stats[out] = 1
|
|
}
|
|
|
|
return out, cur
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_boolsub(varname string, varholder string, template_name string, val reflect.Value) string {
|
|
if dev.SuperDebug {
|
|
fmt.Println("in compile_boolsub")
|
|
}
|
|
out, val := c.compile_if_varsub(varname, varholder, template_name, val)
|
|
switch val.Kind() {
|
|
case reflect.Int: out += " > 0"
|
|
case reflect.Bool: // Do nothing
|
|
case reflect.String: out += " != \"\""
|
|
case reflect.Int64: out += " > 0"
|
|
default:
|
|
fmt.Println("Variable Name:",varname)
|
|
fmt.Println("Variable Holder:",varholder)
|
|
fmt.Println("Variable Kind:",val.Kind())
|
|
panic("I don't know what this variable's type is o.o\n")
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_varsub(varname string, val reflect.Value) string {
|
|
if dev.SuperDebug {
|
|
fmt.Println("in compile_varsub")
|
|
}
|
|
for _, varItem := range c.varList {
|
|
if strings.HasPrefix(varname, varItem.Destination) {
|
|
varname = strings.Replace(varname, varItem.Destination, varItem.Name, 1)
|
|
}
|
|
}
|
|
|
|
_, ok := c.stats[varname]
|
|
if ok {
|
|
c.stats[varname]++
|
|
} else {
|
|
c.stats[varname] = 1
|
|
}
|
|
|
|
if val.Kind() == reflect.Interface {
|
|
val = val.Elem()
|
|
}
|
|
|
|
switch val.Kind() {
|
|
case reflect.Int:
|
|
c.importMap["strconv"] = "strconv"
|
|
return "w.Write([]byte(strconv.Itoa(" + varname + ")))\n"
|
|
case reflect.Bool:
|
|
return "if " + varname + " {\nw.Write([]byte(\"true\"))} else {\nw.Write([]byte(\"false\"))\n}\n"
|
|
case reflect.String:
|
|
if val.Type().Name() != "string" && !strings.HasPrefix(varname,"string(") {
|
|
return "w.Write([]byte(string(" + varname + ")))\n"
|
|
} else {
|
|
return "w.Write([]byte(" + varname + "))\n"
|
|
}
|
|
case reflect.Int64:
|
|
c.importMap["strconv"] = "strconv"
|
|
return "w.Write([]byte(strconv.FormatInt(" + varname + ", 10)))"
|
|
default:
|
|
if !val.IsValid() {
|
|
panic(varname + "^\n" + "Invalid value. Maybe, it doesn't exist?")
|
|
}
|
|
fmt.Println("Unknown Variable Name:",varname)
|
|
fmt.Println("Unknown Kind:",val.Kind())
|
|
fmt.Println("Unknown Type:",val.Type().Name())
|
|
panic("// I don't know what this variable's type is o.o\n")
|
|
}
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_subtemplate(pvarholder string, pholdreflect reflect.Value, node *parse.TemplateNode) (out string) {
|
|
if dev.SuperDebug {
|
|
fmt.Println("in compile_subtemplate")
|
|
fmt.Println("Template Node: " + node.Name)
|
|
}
|
|
|
|
fname := strings.TrimSuffix(node.Name, filepath.Ext(node.Name))
|
|
varholder := "tmpl_" + fname + "_vars"
|
|
var holdreflect reflect.Value
|
|
if node.Pipe != nil {
|
|
for _, cmd := range node.Pipe.Cmds {
|
|
firstWord := cmd.Args[0]
|
|
switch firstWord.(type) {
|
|
case *parse.DotNode:
|
|
varholder = pvarholder
|
|
holdreflect = pholdreflect
|
|
break
|
|
case *parse.NilNode:
|
|
panic("Nil is not a command x.x")
|
|
default:
|
|
out = "var " + varholder + " := false\n"
|
|
out += c.compile_command(cmd)
|
|
}
|
|
}
|
|
}
|
|
|
|
res, err := ioutil.ReadFile(c.dir + node.Name)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
content := string(res)
|
|
if config.MinifyTemplates {
|
|
content = minify(content)
|
|
}
|
|
|
|
tree := parse.New(node.Name, c.funcMap)
|
|
var treeSet map[string]*parse.Tree = make(map[string]*parse.Tree)
|
|
tree, err = tree.Parse(content,"{{","}}", treeSet, c.funcMap)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
c.tlist[fname] = tree
|
|
subtree := c.tlist[fname]
|
|
if dev.SuperDebug {
|
|
fmt.Println(subtree.Root)
|
|
}
|
|
|
|
c.localVars[fname] = make(map[string]VarItemReflect)
|
|
c.localVars[fname]["."] = VarItemReflect{".",varholder,holdreflect}
|
|
c.FragmentCursor[fname] = 0
|
|
|
|
treeLength := len(subtree.Root.Nodes)
|
|
for index, node := range subtree.Root.Nodes {
|
|
if dev.SuperDebug {
|
|
fmt.Println("Node:",node.String())
|
|
}
|
|
|
|
c.previousNode = c.currentNode
|
|
c.currentNode = node.Type()
|
|
if treeLength != (index + 1) {
|
|
c.nextNode = subtree.Root.Nodes[index + 1].Type()
|
|
}
|
|
out += c.compile_switch(varholder, holdreflect, fname, node)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (c *CTemplateSet) compile_command(*parse.CommandNode) (out string) {
|
|
panic("Uh oh! Something went wrong!")
|
|
return ""
|
|
}
|
|
|
|
// TO-DO: Write unit tests for this
|
|
func minify(data string) string {
|
|
data = strings.Replace(data,"\t","",-1)
|
|
data = strings.Replace(data,"\v","",-1)
|
|
data = strings.Replace(data,"\n","",-1)
|
|
data = strings.Replace(data,"\r","",-1)
|
|
data = strings.Replace(data," "," ",-1)
|
|
return data
|
|
}
|
|
|
|
// TO-DO: Strip comments
|
|
// TO-DO: Handle CSS nested in <style> tags?
|
|
// TO-DO: Write unit tests for this
|
|
func minify_html(data string) string {
|
|
return minify(data)
|
|
}
|
|
|
|
// TO-DO: Have static files use this
|
|
// TO-DO: Strip comments
|
|
// TO-DO: Convert the rgb()s to hex codes?
|
|
// TO-DO: Write unit tests for this
|
|
func minify_css(data string) string {
|
|
return minify(data)
|
|
}
|
|
|
|
// TO-DO: Convert this to three character hex strings whenever possible?
|
|
// TO-DO: Write unit tests for this
|
|
func rgb_to_hexstr(red int, green int, blue int) string {
|
|
return strconv.FormatInt(int64(red), 16) + strconv.FormatInt(int64(green), 16) + strconv.FormatInt(int64(blue), 16)
|
|
}
|
|
|
|
/*
|
|
// TO-DO: Write unit tests for this
|
|
func hexstr_to_rgb(hexstr string) (red int, blue int, green int, err error) {
|
|
// Strip the # at the start
|
|
if hexstr[0] == '#' {
|
|
hexstr = strings.TrimPrefix(hexstr,"#")
|
|
}
|
|
if len(hexstr) != 3 && len(hexstr) != 6 {
|
|
return 0, 0, 0, errors.New("Hex colour codes may only be three or six characters long")
|
|
}
|
|
|
|
if len(hexstr) == 3 {
|
|
hexstr = hexstr[0] + hexstr[0] + hexstr[1] + hexstr[1] + hexstr[2] + hexstr[2]
|
|
}
|
|
}*/
|