Skip to content

Commit fa311bd

Browse files
jackHedayajackHedaya
committed
works with refactor
1 parent 3eca5ce commit fa311bd

19 files changed

+2033
-576
lines changed

‎.gitignore

+12-1
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,13 @@
1+
# Ignore all
2+
*
3+
4+
# Unignore all with extensions
5+
!*.*
6+
7+
# Unignore all dirs
8+
!*/
9+
110
.DS_Store
2-
.vscode
11+
.vscode
12+
main
13+
grrcmd

‎clean/clean.go

+39
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
package clean
2+
3+
import (
4+
"os"
5+
"path/filepath"
6+
7+
"github.com/jackHedaya/grr/grr"
8+
"github.com/jackHedaya/grr/utils"
9+
)
10+
11+
// Deletes all grr.gen.go files in the directory.
12+
func CleanEntry(directory string) error {
13+
dir, err := utils.ResolveAbsoluteDir(directory)
14+
15+
if err != nil {
16+
return grr.Errorf("FailedToResolveDir: Failed to resolve directory").AddError(err)
17+
}
18+
19+
err = filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
20+
if err != nil {
21+
return grr.Errorf("FailedToWalk: Failed to walk %s", path).AddError(err)
22+
}
23+
24+
if filepath.Ext(path) == ".gen.go" {
25+
err := os.Remove(path)
26+
if err != nil {
27+
return grr.Errorf("FailedToDelete: Failed to delete %s", path).AddError(err)
28+
}
29+
}
30+
31+
return nil
32+
})
33+
34+
if err != nil {
35+
return grr.Errorf("FailedToClean: Failed to clean directory").AddError(err)
36+
}
37+
38+
return nil
39+
}

‎clean/grr.gen.go

