1 files changed, 284 insertions, 0 deletions

diff --git a/vendor/github.com/otiai10/copy/copy.go b/vendor/github.com/otiai10/copy/copy.go
new file mode 100644
index 0000000..085db78
--- /dev/null
+++ b/vendor/github.com/otiai10/copy/copy.go
@@ -0,0 +1,284 @@
+package copy
+
+import (
+        "io"
+        "io/fs"
+        "io/ioutil"
+        "os"
+        "path/filepath"
+        "time"
+)
+
+type timespec struct {
+        Mtime time.Time
+        Atime time.Time
+        Ctime time.Time
+}
+
+// Copy copies src to dest, doesn't matter if src is a directory or a file.
+func Copy(src, dest string, opts ...Options) error {
+        opt := assureOptions(src, dest, opts...)
+        if opt.FS != nil {
+                info, err := fs.Stat(opt.FS, src)
+                if err != nil {
+                        return onError(src, dest, err, opt)
+                }
+                return switchboard(src, dest, info, opt)
+        }
+        info, err := os.Lstat(src)
+        if err != nil {
+                return onError(src, dest, err, opt)
+        }
+        return switchboard(src, dest, info, opt)
+}
+
+// switchboard switches proper copy functions regarding file type, etc...
+// If there would be anything else here, add a case to this switchboard.
+func switchboard(src, dest string, info os.FileInfo, opt Options) (err error) {
+        if info.Mode()&os.ModeDevice != 0 && !opt.Specials {
+                return onError(src, dest, err, opt)
+        }
+
+        switch {
+        case info.Mode()&os.ModeSymlink != 0:
+                err = onsymlink(src, dest, opt)
+        case info.IsDir():
+                err = dcopy(src, dest, info, opt)
+        case info.Mode()&os.ModeNamedPipe != 0:
+                err = pcopy(dest, info)
+        default:
+                err = fcopy(src, dest, info, opt)
+        }
+
+        return onError(src, dest, err, opt)
+}
+
+// copyNextOrSkip decide if this src should be copied or not.
+// Because this "copy" could be called recursively,
+// "info" MUST be given here, NOT nil.
+func copyNextOrSkip(src, dest string, info os.FileInfo, opt Options) error {
+        if opt.Skip != nil {
+                skip, err := opt.Skip(info, src, dest)
+                if err != nil {
+                        return err
+                }
+                if skip {
+                        return nil
+                }
+        }
+        return switchboard(src, dest, info, opt)
+}
+
+// fcopy is for just a file,
+// with considering existence of parent directory
+// and file permission.
+func fcopy(src, dest string, info os.FileInfo, opt Options) (err error) {
+
+        var readcloser io.ReadCloser
+        if opt.FS != nil {
+                readcloser, err = opt.FS.Open(src)
+        } else {
+                readcloser, err = os.Open(src)
+        }
+        if err != nil {
+                if os.IsNotExist(err) {
+                        return nil
+                }
+                return
+        }
+        defer fclose(readcloser, &err)
+
+        if err = os.MkdirAll(filepath.Dir(dest), os.ModePerm); err != nil {
+                return
+        }
+
+        f, err := os.Create(dest)
+        if err != nil {
+                return
+        }
+        defer fclose(f, &err)
+
+        chmodfunc, err := opt.PermissionControl(info, dest)
+        if err != nil {
+                return err
+        }
+        chmodfunc(&err)
+
+        var buf []byte = nil
+        var w io.Writer = f
+        var r io.Reader = readcloser
+
+        if opt.WrapReader != nil {
+                r = opt.WrapReader(r)
+        }
+
+        if opt.CopyBufferSize != 0 {
+                buf = make([]byte, opt.CopyBufferSize)
+                // Disable using `ReadFrom` by io.CopyBuffer.
+                // See https://github.com/otiai10/copy/pull/60#discussion_r627320811 for more details.
+                w = struct{ io.Writer }{f}
+                // r = struct{ io.Reader }{s}
+        }
+
+        if _, err = io.CopyBuffer(w, r, buf); err != nil {
+                return err
+        }
+
+        if opt.Sync {
+                err = f.Sync()
+        }
+
+        if opt.PreserveOwner {
+                if err := preserveOwner(src, dest, info); err != nil {
+                        return err
+                }
+        }
+        if opt.PreserveTimes {
+                if err := preserveTimes(info, dest); err != nil {
+                        return err
+                }
+        }
+
+        return
+}
+
+// dcopy is for a directory,
+// with scanning contents inside the directory
+// and pass everything to "copy" recursively.
+func dcopy(srcdir, destdir string, info os.FileInfo, opt Options) (err error) {
+        if skip, err := onDirExists(opt, srcdir, destdir); err != nil {
+                return err
+        } else if skip {
+                return nil
+        }
+
+        // Make dest dir with 0755 so that everything writable.
+        chmodfunc, err := opt.PermissionControl(info, destdir)
+        if err != nil {
+                return err
+        }
+        defer chmodfunc(&err)
+
+        var contents []os.FileInfo
+        if opt.FS != nil {
+                entries, err := fs.ReadDir(opt.FS, srcdir)
+                if err != nil {
+                        return err
+                }
+                for _, e := range entries {
+                        info, err := e.Info()
+                        if err != nil {
+                                return err
+                        }
+                        contents = append(contents, info)
+                }
+        } else {
+                contents, err = ioutil.ReadDir(srcdir)
+        }
+
+        if err != nil {
+                if os.IsNotExist(err) {
+                        return nil
+                }
+                return
+        }
+
+        for _, content := range contents {
+                cs, cd := filepath.Join(srcdir, content.Name()), filepath.Join(destdir, content.Name())
+
+                if err = copyNextOrSkip(cs, cd, content, opt); err != nil {
+                        // If any error, exit immediately
+                        return
+                }
+        }
+
+        if opt.PreserveTimes {
+                if err := preserveTimes(info, destdir); err != nil {
+                        return err
+                }
+        }
+
+        if opt.PreserveOwner {
+                if err := preserveOwner(srcdir, destdir, info); err != nil {
+                        return err
+                }
+        }
+
+        return
+}
+
+func onDirExists(opt Options, srcdir, destdir string) (bool, error) {
+        _, err := os.Stat(destdir)
+        if err == nil && opt.OnDirExists != nil && destdir != opt.intent.dest {
+                switch opt.OnDirExists(srcdir, destdir) {
+                case Replace:
+                        if err := os.RemoveAll(destdir); err != nil {
+                                return false, err
+                        }
+                case Untouchable:
+                        return true, nil
+                } // case "Merge" is default behaviour. Go through.
+        } else if err != nil && !os.IsNotExist(err) {
+                return true, err // Unwelcome error type...!
+        }
+        return false, nil
+}
+
+func onsymlink(src, dest string, opt Options) error {
+        switch opt.OnSymlink(src) {
+        case Shallow:
+                if err := lcopy(src, dest); err != nil {
+                        return err
+                }
+                if opt.PreserveTimes {
+                        return preserveLtimes(src, dest)
+                }
+                return nil
+        case Deep:
+                orig, err := os.Readlink(src)
+                if err != nil {
+                        return err
+                }
+                info, err := os.Lstat(orig)
+                if err != nil {
+                        return err
+                }
+                return copyNextOrSkip(orig, dest, info, opt)
+        case Skip:
+                fallthrough
+        default:
+                return nil // do nothing
+        }
+}
+
+// lcopy is for a symlink,
+// with just creating a new symlink by replicating src symlink.
+func lcopy(src, dest string) error {
+        src, err := os.Readlink(src)
+        if err != nil {
+                if os.IsNotExist(err) {
+                        return nil
+                }
+                return err
+        }
+        return os.Symlink(src, dest)
+}
+
+// fclose ANYHOW closes file,
+// with asiging error raised during Close,
+// BUT respecting the error already reported.
+func fclose(f io.Closer, reported *error) {
+        if err := f.Close(); *reported == nil {
+                *reported = err
+        }
+}
+
+// onError lets caller to handle errors
+// occured when copying a file.
+func onError(src, dest string, err error, opt Options) error {
+        if opt.OnError == nil {
+                return err
+        }
+
+        return opt.OnError(src, dest, err)
+}