compile.go

package neyo

import (
	"bufio"
	"bytes"
	"errors"
	"fmt"
	"github.com/wendal/mustache"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"sort"
	"strings"
)

// 编译整个网站
func Compile(public string) error {
	var ctx mustache.Context // 渲染上下文
	var docCont *DocContent  // 文档内容,仅作为变量声明
	var str string           // 仅声明,以减少不一样的编译错误
	var err error            // 仅声明

	var layouts map[string]Mapper

	payload, err := BuildPayload("./") // payload,核心上下文的主要部分,不可变
	if err != nil {
		Log(INFO, "Build payload fail, %s!!", err)
		return err
	}

	payload_ctx := mustache.MakeContextDir(payload, ".tmp_partials/")
	themeName := FromCtx(payload_ctx, "site.config.theme").(string)

	if FromCtx(payload_ctx, "site.config.markdown.toc_title") != nil {
		TOC_TITLE = FromCtx(payload_ctx, "site.config.markdown.toc_title").(string)
	}

	os.Remove(".tmp_partials")
	copyDir("partials", ".tmp_partials")

	theme_partials := filepath.Join("themes/", themeName, "/partials")
	if fi, err := os.Stat(theme_partials); err == nil && fi.IsDir() {
		copyDir(theme_partials, ".tmp_partials")
	}

	defer os.Remove(".tmp_partials")

	db_posts_dict, _ := payload_ctx.Get("db.posts.dictionary")
	Log(DEBUG, "Total of db posts dictionary: %d", len(db_posts_dict.Val.Interface().(map[string]Mapper)))
	for id, post := range db_posts_dict.Val.Interface().(map[string]Mapper) {
		_tmp, err := PrapreMainContent(id, post["_content"].(*DocContent).Source, payload_ctx)
		if err != nil {
			return err
		}
		post["_content"].(*DocContent).Main = _tmp
		Log(DEBUG, "Markdown to HTML: \n%s\n", _tmp)
	}

	helpers := make(map[string]mustache.SectionRenderFunc)
	ctxHelpers := make(map[string]func(interface{}) interface{})

	dynamicMapper := make(Mapper)
	topCtx := mustache.MakeContexts(payload_ctx, helpers, ctxHelpers, dynamicMapper)

	widgets, widget_assets, err := LoadWidgets(topCtx)
	if err != nil {
		return err
	}

	Log(DEBUG, payload_ctx.Dir(), "?>", topCtx.Dir())

	BaiscHelpers(payload, helpers, topCtx)
	CtxHelpers(payload, ctxHelpers, topCtx)
	layouts = payload["layouts"].(map[string]Mapper)

	if len(widgets) > 0 {
		widget_assets += PrapareAssets(themeName, "widgets", topCtx)
	}

	CopyResources(public, themeName)

	// Render Pages
	pages := payload["db"].(map[string]interface{})["pages"].(map[string]Mapper)
	for id, page := range pages {
		docCont = page["_content"].(*DocContent)
		//top := make(map[string]interface{})
		dynamicMapper["current_page_id"] = id
		dynamicMapper["page"] = page
		dynamicMapper["assets"] = PrapareAssets(themeName, page.Layout(), topCtx) + widget_assets
		widgetCtx := PrapareWidgets(widgets, page, topCtx)
		ctx = mustache.MakeContexts(page, dynamicMapper, topCtx, widgetCtx)
		//Log(DEBUG, "%s %s", ctx.Dir(), topCtx.Dir())
		_tmp, err := PrapreMainContent(id, docCont.Source, ctx)
		if err != nil {
			return err
		}
		page["_content"].(*DocContent).Main = _tmp

		str, err = RenderInLayout(docCont.Main, page.Layout(), layouts, ctx)
		if err != nil {
			return errors.New(fmt.Sprintf("Page %d > %s", id, err.Error()))
		}
		WriteTo(public, page.Url(), str)
	}

	// Render Posts
	for id, post := range db_posts_dict.Val.Interface().(map[string]Mapper) {
		//top := make(map[string]interface{})
		dynamicMapper["current_page_id"] = id
		dynamicMapper["page"] = post
		dynamicMapper["assets"] = PrapareAssets(themeName, post.Layout(), topCtx) + widget_assets
		docCont = post["_content"].(*DocContent)
		widgetCtx := PrapareWidgets(widgets, post, topCtx)
		ctx = mustache.MakeContexts(post, dynamicMapper, topCtx, widgetCtx)

		str, err = RenderInLayout(docCont.Main, post.Layout(), layouts, ctx)
		if err != nil {
			return errors.New(fmt.Sprintf("Post %d > %s", id, err.Error()))
		}

		WriteTo(public, post.Url(), str)
	}

	//我们还得把分页给解决了哦
	if paginatorCnf := FromCtx(topCtx, "site.config.paginator"); paginatorCnf != nil {
		var pgCnf Mapper
		pgCnf = paginatorCnf.(map[string]interface{})
		if _, ok := layouts[pgCnf.String("layout")]; ok {
			Log(INFO, "Enable paginator")
			renderPaginator(public, pgCnf, layouts, topCtx, widgets)
		} else {
			Log(INFO, "Layout Not Found", pgCnf.String("layout"))
		}
	}

	if Plugins != nil {
		for _, plugin := range Plugins {
			plugin.Exec(public, topCtx)
		}
	}

	Log(INFO, "Done")
	return nil
}

