if c.maxAge < 0 {
return false
}
- return c.maxAge == 0 || time.Now().Sub(modTime) > c.maxAge
+ return c.maxAge == 0 || time.Since(modTime) > c.maxAge
}
// For testing
bu = 0
}
default:
- return nil, errors.New("Can't apply the operator to the values")
+ return nil, errors.New("can't apply the operator to the values")
}
case reflect.Float32, reflect.Float64:
af = av.Float()
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
bf = float64(bv.Uint()) // may overflow
default:
- return nil, errors.New("Can't apply the operator to the values")
+ return nil, errors.New("can't apply the operator to the values")
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
au = av.Uint()
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
bu = bv.Uint()
default:
- return nil, errors.New("Can't apply the operator to the values")
+ return nil, errors.New("can't apply the operator to the values")
}
case reflect.String:
as := av.String()
bs := bv.String()
return as + bs, nil
}
- return nil, errors.New("Can't apply the operator to the values")
+ return nil, errors.New("can't apply the operator to the values")
default:
- return nil, errors.New("Can't apply the operator to the values")
+ return nil, errors.New("can't apply the operator to the values")
}
switch op {
} else if bu != 0 {
return au / bu, nil
}
- return nil, errors.New("Can't divide the value by 0")
+ return nil, errors.New("can't divide the value by 0")
default:
- return nil, errors.New("There is no such an operation")
+ return nil, errors.New("there is no such an operation")
}
}
}
out, err := targetFs.Create(targetFilename)
+ if err != nil {
+ return err
+ }
_, err = io.Copy(out, in)
if err != nil {
siteConfig[k] = v
}
- if config != nil {
- for k, v := range config {
- siteConfig[k] = v
- }
+ for k, v := range config {
+ siteConfig[k] = v
}
combinedConfig := &BlackFriday{}
err := cmd.Run()
// Most external helpers exit w/ non-zero exit code only if severe, i.e.
// halting errors occurred. -> log stderr output regardless of state of err
- for _, item := range strings.Split(string(cmderr.Bytes()), "\n") {
+ for _, item := range strings.Split(cmderr.String(), "\n") {
item := strings.TrimSpace(item)
if item != "" {
jww.ERROR.Printf("%s: %s", ctx.DocumentName, item)
defer bufferpool.PutBuffer(buff)
emoji.Fprint(buff, string(in))
- bc := make([]byte, buff.Len(), buff.Len())
+ bc := make([]byte, buff.Len())
copy(bc, buff.Bytes())
return bc
}
if a, ok := addr.(*net.TCPAddr); ok {
return a, nil
}
- return nil, fmt.Errorf("Unable to obtain a valid tcp port. %v", addr)
+ return nil, fmt.Errorf("unable to obtain a valid tcp port: %v", addr)
}
return nil, err
}
b.ReadFrom(lines)
- bc := make([]byte, b.Len(), b.Len())
+ bc := make([]byte, b.Len())
copy(bc, b.Bytes())
return bc
}
switch name {
case "baseUrl":
name = "baseURL"
- break
case "uglyUrls":
name = "uglyURLs"
- break
}
return pflag.NormalizedName(name)
}
"github.com/gohugoio/hugo/common/hugio"
_errors "github.com/pkg/errors"
"github.com/spf13/afero"
+ "golang.org/x/text/runes"
"golang.org/x/text/transform"
"golang.org/x/text/unicode/norm"
)
if p.RemovePathAccents {
// remove accents - see https://blog.golang.org/normalization
- t := transform.Chain(norm.NFD, transform.RemoveFunc(isMn), norm.NFC)
+ t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
result, _, _ = transform.String(t, string(target))
} else {
result = string(target)
return result
}
-func isMn(r rune) bool {
- return unicode.Is(unicode.Mn, r) // Mn: nonspacing marks
-}
-
// ReplaceExtension takes a path and an extension, strips the old extension
// and returns the path with the new extension.
func ReplaceExtension(path string, newExt string) string {
return strings.TrimPrefix(inPath, currentPath), nil
}
}
- return inPath, errors.New("Can't extract relative path, unknown prefix")
+ return inPath, errors.New("can't extract relative path, unknown prefix")
}
// Should be good enough for Hugo.
}
-var numInPathRe = regexp.MustCompile("\\.(\\d+)\\.")
-
// FindCWD returns the current working directory from where the Hugo
// executable is run.
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)
+ return "", fmt.Errorf("can't get absolute path for executable: %v", err)
}
path := filepath.Dir(serverFile)
// Sanity check
if root != "" && len(root) < 4 {
- return errors.New("Path is too short")
+ return errors.New("path is too short")
}
// Handle the root first
}
if !fileInfo.IsDir() {
- return fmt.Errorf("Cannot walk regular file %s", root)
+ return fmt.Errorf("cannot walk regular file %s", root)
}
if err := walker(realPath, fileInfo, err); err != nil && err != filepath.SkipDir {
t.Skip("Skip TestGetRealPath as os.Symlink needs administrator rights on Windows")
}
- d1, err := ioutil.TempDir("", "d1")
+ d1, _ := ioutil.TempDir("", "d1")
defer os.Remove(d1)
fs := afero.NewOsFs()
f, err := createZeroSizedFileInTempDir()
if err != nil {
// no file ??
+ return nil, err
}
byteString := []byte("byteString")
err = ioutil.WriteFile(f.Name(), byteString, 0644)
}
func deleteFileInTempDir(f *os.File) {
- err := os.Remove(f.Name())
- if err != nil {
- // now what?
- }
+ _ = os.Remove(f.Name())
}
func createEmptyTempDir() (string, error) {
func createTempDirWithZeroLengthFiles() (string, error) {
d, dirErr := createEmptyTempDir()
if dirErr != nil {
- //now what?
+ return "", dirErr
}
filePrefix := "_path_test_"
_, fileErr := ioutil.TempFile(d, filePrefix) // dir is os.TempDir()
func createTempDirWithNonZeroLengthFiles() (string, error) {
d, dirErr := createEmptyTempDir()
if dirErr != nil {
- //now what?
+ return "", dirErr
}
filePrefix := "_path_test_"
f, fileErr := ioutil.TempFile(d, filePrefix) // dir is os.TempDir()
}
func deleteTempDir(d string) {
- err := os.RemoveAll(d)
- if err != nil {
- // now what?
- }
+ _ = os.RemoveAll(d)
}
func TestExists(t *testing.T) {
return code, err
}
- str := string(normalizeExternalHelperLineFeeds([]byte(out.String())))
+ str := string(normalizeExternalHelperLineFeeds(out.Bytes()))
str = h.injectCodeTag(str, lang)
in = strings.Trim(in, " ")
opts := make(map[string]string)
- if defaults != nil {
- for k, v := range defaults {
- opts[k] = v
- }
+ for k, v := range defaults {
+ opts[k] = v
}
if in == "" {
}
if p.Host != "" {
- panic(fmt.Errorf("Can't make permalink from absolute link %q", plink))
+ panic(fmt.Errorf("can't make permalink from absolute link %q", plink))
}
base.Path = path.Join(base.Path, p.Path)
assert.NoError(err)
defer f.Close()
files, err := f.Readdir(-1)
+ assert.NoError(err)
assert.Equal(4, len(files))
expected := map[string]bool{
filepath.FromSlash("/content/en/f1.txt"): true,
import (
"errors"
- "io"
"os"
"path/filepath"
"strings"
return out
}
-
-func printFs(fs afero.Fs, path string, w io.Writer) {
- if fs == nil {
- return
- }
- afero.Walk(fs, path, func(path string, info os.FileInfo, err error) error {
- if info != nil && !info.IsDir() {
- s := path
- if lang, ok := info.(hugofs.LanguageAnnouncer); ok {
- s = s + "\tLANG: " + lang.Lang()
- }
- if fp, ok := info.(hugofs.FilePather); ok {
- s = s + "\tRF: " + fp.Filename() + "\tBP: " + fp.BaseDir()
- }
- fmt.Fprintln(w, " ", s)
- }
- return nil
- })
-}
"os"
"path"
"path/filepath"
- "runtime"
"sort"
"strings"
"github.com/bep/gitmap"
- "github.com/spf13/cast"
"github.com/gohugoio/hugo/helpers"
return currPos
}
-func content(c resource.ContentProvider) string {
- cc, err := c.Content()
- if err != nil {
- panic(err)
- }
-
- ccs, err := cast.ToStringE(cc)
- if err != nil {
- panic(err)
- }
- return ccs
-}
-
func (s *Site) sectionsFromFile(fi source.File) []string {
dirname := fi.Dir()
dirname = strings.Trim(dirname, helpers.FilePathSeparator)
return parts
}
-
-func printStackTrace(length int) string {
- trace := make([]byte, length)
- runtime.Stack(trace, true)
- return string(trace)
-}
if isFullProtocol && u.Opaque != "" {
u.Opaque = "//" + u.Opaque
} else if isOpaqueProtocol && u.Opaque == "" {
- return "", fmt.Errorf("Cannot determine BaseURL for protocol %q", protocol)
+ return "", fmt.Errorf("cannot determine BaseURL for protocol %q", protocol)
}
return u.String(), nil
"github.com/spf13/viper"
)
-// used to indicate if run as a test.
-var testMode bool
-
// Site contains all the information relevant for constructing a static
// site. The basic flow of information is as follows:
//
templateWithURLAbs = "<a href=\"/foobar.jpg\">Going</a>"
)
-func init() {
- testMode = true
-}
-
func TestRenderWithInvalidTemplate(t *testing.T) {
t.Parallel()
cfg, fs := newTestCfg()
"github.com/gohugoio/hugo/resources/page"
"github.com/sanity-io/litter"
"github.com/spf13/afero"
+ "github.com/spf13/cast"
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/tpl"
"os"
+ "github.com/gohugoio/hugo/resources/resource"
+
"github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/hugofs"
"github.com/stretchr/testify/assert"
return p
}
+func content(c resource.ContentProvider) string {
+ cc, err := c.Content()
+ if err != nil {
+ panic(err)
+ }
+
+ ccs, err := cast.ToStringE(cc)
+ if err != nil {
+ panic(err)
+ }
+ return ccs
+}
+
func dumpPages(pages ...page.Page) {
fmt.Println("---------")
for i, p := range pages {
t.Parallel()
}
}
-
-// Useful to debug nilpointers/panics in templates.
-// Put "defer recoverStack()" in top of the failing function.
-func recoverStack() {
- if r := recover(); r != nil {
- fmt.Println(printStackTrace(1000))
- }
-}
addMinifier(m, mediaTypes, "css", cssMin)
addMinifierFunc(m, mediaTypes, "js", js.Minify)
m.AddFuncRegexp(regexp.MustCompile("^(application|text)/(x-)?(java|ecma)script$"), js.Minify)
- m.AddFuncRegexp(regexp.MustCompile("^(application|text)/(x-|ld\\+)?json$"), json.Minify)
+ m.AddFuncRegexp(regexp.MustCompile(`^(application|text)/(x-|ld\+)?json$`), json.Minify)
addMinifierFunc(m, mediaTypes, "json", json.Minify)
addMinifierFunc(m, mediaTypes, "svg", svg.Minify)
addMinifierFunc(m, mediaTypes, "xml", xml.Minify)
"github.com/BurntSushi/toml"
- "gopkg.in/yaml.v2"
+ yaml "gopkg.in/yaml.v2"
)
const (
return err
default:
- return errors.New("Unsupported Format provided")
+ return errors.New("unsupported Format provided")
}
}
}
-func (l *pageLexer) posFirstNonWhiteSpace() int {
- f := func(c rune) bool {
- return !unicode.IsSpace(c)
- }
- return bytes.IndexFunc(l.input[l.pos:], f)
-}
-
func lexDone(l *pageLexer) stateFunc {
// Done!
return bytes.HasPrefix(l.input[l.pos:], prefix)
}
-func (l *pageLexer) hasPrefixByte(prefix byte) bool {
- b := l.input[l.pos:]
- if len(b) == 0 {
- return false
- }
- return b[0] == prefix
-}
-
// helper functions
// returns the min index >= 0
}
if exists {
- return fmt.Errorf("Tag %q already exists", tag)
+ return fmt.Errorf("tag %q already exists", tag)
}
var changeLogFromTag string
for k := 0; k < 2; k++ {
r1, err := img.Resize(fmt.Sprintf("%dx", id-k))
if err != nil {
- t.Fatal(err)
+ t.Error(err)
}
if r1.Width() != id-k {
- t.Fatalf("Width: %d:%d", r1.Width(), j)
+ t.Errorf("Width: %d:%d", r1.Width(), j)
}
r2, err := r1.Resize(fmt.Sprintf("%dx", id-k-1))
if err != nil {
- t.Fatal(err)
+ t.Error(err)
}
_, err = r2.decodeSource()
if err != nil {
- t.Fatal("Err decode:", err)
+ t.Error("Err decode:", err)
}
img = r1
package source
import (
- "fmt"
- "io"
"os"
"path/filepath"
"strings"
"github.com/gohugoio/hugo/common/hugio"
- "github.com/spf13/afero"
-
"github.com/gohugoio/hugo/hugofs"
"github.com/gohugoio/hugo/helpers"
return f
}
-
-func printFs(fs afero.Fs, path string, w io.Writer) {
- if fs == nil {
- return
- }
- afero.Walk(fs, path, func(path string, info os.FileInfo, err error) error {
-
- if info != nil && !info.IsDir() {
-
- s := path
- if lang, ok := info.(hugofs.LanguageAnnouncer); ok {
- s = s + "\t" + lang.Lang()
- }
- if fp, ok := info.(hugofs.FilePather); ok {
- s = s + "\t" + fp.Filename()
- }
- fmt.Fprintln(w, " ", s)
- }
- return nil
- })
-}
}
}
-type TestPath struct {
- filename string
- logical string
- content string
- section string
- dir string
-}
-
func TestUnicodeNorm(t *testing.T) {
if runtime.GOOS != "darwin" {
// Normalization code is only for Mac OS, since it is not necessary for other OSes.
+++ /dev/null
-// Copyright 2015 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.
-
-// +build linux darwin !windows
-
-package source
-
-//
-// NOTE, any changes here need to be reflected in filesystem_windows_test.go
-//
-var platformBase = "/base/"
-var platformPaths = []TestPath{
- {"foobar", "foobar", "aaa", "", ""},
- {"b/1file", "1file", "aaa", "b", "b/"},
- {"c/d/2file", "2file", "aaa", "c", "c/d/"},
- {"/base/e/f/3file", "3file", "aaa", "e", "e/f/"},
- {"section/foo.rss", "foo.rss", "aaa", "section", "section/"},
-}
+++ /dev/null
-// Copyright 2015 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 source
-
-//
-// NOTE, any changes here need to be reflected in filesystem_linux_test.go
-//
-
-// Note the case of the volume drive. It must be the same in all examples.
-var platformBase = "C:\\foo\\"
-var platformPaths = []TestPath{
- {"foobar", "foobar", "aaa", "", ""},
- {"b\\1file", "1file", "aaa", "b", "b\\"},
- {"c\\d\\2file", "2file", "aaa", "c", "c\\d\\"},
- {"C:\\foo\\e\\f\\3file", "3file", "aaa", "e", "e\\f\\"}, // note volume case is equal to platformBase
- {"section\\foo.rss", "foo.rss", "aaa", "section", "section\\"},
-}
if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
link, err := filepath.EvalSymlinks(filename)
+ if err != nil {
+ return false, err
+ }
+
fi, err = helpers.LstatIfPossible(s.SourceFs, link)
if err != nil {
return false, err
case kind == reflect.Interface:
return numberToFloat(v.Elem())
default:
- return 0, fmt.Errorf("Invalid kind %s in numberToFloat", kind)
+ return 0, fmt.Errorf("invalid kind %s in numberToFloat", kind)
}
}
url := strings.Join(urlParts, "")
cache := ns.cacheGetCSV
- unmarshal := func(b []byte) (error, bool) {
+ unmarshal := func(b []byte) (bool, error) {
if !bytes.Contains(b, []byte(sep)) {
- return _errors.Errorf("cannot find separator %s in CSV for %s", sep, url), false
+ return false, _errors.Errorf("cannot find separator %s in CSV for %s", sep, url)
}
if d, err = parseCSV(b, sep); err != nil {
err = _errors.Wrapf(err, "failed to parse CSV file %s", url)
- return err, true
+ return true, err
}
- return nil, false
+ return false, nil
}
var req *http.Request
return nil, _errors.Wrapf(err, "Failed to create request for getJSON resource %s", url)
}
- unmarshal := func(b []byte) (error, bool) {
+ unmarshal := func(b []byte) (bool, error) {
err := json.Unmarshal(b, &v)
if err != nil {
- return err, true
+ return true, err
}
- return nil, false
+ return false, nil
}
req.Header.Add("Accept", "application/json")
)
// getRemote loads the content of a remote file. This method is thread safe.
-func (ns *Namespace) getRemote(cache *filecache.Cache, unmarshal func([]byte) (error, bool), req *http.Request) error {
+func (ns *Namespace) getRemote(cache *filecache.Cache, unmarshal func([]byte) (bool, error), req *http.Request) error {
url := req.URL.String()
id := helpers.MD5String(url)
var handled bool
}
res.Body.Close()
- err, retry = unmarshal(b)
+ retry, err = unmarshal(b)
if err == nil {
// Return it so it can be cached.
if !handled {
// This is cached content and should be correct.
- err, _ = unmarshal(b)
+ _, err = unmarshal(b)
}
return err
// getResource loads the content of a local or remote file and returns its content and the
// cache ID used, if relevant.
-func (ns *Namespace) getResource(cache *filecache.Cache, unmarshal func(b []byte) (error, bool), req *http.Request) error {
+func (ns *Namespace) getResource(cache *filecache.Cache, unmarshal func(b []byte) (bool, error), req *http.Request) error {
switch req.URL.Scheme {
case "":
b, err := getLocal(req.URL.String(), ns.deps.Fs.Source, ns.deps.Cfg)
if err != nil {
return err
}
- err, _ = unmarshal(b)
+ _, err = unmarshal(b)
return err
default:
return ns.getRemote(cache, unmarshal, req)
ns.client = cl
var c []byte
- f := func(b []byte) (error, bool) {
+ f := func(b []byte) (bool, error) {
c = b
- return nil, false
+ return false, nil
}
err = ns.getRemote(cache, f, req)
defer wg.Done()
for j := 0; j < 10; j++ {
var c []byte
- f := func(b []byte) (error, bool) {
+ f := func(b []byte) (bool, error) {
c = b
- return nil, false
+ return false, nil
}
err := ns.getRemote(ns.cacheGetJSON, f, req)
assert.NoError(t, err)
if string(content) != string(c) {
- t.Fatalf("expected\n%q\ngot\n%q", content, c)
+ t.Errorf("expected\n%q\ngot\n%q", content, c)
}
time.Sleep(23 * time.Millisecond)
bi, errb := cast.ToInt64E(b)
if erra != nil || errb != nil {
- return 0, errors.New("Modulo operator can't be used with non integer value")
+ return 0, errors.New("modulo operator can't be used with non integer value")
}
if bi == 0 {
- return 0, errors.New("The number can't be divided by zero at modulo operation")
+ return 0, errors.New("the number can't be divided by zero at modulo operation")
}
return ai % bi, nil
if info, err := fs.Stat(filename); err == nil {
if info.Size() > 1000000 {
- return "", fmt.Errorf("File %q is too big", filename)
+ return "", fmt.Errorf("file %q is too big", filename)
}
} else {
return "", err
list, err := afero.ReadDir(ns.deps.Fs.WorkingDir, path)
if err != nil {
- return nil, fmt.Errorf("Failed to read Directory %s with error message %s", path, err)
+ return nil, fmt.Errorf("failed to read directory %q: %s", path, err)
}
return list, nil
}
- return "", fmt.Errorf("Partial %q not found", name)
+ return "", fmt.Errorf("partial %q not found", name)
}
// IncludeCached executes and caches partial templates. An optional variant
// Panics in templates are a little bit too common (nil pointers etc.)
// See https://github.com/gohugoio/hugo/issues/5327
if r := recover(); r != nil {
- execErr = t.addFileContext(t.Name(), fmt.Errorf(`panic in Execute: %s. See "https://github.com/gohugoio/hugo/issues/5327" for the reason why we cannot provide a better error message for this.`, r))
+ execErr = t.addFileContext(t.Name(), fmt.Errorf(`panic in Execute: %s. See "https://github.com/gohugoio/hugo/issues/5327" for the reason why we cannot provide a better error message for this`, r))
}
}()
// The identifiers may be truncated in the log, e.g.
// "executing "main" at <$scaled.SRelPermalin...>: can't evaluate field SRelPermalink in type *resource.Image"
-var identifiersRe = regexp.MustCompile("at \\<(.*?)(\\.{3})?\\>:")
+var identifiersRe = regexp.MustCompile(`at \<(.*?)(\.{3})?\>:`)
func (t *TemplateAdapter) extractIdentifiers(line string) []string {
m := identifiersRe.FindAllStringSubmatch(line, -1)
var nameValues []string
err = filepath.Walk(temlatePath, func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ return err
+ }
if info.IsDir() {
return nil
}
meta, err := metadecoders.Default.UnmarshalToMap([]byte(from), fromFormat)
+ if err != nil {
+ return "", err
+ }
var result bytes.Buffer
if err := parser.InterfaceToConfig(meta, mark, &result); err != nil {
expected := "Test: f4r f3r f1r f2r f1r The End."
- if string(out.Bytes()) != expected {
- t.Errorf("Expected %s got %s", expected, string(out.Bytes()))
+ if out.String() != expected {
+ t.Errorf("Expected %s got %s", expected, out.String())
}
}
tr.Apply(out, in)
expected := fmt.Sprintf(`<script data-no-instant>document.write('<script src="/livereload.js?port=1313&mindelay=10"></' + 'script>')</script>%s`, bodyEndTag)
- if string(out.Bytes()) != expected {
- t.Errorf("Expected %s got %s", expected, string(out.Bytes()))
+ if out.String() != expected {
+ t.Errorf("Expected %s got %s", expected, out.String())
}
}
quotes [][]byte
}
-type stateFunc func(*absurllexer) stateFunc
-
type prefix struct {
disabled bool
b []byte
}
}
-type absURLMatcher struct {
- match []byte
- quote []byte
-}
-
func (l *absurllexer) emit() {
l.w.Write(l.content[l.start:l.pos])
l.start = l.pos
replace1 = "No replacements."
replace2 = "ᚠᛇᚻ ᛒᛦᚦ ᚠᚱᚩᚠᚢᚱ\nᚠᛁᚱᚪ ᚷᛖᚻᚹᛦᛚᚳᚢᛗ"
replace3 = `End of file: src="/`
- replace4 = `End of file: srcset="/`
replace5 = `Srcsett with no closing quote: srcset="/img/small.jpg do be do be do.`
// Issue: 816, schemaless links combined with others
projects / brevno-suite / hugo / commitdiff