site.go

// (c) 2012 Alexander Solovyov
// under terms of ISC license

package main

import (
	"os"
	"path/filepath"
	"strings"
	"text/template"
)

type Site struct {
	SiteConfig
	Template *template.Template
	Pages    PageSlice
}

func NewSite(config *SiteConfig) *Site {
	template := template.New("no-idea-what-to-pass-here").Funcs(funcMap)
	template, err := template.ParseFiles(config.Templates...)
	errhandle(err)

	site := &Site{
		SiteConfig: *config,
		Template:   template,
		Pages:      make(PageSlice, 0),
	}

	site.Collect()
	site.FindDeps()

	return site
}

func (site *Site) AddPage(path string) {
	page := NewPage(site, path)
	if page.state != StateIgnored {
		site.Pages = append(site.Pages, page)
	}
}

func (site *Site) Collect() {
	errors := make(chan error)

	filepath.Walk(site.Source, site.collectFunc(errors))

	select {
	case err := <-errors:
		errhandle(err)
	default:
	}

	site.Pages.Sort()
}

func (site *Site) collectFunc(errors chan<- error) filepath.WalkFunc {
	return func(fn string, fi os.FileInfo, err error) error {
		if err != nil {
			errors <- err
			return nil
		}

		if !fi.IsDir() && !strings.HasPrefix(filepath.Base(fn), ".") {
			site.AddPage(fn)
		}

		return nil
	}
}

func (site *Site) FindDeps() {
	for _, page := range site.Pages {
		page.findDeps()
	}
}

func (site *Site) Process() int {
	processed := 0
	for _, page := range site.Pages {
		if page.Changed() {
			page.Process()
			processed++
		}
	}
	return processed
}

func (site *Site) ProcessAll() {
	for _, page := range site.Pages {
		page.Process()
	}
}

func (site *Site) Summary() {
	site.ProcessAll()
	out("Total pages to render: %d\n", len(site.Pages))

	for _, page := range site.Pages {
		// do not output static files in summary mode
		if page.Rule == nil {
			continue
		}

		out("%s - %s: %d chars; %s\n",
			page.Path, page.Title, len(page.Content()), page.Rule)
		out("------------")
		_, err := page.WriteTo(os.Stdout)
		errhandle(err)
		out("------------\n")
	}
}

func (site *Site) Render() {
	processed := site.Process()
	out("Rendering %d changed pages of %d total\n", processed, len(site.Pages))

	for _, page := range site.Pages {
		if !page.Changed() {
			continue
		}

		debug("Rendering %s -> %s\n", page.Source, page.OutputPath())

		err := os.MkdirAll(filepath.Dir(page.OutputPath()), 0755)
		errhandle(err)

		_, err = page.Render()
		errhandle(err)
	}
}

func (site *Site) PageBySomePath(s string) *Page {
	if strings.HasPrefix(s, site.Source) {
		rel, err := filepath.Rel(site.Source, s)
		if err != nil {
			return nil
		}
		return site.Pages.BySource(rel)
	}
	if strings.HasPrefix(s, site.Output) {
		rel, err := filepath.Rel(site.Output, s)
		if err != nil {
			return nil
		}
		return site.Pages.ByPath(rel)
	}
	if page := site.Pages.BySource(s); page != nil {
		return page
	}
	return site.Pages.ByPath(s)
}