template.go

/*
Copyright (C) IBM Corporation 2015, Michele Franceschini <franceschini@us.ibm.com>

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package gowiki

import (
	"fmt"
	"os"
	"regexp"
	"sort"
	"strings"
)

type Template struct {
	Typ        string            `json:"type"` //magic,normal,ext,param
	Name       string            `json:"name"`
	Attr       string            `json:"attr"` //text after the ':' in magic templates
	Parameters map[string]string `json:"parameters"`
}

func (a *Article) parseTemplateEtc(l string) []Template {
	return nil
}

type streak struct {
	opening bool
	length  int
	b       int
	e       int
}

type template struct {
	b        int
	e        int
	isparam  bool
	children []*template
	rt       string
	rendered bool
}

type byStart []*template

func (a byStart) Len() int           { return len(a) }
func (a byStart) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a byStart) Less(i, j int) bool { return a[i].b < a[j].b }

var templateStreaksRe = regexp.MustCompile(`(?:\{\{+)|(?:\}\}+)`)

func findCurlyStreaks(mw string) [][]int {
	out := [][]int{}
	found := '.'
	beg := 0
	//	count :=0
	for i, r := range mw {
		switch r {
		case found:
		default:
			if i-beg > 1 && (found == '{' || found == '}') {
				out = append(out, []int{beg, i})
			}
			beg = i
			found = r
		}
	}
	if beg < len(mw)-1 && (found == '{' || found == '}') {
		out = append(out, []int{beg, len(mw)})
	}
	return out
}

func findTemplates(mw string) []*template {
	//	tsl := templateStreaksRe.FindAllStringSubmatchIndex(mw, -1)
	tsl := findCurlyStreaks(mw)
	//	fmt.Println(tsl)
	streaks := make([]streak, 0, len(tsl))
	for _, pair := range tsl {
		streaks = append(streaks, streak{
			opening: (mw[pair[0]] == '{'),
			length:  pair[1] - pair[0],
			b:       pair[0],
			e:       pair[1],
		})
	}
	//	fmt.Println(streaks)
	tl := make([]*template, 0, 8)
	i := 0
	for i < len(streaks) {
		if !streaks[i].opening && streaks[i].length > 1 { // found a closing set: search for the opening
			found := false
			for j := i - 1; j >= 0; j-- {
				if streaks[j].opening && streaks[j].length > 1 {
					found = true
					n := 2
					isparam := false
					if streaks[i].length > 2 && streaks[j].length > 2 {
						n = 3
						isparam = true
					}
					tl = append(tl, &template{
						isparam: isparam,
						b:       streaks[j].e - n,
						e:       streaks[i].b + n,
					})
					streaks[i].length -= n
					streaks[i].b += n
					streaks[j].length -= n
					streaks[j].e -= n
					break
				}
			}
			if found {
				continue
			}
		}
		i++
	}
	sort.Sort(byStart(tl))
	/*	fmt.Println("Templates found:")
		for i := range tl {
			fmt.Println(tl[i])
		} */
	out := make([]*template, 0, 4)
	cur_end := 0
	for i := range tl {
		tl[i].children = []*template{}
		if tl[i].b >= cur_end {
			cur_end = tl[i].e
			out = append(out, tl[i])
		} else {
			for j := i - 1; j >= 0; j-- {
				if tl[j].e > tl[i].e {
					tl[j].children = append(tl[j].children, tl[i])
					break
				}
			}
		}
	}
	/*	fmt.Println("Templates out:")
		for i := range out {
			fmt.Println(out[i])
		}*/
	/*	fmt.Println("Templates found:")
		for i := range tl {
			fmt.Println(mw[tl[i].b:tl[i].e])
		}
	*/
	return out
}