+285
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,285 @@
1+
package clean
2+
3+
import (
4+
"fmt"
5+
6+
"github.com/jackHedaya/grr/grr"
7+
)
8+
9+
// #############################################################################
10+
// # ErrFailedToClean
11+
// #############################################################################
12+
13+
type ErrFailedToClean struct {
14+
err error
15+
op string
16+
traits map[grr.Trait]string
17+
}
18+
19+
var _ grr.Error = &ErrFailedToClean{}
20+
21+
func NewErrFailedToClean() grr.Error {
22+
return &ErrFailedToClean{}
23+
}
24+
25+
func (e *ErrFailedToClean) Error() string {
26+
return fmt.Sprintf("Failed to clean directory")
27+
}
28+
29+
func (e *ErrFailedToClean) Unwrap() error {
30+
return e.err
31+
}
32+
33+
func (e *ErrFailedToClean) UnwrapAll() error {
34+
return grr.UnwrapAll(e)
35+
}
36+
37+
func (e *ErrFailedToClean) AsGrr(err grr.Error) (grr.Error, bool) {
38+
return grr.AsGrr(e, err)
39+
}
40+
41+
func (e *ErrFailedToClean) AddTrait(trait grr.Trait, value string) grr.Error {
42+
e.traits[trait] = value
43+
return e
44+
}
45+
46+
func (e *ErrFailedToClean) GetTrait(key grr.Trait) (string, bool) {
47+
trait, ok := e.traits[key]
48+
return trait, ok
49+
}
50+
51+
func (e *ErrFailedToClean) GetTraits() map[grr.Trait]string {
52+
traits := make(map[grr.Trait]string)
53+
for k, v := range e.traits {
54+
traits[k] = v
55+
}
56+
return traits
57+
}
58+
59+
func (e *ErrFailedToClean) AddOp(op string) grr.Error {
60+
e.op = op
61+
return e
62+
}
63+
64+
func (e *ErrFailedToClean) GetOp() string {
65+
return e.op
66+
}
67+
68+
func (e *ErrFailedToClean) AddError(err error) grr.Error {
69+
e.err = err
70+
return e
71+
}
72+
73+
func (e *ErrFailedToClean) Trace() {
74+
grr.Trace(e)
75+
}
76+
77+
// #############################################################################
78+
// # ErrFailedToDelete
79+
// #############################################################################
80+
81+
type ErrFailedToDelete struct {
82+
err error
83+
op string
84+
traits map[grr.Trait]string
85+
path string
86+
}
87+
88+
var _ grr.Error = &ErrFailedToDelete{}
89+
90+
func NewErrFailedToDelete(path string) grr.Error {
91+
return &ErrFailedToDelete{
92+
path: path,
93+
}
94+
}
95+
96+
func (e *ErrFailedToDelete) Error() string {
97+
return fmt.Sprintf("Failed to delete %s", e.path)
98+
}
99+
100+
func (e *ErrFailedToDelete) Unwrap() error {
101+
return e.err
102+
}
103+
104+
func (e *ErrFailedToDelete) UnwrapAll() error {
105+
return grr.UnwrapAll(e)
106+
}
107+
108+
func (e *ErrFailedToDelete) AsGrr(err grr.Error) (grr.Error, bool) {
109+
return grr.AsGrr(e, err)
110+
}
111+
112+
func (e *ErrFailedToDelete) AddTrait(trait grr.Trait, value string) grr.Error {
113+
e.traits[trait] = value
114+
return e
115+
}
116+
117+
func (e *ErrFailedToDelete) GetTrait(key grr.Trait) (string, bool) {
118+
trait, ok := e.traits[key]
119+
return trait, ok
120+
}
121+
122+
func (e *ErrFailedToDelete) GetTraits() map[grr.Trait]string {
123+
traits := make(map[grr.Trait]string)
124+
for k, v := range e.traits {
125+
traits[k] = v
126+
}
127+
return traits
128+
}
129+
130+
func (e *ErrFailedToDelete) AddOp(op string) grr.Error {
131+
e.op = op
132+
return e
133+
}
134+
135+
func (e *ErrFailedToDelete) GetOp() string {
136+
return e.op
137+
}
138+
139+
func (e *ErrFailedToDelete) AddError(err error) grr.Error {
140+
e.err = err
141+
return e
142+
}
143+
144+
func (e *ErrFailedToDelete) Trace() {
145+
grr.Trace(e)
146+
}
147+
148+
// #############################################################################
149+
// # ErrFailedToResolveDir
150+
// #############################################################################
151+
152+
type ErrFailedToResolveDir struct {
153+
err error
154+
op string
155+
traits map[grr.Trait]string
156+
}
157+
158+
var _ grr.Error = &ErrFailedToResolveDir{}
159+
160+
func NewErrFailedToResolveDir() grr.Error {
161+
return &ErrFailedToResolveDir{}
162+
}
163+
164+
func (e *ErrFailedToResolveDir) Error() string {
165+
return fmt.Sprintf("Failed to resolve directory")
166+
}
167+
168+
func (e *ErrFailedToResolveDir) Unwrap() error {
169+
return e.err
170+
}
171+
172+
func (e *ErrFailedToResolveDir) UnwrapAll() error {
173+
return grr.UnwrapAll(e)
174+
}
175+
176+
func (e *ErrFailedToResolveDir) AsGrr(err grr.Error) (grr.Error, bool) {
177+
return grr.AsGrr(e, err)
178+
}
179+
180+
func (e *ErrFailedToResolveDir) AddTrait(trait grr.Trait, value string) grr.Error {
181+
e.traits[trait] = value
182+
return e
183+
}
184+
185+
func (e *ErrFailedToResolveDir) GetTrait(key grr.Trait) (string, bool) {
186+
trait, ok := e.traits[key]
187+
return trait, ok
188+
}
189+
190+
func (e *ErrFailedToResolveDir) GetTraits() map[grr.Trait]string {
191+
traits := make(map[grr.Trait]string)
192+
for k, v := range e.traits {
193+
traits[k] = v
194+
}
195+
return traits
196+
}
197+
198+
func (e *ErrFailedToResolveDir) AddOp(op string) grr.Error {
199+
e.op = op
200+
return e
201+
}
202+
203+
func (e *ErrFailedToResolveDir) GetOp() string {
204+
return e.op
205+
}
206+
207+
func (e *ErrFailedToResolveDir) AddError(err error) grr.Error {
208+
e.err = err
209+
return e
210+
}
211+
212+
func (e *ErrFailedToResolveDir) Trace() {
213+
grr.Trace(e)
214+
}
215+
216+
// #############################################################################
217+
// # ErrFailedToWalk
218+
// #############################################################################
219+
220+
type ErrFailedToWalk struct {
221+
err error
222+
op string
223+
traits map[grr.Trait]string
224+
path string
225+
}
226+
227+
var _ grr.Error = &ErrFailedToWalk{}
228+
229+
func NewErrFailedToWalk(path string) grr.Error {
230+
return &ErrFailedToWalk{
231+
path: path,
232+
}
233+
}
234+
235+
func (e *ErrFailedToWalk) Error() string {
236+
return fmt.Sprintf("Failed to walk %s", e.path)
237+
}
238+
239+
func (e *ErrFailedToWalk) Unwrap() error {
240+
return e.err
241+
}
242+
243+
func (e *ErrFailedToWalk) UnwrapAll() error {
244+
return grr.UnwrapAll(e)
245+
}
246+
247+
func (e *ErrFailedToWalk) AsGrr(err grr.Error) (grr.Error, bool) {
248+
return grr.AsGrr(e, err)
249+
}
250+
251+
func (e *ErrFailedToWalk) AddTrait(trait grr.Trait, value string) grr.Error {
252+
e.traits[trait] = value
253+
return e
254+
}
255+
256+
func (e *ErrFailedToWalk) GetTrait(key grr.Trait) (string, bool) {
257+
trait, ok := e.traits[key]
258+
return trait, ok
259+
}
260+
261+
func (e *ErrFailedToWalk) GetTraits() map[grr.Trait]string {
262+
traits := make(map[grr.Trait]string)
263+
for k, v := range e.traits {
264+
traits[k] = v
265+
}
266+
return traits
267+
}
268+
269+
func (e *ErrFailedToWalk) AddOp(op string) grr.Error {
270+
e.op = op
271+
return e
272+
}
273+
274+
func (e *ErrFailedToWalk) GetOp() string {
275+
return e.op
276+
}
277+
278+
func (e *ErrFailedToWalk) AddError(err error) grr.Error {
279+
e.err = err
280+
return e
281+
}
282+
283+
func (e *ErrFailedToWalk) Trace() {
284+
grr.Trace(e)
285+
}

0 commit comments

Comments
 (0)