func RenderInLayout(content string, layoutName string, layouts map[string]Mapper, ctx mustache.Context) (string, error) {
	Log(DEBUG, "Render layout %q >>\n%s\nEOF\n", layoutName, content)
	ctx2 := make(map[string]string)
	ctx2["content"] = content
	layout := layouts[layoutName]
	if layout == nil {
		errMsg := fmt.Sprintf("Not found %s layout", layoutName)
		return "", errors.New(errMsg)
	}
	if c, ok := layout["_content"].(string); ok {
		Log(DEBUG, "Layout %q >>\n%s\nEOF", layoutName, c)
	}
	buf := &bytes.Buffer{}
	err := layout["_content"].(*DocContent).TPL.Render(mustache.MakeContexts(ctx2, ctx), buf)
	if err != nil {
		return content, err
	}
	if layout.Layout() != "" {
		return RenderInLayout(buf.String(), layout.Layout(), layouts, ctx)
	}
	return buf.String(), nil
}

func BaiscHelpers(payload Mapper, helpers map[string]mustache.SectionRenderFunc, topCtx mustache.Context) {
	var err error
	chronological := FromCtx(topCtx, "db.posts.chronological").([]string)
	latest_size := FromCtx(topCtx, "site.config.posts.latest").(int)
	dict := FromCtx(topCtx, "db.posts.dictionary").(map[string]Mapper)
	summary_lines := int(FromCtx(topCtx, "site.config.posts.summary_lines").(int64))
	latest_posts := make([]Mapper, 0)
	for _, id := range chronological {
		latest_posts = append(latest_posts, dict[id])
		if len(latest_posts) >= latest_size {
			break
		}
	}
	//-------------------------------
	helpers["posts_latest"] = func(nodes []mustache.Node, inverted bool, ctx mustache.Context, w io.Writer) error {
		if inverted {
			return nil
		}

		for _, post := range latest_posts {
			top := map[string]interface{}{}
			top["summary"] = MakeSummary(post, summary_lines, topCtx)
			Log(DEBUG, "%s", top["summary"])
			top["content"] = post["_content"].(*DocContent).Main
			for _, node := range nodes {
				err = node.Render(mustache.MakeContexts(post, top, ctx), w)
				if err != nil {
					return err
				}
			}
		}
		return nil
	}

	pages := FromCtx(topCtx, "db.pages").(map[string]Mapper)

	helpers["pages"] = func(nodes []mustache.Node, inverted bool, ctx mustache.Context, w io.Writer) error {
		if inverted {
			return nil
		}

		current_page_id := FromCtx(ctx, "current_page_id")
		for id, page := range pages {
			top := map[string]interface{}{}
			if current_page_id != nil {
				top["is_active_page"] = id == current_page_id.(string)
			}
			for _, node := range nodes {
				err = node.Render(mustache.MakeContexts(page, top, ctx), w)
				if err != nil {
					return err
				}
			}
		}
		return nil
	}

	helpers["posts"] = func(nodes []mustache.Node, inverted bool, ctx mustache.Context, w io.Writer) error {
		if inverted {
			return nil
		}
		for _, post := range dict {
			for _, node := range nodes {
				err = node.Render(mustache.MakeContexts(post, ctx), w)
				if err != nil {
					return err
				}
			}
		}
		return nil
	}

	categories := FromCtx(topCtx, "db.posts.categories").(map[string]*Catalog)
	helpers["categories"] = func(nodes []mustache.Node, inverted bool, ctx mustache.Context, w io.Writer) error {
		if inverted {
			return nil
		}
		names := make([]string, 0)[0:0]
		for name, _ := range categories {
			names = append(names, name)
		}
		sort.Strings(names)
		for _, name := range names {
			categorie := categories[name]
			for _, node := range nodes {
				err = node.Render(mustache.MakeContexts(categorie, ctx), w)
				if err != nil {
					return err
				}
			}
		}
		return nil
	}

	tags := FromCtx(topCtx, "db.posts.tags").(map[string]*Tag)
	helpers["tags"] = func(nodes []mustache.Node, inverted bool, ctx mustache.Context, w io.Writer) error {
		if inverted {
			return nil
		}
		names := make([]string, 0)[0:0]
		for name, _ := range tags {
			names = append(names, name)
		}
		sort.Strings(names)
		for _, name := range names {
			tag := tags[name]
			for _, node := range nodes {
				err = node.Render(mustache.MakeContexts(tag, ctx), w)
				if err != nil {
					return err
				}
			}
		}
		return nil
	}
	return
}