func findTemplateParamPos(mw string, t *template) [][]int { //first is position of pipe, second is position of first equal
	out := make([][]int, 0, 1)
	inChildTemplate := false
	inlink := false
	lastopen := false
	lastclosed := false
	for i, rv := range mw[t.b:t.e] {
		inChildTemplate = false
		open := false
		closed := false
		for _, ct := range t.children {
			if i+t.b >= ct.b && i+t.b < ct.e {
				inChildTemplate = true
				break
			}
		}
		if !inChildTemplate {
			switch {
			case rv == '[':
				if lastopen {
					inlink = true
				}
				open = true
			case rv == ']':
				if lastclosed {
					inlink = false
				}
				closed = true
			case rv == '|' && !inlink:
				out = append(out, []int{i + t.b})
			case rv == '=' && len(out) > 0 && len(out[len(out)-1]) == 1 && !inlink:
				out[len(out)-1] = append(out[len(out)-1], i+t.b)
			}
		}
		lastopen = open
		lastclosed = closed
	}
	return out
}

/*func (a *Article) processTemplates(mw string, tokens map[string]*Token) (string, map[string]*Token) {
	mlt := findTemplates(mw)
	last := 0
	out := make([]byte, 0, len(mw))
	//	tokens := make(map[string]*Token, len(mlt))
	for i, t := range mlt {
		sb := fmt.Sprintf("\x07tb%05d", i)
		se := fmt.Sprintf("\x07te%05d", i)
		out = append(out, []byte(mw[last:t.b])...)
		out = append(out, []byte(sb+a.renderTemplate(mw, t)+se)...)
		last = t.e
		tokens[sb] = &Token{
			TText: fmt.Sprintf("%d", i),
			TType: "tb",
		}
		tokens[se] = &Token{
			TText: fmt.Sprintf("%d", i),
			TType: "te",
		}

	}
	out = append(out, []byte(mw[last:])...)
	return string(out), tokens
} */

func (a *Article) processTemplates(mws string, tokens map[string]*Token, g PageGetter) (string, map[string]*Token) {
	//strip nowiki noinclude etc here
	//	mws := a.stripComments(mw)
	//	mws = a.stripNoinclude(mws)

	//	fmt.Println(mws)
	mlt := findTemplates(mws)

	last := 0
	out := make([]byte, 0, len(mws))
	for i, t := range mlt {
		//		fmt.Println("Process templates:", *t)
		sb := fmt.Sprintf("\x07tb%05d", i)
		se := fmt.Sprintf("\x07te%05d", i)
		tn, pm := a.renderInnerTemplates(mws, t, nil, g, 0)
		a.addTemplate(tn, pm)
		out = append(out, []byte(mws[last:t.b])...)
		out = append(out, []byte(sb+t.rt+se)...)
		last = t.e
		tokens[sb] = &Token{
			TText: fmt.Sprintf("%d", i),
			TType: "tb",
		}
		tokens[se] = &Token{
			TText: fmt.Sprintf("%d", i),
			TType: "te",
		}
	}
	out = append(out, []byte(mws[last:])...)

	//unstrip here

	return string(out), tokens
}

func (a *Article) addTemplate(tn string, pm map[string]string) {
	outT := Template{Parameters: pm}
	base, attr, typ, _ := detectTemplateType(tn)
	outT.Typ = typ
	outT.Name = base
	outT.Attr = attr
	a.Templates = append(a.Templates, &outT)
	return
}

func (a *Article) renderTemplate(mw string, t *template) string {
	pp := findTemplateParamPos(mw, t)
	n := 2
	if t.isparam {
		n = 3
	}
	var tn string
	if len(pp) > 0 {
		tn = fmt.Sprint(strings.TrimSpace(mw[t.b+n : pp[0][0]]))
	} else {
		tn = fmt.Sprint(strings.TrimSpace(mw[t.b+n : t.e-n]))
	}
	pm := make(map[string]string, len(pp))
	pp = append(pp, []int{t.e - n})
	for i := 0; i < len(pp)-1; i++ {
		var name string
		var param string
		if len(pp[i]) > 1 { //named param
			name = fmt.Sprint(strings.TrimSpace(mw[pp[i][0]+1 : pp[i][1]]))
			param = fmt.Sprint(strings.TrimSpace(mw[pp[i][1]+1 : pp[i+1][0]]))
		} else {
			name = fmt.Sprint(i + 1)
			param = fmt.Sprint(strings.TrimSpace(mw[pp[i][0]+1 : pp[i+1][0]]))
		}
		pm[name] = param
	}

	outT := Template{Parameters: pm}
	base, attr, typ, text := detectTemplateType(tn)
	switch {
	case t.isparam:
		outT.Typ = "param"
		outT.Name = tn
		text = ""
	default:
		outT.Typ = typ
		outT.Name = base
		outT.Attr = attr
	}
	a.Templates = append(a.Templates, &outT)
	return text
}

