Commit e0e2368a6595d66ce4fc31d3c2d1e8575293885e - golang-github-gobuffalo-packr

+1

-1

SHOULDERS.md less more

10	10
11	11	* [github.com/gobuffalo/packr/v2](https://godoc.org/github.com/gobuffalo/packr/v2)
12	12
13		* [github.com/pkg/errors](https://godoc.org/github.com/pkg/errors)
	13	* [errors](https://godoc.org/errors)
14	14
15	15	* [github.com/spf13/cobra](https://godoc.org/github.com/spf13/cobra)
16	16

+2

-1

box.go less more

10	10	"runtime"
11	11	"strings"
12	12
	13	"github.com/pkg/errors"
	14
13	15	"github.com/gobuffalo/packd"
14		"github.com/pkg/errors"
15	16	)
16	17
17	18	var (

+6

-6

builder/box.go less more

20	20	func (b *box) Walk(root string) error {
21	21	root, err := filepath.EvalSymlinks(root)
22	22	if err != nil {
23		return errors.WithStack(err)
	23	return err
24	24	}
25	25	if _, err := os.Stat(root); err != nil {
26	26	// return nil

40	40
41	41	bb, err := ioutil.ReadFile(path)
42	42	if err != nil {
43		return errors.WithStack(err)
	43	return err
44	44	}
45	45	if b.compress {
46	46	bb, err = compressFile(bb)
47	47	if err != nil {
48		return errors.WithStack(err)
	48	return err
49	49	}
50	50	}
51	51	bb, err = json.Marshal(bb)
52	52	if err != nil {
53		return errors.WithStack(err)
	53	return err
54	54	}
55	55	f.Contents = strings.Replace(string(bb), "\"", "\\\"", -1)
56	56

65	65	writer := gzip.NewWriter(&buf)
66	66	_, err := writer.Write(bb)
67	67	if err != nil {
68		return bb, errors.WithStack(err)
	68	return bb, err
69	69	}
70	70	err = writer.Close()
71	71	if err != nil {
72		return bb, errors.WithStack(err)
	72	return bb, err
73	73	}
74	74	return buf.Bytes(), nil
75	75	}

+8

-9

builder/builder.go less more

8	8	"sync"
9	9	"text/template"
10	10
11		"github.com/pkg/errors"
12	11	"golang.org/x/sync/errgroup"
13	12	)
14	13

38	37	wg := &errgroup.Group{}
39	38	root, err := filepath.EvalSymlinks(b.RootPath)
40	39	if err != nil {
41		return errors.WithStack(err)
	40	return err
42	41	}
43	42	err = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
44	43	if info == nil {

66	65	return nil
67	66	})
68	67	if err != nil {
69		return errors.WithStack(err)
	68	return err
70	69	}
71	70	if err := wg.Wait(); err != nil {
72		return errors.WithStack(err)
	71	return err
73	72	}
74	73	return b.dump()
75	74	}

80	79	f, err := os.Create(name)
81	80	defer f.Close()
82	81	if err != nil {
83		return errors.WithStack(err)
	82	return err
84	83	}
85	84	t, err := template.New("").Parse(tmpl)
86	85
87	86	if err != nil {
88		return errors.WithStack(err)
	87	return err
89	88	}
90	89	err = t.Execute(f, p)
91	90	if err != nil {
92		return errors.WithStack(err)
	91	return err
93	92	}
94	93	}
95	94	return nil

103	102
104	103	v := newVisitor(path)
105	104	if err := v.Run(); err != nil {
106		return errors.WithStack(err)
	105	return err
107	106	}
108	107
109	108	pk := pkg{

132	131	DebugLog("building box %s\n", bx.Name)
133	132	p := filepath.Join(pk.Dir, bx.Name)
134	133	if err := bx.Walk(p); err != nil {
135		return errors.WithStack(err)
	134	return err
136	135	}
137	136	if len(bx.Files) > 0 {
138	137	pk.Boxes = append(pk.Boxes, *bx)

+3

-4

builder/clean.go less more

5	5
6	6	"github.com/gobuffalo/packr/v2/jam/parser"
7	7	"github.com/gobuffalo/packr/v2/jam/store"
8		"github.com/pkg/errors"
9	8	)
10	9
11	10	// Clean up an *-packr.go files

19	18	IgnoreImports: true,
20	19	})
21	20	if err != nil {
22		return errors.WithStack(err)
	21	return err
23	22	}
24	23
25	24	boxes, err := p.Run()
26	25	if err != nil {
27		return errors.WithStack(err)
	26	return err
28	27	}
29	28
30	29	d := store.NewDisk("", "")
31	30	for _, box := range boxes {
32	31	if err := d.Clean(box); err != nil {
33		return errors.WithStack(err)
	32	return err
34	33	}
35	34	}
36	35	return nil

+12

-13

builder/visitor.go less more

0	0	package builder
1	1
2	2	import (
	3	"errors"
3	4	"go/ast"
4	5	"go/parser"
5	6	"go/token"
6	7	"io/ioutil"
7	8	"sort"
8	9	"strings"
9
10		"github.com/pkg/errors"
11	10	)
12	11
13	12	type visitor struct {

28	27	func (v *visitor) Run() error {
29	28	b, err := ioutil.ReadFile(v.Path)
30	29	if err != nil {
31		return errors.WithStack(err)
	30	return err
32	31	}
33	32
34	33	fset := token.NewFileSet()
35	34	file, err := parser.ParseFile(fset, v.Path, string(b), parser.ParseComments)
36	35	if err != nil {
37		return errors.WithStack(err)
	36	return err
38	37	}
39	38
40	39	v.Package = file.Name.Name

80	79	case *ast.GenDecl:
81	80	for _, n := range t.Specs {
82	81	if err := v.eval(n); err != nil {
83		return errors.WithStack(err)
	82	return err
84	83	}
85	84	}
86	85	case *ast.FuncDecl:

89	88	}
90	89	for _, b := range t.Body.List {
91	90	if err := v.evalStmt(b); err != nil {
92		return errors.WithStack(err)
	91	return err
93	92	}
94	93	}
95	94	return nil
96	95	case *ast.ValueSpec:
97	96	for _, e := range t.Values {
98	97	if err := v.evalExpr(e); err != nil {
99		return errors.WithStack(err)
	98	return err
100	99	}
101	100	}
102	101	}

