Make LazyFileReader use the Afero source fs

Fixes #2317

diff --git a/hugolib/site.go b/hugolib/site.go
index 2a850b3a96752766bfed50a95076c5076179f59b..c5851e813f80ee08793381c3e3865d993e9afba4 100644 (file)
--- a/hugolib/site.go
+++ b/hugolib/site.go
@@ -836,7 +836,7 @@ func (s *Site) reReadFile(absFilePath string) (*source.File, error) {
        jww.INFO.Println("rereading", absFilePath)
        var file *source.File
 
-       reader, err := source.NewLazyFileReader(absFilePath)
+       reader, err := source.NewLazyFileReader(hugofs.Source(), absFilePath)
        if err != nil {
                return nil, err
        }

diff --git a/source/filesystem.go b/source/filesystem.go
index 0ce5808d1e26d95cc8a4e7878d4ea11cb8124a4a..9d723685e587c6e70246bb5ebea0395c62e23f26 100644 (file)
--- a/source/filesystem.go
+++ b/source/filesystem.go
@@ -14,13 +14,14 @@
 package source
 
 import (
-       "github.com/spf13/hugo/hugofs"
        "io"
        "os"
        "path/filepath"
        "regexp"
        "strings"
 
+       "github.com/spf13/hugo/hugofs"
+
        "github.com/spf13/viper"
 
        "github.com/spf13/hugo/helpers"
@@ -84,7 +85,7 @@ func (f *Filesystem) captureFiles() {
                        return err
                }
                if b {
-                       rd, err := NewLazyFileReader(filePath)
+                       rd, err := NewLazyFileReader(hugofs.Source(), filePath)
                        if err != nil {
                                return err
                        }

diff --git a/source/lazy_file_reader.go b/source/lazy_file_reader.go
index 6e75055ad7a0aff1c74467312ef6052e7e9fc786..8ebe8df211aef846aacd742d2b3ad6745db75492 100644 (file)
--- a/source/lazy_file_reader.go
+++ b/source/lazy_file_reader.go
@@ -19,14 +19,15 @@ import (
        "errors"
        "fmt"
        "io"
-       "io/ioutil"
-       "os"
+
+       "github.com/spf13/afero"
 )
 
 // LazyFileReader is an io.Reader implementation to postpone reading the file
 // contents until it is really needed. It keeps filename and file contents once
 // it is read.
 type LazyFileReader struct {
+       fs       afero.Fs
        filename string
        contents *bytes.Reader
        pos      int64
@@ -35,13 +36,13 @@ type LazyFileReader struct {
 // NewLazyFileReader creates and initializes a new LazyFileReader of filename.
 // It checks whether the file can be opened. If it fails, it returns nil and an
 // error.
-func NewLazyFileReader(filename string) (*LazyFileReader, error) {
-       f, err := os.Open(filename)
+func NewLazyFileReader(fs afero.Fs, filename string) (*LazyFileReader, error) {
+       f, err := fs.Open(filename)
        if err != nil {
                return nil, err
        }
        defer f.Close()
-       return &LazyFileReader{filename: filename, contents: nil, pos: 0}, nil
+       return &LazyFileReader{fs: fs, filename: filename, contents: nil, pos: 0}, nil
 }
 
 // Filename returns a file name which LazyFileReader keeps
@@ -55,7 +56,7 @@ func (l *LazyFileReader) Filename() string {
 // the file.
 func (l *LazyFileReader) Read(p []byte) (n int, err error) {
        if l.contents == nil {
-               b, err := ioutil.ReadFile(l.filename)
+               b, err := afero.ReadFile(l.fs, l.filename)
                if err != nil {
                        return 0, fmt.Errorf("failed to read content from %s: %s", l.filename, err.Error())
                }
@@ -80,7 +81,7 @@ func (l *LazyFileReader) Seek(offset int64, whence int) (pos int64, err error) {
                case 1:
                        pos = l.pos + offset
                case 2:
-                       fi, err := os.Stat(l.filename)
+                       fi, err := l.fs.Stat(l.filename)
                        if err != nil {
                                return 0, fmt.Errorf("failed to get %q info: %s", l.filename, err.Error())
                        }
@@ -115,7 +116,7 @@ func (l *LazyFileReader) WriteTo(w io.Writer) (n int64, err error) {
                l.pos += n
                return n, err
        }
-       f, err := os.Open(l.filename)
+       f, err := l.fs.Open(l.filename)
        if err != nil {
                return 0, fmt.Errorf("failed to open %s to read content: %s", l.filename, err.Error())
        }

diff --git a/source/lazy_file_reader_test.go b/source/lazy_file_reader_test.go
index 8da6d0fc206b4639e2ce73add11115b44d4b6772..5522c9f1bef360370bd54c134420de2ce61de251 100644 (file)
--- a/source/lazy_file_reader_test.go
+++ b/source/lazy_file_reader_test.go
@@ -19,25 +19,29 @@ import (
        "io/ioutil"
        "os"
        "testing"
+
+       "github.com/spf13/afero"
 )
 
 func TestNewLazyFileReader(t *testing.T) {
+       fs := afero.NewOsFs()
        filename := "itdoesnotexistfile"
-       _, err := NewLazyFileReader(filename)
+       _, err := NewLazyFileReader(fs, filename)
        if err == nil {
                t.Errorf("NewLazyFileReader %s: error expected but no error is returned", filename)
        }
 
        filename = "lazy_file_reader_test.go"
-       _, err = NewLazyFileReader(filename)
+       _, err = NewLazyFileReader(fs, filename)
        if err != nil {
                t.Errorf("NewLazyFileReader %s: %v", filename, err)
        }
 }
 
 func TestFilename(t *testing.T) {
+       fs := afero.NewOsFs()
        filename := "lazy_file_reader_test.go"
-       rd, err := NewLazyFileReader(filename)
+       rd, err := NewLazyFileReader(fs, filename)
        if err != nil {
                t.Fatalf("NewLazyFileReader %s: %v", filename, err)
        }
@@ -47,18 +51,19 @@ func TestFilename(t *testing.T) {
 }
 
 func TestRead(t *testing.T) {
+       fs := afero.NewOsFs()
        filename := "lazy_file_reader_test.go"
-       fi, err := os.Stat(filename)
+       fi, err := fs.Stat(filename)
        if err != nil {
                t.Fatalf("os.Stat: %v", err)
        }
 
-       b, err := ioutil.ReadFile(filename)
+       b, err := afero.ReadFile(fs, filename)
        if err != nil {
                t.Fatalf("ioutil.ReadFile: %v", err)
        }
 
-       rd, err := NewLazyFileReader(filename)
+       rd, err := NewLazyFileReader(fs, filename)
        if err != nil {
                t.Fatalf("NewLazyFileReader %s: %v", filename, err)
        }
@@ -92,9 +97,9 @@ func TestSeek(t *testing.T) {
                moveto   int64
                expected []byte
        }
-
+       fs := afero.NewOsFs()
        filename := "lazy_file_reader_test.go"
-       b, err := ioutil.ReadFile(filename)
+       b, err := afero.ReadFile(fs, filename)
        if err != nil {
                t.Fatalf("ioutil.ReadFile: %v", err)
        }
@@ -108,7 +113,7 @@ func TestSeek(t *testing.T) {
                {seek: 3, expected: nil},
                {seek: os.SEEK_SET, offset: -1, expected: nil},
        } {
-               rd, err := NewLazyFileReader(filename)
+               rd, err := NewLazyFileReader(fs, filename)
                if err != nil {
                        t.Errorf("[%d] NewLazyFileReader %s: %v", i, filename, err)
                        continue
@@ -140,7 +145,7 @@ func TestSeek(t *testing.T) {
        }
 
        // cache case
-       rd, err := NewLazyFileReader(filename)
+       rd, err := NewLazyFileReader(fs, filename)
        if err != nil {
                t.Fatalf("NewLazyFileReader %s: %v", filename, err)
        }
@@ -185,6 +190,7 @@ func TestSeek(t *testing.T) {
 }
 
 func TestWriteTo(t *testing.T) {
+       fs := afero.NewOsFs()
        filename := "lazy_file_reader_test.go"
        fi, err := os.Stat(filename)
        if err != nil {
@@ -196,7 +202,7 @@ func TestWriteTo(t *testing.T) {
                t.Fatalf("ioutil.ReadFile: %v", err)
        }
 
-       rd, err := NewLazyFileReader(filename)
+       rd, err := NewLazyFileReader(fs, filename)
        if err != nil {
                t.Fatalf("NewLazyFileReader %s: %v", filename, err)
        }