func detectTemplateType(tn string) (string, string, string, string) {
	index := strings.Index(tn, ":")
	var base string
	var attr string
	if index > 0 {
		base = strings.TrimSpace(tn[:index])
		attr = strings.TrimSpace(tn[index+1:])
	} else {
		base = tn
	}
	_, ok := MagicMap[base]
	if ok {
		return base, attr, "magic", ""
	}

	return tn, "", "normal", ""
}

type TemplateRenderer func(name, mw string, params map[string]string) string

var MagicMap map[string]TemplateRenderer = map[string]TemplateRenderer{
	"DISPLAYTITLE": nil,
}

var noHashFunctionsMap map[string]bool = map[string]bool{
	"displaytitle":     true,
	"formatdate":       true,
	"int":              true,
	"namespace":        true,
	"pagesinnamespace": true,
	"speciale":         true,
	"special":          true,
	"tag":              true,
	"anchorencode":     true, "basepagenamee": true, "basepagename": true, "canonicalurle": true,
	"canonicalurl": true, "cascadingsources": true, "defaultsort": true, "filepath": true,
	"formatnum": true, "fullpagenamee": true, "fullpagename": true, "fullurle": true,
	"fullurl": true, "gender": true, "grammar": true, "language": true,
	"lcfirst": true, "lc": true, "localurle": true, "localurl": true,
	"namespacee": true, "namespacenumber": true, "nse": true, "ns": true,
	"numberingroup": true, "numberofactiveusers": true, "numberofadmins": true, "numberofarticles": true,
	"numberofedits": true, "numberoffiles": true, "numberofpages": true, "numberofusers": true,
	"numberofviews": true, "padleft": true, "padright": true, "pageid": true,
	"pagenamee": true, "pagename": true, "pagesincategory": true, "pagesize": true,
	"plural": true, "protectionlevel": true, "revisionday2": true, "revisionday": true,
	"revisionid": true, "revisionmonth1": true, "revisionmonth": true, "revisiontimestamp": true,
	"revisionuser": true, "revisionyear": true, "rootpagenamee": true, "rootpagename": true,
	"subjectpagenamee": true, "subjectpagename": true, "subjectspacee": true, "subjectspace": true,
	"subpagenamee": true, "subpagename": true, "talkpagenamee": true, "talkpagename": true,
	"talkspacee": true, "talkspace": true, "ucfirst": true, "uc": true,
	"urlencode": true,
}
var variablesMap map[string]bool = map[string]bool{
	"articlepath":         true,
	"basepagenamee":       true,
	"basepagename":        true,
	"cascadingsources":    true,
	"contentlanguage":     true,
	"currentday2":         true,
	"currentdayname":      true,
	"currentday":          true,
	"currentdow":          true,
	"currenthour":         true,
	"currentmonth1":       true,
	"currentmonthabbrev":  true,
	"currentmonthnamegen": true,
	"currentmonthname":    true,
	"currentmonth":        true,
	"currenttimestamp":    true,
	"currenttime":         true,
	"currentversion":      true,
	"currentweek":         true,
	"currentyear":         true,
	"directionmark":       true,
	"fullpagenamee":       true,
	"fullpagename":        true,
	"localday2":           true,
	"localdayname":        true,
	"localday":            true,
	"localdow":            true,
	"localhour":           true,
	"localmonth1":         true,
	"localmonthabbrev":    true,
	"localmonthnamegen":   true,
	"localmonthname":      true,
	"localmonth":          true,
	"localtimestamp":      true,
	"localtime":           true,
	"localweek":           true,
	"localyear":           true,
	"namespacee":          true,
	"namespacenumber":     true,
	"namespace":           true,
	"numberofactiveusers": true,
	"numberofadmins":      true,
	"numberofarticles":    true,
	"numberofedits":       true,
	"numberoffiles":       true,
	"numberofpages":       true,
	"numberofusers":       true,
	"numberofviews":       true,
	"pageid":              true,
	"pagenamee":           true,
	"pagename":            true,
	"revisionday2":        true,
	"revisionday":         true,
	"revisionid":          true,
	"revisionmonth1":      true,
	"revisionmonth":       true,
	"revisionsize":        true,
	"revisiontimestamp":   true,
	"revisionuser":        true,
	"revisionyear":        true,
	"rootpagenamee":       true,
	"rootpagename":        true,
	"scriptpath":          true,
	"servername":          true,
	"server":              true,
	"sitename":            true,
	"stylepath":           true,
	"subjectpagenamee":    true,
	"subjectpagename":     true,
	"subjectspacee":       true,
	"subjectspace":        true,
	"subpagenamee":        true,
	"subpagename":         true,
	"talkpagenamee":       true,
	"talkpagename":        true,
	"talkspacee":          true,
	"talkspace":           true,
}