110	109	case *ast.AssignStmt:
111	110	for _, e := range t.Rhs {
112	111	if err := v.evalArgs(e); err != nil {
113		return errors.WithStack(err)
	112	return err
114	113	}
115	114	}
116	115	}

131	130	}
132	131
133	132	if err := v.evalArgs(at); err != nil {
134		return errors.WithStack(err)
	133	return err
135	134	}
136	135	case *ast.CompositeLit:
137	136	for _, e := range at.Elts {
138	137	if err := v.evalExpr(e); err != nil {
139		return errors.WithStack(err)
	138	return err
140	139	}
141	140	}
142	141	}

155	154	case *ast.CompositeLit:
156	155	for _, e := range at.Elts {
157	156	if err := v.evalExpr(e); err != nil {
158		return errors.WithStack(err)
	157	return err
159	158	}
160	159	}
161	160	// case *ast.BasicLit:

168	167	switch st := at.Fun.(type) {
169	168	case *ast.SelectorExpr:
170	169	if err := v.evalSelector(at, st); err != nil {
171		return errors.WithStack(err)
	170	return err
172	171	}
173	172	case *ast.Ident:
174	173	return v.evalIdent(st)
175	174	}
176	175	for _, a := range at.Args {
177	176	if err := v.evalArgs(a); err != nil {
178		return errors.WithStack(err)
	177	return err
179	178	}
180	179	}
181	180	}

+2

-3

go.mod less more

2	2	require (
3	3	github.com/gobuffalo/envy v1.6.15
4	4	github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0
5		github.com/gobuffalo/packr/v2 v2.0.7
6		github.com/inconshreveable/mousetrap v1.0.0 // indirect
	5	github.com/gobuffalo/packr/v2 v2.0.9
7	6	github.com/pkg/errors v0.8.1
	7	github.com/rogpeppe/go-internal v1.3.0 // indirect
8	8	github.com/spf13/cobra v0.0.3
9		github.com/spf13/pflag v1.0.3 // indirect
10	9	github.com/stretchr/testify v1.3.0
11	10	golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6
12	11	)

+8

-16

go.sum less more

0	0	github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
1	1	github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
2	2	github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
3		github.com/gobuffalo/attrs v0.0.0-20190224210810-a9411de4debd/go.mod h1:4duuawTqi2wkkpB4ePgWMaai6/Kc6WEz83bhFwpHzj0=
4		github.com/gobuffalo/depgen v0.0.0-20190315122043-8442b3fa16db/go.mod h1:3STtPUQYuzV0gBVOY3vy6CfMm/ljR4pABfrTeHNLHUY=
5	3	github.com/gobuffalo/envy v1.6.15 h1:OsV5vOpHYUpP7ZLS6sem1y40/lNX1BZj+ynMiRi21lQ=
6	4	github.com/gobuffalo/envy v1.6.15/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
7		github.com/gobuffalo/flect v0.1.0/go.mod h1:d2ehjJqGOH/Kjqcoz+F7jHTBbmDb38yXA598Hb50EGs=
8		github.com/gobuffalo/flect v0.1.1/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI=
9		github.com/gobuffalo/genny v0.0.0-20190315121735-8b38fb089e88/go.mod h1:rWs4Z12d1Zbf19rlsn0nurr75KqhYp52EAGGxTbBhNk=
10		github.com/gobuffalo/genny v0.0.0-20190315124720-e16e52a93c79 h1:5AXgPPMHJYsMAoBnp+QHqIRl5JJ8Sq9opm50O/BrU9E=
11		github.com/gobuffalo/genny v0.0.0-20190315124720-e16e52a93c79/go.mod h1:nKeefjbhYowo36ys9nG9VUvD9FRIS0p3BC2JFfcOucM=
12		github.com/gobuffalo/gitgen v0.0.0-20190315122116-cc086187d211/go.mod h1:vEHJk/E9DmhejeLeNt7UVvlSGv3ziL+djtTr3yyzcOw=
	5	github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9 h1:lGw35M+JVpedVCf08hSiBHKpp3FPTKqt6qRdXMSVAq0=
	6	github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9/go.mod h1:rWs4Z12d1Zbf19rlsn0nurr75KqhYp52EAGGxTbBhNk=
13	7	github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5 h1:f3Fpd5AqsFuTHUEhUeEMIFJkX8FpVnzdW+GpYxIyXkA=
14	8	github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5/go.mod h1:V9QVDIxsgKNZs6L2IYiGR8datgMhB577vzTDqypH360=
15	9	github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2 h1:8thhT+kUJMTMy3HlX4+y9Da+BNJck+p109tqqKp7WDs=
16	10	github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2/go.mod h1:QdxcLw541hSGtBnhUc4gaNIXRjiDppFGaDqzbrBd3v8=
17	11	github.com/gobuffalo/mapi v1.0.1 h1:JRuTiZzDEZhBHkFiHTxJkYRT6CbYuL0K/rn+1byJoEA=
18	12	github.com/gobuffalo/mapi v1.0.1/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc=
19		github.com/gobuffalo/packd v0.0.0-20190315122247-83d601d65093/go.mod h1:LpEu7OkoplvlhztyAEePkS6JwcGgANdgGL5pB4Knxaw=
20	13	github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0 h1:P6naWPiHm/7R3eYx/ub3VhaW9G+1xAMJ6vzACePaGPI=
21	14	github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4=
22		github.com/gobuffalo/packr/v2 v2.0.6/go.mod h1:/TYKOjadT7P9jRWZtj4BRTgeXy2tIYntifGkD+aM2KY=
23		github.com/gobuffalo/packr/v2 v2.0.7 h1:8Gah4OwoqvIZgsUHa07qyXNl/LtZRa4gPjtXux4fVlY=
24		github.com/gobuffalo/packr/v2 v2.0.7/go.mod h1:1SBFAIr3YnxYdJRyrceR7zhOrhV/YhHzOjDwA9LLZ5Y=
	15	github.com/gobuffalo/packr/v2 v2.0.9 h1:g8P4tjthK0vAu2aopXlNNxCNsnGsWd+dbZLdc3fHSYk=
	16	github.com/gobuffalo/packr/v2 v2.0.9/go.mod h1:emmyGweYTm6Kdper+iywB6YK5YzuKchGtJQZ0Odn4pQ=
