this repo has no description
4
fork

Configure Feed

Select the types of activity you want to include in your feed.

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
··· 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
··· 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
··· 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
··· 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 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
··· 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 }