func (a *Article) renderTemplateMagic(name string, params map[string]string) string {
	return ""
}

func (a *Article) renderTemplateExt(name string, params map[string]string) string {
	return ""
}

func (a *Article) renderTemplateRecursive(name string, params map[string]string, g PageGetter, depth int) string {
	if depth > 4 {
		return ""
	}
	//name and parameters have already been substituted so they are guarranteed not to contain any template

	//establish the type of template
	switch templateType(name) {
	case "magic":
		return a.renderTemplateMagic(name, params)
	case "ext":
		return a.renderTemplateExt(name, params)
	}
	//case "normal"
	//based on the type of template
	//for the name and each parameter, find templates and substite them in the proper order
	mw, err := g.Get(WikiCanonicalFormNamespace(name, "Template"))
	if err != nil {
		fmt.Fprintln(os.Stderr, "Title:", a.Title, " Error retrieving:", name, " ->", err)
		return ""
	}
	return a.TranscludeTemplatesRecursive(mw, params, g, depth)
}

func (a *Article) TranscludeTemplatesRecursive(mw string, params map[string]string, g PageGetter, depth int) string {
	var mws string
	followed := 0
	for {
		if followed > 4 {
			return ""
		}
		//strip nowiki noinclude etc here
		mws := a.stripComments(mw)
		isRedirect, redirect := a.checkRedirect(mws)
		if !isRedirect {
			break
		}
		var err error
		mw, err = g.Get(*redirect)
		if err != nil {
			return ""
		}
		followed++
	}
	mws = a.stripNoinclude(mws)

	//	fmt.Println(ds[depth], "TranscludeTemplatesRecursive", mws)
	mlt := findTemplates(mws)

	last := 0
	out := make([]byte, 0, len(mws))
	for _, t := range mlt {
		a.renderInnerTemplates(mws, t, params, g, depth)
		out = append(out, []byte(mws[last:t.b])...)
		out = append(out, []byte(t.rt)...)
		last = t.e
	}
	out = append(out, []byte(mws[last:])...)

	//unstrip here

	return string(out)
}

var ds []string = []string{"   ", "      ", "         ", "            ", "               ", "                  "}