25	17	github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754 h1:tpom+2CJmpzAWj5/VEHync2rJGi+epHNIeRSWjzGA+4=
26	18	github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754/go.mod h1:HhnNqWY95UYwwW3uSASeV7vtgYkT2t16hJgV3AEPUpw=
27	19	github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=

45	37	github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
46	38	github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
47	39	github.com/rogpeppe/go-internal v1.1.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
48		github.com/rogpeppe/go-internal v1.2.2 h1:J7U/N7eRtzjhs26d6GqMh2HBuXP8/Z64Densiiieafo=
49	40	github.com/rogpeppe/go-internal v1.2.2/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
	41	github.com/rogpeppe/go-internal v1.3.0 h1:RR9dF3JtopPvtkroDZuVD7qquD0bnHlKSqaQhgwt8yk=
	42	github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
50	43	github.com/sirupsen/logrus v1.4.0 h1:yKenngtzGh+cUSSh6GWbxW2abRqhYUSR/t/6+2QqNvE=
51	44	github.com/sirupsen/logrus v1.4.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
52	45	github.com/spf13/cobra v0.0.3 h1:ZlrZ4XsMRm04Fr5pSFxBgfND2EBVa1nLpiy1stUsX/8=

68	61	golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU=
69	62	golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
70	63	golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
71		golang.org/x/tools v0.0.0-20190315044204-8b67d361bba2/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
72		golang.org/x/tools v0.0.0-20190318200714-bb1270c20edf h1:OVQ7iQXiQQT4WuYg+7S/bOVVlASHvL1Chsc15Qtkogo=
73		golang.org/x/tools v0.0.0-20190318200714-bb1270c20edf/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
	64	golang.org/x/tools v0.0.0-20190329151228-23e29df326fe h1:tilCFoChsm7TcjFUH5YtBjno7wDleRO+6jICJg0WDS0=
	65	golang.org/x/tools v0.0.0-20190329151228-23e29df326fe/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
74	66	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
75	67	gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=

+1

-2

packr/cmd/build.go less more

6	6
7	7	"github.com/gobuffalo/packr"
8	8	"github.com/gobuffalo/packr/builder"
9		"github.com/pkg/errors"
10	9	"github.com/spf13/cobra"
11	10	)
12	11

20	19	b := builder.New(context.Background(), input)
21	20	err := b.Run()
22	21	if err != nil {
23		return errors.WithStack(err)
	22	return err
24	23	}
25	24
26	25	cargs := []string{"build"}

+2

-3

packr/cmd/install.go less more

8	8
9	9	"github.com/gobuffalo/packr"
10	10	"github.com/gobuffalo/packr/builder"
11		"github.com/pkg/errors"
12	11	"github.com/spf13/cobra"
13	12	)
14	13

23	22	if !strings.HasPrefix(input, ".") {
24	23	input = filepath.Join(packr.GoPath(), "src", input)
25	24	if _, err := os.Stat(input); err != nil {
26		return errors.WithStack(err)
	25	return err
27	26	}
28	27	}
29	28	}

31	30	b := builder.New(context.Background(), input)
32	31	err := b.Run()
33	32	if err != nil {
34		return errors.WithStack(err)
	33	return err
35	34	}
36	35
37	36	cargs := []string{"install"}

+1

-1

v2/SHOULDERS.md less more

24	24
25	25	* [github.com/markbates/safe](https://godoc.org/github.com/markbates/safe)
26	26
27		* [github.com/pkg/errors](https://godoc.org/github.com/pkg/errors)
	27	* [errors](https://godoc.org/errors)
28	28
29	29	* [github.com/rogpeppe/go-internal](https://godoc.org/github.com/rogpeppe/go-internal)
30	30

+4

-4

v2/box.go less more

16	16	"github.com/gobuffalo/packr/v2/file/resolver"
17	17	"github.com/gobuffalo/packr/v2/plog"
18	18	"github.com/markbates/oncer"
19		"github.com/pkg/errors"
	19	"errors"
20	20	)
21	21
22	22	var _ packd.Box = &Box{}

90	90	m := map[string]file.File{}
91	91	f, err := file.NewFile(path, t)
92	92	if err != nil {
93		return errors.WithStack(err)
	93	return err
94	94	}
95	95	m[resolver.Key(path)] = f
96	96	res := resolver.NewInMemory(m)

223	223	}
224	224	b, err := ioutil.ReadAll(f)
225	225	if err != nil {
226		return f, errors.WithStack(err)
	226	return f, err
227	227	}
228	228	f, err = file.NewFile(key, b)
229	229	if err != nil {
230		return f, errors.WithStack(err)
	230	return f, err
231	231	}
232	232	}
233	233	plog.Debug(r, "Resolve", "box", b.Name, "key", key, "file", f.Name())

+2

-3

v2/file/resolver/disk.go less more

9	9	"github.com/gobuffalo/packr/v2/file"
10	10	"github.com/gobuffalo/packr/v2/plog"
11	11	"github.com/karrick/godirwalk"
12		"github.com/pkg/errors"
13	12	)
14	13
15	14	var _ Resolver = &Disk{}

60	59	name := strings.TrimPrefix(path, root+string(filepath.Separator))
61	60	b, err := ioutil.ReadFile(path)
62	61	if err != nil {
63		return errors.WithStack(err)
	62	return err
64	63	}
65	64	m[name], err = file.NewFile(name, b)
66	65	if err != nil {
67		return errors.WithStack(err)
	66	return err
68	67	}
69	68	moot.Unlock()
70	69	return nil

+4

-5

v2/file/resolver/hex_gzip.go less more

