Revert "Fix PostProcess regression for hugo server"

This reverts commit 4deb5c60661bdb1d686664f0207f45517a086f29.

diff --git a/commands/commandeer.go b/commands/commandeer.go
index c42de5d11a52741abd7b2cb9340a62d8dceb2188..1162a4b7054b749e91f7084b88367f0a8f5d8c4b 100644 (file)
--- a/commands/commandeer.go
+++ b/commands/commandeer.go
@@ -395,23 +395,23 @@ func (c *commandeer) loadConfig() error {
        }
 
        c.fsCreate.Do(func() {
-               // Assume both source and destination are using same filesystem.
-               fs := hugofs.NewFromSourceAndDestination(sourceFs, sourceFs, config)
+               fs := hugofs.NewFrom(sourceFs, config)
 
                if c.publishDirFs != nil {
                        // Need to reuse the destination on server rebuilds.
                        fs.PublishDir = c.publishDirFs
                        fs.PublishDirServer = c.publishDirServerFs
                } else {
-                       if c.renderStaticToDisk {
-                               publishDirStatic := config.GetString("publishDirStatic")
-                               workingDir := config.GetString("workingDir")
-                               absPublishDirStatic := paths.AbsPathify(workingDir, publishDirStatic)
+                       publishDir := config.GetString("publishDir")
+                       publishDirStatic := config.GetString("publishDirStatic")
+                       workingDir := config.GetString("workingDir")
+                       absPublishDir := paths.AbsPathify(workingDir, publishDir)
+                       absPublishDirStatic := paths.AbsPathify(workingDir, publishDirStatic)
 
-                               fs = hugofs.NewFromSourceAndDestination(sourceFs, afero.NewMemMapFs(), config)
-                               // Writes the dynamic output to memory,
+                       if c.renderStaticToDisk {
+                               // Writes the dynamic output oton memory,
                                // while serve others directly from /public on disk.
-                               dynamicFs := fs.PublishDir
+                               dynamicFs := afero.NewMemMapFs()
                                staticFs := afero.NewBasePathFs(afero.NewOsFs(), absPublishDirStatic)
 
                                // Serve from both the static and dynamic fs,
@@ -427,10 +427,18 @@ func (c *commandeer) loadConfig() error {
                                                },
                                        },
                                )
+                               fs.PublishDir = dynamicFs
                                fs.PublishDirStatic = staticFs
                        } else if createMemFs {
                                // Hugo writes the output to memory instead of the disk.
-                               fs = hugofs.NewFromSourceAndDestination(sourceFs, afero.NewMemMapFs(), config)
+                               fs.PublishDir = new(afero.MemMapFs)
+                               fs.PublishDirServer = fs.PublishDir
+                               fs.PublishDirStatic = fs.PublishDir
+                       } else {
+                               // Write everything to disk.
+                               fs.PublishDir = afero.NewBasePathFs(afero.NewOsFs(), absPublishDir)
+                               fs.PublishDirServer = fs.PublishDir
+                               fs.PublishDirStatic = fs.PublishDir
                        }
                }
 

diff --git a/commands/commands_test.go b/commands/commands_test.go
index 97d81ec6ee97d82ffe09b6168cb2c5592299d6bb..e3ec7bd99a65c242774f2ae4c8998fbc6f4020c0 100644 (file)
--- a/commands/commands_test.go
+++ b/commands/commands_test.go
@@ -375,10 +375,6 @@ Single: {{ .Title }}
 List: {{ .Title }}
 Environment: {{ hugo.Environment }}
 
-For issue 9788:
-{{ $foo :="abc" | resources.FromString "foo.css" | minify | resources.PostProcess }}
-PostProcess: {{ $foo.RelPermalink }}
-
 `)
 
        return dir

diff --git a/commands/server_test.go b/commands/server_test.go
index c2aa0dfd5d7c15f630f4975afd4d051595e5b7d9..ea50afd94d25dfb52e49970d853cd26f13b86e9d 100644 (file)
--- a/commands/server_test.go
+++ b/commands/server_test.go
@@ -31,6 +31,16 @@ import (
        qt "github.com/frankban/quicktest"
 )
 
+func TestServer(t *testing.T) {
+       c := qt.New(t)
+
+       r := runServerTest(c, true, "")
+
+       c.Assert(r.err, qt.IsNil)
+       c.Assert(r.homeContent, qt.Contains, "List: Hugo Commands")
+       c.Assert(r.homeContent, qt.Contains, "Environment: development")
+}
+
 // Issue 9518
 func TestServerPanicOnConfigError(t *testing.T) {
        c := qt.New(t)
@@ -91,42 +101,6 @@ baseURL="https://example.org"
 
 }
 
-func TestServerBugs(t *testing.T) {
-       c := qt.New(t)
-
-       for _, test := range []struct {
-               name   string
-               flag   string
-               assert func(c *qt.C, r serverTestResult)
-       }{
-               // Issue 9788
-               {"PostProcess, memory", "", func(c *qt.C, r serverTestResult) {
-                       c.Assert(r.err, qt.IsNil)
-                       c.Assert(r.homeContent, qt.Contains, "PostProcess: /foo.min.css")
-               }},
-               {"PostProcess, disk", "--renderToDisk", func(c *qt.C, r serverTestResult) {
-                       c.Assert(r.err, qt.IsNil)
-                       c.Assert(r.homeContent, qt.Contains, "PostProcess: /foo.min.css")
-               }},
-       } {
-               c.Run(test.name, func(c *qt.C) {
-                       config := `
-baseURL="https://example.org"
-`
-
-                       var args []string
-                       if test.flag != "" {
-                               args = strings.Split(test.flag, "=")
-                       }
-                       r := runServerTest(c, true, config, args...)
-                       test.assert(c, r)
-
-               })
-
-       }
-
-}
-
 type serverTestResult struct {
        err            error
        homeContent    string

diff --git a/hugofs/fs.go b/hugofs/fs.go
index 63c25a4c0d77decd82eaf9d9b1b7de1cc0eeb4fc..436387f13f55dde7350929ad11506acca3a01ca0 100644 (file)
--- a/hugofs/fs.go
+++ b/hugofs/fs.go
@@ -65,7 +65,7 @@ type Fs struct {
 // as source and destination file systems.
 func NewDefault(cfg config.Provider) *Fs {
        fs := Os
-       return newFs(fs, fs, cfg)
+       return newFs(fs, cfg)
 }
 
 // NewMem creates a new Fs with the MemMapFs
@@ -73,23 +73,17 @@ func NewDefault(cfg config.Provider) *Fs {
 // Useful for testing.
 func NewMem(cfg config.Provider) *Fs {
        fs := &afero.MemMapFs{}
-       return newFs(fs, fs, cfg)
+       return newFs(fs, cfg)
 }
 
 // NewFrom creates a new Fs based on the provided Afero Fs
 // as source and destination file systems.
 // Useful for testing.
 func NewFrom(fs afero.Fs, cfg config.Provider) *Fs {
-       return newFs(fs, fs, cfg)
+       return newFs(fs, cfg)
 }
 
-// NewFrom creates a new Fs based on the provided Afero Fss
-// as the source and destination file systems.
-func NewFromSourceAndDestination(source, destination afero.Fs, cfg config.Provider) *Fs {
-       return newFs(source, destination, cfg)
-}
-
-func newFs(source, destination afero.Fs, cfg config.Provider) *Fs {
+func newFs(base afero.Fs, cfg config.Provider) *Fs {
        workingDir := cfg.GetString("workingDir")
        publishDir := cfg.GetString("publishDir")
        if publishDir == "" {
@@ -97,27 +91,27 @@ func newFs(source, destination afero.Fs, cfg config.Provider) *Fs {
        }
 
        // Sanity check
-       if IsOsFs(source) && len(workingDir) < 2 {
+       if IsOsFs(base) && len(workingDir) < 2 {
                panic("workingDir is too short")
        }
 
        absPublishDir := paths.AbsPathify(workingDir, publishDir)
 
        // Make sure we always have the /public folder ready to use.
-       if err := source.MkdirAll(absPublishDir, 0777); err != nil && !os.IsExist(err) {
+       if err := base.MkdirAll(absPublishDir, 0777); err != nil && !os.IsExist(err) {
                panic(err)
        }
 
-       pubFs := afero.NewBasePathFs(destination, absPublishDir)
+       pubFs := afero.NewBasePathFs(base, absPublishDir)
 
        return &Fs{
-               Source:             source,
+               Source:             base,
                PublishDir:         pubFs,
                PublishDirServer:   pubFs,
                PublishDirStatic:   pubFs,
                Os:                 &afero.OsFs{},
-               WorkingDirReadOnly: getWorkingDirFsReadOnly(source, workingDir),
-               WorkingDirWritable: getWorkingDirFsWritable(source, workingDir),
+               WorkingDirReadOnly: getWorkingDirFsReadOnly(base, workingDir),
+               WorkingDirWritable: getWorkingDirFsWritable(base, workingDir),
        }
 }