12 |
13 |
19 |
20 |
23 |
24 |
✎
29 |
30 |
35 |
36 |
37 |
45 |
58 | ",
59 | )
60 | let builder = case item.any_completed(counts) {
61 | True -> {
62 | let builder =
63 | string_builder.append(
64 | builder,
65 | "
66 | Clear Completed (",
67 | )
68 | let builder =
69 | string_builder.append(builder, int.to_string(counts.completed))
70 | let builder =
71 | string_builder.append(
72 | builder,
73 | ")
74 | ",
75 | )
76 |
77 | builder
78 | }
79 | False -> {
80 | builder
81 | }
82 | }
83 | let builder =
84 | string_builder.append(
85 | builder,
86 | "
87 |
88 |
89 |
90 | ",
91 | )
92 | let builder = string_builder.append(builder, int.to_string(counts.active))
93 | let builder =
94 | string_builder.append(
95 | builder,
96 | " todos left
97 |
98 | ",
99 | )
100 |
101 | builder
102 | }
103 |
104 | pub fn render(
105 | item item: Item,
106 | counts counts: Counts,
107 | display display: Bool,
108 | ) -> String {
109 | string_builder.to_string(render_builder(
110 | item: item,
111 | counts: counts,
112 | display: display,
113 | ))
114 | }
115 |
--------------------------------------------------------------------------------
/src/todomvc/templates/item_changed.matcha:
--------------------------------------------------------------------------------
1 | {> with item as Item
2 | {> with counts as Counts
3 | {> with display as Bool
4 |
5 | {> import todomvc/templates/item as item_template
6 | {> import todomvc/item.{Item, Counts}
7 | {> import gleam/int
8 |
9 | {% if display %}
10 | {[ item_template.render_builder(item,False) ]}
11 | {% endif %}
12 |
13 |
14 | {% if item.any_completed(counts) %}
15 | Clear Completed ({{ int.to_string(counts.completed) }})
16 | {% endif %}
17 |
18 |
19 |
20 | {{ int.to_string(counts.active) }} todos left
21 |
22 |
--------------------------------------------------------------------------------
/src/todomvc/templates/item_created.gleam:
--------------------------------------------------------------------------------
1 | // DO NOT EDIT: Code generated by matcha from item_created.matcha
2 |
3 | import gleam/int
4 | import gleam/string_builder.{type StringBuilder}
5 | import todomvc/item.{type Counts, type Item}
6 | import todomvc/templates/item as item_template
7 |
8 | pub fn render_builder(
9 | item item: Item,
10 | counts counts: Counts,
11 | display display: Bool,
12 | ) -> StringBuilder {
13 | let builder = string_builder.from_string("")
14 | let builder =
15 | string_builder.append(
16 | builder,
17 | "
18 | ",
19 | )
20 | let builder =
21 | string_builder.append(
22 | builder,
23 | "
24 |
33 |
34 | ",
35 | )
36 | let builder = case display {
37 | True -> {
38 | let builder =
39 | string_builder.append(
40 | builder,
41 | "
42 |
43 | ",
44 | )
45 | let builder =
46 | string_builder.append_builder(
47 | builder,
48 | item_template.render_builder(item, False),
49 | )
50 | let builder =
51 | string_builder.append(
52 | builder,
53 | "
54 |
55 | ",
56 | )
57 |
58 | builder
59 | }
60 | False -> {
61 | builder
62 | }
63 | }
64 | let builder =
65 | string_builder.append(
66 | builder,
67 | "
68 |
69 |
70 | ",
71 | )
72 | let builder = case item.any_completed(counts) {
73 | True -> {
74 | let builder =
75 | string_builder.append(
76 | builder,
77 | "
78 | Clear Completed (",
79 | )
80 | let builder =
81 | string_builder.append(builder, int.to_string(counts.completed))
82 | let builder =
83 | string_builder.append(
84 | builder,
85 | ")
86 | ",
87 | )
88 |
89 | builder
90 | }
91 | False -> {
92 | builder
93 | }
94 | }
95 | let builder =
96 | string_builder.append(
97 | builder,
98 | "
99 |
100 |
101 |
102 | ",
103 | )
104 | let builder = string_builder.append(builder, int.to_string(counts.active))
105 | let builder =
106 | string_builder.append(
107 | builder,
108 | " todos left
109 |
110 | ",
111 | )
112 |
113 | builder
114 | }
115 |
116 | pub fn render(
117 | item item: Item,
118 | counts counts: Counts,
119 | display display: Bool,
120 | ) -> String {
121 | string_builder.to_string(render_builder(
122 | item: item,
123 | counts: counts,
124 | display: display,
125 | ))
126 | }
127 |
--------------------------------------------------------------------------------
/src/todomvc/templates/item_created.matcha:
--------------------------------------------------------------------------------
1 | {> with item as Item
2 | {> with counts as Counts
3 | {> with display as Bool
4 |
5 | {> import todomvc/templates/item as item_template
6 | {> import todomvc/item.{Item, Counts}
7 | {> import gleam/int
8 |
9 |
18 |
19 | {% if display %}
20 |
21 | {[ item_template.render_builder(item,False) ]}
22 |
23 | {% endif %}
24 |
25 |
26 | {% if item.any_completed(counts) %}
27 | Clear Completed ({{ int.to_string(counts.completed) }})
28 | {% endif %}
29 |
30 |
31 |
32 | {{ int.to_string(counts.active) }} todos left
33 |
34 |
--------------------------------------------------------------------------------
/src/todomvc/templates/item_deleted.gleam:
--------------------------------------------------------------------------------
1 | // DO NOT EDIT: Code generated by matcha from item_deleted.matcha
2 |
3 | import gleam/int
4 | import gleam/string_builder.{type StringBuilder}
5 | import todomvc/item.{type Counts}
6 |
7 | pub fn render_builder(counts counts: Counts) -> StringBuilder {
8 | let builder = string_builder.from_string("")
9 | let builder =
10 | string_builder.append(
11 | builder,
12 | "
13 | ",
14 | )
15 | let builder =
16 | string_builder.append(
17 | builder,
18 | "
19 |
20 | ",
21 | )
22 | let builder = case item.any_completed(counts) {
23 | True -> {
24 | let builder =
25 | string_builder.append(
26 | builder,
27 | "
28 | Clear Completed (",
29 | )
30 | let builder =
31 | string_builder.append(builder, int.to_string(counts.completed))
32 | let builder =
33 | string_builder.append(
34 | builder,
35 | ")
36 | ",
37 | )
38 |
39 | builder
40 | }
41 | False -> {
42 | builder
43 | }
44 | }
45 | let builder =
46 | string_builder.append(
47 | builder,
48 | "
49 |
50 |
51 |
52 | ",
53 | )
54 | let builder = string_builder.append(builder, int.to_string(counts.active))
55 | let builder =
56 | string_builder.append(
57 | builder,
58 | " todos left
59 |
60 | ",
61 | )
62 |
63 | builder
64 | }
65 |
66 | pub fn render(counts counts: Counts) -> String {
67 | string_builder.to_string(render_builder(counts: counts))
68 | }
69 |
--------------------------------------------------------------------------------
/src/todomvc/templates/item_deleted.matcha:
--------------------------------------------------------------------------------
1 | {> with counts as Counts
2 |
3 | {> import todomvc/item.{Counts}
4 | {> import gleam/int
5 |
6 |
7 | {% if item.any_completed(counts) %}
8 | Clear Completed ({{ int.to_string(counts.completed) }})
9 | {% endif %}
10 |
11 |
12 |
13 | {{ int.to_string(counts.active) }} todos left
14 |
15 |
--------------------------------------------------------------------------------
/src/todomvc/user.gleam:
--------------------------------------------------------------------------------
1 | import gleam/dynamic
2 | import sqlight
3 |
4 | /// Insert a new user, returning their id.
5 | ///
6 | pub fn insert_user(db: sqlight.Connection) -> Int {
7 | let sql =
8 | "
9 | insert into users
10 | default values
11 | returning id;
12 | "
13 | let assert Ok([id]) =
14 | sqlight.query(
15 | sql,
16 | on: db,
17 | with: [],
18 | expecting: dynamic.element(0, dynamic.int),
19 | )
20 |
21 | id
22 | }
23 |
--------------------------------------------------------------------------------
/src/todomvc/web.gleam:
--------------------------------------------------------------------------------
1 | //// Various helper functions for use in the web interface of the application.
2 | ////
3 |
4 | import gleam/http.{Http}
5 | import gleam/http/cookie
6 | import gleam/http/response
7 | import gleam/int
8 | import gleam/list
9 | import gleam/option
10 | import gleam/result
11 | import todomvc/database
12 | import todomvc/error.{type AppError}
13 | import todomvc/user
14 | import wisp.{type Request, type Response}
15 |
16 | pub type Context {
17 | Context(db: database.Connection, user_id: Int, static_path: String)
18 | }
19 |
20 | const uid_cookie = "uid"
21 |
22 | /// Load the user from the `uid` cookie if set, otherwise create a new user row
23 | /// and assign that in the response cookies.
24 | ///
25 | /// The `uid` cookie is signed to prevent tampering.
26 | ///
27 | pub fn authenticate(
28 | req: Request,
29 | ctx: Context,
30 | next: fn(Context) -> Response,
31 | ) -> Response {
32 | let id =
33 | wisp.get_cookie(req, uid_cookie, wisp.Signed)
34 | |> result.try(int.parse)
35 | |> option.from_result
36 |
37 | let #(id, new_user) = case id {
38 | option.None -> {
39 | wisp.log_info("Creating a new user")
40 | let user = user.insert_user(ctx.db)
41 | #(user, True)
42 | }
43 | option.Some(id) -> #(id, False)
44 | }
45 | let context = Context(..ctx, user_id: id)
46 | let resp = next(context)
47 |
48 | case new_user {
49 | True -> {
50 | let id = int.to_string(id)
51 | let year = 60 * 60 * 24 * 365
52 | wisp.set_cookie(resp, req, uid_cookie, id, wisp.Signed, year)
53 | }
54 | False -> resp
55 | }
56 | }
57 |
58 | pub type AppResult =
59 | Result(Response, AppError)
60 |
61 | pub fn result_to_response(result: AppResult) -> Response {
62 | case result {
63 | Ok(response) -> response
64 | Error(error) -> error_to_response(error)
65 | }
66 | }
67 |
68 | pub fn try_(result: Result(t, AppError), next: fn(t) -> Response) -> Response {
69 | case result {
70 | Ok(t) -> next(t)
71 | Error(error) -> error_to_response(error)
72 | }
73 | }
74 |
75 | /// Return an appropriate HTTP response for a given error.
76 | ///
77 | pub fn error_to_response(error: AppError) -> Response {
78 | case error {
79 | error.UserNotFound -> user_not_found()
80 | error.NotFound -> wisp.not_found()
81 | error.MethodNotAllowed -> wisp.method_not_allowed([])
82 | error.BadRequest -> wisp.bad_request()
83 | error.UnprocessableEntity | error.ContentRequired ->
84 | wisp.unprocessable_entity()
85 | error.SqlightError(_) -> wisp.internal_server_error()
86 | }
87 | }
88 |
89 | pub fn user_not_found() -> Response {
90 | let attributes =
91 | cookie.Attributes(..cookie.defaults(Http), max_age: option.Some(0))
92 | wisp.not_found()
93 | |> response.set_cookie("uid", "", attributes)
94 | }
95 |
96 | pub fn key_find(list: List(#(k, v)), key: k) -> Result(v, AppError) {
97 | list
98 | |> list.key_find(key)
99 | |> result.replace_error(error.UnprocessableEntity)
100 | }
101 |
102 | pub fn parse_int(string: String) -> Result(Int, AppError) {
103 | string
104 | |> int.parse
105 | |> result.replace_error(error.BadRequest)
106 | }
107 |
108 | pub fn require_ok(t: Result(t, AppError), next: fn(t) -> Response) -> Response {
109 | case t {
110 | Ok(t) -> next(t)
111 | Error(error) -> error_to_response(error)
112 | }
113 | }
114 |
--------------------------------------------------------------------------------
/src/todomvc_ffi.erl:
--------------------------------------------------------------------------------
1 | -module(todomvc_ffi).
2 |
3 | -export([configure_logger_backend/0, priv_directory/0]).
4 |
5 | configure_logger_backend() ->
6 | ok = logger:set_primary_config(level, info),
7 | ok = logger:set_handler_config(default, formatter, {logger_formatter, #{
8 | template => [level, ": ", msg, "\n"]
9 | }}),
10 | ok = logger:set_application_level(stdlib, notice),
11 | nil.
12 |
13 | priv_directory() ->
14 | list_to_binary(code:priv_dir(todomvc)).
15 |
--------------------------------------------------------------------------------
/test/todomvc/item_test.gleam:
--------------------------------------------------------------------------------
1 | import gleeunit/should
2 | import todomvc/error
3 | import todomvc/item.{Item}
4 | import todomvc/tests
5 | import todomvc/user
6 |
7 | pub fn item_creation_test() {
8 | use db <- tests.with_db("")
9 | let user_id = user.insert_user(db)
10 |
11 | // A user starts with no items
12 | item.list_items(user_id, db)
13 | |> should.equal([])
14 |
15 | // Items can be added
16 | let assert Ok(id1) = item.insert_item("One", user_id, db)
17 | let assert Ok(id2) = item.insert_item("Two", user_id, db)
18 |
19 | item.list_items(user_id, db)
20 | |> should.equal([
21 | Item(id: id1, content: "One", completed: False),
22 | Item(id: id2, content: "Two", completed: False),
23 | ])
24 | }
25 |
26 | pub fn item_creation_without_content_test() {
27 | use db <- tests.with_db("")
28 | let user_id = user.insert_user(db)
29 |
30 | // Items cannot be added without content
31 | item.insert_item("", user_id, db)
32 | |> should.equal(Error(error.ContentRequired))
33 |
34 | item.list_items(user_id, db)
35 | |> should.equal([])
36 | }
37 |
38 | pub fn item_with_unknown_user_test() {
39 | use db <- tests.with_db("")
40 | // Items cannot be added for an unknown user
41 | item.insert_item("One", -1, db)
42 | |> should.equal(Error(error.UserNotFound))
43 | }
44 |
45 | pub fn toggle_test() {
46 | use db <- tests.with_db("")
47 | let user_id = user.insert_user(db)
48 |
49 | // Items can be added
50 | let assert Ok(id1) = item.insert_item("One", user_id, db)
51 |
52 | item.toggle_completion(id1, user_id, db)
53 | |> should.equal(Ok(Item(id: id1, completed: True, content: "One")))
54 | item.toggle_completion(id1, user_id, db)
55 | |> should.equal(Ok(Item(id: id1, completed: False, content: "One")))
56 | }
57 |
58 | pub fn toggle_unknown_id_test() {
59 | use db <- tests.with_db("")
60 | let user_id = user.insert_user(db)
61 |
62 | item.toggle_completion(0, user_id, db)
63 | |> should.equal(Error(error.NotFound))
64 | }
65 |
66 | pub fn toggle_user_mismatch_test() {
67 | use db <- tests.with_db("")
68 | let user_id1 = user.insert_user(db)
69 | let user_id2 = user.insert_user(db)
70 |
71 | // Items can be added
72 | let assert Ok(id1) = item.insert_item("One", user_id1, db)
73 |
74 | item.toggle_completion(id1, user_id2, db)
75 | |> should.equal(Error(error.NotFound))
76 | }
77 |
78 | pub fn counts_test() {
79 | use db <- tests.with_db("")
80 | let user_id1 = user.insert_user(db)
81 | let user_id2 = user.insert_user(db)
82 |
83 | item.get_counts(user_id1, db)
84 | |> should.equal(item.Counts(active: 0, completed: 0))
85 |
86 | let assert Ok(id1) = item.insert_item("x", user_id1, db)
87 | let assert Ok(id2) = item.insert_item("x", user_id1, db)
88 | let assert Ok(id3) = item.insert_item("x", user_id1, db)
89 | let assert Ok(_id) = item.insert_item("x", user_id1, db)
90 | let assert Ok(_id) = item.insert_item("x", user_id2, db)
91 | let assert Ok(_id) = item.insert_item("x", user_id2, db)
92 |
93 | item.get_counts(user_id1, db)
94 | |> should.equal(item.Counts(active: 4, completed: 0))
95 |
96 | let assert Ok(_) = item.toggle_completion(id1, user_id1, db)
97 | let assert Ok(_) = item.toggle_completion(id2, user_id1, db)
98 | let assert Ok(_) = item.toggle_completion(id3, user_id1, db)
99 |
100 | item.get_counts(user_id1, db)
101 | |> should.equal(item.Counts(active: 1, completed: 3))
102 | }
103 |
104 | pub fn delete_test() {
105 | use db <- tests.with_db("")
106 | let user_id = user.insert_user(db)
107 | let assert Ok(id) = item.insert_item("x", user_id, db)
108 |
109 | item.delete_item(id, user_id, db)
110 |
111 | item.list_items(user_id, db)
112 | |> should.equal([])
113 |
114 | item.delete_item(id, user_id, db)
115 | }
116 |
117 | pub fn delete_other_users_item_test() {
118 | use db <- tests.with_db("")
119 | let user_id1 = user.insert_user(db)
120 | let user_id2 = user.insert_user(db)
121 | let assert Ok(id) = item.insert_item("x", user_id1, db)
122 |
123 | // It belongs to someone else so it can't be deleted
124 | item.delete_item(id, user_id2, db)
125 |
126 | item.list_items(user_id1, db)
127 | |> should.equal([Item(id: id, completed: False, content: "x")])
128 | }
129 |
130 | pub fn delete_completed_test() {
131 | use db <- tests.with_db("")
132 | let user_id1 = user.insert_user(db)
133 | let user_id2 = user.insert_user(db)
134 |
135 | // Create a bunch of items for both users
136 | let assert Ok(id1) = item.insert_item("x", user_id1, db)
137 | let assert Ok(id2) = item.insert_item("x", user_id1, db)
138 | let assert Ok(id3) = item.insert_item("x", user_id1, db)
139 | let assert Ok(id4) = item.insert_item("x", user_id1, db)
140 | let assert Ok(id5) = item.insert_item("x", user_id2, db)
141 | let assert Ok(id6) = item.insert_item("x", user_id2, db)
142 |
143 | // Mark some items as completed for both users
144 | let assert Ok(_) = item.toggle_completion(id1, user_id1, db)
145 | let assert Ok(_) = item.toggle_completion(id2, user_id1, db)
146 | let assert Ok(_) = item.toggle_completion(id6, user_id2, db)
147 |
148 | // Delete completed items for the first user
149 | item.delete_completed(user_id1, db)
150 |
151 | // Completed items for that user have been deleted
152 | item.list_items(user_id1, db)
153 | |> should.equal([
154 | Item(id: id3, completed: False, content: "x"),
155 | Item(id: id4, completed: False, content: "x"),
156 | ])
157 |
158 | // The other user's items were not impacted
159 | item.list_items(user_id2, db)
160 | |> should.equal([
161 | Item(id: id5, completed: False, content: "x"),
162 | Item(id: id6, completed: True, content: "x"),
163 | ])
164 | }
165 |
--------------------------------------------------------------------------------
/test/todomvc/routes_test.gleam:
--------------------------------------------------------------------------------
1 | import gleam/int
2 | import gleam/string
3 | import gleeunit/should
4 | import todomvc/item
5 | import todomvc/router
6 | import todomvc/tests
7 | import todomvc/user
8 | import wisp
9 | import wisp/testing
10 |
11 | pub fn home_test() {
12 | use ctx <- tests.with_context
13 |
14 | let uid1 = user.insert_user(ctx.db)
15 | let assert Ok(_) = item.insert_item("Wibble", uid1, ctx.db)
16 | let assert Ok(_) = item.insert_item("Wobble", uid1, ctx.db)
17 | let uid2 = user.insert_user(ctx.db)
18 | let assert Ok(_) = item.insert_item("Wabble", uid2, ctx.db)
19 |
20 | let request =
21 | testing.get("/", [])
22 | |> testing.set_cookie("uid", int.to_string(uid1), wisp.Signed)
23 | let response = router.handle_request(request, ctx)
24 |
25 | response.status
26 | |> should.equal(200)
27 |
28 | let body = testing.string_body(response)
29 |
30 | body
31 | |> string.contains("Wibble")
32 | |> should.equal(True)
33 |
34 | body
35 | |> string.contains("Wobble")
36 | |> should.equal(True)
37 |
38 | // An item belonging to another user is not included
39 | body
40 | |> string.contains("Wabble")
41 | |> should.equal(False)
42 | }
43 |
--------------------------------------------------------------------------------
/test/todomvc/tests.gleam:
--------------------------------------------------------------------------------
1 | import sqlight
2 | import todomvc/database
3 | import todomvc/web.{type Context, Context}
4 |
5 | pub fn with_context(testcase: fn(Context) -> t) -> t {
6 | use db <- with_db("")
7 | let context = Context(db: db, user_id: 0, static_path: "priv/static")
8 | testcase(context)
9 | }
10 |
11 | pub fn with_db(name: String, f: fn(sqlight.Connection) -> a) -> a {
12 | use db <- database.with_connection(name)
13 | let assert Ok(_) = database.migrate_schema(db)
14 | f(db)
15 | }
16 |
--------------------------------------------------------------------------------
/test/todomvc/user_test.gleam:
--------------------------------------------------------------------------------
1 | import todomvc/tests
2 | import todomvc/user
3 |
4 | pub fn user_insertion_test() {
5 | use db <- tests.with_db("")
6 | user.insert_user(db)
7 | }
8 |
--------------------------------------------------------------------------------
/test/todomvc_test.gleam:
--------------------------------------------------------------------------------
1 | import gleeunit
2 |
3 | pub fn main() {
4 | gleeunit.main()
5 | }
6 |
--------------------------------------------------------------------------------
/test/todomvc_test_helper.erl:
--------------------------------------------------------------------------------
1 | -module(todomvc_test_helper).
2 |
3 | -export([ensure/2]).
4 |
5 | ensure(Task, Cleanup) ->
6 | try
7 | Task()
8 | after
9 | Cleanup()
10 | end.
11 |
--------------------------------------------------------------------------------