12	12	"github.com/gobuffalo/packr/v2/plog"
13	13
14	14	"github.com/gobuffalo/packr/v2/file"
15		"github.com/pkg/errors"
16	15	)
17	16
18	17	var _ Resolver = &HexGzip{}

60	59
61	60	unpacked, err := UnHexGzipString(packed)
62	61	if err != nil {
63		return nil, errors.WithStack(err)
	62	return nil, err
64	63	}
65	64
66	65	f, err := file.NewFile(OsPath(name), []byte(unpacked))
67	66	if err != nil {
68		return nil, errors.WithStack(err)
	67	return nil, err
69	68	}
70	69	hg.unpacked[name] = f.String()
71	70	return f, nil

100	99	dec := hex.NewDecoder(br)
101	100	zr, err := gzip.NewReader(dec)
102	101	if err != nil {
103		return "", errors.WithStack(err)
	102	return "", err
104	103	}
105	104	defer zr.Close()
106	105
107	106	b, err := ioutil.ReadAll(zr)
108	107	if err != nil {
109		return "", errors.WithStack(err)
	108	return "", err
110	109	}
111	110	return string(b), nil
112	111	}

+1

-2

v2/file/resolver/in_memory.go less more

5	5	"github.com/gobuffalo/packd"
6	6	"github.com/gobuffalo/packr/v2/file"
7	7	"github.com/gobuffalo/packr/v2/plog"
8		"github.com/pkg/errors"
9	8	)
10	9
11	10	var _ Resolver = &InMemory{}

30	29	plog.Debug(d, "Pack", "name", name)
31	30	b, err := ioutil.ReadAll(f)
32	31	if err != nil {
33		return errors.WithStack(err)
	32	return err
34	33	}
35	34	d.AddBytes(name, b)
36	35	return nil

+4

-7

v2/go.mod less more

1	1
2	2	require (
3	3	github.com/gobuffalo/envy v1.6.15
4		github.com/gobuffalo/genny v0.0.0-20190329153409-7be1b23270eb
	4	github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e
5	5	github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5
6	6	github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2
7	7	github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0
8	8	github.com/karrick/godirwalk v1.8.0
9		github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
10	9	github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2
11	10	github.com/markbates/safe v1.0.1
12	11	github.com/pkg/errors v0.8.1
13		github.com/rogpeppe/go-internal v1.2.2
14		github.com/sirupsen/logrus v1.4.0
	12	github.com/rogpeppe/go-internal v1.3.0
	13	github.com/sirupsen/logrus v1.4.1
15	14	github.com/spf13/cobra v0.0.3
16	15	github.com/stretchr/testify v1.3.0
17		golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c // indirect
18	16	golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6
19		golang.org/x/sys v0.0.0-20190329044733-9eb1bfa1ce65 // indirect
20		golang.org/x/tools v0.0.0-20190330163440-a68386b9fffe
	17	golang.org/x/tools v0.0.0-20190404132500-923d25813098
21	18	)

+8

-16

v2/go.sum less more

6	6	github.com/gobuffalo/envy v1.6.15/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
7	7	github.com/gobuffalo/flect v0.1.0/go.mod h1:d2ehjJqGOH/Kjqcoz+F7jHTBbmDb38yXA598Hb50EGs=
8	8	github.com/gobuffalo/flect v0.1.1/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI=
9		github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9 h1:lGw35M+JVpedVCf08hSiBHKpp3FPTKqt6qRdXMSVAq0=
10	9	github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9/go.mod h1:rWs4Z12d1Zbf19rlsn0nurr75KqhYp52EAGGxTbBhNk=
11		github.com/gobuffalo/genny v0.0.0-20190329153409-7be1b23270eb h1:IUtUgwYRIQOHgmCP8uAUjKQNJKUxICmptd1gMggAytA=
12		github.com/gobuffalo/genny v0.0.0-20190329153409-7be1b23270eb/go.mod h1:WGiyExKBGcMizwBYYmNL3LIyTRMP6wJQaD7MEYuM7Zk=
	10	github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e h1:JbHBQOMhE0wmpSuejnSkdnL2rULqQTwEGgVe85o7+No=
	11	github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e/go.mod h1:80lIj3kVJWwOrXWWMRzzdhW3DsrdjILVil/SFKBzF28=
13	12	github.com/gobuffalo/gitgen v0.0.0-20190315122116-cc086187d211/go.mod h1:vEHJk/E9DmhejeLeNt7UVvlSGv3ziL+djtTr3yyzcOw=
14	13	github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5 h1:f3Fpd5AqsFuTHUEhUeEMIFJkX8FpVnzdW+GpYxIyXkA=
15	14	github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5/go.mod h1:V9QVDIxsgKNZs6L2IYiGR8datgMhB577vzTDqypH360=
16	15	github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2 h1:8thhT+kUJMTMy3HlX4+y9Da+BNJck+p109tqqKp7WDs=
17	16	github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2/go.mod h1:QdxcLw541hSGtBnhUc4gaNIXRjiDppFGaDqzbrBd3v8=
18		github.com/gobuffalo/mapi v1.0.1 h1:JRuTiZzDEZhBHkFiHTxJkYRT6CbYuL0K/rn+1byJoEA=
19	17	github.com/gobuffalo/mapi v1.0.1/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc=
20	18	github.com/gobuffalo/mapi v1.0.2 h1:fq9WcL1BYrm36SzK6+aAnZ8hcp+SrmnDyAxhNx8dvJk=
21	19	github.com/gobuffalo/mapi v1.0.2/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc=

32	30	github.com/karrick/godirwalk v1.8.0/go.mod h1:H5KPZjojv4lE+QYImBI8xVtrBRgYrIVsaRPx4tDPEn4=
33	31	github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
34	32	github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
35		github.com/konsorten/go-windows-terminal-sequences v1.0.2 h1:DB17ag19krx9CFsz4o3enTrPXyIXCl+2iCXH/aMAp9s=
36		github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
37	33	github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
38	34	github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
39	35	github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=

