hugo/hugolib/paths/paths.go

// Copyright 2018 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 paths

import (
	"path/filepath"
	"strings"

	hpaths "github.com/gohugoio/hugo/common/paths"
	"github.com/gohugoio/hugo/common/urls"
	"github.com/gohugoio/hugo/langs"

	"github.com/gohugoio/hugo/config"
	"github.com/gohugoio/hugo/modules"

	"github.com/gohugoio/hugo/hugofs"
)

var FilePathSeparator = string(filepath.Separator)

type Paths struct {
	Fs  *hugofs.Fs
	Cfg config.AllProvider

	// Directories to store Resource related artifacts.
	AbsResourcesDir string

	AbsPublishDir string

	// When in multihost mode, this returns a list of base paths below PublishDir
	// for each language.
	MultihostTargetBasePaths []string

	// When in multihost mode, this is the URL base path (the path part of baseURL,
	// without trailing slash) for each language, parallel to MultihostTargetBasePaths.
	MultihostBasePaths []string

	// When in multihost mode, this is the deepest of the per-host base paths
	// in MultihostBasePaths. css.Build uses this so file-loader URLs are
	// reachable on every host (each host's base path is a prefix).
	MultihostLongestBasePath string
}

// allBaseURLsProvider is satisfied by allconfig.ConfigLanguage and lets us
// access per-host BaseURLs without importing allconfig (which would create an
// import cycle via helpers).
type allBaseURLsProvider interface {
	AllBaseURLs() []urls.BaseURL
}

func New(fs *hugofs.Fs, cfg config.AllProvider) (*Paths, error) {
	bcfg := cfg.BaseConfig()
	publishDir := bcfg.PublishDir
	if publishDir == "" {
		panic("publishDir not set")
	}

	absPublishDir := hpaths.AbsPathify(bcfg.WorkingDir, publishDir)
	if !strings.HasSuffix(absPublishDir, FilePathSeparator) {
		absPublishDir += FilePathSeparator
	}
	// If root, remove the second '/'
	if absPublishDir == "//" {
		absPublishDir = FilePathSeparator
	}
	absResourcesDir := hpaths.AbsPathify(bcfg.WorkingDir, cfg.Dirs().ResourceDir)
	if !strings.HasSuffix(absResourcesDir, FilePathSeparator) {
		absResourcesDir += FilePathSeparator
	}
	if absResourcesDir == "//" {
		absResourcesDir = FilePathSeparator
	}

	var (
		multihostTargetBasePaths []string
		multihostBasePaths       []string
		multihostLongestBasePath string
	)
	if cfg.IsMultihost() && len(cfg.Languages().(langs.Languages)) > 1 {
		baseURLs := cfg.(allBaseURLsProvider).AllBaseURLs()
		for i, l := range cfg.Languages().(langs.Languages) {
			multihostTargetBasePaths = append(multihostTargetBasePaths, hpaths.ToSlashPreserveLeading(l.Lang))
			bp := baseURLs[i].BasePathNoTrailingSlash
			multihostBasePaths = append(multihostBasePaths, bp)
			if len(bp) > len(multihostLongestBasePath) {
				multihostLongestBasePath = bp
			}
		}
	}

	p := &Paths{
		Fs:                       fs,
		Cfg:                      cfg,
		AbsResourcesDir:          absResourcesDir,
		AbsPublishDir:            absPublishDir,
		MultihostTargetBasePaths: multihostTargetBasePaths,
		MultihostBasePaths:       multihostBasePaths,
		MultihostLongestBasePath: multihostLongestBasePath,
	}

	return p, nil
}

func (p *Paths) AllModules() modules.Modules {
	return p.Cfg.GetConfigSection("allModules").(modules.Modules)
}

// GetBasePath returns any path element in baseURL if needed.
// The path returned will have a leading, but no trailing slash.
func (p *Paths) GetBasePath(isRelativeURL bool) string {
	if isRelativeURL && p.Cfg.CanonifyURLs() {
		// The baseURL will be prepended later.
		return ""
	}
	return p.Cfg.BaseURL().BasePathNoTrailingSlash
}

func (p *Paths) Lang() string {
	if p == nil || p.Cfg.Language() == nil {
		return ""
	}
	return p.Cfg.Language().(*langs.Language).Lang
}

func (p *Paths) GetTargetLanguageBasePath() string {
	if p.Cfg.IsMultihost() {
		// In a multihost configuration all assets will be published below the language code.
		return p.Lang()
	}
	return p.GetLanguagePrefix()
}

func (p *Paths) GetLanguagePrefix() string {
	return p.Cfg.LanguagePrefix()
}

// AbsPathify creates an absolute path if given a relative path. If already
// absolute, the path is just cleaned.
func (p *Paths) AbsPathify(inPath string) string {
	return hpaths.AbsPathify(p.Cfg.BaseConfig().WorkingDir, inPath)
}

// RelPathify trims any WorkingDir prefix from the given filename. If
// the filename is not considered to be absolute, the path is just cleaned.
func (p *Paths) RelPathify(filename string) string {
	filename = filepath.Clean(filename)
	if !filepath.IsAbs(filename) {
		return filename
	}

	return strings.TrimPrefix(strings.TrimPrefix(filename, p.Cfg.BaseConfig().WorkingDir), FilePathSeparator)
}