this repo has no description
rename the formz_x `simple` modules to `generator`
+79
-81
+4
-6
formz_lustre/src/formz_lustre/simple.gleam
formz_lustre/src/formz_lustre/generator.gleam
+4
-6
formz_lustre/src/formz_lustre/simple.gleam
formz_lustre/src/formz_lustre/generator.gleam
···
6
6
import lustre/element
7
7
import lustre/element/html.{html}
8
8
9
-
pub fn generate(form) -> element.Element(msg) {
9
+
pub fn build(form) -> element.Element(msg) {
10
10
form
11
11
|> formz.items
12
-
|> list.map(generate_item)
12
+
|> list.map(build_item)
13
13
|> html.div([attribute.class("formz_items")], _)
14
14
}
15
15
16
-
pub fn generate_item(
17
-
item: formz.Item(widget.Widget(msg)),
18
-
) -> element.Element(msg) {
16
+
pub fn build_item(item: formz.Item(widget.Widget(msg))) -> element.Element(msg) {
19
17
case item {
20
18
formz.Field(config, state, widget.Hidden) -> hidden_input(config, state)
21
19
···
89
87
let id = config.name
90
88
let legend = legend(id, config.label)
91
89
let help_text = help_text(id, config.help_text, html.p, "formz_help_text")
92
-
let children = items |> list.map(generate_item)
90
+
let children = items |> list.map(build_item)
93
91
html.fieldset([described_by_attr(help_text.id)], [
94
92
legend.element,
95
93
help_text.element,
+26
-26
formz_lustre/test/formz_lustre/simple_test.gleam
formz_lustre/test/formz_lustre/generator_test.gleam
+26
-26
formz_lustre/test/formz_lustre/simple_test.gleam
formz_lustre/test/formz_lustre/generator_test.gleam
···
1
1
import formz
2
2
import formz_lustre/definition
3
-
import formz_lustre/simple
3
+
import formz_lustre/generator
4
4
import formz_string/definition as string_definition
5
-
import formz_string/simple as string_simple
5
+
import formz_string/generator as string_generator
6
6
import gleeunit
7
7
import gleeunit/should
8
8
import lustre/element
···
92
92
}
93
93
94
94
pub fn three_field_form_test() {
95
-
let html = three_field_form() |> simple.generate |> convert_to_string
96
-
let string_html = three_field_string_form() |> string_simple.generate
95
+
let html = three_field_form() |> generator.build |> convert_to_string
96
+
let string_html = three_field_string_form() |> string_generator.build
97
97
html |> should.equal(string_html)
98
98
}
99
99
···
101
101
let html =
102
102
three_field_form()
103
103
|> formz.data([#("a", "1"), #("b", "2")])
104
-
|> simple.generate
104
+
|> generator.build
105
105
|> convert_to_string
106
106
let string_html =
107
107
three_field_string_form()
108
108
|> formz.data([#("a", "1"), #("b", "2")])
109
-
|> string_simple.generate
109
+
|> string_generator.build
110
110
html |> should.equal(string_html)
111
111
}
112
112
···
114
114
let html =
115
115
three_field_form()
116
116
|> formz.update_config("b", formz.set_help_text(_, "this is field b"))
117
-
|> simple.generate
117
+
|> generator.build
118
118
|> convert_to_string
119
119
let string_html =
120
120
three_field_string_form()
121
121
|> formz.update_config("b", formz.set_help_text(_, "this is field b"))
122
-
|> string_simple.generate
122
+
|> string_generator.build
123
123
html |> should.equal(string_html)
124
124
}
125
125
···
128
128
three_field_form()
129
129
|> formz.data([#("a", "x"), #("b", "x"), #("c", "x")])
130
130
|> formz.validate(["b"])
131
-
|> simple.generate
131
+
|> generator.build
132
132
|> convert_to_string
133
133
let string_html =
134
134
three_field_string_form()
135
135
|> formz.data([#("a", "x"), #("b", "x"), #("c", "x")])
136
136
|> formz.validate(["b"])
137
-
|> string_simple.generate
137
+
|> string_generator.build
138
138
html |> should.equal(string_html)
139
139
}
140
140
···
144
144
|> formz.data([#("a", "x"), #("b", "x"), #("c", "x")])
145
145
|> formz.validate(["b"])
146
146
|> formz.update_config("b", formz.set_help_text(_, "this is field b"))
147
-
|> simple.generate
147
+
|> generator.build
148
148
|> convert_to_string
149
149
let string_html =
150
150
three_field_string_form()
151
151
|> formz.data([#("a", "x"), #("b", "x"), #("c", "x")])
152
152
|> formz.validate(["b"])
153
153
|> formz.update_config("b", formz.set_help_text(_, "this is field b"))
154
-
|> string_simple.generate
154
+
|> string_generator.build
155
155
html |> should.equal(string_html)
156
156
}
157
157
···
159
159
let html =
160
160
three_field_form()
161
161
|> formz.update_config("b", formz.set_disabled(_, True))
162
-
|> simple.generate
162
+
|> generator.build
163
163
|> convert_to_string
164
164
let string_html =
165
165
three_field_string_form()
166
166
|> formz.update_config("b", formz.set_disabled(_, True))
167
-
|> string_simple.generate
167
+
|> string_generator.build
168
168
html |> should.equal(string_html)
169
169
}
170
170
171
171
pub fn subform_test() {
172
172
let html =
173
173
one_field_and_subform_form()
174
-
|> simple.generate
174
+
|> generator.build
175
175
|> convert_to_string
176
176
let string_html =
177
177
one_field_and_subform_string_form()
178
-
|> string_simple.generate
178
+
|> string_generator.build
179
179
html |> should.equal(string_html)
180
180
}
181
181
···
183
183
let html =
184
184
one_field_and_subform_form()
185
185
|> formz.update_config("b", formz.set_help_text(_, "this is subform b"))
186
-
|> simple.generate
186
+
|> generator.build
187
187
|> convert_to_string
188
188
let string_html =
189
189
one_field_and_subform_string_form()
190
190
|> formz.update_config("b", formz.set_help_text(_, "this is subform b"))
191
-
|> string_simple.generate
191
+
|> string_generator.build
192
192
html |> should.equal(string_html)
193
193
}
194
194
···
197
197
one_field_and_subform_form()
198
198
|> formz.update_config("b", formz.set_help_text(_, "this is subform b"))
199
199
|> formz.field_error("b.a", "woops")
200
-
|> simple.generate
200
+
|> generator.build
201
201
|> convert_to_string
202
202
let string_html =
203
203
one_field_and_subform_string_form()
204
204
|> formz.update_config("b", formz.set_help_text(_, "this is subform b"))
205
205
|> formz.field_error("b.a", "woops")
206
-
|> string_simple.generate
206
+
|> string_generator.build
207
207
html |> should.equal(string_html)
208
208
}
209
209
210
210
pub fn hidden_field_form_test() {
211
211
let html =
212
212
hidden_field_form()
213
-
|> simple.generate
213
+
|> generator.build
214
214
|> convert_to_string
215
215
let string_html =
216
216
hidden_field_string_form()
217
-
|> string_simple.generate
217
+
|> string_generator.build
218
218
html |> should.equal(string_html)
219
219
}
220
220
221
221
pub fn list_field_test() {
222
222
let html =
223
223
list_field_form()
224
-
|> simple.generate
224
+
|> generator.build
225
225
|> convert_to_string
226
226
let string_html =
227
227
list_field_string_form()
228
-
|> string_simple.generate
228
+
|> string_generator.build
229
229
html |> should.equal(string_html)
230
230
}
231
231
···
234
234
list_field_form()
235
235
|> formz.validate_all
236
236
|> formz.listfield_errors("a", [Ok(Nil), Error("woops")])
237
-
|> simple.generate
237
+
|> generator.build
238
238
|> convert_to_string
239
239
let string_html =
240
240
list_field_string_form()
241
241
|> formz.validate_all
242
242
|> formz.listfield_errors("a", [Ok(Nil), Error("woops")])
243
-
|> string_simple.generate
243
+
|> string_generator.build
244
244
html |> should.equal(string_html)
245
245
}
+4
-4
formz_nakai/src/formz_nakai/simple.gleam
formz_nakai/src/formz_nakai/generator.gleam
+4
-4
formz_nakai/src/formz_nakai/simple.gleam
formz_nakai/src/formz_nakai/generator.gleam
···
5
5
import nakai/attr
6
6
import nakai/html
7
7
8
-
pub fn generate(form: formz.Form(widget.Widget, a)) -> html.Node {
8
+
pub fn build(form: formz.Form(widget.Widget, a)) -> html.Node {
9
9
form
10
10
|> formz.items
11
-
|> list.map(generate_item)
11
+
|> list.map(build_item)
12
12
|> html.div([attr.class("formz_items")], _)
13
13
}
14
14
15
-
pub fn generate_item(item: formz.Item(widget.Widget)) -> html.Node {
15
+
pub fn build_item(item: formz.Item(widget.Widget)) -> html.Node {
16
16
case item {
17
17
formz.Field(config, state, widget.Hidden) -> hidden_input(config, state)
18
18
···
84
84
let id = config.name
85
85
let legend = legend(id, config.label)
86
86
let help_text = help_text(id, config.help_text, html.p, "formz_help_text")
87
-
let children = items |> list.map(generate_item)
87
+
let children = items |> list.map(build_item)
88
88
html.fieldset(list.flatten([described_by_attr(help_text.id)]), [
89
89
legend.element,
90
90
help_text.element,
+26
-26
formz_nakai/test/formz_nakai/simple_test.gleam
formz_nakai/test/formz_nakai/generator_test.gleam
+26
-26
formz_nakai/test/formz_nakai/simple_test.gleam
formz_nakai/test/formz_nakai/generator_test.gleam
···
1
1
import formz
2
2
import formz_nakai/definition
3
-
import formz_nakai/simple
3
+
import formz_nakai/generator
4
4
import formz_string/definition as string_definition
5
-
import formz_string/simple as string_simple
5
+
import formz_string/generator as string_generator
6
6
import gleam/string
7
7
import gleeunit
8
8
import gleeunit/should
···
110
110
}
111
111
112
112
pub fn three_field_form_test() {
113
-
let html = three_field_form() |> simple.generate |> convert_to_string
114
-
let string_html = three_field_string_form() |> string_simple.generate
113
+
let html = three_field_form() |> generator.build |> convert_to_string
114
+
let string_html = three_field_string_form() |> string_generator.build
115
115
html |> should.equal(string_html)
116
116
}
117
117
···
119
119
let html =
120
120
three_field_form()
121
121
|> formz.data([#("a", "1"), #("b", "2")])
122
-
|> simple.generate
122
+
|> generator.build
123
123
|> convert_to_string
124
124
let string_html =
125
125
three_field_string_form()
126
126
|> formz.data([#("a", "1"), #("b", "2")])
127
-
|> string_simple.generate
127
+
|> string_generator.build
128
128
html |> should.equal(string_html)
129
129
}
130
130
···
132
132
let html =
133
133
three_field_form()
134
134
|> formz.update_config("b", formz.set_help_text(_, "this is field b"))
135
-
|> simple.generate
135
+
|> generator.build
136
136
|> convert_to_string
137
137
let string_html =
138
138
three_field_string_form()
139
139
|> formz.update_config("b", formz.set_help_text(_, "this is field b"))
140
-
|> string_simple.generate
140
+
|> string_generator.build
141
141
html |> should.equal(string_html)
142
142
}
143
143
···
146
146
three_field_form()
147
147
|> formz.data([#("a", "x"), #("b", "x"), #("c", "x")])
148
148
|> formz.validate(["b"])
149
-
|> simple.generate
149
+
|> generator.build
150
150
|> convert_to_string
151
151
let string_html =
152
152
three_field_string_form()
153
153
|> formz.data([#("a", "x"), #("b", "x"), #("c", "x")])
154
154
|> formz.validate(["b"])
155
-
|> string_simple.generate
155
+
|> string_generator.build
156
156
html |> should.equal(string_html)
157
157
}
158
158
···
162
162
|> formz.data([#("a", "x"), #("b", "x"), #("c", "x")])
163
163
|> formz.validate(["b"])
164
164
|> formz.update_config("b", formz.set_help_text(_, "this is field b"))
165
-
|> simple.generate
165
+
|> generator.build
166
166
|> convert_to_string
167
167
let string_html =
168
168
three_field_string_form()
169
169
|> formz.data([#("a", "x"), #("b", "x"), #("c", "x")])
170
170
|> formz.validate(["b"])
171
171
|> formz.update_config("b", formz.set_help_text(_, "this is field b"))
172
-
|> string_simple.generate
172
+
|> string_generator.build
173
173
html |> should.equal(string_html)
174
174
}
175
175
···
177
177
let html =
178
178
three_field_form()
179
179
|> formz.update_config("b", formz.set_disabled(_, True))
180
-
|> simple.generate
180
+
|> generator.build
181
181
|> convert_to_string
182
182
let string_html =
183
183
three_field_string_form()
184
184
|> formz.update_config("b", formz.set_disabled(_, True))
185
-
|> string_simple.generate
185
+
|> string_generator.build
186
186
html |> should.equal(string_html)
187
187
}
188
188
189
189
pub fn subform_test() {
190
190
let html =
191
191
one_field_and_subform_form()
192
-
|> simple.generate
192
+
|> generator.build
193
193
|> convert_to_string
194
194
let string_html =
195
195
one_field_and_subform_string_form()
196
-
|> string_simple.generate
196
+
|> string_generator.build
197
197
html |> should.equal(string_html)
198
198
}
199
199
···
201
201
let html =
202
202
one_field_and_subform_form()
203
203
|> formz.update_config("b", formz.set_help_text(_, "this is subform b"))
204
-
|> simple.generate
204
+
|> generator.build
205
205
|> convert_to_string
206
206
let string_html =
207
207
one_field_and_subform_string_form()
208
208
|> formz.update_config("b", formz.set_help_text(_, "this is subform b"))
209
-
|> string_simple.generate
209
+
|> string_generator.build
210
210
html |> should.equal(string_html)
211
211
}
212
212
···
215
215
one_field_and_subform_form()
216
216
|> formz.update_config("b", formz.set_help_text(_, "this is subform b"))
217
217
|> formz.field_error("b.a", "woops")
218
-
|> simple.generate
218
+
|> generator.build
219
219
|> convert_to_string
220
220
let string_html =
221
221
one_field_and_subform_string_form()
222
222
|> formz.update_config("b", formz.set_help_text(_, "this is subform b"))
223
223
|> formz.field_error("b.a", "woops")
224
-
|> string_simple.generate
224
+
|> string_generator.build
225
225
html |> should.equal(string_html)
226
226
}
227
227
228
228
pub fn hidden_field_form_test() {
229
229
let html =
230
230
hidden_field_form()
231
-
|> simple.generate
231
+
|> generator.build
232
232
|> convert_to_string
233
233
let string_html =
234
234
hidden_field_string_form()
235
-
|> string_simple.generate
235
+
|> string_generator.build
236
236
html |> should.equal(string_html)
237
237
}
238
238
239
239
pub fn list_field_test() {
240
240
let html =
241
241
list_field_form()
242
-
|> simple.generate
242
+
|> generator.build
243
243
|> convert_to_string
244
244
let string_html =
245
245
list_field_string_form()
246
-
|> string_simple.generate
246
+
|> string_generator.build
247
247
html |> should.equal(string_html)
248
248
}
249
249
···
252
252
list_field_form()
253
253
|> formz.validate_all
254
254
|> formz.listfield_errors("a", [Ok(Nil), Error("woops")])
255
-
|> simple.generate
255
+
|> generator.build
256
256
|> convert_to_string
257
257
let string_html =
258
258
list_field_string_form()
259
259
|> formz.validate_all
260
260
|> formz.listfield_errors("a", [Ok(Nil), Error("woops")])
261
-
|> string_simple.generate
261
+
|> string_generator.build
262
262
html |> should.equal(string_html)
263
263
}
+4
-4
formz_string/src/formz_string/simple.gleam
formz_string/src/formz_string/generator.gleam
+4
-4
formz_string/src/formz_string/simple.gleam
formz_string/src/formz_string/generator.gleam
···
4
4
import gleam/list
5
5
import gleam/string
6
6
7
-
pub fn generate(form) -> String {
7
+
pub fn build(form) -> String {
8
8
formz.items(form)
9
-
|> list.map(generate_item)
9
+
|> list.map(build_item)
10
10
|> string.join("")
11
11
|> wrap("<div class=\"formz_items\">", _, "</div>")
12
12
}
13
13
14
-
pub fn generate_item(item: formz.Item(widget.Widget)) -> String {
14
+
pub fn build_item(item: formz.Item(widget.Widget)) -> String {
15
15
case item {
16
16
formz.Field(config, state, widget.Hidden) -> hidden_input(config, state)
17
17
···
80
80
let help_text = help_text(id, config.help_text, "p", "formz_help_text")
81
81
82
82
let items_el =
83
-
"<div>" <> list.map(items, generate_item) |> string.join("") <> "</div>"
83
+
"<div>" <> list.map(items, build_item) |> string.join("") <> "</div>"
84
84
85
85
{ "<fieldset" <> described_by_attr(help_text.id) <> ">" }
86
86
<> legend.element
+15
-15
formz_string/test/formz_string/simple_test.gleam
formz_string/test/formz_string/generator_test.gleam
+15
-15
formz_string/test/formz_string/simple_test.gleam
formz_string/test/formz_string/generator_test.gleam
···
1
1
import birdie
2
2
import formz
3
3
import formz_string/definition
4
-
import formz_string/simple
4
+
import formz_string/generator
5
5
import formz_string/widget
6
6
import gleeunit
7
7
···
44
44
45
45
pub fn three_field_form_test() {
46
46
three_field_form()
47
-
|> simple.generate
47
+
|> generator.build
48
48
|> birdie.snap(title: "three field form")
49
49
}
50
50
51
51
pub fn three_field_form_with_data_test() {
52
52
three_field_form()
53
53
|> formz.data([#("a", "1"), #("b", "2"), #("c", "3")])
54
-
|> simple.generate
54
+
|> generator.build
55
55
|> birdie.snap(title: "three field form with data")
56
56
}
57
57
58
58
pub fn three_field_form_with_help_test() {
59
59
three_field_form()
60
60
|> formz.update_config("b", formz.set_help_text(_, "this is field b"))
61
-
|> simple.generate
61
+
|> generator.build
62
62
|> birdie.snap(title: "three field form with help text")
63
63
}
64
64
···
66
66
three_field_form()
67
67
|> formz.data([#("a", "x"), #("b", "x"), #("c", "x")])
68
68
|> formz.validate(["b"])
69
-
|> simple.generate
69
+
|> generator.build
70
70
|> birdie.snap(title: "three field form with error")
71
71
}
72
72
···
75
75
|> formz.data([#("a", "x"), #("b", "x"), #("c", "x")])
76
76
|> formz.validate(["b"])
77
77
|> formz.update_config("b", formz.set_help_text(_, "this is field b"))
78
-
|> simple.generate
78
+
|> generator.build
79
79
|> birdie.snap(title: "three field form with error and help text")
80
80
}
81
81
82
82
pub fn three_field_form_with_disabled_test() {
83
83
three_field_form()
84
84
|> formz.update_config("b", formz.set_disabled(_, True))
85
-
|> simple.generate
85
+
|> generator.build
86
86
|> birdie.snap(title: "three field form with disabled field")
87
87
}
88
88
89
89
pub fn subform_test() {
90
90
one_field_and_subform_form()
91
-
|> simple.generate
91
+
|> generator.build
92
92
|> birdie.snap(title: "subform")
93
93
}
94
94
95
95
pub fn subform_with_help_text_test() {
96
96
one_field_and_subform_form()
97
97
|> formz.update_config("b", formz.set_help_text(_, "this is subform b"))
98
-
|> simple.generate
98
+
|> generator.build
99
99
|> birdie.snap(title: "subform with help text")
100
100
}
101
101
···
103
103
one_field_and_subform_form()
104
104
|> formz.update_config("b", formz.set_help_text(_, "this is subform b"))
105
105
|> formz.field_error("b.a", "woops")
106
-
|> simple.generate
106
+
|> generator.build
107
107
|> birdie.snap(title: "subform with help text and error")
108
108
}
109
109
110
110
pub fn hidden_field_form_test() {
111
111
hidden_field_form()
112
112
|> formz.data([#("a", "1")])
113
-
|> simple.generate
113
+
|> generator.build
114
114
|> birdie.snap(title: "hidden field form")
115
115
}
116
116
117
117
pub fn hidden_field_form_no_value_test() {
118
118
hidden_field_form()
119
-
|> simple.generate
119
+
|> generator.build
120
120
|> birdie.snap(title: "hidden field form no value")
121
121
}
122
122
123
123
pub fn list_field_test() {
124
124
list_field_form()
125
-
|> simple.generate
125
+
|> generator.build
126
126
|> birdie.snap(title: "list field form")
127
127
}
128
128
···
130
130
list_field_form()
131
131
|> formz.validate_all
132
132
|> formz.listfield_errors("a", [Ok(Nil), Error("woops")])
133
-
|> simple.generate
133
+
|> generator.build
134
134
|> birdie.snap(title: "list field form with error")
135
135
}
136
136
···
143
143
}
144
144
})
145
145
|> formz.data([#("a", "1"), #("a", "2")])
146
-
|> simple.generate
146
+
|> generator.build
147
147
|> birdie.snap(title: "list field form hidden")
148
148
}