better project layout

2019-03-19 11:15:32 +01:00
parent dfc932b7b0
commit 70d7497eda
128 changed files with 48 additions and 42 deletions
--- a/pkg/filter/custom.go
+++ b/pkg/filter/custom.go
@@ -0,0 +1,73 @@
+package filter
+
+import (
+	"io/ioutil"
+	"path"
+	"strings"
+
+	"gitbase.de/apairon/mark2web/pkg/helper"
+	"gitbase.de/apairon/mark2web/pkg/mark2web"
+	"github.com/ddliu/motto"
+	"github.com/flosch/pongo2"
+	_ "github.com/robertkrimen/otto/underscore"
+)
+
+// RegisterFilters reads a directory and register filters from files within it
+func RegisterFilters(dir string) {
+	files, err := ioutil.ReadDir(dir)
+	if err != nil {
+		helper.Log.Panicf("could not read from template filters dir '%s': %s", dir, err)
+	}
+	for _, f := range files {
+		if !f.IsDir() {
+			switch path.Ext(f.Name()) {
+			case ".js":
+				fileBase := strings.TrimSuffix(f.Name(), ".js")
+				jsFile := dir + "/" + f.Name()
+				helper.Log.Debugf("trying to register filter from: %s", jsFile)
+				/*
+					jsStr, err := ioutil.ReadFile(jsFile)
+					if err != nil {
+						Log.Panicf("could not read '%s': %s", jsFile, err)
+					}
+				*/
+				vm := motto.New()
+				fn, err := vm.Run(jsFile)
+				if err != nil {
+					helper.Log.Panicf("error in javascript vm for '%s': %s", jsFile, err)
+				}
+				if !fn.IsFunction() {
+					helper.Log.Panicf("%s does not contain a function code", jsFile)
+				}
+
+				err = pongo2.RegisterFilter(
+					fileBase,
+					func(in, param *pongo2.Value) (out *pongo2.Value, erro *pongo2.Error) {
+						thisObj, _ := vm.Object("({})")
+						if mark2web.CurrentContext != nil {
+							thisObj.Set("context", *mark2web.CurrentContext)
+						}
+
+						if err != nil {
+							helper.Log.Panicf("could not set context as in '%s': %s", jsFile, err)
+						}
+						ret, err := fn.Call(thisObj.Value(), in.Interface(), param.Interface())
+						if err != nil {
+							helper.Log.Panicf("error in javascript file '%s' while calling returned function: %s", jsFile, err)
+						}
+						retGo, err := ret.Export()
+						if err != nil {
+							helper.Log.Panicf("export error for '%s': %s", jsFile, err)
+						}
+						return pongo2.AsValue(retGo), nil
+					},
+				)
+				if err != nil {
+					helper.Log.Panicf("could not register filter from '%s': %s", jsFile, err)
+				}
+
+			}
+		}
+	}
+
+}
--- a/pkg/filter/dump.go
+++ b/pkg/filter/dump.go
@@ -0,0 +1,12 @@
+package filter
+
+import (
+	"github.com/davecgh/go-spew/spew"
+	"github.com/flosch/pongo2"
+)
+
+// DumpFilter is a pongo2 filter, which returns a spew.Dump of the input
+func DumpFilter(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	dumpString := spew.Sdump(in.Interface())
+	return pongo2.AsValue(string(dumpString)), nil
+}
--- a/pkg/filter/image_process.go
+++ b/pkg/filter/image_process.go
@@ -0,0 +1,239 @@
+package filter
+
+import (
+	"crypto/md5"
+	"errors"
+	"fmt"
+	"image"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+	"strconv"
+	"strings"
+
+	"gitbase.de/apairon/mark2web/pkg/helper"
+	"gitbase.de/apairon/mark2web/pkg/mark2web"
+	"github.com/disintegration/imaging"
+	"github.com/flosch/pongo2"
+)
+
+func parseImageParams(str string) (*mark2web.ImagingConfig, error) {
+	p := mark2web.ImagingConfig{}
+	if str == "" {
+		helper.Merge(&p, mark2web.CurrentPathConfig.Imaging)
+		// Filename and Format are only valid for current image
+		p.Filename = ""
+		p.Format = ""
+		return &p, nil
+	}
+	for _, s := range strings.Split(str, ",") {
+		e := strings.Split(s, "=")
+		if len(e) < 2 {
+			return nil, fmt.Errorf("invalid image parameter: %s", s)
+		}
+		var err error
+		switch e[0] {
+		case "w":
+			p.Width, err = strconv.Atoi(e[1])
+		case "h":
+			p.Height, err = strconv.Atoi(e[1])
+		case "f":
+			p.Filename = e[1]
+		case "t":
+			p.TargetDir = e[1]
+		case "p":
+			p.Process = e[1]
+		case "a":
+			p.Anchor = e[1]
+		case "q":
+			p.Quality, err = strconv.Atoi(e[1])
+			if p.Quality < 0 || p.Quality > 100 {
+				err = errors.New("q= must be between 1 and 100")
+			}
+		default:
+			return nil, fmt.Errorf("invalid image parameter: %s", s)
+		}
+		if err != nil {
+			return nil, fmt.Errorf("could not convert image parameter to correct value type for '%s': %s", s, err)
+		}
+	}
+	return &p, nil
+}
+
+func getImageFromURL(url string) (image.Image, string, error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, "", fmt.Errorf("could not get url '%s': %s", url, err)
+	}
+
+	img, format, err := image.Decode(resp.Body)
+	if err != nil {
+		return nil, "", fmt.Errorf("could read body from url '%s': %s", url, err)
+	}
+
+	return img, format, nil
+}
+
+// ImageProcessFilter read the image url and process parameters and saves the resized/processed image
+// param: w=WITDH,h=HEIGHT
+func ImageProcessFilter(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	imgSource := in.String()
+	p, err := parseImageParams(param.String())
+	if err != nil {
+		return nil, &pongo2.Error{
+			Sender:    "filter:image_resize",
+			OrigError: err,
+		}
+	}
+	if p == nil {
+		return nil, &pongo2.Error{
+			Sender:    "filter:image_resize",
+			OrigError: errors.New("no imaging config defined"),
+		}
+	}
+
+	var img image.Image
+	if p.Process == "" {
+		p.Process = "resize"
+	}
+	filePrefix := fmt.Sprintf(
+		"%s_%dx%d_q%03d",
+		p.Process,
+		p.Width,
+		p.Height,
+		p.Quality,
+	)
+	if strings.HasPrefix(imgSource, "http://") || strings.HasPrefix(imgSource, "https://") {
+		// remote file
+		img, p.Format, err = getImageFromURL(imgSource)
+		if err != nil {
+			return nil, &pongo2.Error{
+				Sender:    "filter:image_resize",
+				OrigError: fmt.Errorf("could not open image '%s': %s", imgSource, err),
+			}
+		}
+		// build filename
+		if p.Filename == "" {
+			var fBase string
+			if u, _ := url.Parse(imgSource); u != nil {
+				fBase = strings.Split(path.Base(u.Path), ".")[0]
+			}
+
+			p.Filename = fmt.Sprintf(
+				"%s_%x_%s.%s",
+				filePrefix,
+				md5.Sum([]byte(imgSource)),
+				fBase,
+				p.Format,
+			)
+		}
+	} else {
+		// local file
+		imgSource = mark2web.ResolveInputPath(imgSource)
+		if p.Filename == "" {
+			p.Filename = fmt.Sprintf(
+				"%s_%s",
+				filePrefix,
+				path.Base(imgSource),
+			)
+		}
+	}
+
+	var imgTarget string
+	if p.TargetDir != "" {
+		imgTarget = mark2web.ResolveOutputPath(
+			path.Clean(p.TargetDir) + "/" +
+				p.Filename,
+		)
+
+		pt := path.Dir(imgTarget)
+		if _, err := os.Stat(pt); os.IsNotExist(err) {
+			helper.Log.Infof("create image target dir: %s", pt)
+			if err := os.MkdirAll(pt, 0755); err != nil {
+				return nil, &pongo2.Error{
+					Sender:    "filter:image_resize",
+					OrigError: fmt.Errorf("could not create image target dir '%s': %s", pt, err),
+				}
+			}
+		}
+
+		p.Filename = mark2web.ResolveNavPath(p.TargetDir + "/" + p.Filename)
+
+	} else {
+		imgTarget = mark2web.ResolveOutputPath(p.Filename)
+	}
+
+	if f, err := os.Stat(imgTarget); err == nil && !f.IsDir() {
+		helper.Log.Noticef("skipped processing image from %s to %s, file already exists", imgSource, imgTarget)
+	} else {
+		helper.Log.Noticef("processing image from %s to %s", imgSource, imgTarget)
+		if strings.HasPrefix(imgSource, "http://") || strings.HasPrefix(imgSource, "https://") {
+			// webrequest before finding target filename, because of file format in filename
+		} else {
+			img, err = imaging.Open(imgSource, imaging.AutoOrientation(true))
+			if err != nil {
+				return nil, &pongo2.Error{
+					Sender:    "filter:image_resize",
+					OrigError: fmt.Errorf("could not open image '%s': %s", imgSource, err),
+				}
+			}
+		}
+
+		switch p.Process {
+		case "resize":
+			img = imaging.Resize(img, p.Width, p.Height, imaging.Lanczos)
+		case "fit":
+			img = imaging.Fit(img, p.Width, p.Height, imaging.Lanczos)
+		case "fill":
+			var anchor imaging.Anchor
+			switch strings.ToLower(p.Anchor) {
+			case "":
+				fallthrough
+			case "center":
+				anchor = imaging.Center
+			case "topleft":
+				anchor = imaging.TopLeft
+			case "top":
+				anchor = imaging.Top
+			case "topright":
+				anchor = imaging.TopRight
+			case "left":
+				anchor = imaging.Left
+			case "right":
+				anchor = imaging.Right
+			case "bottomleft":
+				anchor = imaging.BottomLeft
+			case "bottom":
+				anchor = imaging.Bottom
+			case "bottomright":
+				anchor = imaging.BottomRight
+			default:
+				return nil, &pongo2.Error{
+					Sender:    "filter:image_resize",
+					OrigError: fmt.Errorf("unknown anchor a=%s definition", p.Anchor),
+				}
+			}
+			img = imaging.Fill(img, p.Width, p.Height, anchor, imaging.Lanczos)
+		default:
+			return nil, &pongo2.Error{
+				Sender:    "filter:image_resize",
+				OrigError: fmt.Errorf("invalid p parameter '%s'", p.Process),
+			}
+		}
+
+		var encodeOptions = make([]imaging.EncodeOption, 0)
+		if p.Quality > 0 {
+			encodeOptions = append(encodeOptions, imaging.JPEGQuality(p.Quality))
+		}
+
+		err = imaging.Save(img, imgTarget, encodeOptions...)
+		if err != nil {
+			return nil, &pongo2.Error{
+				Sender:    "filter:image_resize",
+				OrigError: fmt.Errorf("could save image '%s': %s", imgTarget, err),
+			}
+		}
+	}
+	return pongo2.AsValue(mark2web.ResolveNavPath(p.Filename)), nil
+}
--- a/pkg/filter/init.go
+++ b/pkg/filter/init.go
@@ -0,0 +1,26 @@
+package filter
+
+import (
+	"github.com/flosch/pongo2"
+	_ "github.com/flosch/pongo2-addons"
+)
+
+func init() {
+	err := pongo2.ReplaceFilter("markdown", MarkdownFilter)
+	if err != nil {
+		panic(err)
+	}
+
+	newFilters := map[string]pongo2.FilterFunction{
+		"image_process": ImageProcessFilter,
+		"relative_path": RelativePathFilter,
+		"json":          JSONFilter,
+		"dump":          DumpFilter,
+	}
+	for name, fn := range newFilters {
+		err := pongo2.RegisterFilter(name, fn)
+		if err != nil {
+			panic(err)
+		}
+	}
+}
--- a/pkg/filter/json.go
+++ b/pkg/filter/json.go
@@ -0,0 +1,35 @@
+package filter
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/flosch/pongo2"
+)
+
+// JSONFilter is a pongo2 filter, which returns a json string of the input
+func JSONFilter(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	pretty := false
+	for _, s := range strings.Split(param.String(), ",") {
+		switch s {
+		case "pretty":
+			pretty = true
+		}
+	}
+	var err error
+	var jsonBytes []byte
+	if pretty {
+		jsonBytes, err = json.MarshalIndent(in.Interface(), "", "    ")
+
+	} else {
+		jsonBytes, err = json.Marshal(in.Interface())
+	}
+	if err != nil {
+		return nil, &pongo2.Error{
+			Sender:    "filter:json",
+			OrigError: err,
+		}
+	}
+
+	return pongo2.AsSafeValue(string(jsonBytes)), nil
+}
--- a/pkg/filter/markdown.go
+++ b/pkg/filter/markdown.go
@@ -0,0 +1,29 @@
+package filter
+
+import (
+	"gitbase.de/apairon/mark2web/pkg/helper"
+	"gitbase.de/apairon/mark2web/pkg/mark2web"
+	"github.com/flosch/pongo2"
+)
+
+// MarkdownFilter is a pongo2 filter, which converts markdown to html
+func MarkdownFilter(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	chromaRenderer := false
+	chromaStyle := "monokai"
+	if m := mark2web.CurrentPathConfig.Markdown; m != nil {
+		if m.ChromaRenderer != nil && *m.ChromaRenderer {
+			chromaRenderer = true
+		}
+		if m.ChromaStyle != nil && *m.ChromaStyle != "" {
+			chromaStyle = *m.ChromaStyle
+		}
+	}
+	return pongo2.AsSafeValue(
+			string(
+				helper.RenderMarkdown(
+					[]byte(in.String()),
+					chromaRenderer,
+					chromaStyle,
+				))),
+		nil
+}
--- a/pkg/filter/relative_path.go
+++ b/pkg/filter/relative_path.go
@@ -0,0 +1,15 @@
+package filter
+
+import (
+	"gitbase.de/apairon/mark2web/pkg/mark2web"
+	"github.com/flosch/pongo2"
+)
+
+// RelativePathFilter returns the relative path to navpoint based on current nav
+func RelativePathFilter(in, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	return pongo2.AsValue(
+		mark2web.ResolveNavPath(
+			in.String(),
+		),
+	), nil
+}
--- a/pkg/helper/dir.go
+++ b/pkg/helper/dir.go
@@ -0,0 +1,38 @@
+package helper
+
+import (
+	"os"
+	"strings"
+)
+
+// CreateDirectory creates direcory with all missing parents and panic if error
+func CreateDirectory(dir string) {
+	Log.Debugf("trying to create output directory: %s", dir)
+
+	if dirH, err := os.Stat(dir); os.IsNotExist(err) {
+		err := os.MkdirAll(dir, 0755)
+		if err != nil {
+			Log.Panicf("could not create output directory '%s': %s", dir, err)
+		}
+		Log.Noticef("created output directory: %s", dir)
+	} else if dirH != nil {
+		if dirH.IsDir() {
+			Log.Noticef("output directory '%s' already exists", dir)
+		} else {
+			Log.Panicf("output directory '%s' is no directory", dir)
+		}
+	} else {
+		Log.Panicf("unknown error for output directory '%s': %s", dir, err)
+	}
+}
+
+// BackToRoot builds ../../ string
+func BackToRoot(curNavPath string) string {
+	tmpPath := ""
+	if curNavPath != "" {
+		for i := strings.Count(curNavPath, "/") + 1; i > 0; i-- {
+			tmpPath += "../"
+		}
+	}
+	return tmpPath
+}
--- a/pkg/helper/logger.go
+++ b/pkg/helper/logger.go
@@ -0,0 +1,52 @@
+package helper
+
+import (
+	"os"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/op/go-logging"
+)
+
+// Log is global logger
+var Log = logging.MustGetLogger("myLogger")
+
+// ConfigureLogger sets logger backend and level
+func ConfigureLogger(level string) {
+	logBackend := logging.NewLogBackend(os.Stderr, "", 0)
+	logBackendFormatter := logging.NewBackendFormatter(logBackend, logging.MustStringFormatter(
+		`%{color}%{time:15:04:05.000} %{shortfunc} ▶ %{level:.4s} %{id:03x}%{color:reset} %{message}`,
+	))
+	logBackendLeveled := logging.AddModuleLevel(logBackendFormatter)
+	logBackendLevel := logging.INFO
+	switch level {
+	case "debug":
+		logBackendLevel = logging.DEBUG
+		break
+
+	case "info":
+		logBackendLevel = logging.INFO
+		break
+
+	case "notice":
+		logBackendLevel = logging.NOTICE
+		break
+
+	case "warning":
+		logBackendLevel = logging.WARNING
+		break
+
+	case "error":
+		logBackendLevel = logging.ERROR
+		break
+
+	}
+	logBackendLeveled.SetLevel(logBackendLevel, "")
+	logging.SetBackend(logBackendLeveled)
+}
+
+func init() {
+	spew.Config.DisablePointerAddresses = true
+	spew.Config.DisableCapacities = true
+	spew.Config.DisableMethods = true
+	spew.Config.DisablePointerMethods = true
+}
--- a/pkg/helper/map_string.go
+++ b/pkg/helper/map_string.go
@@ -0,0 +1,47 @@
+package helper
+
+import "fmt"
+
+// MapString is a map[string]interface{} which always unmarsahls yaml to map[string]interface{}
+type MapString map[string]interface{}
+
+// UnmarshalYAML handles all maps as map[string]interface{} for later JSON
+// see https://github.com/elastic/beats/blob/6435194af9f42cbf778ca0a1a92276caf41a0da8/libbeat/common/mapstr.go
+func (ms *MapString) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var result map[interface{}]interface{}
+	err := unmarshal(&result)
+	if err != nil {
+		return err
+	}
+	*ms = cleanUpInterfaceMap(result)
+	return nil
+}
+
+func cleanUpInterfaceArray(in []interface{}) []interface{} {
+	result := make([]interface{}, len(in))
+	for i, v := range in {
+		result[i] = cleanUpMapValue(v)
+	}
+	return result
+}
+
+func cleanUpInterfaceMap(in map[interface{}]interface{}) MapString {
+	result := make(MapString)
+	for k, v := range in {
+		result[fmt.Sprintf("%v", k)] = cleanUpMapValue(v)
+	}
+	return result
+}
+
+func cleanUpMapValue(v interface{}) interface{} {
+	switch v := v.(type) {
+	case []interface{}:
+		return cleanUpInterfaceArray(v)
+	case map[interface{}]interface{}:
+		return cleanUpInterfaceMap(v)
+	case string, bool, int, int8, int16, int32, int64, float32, float64:
+		return v
+	default:
+		return fmt.Sprintf("%v", v)
+	}
+}
--- a/pkg/helper/markdown.go
+++ b/pkg/helper/markdown.go
@@ -0,0 +1,29 @@
+package helper
+
+import (
+	"bytes"
+
+	"github.com/Depado/bfchroma"
+	"gopkg.in/russross/blackfriday.v2"
+)
+
+func RenderMarkdown(input []byte, chromaRenderer bool, chromaStyle string) []byte {
+	var options []blackfriday.Option
+
+	if chromaStyle == "" {
+		chromaStyle = "monokai"
+	}
+	if chromaRenderer {
+		options = []blackfriday.Option{
+			blackfriday.WithRenderer(
+				bfchroma.NewRenderer(
+					bfchroma.Style(chromaStyle),
+				),
+			),
+		}
+	}
+
+	// fix \r from markdown for blackfriday
+	input = bytes.Replace(input, []byte("\r"), []byte(""), -1)
+	return blackfriday.Run(input, options...)
+}
--- a/pkg/helper/merge.go
+++ b/pkg/helper/merge.go
@@ -0,0 +1,28 @@
+package helper
+
+import (
+	"reflect"
+
+	"github.com/imdario/mergo"
+)
+
+type ptrTransformer struct{}
+
+func (t ptrTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error {
+	if typ.Kind() == reflect.Ptr {
+		return func(dst, src reflect.Value) error {
+			if dst.CanSet() {
+				if dst.IsNil() {
+					dst.Set(src)
+				}
+			}
+			return nil
+		}
+	}
+	return nil
+}
+
+// Merge merges 2 objects or maps
+func Merge(dst, src interface{}) error {
+	return mergo.Merge(dst, src, mergo.WithTransformers(ptrTransformer{}))
+}
--- a/pkg/helper/webrequest.go
+++ b/pkg/helper/webrequest.go
@@ -0,0 +1,52 @@
+package helper
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"strings"
+)
+
+func JSONWebRequest(url string) interface{} {
+	Log.Noticef("requesting url via GET %s", url)
+
+	resp, err := http.Get(url)
+	if err != nil {
+		Log.Panicf("could not get url '%s': %s", url, err)
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		Log.Panicf("could not read body from url '%s': %s", url, err)
+	}
+
+	Log.Debugf("output from url '%s':\n%s", url, string(body))
+
+	if resp.StatusCode >= 400 {
+		Log.Panicf("bad status '%d - %s' from url '%s'", resp.StatusCode, resp.Status, url)
+	}
+
+	contentType := resp.Header.Get("Content-Type")
+
+	if strings.Contains(contentType, "json") {
+
+	} else {
+		Log.Panicf("is not json '%s' from url '%s'", contentType, url)
+	}
+
+	jsonMap := make(map[string]interface{})
+	err = json.Unmarshal(body, &jsonMap)
+	if err == nil {
+		return jsonMap
+	}
+
+	jsonArrayMap := make([]map[string]interface{}, 0)
+	err = json.Unmarshal(body, &jsonArrayMap)
+	if err == nil {
+		return jsonArrayMap
+	}
+
+	Log.Panicf("could not read json from '%s': invalid type", url)
+	return nil
+}
--- a/pkg/mark2web/assets.go
+++ b/pkg/mark2web/assets.go
@@ -0,0 +1,52 @@
+package mark2web
+
+import (
+	"log"
+	"path"
+	"regexp"
+	"strings"
+
+	"gitbase.de/apairon/mark2web/pkg/helper"
+	cpy "github.com/otiai10/copy"
+)
+
+// ProcessAssets copies the assets from input to output dir
+func ProcessAssets() {
+	switch Config.Assets.Action {
+	case "copy":
+		from := Config.Assets.FromPath
+		to := Config.Assets.ToPath
+		if !strings.HasPrefix(from, "/") {
+			from = Config.Directories.Input + "/" + from
+		}
+		if !strings.HasPrefix(to, "/") {
+			to = Config.Directories.Output + "/" + to
+		}
+		helper.Log.Noticef("copying assets from '%s' to '%s'", from, to)
+		err := cpy.Copy(from, to)
+		if err != nil {
+			helper.Log.Panicf("could not copy assets from '%s' to '%s': %s", from, to, err)
+		}
+	}
+}
+
+// fixAssetsPath replaces assets path based on current path
+func fixAssetsPath(str, curNavPath string) string {
+	if find := Config.Assets.FixTemplate.Find; find != "" {
+		helper.Log.Debugf("fixing assets paths for path '%s'", curNavPath)
+		repl := Config.Assets.FixTemplate.Replace
+		toPath := Config.Assets.ToPath
+
+		bToRoot := helper.BackToRoot(curNavPath)
+		regex, err := regexp.Compile(find)
+		if err != nil {
+			log.Panicf("could not compile regexp '%s' for assets path: %s", find, err)
+		}
+		repl = bToRoot + toPath + "/" + repl
+		repl = path.Clean(repl) + "/"
+		helper.Log.Debugf("new assets paths: %s", repl)
+		return regex.ReplaceAllString(str, repl)
+	}
+
+	return str
+}
--- a/pkg/mark2web/config_global.go
+++ b/pkg/mark2web/config_global.go
@@ -0,0 +1,47 @@
+package mark2web
+
+import (
+	"io/ioutil"
+
+	"gopkg.in/yaml.v2"
+)
+
+// GlobalConfig is config which is used only once in root dir
+type GlobalConfig struct {
+	Webserver struct {
+		Type string `yaml:"Type"`
+	} `yaml:"Webserver"`
+
+	Assets struct {
+		FromPath    string `yaml:"FromPath"`
+		ToPath      string `yaml:"ToPath"`
+		Action      string `yaml:"Action"`
+		FixTemplate struct {
+			Find    string `yaml:"Find"`
+			Replace string `yaml:"Replace"`
+		} `yaml:"FixTemplate"`
+	} `yaml:"Assets"`
+
+	OtherFiles struct {
+		Action string `yaml:"Action"`
+	} `yaml:"OtherFiles"`
+
+	Directories struct {
+		Input  string
+		Output string
+	}
+}
+
+var Config = new(GlobalConfig)
+
+func (c *GlobalConfig) ReadFromFile(filename string) error {
+	data, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return err
+	}
+	err = yaml.Unmarshal(data, c)
+	if err != nil {
+		return err
+	}
+	return nil
+}
--- a/pkg/mark2web/config_path.go
+++ b/pkg/mark2web/config_path.go
@@ -0,0 +1,87 @@
+package mark2web
+
+import "gitbase.de/apairon/mark2web/pkg/helper"
+
+// CollectionConfig describes a collection
+type CollectionConfig struct {
+	Name        *string `yaml:"Name"`
+	URL         *string `yaml:"URL"`
+	NavTemplate *struct {
+		EntriesAttribute string `yaml:"EntriesAttribute"`
+		GoTo             string `yaml:"GoTo"`
+		Navname          string `yaml:"Navname"`
+		Body             string `yaml:"Body"`
+		DataKey          string `yaml:"DataKey"`
+		Hidden           bool   `yaml:"Hidden"`
+		Template         string `yaml:"Template"`
+		//Recursive        bool   `yaml:"Recursive"`
+	} `yaml:"NavTemplate"`
+}
+
+// ThisPathConfig is struct for This in paths yaml
+type ThisPathConfig struct {
+	Navname     *string             `yaml:"Navname"`
+	GoTo        *string             `yaml:"GoTo"`
+	Collections []*CollectionConfig `yaml:"Collections"`
+	Data        helper.MapString    `yaml:"Data"`
+}
+
+// IndexConfig describes index input and output file
+type IndexConfig struct {
+	InputFile   *string `yaml:"InputFile"`
+	InputString *string `yaml:"InputString"`
+	OutputFile  *string `yaml:"OutputFile"`
+}
+
+// MetaData describes meta data for current site/tree node
+type MetaData struct {
+	Title       *string `yaml:"Title"`
+	Description *string `yaml:"Description"`
+	Keywords    *string `yaml:"Keywords"`
+}
+
+// DirnameConfig describes how to handle directory names
+type DirnameConfig struct {
+	Strip        *string `yaml:"Strip"`
+	IgnoreForNav *string `yaml:"IgnoreForNav"`
+}
+
+// FilenameConfig describes how to handle filenames
+type FilenameConfig struct {
+	Strip           *string `yaml:"Strip"`
+	Ignore          *string `yaml:"Ignore"`
+	OutputExtension *string `yaml:"OutputExtension"`
+}
+
+// MarkdownConfig describes markdown handling
+type MarkdownConfig struct {
+	ChromaRenderer *bool   `yaml:"ChromaRenderer"`
+	ChromaStyle    *string `yaml:"ChromaStyle"`
+}
+
+// ImagingConfig defines parameter for imaging processing
+type ImagingConfig struct {
+	Width   int    `yaml:"Width"`
+	Height  int    `yaml:"Height"`
+	Process string `yaml:"Process"`
+	Anchor  string `yaml:"Anchor"`
+	Quality int    `yaml:"Quality"`
+
+	TargetDir string `yaml:"-"`
+	Filename  string `yaml:"-"`
+	Format    string `yaml:"-"`
+}
+
+// PathConfig of subdir
+type PathConfig struct {
+	This     ThisPathConfig  `yaml:"This"`
+	Template *string         `yaml:"Template"`
+	Index    *IndexConfig    `yaml:"Index"`
+	Meta     *MetaData       `yaml:"Meta"`
+	Path     *DirnameConfig  `yaml:"Path"`
+	Filename *FilenameConfig `yaml:"Filename"`
+	Markdown *MarkdownConfig `yaml:"Markdown"`
+	Imaging  *ImagingConfig  `yaml:"Imaging"`
+
+	Data helper.MapString `yaml:"Data"`
+}
--- a/pkg/mark2web/content.go
+++ b/pkg/mark2web/content.go
@@ -0,0 +1,300 @@
+package mark2web
+
+import (
+	"bytes"
+	"io/ioutil"
+	"path"
+	"regexp"
+	"strings"
+
+	"gitbase.de/apairon/mark2web/pkg/helper"
+	"github.com/davecgh/go-spew/spew"
+	"github.com/flosch/pongo2"
+	cpy "github.com/otiai10/copy"
+	"gopkg.in/yaml.v2"
+)
+
+// ReadContentDir walks through content directory and builds the tree of configurations
+func (node *TreeNode) ReadContentDir(inBase string, outBase string, dir string, conf *PathConfig) {
+	if node.root == nil {
+		// first node is root
+		node.root = node
+	}
+	node.fillConfig(inBase, outBase, dir, conf)
+
+	files, err := ioutil.ReadDir(node.InputPath)
+	if err != nil {
+		helper.Log.Panic(err)
+	}
+
+	// first only files
+	for _, f := range files {
+		p := node.InputPath + "/" + f.Name()
+		if !f.IsDir() && f.Name() != "config.yml" {
+			switch path.Ext(f.Name()) {
+			case ".md":
+				helper.Log.Debugf(".MD %s", p)
+				if node.InputFiles == nil {
+					node.InputFiles = make([]string, 0)
+				}
+				node.InputFiles = append(node.InputFiles, f.Name())
+				break
+			default:
+				helper.Log.Debugf("FIL %s", p)
+				if node.OtherFiles == nil {
+					node.OtherFiles = make([]string, 0)
+				}
+				node.OtherFiles = append(node.OtherFiles, f.Name())
+			}
+		}
+	}
+
+	// only directorys, needed config before
+	for _, f := range files {
+		p := node.InputPath + "/" + f.Name()
+		if f.IsDir() {
+			helper.Log.Debugf("DIR %s", p)
+			newTree := new(TreeNode)
+			newTree.root = node.root
+			if node.Sub == nil {
+				node.Sub = make([]*TreeNode, 0)
+			}
+			node.Sub = append(node.Sub, newTree)
+			newTree.ReadContentDir(node.InputPath, node.OutputPath, f.Name(), node.Config)
+		}
+	}
+}
+
+// ProcessContent walks recursivly through the input paths and processes all files for output
+func (node *TreeNode) ProcessContent() {
+	helper.CreateDirectory(node.OutputPath)
+
+	curNavPath := strings.TrimPrefix(node.OutputPath, Config.Directories.Output)
+	curNavPath = strings.TrimPrefix(curNavPath, "/")
+	curNavPath = path.Clean(curNavPath)
+	if curNavPath == "." {
+		curNavPath = ""
+	}
+
+	goTo := node.Config.This.GoTo
+	if goTo != nil && *goTo != "" {
+		goToFixed := *goTo
+		if strings.HasPrefix(goToFixed, "/") {
+			goToFixed = helper.BackToRoot(curNavPath) + goToFixed
+		}
+		goToFixed = path.Clean(goToFixed)
+
+		switch Config.Webserver.Type {
+		case "apache":
+			htaccessFile := node.OutputPath + "/.htaccess"
+			helper.Log.Noticef("writing '%s' with redirect to: %s", htaccessFile, goToFixed)
+			err := ioutil.WriteFile(htaccessFile, []byte(`RewriteEngine on
+RewriteRule ^$ %{REQUEST_URI}`+goToFixed+`/ [R,L]
+`), 0644)
+			if err != nil {
+				helper.Log.Panicf("could not write '%s': %s", htaccessFile, err)
+			}
+			break
+		}
+	}
+
+	for _, file := range node.InputFiles {
+		var input []byte
+		inFile := "InputString"
+
+		if file != "" {
+			inFile = node.InputPath + "/" + file
+			helper.Log.Debugf("reading file: %s", inFile)
+
+			var err error
+			input, err = ioutil.ReadFile(inFile)
+			if err != nil {
+				helper.Log.Panicf("could not read '%s':%s", inFile, err)
+			}
+			helper.Log.Infof("processing input file '%s'", inFile)
+		} else {
+			// use input string if available and input filename == ""
+			var inputString *string
+			if i := node.Config.Index; i != nil {
+				inputString = i.InputString
+			}
+			if inputString != nil {
+				helper.Log.Debugf("using input string instead of file")
+				input = []byte(*inputString)
+			}
+		}
+
+		newConfig := new(PathConfig)
+
+		regex := regexp.MustCompile("(?s)^---(.*?)\\r?\\n\\r?---\\r?\\n\\r?")
+		yamlData := regex.Find(input)
+		if string(yamlData) != "" {
+			// replace tabs
+			yamlData = bytes.Replace(yamlData, []byte("\t"), []byte("    "), -1)
+
+			helper.Log.Debugf("found yaml header in '%s', merging config", inFile)
+			err := yaml.Unmarshal(yamlData, newConfig)
+			if err != nil {
+				helper.Log.Panicf("could not parse YAML header from '%s': %s", inFile, err)
+			}
+
+			helper.Log.Debug("merging config with upper config")
+			oldThis := newConfig.This
+			helper.Merge(newConfig, node.Config)
+			newConfig.This = oldThis
+
+			helper.Log.Debug(spew.Sdump(newConfig))
+
+			input = regex.ReplaceAll(input, []byte(""))
+		} else {
+			helper.Merge(newConfig, node.Config)
+		}
+
+		// ignore ???
+		ignoreFile := false
+		var ignoreRegex *string
+		var stripRegex *string
+		var outputExt *string
+		if f := newConfig.Filename; f != nil {
+			ignoreRegex = f.Ignore
+			stripRegex = f.Strip
+			outputExt = f.OutputExtension
+		}
+		if ignoreRegex != nil && *ignoreRegex != "" {
+			regex, err := regexp.Compile(*ignoreRegex)
+			if err != nil {
+				helper.Log.Panicf("could not compile filename.ignore regexp '%s' for file '%s': %s", *ignoreRegex, inFile, err)
+			}
+			ignoreFile = regex.MatchString(file)
+		}
+
+		if ignoreFile {
+			helper.Log.Infof("ignoring file '%s', because of filename.ignore", inFile)
+		} else {
+
+			// build output filename
+			outputFilename := file
+
+			var indexInputFile *string
+			var indexOutputFile *string
+			if i := newConfig.Index; i != nil {
+				indexInputFile = i.InputFile
+				indexOutputFile = i.OutputFile
+			}
+
+			if indexInputFile != nil &&
+				*indexInputFile == file &&
+				indexOutputFile != nil &&
+				*indexOutputFile != "" {
+				outputFilename = *indexOutputFile
+			} else {
+				if stripRegex != nil && *stripRegex != "" {
+					regex, err := regexp.Compile(*stripRegex)
+					if err != nil {
+						helper.Log.Panicf("could not compile filename.strip regexp '%s' for file '%s': %s", *stripRegex, inFile, err)
+					}
+					outputFilename = regex.ReplaceAllString(outputFilename, "$1")
+				}
+				if outputExt != nil && *outputExt != "" {
+					outputFilename += "." + *outputExt
+				}
+			}
+
+			outFile := node.OutputPath + "/" + outputFilename
+			helper.Log.Debugf("using '%s' as output file", outFile)
+
+			// use --- for splitting document in markdown parts
+			regex := regexp.MustCompile("\\r?\\n\\r?---\\r?\\n\\r?")
+			inputParts := regex.Split(string(input), -1)
+			htmlParts := make([]*pongo2.Value, 0)
+
+			chromaRenderer := false
+			chromaStyle := "monokai"
+			if m := newConfig.Markdown; m != nil {
+				if m.ChromaRenderer != nil && *m.ChromaRenderer {
+					chromaRenderer = true
+				}
+				if m.ChromaStyle != nil && *m.ChromaStyle != "" {
+					chromaStyle = *m.ChromaStyle
+				}
+			}
+			for _, iPart := range inputParts {
+				htmlParts = append(htmlParts,
+					pongo2.AsSafeValue(
+						string(helper.RenderMarkdown([]byte(iPart), chromaRenderer, chromaStyle))))
+			}
+
+			// build navigation
+			navMap := make(map[string]*NavElement)
+			navSlice := make([]*NavElement, 0)
+			navActive := make([]*NavElement, 0)
+			buildNavigation(node.root, &navMap, &navSlice, &navActive, curNavPath)
+
+			// read yaml header as data for template
+			ctx := NewContext()
+			ctx["This"] = newConfig.This
+			ctx["Meta"] = newConfig.Meta
+			ctx["Data"] = newConfig.Data
+			ctx["ColMap"] = node.root.ColMap // root as NavMap and NavSlice, for sub go to NavElement.ColMap
+			ctx["NavMap"] = navMap
+			ctx["NavSlice"] = navSlice
+			ctx["NavActive"] = navActive
+			ctx["Body"] = pongo2.AsSafeValue(string(helper.RenderMarkdown(input, chromaRenderer, chromaStyle)))
+			ctx["BodyParts"] = htmlParts
+			ctx["CurrentPath"] = curNavPath
+			// set active nav element
+			if len(navActive) > 0 {
+				ctx["NavElement"] = navActive[len(navActive)-1]
+			} else {
+				// if no active path to content, we are in root dir
+				ctx["NavElement"] = &NavElement{
+					GoTo:     helper.BackToRoot(curNavPath),
+					Active:   true,
+					ColMap:   node.ColMap,
+					Data:     node.Config.Data,
+					This:     node.Config.This,
+					SubMap:   &navMap,
+					SubSlice: &navSlice,
+				}
+			}
+
+			helper.Log.Debugf("rendering template '%s' for '%s'", *newConfig.Template, outFile)
+			templateFilename := *newConfig.Template
+			result, err := renderTemplate(*newConfig.Template, node, newConfig, &ctx)
+			if err != nil {
+				helper.Log.Panicf("could not execute template '%s' for input file '%s': %s", templateFilename, inFile, err)
+			}
+
+			result = fixAssetsPath(result, curNavPath)
+
+			helper.Log.Noticef("writing to output file: %s", outFile)
+			err = ioutil.WriteFile(outFile, []byte(result), 0644)
+			if err != nil {
+				helper.Log.Panicf("could not write to output file '%s': %s", outFile, err)
+			}
+
+			//fmt.Println(string(html))
+		}
+	}
+
+	// process other files, copy...
+	for _, file := range node.OtherFiles {
+		switch Config.OtherFiles.Action {
+		case "copy":
+			from := node.InputPath + "/" + file
+			to := node.OutputPath + "/" + file
+			helper.Log.Noticef("copying file from '%s' to '%s'", from, to)
+			err := cpy.Copy(from, to)
+			if err != nil {
+				helper.Log.Panicf("could not copy file from '%s' to '%s': %s", from, to, err)
+			}
+		}
+	}
+
+	i := 0
+	// sub can dynamically increase, so no for range
+	for i < len(node.Sub) {
+		node.Sub[i].ProcessContent()
+		i++
+	}
+}
--- a/pkg/mark2web/context.go
+++ b/pkg/mark2web/context.go
@@ -0,0 +1,269 @@
+package mark2web
+
+import (
+	"io/ioutil"
+	"os"
+	"path"
+	"regexp"
+	"strings"
+	"time"
+
+	"gitbase.de/apairon/mark2web/pkg/helper"
+	"github.com/davecgh/go-spew/spew"
+	"github.com/extemporalgenome/slug"
+	"github.com/flosch/pongo2"
+	"gopkg.in/yaml.v2"
+)
+
+var CurrentContext *pongo2.Context
+var CurrentTreeNode *TreeNode
+var CurrentPathConfig *PathConfig
+
+func NewContext() pongo2.Context {
+	ctx := pongo2.Context{
+		"fnRequest": RequestFn,
+		"fnRender":  RenderFn,
+
+		"AssetsPath": Config.Assets.ToPath,
+		"Timestamp":  time.Now().Unix,
+	}
+	CurrentContext = &ctx
+
+	return ctx
+}
+
+func (node *TreeNode) handleCollections() {
+	for _, colConfig := range node.Config.This.Collections {
+		if colConfig != nil {
+			if colConfig.Name == nil || *colConfig.Name == "" {
+				helper.Log.Panicf("missing Name in collection config in '%s'", node.InputPath)
+			}
+			if colConfig.URL == nil || *colConfig.URL == "" {
+				helper.Log.Panicf("missing EntriesJSON in collection config in '%s'", node.InputPath)
+			}
+		}
+
+		if node.ColMap == nil {
+			node.ColMap = make(helper.MapString)
+		}
+		ctx := NewContext()
+		ctx["This"] = node.Config.This
+		ctx["Data"] = node.Config.Data
+
+		url, err := pongo2.RenderTemplateString(*colConfig.URL, ctx)
+		if err != nil {
+			helper.Log.Panicf("invalid template string for Collection Element.URL in '%s': %s", node.InputPath, err)
+		}
+
+		colData := helper.JSONWebRequest(url)
+		node.ColMap[*colConfig.Name] = colData
+
+		if navT := colConfig.NavTemplate; navT != nil {
+			var entries []interface{}
+			var ok bool
+			if navT.EntriesAttribute != "" {
+				var colDataMap map[string]interface{}
+				if colDataMap, ok = colData.(map[string]interface{}); ok {
+					entries, ok = colDataMap[navT.EntriesAttribute].([]interface{})
+					if !ok {
+						helper.Log.Debug(spew.Sdump(colDataMap))
+						helper.Log.Panicf("invalid json data in [%s] from url '%s' for entries", navT.EntriesAttribute, url)
+					}
+				}
+			} else {
+				entries, ok = colData.([]interface{})
+			}
+			if !ok {
+				helper.Log.Debug(spew.Sdump(colData))
+				helper.Log.Panicf("invalid json data from url '%s', need array of objects for entries or object with configured NavTemplate.EntriesAttribute", url)
+			}
+
+			// build navigation with detail sites
+			for idx, colEl := range entries {
+				ctxE := make(pongo2.Context)
+				err := helper.Merge(&ctxE, ctx)
+				if err != nil {
+					helper.Log.Panicf("could not merge context in '%s': %s", node.InputPath, err)
+				}
+				var jsonCtx map[string]interface{}
+				if jsonCtx, ok = colEl.(map[string]interface{}); !ok {
+					helper.Log.Debug(spew.Sdump(colEl))
+					helper.Log.Panicf("no json object for entry index %d from url '%s'", idx, url)
+				}
+				err = helper.Merge(&ctxE, pongo2.Context(jsonCtx))
+				if err != nil {
+					helper.Log.Panicf("could not merge context in '%s': %s", node.InputPath, err)
+				}
+
+				tpl := ""
+				if navT.Template != "" {
+					tpl, err = pongo2.RenderTemplateString(navT.Template, ctxE)
+					if err != nil {
+						helper.Log.Panicf("invalid template string for NavTemplate.Template in '%s': %s", node.InputPath, err)
+					}
+				}
+				if tpl == "" {
+					tpl = *node.Config.Template
+				}
+
+				dataKey := ""
+				if navT.DataKey != "" {
+					dataKey, err = pongo2.RenderTemplateString(navT.DataKey, ctxE)
+					if err != nil {
+						helper.Log.Panicf("invalid template string for NavTemplate.DataKey in '%s': %s", node.InputPath, err)
+					}
+				}
+
+				goTo, err := pongo2.RenderTemplateString(navT.GoTo, ctxE)
+				if err != nil {
+					helper.Log.Panicf("invalid template string for NavTemplate.GoTo in '%s': %s", node.InputPath, err)
+				}
+				goTo = strings.Trim(goTo, "/")
+				goTo = path.Clean(goTo)
+
+				if strings.Contains(goTo, "..") {
+					helper.Log.Panicf("going back via .. in NavTemplate.GoTo forbidden in collection config in '%s': %s", node.InputPath, goTo)
+				}
+				if goTo == "." {
+					helper.Log.Panicf("invalid config '.' for NavTemplate.GoTo in collection config in '%s'", node.InputPath)
+				}
+				if goTo == "" {
+					helper.Log.Panicf("missing NavTemplate.GoTo in collection config in '%s'", node.InputPath)
+				}
+
+				navname := ""
+				if navT.Navname != "" {
+					navname, err = pongo2.RenderTemplateString(navT.Navname, ctxE)
+					if err != nil {
+						helper.Log.Panicf("invalid template string for NavTemplate.Navname in '%s': %s", node.InputPath, err)
+					}
+				}
+				body := ""
+				if navT.Body != "" {
+					body, err = pongo2.RenderTemplateString(navT.Body, ctxE)
+					if err != nil {
+						helper.Log.Panicf("invalid template string for NavTemplate.Body in '%s': %s", node.InputPath, err)
+					}
+				}
+
+				Add2Nav(node, node.Config, tpl, goTo, navname, colEl, dataKey, body, navT.Hidden)
+			}
+		}
+	}
+
+}
+
+func (node *TreeNode) fillConfig(inBase, outBase, dir string, conf *PathConfig) {
+	inPath := inBase
+	if dir != "" {
+		inPath += "/" + dir
+	}
+
+	helper.Log.Infof("reading input directory: %s", inPath)
+
+	node.InputPath = inPath
+
+	// read config
+	newConfig := new(PathConfig)
+	helper.Log.Debug("looking for config.yml ...")
+	configFile := inPath + "/config.yml"
+	if _, err := os.Stat(configFile); os.IsNotExist(err) {
+		helper.Log.Debug("no config.yml found in this directory, using upper configs")
+		helper.Merge(newConfig, conf)
+		// remove this
+		newConfig.This = ThisPathConfig{}
+	} else {
+		helper.Log.Debug("reading config...")
+		data, err := ioutil.ReadFile(configFile)
+		if err != nil {
+			helper.Log.Panicf("could not read file '%s': %s", configFile, err)
+		}
+		err = yaml.Unmarshal(data, newConfig)
+		if err != nil {
+			helper.Log.Panicf("could not parse YAML file '%s': %s", configFile, err)
+		}
+
+		helper.Log.Debug("merging config with upper config")
+		oldThis := newConfig.This
+		helper.Merge(newConfig, conf)
+		newConfig.This = oldThis
+
+		helper.Log.Debug(spew.Sdump(newConfig))
+	}
+
+	node.Config = newConfig
+
+	// calc outDir
+	stripedDir := dir
+	var regexStr *string
+	if newConfig.Path != nil {
+		regexStr = newConfig.Path.Strip
+	}
+	if regexStr != nil && *regexStr != "" {
+		if regex, err := regexp.Compile(*regexStr); err != nil {
+			helper.Log.Panicf("error compiling path.strip regex '%s' from '%s': %s", *regexStr, inBase+"/"+dir, err)
+		} else {
+			stripedDir = regex.ReplaceAllString(stripedDir, "$1")
+		}
+	}
+
+	if node.Config.This.Navname == nil {
+		navname := strings.Replace(stripedDir, "_", " ", -1)
+		node.Config.This.Navname = &navname
+	}
+
+	stripedDir = slug.Slug(stripedDir)
+	outPath := outBase + "/" + stripedDir
+	outPath = path.Clean(outPath)
+
+	helper.Log.Infof("calculated output directory: %s", outPath)
+	node.OutputPath = outPath
+
+	// handle collections
+	node.handleCollections()
+}
+
+func Add2Nav(currentNode *TreeNode, pathConfig *PathConfig, tplFilename, outDir string, navname string, ctx interface{}, dataMapKey string, body string, hidden bool) {
+	newNode := new(TreeNode)
+	newNode.root = currentNode.root
+	newNode.fillConfig(
+		currentNode.InputPath,
+		currentNode.OutputPath,
+		outDir,
+		pathConfig,
+	)
+	if navname != "" {
+		newNode.Config.This = ThisPathConfig{
+			Navname: &navname,
+		}
+	}
+	if dataMapKey != "" {
+		if newNode.Config.Data == nil {
+			newNode.Config.Data = make(helper.MapString)
+		}
+		// as submap in Data
+		newNode.Config.Data[dataMapKey] = ctx
+	} else if m, ok := ctx.(map[string]interface{}); ok {
+		// direct set data
+		newNode.Config.Data = m
+	}
+
+	// fake via normal file behavior
+	newNode.Config.Template = &tplFilename
+	newNode.InputFiles = []string{""} // empty file is special for use InputString
+	indexInFile := ""
+	indexOutFile := "index.html"
+	if idx := newNode.Config.Index; idx != nil {
+		if idx.OutputFile != nil && *idx.OutputFile != "" {
+			indexOutFile = *idx.OutputFile
+		}
+	}
+	newNode.Config.Index = &IndexConfig{
+		InputFile:   &indexInFile,
+		OutputFile:  &indexOutFile,
+		InputString: &body,
+	}
+	newNode.Hidden = hidden
+
+	currentNode.Sub = append(currentNode.Sub, newNode)
+}
--- a/pkg/mark2web/context_fn.go
+++ b/pkg/mark2web/context_fn.go
@@ -0,0 +1,31 @@
+package mark2web
+
+import (
+	"gitbase.de/apairon/mark2web/pkg/helper"
+	"github.com/flosch/pongo2"
+)
+
+// RequestFn will make a web request and returns map[string]interface form pongo2
+func RequestFn(url *pongo2.Value, args ...*pongo2.Value) *pongo2.Value {
+	u := url.String()
+	return pongo2.AsValue(helper.JSONWebRequest(u))
+}
+
+// RenderFn renders a pongo2 template with additional context
+func RenderFn(templateFilename, outDir, ctx *pongo2.Value, param ...*pongo2.Value) *pongo2.Value {
+	dataMapKey := ""
+	body := ""
+
+	for i, p := range param {
+		switch i {
+		case 0:
+			dataMapKey = p.String()
+		case 1:
+			body = p.String()
+		}
+	}
+
+	Add2Nav(CurrentTreeNode, CurrentPathConfig, templateFilename.String(), outDir.String(), "", ctx.Interface(), dataMapKey, body, true)
+
+	return pongo2.AsValue(nil)
+}
--- a/pkg/mark2web/navigation.go
+++ b/pkg/mark2web/navigation.go
@@ -0,0 +1,103 @@
+package mark2web
+
+import (
+	"path"
+	"regexp"
+	"strings"
+
+	"gitbase.de/apairon/mark2web/pkg/helper"
+)
+
+// NavElement is one element with ist attributes and subs
+type NavElement struct {
+	Navname string
+	GoTo    string
+	Active  bool
+
+	ColMap helper.MapString
+
+	Data interface{}
+
+	This ThisPathConfig
+
+	SubMap   *map[string]*NavElement
+	SubSlice *[]*NavElement
+}
+
+// buildNavigation builds the navigation trees for use in templates
+func buildNavigation(tree *TreeNode, curNavMap *map[string]*NavElement, curNavSlice *[]*NavElement, navActive *[]*NavElement, activeNav string) {
+	for _, el := range tree.Sub {
+		if el.Hidden {
+			continue // ignore hidden nav points from collections
+		}
+
+		var ignNav *string
+		if p := el.Config.Path; p != nil {
+			ignNav = p.IgnoreForNav
+		}
+		if ignNav != nil && *ignNav != "" {
+			regex, err := regexp.Compile(*ignNav)
+			if err != nil {
+				helper.Log.Panicf("could not compile IngoreForNav regexp '%s' in '%s': %s", *ignNav, el.InputPath, err)
+			}
+			if regex.MatchString(path.Base(el.InputPath)) {
+				helper.Log.Debugf("ignoring input directory '%s' in navigation", el.InputPath)
+				continue
+			}
+		}
+
+		elPath := strings.TrimPrefix(el.OutputPath, Config.Directories.Output+"/")
+
+		subMap := make(map[string]*NavElement)
+		subSlice := make([]*NavElement, 0)
+		navEl := NavElement{
+			Active:   strings.HasPrefix(activeNav, elPath),
+			Data:     el.Config.Data,
+			ColMap:   el.ColMap,
+			SubMap:   &subMap,
+			SubSlice: &subSlice,
+		}
+
+		navEl.This = el.Config.This
+
+		if navEl.Active {
+			// add to navActive level navigation
+			currentLevel := strings.Count(activeNav, "/")
+			if len(*navActive) <= currentLevel {
+				// not registered
+				*navActive = append(*navActive, &navEl)
+			}
+		}
+
+		n := el.Config.This.Navname
+		if n != nil {
+			navEl.Navname = *n
+		}
+		g := el.Config.This.GoTo
+		if g != nil {
+			if strings.HasPrefix(*g, "/") {
+				// abslute
+				navEl.GoTo = *g
+			} else {
+				// relative
+				navEl.GoTo = elPath + "/" + *g
+			}
+		} else {
+			navEl.GoTo = elPath + "/"
+		}
+
+		if activeNav != "" && activeNav != "/" {
+			// calculate relative path
+			bToRoot := helper.BackToRoot(activeNav)
+			navEl.GoTo = bToRoot + navEl.GoTo
+			navEl.GoTo = path.Clean(navEl.GoTo)
+		}
+
+		(*curNavMap)[path.Base(el.OutputPath)] = &navEl
+		if curNavSlice != nil {
+			*curNavSlice = append(*curNavSlice, &navEl)
+		}
+
+		buildNavigation(el, &subMap, &subSlice, navActive, activeNav)
+	}
+}
--- a/pkg/mark2web/path.go
+++ b/pkg/mark2web/path.go
@@ -0,0 +1,38 @@
+package mark2web
+
+import (
+	"path"
+	"strings"
+
+	"gitbase.de/apairon/mark2web/pkg/helper"
+)
+
+// ResolveNavPath fixes nav target relative to current navigation path
+func ResolveNavPath(target string) string {
+	curNavPath := (*CurrentContext)["CurrentPath"].(string)
+	if strings.HasPrefix(target, "/") {
+		target = helper.BackToRoot(curNavPath) + target
+	}
+	target = path.Clean(target)
+	return target
+}
+
+// ResolveOutputPath fixes output directory relative to current navigation path
+func ResolveOutputPath(target string) string {
+	if strings.HasPrefix(target, "/") {
+		target = Config.Directories.Output + "/" + target
+	} else {
+		target = CurrentTreeNode.OutputPath + "/" + target
+	}
+	return path.Clean(target)
+}
+
+// ResolveInputPath fixes input directory relative to current navigation path
+func ResolveInputPath(target string) string {
+	if strings.HasPrefix(target, "/") {
+		target = Config.Directories.Input + "/" + target
+	} else {
+		target = CurrentTreeNode.InputPath + "/" + target
+	}
+	return path.Clean(target)
+}
--- a/pkg/mark2web/render.go
+++ b/pkg/mark2web/render.go
@@ -0,0 +1,34 @@
+package mark2web
+
+import (
+	"log"
+
+	"github.com/flosch/pongo2"
+)
+
+var templateCache = make(map[string]*pongo2.Template)
+var templateDir string
+
+// SetTemplateDir sets base directory for searching template files
+func SetTemplateDir(dir string) {
+	templateDir = dir
+}
+
+// renderTemplate renders a pongo2 template with context
+func renderTemplate(filename string, node *TreeNode, pathConfig *PathConfig, ctx *pongo2.Context) (string, error) {
+	CurrentContext = ctx
+	CurrentTreeNode = node
+	CurrentPathConfig = pathConfig
+	templateFile := templateDir + "/" + filename
+	template := templateCache[templateFile]
+	if template == nil {
+		var err error
+		if template, err = pongo2.FromFile(templateFile); err != nil {
+			log.Panicf("could not parse template '%s': %s", templateFile, err)
+		} else {
+			templateCache[templateFile] = template
+		}
+	}
+
+	return template.Execute(*ctx)
+}
--- a/pkg/mark2web/tree.go
+++ b/pkg/mark2web/tree.go
@@ -0,0 +1,20 @@
+package mark2web
+
+import "gitbase.de/apairon/mark2web/pkg/helper"
+
+// TreeNode is complete config tree of content dir
+type TreeNode struct {
+	InputPath  string
+	OutputPath string
+	Hidden     bool // for collections which are not part of the navigation
+
+	ColMap helper.MapString
+
+	InputFiles []string
+	OtherFiles []string
+
+	Config *PathConfig
+	Sub    []*TreeNode
+
+	root *TreeNode // shows always to root of tree
+}