func CtxHelpers(payload Mapper, ctxHelper map[string]func(interface{}) interface{}, topCtx mustache.Context) {

	chronological := FromCtx(topCtx, "db.posts.chronological").([]string)
	categories := FromCtx(topCtx, "db.posts.categories").(map[string]*Catalog)
	tags := FromCtx(topCtx, "db.posts.tags").(map[string]*Tag)
	pages := FromCtx(topCtx, "db.pages").(map[string]Mapper)
	dict := FromCtx(topCtx, "db.posts.dictionary").(map[string]Mapper)
	post_list_sz := len(chronological)

	post_id_map := map[string]int{}
	for index, post_id := range chronological {
		post_id_map[post_id] = index
	}

	ctxHelper["to_pages"] = func(in interface{}) interface{} {

		//current_page
		current_page_id := FromCtx(topCtx, "current_page_id")
		Log(DEBUG, "current_page_id = %s", current_page_id)

		Log(DEBUG, "pages = %v", in)
		ids, ok := in.([]interface{})
		if !ok {
			Log(INFO, "Not string array?")
			return false
		}

		_pages := make([]Mapper, 0)
		for _, id := range ids {
			p := pages[id.(string)]
			if p != nil && current_page_id != nil {
				p["is_active_page"] = id == current_page_id.(string)
				Log(DEBUG, "is_active_page %v", id == current_page_id.(string))
			}
			_pages = append(_pages, p)
		}
		return _pages
	}
	ctxHelper["to_posts"] = func(in interface{}) interface{} {
		ids, ok := in.([]string)
		if !ok {
			return false
		}
		_posts := make([]Mapper, 0)
		for _, id := range ids {
			_posts = append(_posts, dict[id])
		}
		return _posts
	}
	ctxHelper["next"] = func(in interface{}) interface{} {
		post, ok := in.(Mapper)
		if !ok {
			id, ok := in.(string)
			if !ok {
				return false
			}
			post = dict[id]
		}
		index := post_id_map[post.Id()]
		if index == post_list_sz-1 {
			return false
		}
		return dict[chronological[index+1]]
	}
	ctxHelper["previous"] = func(in interface{}) interface{} {
		post, ok := in.(Mapper)
		if !ok {
			id, ok := in.(string)
			if !ok {
				return false
			}
			post = dict[id]
		}
		index := post_id_map[post.Id()]
		Log(DEBUG, "%d %s", index, post.Id())
		if index == 0 {
			return false
		}
		Log(DEBUG, "Post has previous", index, post.Id())
		return dict[chronological[index-1]]
	}

	ctxHelper["to_categories"] = func(in interface{}) interface{} {
		ids, ok := in.([]string)
		if !ok {
			Log(INFO, "BAD to_categories")
			return false
		}
		_catalogs := make([]*Catalog, 0)
		for _, id := range ids {
			_catalogs = append(_catalogs, categories[id])
		}
		return _catalogs
	}

	ctxHelper["to_tags"] = func(in interface{}) interface{} {
		ids, ok := in.([]string)
		if !ok {
			return false
		}
		_tags := make([]*Tag, 0)
		for _, id := range ids {
			_tags = append(_tags, tags[id])
		}
		return _tags
	}

	return
}

