This repository has been archived by the owner on Aug 22, 2022. It is now read-only.
/
wrap.go
145 lines (130 loc) · 3.66 KB
/
wrap.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
package pkging
import (
"fmt"
"os"
"path/filepath"
"github.com/gobuffalo/here"
)
func Wrap(parent, with Pkger) Pkger {
return withPkger{
base: with,
parent: parent,
}
}
type withPkger struct {
base Pkger
parent Pkger
}
func (w withPkger) String() string {
if w.parent == nil {
return fmt.Sprintf("%T", w.base)
}
return fmt.Sprintf("%T > %T", w.base, w.parent)
}
func (w withPkger) Parse(p string) (here.Path, error) {
pt, err := w.base.Parse(p)
if err != nil {
if w.parent != nil {
return w.parent.Parse(p)
}
return pt, err
}
return pt, nil
}
func (w withPkger) Current() (here.Info, error) {
pt, err := w.base.Current()
if err != nil {
if w.parent != nil {
return w.parent.Current()
}
return pt, err
}
return pt, nil
}
func (w withPkger) Info(p string) (here.Info, error) {
pt, err := w.base.Info(p)
if err != nil {
if w.parent != nil {
return w.parent.Info(p)
}
return pt, err
}
return pt, nil
}
// Create creates the named file with mode 0666 (before umask) - It's actually 0644, truncating it if it already exists. If successful, methods on the returned File can be used for I/O; the associated file descriptor has mode O_RDWR.
func (w withPkger) Create(p string) (File, error) {
pt, err := w.base.Create(p)
if err != nil {
if w.parent != nil {
return w.parent.Create(p)
}
return pt, err
}
return pt, nil
}
// MkdirAll creates a directory named path, along with any necessary parents, and returns nil, or else returns an error. The permission bits perm (before umask) are used for all directories that MkdirAll creates. If path is already a directory, MkdirAll does nothing and returns nil.
func (w withPkger) MkdirAll(p string, perm os.FileMode) error {
err := w.base.MkdirAll(p, perm)
if err != nil {
return err
}
if w.parent != nil {
return w.parent.MkdirAll(p, perm)
}
return nil
}
// Open opens the named file for reading. If successful, methods on the returned file can be used for reading; the associated file descriptor has mode O_RDONLY.
func (w withPkger) Open(p string) (File, error) {
pt, err := w.base.Open(p)
if err != nil {
if w.parent != nil {
return w.parent.Open(p)
}
return pt, err
}
return pt, nil
}
// Stat returns a FileInfo describing the named file.
func (w withPkger) Stat(p string) (os.FileInfo, error) {
pt, err := w.base.Stat(p)
if err != nil {
if w.parent != nil {
return w.parent.Stat(p)
}
return pt, err
}
return pt, nil
}
// Walk walks the file tree rooted at root, calling walkFn for each file or directory in the tree, including root. All errors that arise visiting files and directories are filtered by walkFn. The files are walked in lexical order, which makes the output deterministic but means that for very large directories Walk can be inefficient. Walk does not follow symbolic links. - That is from the standard library. I know. Their grammar teachers can not be happy with them right now.
func (w withPkger) Walk(p string, wf filepath.WalkFunc) error {
err := w.base.Walk(p, wf)
if err != nil {
return err
}
if w.parent != nil {
return w.parent.Walk(p, wf)
}
return nil
}
// Remove removes the named file or (empty) directory.
func (w withPkger) Remove(p string) error {
err := w.base.Remove(p)
if err != nil {
return err
}
if w.parent != nil {
return w.parent.Remove(p)
}
return nil
}
// RemoveAll removes path and any children it contains. It removes everything it can but returns the first error it encounters. If the path does not exist, RemoveAll returns nil (no error).
func (w withPkger) RemoveAll(p string) error {
err := w.base.RemoveAll(p)
if err != nil {
return err
}
if w.parent != nil {
return w.parent.RemoveAll(p)
}
return nil
}