Add Hugo Modules

This commit implements Hugo Modules.

This is a broad subject, but some keywords include:

* A new `module` configuration section where you can import almost anything. You can configure both your own file mounts nd the file mounts of the modules you import. This is the new recommended way of configuring what you earlier put in `configDir`, `staticDir` etc. And it also allows you to mount folders in non-Hugo-projects, e.g. the `SCSS` folder in the Bootstrap GitHub project.
* A module consists of a set of mounts to the standard 7 component types in Hugo: `static`, `content`, `layouts`, `data`, `assets`, `i18n`, and `archetypes`. Yes, Theme Components can now include content, which should be very useful, especially in bigger multilingual projects.
* Modules not in your local file cache will be downloaded automatically and even "hot replaced" while the server is running.
* Hugo Modules supports and encourages semver versioned modules, and uses the minimal version selection algorithm to resolve versions.
* A new set of CLI commands are provided to manage all of this: `hugo mod init`,  `hugo mod get`,  `hugo mod graph`,  `hugo mod tidy`, and  `hugo mod vendor`.

All of the above is backed by Go Modules.

Fixes #5973
Fixes #5996
Fixes #6010
Fixes #5911
Fixes #5940
Fixes #6074
Fixes #6082
Fixes #6092

7 files changed, 1962 insertions, 0 deletions