47	43	github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
48	44	github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
49	45	github.com/rogpeppe/go-internal v1.1.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
50		github.com/rogpeppe/go-internal v1.2.2 h1:J7U/N7eRtzjhs26d6GqMh2HBuXP8/Z64Densiiieafo=
51	46	github.com/rogpeppe/go-internal v1.2.2/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
52		github.com/sirupsen/logrus v1.4.0 h1:yKenngtzGh+cUSSh6GWbxW2abRqhYUSR/t/6+2QqNvE=
	47	github.com/rogpeppe/go-internal v1.3.0 h1:RR9dF3JtopPvtkroDZuVD7qquD0bnHlKSqaQhgwt8yk=
	48	github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
53	49	github.com/sirupsen/logrus v1.4.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
	50	github.com/sirupsen/logrus v1.4.1 h1:GL2rEmy6nsikmW0r8opw9JIRScdMF5hA8cOYLH7In1k=
	51	github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
54	52	github.com/spf13/cobra v0.0.3 h1:ZlrZ4XsMRm04Fr5pSFxBgfND2EBVa1nLpiy1stUsX/8=
55	53	github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
56	54	github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=

63	61	golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
64	62	golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
65	63	golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
66		golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c h1:Vj5n4GlwjmQteupaxJ9+0FNOmBrHfq7vN4btdGoDZgI=
67		golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
68		golang.org/x/net v0.0.0-20190311183353-d8887717615a h1:oWX7TPOiFAMXLq8o0ikBYfCJVlRHBcsciT5bXOrH628=
69	64	golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
70	65	golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6 h1:bjcUS9ztw9kFmmIxJInhon/0Is3p+EHBKNgquIzo1OI=
71	66	golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
72	67	golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
73	68	golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU=
74	69	golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
75		golang.org/x/sys v0.0.0-20190329044733-9eb1bfa1ce65 h1:hOY+O8MxdkPV10pNf7/XEHaySCiPKxixMKUshfHsGn0=
76		golang.org/x/sys v0.0.0-20190329044733-9eb1bfa1ce65/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
77	70	golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
78		golang.org/x/tools v0.0.0-20190329151228-23e29df326fe h1:tilCFoChsm7TcjFUH5YtBjno7wDleRO+6jICJg0WDS0=
79	71	golang.org/x/tools v0.0.0-20190329151228-23e29df326fe/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
80		golang.org/x/tools v0.0.0-20190330163440-a68386b9fffe h1:TSwzZtGyXzhKPLhVz/4DSkDWaEwA5tC5kFS0Y4QXaSE=
81		golang.org/x/tools v0.0.0-20190330163440-a68386b9fffe/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
	72	golang.org/x/tools v0.0.0-20190404132500-923d25813098 h1:MtqjsZmyGRgMmLUgxnmMJ6RYdvd2ib8ipiayHhqSxs4=
	73	golang.org/x/tools v0.0.0-20190404132500-923d25813098/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
82	74	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
83	75	gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=

+8

-9

v2/jam/pack.go less more

10	10	"github.com/gobuffalo/packr/v2/jam/parser"
11	11	"github.com/gobuffalo/packr/v2/jam/store"
12	12	"github.com/gobuffalo/packr/v2/plog"
13		"github.com/pkg/errors"
14	13	)
15	14
16	15	// PackOptions ...

25	24	func Pack(opts PackOptions) error {
26	25	pwd, err := os.Getwd()
27	26	if err != nil {
28		return errors.WithStack(err)
	27	return err
29	28	}
30	29
31	30	opts.Roots = append(opts.Roots, pwd)
32	31	if err := Clean(opts.Roots...); err != nil {
33		return errors.WithStack(err)
	32	return err
34	33	}
35	34
36	35	p, err := parser.NewFromRoots(opts.Roots, &parser.RootsOptions{
37	36	IgnoreImports: opts.IgnoreImports,
38	37	})
39	38	if err != nil {
40		return errors.WithStack(err)
	39	return err
41	40	}
42	41	boxes, err := p.Run()
43	42	if err != nil {
44		return errors.WithStack(err)
	43	return err
45	44	}
46	45
47	46	// reduce boxes - remove ones we don't want

66	65	continue
67	66	}
68	67	if err := st.Pack(b); err != nil {
69		return errors.WithStack(err)
	68	return err
70	69	}
71	70	}
72	71	if cl, ok := st.(io.Closer); ok {

79	78	func ShellPack(opts PackOptions, boxes parser.Boxes) error {
80	79	b, err := json.Marshal(boxes)
81	80	if err != nil {
82		return errors.WithStack(err)
	81	return err
83	82	}
84	83	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
85	84	defer cancel()

94	93	func Clean(args ...string) error {
95	94	pwd, err := os.Getwd()
96	95	if err != nil {
97		return errors.WithStack(err)
	96	return err
98	97	}
99	98	args = append(args, pwd)
100	99	for _, root := range args {
101	100	if err := store.Clean(root); err != nil {
102		return errors.WithStack(err)
	101	return err
103	102	}
104	103	}
105	104	return nil

+1

-1

v2/jam/parser/args.go less more

2	2	import (
3	3	"encoding/json"
4	4
5		"github.com/pkg/errors"
	5	"errors"
6	6	)
7	7
8	8	// FromArgs is useful when writing packr store-cmd binaries.

+1

-1

v2/jam/parser/finder.go less more

63	63	if err != nil {
64	64	if !strings.Contains(err.Error(), "cannot find package") {
65	65	if _, ok := errors.Cause(err).(*build.NoGoError); !ok {
66		err = errors.WithStack(err)
	66	err = err
67	67	return
68	68	}
69	69	}

+1

-2

v2/jam/parser/parser.go less more

5	5	"strings"
6	6
7	7	"github.com/gobuffalo/packr/v2/plog"
8		"github.com/pkg/errors"
9	8	)
10	9
11	10	// Parser to find boxes

22	21	v := NewVisitor(pros)
23	22	pbr, err := v.Run()
24	23	if err != nil {
25		return boxes, errors.WithStack(err)
	24	return boxes, err
26	25	}
27	26	for _, b := range pbr {
28	27	plog.Debug(p, "Run", "file", pros.Name(), "box", b.Name)

+2

-3

v2/jam/parser/roots.go less more

9	9
10	10	"github.com/gobuffalo/packr/v2/plog"
11	11	"github.com/karrick/godirwalk"
12		"github.com/pkg/errors"
13	12	)
14	13
15	14	type RootsOptions struct {

56	55	plog.Debug(p, "NewFromRoots", "walking", root)
57	56	err := godirwalk.Walk(root, wopts)
58	57	if err != nil {
59		return p, errors.WithStack(err)
	58	return p, err
60	59	}
61	60	}
62	61

80	79	plog.Debug(p, "NewFromRoots", "reading file", path)
81	80	b, err := ioutil.ReadFile(path)
82	81	if err != nil {
83		return nil, errors.WithStack(err)
	82	return nil, err
84	83	}
85	84	p.Prospects = append(p.Prospects, NewFile(path, bytes.NewReader(b)))
86	85	}

+11

-11

v2/jam/parser/visitor.go less more

75	75	case *ast.GenDecl:
76	76	for _, n := range t.Specs {
77	77	if err := v.eval(n); err != nil {
78		return errors.WithStack(err)
	78	return err
79	79	}
80	80	}
81	81	case *ast.FuncDecl:

84	84	}
85	85	for _, b := range t.Body.List {
86	86	if err := v.evalStmt(b); err != nil {
87		return errors.WithStack(err)
	87	return err
88	88	}
89	89	}
90	90	return nil
91	91	case *ast.ValueSpec:
92	92	for _, e := range t.Values {
93	93	if err := v.evalExpr(e); err != nil {
94		return errors.WithStack(err)
	94	return err
95	95	}
96	96	}
97	97	}

