Simplify .Site.GetPage etc.

This commit is a follow up to a recent overhaul of the GetPage/ref/relref implemenation.

The most important change in this commit is the update to `.Site.GetPage`:

* To reduce the amount of breakage in the wild to its minimum, I have reworked .Site.GetPage with some rules:

* We cannot support more than 2 arguments, i.e. .Site.GetPage "page" "posts" "mypage.md" will now throw an error. I think this is the most uncommon syntax and should be OK. It is an easy fix to change the above to .Site.GetPage "/posts/mypage.md" or similar.
* .Site.GetPage "home", .Site.GetPage "home" "" and .Site.GetPage "home" "/" will give you the home page. This means that if you have page in root with the name home.md you need to do .Site.GetPage "/home.md" or similar

This commit also fixes some multilingual issues, most notable it is now possible to do cross-language ref/relref lookups by prepending the language code to the path, e.g. `/jp/posts/mypage.md`.

This commit also reverts the site building tests related to this to "Hugo 0.44 state", to get better control of the changes made.

Closes #4147
Closes #4727
Closes #4728
Closes #4728
Closes #4726
Closes #4652

cache/partitioned_lazy_cache.go

@@ -24,34 +24,52 @@ type Partition struct {
 	Load func() (map[string]interface{}, error)
 }
 
-type lazyPartition struct {
+// Lazy represents a lazily loaded cache.
+type Lazy struct {
 	initSync sync.Once
+	initErr  error
 	cache    map[string]interface{}
 	load     func() (map[string]interface{}, error)
 }
 
-func (l *lazyPartition) init() error {
-	var err error
+// NewLazy creates a lazy cache with the given load func.
+func NewLazy(load func() (map[string]interface{}, error)) *Lazy {
+	return &Lazy{load: load}
+}
+
+func (l *Lazy) init() error {
 	l.initSync.Do(func() {
-		var c map[string]interface{}
-		c, err = l.load()
+		c, err := l.load()
 		l.cache = c
+		l.initErr = err
+
 	})
 
-	return err
+	return l.initErr
+}
+
+// Get initializes the cache if not already initialized, then looks up the
+// given key.
+func (l *Lazy) Get(key string) (interface{}, bool, error) {
+	l.init()
+	if l.initErr != nil {
+		return nil, false, l.initErr
+	}
+	v, found := l.cache[key]
+	return v, found, nil
 }
 
 // PartitionedLazyCache is a lazily loaded cache paritioned by a supplied string key.
 type PartitionedLazyCache struct {
-	partitions map[string]*lazyPartition
+	partitions map[string]*Lazy
 }
 
 // NewPartitionedLazyCache creates a new NewPartitionedLazyCache with the supplied
 // partitions.
 func NewPartitionedLazyCache(partitions ...Partition) *PartitionedLazyCache {
-	lazyPartitions := make(map[string]*lazyPartition, len(partitions))
+	lazyPartitions := make(map[string]*Lazy, len(partitions))
 	for _, partition := range partitions {
-		lazyPartitions[partition.Key] = &lazyPartition{load: partition.Load}
+		lazyPartitions[partition.Key] = NewLazy(partition.Load)
 	}
 	cache := &PartitionedLazyCache{partitions: lazyPartitions}
 
@@ -67,11 +85,12 @@ func (c *PartitionedLazyCache) Get(partition, key string) (interface{}, error) {
 		return nil, nil
 	}
 
-	if err := p.init(); err != nil {
+	v, found, err := p.Get(key)
+	if err != nil {
 		return nil, err
 	}
 
-	if v, found := p.cache[key]; found {
+	if found {
 		return v, nil
 	}