diff --git a/modules/client.go b/modules/client.go
new file mode 100644
index 000000000..ac09721dc
--- /dev/null
+++ b/modules/client.go
@@ -0,0 +1,570 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package modules
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/gohugoio/hugo/hugofs/files"
+
+	"github.com/gohugoio/hugo/common/loggers"
+
+	"strings"
+	"time"
+
+	"github.com/gohugoio/hugo/config"
+
+	"github.com/rogpeppe/go-internal/module"
+
+	"github.com/gohugoio/hugo/common/hugio"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/afero"
+)
+
+var (
+	fileSeparator = string(os.PathSeparator)
+)
+
+const (
+	goBinaryStatusOK goBinaryStatus = iota
+	goBinaryStatusNotFound
+	goBinaryStatusTooOld
+)
+
+// The "vendor" dir is reserved for Go Modules.
+const vendord = "_vendor"
+
+const (
+	goModFilename = "go.mod"
+	goSumFilename = "go.sum"
+)
+
+// NewClient creates a new Client that can be used to manage the Hugo Components
+// in a given workingDir.
+// The Client will resolve the dependencies recursively, but needs the top
+// level imports to start out.
+func NewClient(cfg ClientConfig) *Client {
+	fs := cfg.Fs
+
+	n := filepath.Join(cfg.WorkingDir, goModFilename)
+	goModEnabled, _ := afero.Exists(fs, n)
+	var goModFilename string
+	if goModEnabled {
+		goModFilename = n
+	}
+
+	env := os.Environ()
+	mcfg := cfg.ModuleConfig
+
+	config.SetEnvVars(&env,
+		"PWD", cfg.WorkingDir,
+		"GOPROXY", mcfg.Proxy,
+		"GOPRIVATE", mcfg.Private,
+		"GONOPROXY", mcfg.NoProxy)
+
+	if cfg.CacheDir != "" {
+		// Module cache stored below $GOPATH/pkg
+		config.SetEnvVars(&env, "GOPATH", cfg.CacheDir)
+
+	}
+
+	logger := cfg.Logger
+	if logger == nil {
+		logger = loggers.NewWarningLogger()
+	}
+
+	return &Client{
+		fs:                fs,
+		ignoreVendor:      cfg.IgnoreVendor,
+		workingDir:        cfg.WorkingDir,
+		themesDir:         cfg.ThemesDir,
+		logger:            logger,
+		moduleConfig:      mcfg,
+		environ:           env,
+		GoModulesFilename: goModFilename}
+}
+
+// Client contains most of the API provided by this package.
+type Client struct {
+	fs     afero.Fs
+	logger *loggers.Logger
+
+	// Ignore any _vendor directory.
+	ignoreVendor bool
+
+	// Absolute path to the project dir.
+	workingDir string
+
+	// Absolute path to the project's themes dir.
+	themesDir string
+
+	// The top level module config
+	moduleConfig Config
+
+	// Environment variables used in "go get" etc.
+	environ []string
+
+	// Set when Go modules are initialized in the current repo, that is:
+	// a go.mod file exists.
+	GoModulesFilename string
+
+	// Set if we get a exec.ErrNotFound when running Go, which is most likely
+	// due to being run on a system without Go installed. We record it here
+	// so we can give an instructional error at the end if module/theme
+	// resolution fails.
+	goBinaryStatus goBinaryStatus
+}
+
+// Graph writes a module dependenchy graph to the given writer.
+func (c *Client) Graph(w io.Writer) error {
+	mc, coll := c.collect(true)
+	if coll.err != nil {
+		return coll.err
+	}
+	for _, module := range mc.AllModules {
+		if module.Owner() == nil {
+			continue
+		}
+
+		prefix := ""
+		if module.Disabled() {
+			prefix = "DISABLED "
+		}
+		dep := pathVersion(module.Owner()) + " " + pathVersion(module)
+		if replace := module.Replace(); replace != nil {
+			if replace.Version() != "" {
+				dep += " => " + pathVersion(replace)
+			} else {
+				// Local dir.
+				dep += " => " + replace.Dir()
+			}
+
+		}
+		fmt.Fprintln(w, prefix+dep)
+	}
+
+	return nil
+}
+
+// Tidy can be used to remove unused dependencies from go.mod and go.sum.
+func (c *Client) Tidy() error {
+	tc, coll := c.collect(false)
+	if coll.err != nil {
+		return coll.err
+	}
+
+	if coll.skipTidy {
+		return nil
+	}
+
+	return c.tidy(tc.AllModules, false)
+}
+
+// Vendor writes all the module dependencies to a _vendor folder.
+//
+// Unlike Go, we support it for any level.
+//
+// We, by default, use the /_vendor folder first, if found. To disable,
+// run with
+//    hugo --ignoreVendor
+//
+// Given a module tree, Hugo will pick the first module for a given path,
+// meaning that if the top-level module is vendored, that will be the full
+// set of dependencies.
+func (c *Client) Vendor() error {
+	vendorDir := filepath.Join(c.workingDir, vendord)
+	if err := c.rmVendorDir(vendorDir); err != nil {
+		return err
+	}
+
+	// Write the modules list to modules.txt.
+	//
+	// On the form:
+	//
+	// # github.com/alecthomas/chroma v0.6.3
+	//
+	// This is how "go mod vendor" does it. Go also lists
+	// the packages below it, but that is currently not applicable to us.
+	//
+	var modulesContent bytes.Buffer
+
+	tc, coll := c.collect(true)
+	if coll.err != nil {
+		return coll.err
+	}
+
+	for _, t := range tc.AllModules {
+		if t.Owner() == nil {
+			// This is the project.
+			continue
+		}
+		// We respect the --ignoreVendor flag even for the vendor command.
+		if !t.IsGoMod() && !t.Vendor() {
+			// We currently do not vendor components living in the
+			// theme directory, see https://github.com/gohugoio/hugo/issues/5993
+			continue
+		}
+
+		fmt.Fprintln(&modulesContent, "# "+t.Path()+" "+t.Version())
+
+		dir := t.Dir()
+
+		for _, mount := range t.Mounts() {
+			if err := hugio.CopyDir(c.fs, filepath.Join(dir, mount.Source), filepath.Join(vendorDir, t.Path(), mount.Source), nil); err != nil {
+				return errors.Wrap(err, "failed to copy module to vendor dir")
+			}
+		}
+
+		// Include the resource cache if present.
+		resourcesDir := filepath.Join(dir, files.FolderResources)
+		_, err := c.fs.Stat(resourcesDir)
+		if err == nil {
+			if err := hugio.CopyDir(c.fs, resourcesDir, filepath.Join(vendorDir, t.Path(), files.FolderResources), nil); err != nil {
+				return errors.Wrap(err, "failed to copy resources to vendor dir")
+			}
+		}
+
+		// Also include any theme.toml or config.* files in the root.
+		configFiles, _ := afero.Glob(c.fs, filepath.Join(dir, "config.*"))
+		configFiles = append(configFiles, filepath.Join(dir, "theme.toml"))
+		for _, configFile := range configFiles {
+			if err := hugio.CopyFile(c.fs, configFile, filepath.Join(vendorDir, t.Path(), filepath.Base(configFile))); err != nil {
+				if !os.IsNotExist(err) {
+					return err
+				}
+			}
+		}
+	}
+
+	if modulesContent.Len() > 0 {
+		if err := afero.WriteFile(c.fs, filepath.Join(vendorDir, vendorModulesFilename), modulesContent.Bytes(), 0666); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Get runs "go get" with the supplied arguments.
+func (c *Client) Get(args ...string) error {
+	if err := c.runGo(context.Background(), os.Stdout, append([]string{"get"}, args...)...); err != nil {
+		errors.Wrapf(err, "failed to get %q", args)
+	}
+	return nil
+}
+
+// Init initializes this as a Go Module with the given path.
+// If path is empty, Go will try to guess.
+// If this succeeds, this project will be marked as Go Module.
+func (c *Client) Init(path string) error {
+	err := c.runGo(context.Background(), os.Stdout, "mod", "init", path)
+	if err != nil {
+		return errors.Wrap(err, "failed to init modules")
+	}
+
+	c.GoModulesFilename = filepath.Join(c.workingDir, goModFilename)
+
+	return nil
+}
+
+func (c *Client) isProbablyModule(path string) bool {
+	return module.CheckPath(path) == nil
+}
+
+func (c *Client) listGoMods() (goModules, error) {
+	if c.GoModulesFilename == "" {
+		return nil, nil
+	}
+
+	out := ioutil.Discard
+	err := c.runGo(context.Background(), out, "mod", "download")
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to download modules")
+	}
+
+	b := &bytes.Buffer{}
+	err = c.runGo(context.Background(), b, "list", "-m", "-json", "all")
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to list modules")
+	}
+
+	var modules goModules
+
+	dec := json.NewDecoder(b)
+	for {
+		m := &goModule{}
+		if err := dec.Decode(m); err != nil {
+			if err == io.EOF {
+				break
+			}
+			return nil, errors.Wrap(err, "failed to decode modules list")
+		}
+
+		modules = append(modules, m)
+	}
+
+	return modules, err
+
+}
+
+func (c *Client) rewriteGoMod(name string, isGoMod map[string]bool) error {
+	data, err := c.rewriteGoModRewrite(name, isGoMod)
+	if err != nil {
+		return err
+	}
+	if data != nil {
+		if err := afero.WriteFile(c.fs, filepath.Join(c.workingDir, name), data, 0666); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *Client) rewriteGoModRewrite(name string, isGoMod map[string]bool) ([]byte, error) {
+	if name == goModFilename && c.GoModulesFilename == "" {
+		// Already checked.
+		return nil, nil
+	}
+
+	modlineSplitter := getModlineSplitter(name == goModFilename)
+
+	b := &bytes.Buffer{}
+	f, err := c.fs.Open(filepath.Join(c.workingDir, name))
+	if err != nil {
+		if os.IsNotExist(err) {
+			// It's been deleted.
+			return nil, nil
+		}
+		return nil, err
+	}
+	defer f.Close()
+
+	scanner := bufio.NewScanner(f)
+	var dirty bool
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		var doWrite bool
+
+		if parts := modlineSplitter(line); parts != nil {
+			modname, modver := parts[0], parts[1]
+			modver = strings.TrimSuffix(modver, "/"+goModFilename)
+			modnameVer := modname + " " + modver
+			doWrite = isGoMod[modnameVer]
+		} else {
+			doWrite = true
+		}
+
+		if doWrite {
+			fmt.Fprintln(b, line)
+		} else {
+			dirty = true
+		}
+	}
+
+	if !dirty {
+		// Nothing changed
+		return nil, nil
+	}
+
+	return b.Bytes(), nil
+
+}
+
+func (c *Client) rmVendorDir(vendorDir string) error {
+	modulestxt := filepath.Join(vendorDir, vendorModulesFilename)
+
+	if _, err := c.fs.Stat(vendorDir); err != nil {
+		return nil
+	}
+
+	_, err := c.fs.Stat(modulestxt)
+	if err != nil {
+		// If we have a _vendor dir without modules.txt it sounds like
+		// a _vendor dir created by others.
+		return errors.New("found _vendor dir without modules.txt, skip delete")
+	}
+
+	return c.fs.RemoveAll(vendorDir)
+}
+
+func (c *Client) runGo(
+	ctx context.Context,
+	stdout io.Writer,
+	args ...string) error {
+
+	if c.goBinaryStatus != 0 {
+		return nil
+	}
+
+	stderr := new(bytes.Buffer)
+	cmd := exec.CommandContext(ctx, "go", args...)
+
+	cmd.Env = c.environ
+	cmd.Dir = c.workingDir
+	cmd.Stdout = stdout
+	cmd.Stderr = io.MultiWriter(stderr, os.Stderr)
+
+	if err := cmd.Run(); err != nil {
+		if ee, ok := err.(*exec.Error); ok && ee.Err == exec.ErrNotFound {
+			c.goBinaryStatus = goBinaryStatusNotFound
+			return nil
+		}
+
+		_, ok := err.(*exec.ExitError)
+		if !ok {
+			return errors.Errorf("failed to execute 'go %v': %s %T", args, err, err)
+		}
+
+		// Too old Go version
+		if strings.Contains(stderr.String(), "flag provided but not defined") {
+			c.goBinaryStatus = goBinaryStatusTooOld
+			return nil
+		}
+
+		return errors.Errorf("go command failed: %s", stderr)
+
+	}
+
+	return nil
+}
+
+func (c *Client) tidy(mods Modules, goModOnly bool) error {
+	isGoMod := make(map[string]bool)
+	for _, m := range mods {
+		if m.Owner() == nil {
+			continue
+		}
+		if m.IsGoMod() {
+			// Matching the format in go.mod
+			pathVer := m.Path() + " " + m.Version()
+			isGoMod[pathVer] = true
+		}
+	}
+
+	if err := c.rewriteGoMod(goModFilename, isGoMod); err != nil {
+		return err
+	}
+
+	if goModOnly {
+		return nil
+	}
+
+	if err := c.rewriteGoMod(goSumFilename, isGoMod); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// ClientConfig configures the module Client.
+type ClientConfig struct {
+	Fs           afero.Fs
+	Logger       *loggers.Logger
+	IgnoreVendor bool
+	WorkingDir   string
+	ThemesDir    string // Absolute directory path
+	CacheDir     string // Module cache
+	ModuleConfig Config
+}
+
+type goBinaryStatus int
+
+type goModule struct {
+	Path     string         // module path
+	Version  string         // module version
+	Versions []string       // available module versions (with -versions)
+	Replace  *goModule      // replaced by this module
+	Time     *time.Time     // time version was created
+	Update   *goModule      // available update, if any (with -u)
+	Main     bool           // is this the main module?
+	Indirect bool           // is this module only an indirect dependency of main module?
+	Dir      string         // directory holding files for this module, if any
+	GoMod    string         // path to go.mod file for this module, if any
+	Error    *goModuleError // error loading module
+}
+
+type goModuleError struct {
+	Err string // the error itself
+}
+
+type goModules []*goModule
+
+func (modules goModules) GetByPath(p string) *goModule {
+	if modules == nil {
+		return nil
+	}
+
+	for _, m := range modules {
+		if strings.EqualFold(p, m.Path) {
+			return m
+		}
+	}
+
+	return nil
+}
+
+func (modules goModules) GetMain() *goModule {
+	for _, m := range modules {
+		if m.Main {
+			return m
+		}
+	}
+
+	return nil
+}
+
+func getModlineSplitter(isGoMod bool) func(line string) []string {
+	if isGoMod {
+		return func(line string) []string {
+			if strings.HasPrefix(line, "require (") {
+				return nil
+			}
+			if !strings.HasPrefix(line, "require") && !strings.HasPrefix(line, "\t") {
+				return nil
+			}
+			line = strings.TrimPrefix(line, "require")
+			line = strings.TrimSpace(line)
+			line = strings.TrimSuffix(line, "// indirect")
+
+			return strings.Fields(line)
+		}
+	}
+
+	return func(line string) []string {
+		return strings.Fields(line)
+	}
+}
+
+func pathVersion(m Module) string {
+	versionStr := m.Version()
+	if m.Vendor() {
+		versionStr += "+vendor"
+	}
+	if versionStr == "" {
+		return m.Path()
+	}
+	return fmt.Sprintf("%s@%s", m.Path(), versionStr)
+}
diff --git a/modules/client_test.go b/modules/client_test.go
new file mode 100644
index 000000000..d8301514d
--- /dev/null
+++ b/modules/client_test.go
@@ -0,0 +1,117 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package modules
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/gohugoio/hugo/common/hugo"
+
+	"github.com/gohugoio/hugo/htesting"
+
+	"github.com/gohugoio/hugo/hugofs"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestClient(t *testing.T) {
+	if hugo.GoMinorVersion() < 12 {
+		// https://github.com/golang/go/issues/26794
+		// There were some concurrent issues with Go modules in < Go 12.
+		t.Skip("skip this for Go <= 1.11 due to a bug in Go's stdlib")
+	}
+
+	t.Parallel()
+
+	modName := "hugo-modules-basic-test"
+	modPath := "github.com/gohugoio/tests/" + modName
+	modConfig := DefaultModuleConfig
+	modConfig.Imports = []Import{Import{Path: "github.com/gohugoio/hugoTestModules1_darwin/modh2_2"}}
+
+	assert := require.New(t)
+
+	workingDir, clean, err := htesting.CreateTempDir(hugofs.Os, modName)
+	assert.NoError(err)
+	defer clean()
+
+	client := NewClient(ClientConfig{
+		Fs:           hugofs.Os,
+		WorkingDir:   workingDir,
+		ModuleConfig: modConfig,
+	})
+
+	// Test Init
+	assert.NoError(client.Init(modPath))
+
+	// Test Collect
+	mc, err := client.Collect()
+	assert.NoError(err)
+	assert.Equal(4, len(mc.AllModules))
+	for _, m := range mc.AllModules {
+		assert.NotNil(m)
+	}
+
+	// Test Graph
+	var graphb bytes.Buffer
+	assert.NoError(client.Graph(&graphb))
+
+	expect := `github.com/gohugoio/tests/hugo-modules-basic-test github.com/gohugoio/hugoTestModules1_darwin/modh2_2@v1.4.0
+github.com/gohugoio/hugoTestModules1_darwin/modh2_2@v1.4.0 github.com/gohugoio/hugoTestModules1_darwin/modh2_2_1v@v1.3.0
+github.com/gohugoio/hugoTestModules1_darwin/modh2_2@v1.4.0 github.com/gohugoio/hugoTestModules1_darwin/modh2_2_2@v1.3.0
+`
+
+	assert.Equal(expect, graphb.String())
+
+	// Test Vendor
+	assert.NoError(client.Vendor())
+	graphb.Reset()
+	assert.NoError(client.Graph(&graphb))
+	expectVendored := `github.com/gohugoio/tests/hugo-modules-basic-test github.com/gohugoio/hugoTestModules1_darwin/modh2_2@v1.4.0+vendor
+github.com/gohugoio/tests/hugo-modules-basic-test github.com/gohugoio/hugoTestModules1_darwin/modh2_2_1v@v1.3.0+vendor
+github.com/gohugoio/tests/hugo-modules-basic-test github.com/gohugoio/hugoTestModules1_darwin/modh2_2_2@v1.3.0+vendor
+`
+	assert.Equal(expectVendored, graphb.String())
+
+	// Test the ignoreVendor setting
+	clientIgnoreVendor := NewClient(ClientConfig{
+		Fs:           hugofs.Os,
+		WorkingDir:   workingDir,
+		ModuleConfig: modConfig,
+		IgnoreVendor: true,
+	})
+
+	graphb.Reset()
+	assert.NoError(clientIgnoreVendor.Graph(&graphb))
+	assert.Equal(expect, graphb.String())
+
+	// Test Tidy
+	assert.NoError(client.Tidy())
+
+}
+
+func TestGetModlineSplitter(t *testing.T) {
+
+	assert := require.New(t)
+
+	gomodSplitter := getModlineSplitter(true)
+
+	assert.Equal([]string{"github.com/BurntSushi/toml", "v0.3.1"}, gomodSplitter("\tgithub.com/BurntSushi/toml v0.3.1"))
+	assert.Equal([]string{"github.com/cpuguy83/go-md2man", "v1.0.8"}, gomodSplitter("\tgithub.com/cpuguy83/go-md2man v1.0.8 // indirect"))
+	assert.Nil(gomodSplitter("require ("))
+
+	gosumSplitter := getModlineSplitter(false)
+	assert.Equal([]string{"github.com/BurntSushi/toml", "v0.3.1"}, gosumSplitter("github.com/BurntSushi/toml v0.3.1"))
+
+}
diff --git a/modules/collect.go b/modules/collect.go
new file mode 100644
index 000000000..f57b4d04b
--- /dev/null
+++ b/modules/collect.go
@@ -0,0 +1,574 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package modules
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/spf13/cast"
+
+	"github.com/gohugoio/hugo/common/maps"
+
+	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/gohugoio/hugo/parser/metadecoders"
+
+	"github.com/gohugoio/hugo/hugofs/files"
+
+	"github.com/rogpeppe/go-internal/module"
+
+	"github.com/pkg/errors"
+
+	"github.com/gohugoio/hugo/config"
+	"github.com/spf13/afero"
+)
+
+var ErrNotExist = errors.New("module does not exist")
+
+const vendorModulesFilename = "modules.txt"
+
+// IsNotExist returns whether an error means that a module could not be found.
+func IsNotExist(err error) bool {
+	return errors.Cause(err) == ErrNotExist
+}
+
+// CreateProjectModule creates modules from the given config.
+// This is used in tests only.
+func CreateProjectModule(cfg config.Provider) (Module, error) {
+	workingDir := cfg.GetString("workingDir")
+	var modConfig Config
+
+	mod := createProjectModule(nil, workingDir, modConfig)
+	if err := ApplyProjectConfigDefaults(cfg, mod); err != nil {
+		return nil, err
+	}
+
+	return mod, nil
+}
+
+func (h *Client) Collect() (ModulesConfig, error) {
+	mc, coll := h.collect(true)
+	return mc, coll.err
+
+}
+
+func (h *Client) collect(tidy bool) (ModulesConfig, *collector) {
+	c := &collector{
+		Client: h,
+	}
+
+	c.collect()
+	if c.err != nil {
+		return ModulesConfig{}, c
+	}
+
+	if !c.skipTidy && tidy {
+		if err := h.tidy(c.modules, true); err != nil {
+			c.err = err
+			return ModulesConfig{}, c
+		}
+	}
+
+	// TODO(bep) consider --ignoreVendor vs removing from go.mod
+	var activeMods Modules
+	for _, mod := range c.modules {
+		if !mod.Config().HugoVersion.IsValid() {
+			h.logger.WARN.Printf(`Module %q is not compatible with this Hugo version; run "hugo mod graph" for more information.`, mod.Path())
+		}
+		if !mod.Disabled() {
+			activeMods = append(activeMods, mod)
+		}
+	}
+
+	return ModulesConfig{
+		AllModules:        c.modules,
+		ActiveModules:     activeMods,
+		GoModulesFilename: c.GoModulesFilename,
+	}, c
+
+}
+
+type ModulesConfig struct {
+	// All modules, including any disabled.
+	AllModules Modules
+
+	// All active modules.
+	ActiveModules Modules
+
+	// Set if this is a Go modules enabled project.
+	GoModulesFilename string
+}
+
+type collected struct {
+	// Pick the first and prevent circular loops.
+	seen map[string]bool
+
+	// Maps module path to a _vendor dir. These values are fetched from
+	// _vendor/modules.txt, and the first (top-most) will win.
+	vendored map[string]vendoredModule
+
+	// Set if a Go modules enabled project.
+	gomods goModules
+
+	// Ordered list of collected modules, including Go Modules and theme
+	// components stored below /themes.
+	modules Modules
+}
+
+// Collects and creates a module tree.
+type collector struct {
+	*Client
+
+	// Store away any non-fatal error and return at the end.
+	err error
+
+	// Set to disable any Tidy operation in the end.
+	skipTidy bool
+
+	*collected
+}
+
+func (c *collector) initModules() error {
+	c.collected = &collected{
+		seen:     make(map[string]bool),
+		vendored: make(map[string]vendoredModule),
+	}
+
+	// We may fail later if we don't find the mods.
+	return c.loadModules()
+}
+
+func (c *collector) isSeen(path string) bool {
+	key := pathKey(path)
+	if c.seen[key] {
+		return true
+	}
+	c.seen[key] = true
+	return false
+}
+
+func (c *collector) getVendoredDir(path string) (vendoredModule, bool) {
+	v, found := c.vendored[path]
+	return v, found
+}
+
+func (c *collector) add(owner *moduleAdapter, moduleImport Import, disabled bool) (*moduleAdapter, error) {
+	var (
+		mod       *goModule
+		moduleDir string
+		version   string
+		vendored  bool
+	)
+
+	modulePath := moduleImport.Path
+	var realOwner Module = owner
+
+	if !c.ignoreVendor {
+		if err := c.collectModulesTXT(owner); err != nil {
+			return nil, err
+		}
+
+		// Try _vendor first.
+		var vm vendoredModule
+		vm, vendored = c.getVendoredDir(modulePath)
+		if vendored {
+			moduleDir = vm.Dir
+			realOwner = vm.Owner
+			version = vm.Version
+
+			if owner.projectMod {
+				// We want to keep the go.mod intact with the versions and all.
+				c.skipTidy = true
+			}
+
+		}
+	}
+
+	if moduleDir == "" {
+		mod = c.gomods.GetByPath(modulePath)
+		if mod != nil {
+			moduleDir = mod.Dir
+		}
+
+		if moduleDir == "" {
+
+			if c.GoModulesFilename != "" && c.isProbablyModule(modulePath) {
+				// Try to "go get" it and reload the module configuration.
+				if err := c.Get(modulePath); err != nil {
+					return nil, err
+				}
+				if err := c.loadModules(); err != nil {
+					return nil, err
+				}
+
+				mod = c.gomods.GetByPath(modulePath)
+				if mod != nil {
+					moduleDir = mod.Dir
+				}
+			}
+
+			// Fall back to /themes/<mymodule>
+			if moduleDir == "" {
+				moduleDir = filepath.Join(c.themesDir, modulePath)
+
+				if found, _ := afero.Exists(c.fs, moduleDir); !found {
+					c.err = c.wrapModuleNotFound(errors.Errorf(`module %q not found; either add it as a Hugo Module or store it in %q.`, modulePath, c.themesDir))
+					return nil, nil
+				}
+			}
+		}
+	}
+
+	if found, _ := afero.Exists(c.fs, moduleDir); !found {
+		c.err = c.wrapModuleNotFound(errors.Errorf("%q not found", moduleDir))
+		return nil, nil
+	}
+
+	if !strings.HasSuffix(moduleDir, fileSeparator) {
+		moduleDir += fileSeparator
+	}
+
+	ma := &moduleAdapter{
+		dir:      moduleDir,
+		vendor:   vendored,
+		disabled: disabled,
+		gomod:    mod,
+		version:  version,
+		// This may be the owner of the _vendor dir
+		owner: realOwner,
+	}
+
+	if mod == nil {
+		ma.path = modulePath
+	}
+
+	if err := ma.validateAndApplyDefaults(c.fs); err != nil {
+		return nil, err
+	}
+
+	if !moduleImport.IgnoreConfig {
+		if err := c.applyThemeConfig(ma); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := c.applyMounts(moduleImport, ma); err != nil {
+		return nil, err
+	}
+
+	c.modules = append(c.modules, ma)
+	return ma, nil
+
+}
+
+func (c *collector) addAndRecurse(owner *moduleAdapter, disabled bool) error {
+	moduleConfig := owner.Config()
+	if owner.projectMod {
+		if err := c.applyMounts(Import{}, owner); err != nil {
+			return err
+		}
+	}
+
+	for _, moduleImport := range moduleConfig.Imports {
+		disabled := disabled || moduleImport.Disabled
+
+		if !c.isSeen(moduleImport.Path) {
+			tc, err := c.add(owner, moduleImport, disabled)
+			if err != nil {
+				return err
+			}
+			if tc == nil {
+				continue
+			}
+			if err := c.addAndRecurse(tc, disabled); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (c *collector) applyMounts(moduleImport Import, mod *moduleAdapter) error {
+	mounts := moduleImport.Mounts
+
+	if !mod.projectMod && len(mounts) == 0 {
+		modConfig := mod.Config()
+		mounts = modConfig.Mounts
+		if len(mounts) == 0 {
+			// Create default mount points for every component folder that
+			// exists in the module.
+			for _, componentFolder := range files.ComponentFolders {
+				sourceDir := filepath.Join(mod.Dir(), componentFolder)
+				_, err := c.fs.Stat(sourceDir)
+				if err == nil {
+					mounts = append(mounts, Mount{
+						Source: componentFolder,
+						Target: componentFolder,
+					})
+				}
+			}
+		}
+	}
+
+	var err error
+	mounts, err = c.normalizeMounts(mod, mounts)
+	if err != nil {
+		return err
+	}
+
+	mod.mounts = mounts
+	return nil
+}
+
+func (c *collector) applyThemeConfig(tc *moduleAdapter) error {
+
+	var (
+		configFilename string
+		cfg            config.Provider
+		themeCfg       map[string]interface{}
+		hasConfig      bool
+		err            error
+	)
+
+	// Viper supports more, but this is the sub-set supported by Hugo.
+	for _, configFormats := range config.ValidConfigFileExtensions {
+		configFilename = filepath.Join(tc.Dir(), "config."+configFormats)
+		hasConfig, _ = afero.Exists(c.fs, configFilename)
+		if hasConfig {
+			break
+		}
+	}
+
+	// The old theme information file.
+	themeTOML := filepath.Join(tc.Dir(), "theme.toml")
+
+	hasThemeTOML, _ := afero.Exists(c.fs, themeTOML)
+	if hasThemeTOML {
+		data, err := afero.ReadFile(c.fs, themeTOML)
+		if err != nil {
+			return err
+		}
+		themeCfg, err = metadecoders.Default.UnmarshalToMap(data, metadecoders.TOML)
+		if err != nil {
+			return errors.Wrapf(err, "failed to read module config for %q in %q", tc.Path(), themeTOML)
+		}
+		maps.ToLower(themeCfg)
+	}
+
+	if hasConfig {
+		if configFilename != "" {
+			var err error
+			cfg, err = config.FromFile(c.fs, configFilename)
+			if err != nil {
+				return errors.Wrapf(err, "failed to read module config for %q in %q", tc.Path(), configFilename)
+			}
+		}
+
+		tc.configFilename = configFilename
+		tc.cfg = cfg
+	}
+
+	config, err := DecodeConfig(cfg)
+	if err != nil {
+		return err
+	}
+
+	const oldVersionKey = "min_version"
+
+	if hasThemeTOML {
+
+		// Merge old with new
+		if minVersion, found := themeCfg[oldVersionKey]; found {
+			if config.HugoVersion.Min == "" {
+				config.HugoVersion.Min = hugo.VersionString(cast.ToString(minVersion))
+			}
+		}
+
+		if config.Params == nil {
+			config.Params = make(map[string]interface{})
+		}
+
+		for k, v := range themeCfg {
+			if k == oldVersionKey {
+				continue
+			}
+			config.Params[k] = v
+		}
+
+	}
+
+	tc.config = config
+
+	return nil
+
+}
+
+func (c *collector) collect() {
+	if err := c.initModules(); err != nil {
+		c.err = err
+		return
+	}
+
+	projectMod := createProjectModule(c.gomods.GetMain(), c.workingDir, c.moduleConfig)
+
+	if err := c.addAndRecurse(projectMod, false); err != nil {
+		c.err = err
+		return
+	}
+
+	// Append the project module at the tail.
+	c.modules = append(c.modules, projectMod)
+
+}
+
+func (c *collector) collectModulesTXT(owner Module) error {
+	vendorDir := filepath.Join(owner.Dir(), vendord)
+	filename := filepath.Join(vendorDir, vendorModulesFilename)
+
+	f, err := c.fs.Open(filename)
+
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+
+		return err
+	}
+
+	defer f.Close()
+
+	scanner := bufio.NewScanner(f)
+
+	for scanner.Scan() {
+		// # github.com/alecthomas/chroma v0.6.3
+		line := scanner.Text()
+		line = strings.Trim(line, "# ")
+		line = strings.TrimSpace(line)
+		parts := strings.Fields(line)
+		if len(parts) != 2 {
+			return errors.Errorf("invalid modules list: %q", filename)
+		}
+		path := parts[0]
+		if _, found := c.vendored[path]; !found {
+			c.vendored[path] = vendoredModule{
+				Owner:   owner,
+				Dir:     filepath.Join(vendorDir, path),
+				Version: parts[1],
+			}
+		}
+
+	}
+	return nil
+}
+
+func (c *collector) loadModules() error {
+	modules, err := c.listGoMods()
+	if err != nil {
+		return err
+	}
+	c.gomods = modules
+	return nil
+}
+
+func (c *collector) normalizeMounts(owner Module, mounts []Mount) ([]Mount, error) {
+	var out []Mount
+	dir := owner.Dir()
+
+	for _, mnt := range mounts {
+		errMsg := fmt.Sprintf("invalid module config for %q", owner.Path())
+
+		if mnt.Source == "" || mnt.Target == "" {
+			return nil, errors.New(errMsg + ": both source and target must be set")
+		}
+
+		mnt.Source = filepath.Clean(mnt.Source)
+		mnt.Target = filepath.Clean(mnt.Target)
+
+		// Verify that Source exists
+		sourceDir := filepath.Join(dir, mnt.Source)
+		_, err := c.fs.Stat(sourceDir)
+		if err != nil {
+			continue
+		}
+
+		// Verify that target points to one of the predefined component dirs
+		targetBase := mnt.Target
+		idxPathSep := strings.Index(mnt.Target, string(os.PathSeparator))
+		if idxPathSep != -1 {
+			targetBase = mnt.Target[0:idxPathSep]
+		}
+		if !files.IsComponentFolder(targetBase) {
+			return nil, errors.Errorf("%s: mount target must be one of: %v", errMsg, files.ComponentFolders)
+		}
+
+		out = append(out, mnt)
+	}
+
+	return out, nil
+}
+
+func (c *collector) wrapModuleNotFound(err error) error {
+	err = errors.Wrap(ErrNotExist, err.Error())
+	if c.GoModulesFilename == "" {
+		return err
+	}
+
+	baseMsg := "we found a go.mod file in your project, but"
+
+	switch c.goBinaryStatus {
+	case goBinaryStatusNotFound:
+		return errors.Wrap(err, baseMsg+" you need to install Go to use it. See https://golang.org/dl/.")
+	case goBinaryStatusTooOld:
+		return errors.Wrap(err, baseMsg+" you need to a newer version of Go to use it. See https://golang.org/dl/.")
+	}
+
+	return err
+
+}
+
+type vendoredModule struct {
+	Owner   Module
+	Dir     string
+	Version string
+}
+
+func createProjectModule(gomod *goModule, workingDir string, conf Config) *moduleAdapter {
+	// Create a pseudo module for the main project.
+	var path string
+	if gomod == nil {
+		path = "project"
+	}
+
+	return &moduleAdapter{
+		path:       path,
+		dir:        workingDir,
+		gomod:      gomod,
+		projectMod: true,
+		config:     conf,
+	}
+
+}
+
+// In the first iteration of Hugo Modules, we do not support multiple
+// major versions running at the same time, so we pick the first (upper most).
+// We will investigate namespaces in future versions.
+// TODO(bep) add a warning when the above happens.
+func pathKey(p string) string {
+	prefix, _, _ := module.SplitPathVersion(p)
+
+	return strings.ToLower(prefix)
+}
diff --git a/modules/collect_test.go b/modules/collect_test.go
new file mode 100644
index 000000000..d76c0b2bb
--- /dev/null
+++ b/modules/collect_test.go
@@ -0,0 +1,38 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package modules
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestPathKey(t *testing.T) {
+	assert := require.New(t)
+
+	for _, test := range []struct {
+		in     string
+		expect string
+	}{
+		{"github.com/foo", "github.com/foo"},
+		{"github.com/foo/v2", "github.com/foo"},
+		{"github.com/foo/v12", "github.com/foo"},
+		{"github.com/foo/v3d", "github.com/foo/v3d"},
+		{"MyTheme", "mytheme"},
+	} {
+		assert.Equal(test.expect, pathKey(test.in))
+	}
+
+}
diff --git a/modules/config.go b/modules/config.go
new file mode 100644
index 000000000..b084863d4
--- /dev/null
+++ b/modules/config.go
@@ -0,0 +1,335 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package modules
+
+import (
+	"fmt"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/gohugoio/hugo/common/hugo"
+
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/hugofs/files"
+	"github.com/gohugoio/hugo/langs"
+	"github.com/mitchellh/mapstructure"
+)
+
+var DefaultModuleConfig = Config{
+
+	// Default to direct, which means "git clone" and similar. We
+	// will investigate proxy settings in more depth later.
+	// See https://github.com/golang/go/issues/26334
+	Proxy: "direct",
+
+	// Comma separated glob list matching paths that should not use the
+	// proxy configured above.
+	NoProxy: "none",
+
+	// Comma separated glob list matching paths that should be
+	// treated as private.
+	Private: "*.*",
+}
+
+// ApplyProjectConfigDefaults applies default/missing module configuration for
+// the main project.
+func ApplyProjectConfigDefaults(cfg config.Provider, mod Module) error {
+	moda := mod.(*moduleAdapter)
+
+	// Map legacy directory config into the new module.
+	languages := cfg.Get("languagesSortedDefaultFirst").(langs.Languages)
+	isMultiHost := languages.IsMultihost()
+
+	// To bridge between old and new configuration format we need
+	// a way to make sure all of the core components are configured on
+	// the basic level.
+	componentsConfigured := make(map[string]bool)
+	for _, mnt := range moda.mounts {
+		componentsConfigured[mnt.Component()] = true
+	}
+
+	type dirKeyComponent struct {
+		key          string
+		component    string
+		multilingual bool
+	}
+
+	dirKeys := []dirKeyComponent{
+		{"contentDir", files.ComponentFolderContent, true},
+		{"dataDir", files.ComponentFolderData, false},
+		{"layoutDir", files.ComponentFolderLayouts, false},
+		{"i18nDir", files.ComponentFolderI18n, false},
+		{"archetypeDir", files.ComponentFolderArchetypes, false},
+		{"assetDir", files.ComponentFolderAssets, false},
+		{"", files.ComponentFolderStatic, isMultiHost},
+	}
+
+	createMountsFor := func(d dirKeyComponent, cfg config.Provider) []Mount {
+		var lang string
+		if language, ok := cfg.(*langs.Language); ok {
+			lang = language.Lang
+		}
+
+		// Static mounts are a little special.
+		if d.component == files.ComponentFolderStatic {
+			var mounts []Mount
+			staticDirs := getStaticDirs(cfg)
+			if len(staticDirs) > 0 {
+				componentsConfigured[d.component] = true
+			}
+
+			for _, dir := range staticDirs {
+				mounts = append(mounts, Mount{Lang: lang, Source: dir, Target: d.component})
+			}
+
+			return mounts
+
+		}
+
+		if cfg.IsSet(d.key) {
+			source := cfg.GetString(d.key)
+			componentsConfigured[d.component] = true
+
+			return []Mount{Mount{
+				// No lang set for layouts etc.
+				Source: source,
+				Target: d.component}}
+		}
+
+		return nil
+	}
+
+	createMounts := func(d dirKeyComponent) []Mount {
+		var mounts []Mount
+		if d.multilingual {
+			if d.component == files.ComponentFolderContent {
+				seen := make(map[string]bool)
+				hasContentDir := false
+				for _, language := range languages {
+					if language.ContentDir != "" {
+						hasContentDir = true
+						break
+					}
+				}
+
+				if hasContentDir {
+					for _, language := range languages {
+						contentDir := language.ContentDir
+						if contentDir == "" {
+							contentDir = files.ComponentFolderContent
+						}
+						if contentDir == "" || seen[contentDir] {
+							continue
+						}
+						seen[contentDir] = true
+						mounts = append(mounts, Mount{Lang: language.Lang, Source: contentDir, Target: d.component})
+					}
+				}
+
+				componentsConfigured[d.component] = len(seen) > 0
+
+			} else {
+				for _, language := range languages {
+					mounts = append(mounts, createMountsFor(d, language)...)
+				}
+			}
+		} else {
+			mounts = append(mounts, createMountsFor(d, cfg)...)
+		}
+
+		return mounts
+	}
+
+	var mounts []Mount
+	for _, dirKey := range dirKeys {
+		if componentsConfigured[dirKey.component] {
+
+			continue
+		}
+
+		mounts = append(mounts, createMounts(dirKey)...)
+
+	}
+
+	// Add default configuration
+	for _, dirKey := range dirKeys {
+		if componentsConfigured[dirKey.component] {
+			continue
+		}
+		mounts = append(mounts, Mount{Source: dirKey.component, Target: dirKey.component})
+	}
+
+	// Remove duplicates
+	seen := make(map[string]bool)
+	tmp := mounts[:0]
+	for _, m := range mounts {
+		key := path.Join(m.Lang, m.Source, m.Target)
+		if !seen[key] {
+			tmp = append(tmp, m)
+		}
+		seen[key] = true
+	}
+
+	moda.mounts = tmp
+
+	return nil
+}
+
+// DecodeConfig creates a modules Config from a given Hugo configuration.
+func DecodeConfig(cfg config.Provider) (Config, error) {
+	c := DefaultModuleConfig
+
+	if cfg == nil {
+		return c, nil
+	}
+
+	themeSet := cfg.IsSet("theme")
+	moduleSet := cfg.IsSet("module")
+
+	if moduleSet {
+		m := cfg.GetStringMap("module")
+		if err := mapstructure.WeakDecode(m, &c); err != nil {
+			return c, err
+		}
+
+		for i, mnt := range c.Mounts {
+			mnt.Source = filepath.Clean(mnt.Source)
+			mnt.Target = filepath.Clean(mnt.Target)
+			c.Mounts[i] = mnt
+		}
+
+	}
+
+	if themeSet {
+		imports := config.GetStringSlicePreserveString(cfg, "theme")
+		for _, imp := range imports {
+			c.Imports = append(c.Imports, Import{
+				Path: imp,
+			})
+		}
+
+	}
+
+	return c, nil
+}
+
+// Config holds a module config.
+type Config struct {
+	Mounts  []Mount
+	Imports []Import
+
+	// Meta info about this module (license information etc.).
+	Params map[string]interface{}
+
+	// Will be validated against the running Hugo version.
+	HugoVersion HugoVersion
+
+	// Configures GOPROXY.
+	Proxy string
+	// Configures GONOPROXY.
+	NoProxy string
+	// Configures GOPRIVATE.
+	Private string
+}
+
+// HugoVersion holds Hugo binary version requirements for a module.
+type HugoVersion struct {
+	// The minimum Hugo version that this module works with.
+	Min hugo.VersionString
+
+	// The maxium Hugo version that this module works with.
+	Max hugo.VersionString
+
+	// Set if the extended version is needed.
+	Extended bool
+}
+
+func (v HugoVersion) String() string {
+	extended := ""
+	if v.Extended {
+		extended = " extended"
+	}
+
+	if v.Min != "" && v.Max != "" {
+		return fmt.Sprintf("%s/%s%s", v.Min, v.Max, extended)
+	}
+
+	if v.Min != "" {
+		return fmt.Sprintf("Min %s%s", v.Min, extended)
+	}
+
+	if v.Max != "" {
+		return fmt.Sprintf("Max %s%s", v.Max, extended)
+	}
+
+	return extended
+}
+
+// IsValid reports whether this version is valid compared to the running
+// Hugo binary.
+func (v HugoVersion) IsValid() bool {
+	current := hugo.CurrentVersion.Version()
+	if v.Extended && !hugo.IsExtended {
+		return false
+	}
+
+	isValid := true
+
+	if v.Min != "" && current.Compare(v.Min) > 0 {
+		isValid = false
+	}
+
+	if v.Max != "" && current.Compare(v.Max) < 0 {
+		isValid = false
+	}
+
+	return isValid
+}
+
+type Import struct {
+	Path         string // Module path
+	IgnoreConfig bool   // Ignore any config.toml found.
+	Disabled     bool   // Turn off this module.
+	Mounts       []Mount
+}
+
+type Mount struct {
+	Source string // relative path in source repo, e.g. "scss"
+	Target string // relative target path, e.g. "assets/bootstrap/scss"
+
+	Lang string // any language code associated with this mount.
+}
+
+func (m Mount) Component() string {
+	return strings.Split(m.Target, fileSeparator)[0]
+}
+
+func getStaticDirs(cfg config.Provider) []string {
+	var staticDirs []string
+	for i := -1; i <= 10; i++ {
+		staticDirs = append(staticDirs, getStringOrStringSlice(cfg, "staticDir", i)...)
+	}
+	return staticDirs
+}
+
+func getStringOrStringSlice(cfg config.Provider, key string, id int) []string {
+
+	if id >= 0 {
+		key = fmt.Sprintf("%s%d", key, id)
+	}
+
+	return config.GetStringSlicePreserveString(cfg, key)
+
+}
diff --git a/modules/config_test.go b/modules/config_test.go
new file mode 100644
index 000000000..e99944b75
--- /dev/null
+++ b/modules/config_test.go
@@ -0,0 +1,132 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package modules
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/gohugoio/hugo/common/hugo"
+
+	"github.com/gohugoio/hugo/config"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestConfigHugoVersionIsValid(t *testing.T) {
+	assert := require.New(t)
+
+	for i, test := range []struct {
+		in     HugoVersion
+		expect bool
+	}{
+		{HugoVersion{Min: "0.33.0"}, true},
+		{HugoVersion{Min: "0.56.0-DEV"}, true},
+		{HugoVersion{Min: "0.33.0", Max: "0.55.0"}, false},
+		{HugoVersion{Min: "0.33.0", Max: "0.99.0"}, true},
+	} {
+		assert.Equal(test.expect, test.in.IsValid(), fmt.Sprintf("test %d", i))
+	}
+}
+
+func TestDecodeConfig(t *testing.T) {
+	assert := require.New(t)
+	tomlConfig := `
+[module]
+
+[module.hugoVersion]
+min = "0.54.2"
+max = "0.99.0"
+extended = true
+
+[[module.mounts]]
+source="src/project/blog"
+target="content/blog"
+lang="en"
+[[module.imports]]
+path="github.com/bep/mycomponent"
+[[module.imports.mounts]]
+source="scss"
+target="assets/bootstrap/scss"
+[[module.imports.mounts]]
+source="src/markdown/blog"
+target="content/blog"
+lang="en"
+`
+	cfg, err := config.FromConfigString(tomlConfig, "toml")
+	assert.NoError(err)
+
+	mcfg, err := DecodeConfig(cfg)
+	assert.NoError(err)
+
+	v056 := hugo.VersionString("0.56.0")
+
+	hv := mcfg.HugoVersion
+
+	assert.Equal(-1, v056.Compare(hv.Min))
+	assert.Equal(1, v056.Compare(hv.Max))
+	assert.True(hv.Extended)
+
+	if hugo.IsExtended {
+		assert.True(hv.IsValid())
+	}
+
+	assert.Len(mcfg.Mounts, 1)
+	assert.Len(mcfg.Imports, 1)
+	imp := mcfg.Imports[0]
+	imp.Path = "github.com/bep/mycomponent"
+	assert.Equal("src/markdown/blog", imp.Mounts[1].Source)
+	assert.Equal("content/blog", imp.Mounts[1].Target)
+	assert.Equal("en", imp.Mounts[1].Lang)
+
+}
+
+func TestDecodeConfigBothOldAndNewProvided(t *testing.T) {
+	assert := require.New(t)
+	tomlConfig := `
+
+theme = ["b", "c"]
+
+[module]
+[[module.imports]]
+path="a"
+
+`
+	cfg, err := config.FromConfigString(tomlConfig, "toml")
+	assert.NoError(err)
+
+	modCfg, err := DecodeConfig(cfg)
+	assert.NoError(err)
+	assert.Len(modCfg.Imports, 3)
+	assert.Equal("a", modCfg.Imports[0].Path)
+
+}
+
+// Test old style theme import.
+func TestDecodeConfigTheme(t *testing.T) {
+	assert := require.New(t)
+	tomlConfig := `
+
+theme = ["a", "b"]
+`
+	cfg, err := config.FromConfigString(tomlConfig, "toml")
+	assert.NoError(err)
+
+	mcfg, err := DecodeConfig(cfg)
+	assert.NoError(err)
+
+	assert.Len(mcfg.Imports, 2)
+	assert.Equal("a", mcfg.Imports[0].Path)
+	assert.Equal("b", mcfg.Imports[1].Path)
+}
diff --git a/modules/module.go b/modules/module.go
new file mode 100644
index 000000000..bba7657c5
--- /dev/null
+++ b/modules/module.go
@@ -0,0 +1,196 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package modules provides a client that can be used to manage Hugo Components,
+// what's refered to as Hugo Modules. Hugo Modules is built on top of Go Modules,
+// but also supports vendoring and components stored directly in the themes dir.
+package modules
+
+import (
+	"github.com/gohugoio/hugo/config"
+	"github.com/spf13/afero"
+)
+
+var _ Module = (*moduleAdapter)(nil)
+
+type Module interface {
+
+	// Optional config read from the configFilename above.
+	Cfg() config.Provider
+
+	// The decoded module config and mounts.
+	Config() Config
+
+	// Optional configuration filename (e.g. "/themes/mytheme/config.json").
+	// This will be added to the special configuration watch list when in
+	// server mode.
+	ConfigFilename() string
+
+	// Directory holding files for this module.
+	Dir() string
+
+	// This module is disabled.
+	Disabled() bool
+
+	// Returns whether this is a Go Module.
+	IsGoMod() bool
+
+	// Any directory remappings.
+	Mounts() []Mount
+
+	// In the dependency tree, this is the first module that defines this module
+	// as a dependency.
+	Owner() Module
+
+	// Returns the path to this module.
+	// This will either be the module path, e.g. "github.com/gohugoio/myshortcodes",
+	// or the path below your /theme folder, e.g. "mytheme".
+	Path() string
+
+	// Replaced by this module.
+	Replace() Module
+
+	// Returns whether Dir points below the _vendor dir.
+	Vendor() bool
+
+	// The module version.
+	Version() string
+
+	// Whether this module's dir is a watch candidate.
+	Watch() bool
+}
+
+type Modules []Module
+
+type moduleAdapter struct {
+	path       string
+	dir        string
+	version    string
+	vendor     bool
+	disabled   bool
+	projectMod bool
+	owner      Module
+
+	mounts []Mount
+
+	configFilename string
+	cfg            config.Provider
+	config         Config
+
+	// Set if a Go module.
+	gomod *goModule
+}
+
+func (m *moduleAdapter) Cfg() config.Provider {
+	return m.cfg
+}
+
+func (m *moduleAdapter) Config() Config {
+	return m.config
+}
+
+func (m *moduleAdapter) ConfigFilename() string {
+	return m.configFilename
+}
+
+func (m *moduleAdapter) Dir() string {
+	// This may point to the _vendor dir.
+	if !m.IsGoMod() || m.dir != "" {
+		return m.dir
+	}
+	return m.gomod.Dir
+}
+
+func (m *moduleAdapter) Disabled() bool {
+	return m.disabled
+}
+
+func (m *moduleAdapter) IsGoMod() bool {
+	return m.gomod != nil
+}
+
+func (m *moduleAdapter) Mounts() []Mount {
+	return m.mounts
+}
+
+func (m *moduleAdapter) Owner() Module {
+	return m.owner
+}
+
+func (m *moduleAdapter) Path() string {
+	if !m.IsGoMod() || m.path != "" {
+		return m.path
+	}
+	return m.gomod.Path
+}
+
+func (m *moduleAdapter) Replace() Module {
+	if m.IsGoMod() && !m.Vendor() && m.gomod.Replace != nil {
+		return &moduleAdapter{
+			gomod: m.gomod.Replace,
+			owner: m.owner,
+		}
+	}
+	return nil
+}
+
+func (m *moduleAdapter) Vendor() bool {
+	return m.vendor
+}
+
+func (m *moduleAdapter) Version() string {
+	if !m.IsGoMod() || m.version != "" {
+		return m.version
+	}
+	return m.gomod.Version
+}
+
+func (m *moduleAdapter) Watch() bool {
+	if m.Owner() == nil {
+		// Main project
+		return true
+	}
+
+	if !m.IsGoMod() {
+		// Module inside /themes
+		return true
+	}
+
+	if m.Replace() != nil {
+		// Version is not set when replaced by a local folder.
+		return m.Replace().Version() == ""
+	}
+
+	return false
+}
+
+func (m *moduleAdapter) validateAndApplyDefaults(fs afero.Fs) error {
+
+	/*if len(m.modImport.Mounts) == 0 {
+		// Create default mount points for every component folder that
+		// exists in the module.
+		for _, componentFolder := range files.ComponentFolders {
+			sourceDir := filepath.Join(dir, componentFolder)
+			_, err := fs.Stat(sourceDir)
+			if err == nil {
+				m.modImport.Mounts = append(m.modImport.Mounts, Mount{
+					Source: componentFolder,
+					Target: componentFolder,
+				})
+			}
+		}
+	}*/
+
+	return nil
+
+}