105	105	case *ast.AssignStmt:
106	106	for _, e := range t.Rhs {
107	107	if err := v.evalArgs(e); err != nil {
108		return errors.WithStack(err)
	108	return err
109	109	}
110	110	}
111	111	}

126	126	}
127	127
128	128	if err := v.evalArgs(at); err != nil {
129		return errors.WithStack(err)
	129	return err
130	130	}
131	131	case *ast.CompositeLit:
132	132	for _, e := range at.Elts {
133	133	if err := v.evalExpr(e); err != nil {
134		return errors.WithStack(err)
	134	return err
135	135	}
136	136	}
137	137	}

150	150	case *ast.CompositeLit:
151	151	for _, e := range at.Elts {
152	152	if err := v.evalExpr(e); err != nil {
153		return errors.WithStack(err)
	153	return err
154	154	}
155	155	}
156	156	case *ast.CallExpr:

160	160	switch st := at.Fun.(type) {
161	161	case *ast.SelectorExpr:
162	162	if err := v.evalSelector(at, st); err != nil {
163		return errors.WithStack(err)
	163	return err
164	164	}
165	165	case *ast.Ident:
166	166	return v.evalIdent(st)
167	167	}
168	168	for _, a := range at.Args {
169	169	if err := v.evalArgs(a); err != nil {
170		return errors.WithStack(err)
	170	return err
171	171	}
172	172	}
173	173	}

210	210
211	211	k1, err := zz(expr.Args[0])
212	212	if err != nil {
213		return errors.WithStack(err)
	213	return err
214	214	}
215	215	k2, err := zz(expr.Args[1])
216	216	if err != nil {
217		return errors.WithStack(err)
	217	return err
218	218	}
219	219	v.addBox(k1, k2)
220	220

+2

-2

v2/jam/store/_fixtures/disk-pack/go.sum less more

190	190	github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
191	191	github.com/onsi/gomega v1.4.2/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
192	192	github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
193		github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
194		github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
	193	errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
	194	errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
195	195	github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
196	196	github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
197	197	github.com/serenize/snaker v0.0.0-20171204205717-a683aaf2d516/go.mod h1:Yow6lPLSAXx2ifx470yD/nUe22Dv5vBvxK/UK9UUTVs=

+7

-8

v2/jam/store/clean.go less more

5	5	"strings"
6	6
7	7	"github.com/gobuffalo/packr/v2/jam/parser"
8		"github.com/pkg/errors"
9	8	)
10	9
11	10	func Clean(root string) error {

16	15
17	16	p, err := parser.NewFromRoots([]string{root}, &parser.RootsOptions{})
18	17	if err != nil {
19		return errors.WithStack(err)
	18	return err
20	19	}
21	20
22	21	boxes, err := p.Run()
23	22	if err != nil {
24		return errors.WithStack(err)
	23	return err
25	24	}
26	25
27	26	d := NewDisk("", "")
28	27	for _, box := range boxes {
29	28	if err := d.Clean(box); err != nil {
30		return errors.WithStack(err)
	29	return err
31	30	}
32	31	}
33	32	return nil

37	36	if len(root) == 0 {
38	37	pwd, err := os.Getwd()
39	38	if err != nil {
40		return errors.WithStack(err)
	39	return err
41	40	}
42	41	root = pwd
43	42	}

51	50
52	51	err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
53	52	if err != nil {
54		return errors.WithStack(err)
	53	return err
55	54	}
56	55	if info.IsDir() {
57	56	if filepath.Base(path) == "packrd" {

62	61	if strings.HasSuffix(path, "-packr.go") {
63	62	err := os.RemoveAll(path)
64	63	if err != nil {
65		return errors.WithStack(err)
	64	return err
66	65	}
67	66	}
68	67	return nil
69	68	})
70	69	if err != nil {
71		return errors.WithStack(err)
	70	return err
72	71	}
73	72
74	73	return nil

+14

-12

v2/jam/store/disk.go less more

24	24	"github.com/gobuffalo/packr/v2/plog"
25	25	"github.com/rogpeppe/go-internal/modfile"
26	26
	27	"github.com/pkg/errors"
	28
27	29	"github.com/gobuffalo/packr/v2/jam/parser"
28	30	"github.com/karrick/godirwalk"
29		"github.com/pkg/errors"
30	31	"golang.org/x/sync/errgroup"
31	32	)
32	33

