/
expand.go
215 lines (182 loc) · 5.04 KB
/
expand.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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
// Package expand contains helper functions used to map terraform configuration
// to an API object.
package expand
//go:generate go run gen.go > expand.gen.go
import (
"strconv"
"github.com/alexkappa/terraform-plugin-helper/helper"
"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
"github.com/hashicorp/terraform-plugin-sdk/helper/structure"
)
type data struct {
prefix string
helper.ResourceData
}
func dataAtKey(key string, d helper.ResourceData) helper.ResourceData {
return &data{key, d}
}
func dataAtIndex(i int, d helper.ResourceData) helper.ResourceData {
return &data{strconv.Itoa(i), d}
}
func (d *data) IsNewResource() bool {
return d.ResourceData.IsNewResource()
}
func (d *data) HasChange(key string) bool {
return d.ResourceData.HasChange(d.prefix + "." + key)
}
func (d *data) GetChange(key string) (interface{}, interface{}) {
return d.ResourceData.GetChange(d.prefix + "." + key)
}
func (d *data) Get(key string) interface{} {
return d.ResourceData.Get(d.prefix + "." + key)
}
func (d *data) GetOk(key string) (interface{}, bool) {
return d.ResourceData.GetOk(d.prefix + "." + key)
}
func (d *data) GetOkExists(key string) (interface{}, bool) {
return d.ResourceData.GetOkExists(d.prefix + "." + key)
}
var _ helper.ResourceData = (*data)(nil)
func get(d helper.ResourceData, key string) (v interface{}, ok bool) {
if d.IsNewResource() || d.HasChange(key) {
v, ok = d.GetOkExists(key)
}
return
}
// Slice accesses the value held by key and type asserts it to a slice.
func Slice(d helper.ResourceData, key string) (s []interface{}) {
if d.IsNewResource() || d.HasChange(key) {
v, ok := d.GetOkExists(key)
if ok {
s = v.([]interface{})
}
}
return
}
// Map accesses the value held by key and type asserts it to a map.
func Map(d helper.ResourceData, key string) (m map[string]interface{}) {
if d.IsNewResource() || d.HasChange(key) {
v, ok := d.GetOkExists(key)
if ok {
m = v.(map[string]interface{})
}
}
return
}
// List accesses the value held by key and returns an iterator able to go over
// its elements.
func List(d helper.ResourceData, key string) Iterator {
if d.IsNewResource() || d.HasChange(key) {
v, ok := d.GetOkExists(key)
if ok {
return &list{dataAtKey(key, d), v.([]interface{})}
}
}
return &list{}
}
// Set accesses the value held by key, type asserts it to a set and returns an
// iterator able to go over its elements.
func Set(d helper.ResourceData, key string) Iterator {
if d.IsNewResource() || d.HasChange(key) {
v, ok := d.GetOkExists(key)
if ok {
if s, ok := v.(*schema.Set); ok {
return &set{dataAtKey(key, d), s}
}
}
}
return &set{nil, &schema.Set{}}
}
// Iterator enables access to the elements of a list or set.
type Iterator interface {
// Elem iterates over all elements of the list or set, calling fn with each
// iteration.
//
// The callback takes a Data interface as argument which is prefixed with
// its parents key, making nested data access more convenient.
//
// The operation
//
// bar = d.Get("foo.0.bar").(string)
//
// can be expressed as
//
// List(d, "foo").Elem(func (d Data) {
// bar = String(d, "bar")
// })
//
// making data access more intuitive for nested structures.
Elem(func(d helper.ResourceData))
// Range iterates over all elements of the list, calling fn in each iteration.
Range(func(k int, v interface{}))
// List returns the underlying list as a Go slice.
List() []interface{}
}
type list struct {
d helper.ResourceData
v []interface{}
}
func (l *list) Range(fn func(key int, value interface{})) {
for key, value := range l.v {
fn(key, value)
}
}
func (l *list) Elem(fn func(helper.ResourceData)) {
for idx := range l.v {
fn(dataAtIndex(idx, l.d))
}
}
func (l *list) List() []interface{} {
return l.v
}
type set struct {
d helper.ResourceData
s *schema.Set
}
func (s *set) hash(item interface{}) string {
code := s.s.F(item)
if code < 0 {
code = -code
}
return strconv.Itoa(code)
}
func (s *set) Range(fn func(key int, value interface{})) {
for key, value := range s.s.List() {
fn(key, value)
}
}
func (s *set) Elem(fn func(helper.ResourceData)) {
for _, v := range s.s.List() {
fn(dataAtKey(s.hash(v), s.d))
}
}
func (s *set) List() []interface{} {
return s.s.List()
}
// Diff accesses the value held by key and type asserts it to a set. It then
// compares it's changes if any and returns what needs to be added and what
// needs to be removed.
func Diff(d helper.ResourceData, key string) (add []interface{}, rm []interface{}) {
if d.IsNewResource() {
add = Set(d, key).List()
}
if d.HasChange(key) {
o, n := d.GetChange(key)
add = n.(*schema.Set).Difference(o.(*schema.Set)).List()
rm = o.(*schema.Set).Difference(n.(*schema.Set)).List()
}
return
}
// JSON accesses the value held by key and unmarshals it into a map.
func JSON(d helper.ResourceData, key string) (m map[string]interface{}, err error) {
if d.IsNewResource() || d.HasChange(key) {
v, ok := d.GetOkExists(key)
if ok {
m, err = structure.ExpandJsonFromString(v.(string))
if err != nil {
return
}
}
}
return
}