func PrapreMainContent(id string, content string, ctx mustache.Context) (string, error) {
	str, err := mustache.RenderString(content, ctx)
	if err != nil {
		Log(INFO, "Error when parse %s", id)
		return str, err
	}
	if strings.HasSuffix(id, ".md") || strings.HasSuffix(id, ".markdown") {
		Log(DEBUG, "Read markdown: %s", id)
		str = MarkdownToHtml(str)
	}
	return str, nil
}

func FromCtx(ctx mustache.Context, key string) interface{} {
	val, found := ctx.Get(key)
	if found {
		return val.Val.Interface()
	}
	return nil
}

func WriteTo(public, url, content string) {
	if strings.HasSuffix(url, "/") {
		url = filepath.Join(url, "index.html")
	} else if !strings.HasSuffix(url, ".html") {
		url = filepath.Join(url, "/index.html")
	}

	url = DecodePathInfo(url)

	dstPath := filepath.Join(public, url)
	Log(INFO, "Write %s", dstPath)
	os.MkdirAll(filepath.Dir(dstPath), DEFAULT_DIR_MODE)
	ioutil.WriteFile(dstPath, []byte(content), DEFAULT_FILE_MODE)
}

func PrapareAssets(theme string, layoutName string, topCtx mustache.Context) string {
	//themeCnf := FromCtx(topCtx, "theme").(map[string]interface{})
	urls := FromCtx(topCtx, "urls").(map[string]string)
	//theme_base_path := urls["theme"]
	//theme_media_path := urls["theme_media"]
	theme_javascripts_path := urls["theme_javascripts"]
	theme_stylesheets_path := urls["theme_stylesheets"]

	assets := make([]string, 0)

	stylesheets := FromCtx(topCtx, "theme.stylesheets."+layoutName)
	if stylesheets == nil && layoutName != "widgets" {
		stylesheets = FromCtx(topCtx, "theme.stylesheets.default")
	}
	if stylesheets != nil {
		switch stylesheets.(type) {
		case []interface{}:
			for _, _stylesheet := range stylesheets.([]interface{}) {
				stylesheet := _stylesheet.(string)
				if strings.HasPrefix(stylesheet, "http://") || strings.HasPrefix(stylesheet, "https:") {
					assets = append(assets, fmt.Sprintf("<link href=\"%s\" type=\"text/css\" rel=\"stylesheet\" media=\"all\">", stylesheet))
				} else {
					assets = append(assets, fmt.Sprintf("<link href=\"%s/%s\" type=\"text/css\" rel=\"stylesheet\" media=\"all\">", theme_stylesheets_path, stylesheet))
				}
			}
		case map[string]interface{}:
			for widgetName, _stylesheet := range stylesheets.(map[string]interface{}) {
				stylesheet := widgetName + "/stylesheets/" + _stylesheet.(string)
				if strings.HasPrefix(stylesheet, "http://") || strings.HasPrefix(stylesheet, "https:") {
					assets = append(assets, fmt.Sprintf("<link href=\"%s\" type=\"text/css\" rel=\"stylesheet\" media=\"all\">", stylesheet))
				} else {
					assets = append(assets, fmt.Sprintf("<link href=\"%s/%s\" type=\"text/css\" rel=\"stylesheet\" media=\"all\">", "/assets/twitter/widgets", stylesheet))
				}
			}
		}

	}

	javascripts := FromCtx(topCtx, "theme.javascripts."+layoutName)
	if javascripts == nil && layoutName != "widgets" {
		javascripts = FromCtx(topCtx, "theme.javascripts.default")
	}
	if javascripts != nil {
		switch javascripts.(type) {
		case []interface{}:
			for _, _javascript := range javascripts.([]interface{}) {
				javascript := _javascript.(string)
				if strings.HasPrefix(javascript, "http://") || strings.HasPrefix(javascript, "https:") {
					assets = append(assets, fmt.Sprintf("<script src=\"%s\"></script>", javascript))
				} else {
					assets = append(assets, fmt.Sprintf("<script src=\"%s/%s\"></script>", theme_javascripts_path, javascript))
				}
			}
		case map[string]interface{}:
			for widgetName, _javascript := range javascripts.(map[string]interface{}) {
				javascript := widgetName + "/javascripts/" + _javascript.(string)
				if strings.HasPrefix(javascript, "http://") || strings.HasPrefix(javascript, "https:") {
					assets = append(assets, fmt.Sprintf("<script src=\"%s\"></script>", javascript))
				} else {
					assets = append(assets, fmt.Sprintf("<script src=\"%s/%s\"> </script>", "/assets/twitter/widgets/", javascript))
				}
			}
		}
	}

	rs := ""
	for _, str := range assets {
		rs += str + "\n"
	}
	return rs
}