87	88	var files []*parser.File
88	89	names, err := d.FileNames(box)
89	90	if err != nil {
90		return files, errors.WithStack(err)
	91	return files, err
91	92	}
92	93	for _, n := range names {
93	94	b, err := ioutil.ReadFile(n)
94	95	if err != nil {
95		return files, errors.WithStack(err)
	96	return files, err
96	97	}
97	98	f := parser.NewFile(n, bytes.NewReader(b))
98	99	files = append(files, f)

105	106	d.boxes[box.Name] = box
106	107	names, err := d.FileNames(box)
107	108	if err != nil {
108		return errors.WithStack(err)
	109	return err
109	110	}
110	111	for _, n := range names {
111	112	_, ok := d.global[n]

162	163	zw := gzip.NewWriter(enc)
163	164	f, err := os.Open(k)
164	165	if err != nil {
165		return errors.WithStack(err)
	166	return err
166	167	}
167	168	defer f.Close()
168	169	io.Copy(zw, f)
169	170	if err := zw.Close(); err != nil {
170		return errors.WithStack(err)
	171	return err
171	172	}
172	173	d.moot.Lock()
173	174	opts.GlobalFiles[makeKey(xb, k)] = bb.String()

178	179	}
179	180
180	181	if err := wg.Wait(); err != nil {
181		return g, errors.WithStack(err)
	182	return g, err
182	183	}
183	184
184	185	for _, b := range d.boxes {

200	201	}
201	202	fn, err := d.FileNames(box)
202	203	if err != nil {
203		return "", errors.WithStack(err)
	204	return "", err
204	205	}
205	206	if len(fn) == 0 {
206	207	return "", nil

228	229	t := gogen.TemplateTransformer(opts, nil)
229	230	gf, err = t.Transform(gf)
230	231	if err != nil {
231		return "", errors.WithStack(err)
	232	return "", err
232	233	}
233	234	return template.HTML(gf.String()), nil
234	235	},

239	240	global := genny.NewFile(fp, strings.NewReader(diskGlobalTmpl))
240	241	global, err := t.Transform(global)
241	242	if err != nil {
242		return g, errors.WithStack(err)
	243	return g, err
243	244	}
244	245
245	246	ft := gogen.FmtTransformer()
246	247	global, err = ft.Transform(global)
247	248	if err != nil {
248		return g, errors.WithStack(err)
	249	return g, err
249	250	}
250	251	g.File(global)
251	252

278	279	return g, errors.New("go.mod is malformed.")
279	280	}
280	281	ip = filepath.Join(ip, strings.TrimPrefix(filepath.Dir(d.DBPath), filepath.Dir(mp)))
	282	ip = strings.Replace(ip, "\\", "/", -1)
281	283	} else {
282	284	ip = filepath.Dir(d.DBPath)
283	285	srcs := envy.GoPaths()

326	328	run := genny.WetRunner(context.Background())
327	329	run.Logger = plog.Logger
328	330	if err := run.WithNew(d.Generator()); err != nil {
329		return errors.WithStack(err)
	331	return err
330	332	}
331	333	return run.Run()
332	334	}

+7

-9

v2/jam/store/legacy.go less more

7	7	"path/filepath"
8	8	"sort"
9	9	"strings"
10
11		"github.com/pkg/errors"
12	10
13	11	"github.com/gobuffalo/genny"
14	12	"github.com/gobuffalo/gogen"

33	31	func (l Legacy) Pack(box parser.Box) error {
34	32	files, err := l.Files(box)
35	33	if err != nil {
36		return errors.WithStack(err)
	34	return err
37	35	}
38	36
39	37	var fcs []legacyFile

42	40	n := strings.TrimPrefix(f.Name(), box.AbsPath+string(filepath.Separator))
43	41	c, err := l.prepFile(f)
44	42	if err != nil {
45		return errors.WithStack(err)
	43	return err
46	44	}
47	45	fcs = append(fcs, legacyFile{Name: n, Contents: c})
48	46	}

61	59
62	60	// run := genny.WetRunner(context.Background())
63	61	// if err := run.WithNew(l.Generator(box)); err != nil {
64		// return errors.WithStack(err)
	62	// return err
65	63	// }
66	64	// run.Logger = plog.Logger
67	65	// return run.Run()

70	68	func (l *Legacy) prepFile(r io.Reader) (string, error) {
71	69	bb := &bytes.Buffer{}
72	70	if _, err := io.Copy(bb, r); err != nil {
73		return "", errors.WithStack(err)
	71	return "", err
74	72	}
75	73	b, err := json.Marshal(bb.Bytes())
76	74	if err != nil {
77		return "", errors.WithStack(err)
	75	return "", err
78	76	}
79	77	return strings.Replace(string(b), "\"", "\\\"", -1), nil
80	78	}

95	93	t := gogen.TemplateTransformer(opts, nil)
96	94	f, err := t.Transform(f)
97	95	if err != nil {
98		return g, errors.WithStack(err)
	96	return g, err
99	97	}
100	98	g.File(f)
101	99	}

105	103	func (l *Legacy) Close() error {
106	104	run := genny.WetRunner(context.Background())
107	105	if err := run.WithNew(l.Generator()); err != nil {
108		return errors.WithStack(err)
	106	return err
109	107	}
110	108	run.Logger = plog.Logger
111	109	return run.Run()

+1

-2

v2/packr2/cmd/build.go less more

1	1
2	2	import (
3	3	"github.com/gobuffalo/packr/v2/jam"
4		"github.com/pkg/errors"
5	4	"github.com/spf13/cobra"
6	5	)
7	6

12	11	RunE: func(cmd *cobra.Command, args []string) error {
13	12	cargs := parseArgs(args)
14	13	if err := jam.Pack(globalOptions.PackOptions); err != nil {
15		return errors.WithStack(err)
	14	return err
16	15	}
17	16	return goCmd("build", cargs...)
18	17	},

+1

-2

v2/packr2/cmd/fix/fix.go less more

7	7
8	8	"github.com/gobuffalo/envy"
9	9	"github.com/gobuffalo/packr/v2/jam/store"
10		"github.com/pkg/errors"
11	10	)
12	11
13	12	var modsOn = (strings.TrimSpace(envy.Get("GO111MODULE", "off")) == "on")

