this repo has no description
rename to formz
+375
-368
forma/.github/workflows/test.yml
formz/.github/workflows/test.yml
forma/.github/workflows/test.yml
formz/.github/workflows/test.yml
forma/.gitignore
formz/.gitignore
forma/.gitignore
formz/.gitignore
-24
forma/README.md
-24
forma/README.md
···
1
-
# forma
2
-
3
-
[](https://hex.pm/packages/forma)
4
-
[](https://hexdocs.pm/forma/)
5
-
6
-
```sh
7
-
gleam add forma@1
8
-
```
9
-
```gleam
10
-
import forma
11
-
12
-
pub fn main() {
13
-
// TODO: An example of the project in use
14
-
}
15
-
```
16
-
17
-
Further documentation can be found at <https://hexdocs.pm/forma>.
18
-
19
-
## Development
20
-
21
-
```sh
22
-
gleam run # Run the project
23
-
gleam test # Run the tests
24
-
```
+1
-1
forma/gleam.toml
formz/gleam.toml
+1
-1
forma/gleam.toml
formz/gleam.toml
forma/manifest.toml
formz/manifest.toml
forma/manifest.toml
formz/manifest.toml
forma/src/forma.gleam
forma/src/forma.gleam
This is a binary file and will not be displayed.
+2
-2
forma/src/forma/field.gleam
formz/src/formz/field.gleam
+2
-2
forma/src/forma/field.gleam
formz/src/formz/field.gleam
+2
-2
forma/src/forma/forma_pipes/forma.gleam
formz/src/formz/formz_pipes.gleam
+2
-2
forma/src/forma/forma_pipes/forma.gleam
formz/src/formz/formz_pipes.gleam
···
9
9
// - csrf token
10
10
// - overwrite error messages
11
11
12
-
import forma/field.{type Field}
13
-
import forma/input.{type Input, Input}
12
+
import formz/field.{type Field}
13
+
import formz/input.{type Input, Input}
14
14
import gleam/list
15
15
import gleam/option.{type Option, None, Some}
16
16
import gleam/result
+2
-2
forma/src/forma/forma_use/forma.gleam
formz/src/formz/formz_use.gleam
+2
-2
forma/src/forma/forma_use/forma.gleam
formz/src/formz/formz_use.gleam
forma/src/forma/input.gleam
formz/src/formz/input.gleam
forma/src/forma/input.gleam
formz/src/formz/input.gleam
+2
-2
forma/src/forma/string_fields.gleam
formz/src/formz/string_fields.gleam
+2
-2
forma/src/forma/string_fields.gleam
formz/src/formz/string_fields.gleam
forma/src/forma/validation.gleam
formz/src/formz/validation.gleam
forma/src/forma/validation.gleam
formz/src/formz/validation.gleam
-254
forma/test/forma/forma_pipes/forma_test.gleam
-254
forma/test/forma/forma_pipes/forma_test.gleam
···
1
-
import forma/field.{field}
2
-
import forma/forma_pipes/forma
3
-
import forma/input
4
-
import forma/string_fields
5
-
import gleam/list
6
-
import gleeunit
7
-
import gleeunit/should
8
-
9
-
pub fn main() {
10
-
gleeunit.main()
11
-
}
12
-
13
-
pub fn empty_form_test() {
14
-
forma.new()
15
-
|> forma.get_inputs
16
-
|> list.length
17
-
|> should.equal(0)
18
-
}
19
-
20
-
pub fn parse_empty_form_test() {
21
-
forma.new()
22
-
|> forma.data([])
23
-
|> forma.decodes(1)
24
-
|> forma.parse
25
-
|> should.equal(Ok(1))
26
-
27
-
forma.new()
28
-
|> forma.data([])
29
-
|> forma.decodes("Hello")
30
-
|> forma.parse
31
-
|> should.equal(Ok("Hello"))
32
-
}
33
-
34
-
pub fn parse_single_field_form_test() {
35
-
forma.new()
36
-
|> forma.add(field("first", string_fields.text_field()))
37
-
|> forma.data([#("first", "world")])
38
-
|> forma.decodes(fn(str) { "hello " <> str })
39
-
|> forma.parse
40
-
|> should.equal(Ok("hello world"))
41
-
}
42
-
43
-
pub fn parse_double_field_form_test() {
44
-
forma.new()
45
-
|> forma.add(field("first", string_fields.text_field()))
46
-
|> forma.add(field("second", string_fields.text_field()))
47
-
|> forma.data([#("first", "hello"), #("second", "world")])
48
-
|> forma.decodes(fn(a) { fn(b) { a <> " " <> b } })
49
-
|> forma.parse
50
-
|> should.equal(Ok("hello world"))
51
-
}
52
-
53
-
pub fn parse_double_field_form_extra_data_test() {
54
-
forma.new()
55
-
|> forma.add(field("first", string_fields.text_field()))
56
-
|> forma.add(field("second", string_fields.text_field()))
57
-
|> forma.data([#("first", "1"), #("second", "2")])
58
-
|> forma.decodes(fn(a) { fn(b) { a <> " " <> b } })
59
-
|> forma.parse
60
-
|> should.equal(Ok("1 2"))
61
-
62
-
forma.new()
63
-
|> forma.add(field("first", string_fields.text_field()))
64
-
|> forma.add(field("second", string_fields.text_field()))
65
-
|> forma.data([#("first", "1"), #("second", "2"), #("second", "3")])
66
-
|> forma.decodes(fn(a) { fn(b) { a <> " " <> b } })
67
-
|> forma.parse
68
-
|> should.equal(Ok("1 2"))
69
-
}
70
-
71
-
pub fn integer_field_test() {
72
-
forma.new()
73
-
|> forma.add(field("first", string_fields.integer_field()))
74
-
|> forma.data([#("first", " 1 ")])
75
-
|> forma.decodes(fn(i) { i })
76
-
|> forma.parse
77
-
|> should.equal(Ok(1))
78
-
}
79
-
80
-
pub fn can_decodes_in_any_order_test() {
81
-
forma.new()
82
-
|> forma.decodes(fn(str) { "hello " <> str })
83
-
|> forma.add(field("first", string_fields.text_field()))
84
-
|> forma.data([#("first", "world")])
85
-
|> forma.parse
86
-
|> should.equal(Ok("hello world"))
87
-
88
-
forma.new()
89
-
|> forma.add(field("first", string_fields.text_field()))
90
-
|> forma.data([#("first", "world")])
91
-
|> forma.decodes(fn(str) { "hello " <> str })
92
-
|> forma.parse
93
-
|> should.equal(Ok("hello world"))
94
-
}
95
-
96
-
pub fn parse_single_field_form_with_error_test() {
97
-
let assert Error(f) =
98
-
forma.new()
99
-
|> forma.add(field("first", string_fields.integer_field()))
100
-
|> forma.data([#("first", "world")])
101
-
|> forma.decodes(fn(_) { 1 })
102
-
|> forma.parse
103
-
104
-
let assert [field] = forma.get_inputs(f)
105
-
field |> should_be_field_with_error("Must be a whole number")
106
-
}
107
-
108
-
pub fn parse_double_field_form_with_error_test() {
109
-
let form =
110
-
forma.new()
111
-
|> forma.add(field("a", string_fields.integer_field()))
112
-
|> forma.add(field("b", string_fields.integer_field()))
113
-
|> forma.decodes(fn(_) { fn(_) { 1 } })
114
-
115
-
let assert Error(f) =
116
-
form
117
-
|> forma.data([#("a", "not a number"), #("b", "2")])
118
-
|> forma.parse
119
-
120
-
let assert [fielda, fieldb] = forma.get_inputs(f)
121
-
fielda |> should_be_field_with_error("Must be a whole number")
122
-
fieldb |> should_be_field_no_error
123
-
124
-
let assert Error(f) =
125
-
form
126
-
|> forma.data([#("a", "1"), #("b", "string")])
127
-
|> forma.parse
128
-
129
-
let assert [fielda, fieldb] = forma.get_inputs(f)
130
-
fielda |> should_be_field_no_error
131
-
fieldb |> should_be_field_with_error("Must be a whole number")
132
-
133
-
let assert Error(f) =
134
-
form
135
-
|> forma.data([#("a", "string"), #("b", "string")])
136
-
|> forma.parse
137
-
138
-
let assert [fielda, fieldb] = forma.get_inputs(f)
139
-
fielda |> should_be_field_with_error("Must be a whole number")
140
-
fieldb |> should_be_field_with_error("Must be a whole number")
141
-
}
142
-
143
-
pub fn parse_triple_field_form_with_error_test() {
144
-
let form =
145
-
forma.new()
146
-
|> forma.add(field("a", string_fields.integer_field()))
147
-
|> forma.add(field("b", string_fields.integer_field()))
148
-
|> forma.add(field("c", string_fields.integer_field()))
149
-
|> forma.decodes(fn(_) { fn(_) { fn(_) { 1 } } })
150
-
151
-
let assert Error(f) =
152
-
form
153
-
|> forma.data([#("a", "1"), #("b", "2"), #("c", "string")])
154
-
|> forma.parse
155
-
let assert [fielda, fieldb, fieldc] = forma.get_inputs(f)
156
-
fielda |> should_be_field_no_error
157
-
fieldb |> should_be_field_no_error
158
-
fieldc |> should_be_field_with_error("Must be a whole number")
159
-
160
-
let assert Error(f) =
161
-
form
162
-
|> forma.data([#("a", "1"), #("b", "string"), #("c", "string")])
163
-
|> forma.parse
164
-
let assert [fielda, fieldb, fieldc] = forma.get_inputs(f)
165
-
fielda |> should_be_field_no_error
166
-
fieldb |> should_be_field_with_error("Must be a whole number")
167
-
fieldc |> should_be_field_with_error("Must be a whole number")
168
-
169
-
let assert Error(f) =
170
-
form
171
-
|> forma.data([#("a", "1"), #("b", "string"), #("c", "3")])
172
-
|> forma.parse
173
-
let assert [fielda, fieldb, fieldc] = forma.get_inputs(f)
174
-
fielda |> should_be_field_no_error
175
-
fieldb |> should_be_field_with_error("Must be a whole number")
176
-
fieldc |> should_be_field_no_error
177
-
178
-
let assert Error(f) =
179
-
form
180
-
|> forma.data([#("a", "string"), #("b", "string"), #("c", "3")])
181
-
|> forma.parse
182
-
let assert [fielda, fieldb, fieldc] = forma.get_inputs(f)
183
-
fielda |> should_be_field_with_error("Must be a whole number")
184
-
fieldb |> should_be_field_with_error("Must be a whole number")
185
-
fieldc |> should_be_field_no_error
186
-
187
-
let assert Error(f) =
188
-
form
189
-
|> forma.data([#("a", "string"), #("b", "2"), #("c", "3")])
190
-
|> forma.parse
191
-
let assert [fielda, fieldb, fieldc] = forma.get_inputs(f)
192
-
fielda |> should_be_field_with_error("Must be a whole number")
193
-
fieldb |> should_be_field_no_error
194
-
fieldc |> should_be_field_no_error
195
-
}
196
-
197
-
fn should_be_field_no_error(field: input.Input(String)) {
198
-
should.equal(
199
-
field,
200
-
input.Input(
201
-
name: field.name,
202
-
label: field.label,
203
-
help_text: field.help_text,
204
-
value: field.value,
205
-
render: field.render,
206
-
),
207
-
)
208
-
}
209
-
210
-
fn should_be_field_with_error(field: input.Input(String), str: String) {
211
-
should.equal(
212
-
field,
213
-
input.InvalidInput(
214
-
name: field.name,
215
-
label: field.label,
216
-
help_text: field.help_text,
217
-
value: field.value,
218
-
render: field.render,
219
-
error: str,
220
-
),
221
-
)
222
-
}
223
-
224
-
pub fn parse_and_try_test() {
225
-
let f =
226
-
forma.new()
227
-
|> forma.add(field("a", string_fields.integer_field()))
228
-
|> forma.add(field("b", string_fields.integer_field()))
229
-
|> forma.add(field("c", string_fields.integer_field()))
230
-
|> forma.decodes(fn(_) { fn(_) { fn(_) { 1 } } })
231
-
|> forma.data([#("a", "1"), #("b", "2"), #("c", "3")])
232
-
233
-
// can succeed
234
-
forma.parse_and_try(f, fn(_, _) { Ok(3) })
235
-
|> should.equal(Ok(3))
236
-
237
-
// can change type
238
-
forma.parse_and_try(f, fn(_, _) { Ok("it worked") })
239
-
|> should.equal(Ok("it worked"))
240
-
241
-
// can error
242
-
forma.parse_and_try(f, fn(_, form) { Error(form) })
243
-
|> should.equal(Error(f))
244
-
245
-
// can change field
246
-
let assert Error(form) =
247
-
forma.parse_and_try(f, fn(_, form) {
248
-
Error(forma.update_input(form, "a", input.set_error(_, "woops")))
249
-
})
250
-
let assert [fielda, fieldb, fieldc] = forma.get_inputs(form)
251
-
fielda |> should_be_field_with_error("woops")
252
-
fieldb |> should_be_field_no_error
253
-
fieldc |> should_be_field_no_error
254
-
}
+70
-70
forma/test/forma/forma_use/forma_test.gleam
formz/test/formz/formz_use_test.gleam
+70
-70
forma/test/forma/forma_use/forma_test.gleam
formz/test/formz/formz_use_test.gleam
···
1
-
import forma/field.{field}
2
-
import forma/forma_use/forma
3
-
import forma/input
4
-
import forma/string_fields
5
-
import forma/validation
1
+
import formz/field.{field}
2
+
import formz/formz_use as formz
3
+
import formz/input
4
+
import formz/string_fields
5
+
import formz/validation
6
6
import gleam/option
7
7
import gleeunit
8
8
import gleeunit/should
···
35
35
}
36
36
37
37
fn get_form_from_error_result(
38
-
result: Result(output, forma.Form(format, output)),
39
-
) -> forma.Form(format, output) {
38
+
result: Result(output, formz.Form(format, output)),
39
+
) -> formz.Form(format, output) {
40
40
let assert Error(form) = result
41
41
form
42
42
}
···
46
46
}
47
47
48
48
fn empty_form(val) {
49
-
forma.create_form(val)
49
+
formz.create_form(val)
50
50
}
51
51
52
52
fn one_field_form() {
53
-
use a <- forma.with(field("a", string_fields.text_field()))
54
-
forma.create_form("hello " <> a)
53
+
use a <- formz.with(field("a", string_fields.text_field()))
54
+
formz.create_form("hello " <> a)
55
55
}
56
56
57
57
fn two_field_form() {
58
58
{
59
-
use a <- forma.with(field("a", string_fields.text_field()))
60
-
use b <- forma.with(field("b", string_fields.text_field()))
59
+
use a <- formz.with(field("a", string_fields.text_field()))
60
+
use b <- formz.with(field("b", string_fields.text_field()))
61
61
62
-
forma.create_form(#(a, b))
62
+
formz.create_form(#(a, b))
63
63
}
64
64
}
65
65
66
66
fn three_field_form() {
67
-
use a <- forma.with(
67
+
use a <- formz.with(
68
68
field("x", string_fields.text_field())
69
69
|> field.name("a")
70
70
|> field.label("A")
71
71
|> field.validate(validation.must_be_longer_than(3)),
72
72
)
73
-
use b <- forma.with(field("b", string_fields.integer_field()))
74
-
use c <- forma.with(field.full(
73
+
use b <- formz.with(field("b", string_fields.integer_field()))
74
+
use c <- formz.with(field.full(
75
75
"c",
76
76
"C",
77
77
"help!",
78
78
string_fields.number_field(),
79
79
))
80
80
81
-
forma.create_form(#(a, b, c))
81
+
formz.create_form(#(a, b, c))
82
82
}
83
83
84
84
pub fn empty_form_test() {
85
85
empty_form(1)
86
-
|> forma.get_inputs
86
+
|> formz.get_inputs
87
87
|> should.equal([])
88
88
}
89
89
90
90
pub fn parse_empty_form_test() {
91
91
empty_form(1)
92
-
|> forma.data([])
93
-
|> forma.parse
92
+
|> formz.data([])
93
+
|> formz.parse
94
94
|> should.equal(Ok(1))
95
95
96
96
empty_form("hello")
97
-
|> forma.data([])
98
-
|> forma.parse
97
+
|> formz.data([])
98
+
|> formz.parse
99
99
|> should.equal(Ok("hello"))
100
100
}
101
101
102
102
pub fn parse_single_field_form_test() {
103
103
one_field_form()
104
-
|> forma.data([#("a", "world")])
105
-
|> forma.parse
104
+
|> formz.data([#("a", "world")])
105
+
|> formz.parse
106
106
|> should.equal(Ok("hello world"))
107
107
108
108
one_field_form()
109
-
|> forma.data([#("a", "ignored"), #("a", "world")])
110
-
|> forma.parse
109
+
|> formz.data([#("a", "ignored"), #("a", "world")])
110
+
|> formz.parse
111
111
|> should.equal(Ok("hello world"))
112
112
}
113
113
114
114
pub fn parse_double_field_form_test() {
115
115
two_field_form()
116
-
|> forma.data([#("a", "hello"), #("b", "world")])
117
-
|> forma.parse
116
+
|> formz.data([#("a", "hello"), #("b", "world")])
117
+
|> formz.parse
118
118
|> should.equal(Ok(#("hello", "world")))
119
119
120
120
// wrong order
121
121
two_field_form()
122
-
|> forma.data([#("b", "world"), #("a", "hello")])
123
-
|> forma.parse
122
+
|> formz.data([#("b", "world"), #("a", "hello")])
123
+
|> formz.parse
124
124
|> should.equal(Ok(#("hello", "world")))
125
125
126
126
// takes second
127
127
two_field_form()
128
-
|> forma.data([
128
+
|> formz.data([
129
129
#("a", "ignored"),
130
130
#("b", "ignored"),
131
131
#("b", "world"),
132
132
#("a", "hello"),
133
133
])
134
-
|> forma.parse
134
+
|> formz.parse
135
135
|> should.equal(Ok(#("hello", "world")))
136
136
}
137
137
138
138
pub fn parse_double_optional_field_form_test() {
139
139
let f = {
140
-
use a <- forma.with(
140
+
use a <- formz.with(
141
141
field("a", string_fields.text_field()) |> field.optional,
142
142
)
143
-
use b <- forma.with(
143
+
use b <- formz.with(
144
144
field("b", string_fields.text_field()) |> field.optional,
145
145
)
146
146
147
-
forma.create_form(#(a, b))
147
+
formz.create_form(#(a, b))
148
148
}
149
149
150
150
f
151
-
|> forma.data([#("a", "hello"), #("b", "world")])
152
-
|> forma.parse
151
+
|> formz.data([#("a", "hello"), #("b", "world")])
152
+
|> formz.parse
153
153
|> should.equal(Ok(#(option.Some("hello"), option.Some("world"))))
154
154
155
155
// missing second
156
156
f
157
-
|> forma.data([#("a", "hello")])
158
-
|> forma.parse
157
+
|> formz.data([#("a", "hello")])
158
+
|> formz.parse
159
159
|> should.equal(Ok(#(option.Some("hello"), option.None)))
160
160
161
161
// missing first
162
162
f
163
-
|> forma.data([#("b", "world")])
164
-
|> forma.parse
163
+
|> formz.data([#("b", "world")])
164
+
|> formz.parse
165
165
|> should.equal(Ok(#(option.None, option.Some("world"))))
166
166
167
167
// missing both
168
168
f
169
-
|> forma.data([])
170
-
|> forma.parse
169
+
|> formz.data([])
170
+
|> formz.parse
171
171
|> should.equal(Ok(#(option.None, option.None)))
172
172
}
173
173
174
174
pub fn parse_single_field_form_with_error_test() {
175
175
let assert Error(f) =
176
176
{
177
-
use a <- forma.with(field("a", string_fields.integer_field()))
178
-
forma.create_form(a)
177
+
use a <- formz.with(field("a", string_fields.integer_field()))
178
+
formz.create_form(a)
179
179
}
180
-
|> forma.data([#("first", "world")])
181
-
|> forma.parse
180
+
|> formz.data([#("first", "world")])
181
+
|> formz.parse
182
182
183
-
let assert [field] = forma.get_inputs(f)
183
+
let assert [field] = formz.get_inputs(f)
184
184
field |> should_be_field_with_error("Must be a whole number")
185
185
}
186
186
187
187
pub fn parse_triple_field_form_with_error_test() {
188
188
let assert [fielda, fieldb, fieldc] =
189
189
three_field_form()
190
-
|> forma.data([#("a", "string"), #("b", "1"), #("c", "string")])
191
-
|> forma.parse
190
+
|> formz.data([#("a", "string"), #("b", "1"), #("c", "string")])
191
+
|> formz.parse
192
192
|> get_form_from_error_result
193
-
|> forma.get_inputs
193
+
|> formz.get_inputs
194
194
195
195
fielda |> should_be_field_no_error
196
196
fieldb |> should_be_field_no_error
···
198
198
199
199
let assert [fielda, fieldb, fieldc] =
200
200
three_field_form()
201
-
|> forma.data([#("a", "string"), #("b", "string"), #("c", "string")])
202
-
|> forma.parse
201
+
|> formz.data([#("a", "string"), #("b", "string"), #("c", "string")])
202
+
|> formz.parse
203
203
|> get_form_from_error_result
204
-
|> forma.get_inputs
204
+
|> formz.get_inputs
205
205
fielda |> should_be_field_no_error
206
206
fieldb |> should_be_field_with_error("Must be a whole number")
207
207
fieldc |> should_be_field_with_error("Must be a number")
208
208
209
209
let assert [fielda, fieldb, fieldc] =
210
210
three_field_form()
211
-
|> forma.data([#("a", "string"), #("b", "string"), #("c", "3.4")])
212
-
|> forma.parse
211
+
|> formz.data([#("a", "string"), #("b", "string"), #("c", "3.4")])
212
+
|> formz.parse
213
213
|> get_form_from_error_result
214
-
|> forma.get_inputs
214
+
|> formz.get_inputs
215
215
fielda |> should_be_field_no_error
216
216
fieldb |> should_be_field_with_error("Must be a whole number")
217
217
fieldc |> should_be_field_no_error
218
218
219
219
let assert [fielda, fieldb, fieldc] =
220
220
three_field_form()
221
-
|> forma.data([#("a", "."), #("b", "string"), #("c", "3.4")])
222
-
|> forma.parse
221
+
|> formz.data([#("a", "."), #("b", "string"), #("c", "3.4")])
222
+
|> formz.parse
223
223
|> get_form_from_error_result
224
-
|> forma.get_inputs
224
+
|> formz.get_inputs
225
225
fielda |> should_be_field_with_error("Must be longer than 3 characters")
226
226
fieldb |> should_be_field_with_error("Must be a whole number")
227
227
fieldc |> should_be_field_no_error
228
228
229
229
let assert [fielda, fieldb, fieldc] =
230
230
three_field_form()
231
-
|> forma.data([#("a", "."), #("b", "1"), #("c", "3.4")])
232
-
|> forma.parse
231
+
|> formz.data([#("a", "."), #("b", "1"), #("c", "3.4")])
232
+
|> formz.parse
233
233
|> get_form_from_error_result
234
-
|> forma.get_inputs
234
+
|> formz.get_inputs
235
235
fielda |> should_be_field_with_error("Must be longer than 3 characters")
236
236
fieldb |> should_be_field_no_error
237
237
fieldc |> should_be_field_no_error
···
240
240
pub fn decoded_and_try_test() {
241
241
let f =
242
242
three_field_form()
243
-
|> forma.data([#("a", "string"), #("b", "2"), #("c", "3.0")])
243
+
|> formz.data([#("a", "string"), #("b", "2"), #("c", "3.0")])
244
244
245
245
// can succeed
246
-
forma.parse_and_try(f, fn(_, _) { Ok(3) })
246
+
formz.parse_and_try(f, fn(_, _) { Ok(3) })
247
247
|> should.equal(Ok(3))
248
248
249
249
// can change type
250
-
forma.parse_and_try(f, fn(_, _) { Ok("it worked") })
250
+
formz.parse_and_try(f, fn(_, _) { Ok("it worked") })
251
251
|> should.equal(Ok("it worked"))
252
252
253
253
// can error
254
-
forma.parse_and_try(f, fn(_, form) { Error(form) })
254
+
formz.parse_and_try(f, fn(_, form) { Error(form) })
255
255
|> should.equal(Error(f))
256
256
257
257
// can change field
258
258
let assert Error(form) =
259
-
forma.parse_and_try(f, fn(_, form) {
259
+
formz.parse_and_try(f, fn(_, form) {
260
260
form
261
-
|> forma.update_input("a", input.set_error(_, "woops"))
261
+
|> formz.update_input("a", input.set_error(_, "woops"))
262
262
|> Error
263
263
})
264
-
let assert [fielda, fieldb, fieldc] = forma.get_inputs(form)
264
+
let assert [fielda, fieldb, fieldc] = formz.get_inputs(form)
265
265
fielda |> should_be_field_with_error("woops")
266
266
fieldb |> should_be_field_no_error
267
267
fieldc |> should_be_field_no_error
+1
-1
forma/test/forma/validation_test.gleam
formz/test/formz/validation_test.gleam
+1
-1
forma/test/forma/validation_test.gleam
formz/test/formz/validation_test.gleam
-10
forma/test/forma_test.gleam
-10
forma/test/forma_test.gleam
+24
formz/README.md
+24
formz/README.md
···
1
+
# formz
2
+
3
+
[](https://hex.pm/packages/formz)
4
+
[](https://hexdocs.pm/formz/)
5
+
6
+
```sh
7
+
gleam add formz@1
8
+
```
9
+
```gleam
10
+
import formz
11
+
12
+
pub fn main() {
13
+
// TODO: An example of the project in use
14
+
}
15
+
```
16
+
17
+
Further documentation can be found at <https://hexdocs.pm/formz>.
18
+
19
+
## Development
20
+
21
+
```sh
22
+
gleam run # Run the project
23
+
gleam test # Run the tests
24
+
```
+5
formz/src/formz.gleam
+5
formz/src/formz.gleam
+254
formz/test/formz/formz_pipes_test.gleam
+254
formz/test/formz/formz_pipes_test.gleam
···
1
+
import formz/field.{field}
2
+
import formz/formz_pipes as formz
3
+
import formz/input
4
+
import formz/string_fields
5
+
import gleam/list
6
+
import gleeunit
7
+
import gleeunit/should
8
+
9
+
pub fn main() {
10
+
gleeunit.main()
11
+
}
12
+
13
+
pub fn empty_form_test() {
14
+
formz.new()
15
+
|> formz.get_inputs
16
+
|> list.length
17
+
|> should.equal(0)
18
+
}
19
+
20
+
pub fn parse_empty_form_test() {
21
+
formz.new()
22
+
|> formz.data([])
23
+
|> formz.decodes(1)
24
+
|> formz.parse
25
+
|> should.equal(Ok(1))
26
+
27
+
formz.new()
28
+
|> formz.data([])
29
+
|> formz.decodes("Hello")
30
+
|> formz.parse
31
+
|> should.equal(Ok("Hello"))
32
+
}
33
+
34
+
pub fn parse_single_field_form_test() {
35
+
formz.new()
36
+
|> formz.add(field("first", string_fields.text_field()))
37
+
|> formz.data([#("first", "world")])
38
+
|> formz.decodes(fn(str) { "hello " <> str })
39
+
|> formz.parse
40
+
|> should.equal(Ok("hello world"))
41
+
}
42
+
43
+
pub fn parse_double_field_form_test() {
44
+
formz.new()
45
+
|> formz.add(field("first", string_fields.text_field()))
46
+
|> formz.add(field("second", string_fields.text_field()))
47
+
|> formz.data([#("first", "hello"), #("second", "world")])
48
+
|> formz.decodes(fn(a) { fn(b) { a <> " " <> b } })
49
+
|> formz.parse
50
+
|> should.equal(Ok("hello world"))
51
+
}
52
+
53
+
pub fn parse_double_field_form_extra_data_test() {
54
+
formz.new()
55
+
|> formz.add(field("first", string_fields.text_field()))
56
+
|> formz.add(field("second", string_fields.text_field()))
57
+
|> formz.data([#("first", "1"), #("second", "2")])
58
+
|> formz.decodes(fn(a) { fn(b) { a <> " " <> b } })
59
+
|> formz.parse
60
+
|> should.equal(Ok("1 2"))
61
+
62
+
formz.new()
63
+
|> formz.add(field("first", string_fields.text_field()))
64
+
|> formz.add(field("second", string_fields.text_field()))
65
+
|> formz.data([#("first", "1"), #("second", "2"), #("second", "3")])
66
+
|> formz.decodes(fn(a) { fn(b) { a <> " " <> b } })
67
+
|> formz.parse
68
+
|> should.equal(Ok("1 2"))
69
+
}
70
+
71
+
pub fn integer_field_test() {
72
+
formz.new()
73
+
|> formz.add(field("first", string_fields.integer_field()))
74
+
|> formz.data([#("first", " 1 ")])
75
+
|> formz.decodes(fn(i) { i })
76
+
|> formz.parse
77
+
|> should.equal(Ok(1))
78
+
}
79
+
80
+
pub fn can_decodes_in_any_order_test() {
81
+
formz.new()
82
+
|> formz.decodes(fn(str) { "hello " <> str })
83
+
|> formz.add(field("first", string_fields.text_field()))
84
+
|> formz.data([#("first", "world")])
85
+
|> formz.parse
86
+
|> should.equal(Ok("hello world"))
87
+
88
+
formz.new()
89
+
|> formz.add(field("first", string_fields.text_field()))
90
+
|> formz.data([#("first", "world")])
91
+
|> formz.decodes(fn(str) { "hello " <> str })
92
+
|> formz.parse
93
+
|> should.equal(Ok("hello world"))
94
+
}
95
+
96
+
pub fn parse_single_field_form_with_error_test() {
97
+
let assert Error(f) =
98
+
formz.new()
99
+
|> formz.add(field("first", string_fields.integer_field()))
100
+
|> formz.data([#("first", "world")])
101
+
|> formz.decodes(fn(_) { 1 })
102
+
|> formz.parse
103
+
104
+
let assert [field] = formz.get_inputs(f)
105
+
field |> should_be_field_with_error("Must be a whole number")
106
+
}
107
+
108
+
pub fn parse_double_field_form_with_error_test() {
109
+
let form =
110
+
formz.new()
111
+
|> formz.add(field("a", string_fields.integer_field()))
112
+
|> formz.add(field("b", string_fields.integer_field()))
113
+
|> formz.decodes(fn(_) { fn(_) { 1 } })
114
+
115
+
let assert Error(f) =
116
+
form
117
+
|> formz.data([#("a", "not a number"), #("b", "2")])
118
+
|> formz.parse
119
+
120
+
let assert [fielda, fieldb] = formz.get_inputs(f)
121
+
fielda |> should_be_field_with_error("Must be a whole number")
122
+
fieldb |> should_be_field_no_error
123
+
124
+
let assert Error(f) =
125
+
form
126
+
|> formz.data([#("a", "1"), #("b", "string")])
127
+
|> formz.parse
128
+
129
+
let assert [fielda, fieldb] = formz.get_inputs(f)
130
+
fielda |> should_be_field_no_error
131
+
fieldb |> should_be_field_with_error("Must be a whole number")
132
+
133
+
let assert Error(f) =
134
+
form
135
+
|> formz.data([#("a", "string"), #("b", "string")])
136
+
|> formz.parse
137
+
138
+
let assert [fielda, fieldb] = formz.get_inputs(f)
139
+
fielda |> should_be_field_with_error("Must be a whole number")
140
+
fieldb |> should_be_field_with_error("Must be a whole number")
141
+
}
142
+
143
+
pub fn parse_triple_field_form_with_error_test() {
144
+
let form =
145
+
formz.new()
146
+
|> formz.add(field("a", string_fields.integer_field()))
147
+
|> formz.add(field("b", string_fields.integer_field()))
148
+
|> formz.add(field("c", string_fields.integer_field()))
149
+
|> formz.decodes(fn(_) { fn(_) { fn(_) { 1 } } })
150
+
151
+
let assert Error(f) =
152
+
form
153
+
|> formz.data([#("a", "1"), #("b", "2"), #("c", "string")])
154
+
|> formz.parse
155
+
let assert [fielda, fieldb, fieldc] = formz.get_inputs(f)
156
+
fielda |> should_be_field_no_error
157
+
fieldb |> should_be_field_no_error
158
+
fieldc |> should_be_field_with_error("Must be a whole number")
159
+
160
+
let assert Error(f) =
161
+
form
162
+
|> formz.data([#("a", "1"), #("b", "string"), #("c", "string")])
163
+
|> formz.parse
164
+
let assert [fielda, fieldb, fieldc] = formz.get_inputs(f)
165
+
fielda |> should_be_field_no_error
166
+
fieldb |> should_be_field_with_error("Must be a whole number")
167
+
fieldc |> should_be_field_with_error("Must be a whole number")
168
+
169
+
let assert Error(f) =
170
+
form
171
+
|> formz.data([#("a", "1"), #("b", "string"), #("c", "3")])
172
+
|> formz.parse
173
+
let assert [fielda, fieldb, fieldc] = formz.get_inputs(f)
174
+
fielda |> should_be_field_no_error
175
+
fieldb |> should_be_field_with_error("Must be a whole number")
176
+
fieldc |> should_be_field_no_error
177
+
178
+
let assert Error(f) =
179
+
form
180
+
|> formz.data([#("a", "string"), #("b", "string"), #("c", "3")])
181
+
|> formz.parse
182
+
let assert [fielda, fieldb, fieldc] = formz.get_inputs(f)
183
+
fielda |> should_be_field_with_error("Must be a whole number")
184
+
fieldb |> should_be_field_with_error("Must be a whole number")
185
+
fieldc |> should_be_field_no_error
186
+
187
+
let assert Error(f) =
188
+
form
189
+
|> formz.data([#("a", "string"), #("b", "2"), #("c", "3")])
190
+
|> formz.parse
191
+
let assert [fielda, fieldb, fieldc] = formz.get_inputs(f)
192
+
fielda |> should_be_field_with_error("Must be a whole number")
193
+
fieldb |> should_be_field_no_error
194
+
fieldc |> should_be_field_no_error
195
+
}
196
+
197
+
fn should_be_field_no_error(field: input.Input(String)) {
198
+
should.equal(
199
+
field,
200
+
input.Input(
201
+
name: field.name,
202
+
label: field.label,
203
+
help_text: field.help_text,
204
+
value: field.value,
205
+
render: field.render,
206
+
),
207
+
)
208
+
}
209
+
210
+
fn should_be_field_with_error(field: input.Input(String), str: String) {
211
+
should.equal(
212
+
field,
213
+
input.InvalidInput(
214
+
name: field.name,
215
+
label: field.label,
216
+
help_text: field.help_text,
217
+
value: field.value,
218
+
render: field.render,
219
+
error: str,
220
+
),
221
+
)
222
+
}
223
+
224
+
pub fn parse_and_try_test() {
225
+
let f =
226
+
formz.new()
227
+
|> formz.add(field("a", string_fields.integer_field()))
228
+
|> formz.add(field("b", string_fields.integer_field()))
229
+
|> formz.add(field("c", string_fields.integer_field()))
230
+
|> formz.decodes(fn(_) { fn(_) { fn(_) { 1 } } })
231
+
|> formz.data([#("a", "1"), #("b", "2"), #("c", "3")])
232
+
233
+
// can succeed
234
+
formz.parse_and_try(f, fn(_, _) { Ok(3) })
235
+
|> should.equal(Ok(3))
236
+
237
+
// can change type
238
+
formz.parse_and_try(f, fn(_, _) { Ok("it worked") })
239
+
|> should.equal(Ok("it worked"))
240
+
241
+
// can error
242
+
formz.parse_and_try(f, fn(_, form) { Error(form) })
243
+
|> should.equal(Error(f))
244
+
245
+
// can change field
246
+
let assert Error(form) =
247
+
formz.parse_and_try(f, fn(_, form) {
248
+
Error(formz.update_input(form, "a", input.set_error(_, "woops")))
249
+
})
250
+
let assert [fielda, fieldb, fieldc] = formz.get_inputs(form)
251
+
fielda |> should_be_field_with_error("woops")
252
+
fieldb |> should_be_field_no_error
253
+
fieldc |> should_be_field_no_error
254
+
}