func (a *Article) renderInnerTemplates(mws string, t *template, params map[string]string, g PageGetter, depth int) (string, map[string]string) {
	// render inner templates first
	//	fmt.Println(ds[depth], *t, "\n", ds[depth], "Template:\n", ds[depth], mws[t.b:t.e])
	for _, it := range t.children {
		if !it.rendered {
			a.renderInnerTemplates(mws, it, params, g, depth)
		}
	}
	//	fmt.Println(ds[depth], "Working on", mws[t.b:t.e])
	pp := findTemplateParamPos(mws, t) //position of the pipes for this template
	//	fmt.Println(ds[depth], "pp:", pp)

	n := 2
	if t.isparam {
		n = 3
	}
	pp = append(pp, []int{t.e - n})

	var mw string
	var tb int
	//	var te int
	if len(t.children) == 0 {
		//		fmt.Println(ds[depth], "No nested templates in", mws[t.b:t.e])
		mw = mws
		tb = t.b
		//		te = t.e
	} else {
		//		fmt.Println(ds[depth], "Nested templates: fixing pp")
		//substitute the strings and update pp
		tci := 0
		ioff := t.children[tci].b
		tb = 0
		mw = mws[t.b:ioff]
		//		fmt.Println(*t)
		ooff := -t.b
		ppi0 := 0
		ppi1 := 0
		for ppi0 < len(pp) {
			//			fmt.Println(mws)
			//			fmt.Println(len(mws), tci, ioff, ooff, ppi0, ppi1, pp)
			if pp[ppi0][ppi1] <= ioff {
				pp[ppi0][ppi1] += ooff
				ppi1++
				if ppi1 >= len(pp[ppi0]) {
					ppi0++
					ppi1 = 0
				}
			} else {
				mw += t.children[tci].rt
				ooff += len(t.children[tci].rt) - (t.children[tci].e - t.children[tci].b)
				teoff := t.children[tci].e
				tci++
				if tci >= len(t.children) {
					ioff = t.e
				} else {
					ioff = t.children[tci].b
				}
				//				fmt.Println(ds[depth], tci, teoff, ioff)
				mw += mws[teoff:ioff]
			}
		}
		//		te = len(mw)
	}
	//	fmt.Println("len(mw):", len(mw), "mw:", mw, "\npp:", pp)
	var tn string
	if len(pp) > 1 {
		tn = fmt.Sprint(strings.TrimSpace(mw[tb+n : pp[0][0]]))
	} else {
		tn = fmt.Sprint(strings.TrimSpace(mw[tb+n : pp[len(pp)-1][0]]))
	}

	t.rendered = true
	if t.isparam { //it's a parameter substitution
		text, ok := params[tn]
		if ok {
			t.rt = text
			return "", nil
		}
		if len(pp) == 1 { //no default
			t.rt = "{{{" + tn + "}}}"
			return "", nil
		}
		t.rt = mw[pp[0][0]+1 : pp[len(pp)-1][0]]
		return "", nil
	}
	pm := make(map[string]string, len(pp))
	for i := 0; i < len(pp)-1; i++ {
		var name string
		var param string
		if len(pp[i]) > 1 { //named param
			name = fmt.Sprint(strings.TrimSpace(mw[pp[i][0]+1 : pp[i][1]]))
			param = fmt.Sprint(strings.TrimSpace(mw[pp[i][1]+1 : pp[i+1][0]]))
		} else {
			name = fmt.Sprint(i + 1)
			param = fmt.Sprint(strings.TrimSpace(mw[pp[i][0]+1 : pp[i+1][0]]))
		}
		pm[name] = param
	}
	t.rt = a.renderTemplateRecursive(tn, pm, g, depth+1)
	return tn, pm
}

func templateType(tn string) string {
	index := strings.Index(tn, ":")
	tns := strings.TrimSpace(tn)
	var base string
	//	var attr string
	if index > 0 {
		base = strings.TrimSpace(tn[:index])
		//		attr = strings.TrimSpace(tn[index+1:])
	} else {
		base = tns
	}
	base = strings.ToLower(base)
	_, ok1 := noHashFunctionsMap[base]
	_, ok2 := variablesMap[base]
	if ok1 || ok2 {
		return "magic"
	}
	if strings.HasPrefix(tns, "#") {
		return "ext"
	}
	return "normal"
}

var noincludeRe = regexp.MustCompile(`(?isU)<noinclude>.*(?:</noinclude>|\z)`)
var includeonlyRe = regexp.MustCompile(`(?isU)<includeonly>(.*)(?:</includeonly>|\z)`)

func (a *Article) stripNoinclude(mw string) string {
	mwni := noincludeRe.ReplaceAllLiteralString(mw, "")
	ssl := includeonlyRe.FindAllStringSubmatch(mwni, -1)
	if len(ssl) == 0 {
		return mwni
	}
	sl := make([]string, 0, len(ssl))
	for _, s := range ssl {
		sl = append(sl, s[1])
	}
	return strings.Join(sl, "")
}