31	30	func packrClean(r *Runner) error {
32	31	pwd, err := os.Getwd()
33	32	if err != nil {
34		return errors.WithStack(err)
	33	return err
35	34	}
36	35	store.Clean(pwd)
37	36	return nil

+3

-4

v2/packr2/cmd/fix/imports.go less more

12	12	"strconv"
13	13	"strings"
14	14
15		"github.com/pkg/errors"
16	15	"golang.org/x/tools/go/ast/astutil"
17	16	)
18	17

29	28
30	29	err := filepath.Walk(".", c.processFile)
31	30	if err != nil {
32		return errors.WithStack(err)
	31	return err
33	32	}
34	33
35	34	if _, err := os.Stat("Gopkg.toml"); err != nil {

38	37
39	38	b, err := ioutil.ReadFile("Gopkg.toml")
40	39	if err != nil {
41		return errors.WithStack(err)
	40	return err
42	41	}
43	42
44	43	for k := range c.Data {

54	53	er := onlyRelevantFiles(p, info, err, func(p string) error {
55	54	err := c.rewriteFile(p)
56	55	if err != nil {
57		err = errors.WithStack(err)
	56	err = err
58	57	}
59	58
60	59	return err

+1

-2

v2/packr2/cmd/fix/runner.go less more

3	3	"fmt"
4	4
5	5	packr "github.com/gobuffalo/packr/v2"
6		"github.com/pkg/errors"
7	6	)
8	7
9	8	// Check interface for runnable checker functions

40	39
41	40	for _, c := range checks {
42	41	if err := c(r); err != nil {
43		return errors.WithStack(err)
	42	return err
44	43	}
45	44	}
46	45	return nil

+4

-5

v2/packr2/cmd/gocmd.go less more

8	8
9	9	"github.com/gobuffalo/genny"
10	10	"github.com/gobuffalo/packr/v2/plog"
11		"github.com/pkg/errors"
12	11	)
13	12
14	13	func goCmd(name string, args ...string) error {

20	19
21	20	pwd, err := os.Getwd()
22	21	if err != nil {
23		return errors.WithStack(err)
	22	return err
24	23	}
25	24
26	25	if fi, err := os.Stat(filepath.Join(pwd, args[len(args)-1])); err == nil {

36	35
37	36	path, err = filepath.Abs(filepath.Dir(path))
38	37	if err != nil {
39		return errors.WithStack(err)
	38	return err
40	39	}
41	40
42	41	files, err := ioutil.ReadDir(path)
43	42	if err != nil {
44		return errors.WithStack(err)
	43	return err
45	44	}
46	45	for _, f := range files {
47	46	if strings.HasSuffix(f.Name(), "-packr.go") {

51	50	return nil
52	51	}()
53	52	if err != nil {
54		return errors.WithStack(err)
	53	return err
55	54	}
56	55	}
57	56	cp := exec.Command(genny.GoBin(), cargs...)

+1

-2

v2/packr2/cmd/install.go less more

1	1
2	2	import (
3	3	"github.com/gobuffalo/packr/v2/jam"
4		"github.com/pkg/errors"
5	4	"github.com/spf13/cobra"
6	5	)
7	6

12	11	RunE: func(cmd *cobra.Command, args []string) error {
13	12	cargs := parseArgs(args)
14	13	if err := jam.Pack(globalOptions.PackOptions); err != nil {
15		return errors.WithStack(err)
	14	return err
16	15	}
17	16	return goCmd("install", cargs...)
18	17	},

+1

-1

v2/pointer.go less more

21	21	plog.Debug(p, "Resolve", "box", box, "path", path, "forward-box", p.ForwardBox, "forward-path", p.ForwardPath)
22	22	b, err := findBox(p.ForwardBox)
23	23	if err != nil {
24		return nil, errors.WithStack(err)
	24	return nil, err
25	25	}
26	26	f, err := b.Resolve(p.ForwardPath)
27	27	if err != nil {

+3

-4

v2/walk.go less more

7	7	"github.com/gobuffalo/packr/v2/file"
8	8	"github.com/gobuffalo/packr/v2/file/resolver"
9	9	"github.com/gobuffalo/packr/v2/plog"
10		"github.com/pkg/errors"
11	10	)
12	11
13	12	// WalkFunc is used to walk a box

46	45	return true
47	46	})
48	47	if err != nil {
49		return errors.WithStack(err)
	48	return err
50	49	}
51	50
52	51	var keys = make([]string, 0, len(m))

59	58	osPath := resolver.OsPath(k)
60	59	plog.Debug(b, "Walk", "path", k, "osPath", osPath)
61	60	if err := wf(osPath, m[k]); err != nil {
62		return errors.WithStack(err)
	61	return err
63	62	}
64	63	}
65	64	return nil

72	71	ipath := resolver.OsPath(path)
73	72	if strings.HasPrefix(ipath, ipref) {
74	73	if err := wf(path, f); err != nil {
75		return errors.WithStack(err)
	74	return err
76	75	}
77	76	}
78	77	return nil

+2

-3

walk.go less more

5	5	"strings"
6	6
7	7	"github.com/gobuffalo/packd"
8		"github.com/pkg/errors"
9	8	)
10	9
11	10	type WalkFunc = packd.WalkFunc

15	14	if data[b.Path] == nil {
16	15	base, err := filepath.EvalSymlinks(filepath.Join(b.callingDir, b.Path))
17	16	if err != nil {
18		return errors.WithStack(err)
	17	return err
19	18	}
20	19	return filepath.Walk(base, func(path string, info os.FileInfo, err error) error {
21	20	cleanName, err := filepath.Rel(base, path)

55	54	return b.Walk(func(path string, f File) error {
56	55	if strings.HasPrefix(osPath(path), opre) {
57	56	if err := wf(path, f); err != nil {
58		return errors.WithStack(err)
	57	return err
59	58	}
60	59	}
61	60	return nil