35 | )mx
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
1 | name: Tests
2 |
3 | on:
4 | push:
5 | pull_request:
6 | branches:
7 | - main
8 |
9 | jobs:
10 | tests:
11 | name: Run tests (Elixir ${{matrix.elixir}}, OTP ${{matrix.otp}})
12 |
13 | strategy:
14 | matrix:
15 | include:
16 | - elixir: 1.7
17 | otp: 21.3
18 | - elixir: 1.14
19 | otp: 25.3
20 | lint: lint
21 |
22 | runs-on: ubuntu-20.04
23 |
24 | steps:
25 | - name: Checkout
26 | uses: actions/checkout@v2
27 |
28 | - name: Set up Elixir
29 | uses: erlef/setup-elixir@v1
30 | with:
31 | elixir-version: ${{ matrix.elixir }}
32 | otp-version: ${{ matrix.otp }}
33 |
34 | - name: Restore deps and _build cache
35 | uses: actions/cache@v2
36 | with:
37 | path: |
38 | deps
39 | _build
40 | key: deps-${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-${{ hashFiles('**/mix.lock') }}
41 | restore-keys: |
42 | deps-${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}
43 |
44 | - name: Install dependencies
45 | run: mix deps.get --only test
46 |
47 | - name: Check source code format
48 | run: mix format --check-formatted
49 | if: ${{ matrix.lint }}
50 |
51 | - name: Remove compiled application files
52 | run: mix clean
53 |
54 | - name: Compile dependencies
55 | run: mix compile
56 | if: ${{ !matrix.lint }}
57 | env:
58 | MIX_ENV: test
59 |
60 | - name: Compile & lint dependencies
61 | run: mix compile --warnings-as-errors
62 | if: ${{ matrix.lint }}
63 | env:
64 | MIX_ENV: test
65 |
66 | - name: Run tests
67 | run: mix test
68 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # PhoenixHTMLHelpers
2 |
3 | [](https://github.com/phoenixframework/phoenix_html_helpers/actions?query=workflow%3ATests)
4 |
5 | Collection of helpers to generate and manipulate HTML contents.
6 | These helpers were used in Phoenix v1.6 and earlier versions,
7 | before the introduction of `Phoenix.Component`.
8 |
9 | To maintain compatibility, replace `use Phoenix.HTML` in your applications by:
10 |
11 | ```elixir
12 | import Phoenix.HTML
13 | import Phoenix.HTML.Form
14 | use PhoenixHTMLHelpers
15 | ```
16 |
17 | See the [docs](https://hexdocs.pm/phoenix_html_helpers/) for more information.
18 |
19 | This library is maintained for compatibility, but does not accept new features.
20 |
21 | ## License
22 |
23 | Copyright (c) 2014 Chris McCord
24 |
25 | Permission is hereby granted, free of charge, to any person obtaining
26 | a copy of this software and associated documentation files (the
27 | "Software"), to deal in the Software without restriction, including
28 | without limitation the rights to use, copy, modify, merge, publish,
29 | distribute, sublicense, and/or sell copies of the Software, and to
30 | permit persons to whom the Software is furnished to do so, subject to
31 | the following conditions:
32 |
33 | The above copyright notice and this permission notice shall be
34 | included in all copies or substantial portions of the Software.
35 |
36 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
37 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
38 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
39 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
40 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
41 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
42 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
43 |
--------------------------------------------------------------------------------
/test/phoenix_html_helpers/format_test.exs:
--------------------------------------------------------------------------------
1 | defmodule PhoenixHTMLHelpers.FormatTest do
2 | use ExUnit.Case, async: true
3 |
4 | import PhoenixHTMLHelpers.Format
5 | import Phoenix.HTML
6 |
7 | doctest PhoenixHTMLHelpers.Format
8 |
9 | test "wraps paragraphs" do
10 | formatted =
11 | format("""
12 | Hello,
13 |
14 | Please come see me.
15 |
16 | Regards,
17 | The Boss.
18 | """)
19 |
20 | assert formatted == """
21 | Hello,
22 | Please come see me.
23 | Regards,
25 | """
26 | end
27 |
28 | test "wraps paragraphs with carriage returns" do
29 | formatted = format("Hello,\r\n\r\nPlease come see me.\r\n\r\nRegards,\r\nThe Boss.")
30 |
31 | assert formatted == """
32 | Hello,
33 | Please come see me.
34 | Regards,
36 | """
37 | end
38 |
39 | test "escapes html" do
40 | formatted =
41 | format("""
42 |
43 | """)
44 |
45 | assert formatted == """
46 | <script></script>
47 | """
48 | end
49 |
50 | test "skips escaping html" do
51 | formatted =
52 | format(
53 | """
54 |
55 | """,
56 | escape: false
57 | )
58 |
59 | assert formatted == """
60 |
61 | """
62 | end
63 |
64 | test "adds brs" do
65 | formatted =
66 | format("""
67 | Hello,
68 | This is dog,
69 | How can I help you?
70 |
71 |
72 | """)
73 |
74 | assert formatted == """
75 | Hello,
78 | """
79 | end
80 |
81 | test "adds brs with carriage return" do
82 | formatted = format("Hello,\r\nThis is dog,\r\nHow can I help you?\r\n\r\n\r\n")
83 |
84 | assert formatted == """
85 | Hello,
88 | """
89 | end
90 |
91 | test "doesn't add brs" do
92 | formatted =
93 | format(
94 | """
95 | Hello,
96 | This is dog,
97 | How can I help you?
98 |
99 |
100 | """,
101 | insert_brs: false
102 | )
103 |
104 | assert formatted == """
105 | Hello, This is dog, How can I help you?
106 | """
107 | end
108 |
109 | defp format(text, opts \\ []) do
110 | text |> text_to_html(opts) |> safe_to_string
111 | end
112 | end
113 |
--------------------------------------------------------------------------------
/lib/phoenix_html_helpers/format.ex:
--------------------------------------------------------------------------------
1 | defmodule PhoenixHTMLHelpers.Format do
2 | @moduledoc """
3 | Formatting functions.
4 | """
5 |
6 | @doc ~S"""
7 | Returns text transformed into HTML using simple formatting rules.
8 |
9 | Two or more consecutive newlines `\n\n` or `\r\n\r\n` are considered as a
10 | paragraph and text between them is wrapped in `` tags.
11 | One newline `\n` or `\r\n` is considered as a linebreak and a `
Hello
\nWorld
\n"
17 |
18 | iex> text_to_html("Hello\nWorld") |> safe_to_string
19 | "Hello
\n"
20 |
21 | iex> opts = [wrapper_tag: :div, attributes: [class: "p"]]
22 | ...> text_to_html("Hello\n\nWorld", opts) |> safe_to_string
23 | "Hello
\nWorld
\n"
24 |
25 | ## Options
26 |
27 | * `:escape` - if `false` does not html escape input (default: `true`)
28 | * `:wrapper_tag` - tag to wrap each paragraph (default: `:p`)
29 | * `:attributes` - html attributes of the wrapper tag (default: `[]`)
30 | * `:insert_brs` - if `true` insert `hello ]
12 | end
13 |
14 | test "link with %URI{}" do
15 | url = "https://elixir-lang.org/"
16 |
17 | assert safe_to_string(link("elixir", to: url)) ==
18 | safe_to_string(link("elixir", to: URI.parse(url)))
19 |
20 | path = "/elixir"
21 |
22 | assert safe_to_string(link("elixir", to: path)) ==
23 | safe_to_string(link("elixir", to: URI.parse(path)))
24 | end
25 |
26 | test "link with put/delete" do
27 | csrf_token = Plug.CSRFProtection.get_csrf_token()
28 |
29 | assert safe_to_string(link("hello", to: "/world", method: :put)) ==
30 | ~s[hello ]
31 | end
32 |
33 | test "link with put/delete without csrf_token" do
34 | assert safe_to_string(link("hello", to: "/world", method: :put, csrf_token: false)) ==
35 | ~s[hello ]
36 | end
37 |
38 | test "link with :do contents" do
39 | assert ~s[world
world ]
51 | end
52 |
53 | test "link with scheme" do
54 | assert safe_to_string(link("foo", to: "/javascript:alert(<1>)")) ==
55 | ~s[foo ]
56 |
57 | assert safe_to_string(link("foo", to: {:safe, "/javascript:alert(<1>)"})) ==
58 | ~s[foo ]
59 |
60 | assert safe_to_string(link("foo", to: {:javascript, "alert(<1>)"})) ==
61 | ~s[foo ]
62 |
63 | assert safe_to_string(link("foo", to: {:javascript, ~c"alert(<1>)"})) ==
64 | ~s[foo ]
65 |
66 | assert safe_to_string(link("foo", to: {:javascript, {:safe, "alert(<1>)"}})) ==
67 | ~s[foo ]
68 |
69 | assert safe_to_string(link("foo", to: {:javascript, {:safe, ~c"alert(<1>)"}})) ==
70 | ~s[foo ]
71 | end
72 |
73 | test "link with invalid args" do
74 | msg = "expected non-nil value for :to in link/2"
75 |
76 | assert_raise ArgumentError, msg, fn ->
77 | link("foo", bar: "baz")
78 | end
79 |
80 | msg = "link/2 requires a keyword list as second argument"
81 |
82 | assert_raise ArgumentError, msg, fn ->
83 | link("foo", "/login")
84 | end
85 |
86 | assert_raise ArgumentError, ~r"unsupported scheme given as link", fn ->
87 | link("foo", to: "javascript:alert(1)")
88 | end
89 |
90 | assert_raise ArgumentError, ~r"unsupported scheme given as link", fn ->
91 | link("foo", to: {:safe, "javascript:alert(1)"})
92 | end
93 |
94 | assert_raise ArgumentError, ~r"unsupported scheme given as link", fn ->
95 | link("foo", to: {:safe, ~c"javascript:alert(1)"})
96 | end
97 | end
98 |
99 | test "button with post (default)" do
100 | csrf_token = Plug.CSRFProtection.get_csrf_token()
101 |
102 | assert safe_to_string(button("hello", to: "/world")) ==
103 | ~s[hello ]
104 | end
105 |
106 | test "button with %URI{}" do
107 | url = "https://elixir-lang.org/"
108 |
109 | assert safe_to_string(button("elixir", to: url, csrf_token: false)) ==
110 | safe_to_string(button("elixir", to: URI.parse(url), csrf_token: false))
111 | end
112 |
113 | test "button with post without csrf_token" do
114 | assert safe_to_string(button("hello", to: "/world", csrf_token: false)) ==
115 | ~s[hello ]
116 | end
117 |
118 | test "button with get does not generate CSRF" do
119 | assert safe_to_string(button("hello", to: "/world", method: :get)) ==
120 | ~s[hello ]
121 | end
122 |
123 | test "button with do" do
124 | csrf_token = Plug.CSRFProtection.get_csrf_token()
125 |
126 | output =
127 | safe_to_string(
128 | button to: "/world", class: "small" do
129 | raw("Hi ")
130 | end
131 | )
132 |
133 | assert output ==
134 | ~s[Hi hello ]
142 | end
143 |
144 | test "button with invalid args" do
145 | assert_raise ArgumentError, ~r/unsupported scheme given as link/, fn ->
146 | button("foo", to: "javascript:alert(1)", method: :get)
147 | end
148 | end
149 | end
150 |
--------------------------------------------------------------------------------
/test/phoenix_html_helpers/inputs_for_test.exs:
--------------------------------------------------------------------------------
1 | defmodule PhoenixHTMLHelpers.InputsForTest do
2 | use ExUnit.Case, async: true
3 |
4 | import Phoenix.HTML
5 | import PhoenixHTMLHelpers.Form
6 |
7 | @doc """
8 | A function that executes `inputs_for/4` and
9 | extracts its inner contents for assertion.
10 | """
11 | def safe_inputs_for(field, opts \\ [], fun) do
12 | mark = "--PLACEHOLDER--"
13 | {multipart, opts} = Keyword.pop(opts, :multipart, false)
14 |
15 | conn =
16 | Plug.Test.conn(:get, "/foo", %{
17 | "search" => %{
18 | "date" => %{"year" => "2020", "month" => "4", "day" => "17"},
19 | "dates" => %{
20 | "0" => %{"year" => "2010", "month" => "4", "day" => "17"},
21 | "1" => %{"year" => "2020", "month" => "4", "day" => "17"}
22 | }
23 | }
24 | })
25 |
26 | contents =
27 | safe_to_string(
28 | form_for(conn, "/", [as: :search, multipart: multipart], fn f ->
29 | html_escape([mark, inputs_for(f, field, opts, fun), mark])
30 | end)
31 | )
32 |
33 | [_, inner, _] = String.split(contents, mark)
34 | inner
35 | end
36 |
37 | ## Cardinality one
38 |
39 | test "one: inputs_for/4 without default and field is not present" do
40 | contents =
41 | safe_inputs_for(:unknown, fn f ->
42 | refute f.index
43 | text_input(f, :year)
44 | end)
45 |
46 | assert contents ==
47 | ~s(hello
15 |
16 | link("hello", to: URI.parse("https://elixir-lang.org"))
17 | #=> hello
18 |
19 | link("", to: "/world")
20 | #=> <hello>
21 |
22 | link("", to: "/world", class: "btn")
23 | #=> <hello>
24 |
25 | link("delete", to: "/the_world", data: [confirm: "Really?"])
26 | #=> delete
27 |
28 | # If you supply a method other than `:get`:
29 | link("delete", to: "/everything", method: :delete)
30 | #=> delete
31 |
32 | # You can use a `do ... end` block too:
33 | link to: "/hello" do
34 | "world"
35 | end
36 | #=> world
37 |
38 | ## Options
39 |
40 | * `:to` - the page to link to. This option is required
41 |
42 | * `:method` - the method to use with the link. In case the
43 | method is not `:get`, the link is generated inside the form
44 | which sets the proper information. In order to submit the
45 | form, JavaScript must be enabled
46 |
47 | * `:csrf_token` - a custom token to use for links with a method
48 | other than `:get`.
49 |
50 | All other options are forwarded to the underlying ` ` tag.
51 |
52 | ## Data attributes
53 |
54 | Data attributes are added as a keyword list passed to the `data` key.
55 | The following data attributes are supported:
56 |
57 | * `data-confirm` - shows a confirmation prompt before
58 | generating and submitting the form when `:method`
59 | is not `:get`.
60 |
61 | ## CSRF Protection
62 |
63 | By default, CSRF tokens are generated through `Plug.CSRFProtection`.
64 | """
65 | def link(text, opts)
66 |
67 | def link(opts, do: contents) when is_list(opts) do
68 | link(contents, opts)
69 | end
70 |
71 | def link(_text, opts) when not is_list(opts) do
72 | raise ArgumentError, "link/2 requires a keyword list as second argument"
73 | end
74 |
75 | def link(text, opts) do
76 | {to, opts} = pop_required_option!(opts, :to, "expected non-nil value for :to in link/2")
77 | {method, opts} = Keyword.pop(opts, :method, :get)
78 |
79 | if method == :get do
80 | # Call link attributes to validate `to`
81 | [data: data] = link_attributes(to, [])
82 | content_tag(:a, text, [href: data[:to]] ++ Keyword.delete(opts, :csrf_token))
83 | else
84 | {csrf_token, opts} = Keyword.pop(opts, :csrf_token, true)
85 | opts = Keyword.put_new(opts, :rel, "nofollow")
86 | [data: data] = link_attributes(to, method: method, csrf_token: csrf_token)
87 | content_tag(:a, text, [data: data, href: data[:to]] ++ opts)
88 | end
89 | end
90 |
91 | @doc """
92 | Generates a button tag that uses the Javascript function handleClick()
93 | (see phoenix_html.js) to submit the form data.
94 |
95 | Useful to ensure that links that change data are not triggered by
96 | search engines and other spidering software.
97 |
98 | ## Examples
99 |
100 | button("hello", to: "/world")
101 | #=> hello
102 |
103 | button("hello", to: "/world", method: :get, class: "btn")
104 | #=> hello
105 |
106 | ## Options
107 |
108 | * `:to` - the page to link to. This option is required
109 |
110 | * `:method` - the method to use with the button. Defaults to :post.
111 |
112 | All other options are forwarded to the underlying button input.
113 |
114 | When the `:method` is set to `:get` and the `:to` URL contains query
115 | parameters the generated form element will strip the parameters in accordance
116 | with the [W3C](https://www.w3.org/TR/html401/interact/forms.html#h-17.13.3.4)
117 | form specification.
118 |
119 | ## Data attributes
120 |
121 | Data attributes are added as a keyword list passed to the
122 | `data` key. The following data attributes are supported:
123 |
124 | * `data-confirm` - shows a confirmation prompt before generating and
125 | submitting the form.
126 | """
127 | def button(opts, do: contents) do
128 | button(contents, opts)
129 | end
130 |
131 | def button(text, opts) do
132 | {to, opts} = pop_required_option!(opts, :to, "option :to is required in button/2")
133 |
134 | {link_opts, opts} =
135 | opts
136 | |> Keyword.put_new(:method, :post)
137 | |> Keyword.split([:method, :csrf_token])
138 |
139 | content_tag(:button, text, link_attributes(to, link_opts) ++ opts)
140 | end
141 |
142 | defp pop_required_option!(opts, key, error_message) do
143 | {value, opts} = Keyword.pop(opts, key)
144 |
145 | unless value do
146 | raise ArgumentError, error_message
147 | end
148 |
149 | {value, opts}
150 | end
151 |
152 | defp link_attributes(to, opts) do
153 | to = valid_destination!(to)
154 | method = Keyword.get(opts, :method, :get)
155 | data = [method: method, to: to]
156 |
157 | data =
158 | if method == :get do
159 | data
160 | else
161 | case Keyword.get(opts, :csrf_token, true) do
162 | true -> [csrf: PhoenixHTMLHelpers.Tag.csrf_token_value(to)] ++ data
163 | false -> data
164 | csrf when is_binary(csrf) -> [csrf: csrf] ++ data
165 | end
166 | end
167 |
168 | [data: data]
169 | end
170 |
171 | defp valid_destination!(%URI{} = uri) do
172 | valid_destination!(URI.to_string(uri))
173 | end
174 |
175 | defp valid_destination!({:safe, to}) do
176 | {:safe, valid_string_destination!(IO.iodata_to_binary(to))}
177 | end
178 |
179 | defp valid_destination!({other, to}) when is_atom(other) do
180 | [Atom.to_string(other), ?:, to]
181 | end
182 |
183 | defp valid_destination!(to) do
184 | valid_string_destination!(IO.iodata_to_binary(to))
185 | end
186 |
187 | @valid_uri_schemes ~w(http: https: ftp: ftps: mailto: news: irc: gopher:) ++
188 | ~w(nntp: feed: telnet: mms: rtsp: svn: tel: fax: xmpp:)
189 |
190 | for scheme <- @valid_uri_schemes do
191 | defp valid_string_destination!(unquote(scheme) <> _ = string), do: string
192 | end
193 |
194 | defp valid_string_destination!(to) do
195 | if not match?("/" <> _, to) and String.contains?(to, ":") do
196 | raise ArgumentError, """
197 | unsupported scheme given as link. In case you want to link to an
198 | unknown or unsafe scheme, such as javascript, use a tuple: {:javascript, rest}\
199 | """
200 | else
201 | to
202 | end
203 | end
204 | end
205 |
--------------------------------------------------------------------------------
/test/phoenix_html_helpers/tag_test.exs:
--------------------------------------------------------------------------------
1 | defmodule PhoenixHTMLHelpers.TagTest do
2 | use ExUnit.Case, async: true
3 |
4 | import Phoenix.HTML
5 | import PhoenixHTMLHelpers.Tag
6 | doctest PhoenixHTMLHelpers.Tag
7 |
8 | test "tag" do
9 | assert tag(:br) |> safe_to_string() == ~s( safe_to_string() == ~s()
38 |
39 | assert tag(:audio, autoplay: true) |> safe_to_string() == ~s()
40 | assert tag(:audio, autoplay: false) |> safe_to_string() == ~s()
41 | assert tag(:audio, autoplay: nil) |> safe_to_string() == ~s()
42 | end
43 |
44 | test "content_tag" do
45 | assert content_tag(:p, "Hello") |> safe_to_string() == "Hello
"
46 |
47 | assert content_tag(:p, "Hello", class: "dark") |> safe_to_string() ==
48 | "Hello
"
49 |
50 | assert content_tag(:p, [class: "dark"], do: "Hello") |> safe_to_string() ==
51 | "Hello
"
52 |
53 | assert content_tag(:p, "") |> safe_to_string() == "<Hello>
"
54 |
55 | assert content_tag(:p, 13) |> safe_to_string() == "13
"
56 |
57 | assert content_tag(:p, [class: "dark"], do: "") |> safe_to_string() ==
58 | "<Hello>
"
59 |
60 | assert content_tag(:p, raw("")) |> safe_to_string() == "
"
61 |
62 | assert content_tag(:p, [class: "dark"], do: raw("")) |> safe_to_string() ==
63 | "
"
64 |
65 | content =
66 | content_tag :form, action: "/users", data: [remote: true] do
67 | tag(:input, name: "user[name]")
68 | end
69 |
70 | assert safe_to_string(content) ==
71 | ~s()
72 |
73 | assert content_tag(:p, do: "Hello") |> safe_to_string() == "Hello
"
74 |
75 | content =
76 | content_tag :ul do
77 | content_tag :li do
78 | "Hello"
79 | end
80 | end
81 |
82 | assert safe_to_string(content) == ""
83 |
84 | assert content_tag(:p, ["hello", ?\s, "world"]) |> safe_to_string() == "hello world
"
85 |
86 | assert content_tag(:div, [autoplay: "autoplay"], do: "") |> safe_to_string() ==
87 | ~s(
)
88 |
89 | assert content_tag(:div, [autoplay: true], do: "") |> safe_to_string() ==
90 | ~s(
)
91 |
92 | assert content_tag(:div, [autoplay: false], do: "") |> safe_to_string() == ~s(
)
93 |
94 | assert content_tag(:div, [autoplay: nil], do: "") |> safe_to_string() == ~s(
)
95 |
96 | assert content_tag("custom-tag", "Hi") |> safe_to_string() == ~s(Hi )
97 | end
98 |
99 | test "img_tag" do
100 | assert img_tag("user.png") |> safe_to_string() == ~s(
20 | > Hello
21 | >
22 |
23 | > Note: the examples in this module use `safe_to_string/1`
24 | > imported from `Phoenix.HTML` for readability.
25 | """
26 |
27 | import Phoenix.HTML
28 |
29 | @csrf_param "_csrf_token"
30 |
31 | @doc ~S"""
32 | Creates an HTML tag with the given name and options.
33 |
34 | iex> safe_to_string tag(:br)
35 | ""
57 | iex> safe_to_string tag(:audio, autoplay: true)
58 | ""
59 | iex> safe_to_string tag(:audio, autoplay: false)
60 | ""
61 |
62 | If you want the boolean attribute to be sent as is,
63 | you can explicitly convert it to a string before.
64 | """
65 | def tag(name), do: tag(name, [])
66 |
67 | def tag(name, attrs) when is_list(attrs) do
68 | {:safe, [?<, to_string(name), sorted_attrs(attrs), ?>]}
69 | end
70 |
71 | @doc ~S"""
72 | Creates an HTML tag with given name, content, and attributes.
73 |
74 | See `PhoenixHTMLHelpers.Tag.tag/2` for more information and examples.
75 |
76 | iex> safe_to_string content_tag(:p, "Hello")
77 | "Hello
"
78 |
79 | iex> safe_to_string content_tag(:p, "", class: "test")
80 | "<Hello>
"
81 |
82 | iex> safe_to_string(content_tag :p, class: "test" do
83 | ...> "Hello"
84 | ...> end)
85 | "Hello
"
86 |
87 | iex> safe_to_string content_tag(:option, "Display Value", [{:data, [foo: "bar"]}, value: "value"])
88 | "Display Value "
89 |
90 | """
91 | def content_tag(name, do: block) do
92 | content_tag(name, block, [])
93 | end
94 |
95 | def content_tag(name, content) do
96 | content_tag(name, content, [])
97 | end
98 |
99 | def content_tag(name, attrs, do: block) when is_list(attrs) do
100 | content_tag(name, block, attrs)
101 | end
102 |
103 | def content_tag(name, content, attrs) when is_list(attrs) do
104 | name = to_string(name)
105 | {:safe, escaped} = html_escape(content)
106 | {:safe, [?<, name, sorted_attrs(attrs), ?>, escaped, ?<, ?/, name, ?>]}
107 | end
108 |
109 | defp sorted_attrs(attrs) when is_list(attrs),
110 | do: attrs |> Enum.sort() |> attributes_escape() |> elem(1)
111 |
112 | defp sorted_attrs(attrs),
113 | do: attrs |> Enum.to_list() |> sorted_attrs()
114 |
115 | @doc ~S"""
116 | Generates a form tag.
117 |
118 | This function generates the `
194 |
195 | """
196 | def form_tag(action, options, do: block) do
197 | html_escape([form_tag(action, options), block, raw("")])
198 | end
199 |
200 | defp csrf_form_tag(to, opts) do
201 | case Keyword.pop(opts, :csrf_token, true) do
202 | {csrf_token, opts} when is_binary(csrf_token) ->
203 | {[~s'
84 | Name: <%= text_input f, :name %>
85 |
86 |
87 |
88 | Age: <%= select f, :age, 18..100 %>
89 |
90 |
91 | <%= submit "Submit" %>
92 | <% end %>
93 |
94 | `form_for/4` receives the `Ecto.Changeset` and converts it
95 | to a form, which is passed to the function as the argument
96 | `f`. All the remaining functions in this module receive
97 | the form and automatically generate the input fields, often
98 | by extracting information from the given changeset. For example,
99 | if the user had a default value for age set, it will
100 | automatically show up as selected in the form.
101 |
102 | ### A note on `:errors`
103 |
104 | Even if `changeset.errors` is non-empty, errors will not be displayed in a
105 | form if [the changeset
106 | `:action`](https://hexdocs.pm/ecto/Ecto.Changeset.html#module-changeset-actions)
107 | is `nil` or `:ignore`.
108 |
109 | This is useful for things like validation hints on form fields, e.g. an empty
110 | changeset for a new form. That changeset isn't valid, but we don't want to
111 | show errors until an actual user action has been performed.
112 |
113 | For example, if the user submits and a `Repo.insert/1` is called and fails on
114 | changeset validation, the action will be set to `:insert` to show that an
115 | insert was attempted, and the presence of that action will cause errors to be
116 | displayed. The same is true for Repo.update/delete.
117 |
118 | If you want to show errors manually you can also set the action yourself,
119 | either directly on the `Ecto.Changeset` struct field or by using
120 | `Ecto.Changeset.apply_action/2`. Since the action can be arbitrary, you can
121 | set it to `:validate` or anything else to avoid giving the impression that a
122 | database operation has actually been attempted.
123 |
124 | ## With map data
125 |
126 | `form_for/4` expects as first argument any data structure that
127 | implements the `Phoenix.HTML.FormData` protocol. By default,
128 | Phoenix.HTML implements this protocol for `Map`.
129 |
130 | This is useful when you are creating forms that are not backed
131 | by any kind of data layer. Let's assume that we're submitting a
132 | form to the `:new` action in the `FooController`:
133 |
134 | <%= form_for @conn.params, Routes.foo_path(@conn, :new), fn f -> %>
135 | <%= text_input f, :contents %>
136 | <%= submit "Search" %>
137 | <% end %>
138 |
139 | Once the form is submitted, the form contents will be set directly
140 | as the parameters root, such as `conn.params["contents"]`. If you
141 | prefer, you can pass the `:as` option to configure them to be nested:
142 |
143 | <%= form_for @conn.params["search"] || %{}, Routes.foo_path(@conn, :new), [as: :search], fn f -> %>
144 | <%= text_input f, :contents %>
145 | <%= submit "Search" %>
146 | <% end %>
147 |
148 | In the example above, all form contents are now set inside `conn.params["search"]`
149 | thanks to the `[as: :search]` option.
150 |
151 | ## Nested inputs
152 |
153 | If your data layer supports embedding or nested associations,
154 | you can use `inputs_for` to attach nested data to the form.
155 |
156 | Imagine the following Ecto schemas:
157 |
158 | defmodule User do
159 | use Ecto.Schema
160 |
161 | schema "users" do
162 | field :name
163 | embeds_one :permalink, Permalink
164 | end
165 |
166 | def changeset(user \\ %User{}, params) do
167 | user
168 | |> Ecto.Changeset.cast(params, [:name])
169 | |> Ecto.Changeset.cast_embed(:permalink)
170 | end
171 | end
172 |
173 | defmodule Permalink do
174 | use Ecto.Schema
175 |
176 | embedded_schema do
177 | field :url
178 | end
179 | end
180 |
181 | In the form, you can now do this:
182 |
183 | <%= form_for @changeset, Routes.user_path(@conn, :create), fn f -> %>
184 | <%= text_input f, :name %>
185 |
186 | <%= inputs_for f, :permalink, fn fp -> %>
187 | <%= text_input fp, :url %>
188 | <% end %>
189 | <% end %>
190 |
191 | The default option can be given to populate the fields if none
192 | is given:
193 |
194 | <%= inputs_for f, :permalink, [default: %Permalink{title: "default"}], fn fp -> %>
195 | <%= text_input fp, :url %>
196 | <% end %>
197 |
198 | `inputs_for/4` can be used to work with single entities or
199 | collections. When working with collections, `:prepend` and
200 | `:append` can be used to add entries to the collection
201 | stored in the changeset.
202 |
203 | ## CSRF protection
204 |
205 | CSRF protection is a mechanism to ensure that the user who rendered
206 | the form is the one actually submitting it. This module generates a
207 | CSRF token by default. Your application should check this token on
208 | the server to prevent attackers from making requests on your server on
209 | behalf of other users. Phoenix checks this token by default.
210 |
211 | When posting a form with a host in its address, such as "//host.com/path"
212 | instead of only "/path", Phoenix will include the host signature in the
213 | token, and will only validate the token if the accessed host is the same as
214 | the host in the token. This is to avoid tokens from leaking to third-party
215 | applications. If this behaviour is problematic, you can generate a
216 | non-host-specific token with `Plug.CSRFProtection.get_csrf_token/0` and
217 | pass it to the form generator via the `:csrf_token` option.
218 |
219 | ## Options
220 |
221 | * `:as` - the server side parameter in which all params for this
222 | form will be collected (i.e. `as: :user_params` would mean all fields
223 | for this form will be accessed as `conn.params.user_params` server
224 | side). Automatically inflected when a changeset is given.
225 |
226 | * `:method` - the HTTP method. If the method is not "get" nor "post",
227 | an input tag with name `_method` is generated along-side the form tag.
228 | Defaults to "post".
229 |
230 | * `:multipart` - when true, sets enctype to "multipart/form-data".
231 | Required when uploading files.
232 |
233 | * `:csrf_token` - for "post" requests, the form tag will automatically
234 | include an input tag with name `_csrf_token`. When set to false, this
235 | is disabled.
236 |
237 | * `:errors` - use this to manually pass a keyword list of errors to the form
238 | (for example from `conn.assigns[:errors]`). This option is only used when a
239 | connection is used as the form source and it will make the errors available
240 | under `f.errors`.
241 |
242 | * `:id` - the ID of the form attribute. If an ID is given, all form inputs
243 | will also be prefixed by the given ID.
244 |
245 | All other options will be passed as HTML attributes, such as `class: "foo"`.
246 | """
247 | @spec form_for(Phoenix.HTML.FormData.t(), String.t(), (Form.t() -> Phoenix.HTML.unsafe())) ::
248 | Phoenix.HTML.safe()
249 | @spec form_for(
250 | Phoenix.HTML.FormData.t(),
251 | String.t(),
252 | Keyword.t(),
253 | (Form.t() -> Phoenix.HTML.unsafe())
254 | ) ::
255 | Phoenix.HTML.safe()
256 | def form_for(form_data, action, options \\ [], fun) when is_function(fun, 1) do
257 | form = Phoenix.HTML.FormData.to_form(form_data, options)
258 | html_escape([form_tag(action, form.options), fun.(form), raw("")])
259 | end
260 |
261 | @doc """
262 | Generate a new form builder for the given parameter in form.
263 |
264 | See `form_for/4` for examples of using this function.
265 |
266 | ## Options
267 |
268 | * `:id` - the id to be used in the form, defaults to the
269 | concatenation of the given `field` to the parent form id
270 |
271 | * `:as` - the name to be used in the form, defaults to the
272 | concatenation of the given `field` to the parent form name
273 |
274 | * `:default` - the value to use if none is available
275 |
276 | * `:prepend` - the values to prepend when rendering. This only
277 | applies if the field value is a list and no parameters were
278 | sent through the form.
279 |
280 | * `:append` - the values to append when rendering. This only
281 | applies if the field value is a list and no parameters were
282 | sent through the form.
283 |
284 | * `:skip_hidden` - skip the automatic rendering of hidden
285 | fields to allow for more tight control over the generated
286 | markup. You can access `form.hidden` to generate them manually
287 | within the supplied callback.
288 |
289 | """
290 | @spec inputs_for(Form.t(), Form.field(), (Form.t() -> Phoenix.HTML.unsafe())) ::
291 | Phoenix.HTML.safe()
292 | @spec inputs_for(Form.t(), Form.field(), Keyword.t(), (Form.t() -> Phoenix.HTML.unsafe())) ::
293 | Phoenix.HTML.safe()
294 | def inputs_for(%{impl: impl} = form, field, options \\ [], fun)
295 | when is_atom(field) or is_binary(field) do
296 | {skip, options} = Keyword.pop(options, :skip_hidden, false)
297 |
298 | options =
299 | form.options
300 | |> Keyword.take([:multipart])
301 | |> Keyword.merge(options)
302 |
303 | forms = impl.to_form(form.source, form, field, options)
304 |
305 | html_escape(
306 | Enum.map(forms, fn form ->
307 | if skip do
308 | fun.(form)
309 | else
310 | [hidden_inputs_for(form), fun.(form)]
311 | end
312 | end)
313 | )
314 | end
315 |
316 | @mapping %{
317 | "url" => :url_input,
318 | "email" => :email_input,
319 | "search" => :search_input,
320 | "password" => :password_input
321 | }
322 |
323 | @doc """
324 | Gets the input type for a given field.
325 |
326 | If the underlying input type is a `:text_field`,
327 | a mapping could be given to further inflect
328 | the input type based solely on the field name.
329 | The default mapping is:
330 |
331 | %{"url" => :url_input,
332 | "email" => :email_input,
333 | "search" => :search_input,
334 | "password" => :password_input}
335 |
336 | """
337 | @spec input_type(Form.t(), Form.field()) :: atom
338 | def input_type(%{impl: impl, source: source} = form, field, mapping \\ @mapping)
339 | when is_atom(field) or is_binary(field) do
340 | type =
341 | if function_exported?(impl, :input_type, 3) do
342 | impl.input_type(source, form, field)
343 | else
344 | :text_input
345 | end
346 |
347 | if type == :text_input do
348 | field = field_to_string(field)
349 |
350 | Enum.find_value(mapping, type, fn {k, v} ->
351 | String.contains?(field, k) && v
352 | end)
353 | else
354 | type
355 | end
356 | end
357 |
358 | @doc """
359 | Generates a text input.
360 |
361 | The form should either be a `Phoenix.HTML.Form` emitted
362 | by `form_for` or an atom.
363 |
364 | All given options are forwarded to the underlying input,
365 | default values are provided for id, name and value if
366 | possible.
367 |
368 | ## Examples
369 |
370 | # Assuming form contains a User schema
371 | text_input(form, :name)
372 | #=> Submit
655 |
656 | """
657 | def submit([do: _] = block_option), do: submit([], block_option)
658 |
659 | @doc """
660 | Generates a submit button to send the form.
661 |
662 | All options are forwarded to the underlying button tag.
663 | When called with a `do:` block, the button tag options
664 | come first.
665 |
666 | ## Examples
667 |
668 | submit "Submit"
669 | #=> Submit
670 |
671 | submit "Submit", class: "btn"
672 | #=> Submit
673 |
674 | submit [class: "btn"], do: "Submit"
675 | #=> Submit
676 |
677 | """
678 | def submit(value, opts \\ [])
679 |
680 | def submit(opts, [do: _] = block_option) do
681 | opts = Keyword.put_new(opts, :type, "submit")
682 |
683 | content_tag(:button, opts, block_option)
684 | end
685 |
686 | def submit(value, opts) do
687 | opts = Keyword.put_new(opts, :type, "submit")
688 |
689 | content_tag(:button, value, opts)
690 | end
691 |
692 | @doc """
693 | Generates a reset input to reset all the form fields to
694 | their original state.
695 |
696 | All options are forwarded to the underlying input tag.
697 |
698 | ## Examples
699 |
700 | reset "Reset"
701 | #=> ` and the value will be used to
852 | generate `` nested under the group.
853 |
854 | ## Examples
855 |
856 | # Assuming form contains a User schema
857 | select(form, :age, 0..120)
858 | #=>
859 | #=> 0
860 | #=> ...
861 | #=> 120
862 | #=>
863 |
864 | select(form, :role, ["Admin": "admin", "User": "user"])
865 | #=>
866 | #=> Admin
867 | #=> User
868 | #=>
869 |
870 | select(form, :role, [[key: "Admin", value: "admin", disabled: true],
871 | [key: "User", value: "user"]])
872 | #=>
873 | #=> Admin
874 | #=> User
875 | #=>
876 |
877 | You can also pass a prompt:
878 |
879 | select(form, :role, ["Admin": "admin", "User": "user"], prompt: "Choose your role")
880 | #=>
881 | #=> Choose your role
882 | #=> Admin
883 | #=> User
884 | #=>
885 |
886 | And customize the prompt like any other entry:
887 |
888 | select(form, :role, ["Admin": "admin", "User": "user"], prompt: [key: "Choose your role", disabled: true])
889 | #=>
890 | #=> Choose your role
891 | #=> Admin
892 | #=> User
893 | #=>
894 |
895 | If you want to select an option that comes from the database,
896 | such as a manager for a given project, you may write:
897 |
898 | select(form, :manager_id, Enum.map(@managers, &{&1.name, &1.id}))
899 | #=>
900 | #=> Mary Jane
901 | #=> John Doe
902 | #=>
903 |
904 | Finally, if the values are a list or a map, we use the keys for
905 | grouping:
906 |
907 | select(form, :country, ["Europe": ["UK", "Sweden", "France"]], ...)
908 | #=>
909 | #=>
910 | #=> UK
911 | #=> Sweden
912 | #=> France
913 | #=>
914 | #=> ...
915 | #=>
916 |
917 | ## Options
918 |
919 | * `:prompt` - an option to include at the top of the options. It may be
920 | a string or a keyword list of attributes and the `:key`
921 |
922 | * `:selected` - the default value to use when none was sent as parameter
923 |
924 | Be aware that a `:multiple` option will not generate a correctly
925 | functioning multiple select element. Use `multiple_select/4` instead.
926 |
927 | All other options are forwarded to the underlying HTML tag.
928 | """
929 | def select(form, field, options, opts \\ []) when is_atom(field) or is_binary(field) do
930 | {selected, opts} = selected(form, field, opts)
931 | options_html = options_for_select(options, selected)
932 |
933 | {options_html, opts} =
934 | case Keyword.pop(opts, :prompt) do
935 | {nil, opts} -> {options_html, opts}
936 | {prompt, opts} -> {[prompt_option(prompt) | options_html], opts}
937 | end
938 |
939 | opts =
940 | opts
941 | |> Keyword.put_new(:id, input_id(form, field))
942 | |> Keyword.put_new(:name, input_name(form, field))
943 |
944 | content_tag(:select, options_html, opts)
945 | end
946 |
947 | defp prompt_option(prompt) when is_list(prompt) do
948 | {prompt_key, prompt_opts} = Keyword.pop(prompt, :key)
949 |
950 | prompt_key ||
951 | raise ArgumentError,
952 | "expected :key key when building a prompt select option with a keyword list: " <>
953 | inspect(prompt)
954 |
955 | prompt_option(prompt_key, prompt_opts)
956 | end
957 |
958 | defp prompt_option(key) when is_binary(key), do: prompt_option(key, [])
959 |
960 | defp prompt_option(key, opts) when is_list(opts) do
961 | content_tag(:option, key, Keyword.put_new(opts, :value, ""))
962 | end
963 |
964 | @doc """
965 | Generates a select tag with the given `options`.
966 |
967 | Values are expected to be an Enumerable containing two-item tuples
968 | (like maps and keyword lists) or any Enumerable where the element
969 | will be used both as key and value for the generated select.
970 |
971 | ## Examples
972 |
973 | # Assuming form contains a User schema
974 | multiple_select(form, :roles, ["Admin": 1, "Power User": 2])
975 | #=>
976 | #=> Admin
977 | #=> Power User
978 | #=>
979 |
980 | multiple_select(form, :roles, ["Admin": 1, "Power User": 2], selected: [1])
981 | #=>
982 | #=> Admin
983 | #=> Power User
984 | #=>
985 |
986 | When working with structs, associations, and embeds, you will need to tell
987 | Phoenix how to extract the value out of the collection. For example,
988 | imagine `user.roles` is a list of `%Role{}` structs. You must call it as:
989 |
990 | multiple_select(form, :roles, ["Admin": 1, "Power User": 2],
991 | selected: Enum.map(@user.roles, &(&1.id))
992 |
993 | The `:selected` option will mark the given IDs as selected unless the form
994 | is being resubmitted. When resubmitted, it uses the form params as values.
995 |
996 | When used with Ecto, you will typically do a query to retrieve the IDs from
997 | the database:
998 |
999 | from r in Role, where: r.id in ^(params["roles"] || [])
1000 |
1001 | And then use `Ecto.Changeset.put_assoc/2` to insert the new roles into the user.
1002 |
1003 | ## Options
1004 |
1005 | * `:selected` - the default options to be marked as selected. The values
1006 | on this list are ignored in case ids have been set as parameters.
1007 |
1008 | All other options are forwarded to the underlying HTML tag.
1009 | """
1010 | def multiple_select(form, field, options, opts \\ []) do
1011 | {selected, opts} = selected(form, field, opts)
1012 |
1013 | opts =
1014 | opts
1015 | |> Keyword.put_new(:id, input_id(form, field))
1016 | |> Keyword.put_new(:name, input_name(form, field) <> "[]")
1017 | |> Keyword.put_new(:multiple, "")
1018 |
1019 | content_tag(:select, options_for_select(options, selected), opts)
1020 | end
1021 |
1022 | defp selected(form, field, opts) do
1023 | {value, opts} = Keyword.pop(opts, :value)
1024 | {selected, opts} = Keyword.pop(opts, :selected)
1025 |
1026 | if value != nil do
1027 | {value, opts}
1028 | else
1029 | param = field_to_string(field)
1030 |
1031 | case form do
1032 | %{params: %{^param => sent}} ->
1033 | {sent, opts}
1034 |
1035 | _ ->
1036 | {selected || input_value(form, field), opts}
1037 | end
1038 | end
1039 | end
1040 |
1041 | ## Datetime
1042 |
1043 | @doc ~S'''
1044 | Generates select tags for datetime.
1045 |
1046 | Warning: This functionality is best provided by browsers nowadays.
1047 | Consider using `datetime_local_input/3` instead.
1048 |
1049 | ## Examples
1050 |
1051 | # Assuming form contains a User schema
1052 | datetime_select form, :born_at
1053 | #=> ... /
1054 | #=> ... /
1055 | #=> ... —
1056 | #=> ... :
1057 | #=> ...
1058 |
1059 | If you want to include the seconds field (hidden by default), pass `second: []`:
1060 |
1061 | # Assuming form contains a User schema
1062 | datetime_select form, :born_at, second: []
1063 |
1064 | If you want to configure the years range:
1065 |
1066 | # Assuming form contains a User schema
1067 | datetime_select form, :born_at, year: [options: 1900..2100]
1068 |
1069 | You are also able to configure `:month`, `:day`, `:hour`, `:minute` and
1070 | `:second`. All options given to those keys will be forwarded to the
1071 | underlying select. See `select/4` for more information.
1072 |
1073 | For example, if you are using Phoenix with Gettext and you want to localize
1074 | the list of months, you can pass `:options` to the `:month` key:
1075 |
1076 | # Assuming form contains a User schema
1077 | datetime_select form, :born_at, month: [
1078 | options: [
1079 | {gettext("January"), "1"},
1080 | {gettext("February"), "2"},
1081 | {gettext("March"), "3"},
1082 | {gettext("April"), "4"},
1083 | {gettext("May"), "5"},
1084 | {gettext("June"), "6"},
1085 | {gettext("July"), "7"},
1086 | {gettext("August"), "8"},
1087 | {gettext("September"), "9"},
1088 | {gettext("October"), "10"},
1089 | {gettext("November"), "11"},
1090 | {gettext("December"), "12"},
1091 | ]
1092 | ]
1093 |
1094 | You may even provide your own `localized_datetime_select/3` built on top of
1095 | `datetime_select/3`:
1096 |
1097 | defp localized_datetime_select(form, field, opts \\ []) do
1098 | opts =
1099 | Keyword.put(opts, :month, options: [
1100 | {gettext("January"), "1"},
1101 | {gettext("February"), "2"},
1102 | {gettext("March"), "3"},
1103 | {gettext("April"), "4"},
1104 | {gettext("May"), "5"},
1105 | {gettext("June"), "6"},
1106 | {gettext("July"), "7"},
1107 | {gettext("August"), "8"},
1108 | {gettext("September"), "9"},
1109 | {gettext("October"), "10"},
1110 | {gettext("November"), "11"},
1111 | {gettext("December"), "12"},
1112 | ])
1113 |
1114 | datetime_select(form, field, opts)
1115 | end
1116 |
1117 | ## Options
1118 |
1119 | * `:value` - the value used to select a given option.
1120 | The default value is extracted from the form data if available.
1121 |
1122 | * `:default` - the default value to use when none was given in
1123 | `:value` and none is available in the form data
1124 |
1125 | * `:year`, `:month`, `:day`, `:hour`, `:minute`, `:second` - options passed
1126 | to the underlying select. See `select/4` for more information.
1127 | The available values can be given in `:options`.
1128 |
1129 | * `:builder` - specify how the select can be build. It must be a function
1130 | that receives a builder that should be invoked with the select name
1131 | and a set of options. See builder below for more information.
1132 |
1133 | ## Builder
1134 |
1135 | The generated datetime_select can be customized at will by providing a
1136 | builder option. Here is an example from EEx:
1137 |
1138 | <%= datetime_select form, :born_at, builder: fn b -> %>
1139 | Date: <%= b.(:day, []) %> / <%= b.(:month, []) %> / <%= b.(:year, []) %>
1140 | Time: <%= b.(:hour, []) %> : <%= b.(:minute, []) %>
1141 | <% end %>
1142 |
1143 | Although we have passed empty lists as options (they are required), you
1144 | could pass any option there and it would be given to the underlying select
1145 | input.
1146 |
1147 | In practice, we recommend you to create your own helper with your default
1148 | builder:
1149 |
1150 | def my_datetime_select(form, field, opts \\ []) do
1151 | builder = fn b ->
1152 | assigns = %{b: b}
1153 |
1154 | ~H"""
1155 | Date: <%= @b.(:day, []) %> / <%= @b.(:month, []) %> / <%= @b.(:year, []) %>
1156 | Time: <%= @b.(:hour, []) %> : <%= @b.(:minute, []) %>
1157 | """
1158 | end
1159 |
1160 | datetime_select(form, field, [builder: builder] ++ opts)
1161 | end
1162 |
1163 | Then you are able to use your own datetime_select throughout your whole
1164 | application.
1165 |
1166 | ## Supported date values
1167 |
1168 | The following values are supported as date:
1169 |
1170 | * a map containing the `year`, `month` and `day` keys (either as strings or atoms)
1171 | * a tuple with three elements: `{year, month, day}`
1172 | * a string in ISO 8601 format
1173 | * `nil`
1174 |
1175 | ## Supported time values
1176 |
1177 | The following values are supported as time:
1178 |
1179 | * a map containing the `hour` and `minute` keys and an optional `second` key (either as strings or atoms)
1180 | * a tuple with three elements: `{hour, min, sec}`
1181 | * a tuple with four elements: `{hour, min, sec, usec}`
1182 | * `nil`
1183 |
1184 | '''
1185 | def datetime_select(form, field, opts \\ []) do
1186 | value = Keyword.get(opts, :value, input_value(form, field) || Keyword.get(opts, :default))
1187 |
1188 | builder =
1189 | Keyword.get(opts, :builder) ||
1190 | fn b ->
1191 | date = date_builder(b, opts)
1192 | time = time_builder(b, opts)
1193 | html_escape([date, raw(" — "), time])
1194 | end
1195 |
1196 | builder.(datetime_builder(form, field, date_value(value), time_value(value), opts))
1197 | end
1198 |
1199 | @doc """
1200 | Generates select tags for date.
1201 |
1202 | Warning: This functionality is best provided by browsers nowadays.
1203 | Consider using `date_input/3` instead.
1204 |
1205 | Check `datetime_select/3` for more information on options and supported values.
1206 | """
1207 | def date_select(form, field, opts \\ []) do
1208 | value = Keyword.get(opts, :value, input_value(form, field) || Keyword.get(opts, :default))
1209 | builder = Keyword.get(opts, :builder) || (&date_builder(&1, opts))
1210 | builder.(datetime_builder(form, field, date_value(value), nil, opts))
1211 | end
1212 |
1213 | defp date_builder(b, _opts) do
1214 | html_escape([b.(:year, []), raw(" / "), b.(:month, []), raw(" / "), b.(:day, [])])
1215 | end
1216 |
1217 | defp date_value(%{"year" => year, "month" => month, "day" => day}),
1218 | do: %{year: year, month: month, day: day}
1219 |
1220 | defp date_value(%{year: year, month: month, day: day}),
1221 | do: %{year: year, month: month, day: day}
1222 |
1223 | defp date_value({{year, month, day}, _}), do: %{year: year, month: month, day: day}
1224 | defp date_value({year, month, day}), do: %{year: year, month: month, day: day}
1225 |
1226 | defp date_value(nil), do: %{year: nil, month: nil, day: nil}
1227 |
1228 | defp date_value(string) when is_binary(string) do
1229 | string
1230 | |> Date.from_iso8601!()
1231 | |> date_value
1232 | end
1233 |
1234 | defp date_value(other), do: raise(ArgumentError, "unrecognized date #{inspect(other)}")
1235 |
1236 | @doc """
1237 | Generates select tags for time.
1238 |
1239 | Warning: This functionality is best provided by browsers nowadays.
1240 | Consider using `time_input/3` instead.
1241 |
1242 | Check `datetime_select/3` for more information on options and supported values.
1243 | """
1244 | def time_select(form, field, opts \\ []) do
1245 | value = Keyword.get(opts, :value, input_value(form, field) || Keyword.get(opts, :default))
1246 | builder = Keyword.get(opts, :builder) || (&time_builder(&1, opts))
1247 | builder.(datetime_builder(form, field, nil, time_value(value), opts))
1248 | end
1249 |
1250 | defp time_builder(b, opts) do
1251 | time = html_escape([b.(:hour, []), raw(" : "), b.(:minute, [])])
1252 |
1253 | if Keyword.get(opts, :second) do
1254 | html_escape([time, raw(" : "), b.(:second, [])])
1255 | else
1256 | time
1257 | end
1258 | end
1259 |
1260 | defp time_value(%{"hour" => hour, "minute" => min} = map),
1261 | do: %{hour: hour, minute: min, second: Map.get(map, "second", 0)}
1262 |
1263 | defp time_value(%{hour: hour, minute: min} = map),
1264 | do: %{hour: hour, minute: min, second: Map.get(map, :second, 0)}
1265 |
1266 | defp time_value({_, {hour, min, sec}}),
1267 | do: %{hour: hour, minute: min, second: sec}
1268 |
1269 | defp time_value({hour, min, sec}),
1270 | do: %{hour: hour, minute: min, second: sec}
1271 |
1272 | defp time_value(nil), do: %{hour: nil, minute: nil, second: nil}
1273 |
1274 | defp time_value(string) when is_binary(string) do
1275 | string
1276 | |> Time.from_iso8601!()
1277 | |> time_value
1278 | end
1279 |
1280 | defp time_value(other), do: raise(ArgumentError, "unrecognized time #{inspect(other)}")
1281 |
1282 | @months [
1283 | {"January", "1"},
1284 | {"February", "2"},
1285 | {"March", "3"},
1286 | {"April", "4"},
1287 | {"May", "5"},
1288 | {"June", "6"},
1289 | {"July", "7"},
1290 | {"August", "8"},
1291 | {"September", "9"},
1292 | {"October", "10"},
1293 | {"November", "11"},
1294 | {"December", "12"}
1295 | ]
1296 |
1297 | map =
1298 | &Enum.map(&1, fn i ->
1299 | pre = if i < 10, do: "0"
1300 | {"#{pre}#{i}", i}
1301 | end)
1302 |
1303 | @days map.(1..31)
1304 | @hours map.(0..23)
1305 | @minsec map.(0..59)
1306 |
1307 | defp datetime_builder(form, field, date, time, parent) do
1308 | id = Keyword.get(parent, :id, input_id(form, field))
1309 | name = Keyword.get(parent, :name, input_name(form, field))
1310 |
1311 | fn
1312 | :year, opts when date != nil ->
1313 | {year, _, _} = :erlang.date()
1314 |
1315 | {value, opts} =
1316 | datetime_options(:year, (year - 5)..(year + 5), id, name, parent, date, opts)
1317 |
1318 | select(:datetime, :year, value, opts)
1319 |
1320 | :month, opts when date != nil ->
1321 | {value, opts} = datetime_options(:month, @months, id, name, parent, date, opts)
1322 | select(:datetime, :month, value, opts)
1323 |
1324 | :day, opts when date != nil ->
1325 | {value, opts} = datetime_options(:day, @days, id, name, parent, date, opts)
1326 | select(:datetime, :day, value, opts)
1327 |
1328 | :hour, opts when time != nil ->
1329 | {value, opts} = datetime_options(:hour, @hours, id, name, parent, time, opts)
1330 | select(:datetime, :hour, value, opts)
1331 |
1332 | :minute, opts when time != nil ->
1333 | {value, opts} = datetime_options(:minute, @minsec, id, name, parent, time, opts)
1334 | select(:datetime, :minute, value, opts)
1335 |
1336 | :second, opts when time != nil ->
1337 | {value, opts} = datetime_options(:second, @minsec, id, name, parent, time, opts)
1338 | select(:datetime, :second, value, opts)
1339 | end
1340 | end
1341 |
1342 | defp datetime_options(type, values, id, name, parent, datetime, opts) do
1343 | opts = Keyword.merge(Keyword.get(parent, type, []), opts)
1344 | suff = Atom.to_string(type)
1345 |
1346 | {value, opts} = Keyword.pop(opts, :options, values)
1347 |
1348 | {value,
1349 | opts
1350 | |> Keyword.put_new(:id, id <> "_" <> suff)
1351 | |> Keyword.put_new(:name, name <> "[" <> suff <> "]")
1352 | |> Keyword.put_new(:value, Map.get(datetime, type))}
1353 | end
1354 |
1355 | @doc """
1356 | Generates a label tag.
1357 |
1358 | Useful when wrapping another input inside a label.
1359 |
1360 | ## Examples
1361 |
1362 | label do
1363 | radio_button :user, :choice, "Choice"
1364 | end
1365 | #=> ...
1366 |
1367 | label class: "control-label" do
1368 | radio_button :user, :choice, "Choice"
1369 | end
1370 | #=> ...
1371 |
1372 | """
1373 | def label(do_block)
1374 |
1375 | def label(do: block) do
1376 | content_tag(:label, block, [])
1377 | end
1378 |
1379 | def label(opts, do: block) when is_list(opts) do
1380 | content_tag(:label, block, opts)
1381 | end
1382 |
1383 | @doc """
1384 | Generates a label tag for the given field.
1385 |
1386 | The form should either be a `Phoenix.HTML.Form` emitted
1387 | by `form_for` or an atom.
1388 |
1389 | All given options are forwarded to the underlying tag.
1390 | A default value is provided for `for` attribute but can
1391 | be overridden if you pass a value to the `for` option.
1392 | Text content would be inferred from `field` if not specified
1393 | as either a function argument or string value in a block.
1394 |
1395 | To wrap a label around an input, see `label/1`.
1396 |
1397 | ## Examples
1398 |
1399 | # Assuming form contains a User schema
1400 | label(form, :name, "Name")
1401 | #=> Name
1402 |
1403 | label(:user, :email, "Email")
1404 | #=> Email
1405 |
1406 | label(:user, :email)
1407 | #=> Email
1408 |
1409 | label(:user, :email, class: "control-label")
1410 | #=> Email
1411 |
1412 | label :user, :email do
1413 | "E-mail Address"
1414 | end
1415 | #=> E-mail Address
1416 |
1417 | label :user, :email, "E-mail Address", class: "control-label"
1418 | #=> E-mail Address
1419 |
1420 | label :user, :email, class: "control-label" do
1421 | "E-mail Address"
1422 | end
1423 | #=> E-mail Address
1424 |
1425 | """
1426 | def label(form, field) when is_atom(field) or is_binary(field) do
1427 | label(form, field, humanize(field), [])
1428 | end
1429 |
1430 | @doc """
1431 | See `label/2`.
1432 | """
1433 | def label(form, field, text_or_do_block_or_attributes)
1434 |
1435 | def label(form, field, do: block) do
1436 | label(form, field, [], do: block)
1437 | end
1438 |
1439 | def label(form, field, opts) when is_list(opts) do
1440 | label(form, field, humanize(field), opts)
1441 | end
1442 |
1443 | def label(form, field, text) do
1444 | label(form, field, text, [])
1445 | end
1446 |
1447 | @doc """
1448 | See `label/2`.
1449 | """
1450 | def label(form, field, text, do_block_or_attributes)
1451 |
1452 | def label(form, field, opts, do: block) when is_list(opts) do
1453 | opts = Keyword.put_new(opts, :for, input_id(form, field))
1454 | content_tag(:label, block, opts)
1455 | end
1456 |
1457 | def label(form, field, text, opts) when is_list(opts) do
1458 | opts = Keyword.put_new(opts, :for, input_id(form, field))
1459 | content_tag(:label, text, opts)
1460 | end
1461 |
1462 | # Normalize field name to string version
1463 | defp field_to_string(field) when is_atom(field), do: Atom.to_string(field)
1464 | defp field_to_string(field) when is_binary(field), do: field
1465 | end
1466 |
--------------------------------------------------------------------------------
/test/phoenix_html_helpers/form_test.exs:
--------------------------------------------------------------------------------
1 | defmodule PhoenixHTMLHelpers.FormTest do
2 | use ExUnit.Case, async: true
3 |
4 | import Phoenix.HTML
5 | import PhoenixHTMLHelpers.Form
6 | doctest PhoenixHTMLHelpers.Form
7 |
8 | defp search_params do
9 | %{
10 | "key" => "value",
11 | "time" => ~T[01:02:03.004005],
12 | "datetime" => %{
13 | "year" => "2020",
14 | "month" => "4",
15 | "day" => "17",
16 | "hour" => "2",
17 | "minute" => "11",
18 | "second" => "13"
19 | },
20 | "naive_datetime" => ~N[2000-01-01 10:00:42]
21 | }
22 | end
23 |
24 | describe "form_for/4 with map" do
25 | test "with :as" do
26 | search_params = search_params()
27 |
28 | form =
29 | safe_to_string(
30 | form_for(search_params, "/", [as: :search], fn f ->
31 | assert f.impl == Phoenix.HTML.FormData.Map
32 | assert f.name == "search"
33 | assert f.source == search_params
34 | assert f.params["key"] == "value"
35 | ""
36 | end)
37 | )
38 |
39 | assert form =~ ~s()
73 | end
74 |
75 | test "with type and validations" do
76 | form =
77 | safe_to_string(
78 | form_for(search_params(), "/", [as: :search], fn f ->
79 | assert input_type(f, :hello) == :text_input
80 | assert input_type(f, :email) == :email_input
81 | assert input_type(f, :search) == :search_input
82 | assert input_type(f, :password) == :password_input
83 | assert input_type(f, :special_url) == :url_input
84 | assert input_type(f, :number, %{"number" => :number_input}) == :number_input
85 | ""
86 | end)
87 | )
88 |
89 | assert form =~ "
98 | for {field, {message, _}} <- f.errors do
99 | PhoenixHTMLHelpers.Tag.content_tag(:span, humanize(field) <> " " <> message,
100 | class: "errors"
101 | )
102 | end
103 | end)
104 | )
105 |
106 | assert form =~ ~s(Field error message! )
107 | end
108 | end
109 |
110 | defp conn do
111 | Plug.Test.conn(:get, "/foo", %{"search" => search_params()})
112 | end
113 |
114 | def conn_form(fun, opts \\ [as: :search]) do
115 | mark = "--PLACEHOLDER--"
116 |
117 | contents =
118 | safe_to_string(
119 | form_for(conn(), "/", opts, fn f ->
120 | html_escape([mark, fun.(f), mark])
121 | end)
122 | )
123 |
124 | [_, inner, _] = String.split(contents, mark)
125 | inner
126 | end
127 |
128 | describe "form_for/4 with connection" do
129 | test "with :as" do
130 | conn = conn()
131 |
132 | form =
133 | safe_to_string(
134 | form_for(conn, "/", [as: :search], fn f ->
135 | assert f.impl == Phoenix.HTML.FormData.Plug.Conn
136 | assert f.name == "search"
137 | assert f.source == conn
138 | assert f.params["key"] == "value"
139 | ""
140 | end)
141 | )
142 |
143 | assert form =~ ~s()
177 | end
178 |
179 | test "with type and validations" do
180 | form =
181 | safe_to_string(
182 | form_for(conn(), "/", [as: :search], fn f ->
183 | assert input_type(f, :hello) == :text_input
184 | assert input_type(f, :email) == :email_input
185 | assert input_type(f, :search) == :search_input
186 | assert input_type(f, :password) == :password_input
187 | assert input_type(f, :special_url) == :url_input
188 | assert input_type(f, :number, %{"number" => :number_input}) == :number_input
189 | ""
190 | end)
191 | )
192 |
193 | assert form =~ "
202 | for {field, {message, _}} <- f.errors do
203 | PhoenixHTMLHelpers.Tag.content_tag(:span, humanize(field) <> " " <> message,
204 | class: "errors"
205 | )
206 | end
207 | end)
208 | )
209 |
210 | assert form =~ ~s(Field error message! )
211 | end
212 | end
213 |
214 | describe "form_for/4 with atom" do
215 | test "without params" do
216 | form =
217 | safe_to_string(
218 | form_for(:search, "/", fn f ->
219 | assert f.impl == Phoenix.HTML.FormData.Atom
220 | assert f.name == "search"
221 | assert f.source == :search
222 | assert f.params == %{}
223 | ""
224 | end)
225 | )
226 |
227 | assert form =~ ~s()
261 | end
262 |
263 | test "with type and validations" do
264 | form =
265 | safe_to_string(
266 | form_for(:search, "/", [], fn f ->
267 | assert input_type(f, :hello) == :text_input
268 | assert input_type(f, :email) == :email_input
269 | assert input_type(f, :search) == :search_input
270 | assert input_type(f, :password) == :password_input
271 | assert input_type(f, :special_url) == :url_input
272 | assert input_type(f, :number, %{"number" => :number_input}) == :number_input
273 | ""
274 | end)
275 | )
276 |
277 | assert form =~ "
286 | for {field, {message, _}} <- f.errors do
287 | PhoenixHTMLHelpers.Tag.content_tag(:span, humanize(field) <> " " <> message,
288 | class: "errors"
289 | )
290 | end
291 | end)
292 | )
293 |
294 | assert form =~ ~s(Field error message! )
295 | end
296 |
297 | test "with id prefix the form id in the input id" do
298 | form =
299 | safe_to_string(
300 | form_for(:search, "/", [params: search_params(), id: "form_id"], fn f ->
301 | text_input(f, :key)
302 | end)
303 | )
304 |
305 | assert form =~
306 | ~s(Submit )
752 |
753 | assert safe_to_string(submit("Submit", class: "btn")) ==
754 | ~s(Submit )
755 |
756 | assert safe_to_string(submit([class: "btn"], do: "Submit")) ==
757 | ~s(Submit )
758 |
759 | assert safe_to_string(submit(do: "Submit")) == ~s(Submit )
760 |
761 | assert safe_to_string(submit("")) == ~s(<Submit> )
762 |
763 | assert safe_to_string(submit("", class: "btn")) ==
764 | ~s(<Submit> )
765 |
766 | assert safe_to_string(submit([class: "btn"], do: "")) ==
767 | ~s(<Submit> )
768 |
769 | assert safe_to_string(submit(do: "")) ==
770 | ~s(<Submit> )
771 | end
772 |
773 | ## reset/2
774 |
775 | test "reset/2" do
776 | assert safe_to_string(reset("Reset")) == ~s() <>
875 | ~s(foo ) <>
876 | ~s(bar ) <> ~s( )
877 |
878 | assert safe_to_string(select(:search, :key, Foo: "foo", Bar: "bar")) ==
879 | ~s() <>
880 | ~s(Foo ) <>
881 | ~s(Bar ) <> ~s( )
882 |
883 | assert safe_to_string(
884 | select(:search, :key, [
885 | [key: "Foo", value: "foo"],
886 | [key: "Bar", value: "bar", disabled: true]
887 | ])
888 | ) ==
889 | ~s() <>
890 | ~s(Foo ) <>
891 | ~s(Bar ) <> ~s( )
892 |
893 | assert safe_to_string(
894 | select(:search, :key, [Foo: "foo", Bar: "bar"], prompt: "Choose your destiny")
895 | ) ==
896 | ~s() <>
897 | ~s(Choose your destiny ) <>
898 | ~s(Foo ) <>
899 | ~s(Bar ) <> ~s( )
900 |
901 | assert safe_to_string(
902 | select(:search, :key, [Foo: "foo", Bar: "bar"],
903 | prompt: [key: "Choose your destiny", disabled: true]
904 | )
905 | ) ==
906 | ~s() <>
907 | ~s(Choose your destiny ) <>
908 | ~s(Foo ) <>
909 | ~s(Bar ) <> ~s( )
910 |
911 | assert_raise ArgumentError, fn ->
912 | select(:search, :key, [Foo: "foo", Bar: "bar"], prompt: [])
913 | end
914 |
915 | assert safe_to_string(select(:search, :key, ~w(foo bar), value: "foo")) =~
916 | ~s(foo )
917 |
918 | assert safe_to_string(select(:search, :key, ~w(foo bar), selected: "foo")) =~
919 | ~s(foo )
920 | end
921 |
922 | test "select/4 with form" do
923 | assert conn_form(&select(&1, :key, ~w(value novalue), selected: "novalue")) ==
924 | ~s() <>
925 | ~s(value ) <>
926 | ~s(novalue ) <> ~s( )
927 |
928 | assert conn_form(&select(&1, :other, ~w(value novalue), selected: "novalue")) ==
929 | ~s() <>
930 | ~s(value ) <>
931 | ~s(novalue ) <> ~s( )
932 |
933 | assert conn_form(
934 | &select(
935 | &1,
936 | :key,
937 | [
938 | [value: "value", key: "Value", disabled: true],
939 | [value: "novalue", key: "No Value"]
940 | ],
941 | selected: "novalue"
942 | )
943 | ) ==
944 | ~s() <>
945 | ~s(Value ) <>
946 | ~s(No Value ) <> ~s( )
947 |
948 | assert conn_form(
949 | &select(
950 | put_in(&1.data[:other], "value"),
951 | :other,
952 | ~w(value novalue),
953 | selected: "novalue"
954 | )
955 | ) ==
956 | ~s() <>
957 | ~s(value ) <>
958 | ~s(novalue ) <> ~s( )
959 |
960 | assert conn_form(&select(&1, :key, ~w(value novalue), value: "novalue")) ==
961 | ~s() <>
962 | ~s(value ) <>
963 | ~s(novalue ) <> ~s( )
964 | end
965 |
966 | test "select/4 with groups" do
967 | assert conn_form(
968 | &select(&1, :key, [{"foo", ~w(bar baz)}, {"qux", ~w(qux quz)}], value: "qux")
969 | ) ==
970 | ~s() <>
971 | ~s() <>
972 | ~s(bar ) <>
973 | ~s(baz ) <>
974 | ~s( ) <>
975 | ~s() <>
976 | ~s(qux ) <>
977 | ~s(quz ) <> ~s( ) <> ~s( )
978 |
979 | assert conn_form(
980 | &select(
981 | &1,
982 | :key,
983 | [foo: [{"1", "One"}, {"2", "Two"}], qux: ~w(qux quz)],
984 | value: "qux"
985 | )
986 | ) ==
987 | ~s() <>
988 | ~s() <>
989 | ~s(1 ) <>
990 | ~s(2 ) <>
991 | ~s( ) <>
992 | ~s() <>
993 | ~s(qux ) <>
994 | ~s(quz ) <> ~s( ) <> ~s( )
995 |
996 | assert conn_form(
997 | &select(
998 | &1,
999 | :key,
1000 | %{"foo" => %{"1" => "One", "2" => "Two"}, "qux" => ~w(qux quz)},
1001 | value: "qux"
1002 | )
1003 | ) ==
1004 | ~s() <>
1005 | ~s() <>
1006 | ~s(1 ) <>
1007 | ~s(2 ) <>
1008 | ~s( ) <>
1009 | ~s() <>
1010 | ~s(qux ) <>
1011 | ~s(quz ) <> ~s( ) <> ~s( )
1012 |
1013 | assert conn_form(
1014 | &select(
1015 | &1,
1016 | :key,
1017 | %{"foo" => [{"1", "One"}, {"2", "Two"}], "qux" => ~w(qux quz)},
1018 | value: "qux"
1019 | )
1020 | ) ==
1021 | ~s() <>
1022 | ~s() <>
1023 | ~s(1 ) <>
1024 | ~s(2 ) <>
1025 | ~s( ) <>
1026 | ~s() <>
1027 | ~s(qux ) <>
1028 | ~s(quz ) <> ~s( ) <> ~s( )
1029 | end
1030 |
1031 | # multiple_select/4
1032 |
1033 | test "multiple_select/4" do
1034 | assert safe_to_string(multiple_select(:search, :key, ~w(foo bar))) ==
1035 | ~s() <>
1036 | ~s(foo ) <>
1037 | ~s(bar ) <> ~s( )
1038 |
1039 | assert safe_to_string(multiple_select(:search, :key, [{"foo", 1}, {"bar", 2}])) ==
1040 | ~s() <>
1041 | ~s(foo ) <>
1042 | ~s(bar ) <> ~s( )
1043 |
1044 | assert safe_to_string(multiple_select(:search, :key, ~w(foo bar), value: ["foo"])) =~
1045 | ~s(foo )
1046 |
1047 | assert safe_to_string(
1048 | multiple_select(:search, :key, [{"foo", "1"}, {"bar", "2"}], value: [1])
1049 | ) =~ ~s(foo )
1050 |
1051 | assert safe_to_string(multiple_select(:search, :key, [{"foo", 1}, {"bar", 2}], selected: [1])) =~
1052 | ~s(foo )
1053 |
1054 | assert safe_to_string(
1055 | multiple_select(:search, :key, %{"foo" => [{"One", 1}, {"Two", 2}], "bar" => ~w(3 4)})
1056 | ) ==
1057 | ~s() <>
1058 | ~s() <>
1059 | ~s(3 ) <>
1060 | ~s(4 ) <>
1061 | ~s( ) <>
1062 | ~s() <>
1063 | ~s(One ) <>
1064 | ~s(Two ) <> ~s( ) <> ~s( )
1065 | end
1066 |
1067 | test "multiple_select/4 with form" do
1068 | assert conn_form(
1069 | &multiple_select(&1, :key, [{"foo", 1}, {"bar", 2}], value: [1], selected: [2])
1070 | ) ==
1071 | ~s() <>
1072 | ~s(foo ) <>
1073 | ~s(bar ) <> ~s( )
1074 |
1075 | assert conn_form(&multiple_select(&1, :other, [{"foo", 1}, {"bar", 2}], selected: [2])) ==
1076 | ~s() <>
1077 | ~s(foo ) <>
1078 | ~s(bar ) <> ~s( )
1079 |
1080 | assert conn_form(&multiple_select(&1, :key, [{"foo", 1}, {"bar", 2}], value: [2])) ==
1081 | ~s() <>
1082 | ~s(foo ) <>
1083 | ~s(bar ) <> ~s( )
1084 |
1085 | assert conn_form(&multiple_select(&1, :key, ~w(value novalue), value: ["novalue"])) ==
1086 | ~s() <>
1087 | ~s(value ) <>
1088 | ~s(novalue ) <> ~s( )
1089 |
1090 | assert conn_form(
1091 | &multiple_select(
1092 | put_in(&1.params["key"], ["3"]),
1093 | :key,
1094 | [{"foo", 1}, {"bar", 2}, {"goo", 3}],
1095 | selected: [2]
1096 | )
1097 | ) ==
1098 | ~s() <>
1099 | ~s(foo ) <>
1100 | ~s(bar ) <>
1101 | ~s(goo ) <> ~s( )
1102 | end
1103 |
1104 | test "multiple_select/4 with unnamed form" do
1105 | assert conn_form(
1106 | &multiple_select(&1, :key, [{"foo", 1}, {"bar", 2}], value: [1], selected: [2]),
1107 | []
1108 | ) ==
1109 | ~s() <>
1110 | ~s(foo ) <>
1111 | ~s(bar ) <> ~s( )
1112 |
1113 | assert conn_form(&multiple_select(&1, :other, [{"foo", 1}, {"bar", 2}], selected: [2]), []) ==
1114 | ~s() <>
1115 | ~s(foo ) <>
1116 | ~s(bar ) <> ~s( )
1117 |
1118 | assert conn_form(&multiple_select(&1, :key, [{"foo", 1}, {"bar", 2}], value: [2]), []) ==
1119 | ~s() <>
1120 | ~s(foo ) <>
1121 | ~s(bar ) <> ~s( )
1122 |
1123 | assert conn_form(&multiple_select(&1, :key, ~w(value novalue), value: ["novalue"]), []) ==
1124 | ~s() <>
1125 | ~s(value ) <>
1126 | ~s(novalue ) <> ~s( )
1127 |
1128 | assert conn_form(
1129 | &multiple_select(
1130 | put_in(&1.params["key"], ["3"]),
1131 | :key,
1132 | [{"foo", 1}, {"bar", 2}, {"goo", 3}],
1133 | selected: [2]
1134 | ),
1135 | []
1136 | ) ==
1137 | ~s() <>
1138 | ~s(foo ) <>
1139 | ~s(bar ) <>
1140 | ~s(goo ) <> ~s( )
1141 | end
1142 |
1143 | # date_select/4
1144 |
1145 | test "date_select/4" do
1146 | content = safe_to_string(date_select(:search, :datetime))
1147 | assert content =~ ~s()
1148 | assert content =~ ~s()
1149 | assert content =~ ~s()
1150 |
1151 | content = safe_to_string(date_select(:search, :datetime, value: {2020, 04, 17}))
1152 | assert content =~ ~s(2020 )
1153 | assert content =~ ~s(April )
1154 | assert content =~ ~s(17 )
1155 |
1156 | content = safe_to_string(date_select(:search, :datetime, value: "2020-04-17"))
1157 | assert content =~ ~s(2020 )
1158 | assert content =~ ~s(April )
1159 | assert content =~ ~s(17 )
1160 |
1161 | content =
1162 | safe_to_string(date_select(:search, :datetime, value: %{year: 2020, month: 04, day: 07}))
1163 |
1164 | assert content =~ ~s(2020 )
1165 | assert content =~ ~s(April )
1166 | assert content =~ ~s(07 )
1167 |
1168 | content =
1169 | safe_to_string(date_select(:search, :datetime, value: %{year: 2020, month: 04, day: 09}))
1170 |
1171 | assert content =~ ~s(2020 )
1172 | assert content =~ ~s(April )
1173 | assert content =~ ~s(09 )
1174 |
1175 | content =
1176 | safe_to_string(
1177 | date_select(
1178 | :search,
1179 | :datetime,
1180 | year: [prompt: "Year"],
1181 | month: [prompt: "Month"],
1182 | day: [prompt: "Day"]
1183 | )
1184 | )
1185 |
1186 | assert content =~
1187 | ~s() <>
1188 | ~s(Year )
1189 |
1190 | assert content =~
1191 | ~s() <>
1192 | ~s(Month )
1193 |
1194 | assert content =~
1195 | ~s() <>
1196 | ~s(Day )
1197 | end
1198 |
1199 | test "date_select/4 with form" do
1200 | content = conn_form(&date_select(&1, :datetime, default: {2020, 10, 13}))
1201 | assert content =~ ~s()
1202 | assert content =~ ~s()
1203 | assert content =~ ~s()
1204 | assert content =~ ~s(2020 )
1205 | assert content =~ ~s(April )
1206 | assert content =~ ~s(17 )
1207 | assert content =~ ~s(January February )
1208 |
1209 | content = conn_form(&date_select(&1, :unknown, default: {2020, 9, 9}))
1210 | assert content =~ ~s(2020 )
1211 | assert content =~ ~s(September )
1212 | assert content =~ ~s(09 )
1213 |
1214 | content = conn_form(&date_select(&1, :unknown, default: {2020, 10, 13}))
1215 | assert content =~ ~s(2020 )
1216 | assert content =~ ~s(October )
1217 | assert content =~ ~s(13 )
1218 |
1219 | content = conn_form(&date_select(&1, :datetime, value: {2020, 10, 13}))
1220 | assert content =~ ~s(2020 )
1221 | assert content =~ ~s(October )
1222 | assert content =~ ~s(13 )
1223 | end
1224 |
1225 | # time_select/4
1226 |
1227 | test "time_select/4" do
1228 | content = safe_to_string(time_select(:search, :datetime))
1229 | assert content =~ ~s()
1230 | assert content =~ ~s()
1231 | refute content =~ ~s()
1232 |
1233 | content = safe_to_string(time_select(:search, :datetime, second: []))
1234 | assert content =~ ~s()
1235 | assert content =~ ~s()
1236 | assert content =~ ~s()
1237 |
1238 | content = safe_to_string(time_select(:search, :datetime, value: {2, 9, 9}, second: []))
1239 | assert content =~ ~s(02 )
1240 | assert content =~ ~s(09 )
1241 | assert content =~ ~s(09 )
1242 |
1243 | content = safe_to_string(time_select(:search, :datetime, value: "02:11:13.123Z", second: []))
1244 | assert content =~ ~s(02 )
1245 | assert content =~ ~s(11 )
1246 | assert content =~ ~s(13 )
1247 |
1248 | content = safe_to_string(time_select(:search, :datetime, value: {2, 11, 13}, second: []))
1249 | assert content =~ ~s(02 )
1250 | assert content =~ ~s(11 )
1251 | assert content =~ ~s(13 )
1252 |
1253 | content =
1254 | safe_to_string(
1255 | time_select(:search, :datetime, value: %{hour: 2, minute: 11, second: 13}, second: [])
1256 | )
1257 |
1258 | assert content =~ ~s(02 )
1259 | assert content =~ ~s(11 )
1260 | assert content =~ ~s(13 )
1261 |
1262 | content =
1263 | safe_to_string(
1264 | time_select(
1265 | :search,
1266 | :datetime,
1267 | hour: [prompt: "Hour"],
1268 | minute: [prompt: "Minute"],
1269 | second: [prompt: "Second"]
1270 | )
1271 | )
1272 |
1273 | assert content =~
1274 | ~s() <>
1275 | ~s(Hour )
1276 |
1277 | assert content =~
1278 | ~s() <>
1279 | ~s(Minute )
1280 |
1281 | assert content =~
1282 | ~s() <>
1283 | ~s(Second )
1284 | end
1285 |
1286 | test "time_select/4 with form" do
1287 | content = conn_form(&time_select(&1, :datetime, default: {1, 2, 3}, second: []))
1288 | assert content =~ ~s()
1289 | assert content =~ ~s()
1290 | assert content =~ ~s()
1291 | assert content =~ ~s(02 )
1292 | assert content =~ ~s(11 )
1293 | assert content =~ ~s(13 )
1294 | assert content =~ ~s(01 02 )
1295 |
1296 | content = conn_form(&time_select(&1, :unknown, default: {1, 2, 3}, second: []))
1297 | assert content =~ ~s(01 )
1298 | assert content =~ ~s(02 )
1299 | assert content =~ ~s(03 )
1300 |
1301 | content = conn_form(&time_select(&1, :datetime, value: {1, 2, 3}, second: []))
1302 | assert content =~ ~s(01 )
1303 | assert content =~ ~s(02 )
1304 | assert content =~ ~s(03 )
1305 | end
1306 |
1307 | # datetime_select/4
1308 |
1309 | test "datetime_select/4" do
1310 | content = safe_to_string(datetime_select(:search, :datetime))
1311 | assert content =~ ~s()
1312 | assert content =~ ~s()
1313 | assert content =~ ~s()
1314 | assert content =~ ~s()
1315 | assert content =~ ~s()
1316 | refute content =~ ~s()
1317 |
1318 | content = safe_to_string(datetime_select(:search, :datetime, second: []))
1319 | assert content =~ ~s()
1320 | assert content =~ ~s()
1321 | assert content =~ ~s()
1322 | assert content =~ ~s()
1323 | assert content =~ ~s()
1324 | assert content =~ ~s()
1325 |
1326 | content =
1327 | safe_to_string(
1328 | datetime_select(:search, :datetime, value: {{2020, 9, 9}, {2, 11, 13}}, second: [])
1329 | )
1330 |
1331 | assert content =~ ~s(2020 )
1332 | assert content =~ ~s(September )
1333 | assert content =~ ~s(09 )
1334 | assert content =~ ~s(02 )
1335 | assert content =~ ~s(11 )
1336 | assert content =~ ~s(13 )
1337 |
1338 | content =
1339 | safe_to_string(
1340 | datetime_select(:search, :datetime, value: {{2020, 04, 17}, {2, 11, 13}}, second: [])
1341 | )
1342 |
1343 | assert content =~ ~s(2020 )
1344 | assert content =~ ~s(April )
1345 | assert content =~ ~s(17 )
1346 | assert content =~ ~s(02 )
1347 | assert content =~ ~s(11 )
1348 | assert content =~ ~s(13 )
1349 | end
1350 |
1351 | test "datetime_select/4 with form" do
1352 | content =
1353 | conn_form(&datetime_select(&1, :datetime, default: {{2020, 10, 13}, {1, 2, 3}}, second: []))
1354 |
1355 | assert content =~ ~s()
1356 | assert content =~ ~s()
1357 | assert content =~ ~s()
1358 | assert content =~ ~s(2020 )
1359 | assert content =~ ~s(April )
1360 | assert content =~ ~s(17 )
1361 |
1362 | assert content =~ ~s()
1363 | assert content =~ ~s()
1364 | assert content =~ ~s()
1365 | assert content =~ ~s(02 )
1366 | assert content =~ ~s(11 )
1367 | assert content =~ ~s(13 )
1368 |
1369 | content =
1370 | conn_form(&datetime_select(&1, :unknown, default: {{2020, 10, 9}, {1, 2, 3}}, second: []))
1371 |
1372 | assert content =~ ~s(2020 )
1373 | assert content =~ ~s(October )
1374 | assert content =~ ~s(09 )
1375 | assert content =~ ~s(01 )
1376 | assert content =~ ~s(02 )
1377 | assert content =~ ~s(03 )
1378 |
1379 | content =
1380 | conn_form(&datetime_select(&1, :unknown, default: {{2020, 10, 13}, {1, 2, 3}}, second: []))
1381 |
1382 | assert content =~ ~s(2020 )
1383 | assert content =~ ~s(October )
1384 | assert content =~ ~s(13 )
1385 | assert content =~ ~s(01 )
1386 | assert content =~ ~s(02 )
1387 | assert content =~ ~s(03 )
1388 |
1389 | content =
1390 | conn_form(&datetime_select(&1, :datetime, value: {{2020, 10, 13}, {1, 2, 3}}, second: []))
1391 |
1392 | assert content =~ ~s(2020 )
1393 | assert content =~ ~s(October )
1394 | assert content =~ ~s(13 )
1395 | assert content =~ ~s(01 )
1396 | assert content =~ ~s(02 )
1397 | assert content =~ ~s(03 )
1398 | end
1399 |
1400 | test "datetime_select/4 with builder" do
1401 | builder = fn b ->
1402 | html_escape([
1403 | "Year: ",
1404 | b.(:year, class: "year"),
1405 | "Month: ",
1406 | b.(:month, class: "month"),
1407 | "Day: ",
1408 | b.(:day, class: "day"),
1409 | "Hour: ",
1410 | b.(:hour, class: "hour"),
1411 | "Min: ",
1412 | b.(:minute, class: "min"),
1413 | "Sec: ",
1414 | b.(:second, class: "sec")
1415 | ])
1416 | end
1417 |
1418 | content =
1419 | safe_to_string(
1420 | datetime_select(
1421 | :search,
1422 | :datetime,
1423 | builder: builder,
1424 | year: [id: "year"],
1425 | month: [id: "month"],
1426 | day: [id: "day"],
1427 | hour: [id: "hour"],
1428 | minute: [id: "min"],
1429 | second: [id: "sec"]
1430 | )
1431 | )
1432 |
1433 | assert content =~ ~s(Year: )
1434 | assert content =~ ~s(Month: )
1435 | assert content =~ ~s(Day: )
1436 | assert content =~ ~s(Hour: )
1437 | assert content =~ ~s(Min: )
1438 | assert content =~ ~s(Sec: )
1439 | end
1440 |
1441 | describe "label" do
1442 | test "with block" do
1443 | assert safe_to_string(
1444 | label do
1445 | "Block"
1446 | end
1447 | ) == ~s(Block )
1448 |
1449 | assert safe_to_string(
1450 | label class: "foo" do
1451 | "Block"
1452 | end
1453 | ) == ~s(Block )
1454 | end
1455 |
1456 | test "with field but no content" do
1457 | assert safe_to_string(label(:search, :key)) == ~s(Key )
1458 |
1459 | assert safe_to_string(label(:search, :key, for: "test_key")) ==
1460 | ~s(Key )
1461 |
1462 | assert safe_to_string(label(:search, :key, for: "test_key", class: "foo")) ==
1463 | ~s(Key )
1464 | end
1465 |
1466 | test "with field and inline content" do
1467 | assert safe_to_string(label(:search, :key, "Search")) ==
1468 | ~s(Search )
1469 |
1470 | assert safe_to_string(label(:search, :key, "Search", for: "test_key")) ==
1471 | ~s(Search )
1472 |
1473 | assert conn_form(&label(&1, :key, "Search")) == ~s(Search )
1474 |
1475 | assert conn_form(&label(&1, :key, "Search", for: "test_key")) ==
1476 | ~s(Search )
1477 |
1478 | assert conn_form(&label(&1, :key, "Search", for: "test_key", class: "foo")) ==
1479 | ~s(Search )
1480 | end
1481 |
1482 | test "with field and inline safe content" do
1483 | assert safe_to_string(label(:search, :key, {:safe, "Search "})) ==
1484 | ~s(Search Hello )
1489 |
1490 | assert conn_form(&label(&1, :key, [class: "test-label"], do: "Hello")) ==
1491 | ~s(Hello )
1492 | end
1493 |
1494 | test "with atom or binary field" do
1495 | assert conn_form(&label(&1, :key, do: "Hello")) ==
1496 | ~s(Hello )
1497 |
1498 | assert conn_form(&label(&1, "key", do: "Hello")) ==
1499 | ~s(Hello )
1500 | end
1501 | end
1502 | end
1503 |
--------------------------------------------------------------------------------