Hugo config abstracted into a general purpose config library called "Viper".

Hugo casting now in own library called "cast"

9 files changed, 197 insertions, 470 deletions

diff --git a/commands/check.go b/commands/check.go
index 6ce8b8177..ee5a6d5d8 100644
--- a/commands/check.go
+++ b/commands/check.go
@@ -25,7 +25,7 @@ var check = &cobra.Command{
     content provided and will give feedback.`,
 	Run: func(cmd *cobra.Command, args []string) {
 		InitializeConfig()
-		site := hugolib.Site{Config: *Config}
+		site := hugolib.Site{}
 		site.Analyze()
 	},
 }
diff --git a/commands/hugo.go b/commands/hugo.go
index 9a42a0edb..0e84093c1 100644
--- a/commands/hugo.go
+++ b/commands/hugo.go
@@ -24,14 +24,16 @@ import (
 
 	"github.com/mostafah/fsync"
 	"github.com/spf13/cobra"
+	"github.com/spf13/hugo/helpers"
 	"github.com/spf13/hugo/hugolib"
 	"github.com/spf13/hugo/utils"
 	"github.com/spf13/hugo/watcher"
 	jww "github.com/spf13/jwalterweatherman"
 	"github.com/spf13/nitro"
+	"github.com/spf13/viper"
 )
 
-var Config *hugolib.Config
+//var Config *hugolib.Config
 var HugoCmd = &cobra.Command{
 	Use:   "hugo",
 	Short: "Hugo is a very fast static site generator",
@@ -78,34 +80,58 @@ func init() {
 }
 
 func InitializeConfig() {
-	Config = hugolib.SetupConfig(&CfgFile, &Source)
+	viper.SetConfigName(CfgFile) // config
+	viper.AddConfigPath(Source)
+	viper.ReadInConfig()
+
+	viper.SetDefault("ContentDir", "content")
+	viper.SetDefault("LayoutDir", "layouts")
+	viper.SetDefault("StaticDir", "static")
+	viper.SetDefault("PublishDir", "public")
+	viper.SetDefault("DefaultLayout", "post")
+	viper.SetDefault("BuildDrafts", false)
+	viper.SetDefault("UglyUrls", false)
+	viper.SetDefault("Verbose", false)
+	viper.SetDefault("CanonifyUrls", false)
+	viper.SetDefault("Indexes", map[string]string{"tag": "tags", "category": "categories"})
+	viper.SetDefault("Permalinks", make(hugolib.PermalinkOverrides, 0))
 
 	if hugoCmdV.PersistentFlags().Lookup("build-drafts").Changed {
-		Config.BuildDrafts = Draft
+		viper.Set("BuildDrafts", Draft)
 	}
 
 	if hugoCmdV.PersistentFlags().Lookup("uglyurls").Changed {
-		Config.UglyUrls = UglyUrls
+		viper.Set("UglyUrls", UglyUrls)
 	}
 
 	if hugoCmdV.PersistentFlags().Lookup("verbose").Changed {
-		Config.Verbose = Verbose
+		viper.Set("Verbose", Verbose)
 	}
 
 	if hugoCmdV.PersistentFlags().Lookup("logfile").Changed {
-		Config.LogFile = LogFile
+		viper.Set("LogFile", LogFile)
 	}
 
 	if BaseUrl != "" {
-		Config.BaseUrl = BaseUrl
+		if !strings.HasSuffix(BaseUrl, "/") {
+			BaseUrl = BaseUrl + "/"
+		}
+		viper.Set("BaseUrl", BaseUrl)
 	}
 	if Destination != "" {
-		Config.PublishDir = Destination
+		viper.Set("PublishDir", Destination)
+	}
+
+	if Source != "" {
+		viper.Set("WorkingDir", Source)
+	} else {
+		dir, _ := helpers.FindCWD()
+		viper.Set("WorkingDir", dir)
 	}
 
-	if VerboseLog || Logging || Config.LogFile != "" {
-		if Config.LogFile != "" {
-			jww.SetLogFile(Config.LogFile)
+	if VerboseLog || Logging || (viper.IsSet("LogFile") && viper.GetString("LogFile") != "") {
+		if viper.IsSet("LogFile") && viper.GetString("LogFile") != "" {
+			jww.SetLogFile(viper.GetString("LogFile"))
 		} else {
 			jww.UseTempLogFile("hugo")
 		}
@@ -113,7 +139,7 @@ func InitializeConfig() {
 		jww.DiscardLogging()
 	}
 
-	if Config.Verbose {
+	if viper.GetBool("verbose") {
 		jww.SetStdoutThreshold(jww.LevelDebug)
 	}
 
@@ -123,7 +149,7 @@ func InitializeConfig() {
 }
 
 func build(watches ...bool) {
-	utils.CheckErr(copyStatic(), fmt.Sprintf("Error copying static files to %s", Config.GetAbsPath(Config.PublishDir)))
+	utils.CheckErr(copyStatic(), fmt.Sprintf("Error copying static files to %s", helpers.AbsPathify(viper.GetString("PublishDir"))))
 	watch := false
 	if len(watches) > 0 && watches[0] {
 		watch = true
@@ -131,20 +157,22 @@ func build(watches ...bool) {
 	utils.StopOnErr(buildSite(BuildWatch || watch))
 
 	if BuildWatch {
-		jww.FEEDBACK.Println("Watching for changes in", Config.GetAbsPath(Config.ContentDir))
+		jww.FEEDBACK.Println("Watching for changes in", helpers.AbsPathify(viper.GetString("ContentDir")))
 		jww.FEEDBACK.Println("Press ctrl+c to stop")
 		utils.CheckErr(NewWatcher(0))
 	}
 }
 
 func copyStatic() error {
-	staticDir := Config.GetAbsPath(Config.StaticDir + "/")
+	staticDir := helpers.AbsPathify(viper.GetString("StaticDir")) + "/"
 	if _, err := os.Stat(staticDir); os.IsNotExist(err) {
 		return nil
 	}
 
+	publishDir := helpers.AbsPathify(viper.GetString("PublishDir")) + "/"
 	// Copy Static to Destination
-	return fsync.Sync(Config.GetAbsPath(Config.PublishDir+"/"), Config.GetAbsPath(Config.StaticDir+"/"))
+	jww.INFO.Println("syncing from", staticDir, "to", publishDir)
+	return fsync.Sync(publishDir, staticDir)
 }
 
 func getDirList() []string {
@@ -161,16 +189,16 @@ func getDirList() []string {
 		return nil
 	}
 
-	filepath.Walk(Config.GetAbsPath(Config.ContentDir), walker)
-	filepath.Walk(Config.GetAbsPath(Config.LayoutDir), walker)
-	filepath.Walk(Config.GetAbsPath(Config.StaticDir), walker)
+	filepath.Walk(helpers.AbsPathify(viper.GetString("ContentDir")), walker)
+	filepath.Walk(helpers.AbsPathify(viper.GetString("LayoutDir")), walker)
+	filepath.Walk(helpers.AbsPathify(viper.GetString("StaticDir")), walker)
 
 	return a
 }
 
 func buildSite(watching ...bool) (err error) {
 	startTime := time.Now()
-	site := &hugolib.Site{Config: *Config}
+	site := &hugolib.Site{}
 	if len(watching) > 0 && watching[0] {
 		site.RunMode.Watching = true
 	}
@@ -226,7 +254,7 @@ func NewWatcher(port int) error {
 						continue
 					}
 
-					isstatic := strings.HasPrefix(ev.Name, Config.GetAbsPath(Config.StaticDir))
+					isstatic := strings.HasPrefix(ev.Name, helpers.AbsPathify(viper.GetString("StaticDir")))
 					static_changed = static_changed || isstatic
 					dynamic_changed = dynamic_changed || !isstatic
 
@@ -240,7 +268,7 @@ func NewWatcher(port int) error {
 
 				if static_changed {
 					fmt.Print("Static file changed, syncing\n\n")
-					utils.StopOnErr(copyStatic(), fmt.Sprintf("Error copying static files to %s", Config.GetAbsPath(Config.PublishDir)))
+					utils.StopOnErr(copyStatic(), fmt.Sprintf("Error copying static files to %s", helpers.AbsPathify(viper.GetString("PublishDir"))))
 				}
 
 				if dynamic_changed {
diff --git a/commands/server.go b/commands/server.go
index b8183817f..d4089bdb3 100644
--- a/commands/server.go
+++ b/commands/server.go
@@ -21,7 +21,9 @@ import (
 	"strings"
 
 	"github.com/spf13/cobra"
+	"github.com/spf13/hugo/helpers"
 	jww "github.com/spf13/jwalterweatherman"
+	"github.com/spf13/viper"
 )
 
 var serverPort int
@@ -55,16 +57,16 @@ func server(cmd *cobra.Command, args []string) {
 	}
 
 	if serverAppend {
-		Config.BaseUrl = strings.TrimSuffix(BaseUrl, "/") + ":" + strconv.Itoa(serverPort)
+		viper.Set("BaseUrl", strings.TrimSuffix(BaseUrl, "/")+":"+strconv.Itoa(serverPort))
 	} else {
-		Config.BaseUrl = strings.TrimSuffix(BaseUrl, "/")
+		viper.Set("BaseUrl", strings.TrimSuffix(BaseUrl, "/"))
 	}
 
 	build(serverWatch)
 
 	// Watch runs its own server as part of the routine
 	if serverWatch {
-		jww.FEEDBACK.Println("Watching for changes in", Config.GetAbsPath(Config.ContentDir))
+		jww.FEEDBACK.Println("Watching for changes in", helpers.AbsPathify(viper.GetString("ContentDir")))
 		err := NewWatcher(serverPort)
 		if err != nil {
 			fmt.Println(err)
@@ -75,17 +77,17 @@ func server(cmd *cobra.Command, args []string) {
 }
 
 func serve(port int) {
-	jww.FEEDBACK.Println("Serving pages from " + Config.GetAbsPath(Config.PublishDir))
+	jww.FEEDBACK.Println("Serving pages from " + helpers.AbsPathify(viper.GetString("PublishDir")))
 
 	if BaseUrl == "" {
-		jww.FEEDBACK.Printf("Web Server is available at %s\n", Config.BaseUrl)
+		jww.FEEDBACK.Printf("Web Server is available at %s\n", viper.GetString("BaseUrl"))
 	} else {
 		jww.FEEDBACK.Printf("Web Server is available at http://localhost:%v\n", port)
 	}
 
 	fmt.Println("Press ctrl+c to stop")
 
-	err := http.ListenAndServe(":"+strconv.Itoa(port), http.FileServer(http.Dir(Config.GetAbsPath(Config.PublishDir))))
+	err := http.ListenAndServe(":"+strconv.Itoa(port), http.FileServer(http.Dir(helpers.AbsPathify(viper.GetString("PublishDir")))))
 	if err != nil {
 		jww.ERROR.Printf("Error: %s\n", err.Error())
 		os.Exit(1)
diff --git a/helpers/path.go b/helpers/path.go
index e0075834e..1573204e2 100644
--- a/helpers/path.go
+++ b/helpers/path.go
@@ -14,11 +14,14 @@
 package helpers
 
 import (
+	"fmt"
 	"os"
 	"path"
+	"path/filepath"
 	"regexp"
 	"strings"
 	"unicode"
+	"github.com/spf13/viper"
 )
 
 var sanitizeRegexp = regexp.MustCompile("[^a-zA-Z0-9./_-]")
@@ -75,6 +78,14 @@ func Exists(path string) (bool, error) {
 	return false, err
 }
 
+func AbsPathify(inPath string) string {
+	if filepath.IsAbs(inPath) {
+		return filepath.Clean(inPath)
+	}
+
+	return filepath.Clean(filepath.Join(viper.GetString("WorkingDir"), inPath))
+}
+
 func FileAndExt(in string) (name string, ext string) {
 	ext = path.Ext(in)
 	base := path.Base(in)
@@ -117,3 +128,26 @@ func PrettifyPath(in string) string {
 		}
 	}
 }
+
+func FindCWD() (string, error) {
+	serverFile, err := filepath.Abs(os.Args[0])
+
+	if err != nil {
+		return "", fmt.Errorf("Can't get absolute path for executable: %v", err)
+	}
+
+	path := filepath.Dir(serverFile)
+	realFile, err := filepath.EvalSymlinks(serverFile)
+
+	if err != nil {
+		if _, err = os.Stat(serverFile + ".exe"); err == nil {
+			realFile = filepath.Clean(serverFile + ".exe")
+		}
+	}
+
+	if err == nil && realFile != serverFile {
+		path = filepath.Dir(realFile)
+	}
+
+	return path, nil
+}
diff --git a/hugolib/config.go b/hugolib/config.go
deleted file mode 100644
index c3f753cd4..000000000
--- a/hugolib/config.go
+++ /dev/null
@@ -1,203 +0,0 @@
-// Copyright © 2013 Steve Francia <spf@spf13.com>.
-//
-// Licensed under the Simple Public 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://opensource.org/licenses/Simple-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 hugolib
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"github.com/BurntSushi/toml"
-	"github.com/spf13/hugo/helpers"
-	jww "github.com/spf13/jwalterweatherman"
-	"launchpad.net/goyaml"
-)
-
-// config file items
-type Config struct {
-	ContentDir, PublishDir, BaseUrl, StaticDir string
-	Path, CacheDir, LayoutDir, DefaultLayout   string
-	ConfigFile, LogFile                        string
-	Title                                      string
-	Indexes                                    map[string]string // singular, plural
-	ProcessFilters                             map[string][]string
-	Params                                     map[string]interface{}
-	Permalinks                                 PermalinkOverrides
-	BuildDrafts, UglyUrls, Verbose             bool
-	CanonifyUrls                               bool
-}
-
-var c Config
-
-// Read cfgfile or setup defaults.
-func SetupConfig(cfgfile *string, path *string) *Config {
-	c.setPath(*path)
-
-	cfg, err := c.findConfigFile(*cfgfile)
-	c.ConfigFile = cfg
-
-	if err != nil {
-		jww.ERROR.Printf("%v", err)
-		jww.FEEDBACK.Println("using defaults instead")
-	}
-
-	// set defaults
-	c.ContentDir = "content"
-	c.LayoutDir = "layouts"
-	c.PublishDir = "public"
-	c.StaticDir = "static"
-	c.DefaultLayout = "post"
-	c.BuildDrafts = false
-	c.UglyUrls = false
-	c.Verbose = false
-	c.CanonifyUrls = true
-
-	c.readInConfig()
-
-	// set index defaults if none provided
-	if c.Indexes == nil {
-		c.Indexes = make(map[string]string)
-		c.Indexes["tag"] = "tags"
-		c.Indexes["category"] = "categories"
-	}
-
-	// ensure map exists, albeit empty
-	if c.Permalinks == nil {
-		c.Permalinks = make(PermalinkOverrides, 0)
-	}
-
-	if !strings.HasSuffix(c.BaseUrl, "/") {
-		c.BaseUrl = c.BaseUrl + "/"
-	}
-
-	return &c
-}
-
-func (c *Config) readInConfig() {
-	file, err := ioutil.ReadFile(c.ConfigFile)
-	if err == nil {
-		switch path.Ext(c.ConfigFile) {
-		case ".yaml":
-			if err := goyaml.Unmarshal(file, &c); err != nil {
-				jww.ERROR.Printf("Error parsing config: %s", err)
-				os.Exit(1)
-			}
-
-		case ".json":
-			if err := json.Unmarshal(file, &c); err != nil {
-				jww.ERROR.Printf("Error parsing config: %s", err)
-				os.Exit(1)
-			}
-
-		case ".toml":
-			if _, err := toml.Decode(string(file), &c); err != nil {
-				jww.ERROR.Printf("Error parsing config: %s", err)
-				os.Exit(1)
-			}
-		}
-	}
-}
-
-func (c *Config) setPath(p string) {
-	if p == "" {
-		path, err := findPath()
-		if err != nil {
-			jww.ERROR.Printf("Error finding path: %s", err)
-		}
-		c.Path = path
-	} else {
-		path, err := filepath.Abs(p)
-		if err != nil {
-			jww.ERROR.Printf("Error finding path: %s", err)
-		}
-		c.Path = path
-	}
-}
-
-func (c *Config) GetPath() string {
-	if c.Path == "" {
-		c.setPath("")
-	}
-	return c.Path
-}
-
-func findPath() (string, error) {
-	serverFile, err := filepath.Abs(os.Args[0])
-
-	if err != nil {
-		return "", fmt.Errorf("Can't get absolute path for executable: %v", err)
-	}
-
-	path := filepath.Dir(serverFile)
-	realFile, err := filepath.EvalSymlinks(serverFile)
-
-	if err != nil {
-		if _, err = os.Stat(serverFile + ".exe"); err == nil {
-			realFile = filepath.Clean(serverFile + ".exe")
-		}
-	}
-
-	if err == nil && realFile != serverFile {
-		path = filepath.Dir(realFile)
-	}
-
-	return path, nil
-}
-
-// GetAbsPath return the absolute path for a given path with the internal slashes
-// properly converted.
-func (c *Config) GetAbsPath(name string) string {
-	if filepath.IsAbs(name) {
-		return name
-	}
-
-	return filepath.Join(c.GetPath(), name)
-}
-
-func (c *Config) findConfigFile(configFileName string) (string, error) {
-
-	if configFileName == "" { // config not specified, let's search
-		if b, _ := helpers.Exists(c.GetAbsPath("config.json")); b {
-			return c.GetAbsPath("config.json"), nil
-		}
-
-		if b, _ := helpers.Exists(c.GetAbsPath("config.toml")); b {
-			return c.GetAbsPath("config.toml"), nil
-		}
-
-		if b, _ := helpers.Exists(c.GetAbsPath("config.yaml")); b {
-			return c.GetAbsPath("config.yaml"), nil
-		}
-
-		return "", fmt.Errorf("config file not found in: %s", c.GetPath())
-
-	} else {
-		// If the full path is given, just use that
-		if path.IsAbs(configFileName) {
-			return configFileName, nil
-		}
-
-		// Else check the local directory
-		t := c.GetAbsPath(configFileName)
-		if b, _ := helpers.Exists(t); b {
-			return t, nil
-		} else {
-			return "", fmt.Errorf("config file not found at: %s", t)
-		}
-	}
-}
diff --git a/hugolib/index.go b/hugolib/index.go
index f87ca6035..b683f2b3c 100644
--- a/hugolib/index.go
+++ b/hugolib/index.go
@@ -14,8 +14,9 @@
 package hugolib
 
 import (
-	"github.com/spf13/hugo/helpers"
 	"sort"
+
+	"github.com/spf13/hugo/helpers"
 )
 
 /*
diff --git a/hugolib/metadata.go b/hugolib/metadata.go
deleted file mode 100644
index b37d5451f..000000000
--- a/hugolib/metadata.go
+++ /dev/null
@@ -1,157 +0,0 @@
-package hugolib
-
-import (
-	"errors"
-	"fmt"
-	"strconv"
-	"time"
-
-	jww "github.com/spf13/jwalterweatherman"
-)
-
-func interfaceToTime(i interface{}) time.Time {
-	switch s := i.(type) {
-	case time.Time:
-		return s
-	case string:
-		d, e := stringToDate(s)
-		if e == nil {
-			return d
-		}
-		jww.ERROR.Println("Could not parse Date/Time format:", e)
-	default:
-		jww.ERROR.Println("Only Time is supported for this key")
-	}
-
-	return *new(time.Time)
-}
-
-func interfaceToStringToDate(i interface{}) time.Time {
-	s := interfaceToString(i)
-
-	if d, e := stringToDate(s); e == nil {
-		return d
-	}
-
-	return time.Unix(0, 0)
-}
-
-func stringToDate(s string) (time.Time, error) {
-	return parseDateWith(s, []string{
-		time.RFC3339,
-		"2006-01-02T15:04:05", // iso8601 without timezone
-		time.RFC1123Z,
-		time.RFC1123,
-		time.RFC822Z,
-		time.RFC822,
-		time.ANSIC,
-		time.UnixDate,
-		time.RubyDate,
-		"2006-01-02 15:04:05Z07:00",
-		"02 Jan 06 15:04 MST",
-		"2006-01-02",
-		"02 Jan 2006",
-	})
-}
-
-func parseDateWith(s string, dates []string) (d time.Time, e error) {
-	for _, dateType := range dates {
-		if d, e = time.Parse(dateType, s); e == nil {
-			return
-		}
-	}
-	return d, errors.New(fmt.Sprintf("Unable to parse date: %s", s))
-}
-
-func interfaceToBool(i interface{}) bool {
-	switch b := i.(type) {
-	case bool:
-		return b
-	case int:
-		if i.(int) > 0 {
-			return true
-		}
-		return false
-	default:
-		jww.ERROR.Println("Only Boolean values are supported for this YAML key")
-	}
-
-	return false
-
-}
-
-func interfaceArrayToStringArray(i interface{}) []string {
-	var a []string
-
-	switch vv := i.(type) {
-	case []interface{}:
-		for _, u := range vv {
-			a = append(a, interfaceToString(u))
-		}
-	}
-
-	return a
-}
-
-func interfaceToFloat64(i interface{}) float64 {
-	switch s := i.(type) {
-	case float64:
-		return s
-	case float32:
-		return float64(s)
-
-	case string:
-		v, err := strconv.ParseFloat(s, 64)
-		if err == nil {
-			return float64(v)
-		} else {
-			jww.ERROR.Println("Only Floats are supported for this key\nErr:", err)
-		}
-
-	default:
-		jww.ERROR.Println("Only Floats are supported for this key")
-	}
-
-	return 0.0
-}
-
-func interfaceToInt(i interface{}) int {
-	switch s := i.(type) {
-	case int:
-		return s
-	case int64:
-		return int(s)
-	case int32:
-		return int(s)
-	case int16:
-		return int(s)
-	case int8:
-		return int(s)
-	case string:
-		v, err := strconv.ParseInt(s, 0, 0)
-		if err == nil {
-			return int(v)
-		} else {
-			jww.ERROR.Println("Only Ints are supported for this key\nErr:", err)
-		}
-	default:
-		jww.ERROR.Println("Only Ints are supported for this key")
-	}
-
-	return 0
-}
-
-func interfaceToString(i interface{}) string {
-	switch s := i.(type) {
-	case string:
-		return s
-	case float64:
-		return strconv.FormatFloat(i.(float64), 'f', -1, 64)
-	case int:
-		return strconv.FormatInt(int64(i.(int)), 10)
-	default:
-		jww.ERROR.Println(fmt.Sprintf("Only Strings are supported for this key (got type '%T'): %s", s, s))
-	}
-
-	return ""
-}
diff --git a/hugolib/page.go b/hugolib/page.go
index 8c846c465..b349be40d 100644
--- a/hugolib/page.go
+++ b/hugolib/page.go
@@ -25,10 +25,12 @@ import (
 	"time"
 
 	"github.com/BurntSushi/toml"
+	"github.com/spf13/cast"
 	"github.com/spf13/hugo/helpers"
 	"github.com/spf13/hugo/parser"
 	"github.com/spf13/hugo/template/bundle"
 	jww "github.com/spf13/jwalterweatherman"
+	"github.com/spf13/viper"
 	"github.com/theplant/blackfriday"
 	"launchpad.net/goyaml"
 	json "launchpad.net/rjson"
@@ -252,10 +254,10 @@ func (p *Page) permalink() (*url.URL, error) {
 		// fmt.Printf("have a section override for %q in section %s → %s\n", p.Title, p.Section, permalink)
 	} else {
 		if len(pSlug) > 0 {
-			permalink = helpers.UrlPrep(p.Site.Config.UglyUrls, path.Join(dir, p.Slug+"."+p.Extension))
+			permalink = helpers.UrlPrep(viper.GetBool("UglyUrls"), path.Join(dir, p.Slug+"."+p.Extension))
 		} else {
 			_, t := path.Split(p.FileName)
-			permalink = helpers.UrlPrep(p.Site.Config.UglyUrls, path.Join(dir, helpers.ReplaceExtension(strings.TrimSpace(t), p.Extension)))
+			permalink = helpers.UrlPrep(viper.GetBool("UglyUrls"), path.Join(dir, helpers.ReplaceExtension(strings.TrimSpace(t), p.Extension)))
 		}
 	}
 
@@ -327,41 +329,41 @@ func (page *Page) update(f interface{}) error {
 		loki := strings.ToLower(k)
 		switch loki {
 		case "title":
-			page.Title = interfaceToString(v)
+			page.Title = cast.ToString(v)
 		case "linktitle":
-			page.linkTitle = interfaceToString(v)
+			page.linkTitle = cast.ToString(v)
 		case "description":
-			page.Description = interfaceToString(v)
+			page.Description = cast.ToString(v)
 		case "slug":
-			page.Slug = helpers.Urlize(interfaceToString(v))
+			page.Slug = helpers.Urlize(cast.ToString(v))
 		case "url":
-			if url := interfaceToString(v); strings.HasPrefix(url, "http://") || strings.HasPrefix(url, "https://") {
+			if url := cast.ToString(v); strings.HasPrefix(url, "http://") || strings.HasPrefix(url, "https://") {
 				return fmt.Errorf("Only relative urls are supported, %v provided", url)
 			}
-			page.Url = helpers.Urlize(interfaceToString(v))
+			page.Url = helpers.Urlize(cast.ToString(v))
 		case "type":
-			page.contentType = interfaceToString(v)
+			page.contentType = cast.ToString(v)
 		case "keywords":
-			page.Keywords = interfaceArrayToStringArray(v)
+			page.Keywords = cast.ToStringSlice(v)
 		case "date", "pubdate":
-			page.Date = interfaceToTime(v)
+			page.Date = cast.ToTime(v)
 		case "draft":
-			page.Draft = interfaceToBool(v)
+			page.Draft = cast.ToBool(v)
 		case "layout":
-			page.layout = interfaceToString(v)
+			page.layout = cast.ToString(v)
 		case "markup":
-			page.Markup = interfaceToString(v)
+			page.Markup = cast.ToString(v)
 		case "weight":
-			page.Weight = interfaceToInt(v)
+			page.Weight = cast.ToInt(v)
 		case "aliases":
-			page.Aliases = interfaceArrayToStringArray(v)
+			page.Aliases = cast.ToStringSlice(v)
 			for _, alias := range page.Aliases {
 				if strings.HasPrefix(alias, "http://") || strings.HasPrefix(alias, "https://") {
 					return fmt.Errorf("Only relative aliases are supported, %v provided", alias)
 				}
 			}
 		case "status":
-			page.Status = interfaceToString(v)
+			page.Status = cast.ToString(v)
 		default:
 			// If not one of the explicit values, store in Params
 			switch vv := v.(type) {
@@ -380,7 +382,7 @@ func (page *Page) update(f interface{}) error {
 				case []interface{}:
 					var a = make([]string, len(vvv))
 					for i, u := range vvv {
-						a[i] = interfaceToString(u)
+						a[i] = cast.ToString(u)
 					}
 					page.Params[loki] = a
 				}
@@ -400,15 +402,15 @@ func (page *Page) GetParam(key string) interface{} {
 
 	switch v.(type) {
 	case bool:
-		return interfaceToBool(v)
+		return cast.ToBool(v)
 	case string:
-		return interfaceToString(v)
+		return cast.ToString(v)
 	case int64, int32, int16, int8, int:
-		return interfaceToInt(v)
+		return cast.ToInt(v)
 	case float64, float32:
-		return interfaceToFloat64(v)
+		return cast.ToFloat64(v)
 	case time.Time:
-		return interfaceToTime(v)
+		return cast.ToTime(v)
 	case []string:
 		return v
 	}
diff --git a/hugolib/site.go b/hugolib/site.go
index 7602853d5..f653a2441 100644
--- a/hugolib/site.go
+++ b/hugolib/site.go
@@ -31,6 +31,7 @@ import (
 	"github.com/spf13/hugo/transform"
 	jww "github.com/spf13/jwalterweatherman"
 	"github.com/spf13/nitro"
+	"github.com/spf13/viper"
 )
 
 var _ = transform.AbsURL
@@ -55,7 +56,6 @@ var DefaultTimer *nitro.B
 //
 // 5. The entire collection of files is written to disk.
 type Site struct {
-	Config     Config
 	Pages      Pages
 	Tmpl       bundle.Template
 	Indexes    IndexList
@@ -77,7 +77,7 @@ type SiteInfo struct {
 	Recent     *Pages
 	LastChange time.Time
 	Title      string
-	Config     *Config
+	ConfigGet  func(key string) interface{}
 	Permalinks PermalinkOverrides
 	Params     map[string]interface{}
 }
@@ -202,7 +202,7 @@ func (s *Site) initialize() (err error) {
 		return err
 	}
 
-	staticDir := s.Config.GetAbsPath(s.Config.StaticDir + "/")
+	staticDir := helpers.AbsPathify(viper.GetString("StaticDir") + "/")
 
 	s.Source = &source.Filesystem{
 		AvoidPaths: []string{staticDir},
@@ -216,26 +216,35 @@ func (s *Site) initialize() (err error) {
 }
 
 func (s *Site) initializeSiteInfo() {
+	params, ok := viper.Get("Params").(map[string]interface{})
+	if !ok {
+		params = make(map[string]interface{})
+	}
+
+	permalinks, ok := viper.Get("Permalinks").(PermalinkOverrides)
+	if !ok {
+		permalinks = make(PermalinkOverrides)
+	}
+
 	s.Info = SiteInfo{
-		BaseUrl:    template.URL(s.Config.BaseUrl),
-		Title:      s.Config.Title,
+		BaseUrl:    template.URL(viper.GetString("BaseUrl")),
+		Title:      viper.GetString("Title"),
 		Recent:     &s.Pages,
-		Config:     &s.Config,
-		Params:     s.Config.Params,
-		Permalinks: s.Config.Permalinks,