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
|
package jen
import (
"bytes"
"fmt"
"go/format"
"io"
)
// Statement represents a simple list of code items. When rendered the items
// are separated by spaces.
type Statement []Code
func newStatement() *Statement {
return &Statement{}
}
// Clone makes a copy of the Statement, so further tokens can be appended
// without affecting the original.
func (s *Statement) Clone() *Statement {
return &Statement{s}
}
func (s *Statement) previous(c Code) Code {
index := -1
for i, item := range *s {
if item == c {
index = i
break
}
}
if index > 0 {
return (*s)[index-1]
}
return nil
}
func (s *Statement) isNull(f *File) bool {
if s == nil {
return true
}
for _, c := range *s {
if !c.isNull(f) {
return false
}
}
return true
}
func (s *Statement) render(f *File, w io.Writer, _ *Statement) error {
first := true
for _, code := range *s {
if code == nil || code.isNull(f) {
// Null() token produces no output but also
// no separator. Empty() token products no
// output but adds a separator.
continue
}
if !first {
if _, err := w.Write([]byte(" ")); err != nil {
return err
}
}
if err := code.render(f, w, s); err != nil {
return err
}
first = false
}
return nil
}
// Render renders the Statement to the provided writer.
func (s *Statement) Render(writer io.Writer) error {
return s.RenderWithFile(writer, NewFile(""))
}
// GoString renders the Statement for testing. Any error will cause a panic.
func (s *Statement) GoString() string {
buf := bytes.Buffer{}
if err := s.Render(&buf); err != nil {
panic(err)
}
return buf.String()
}
// RenderWithFile renders the Statement to the provided writer, using imports from the provided file.
func (s *Statement) RenderWithFile(writer io.Writer, file *File) error {
buf := &bytes.Buffer{}
if err := s.render(file, buf, nil); err != nil {
return err
}
b, err := format.Source(buf.Bytes())
if err != nil {
return fmt.Errorf("Error %s while formatting source:\n%s", err, buf.String())
}
if _, err := writer.Write(b); err != nil {
return err
}
return nil
}
|