func CopyResources(public, themeName string) {
	SyncDirectory("others", public)
	SyncDirectory("media", filepath.Join(public, "/assets/media"))
	SyncDirectory("widgets", filepath.Join(public, "/assets/widgets"))
	SyncDirectory(filepath.Join("themes/", themeName), filepath.Join(public, "/assets/", themeName))
}

func SyncDirectory(src string, target string) error {
	if fi, err := os.Stat(src); os.IsExist(err) && fi.IsDir() {
		copyDir(src, target)
	} else {
		return err
	}
	return nil
}

func copyDir(src string, target string) error {
	Log(DEBUG, "Copy directory from %s to %s", src, target)
	fst, err := os.Stat(src)
	if err != nil {
		Log(ERROR, "Copy directory %s error %s", src, err)
		return err
	}
	if !fst.IsDir() {
		return nil
	}
	finfos, err := ioutil.ReadDir(src)
	if err != nil {
		Log(ERROR, "Read diretory %s %s", src, err)
		return err
	}
	for _, finfo := range finfos {
		if strings.HasPrefix(finfo.Name(), ".") {
			continue
		} else if finfo.Name() == "config.yml" {
			continue
		}
		//Log(DEBUG, finfo.Name())
		dst_path := filepath.Join(target, finfo.Name())
		src_path := filepath.Join(src, finfo.Name())
		if finfo.IsDir() {
			copyDir(src_path, dst_path)
			continue
		}

		os.MkdirAll(filepath.Dir(dst_path), DEFAULT_DIR_MODE)

		src_file, err := os.Open(src_path)
		if err != nil {
			Log(ERROR, "Open %s error %s", src_path, err)
			continue
		}
		defer src_file.Close()

		dst_file, err := os.OpenFile(dst_path, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, DEFAULT_FILE_MODE)
		if err != nil {
			Log(ERROR, "Open %s error %s", dst_path, err)
			continue
		}
		defer dst_file.Close()

		io.Copy(dst_file, src_file)
	}
	return nil
}

func MakeSummary(post Mapper, lines int, topCtx mustache.Context) string {
	content := post["_content"].(*DocContent).Source
	r := bufio.NewReader(bytes.NewBufferString(content))
	dst := ""
	readUntil := ""
	for lines > 0 {
		line, _ := r.ReadString('\n')
		dst += line
		lines--
		if strings.Trim(line, "\r\n\t ") == "```" {
			if readUntil == "" {
				readUntil = "```"
			} else {
				readUntil = ""
			}
		}
		if lines == 0 {
			var err error
			for readUntil != strings.Trim(line, "\r\n\t ") {
				line, err = r.ReadString('\n')
				dst += line
				if err != nil {
					break
				}
			}
		}
	}
	str, err := mustache.RenderString(dst, topCtx)
	if err != nil {
		Log(ERROR, "BAD Mustache after Summary cut!")
		str, err = mustache.RenderString(dst, topCtx)
		if err != nil {
			Log(ERROR, "BAD Mustache Summary?", err)
			str = post["_content"].(*DocContent).Main
		}
	}
	str = strings.Replace(str, TOC_MARKUP, "", 1)
	return MarkdownToHtml(str)
}

