diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c11117b32a..6685cb92c2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -22,8 +22,11 @@ jobs:
- elixir: 1.14.5
otp: 25.3.2.9
+ - elixir: 1.15.x
+ otp: 25.x
+
- elixir: 1.17.3
- otp: 27.1
+ otp: 27.2
lint: true
installer: true
diff --git a/.gitignore b/.gitignore
index 44fba26034..e46730c560 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,6 +12,7 @@
/installer/deps/
/installer/doc/
/installer/phx_new-*.ez
+/installer/tmp/
/integration_test/_build/
/integration_test/deps/
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d3849ce1c1..2cc0b330c2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,241 +1,5 @@
-# Changelog for v1.7
+# Changelog for v1.8
-See the [upgrade guide](https://gist.github.com/chrismccord/00a6ea2a96bc57df0cce526bd20af8a7) to upgrade from Phoenix 1.6.x.
+## v1.7
-Phoenix v1.7 requires Elixir v1.11+ & Erlang v22.1+.
-
-## Introduction of Verified Routes
-
-Phoenix 1.7 includes a new `Phoenix.VerifiedRoutes` feature which provides `~p`
-for route generation with compile-time verification.
-
-Use of the `sigil_p` macro allows paths and URLs throughout your
-application to be compile-time verified against your Phoenix router(s).
-For example the following path and URL usages:
-
- <.link href={~p"/sessions/new"} method="post">Log in
-
- redirect(to: url(~p"/posts/#{post}"))
-
-Will be verified against your standard `Phoenix.Router` definitions:
-
- get "/posts/:post_id", PostController, :show
- post "/sessions/new", SessionController, :create
-
-Unmatched routes will issue compiler warnings:
-
- warning: no route path for AppWeb.Router matches "/postz/#{post}"
- lib/app_web/controllers/post_controller.ex:100: AppWeb.PostController.show/2
-
-*Note: Elixir v1.14+ is required for comprehensive warnings. Older versions
-will work properly and warn on new compilations, but changes to the router file
-will not issue new warnings.*
-
-This feature replaces the `Helpers` module generated in your Phoenix router, but helpers
-will continue to work and be generated. You can disable router helpers by passing the
-`helpers: false` option to `use Phoenix.Router`.
-
-## phx.new revamp
-
-The `phx.new` application generator has been improved to rely on function components for
-both Controller and LiveView rendering, ultimately simplifying the rendering stack of
-Phoenix applications and providing better reuse.
-
-New applications come with a collection of well-documented and accessible core components,
-styled with Tailwind CSS by default. You can opt-out of Tailwind CSS with the `--no-tailwind`
-flag (the Tailwind CSS classes are kept in the generated components as reference for
-future styling).
-
-## 1.7.14 (2024-06-18)
-
-### Bug fixes
- * Revert "Add `follow_redirect/2` to Phoenix.ConnTest" (#5797) as this conflicts with `follow_redirect/2` in LiveView, which is imported with ConnTest by default
-
-## 1.7.13 (2024-06-18)
-
-### Bug fixes
- * Fix Elixir 1.17 warning in Cowboy2Adapter
- * Fix verified routes emitting diagnostics without file and position
-
-### JavaScript Client Bug Fixes
- * Fix error when `sessionStorage` is not available on global namespace
-
-### Enhancements
- * Add `follow_redirect/2` to Phoenix.ConnTest
- * Use LiveView 1.0.0-rc for newly generated applications
- * Use new `Phoenix.Component.used_input?` for form errors in generated `core_components.ex`
- * Allow `mix ecto.setup` from the umbrella root
- * Bump Endpoint static cache manifest on `config_change` callback
-
-## 1.7.12 (2024-04-11)
-
-### JavaScript Client Bug Fixes
- * Fix all unjoined channels from being removed from the socket when channel leave is called on any single unjoined channel instance
-
-### Enhancements
- * [phx.gen.auth] Add enhanced session fixation protection.
- For applications whichs previously used `phx.gen.auth`, the following line can be added to the `renew_session` function in the auth module:
-
- ```diff
- defp renew_session(conn) do
- + delete_csrf_token()
-
- conn
- |> configure_session(renew: true)
- |> clear_session()
- ```
-
- *Note*: because the session id is in a http-only cookie by default, the only way to perform this attack prior to this change is if your application was already vulnerable to an XSS attack, which itself grants more escalated "privileges” than the CSRF fixation.
-
-### JavaScript Client Enhancements
- * Only memorize longpoll fallback for browser session if WebSocket never had a successful connection
-
-## 1.7.11 (2024-02-01)
-
-### Enhancements
- * [phx.new] Default to the [Bandit webserver](https://github.com/mtrudel/bandit) for newly generated applications
- * [phx.new] Enable longpoll transport by default and auto fallback when websocket fails for newly generated applications
-
-### JavaScript Client Enhancements
- * Support new `longPollFallbackMs` option to auto fallback when websocket fails to connect
- * Support new `debug` option to enable verbose logging
-
-### Deprecations
- * Deprecate the `c:init/2` callback in endpoints in favor of `config/runtime.exs` or in favor of `{Phoenix.Endpoint, options}`
-
-## 1.7.10 (2023-11-03)
-
-### Bug fixes
- * [phx.new] Fix `CoreComponents.flash` generating incorrect id's causing flash messages to fail to be closed when clicked
-
-### Enhancements
- * [Phoenix.Endpoint] Support dynamic port for `Endpoint.url/0`
-
-## 1.7.9 (2023-10-11)
-
-### Bug fixes
- * [Phoenix.CodeReloader] - Fix error in code reloader causing compilation errors
- * [phx.new] – fix LiveView debug heex configuration being generated when `--no-html` pas passed
-
-## 1.7.8 (2023-10-09)
-
-### Bug fixes
- * [Phoenix.ChannelTest] Stringify lists when pushing data
- * [Phoenix.Controller] Fix filename when sending downloads with non-ascii names
- * [Phoenix.CodeReloader] Remove duplicate warnings on recent Elixir versions
- * [Phoenix.CodeReloader] Do not crash code reloader if file information is missing from diagnostic
- * [Phoenix.Logger] Do not crash when status is atom
- * [phx.gen.release] Fix `mix phx.gen.release --docker` failing with `:http_util` error on Elixir v1.15
- * [phx.gen.*] Skip map inputs in generated forms as there is no trivial matching input
- * [phx.new] Fix tailwind/esbuild config and paths in umbrella projects
- * [phx.new] Do not render `th` for actions if actions are empty
-
-### Enhancements
- * [Phoenix] Allow latest `plug_crypto`
- * [Phoenix.Endpoint] Support dynamic socket drainer configuration
- * [Phoenix.Logger] Change socket serializer/version logs to warning
- * [Phoenix.VerifiedRoutes] Add support for static resources with fragments in `~p`
- * [phx.gen.schema] Support `--repo` and `--migration-dir` flags
- * [phx.new] Allow `<.input type="checkbox">` without `value` attr in core components
- * [phx.new] Allow UTC datetimes in the generators
- * [phx.new] Automatically migrate when release starts when using sqlite 3
- * [phx.new] Allow ID to be assigned in flash component
- * [phx.new] Add `--adapter` flag for generating application with bandit
- * [phx.new] Include DNSCluster for simple clustering
- * [phx.routes] Support `--method` option
-
-## 1.7.7 (2023-07-10)
-
-### Enhancements
- * Support incoming binary payloads to channels over longpoll transport
-
-## 1.7.6 (2023-06-16)
-
-### Bug Fixes
- * Support websock_adapter 0.5.3
-
-### Enhancements
- * Allow using Phoenix.ChannelTest socket/connect in another process
-
-## 1.7.5 (2023-06-15)
-
-### Bug Fixes
- * Fix LongPoll error when draining connections
-
-## 1.7.4 (2023-06-15)
-
-### Bug Fixes
- * Fix the WebSocket draining sending incorrect close code when draining causing LiveViews to reload the page instead of reconnecting
-
-## 1.7.3 (2023-05-30)
-
-### Enhancements
- * Use LiveView 0.19 for new apps
-
-### Bug Fixes
- * Fix compilation error page on plug debugger showing obscure error when app fails to compile
- * Fix warnings being printed twice in route verification
-
-## 1.7.2 (2023-03-20)
-
-### Enhancements
- * [Endpoint] Add socket draining for batched and orchestrated Channel/LiveView socket shutdown
- * [code reloader] Improve the compilation error page to remove horizontal scrolling and include all warnings and errors from compilation
- * [phx.new] Support the `--no-tailwind` and `--no-esbuild` flags
- * [phx.new] Move heroicons to assets/vendor
- * [phx.new] Simplify core modal to use the new JS.exec instruction to reduce footprint
- * [sockets] Allow custom csrf_token_keys in WebSockets
-
-## 1.7.1 (2023-03-02)
-
-### Enhancements
- * [phx.new] Embed heroicons in app.css bundle to optimize usage
-
-## 1.7.0 (2023-02-24)
-
-### Bug Fixes
- * Fix race conditions in the longpoll transport by batching messages
-
-## 1.7.0-rc.3 (2023-02-15)
-
-### Enhancements
- * Use stream based collections for `phx.gen.live` generators
- * Update `phx.gen.live` generators to use `Phoenix.Component.to_form`
-
-## 1.7.0-rc.2 (2023-01-13)
-
-### Bug Fixes
- * [Router] Fix routing bug causing incorrect matching order on similar routes
- * [phx.new] Fix installation hanging in some cases
-
-## 1.7.0-rc.1 (2023-01-06)
-
-### Enhancements
- * Raise if using verified routes outside of functions
- * Add tailwind.install/esbuild.install to mix setup
-
-### Bug Fixes
- * [Presence] fix task shutdown match causing occasional presence errors
- * [VerifiedRoutes] Fix expansion causing more compile-time deps than necessary
- * [phx.gen.auth] Add password inputs to password reset edit form
- * [phx.gen.embedded] Fixes missing :references generation to phx.gen.embedded
- * Fix textarea rendering in core components
- * Halt all sockets on intercept to fix longpoll response already sent error
-
-## 1.7.0-rc.0 (2022-11-07)
-
-### Deprecations
- * `Phoenix.Controller.get_flash` has been deprecated in favor of the new `Phoenix.Flash` module, which provides unified flash access
-
-### Enhancements
- * [Router] Add `Phoenix.VerifiedRoutes` for `~p`-based route generation with compile-time verification.
- * [Router] Support `helpers: false` to `use Phoenix.Router` to disable helper generation
- * [Router] Add `--info [url]` switch to `phx.routes` to get route information about a url/path
- * [Flash] Add `Phoenix.Flash` for unfied flash access
-
-### JavaScript Client Bug Fixes
- * Fix heartbeat being sent after disconnect and causing abnormal disconnects
-
-## v1.6
-
-The CHANGELOG for v1.6 releases can be found in the [v1.6 branch](https://github.com/phoenixframework/phoenix/blob/v1.6/CHANGELOG.md).
+The CHANGELOG for v1.7 releases can be found in the [v1.7 branch](https://github.com/phoenixframework/phoenix/blob/v1.7/CHANGELOG.md).
diff --git a/README.md b/README.md
index 5374f74e89..ce1791f55e 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,8 @@
-
+
+
+
+
+
> Peace of mind from prototype to production.
diff --git a/RELEASE.md b/RELEASE.md
index 9a95c77e03..e3fd77c68e 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -1,6 +1,6 @@
# Release Instructions
- 1. Check related deps for required version bumps and compatibility (`phoenix_ecto`, `phoenix_pubsub_redis`, `phoenix_html`)
+ 1. Check related deps for required version bumps and compatibility (`phoenix_ecto`, `phoenix_html`)
2. Bump version in related files below
3. Bump external dependency version in related external files below
4. Run tests:
@@ -10,7 +10,8 @@
6. Publish `phx_new` and `phoenix` packages and docs after pruning any extraneous uncommitted files
7. Test installer by generating a new app, running `mix deps.get`, and compiling
8. Publish to `npm` with `npm publish`
- 9. Start -dev version in related files below
+ 9. Update Elixir and Erlang/OTP versions on new.phoenixframework.org
+ 10. Start -dev version in related files below
## Files with version
@@ -21,5 +22,6 @@
* `assets/package.json`
## Files with external dependency versions
+
* `priv/templates/phx.gen.release/Docker.eex` (debian)
* `priv/templates/phx.gen.release/Docker.eex` (esbuild)
diff --git a/guides/components.md b/guides/components.md
index 83e6710e8c..5e98f92131 100644
--- a/guides/components.md
+++ b/guides/components.md
@@ -16,7 +16,7 @@ At the end of the Request life-cycle chapter, we created a template at `lib/hell
```heex
-
Hello World, from <%= @messenger %>!
+
Hello World, from {@messenger}!
```
@@ -34,7 +34,7 @@ That's simple enough. There's only two lines, `use HelloWeb, :html`. This line c
All of the imports and aliases we make in our module will also be available in our templates. That's because templates are effectively compiled into functions inside their respective module. For example, if you define a function in your module, you will be able to invoke it directly from the template. Let's see this in practice.
-Imagine we want to refactor our `show.html.heex` to move the rendering of `
Hello World, from <%= @messenger %>!
` to its own function. We can move it to a function component inside `HelloHTML`, let's do so:
+Imagine we want to refactor our `show.html.heex` to move the rendering of `
Hello World, from {@messenger}!
` to its own function. We can move it to a function component inside `HelloHTML`, let's do so:
```elixir
defmodule HelloWeb.HelloHTML do
@@ -46,7 +46,7 @@ defmodule HelloWeb.HelloHTML do
def greet(assigns) do
~H"""
-
Hello World, from <%= @messenger %>!
+
Hello World, from {@messenger}!
"""
end
end
@@ -89,19 +89,21 @@ Next, let's fully understand the expressive power behind the HEEx template langu
## HEEx
-Function components and templates files are powered by [the HEEx template language](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html#sigil_H/2), which stands for "HTML+EEx". EEx is an Elixir library that uses `<%= expression %>` to execute Elixir expressions and interpolate their results into the template. This is frequently used to display assigns we have set by way of the `@` shortcut. In your controller, if you invoke:
+Function components and templates files are powered by [the HEEx template language](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html#sigil_H/2), which stands for "HTML+EEx". EEx is an Elixir library that uses `<%= expression %>` to execute Elixir expressions and interpolate their results into arbitrary text templates. HEEx extends EEx for writing HTML templates mixed with Elixir interpolation. We can write Elixir code inside `{...}` for HTML-aware interpolation inside tag attributes and the body. We can also interpolate arbitrary HEEx blocks using EEx interpolation (`<%= ... %>`). We use `@name` to access the key `name` defined inside `assigns`.
+
+This is frequently used to display assigns we have set by way of the `@` shortcut. In your controller, if you invoke:
```elixir
render(conn, :show, username: "joe")
```
-Then you can access said username in the templates as `<%= @username %>`. In addition to displaying assigns and functions, we can use pretty much any Elixir expression. For example, in order to have conditionals:
+Then you can access said username in the templates as `{@username}`. In addition to displaying assigns and functions, we can use pretty much any Elixir expression. For example, in order to have conditionals:
```heex
<%= if some_condition? do %>
-
Some condition is true for user: <%= @username %>
+
Some condition is true for user: {@username}
<% else %>
-
Some condition is false for user: <%= @username %>
+
Some condition is false for user: {@username}
<% end %>
```
@@ -115,8 +117,8 @@ or even loops:
<%= for number <- 1..10 do %>
-
<%= number %>
-
<%= number * number %>
+
{number}
+
{number * number}
<% end %>
@@ -131,20 +133,20 @@ HEEx also comes with handy HTML extensions we will learn next.
Besides allowing interpolation of Elixir expressions via `<%= %>`, `.heex` templates come with HTML-aware extensions. For example, let's see what happens if you try to interpolate a value with "<" or ">" in it, which would lead to HTML injection:
```heex
-<%= "Bold?" %>
+{"Bold?"}
```
Once you render the template, you will see the literal `` on the page. This means users cannot inject HTML content on the page. If you want to allow them to do so, you can call `raw`, but do so with extreme care:
```heex
-<%= raw "Bold?" %>
+{raw("Bold?")}
```
-Another super power of HEEx templates is validation of HTML and lean interpolation syntax of attributes. You can write:
+Another super power of HEEx templates is validation of HTML and interpolation syntax of attributes. You can write:
```heex
-
Hello <%= @username %>
+
Hello {@username}
```
@@ -154,7 +156,7 @@ To interpolate a dynamic number of attributes in a keyword list or map, do:
```heex
-
Hello <%= @username %>
+
Hello {@username}
```
@@ -178,7 +180,7 @@ Likewise, for comprehensions may be written as:
```heex
-
<%= item.name %>
+
{item.name}
```
@@ -189,7 +191,7 @@ Layouts are just function components. They are defined in a module, just like al
You may be wondering how the string resulting from a rendered view ends up inside a layout. That's a great question! If we look at `lib/hello_web/components/layouts/root.html.heex`, just about at the end of the ``, we will see this.
```heex
-<%= @inner_content %>
+{@inner_content}
```
In other words, after rendering your page, the result is placed in the `@inner_content` assign.
diff --git a/guides/contexts.md b/guides/contexts.md
index 273b35517c..22fc256eb4 100644
--- a/guides/contexts.md
+++ b/guides/contexts.md
@@ -73,7 +73,7 @@ Phoenix generated the web files as expected in `lib/hello_web/`. We can also see
With the new route in place, Phoenix reminds us to update our repo by running `mix ecto.migrate`, but first we need to make a few tweaks to the generated migration in `priv/repo/migrations/*_create_products.exs`:
-```elixir
+```diff
def change do
create table(:products) do
add :title, :string
@@ -498,8 +498,9 @@ Next, let's expose our new feature to the web by adding the category input to ou
|> Ecto.Changeset.get_change(:categories, [])
|> Enum.map(& &1.data.id)
- for cat <- Hello.Catalog.list_categories(),
- do: [key: cat.title, value: cat.id, selected: cat.id in existing_ids]
+ for cat <- Hello.Catalog.list_categories() do
+ [key: cat.title, value: cat.id, selected: cat.id in existing_ids]
+ end
end
```
@@ -524,10 +525,9 @@ We added a `category_select` above our save button. Now let's try it out. Next,
<.list>
...
+ <:item title="Categories">
-+ <%= for cat <- @product.categories do %>
-+ <%= cat.title %>
-+
-+ <% end %>
++
++
{cat.title}
++
+
```
@@ -605,12 +605,11 @@ Would you like to proceed? [Yn] y
Remember to update your repository by running migrations:
$ mix ecto.migrate
-
```
We generated a new resource inside our `ShoppingCart` named `CartItem`. This schema and table will hold references to a cart and product, along with the price at the time we added the item to our cart, and the quantity the user wishes to purchase. Let's touch up the generated migration file in `priv/repo/migrations/*_create_cart_items.ex`:
-```elixir
+```diff
create table(:cart_items) do
- add :price_when_carted, :decimal
+ add :price_when_carted, :decimal, precision: 15, scale: 6, null: false
@@ -664,7 +663,7 @@ Our `Catalog.Product` resource serves to keep the responsibilities of representi
Now that we know where our data dependencies exist, let's add our schema associations so we can tie shopping cart items to products. First, let's make a quick change to our cart schema in `lib/hello/shopping_cart/cart.ex` to associate a cart to its items:
-```elixir
+```diff
schema "carts" do
field :user_uuid, Ecto.UUID
@@ -676,7 +675,7 @@ Now that we know where our data dependencies exist, let's add our schema associa
Now that our cart is associated to the items we place in it, let's set up the cart item associations inside `lib/hello/shopping_cart/cart_item.ex`:
-```elixir
+```diff
schema "cart_items" do
field :price_when_carted, :decimal
field :quantity, :integer
@@ -708,7 +707,7 @@ As we mentioned before, the context generators are only a starting point for our
We won't focus on a real user authentication system at this point, but by the time we're done, you'll be able to naturally integrate one with what we've written here. To simulate a current user session, open up your `lib/hello_web/router.ex` and key this in:
-```elixir
+```diff
pipeline :browser do
plug :accepts, ["html"]
plug :fetch_session
@@ -797,7 +796,7 @@ We defined a new `CartItemController` with the create and delete actions that we
Let's implement the new interface for the `ShoppingCart` context API in `lib/hello/shopping_cart.ex`:
-```elixir
+```diff
+ alias Hello.Catalog
- alias Hello.ShoppingCart.Cart
+ alias Hello.ShoppingCart.{Cart, CartItem}
@@ -937,34 +936,28 @@ We created a view to render our `show.html` template and aliased our `ShoppingCa
Next we can create the template at `lib/hello_web/controllers/cart_html/show.html.heex`:
```heex
-<%= if @cart.items == [] do %>
- <.header>
- My Cart
- <:subtitle>Your cart is empty
-
-<% else %>
- <.header>
- My Cart
-
+<.header>
+ My Cart
+ <:subtitle :if={@cart.items == []}>Your cart is empty
+
+
<.back navigate={~p"/products"}>Back to products
```
-We started by showing the empty cart message if our preloaded `cart.items` is empty. If we have items, we use the `simple_form` component provided by our `HelloWeb.CoreComponents` to take our cart changeset that we assigned in the `CartController.show/2` action and create a form which maps to our cart controller `update/2` action. Within the form, we use the [`inputs_for`](`Phoenix.Component.inputs_for/1`) component to render inputs for the nested cart items. This will allow us to map item inputs back together when the form is submitted. Next, we display a number input for the item quantity and label it with the product title. We finish the item form by converting the item price to string. We haven't written the `ShoppingCart.total_item_price/1` function yet, but again we employed the idea of clear, descriptive public interfaces for our contexts. After rendering inputs for all the cart items, we show an "update cart" submit button, along with the total price of the entire cart. This is accomplished with another new `ShoppingCart.total_cart_price/1` function which we'll implement in a moment. Finally, we added a `back` component to go back to our products page.
+We started by showing the empty cart message if our preloaded `cart.items` is empty. If we have items, we use the `simple_form` component provided by our `HelloWeb.CoreComponents` to take our cart changeset that we assigned in the `CartController.show/2` action and create a form which maps to our cart controller `update/2` action. Within the form, we use the [`inputs_for`](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html#inputs_for/1) component to render inputs for the nested cart items. This will allow us to map item inputs back together when the form is submitted. Next, we display a number input for the item quantity and label it with the product title. We finish the item form by converting the item price to string. We haven't written the `ShoppingCart.total_item_price/1` function yet, but again we employed the idea of clear, descriptive public interfaces for our contexts. After rendering inputs for all the cart items, we show an "update cart" submit button, along with the total price of the entire cart. This is accomplished with another new `ShoppingCart.total_cart_price/1` function which we'll implement in a moment. Finally, we added a `back` component to go back to our products page.
We're almost ready to try out our cart page, but first we need to implement our new currency calculation functions. Open up your shopping cart context at `lib/hello/shopping_cart.ex` and add these new functions:
@@ -1034,7 +1027,7 @@ Head back over to your shopping cart context in `lib/hello/shopping_cart.ex` and
end
```
-We started much like how our out-of-the-box code started – we take the cart struct and cast the user input to a cart changeset, except this time we use `Ecto.Changeset.cast_assoc/3` to cast the nested item data into `CartItem` changesets. Remember the [`<.inputs_for />`](`Phoenix.Component.inputs_for/1`) call in our cart form template? That hidden ID data is what allows Ecto's `cast_assoc` to map item data back to existing item associations in the cart. Next we use `Ecto.Multi.new/0`, which you may not have seen before. Ecto's `Multi` is a feature that allows lazily defining a chain of named operations to eventually execute inside a database transaction. Each operation in the multi chain receives the values from the previous steps and executes until a failed step is encountered. When an operation fails, the transaction is rolled back and an error is returned, otherwise the transaction is committed.
+We started much like how our out-of-the-box code started – we take the cart struct and cast the user input to a cart changeset, except this time we use `Ecto.Changeset.cast_assoc/3` to cast the nested item data into `CartItem` changesets. Remember the [`<.inputs_for />`](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html#inputs_for/1) call in our cart form template? That hidden ID data is what allows Ecto's `cast_assoc` to map item data back to existing item associations in the cart. Next we use `Ecto.Multi.new/0`, which you may not have seen before. Ecto's `Multi` is a feature that allows lazily defining a chain of named operations to eventually execute inside a database transaction. Each operation in the multi chain receives the values from the previous steps and executes until a failed step is encountered. When an operation fails, the transaction is rolled back and an error is returned, otherwise the transaction is committed.
For our multi operations, we start by issuing an update of our cart, which we named `:cart`. After the cart update is issued, we perform a multi `delete_all` operation, which takes the updated cart and applies our zero-quantity logic. We prune any items in the cart with zero quantity by returning an ecto query that finds all cart items for this cart with an empty quantity. Calling `Repo.transaction/1` with our multi will execute the operations in a new transaction and we return the success or failure result to the caller just like the original function.
@@ -1067,7 +1060,7 @@ Remember to update your repository by running migrations:
We generated an `Orders` context. We added a `user_uuid` field to associate our placeholder current user to an order, along with a `total_price` column. With our starting point in place, let's open up the newly created migration in `priv/repo/migrations/*_create_orders.exs` and make the following changes:
-```elixir
+```diff
def change do
create table(:orders) do
add :user_uuid, :uuid
@@ -1104,7 +1097,7 @@ Remember to update your repository by running migrations:
We used the `phx.gen.context` command to generate the `LineItem` Ecto schema and inject supporting functions into our orders context. Like before, let's modify the migration in `priv/repo/migrations/*_create_order_line_items.exs` and make the following decimal field changes:
-```elixir
+```diff
def change do
create table(:order_line_items) do
- add :price, :decimal
@@ -1123,7 +1116,7 @@ We used the `phx.gen.context` command to generate the `LineItem` Ecto schema and
With our migration in place, let's wire up our orders and line items associations in `lib/hello/orders/order.ex`:
-```elixir
+```diff
schema "orders" do
field :total_price, :decimal
field :user_uuid, Ecto.UUID
@@ -1137,7 +1130,7 @@ With our migration in place, let's wire up our orders and line items association
We used `has_many :line_items` to associate orders and line items, just like we've seen before. Next, we used the `:through` feature of `has_many`, which allows us to instruct ecto how to associate resources across another relationship. In this case, we can associate products of an order by finding all products through associated line items. Next, let's wire up the association in the other direction in `lib/hello/orders/line_item.ex`:
-```elixir
+```diff
schema "order_line_items" do
field :price, :decimal
field :quantity, :integer
@@ -1153,7 +1146,7 @@ We used `has_many :line_items` to associate orders and line items, just like we'
We used `belongs_to` to associate line items to orders and products. With our associations in place, we can start integrating the web interface into our order process. Open up your router `lib/hello_web/router.ex` and add the following line:
-```elixir
+```diff
scope "/", HelloWeb do
pipe_through :browser
@@ -1299,20 +1292,20 @@ Next we can create the template at `lib/hello_web/controllers/order_html/show.ht
<.header>
Thank you for your order!
<:subtitle>
- User uuid: <%= @order.user_uuid %>
+ User uuid: {@order.user_uuid}
<.table id="items" rows={@order.line_items}>
- <:col :let={item} label="Title"><%= item.product.title %>
- <:col :let={item} label="Quantity"><%= item.quantity %>
+ <:col :let={item} label="Title">{item.product.title}
+ <:col :let={item} label="Quantity">{item.quantity}
<:col :let={item} label="Price">
- <%= HelloWeb.CartHTML.currency_to_str(item.price) %>
+ {HelloWeb.CartHTML.currency_to_str(item.price)}
Total price:
-<%= HelloWeb.CartHTML.currency_to_str(@order.total_price) %>
+{HelloWeb.CartHTML.currency_to_str(@order.total_price)}
<.back navigate={~p"/products"}>Back to products
```
@@ -1324,11 +1317,11 @@ Our last addition will be to add the "complete order" button to our cart page to
```diff
<.header>
My Cart
-+ <:actions>
-+ <.link href={~p"/orders"} method="post">
-+ <.button>Complete order
-+
-+
++ <:actions>
++ <.link href={~p"/orders"} method="post">
++ <.button>Complete order
++
++
```
diff --git a/guides/introduction/up_and_running.md b/guides/introduction/up_and_running.md
index df1871d49a..6b33dbb252 100644
--- a/guides/introduction/up_and_running.md
+++ b/guides/introduction/up_and_running.md
@@ -1,10 +1,34 @@
# Up and Running
-Let's get a Phoenix application up and running as quickly as possible.
+There are two mechanisms to start a new Phoenix application: the express option, supported on some OSes, and via `mix phx.new`. Let's check it out.
-Before we begin, please take a minute to read the [Installation Guide](installation.html). By installing any necessary dependencies beforehand, we'll be able to get our application up and running smoothly.
+## Phoenix Express
-We can run `mix phx.new` from any directory in order to bootstrap our Phoenix application. Phoenix will accept either an absolute or relative path for the directory of our new project. Assuming that the name of our application is `hello`, let's run the following command:
+A single command will get you up and running in seconds:
+
+For macOS/Ubuntu:
+
+```bash
+$ curl https://new.phoenixframework.org/myapp | sh
+```
+
+For Windows PowerShell:
+
+```cmd
+> curl.exe -fsSO https://new.phoenixframework.org/myapp.bat; .\myapp.bat
+```
+
+The above will install Erlang, Elixir, and Phoenix, and generate a fresh Phoenix application. It will also automatically pick one of PostgreSQL or MySQL as the database, and fallback to SQLite if none of them are available. Once the command above, it will open up a Phoenix application, with the steps necessary to complete your installation.
+
+> Your Phoenix application name is taken from the path.
+
+If your operating system is not supported, or the command above fails, don't fret! You can still start your Phoenix application using `mix phx.new`.
+
+## Via `mix phx.new`
+
+In order to create a new Phoenix application, you will need to install Erlang, Elixir, and Phoenix. See the [Installation Guide](installation.html) for more information. If you share your application with someone, they will also need to follow the Installation Guide steps to set it all up.
+
+Once you are ready, you can run `mix phx.new` from any directory in order to bootstrap our Phoenix application. Phoenix will accept either an absolute or relative path for the directory of our new project. Assuming that the name of our application is `hello`, let's run the following command:
```console
$ mix phx.new hello
diff --git a/guides/plug.md b/guides/plug.md
index 0c1d6a5175..04e502a48d 100644
--- a/guides/plug.md
+++ b/guides/plug.md
@@ -120,7 +120,7 @@ In the [`init/1`] callback, we pass a default locale to use if none is present i
To see the assign in action, go to the template in `lib/hello_web/controllers/page_html/home.html.heex` and add the following code after the closing of the `` tag:
```heex
-
Locale: <%= @locale %>
+
Locale: {@locale}
```
Go to [http://localhost:4000/](http://localhost:4000/) and you should see the locale exhibited. Visit [http://localhost:4000/?locale=fr](http://localhost:4000/?locale=fr) and you should see the assign changed to `"fr"`. Someone can use this information alongside [Gettext](https://hexdocs.pm/gettext/Gettext.html) to provide a fully internationalized web application.
diff --git a/guides/real_time/presence.md b/guides/real_time/presence.md
index 106ea41775..32271b855a 100644
--- a/guides/real_time/presence.md
+++ b/guides/real_time/presence.md
@@ -217,7 +217,7 @@ defmodule HelloWeb.OnlineLive do
def render(assigns) do
~H"""
-
<%= id %> (<%= length(metas) %>)
+
{id} ({length(metas)})
"""
end
diff --git a/guides/request_lifecycle.md b/guides/request_lifecycle.md
index 177b9376ab..79ac1e9649 100644
--- a/guides/request_lifecycle.md
+++ b/guides/request_lifecycle.md
@@ -181,7 +181,7 @@ Now that we've got the route, controller, view, and template, we should be able
There are a couple of interesting things to notice about what we just did. We didn't need to stop and restart the server while we made these changes. Yes, Phoenix has hot code reloading! Also, even though our `index.html.heex` file consists of only a single `section` tag, the page we get is a full HTML document. Our index template is actually rendered into layouts: first it renders `lib/hello_web/components/layouts/root.html.heex` which renders `lib/hello_web/components/layouts/app.html.heex` which finally includes our content. If you open those files, you'll see a line that looks like this at the bottom:
```heex
-<%= @inner_content %>
+{@inner_content}
```
This line injects our template into the layout before the HTML is sent off to the browser. We will talk more about layouts in the Controllers guide.
@@ -273,15 +273,17 @@ It's good to remember that the keys of the `params` map will always be strings,
For the last piece of this puzzle, we'll need a new template. Since it is for the `show` action of `HelloController`, it will go into the `lib/hello_web/controllers/hello_html` directory and be called `show.html.heex`. It will look surprisingly like our `index.html.heex` template, except that we will need to display the name of our messenger.
-To do that, we'll use the special HEEx tags for executing Elixir expressions: `<%= %>`. Notice that the initial tag has an equals sign like this: `<%=` . That means that any Elixir code that goes between those tags will be executed, and the resulting value will replace the tag in the HTML output. If the equals sign were missing, the code would still be executed, but the value would not appear on the page.
+To do that, we'll use the special HEEx tags for executing Elixir expressions: `{...}` and `<%= %>`. Notice that EEx tag has an equals sign like this: `<%=` . That means that any Elixir code that goes between those tags will be executed, and the resulting value will replace the tag in the HTML output. If the equals sign were missing, the code would still be executed, but the value would not appear on the page.
-Remember our templates are written in HEEx (HTML+EEx). HEEx is a superset of EEx which is why it shares the `<%= %>` syntax.
+Remember our templates are written in HEEx (HTML+EEx). HEEx is a superset of EEx, and thereby supports the EEx `<%= %>` interpolation syntax for interpolating arbitrary blocks of code. In general, the HEEx `{...}` interpolation syntax is preferred anytime there is HTML-aware intepolation to be done – such as within attributes or inline values with a body.
-And this is what the template should look like:
+The only times `EEx` `<%= %>` interpolation is necessary is for interpolationg arbitrary blocks of markup, such as branching logic that inects separate markup trees, or for interpolating values within `
- <%%= @inner_content %>
+ {@inner_content}
+