func renderPaginator(public string, pgCnf Mapper, layouts map[string]Mapper, topCtx mustache.Context, widgets []Widget) {
	summary_lines := int(FromCtx(topCtx, "site.config.posts.summary_lines").(int64))
	per_page := pgCnf.Int("per_page")
	if per_page < 2 {
		per_page = 2
	} else if per_page > 100 {
		per_page = 100
	}
	namespace := pgCnf.String("namespace")
	if namespace == "" {
		namespace = "/posts/"
	}
	layout := pgCnf.String("layout")

	posts_ctx := make(Mapper)

	chronological, _ := FromCtx(topCtx, "db.posts.chronological").([]string)
	dictionary, _ := FromCtx(topCtx, "db.posts.dictionary").(map[string]Mapper)
	siteTitle, _ := FromCtx(topCtx, "site.title").(string)

	page_count := len(chronological)/per_page + 1
	if len(chronological)%per_page == 0 {
		page_count--
	}

	paginator_navigation := make([]Mapper, page_count)
	for i := 0; i < len(paginator_navigation); i++ {
		pn := make(Mapper)
		pn["page_number"] = i + 1
		pn["name"] = fmt.Sprintf("%d", i+1)
		pn["url"] = fmt.Sprintf("%s%d/", namespace, i+1)
		pn["is_active_page"] = false
		paginator_navigation[i] = pn
	}

	posts_ctx["paginator_navigation"] = paginator_navigation

	one_page := make([]Mapper, 0)
	current_page_number := 0
	Log(INFO, "Total posts: %5d", len(chronological))

	for i, post_id := range chronological {
		if i != 0 && i%per_page == 0 {
			current_page_number++
			Log(INFO, "Rendering page #%d with %d posts", current_page_number, len(one_page))
			posts_ctx["current_page_number"] = current_page_number
			posts_ctx["paginator"] = one_page
			if current_page_number >= 2 {
				paginator_navigation[current_page_number-2]["is_active_page"] = false
			}
			paginator_navigation[current_page_number-1]["is_active_page"] = true
			widgetCtx := PrapareWidgets(widgets, make(Mapper), topCtx)

			_vars := map[string]interface{}{
				"posts": posts_ctx,
				"page": map[string]interface{}{
					"title": fmt.Sprintf("%s Page %d", siteTitle, current_page_number),
				},
			}
			_url := paginator_navigation[current_page_number-1].String("url")
			_ctx := mustache.MakeContexts(_vars, topCtx, widgetCtx)
			renderOnePager(public, _url, layout, layouts, _ctx)
			one_page = one_page[0:0]
		}
		post := dictionary[post_id]
		post["summary"] = MakeSummary(post, summary_lines, topCtx)
		one_page = append(one_page, post)
	}
	if len(one_page) > 0 {
		current_page_number++
		Log(INFO, "Rendering page #%d with %d post(s)", current_page_number, len(one_page))
		posts_ctx["current_page_number"] = current_page_number
		posts_ctx["paginator"] = one_page
		if current_page_number >= 2 {
			paginator_navigation[current_page_number-2]["is_active_page"] = false
		}
		paginator_navigation[current_page_number-1]["is_active_page"] = true
		m := make(Mapper)
		widgetCtx := PrapareWidgets(widgets, m, topCtx)
		vars := map[string]interface{}{
			"posts": posts_ctx,
			"page": map[string]interface{}{
				"title": fmt.Sprintf("%s Page %d", siteTitle, current_page_number),
			},
		}
		_url := paginator_navigation[current_page_number-1].String("url")
		_ctx := mustache.MakeContexts(vars, topCtx, widgetCtx)
		renderOnePager(public, _url, layout, layouts, _ctx)
	}
}

func renderOnePager(public, url, layoutName string, layouts map[string]Mapper, ctx mustache.Context) {
	str, err := RenderInLayout("", layoutName, layouts, ctx)
	if err != nil {
		Log(ERROR, "Pager %s %s", url, err)
		return
	}
	if strings.HasSuffix(url, "/") {
		url = filepath.Join(url, "/index.html")
	}
	WriteTo(public, url, str)
}