Historical errata for Programming Phoenix

This may be the wrong forum for this, but I tried to upload the epub file to my google books account and it threw an error saying that it couldn’t process the epub file.

Anyone had this same issue?

— This is a Google Play Reader bug.

Regarding this sentence: “If you’re using a database, in Phoenix you want to be using Ecto, the persistence layer.”

The first comma looks like a typo.

“In Phoenix, whenever its possible…”

should be “it’s”

“Our two new routes use the new UsersController, which doesn’t yet exist” Should be “UserController”

In the graph the functions are:

connection |> endpoint |> router |> pipelines |> controller

but in the description below is:

connection |> endpoint |> pipelines |> router |> controller

When running:
mix ecto.create

if the user hasn’t got a postgresql database with a user ‘postgres’ and password ‘postgres’ setup there will be an error:

• (Mix) The database for Hello.Repo couldn’t be created, reason given: “psql: FATAL: password authentication failed for user \\”postgres\\“\
  FATAL: password authentication failed for user \\”postgres\\“\
  ”

so maybe a mention that these need to be in place would be a good idea.

“The basic flow of traditional applications is endpoint, pipeline, controller”

Shouldn’t the router be included too?

Under the heading “Creating Users” the text discusses using the “registration_changeset” in the create action but the `User.changeset` is still shown in the example.

You have:
connection
|> endpoint
|> router
|> pipelines
|> controller

and must be

connection
|> endpoint
|> pipelines
|> router
|> controller

sends them to the UsersController, calling the index action -> sends them to the UserController, calling the index action

—Deans Charbal

Quotes are unbalanced so SQLi would fail in some instances(0). When you attack using SQL you tend to use SQL comments at the end of your attack so you don’t need to worry about such things. ie:

bob’; drop database production; —

Also, Bravo. I’m just inhaling this book it’s so well done thus far.

“right after use Rumble.Web” should read “right after use Rumbl.Web”

“How does Phoenix knows which data to show in the form?”
How does Phoenix know what data to show in the form?

```
def create(conn, %{“user” => user_params}) do
changeset = User.changeset(%User{}, user_params)
case Repo.insert(changeset) do
#…
end
end
```
Should be `changeset = User.registration_changeset(%User{}, user_params) `

Layers of Phoenix:

Diagram and textual description differ in ordering: (pipelines <-> router)
Diagram shows:
connection
|> endpoint
|> router
|> pipelines
|> controller

Text states: “A request comes into an endpoint. From there, a request goes into pipelines. As you might expect, a pipeline groups functions together to handle common tasks. You might have a pipeline for browser requests, and another for JSON requests. From there, requests go into our router layer, which directs a request into the appropriate controller.”

ie:
endpoint
|> pipelines
|> router
|> controller

I found the paragraph in this page that says “If you’re a diehard MVC person…” to be a bit unclear. I came in as a “diehard MVC” person (or I prefer to think of myself as an open-minded person with more than passing familiarity with MVC). I didn’t quite understand how Phoenix’s approach to MVC differs from “diehard MVC”. I think the ambiguity comes with the phrase “we process data in the model”. What does it mean to “process data”? Perhaps an illustration that makes the different approaches more clear?

When installing Phoenix, the command line which begins mix archive.install… has the first line in the “type this” purplish color, but the line below that (starts with download/v1.0.3) is a continuation of the command. I was thrown by the fact that the entire command was not in that purple color.

We know that Jose likes Elixir :-) so his password in this page is: “<3<3elixir”
but on the previous page (40) he has only set it as “elixir”.

In the ‘Jose says’: section.

I’m not sure I fully understand why the distinction Jose is making with the two. A code-reload of a ‘long running process’ still maintains its state so I don’t really see that as a difference per se. Am I missing something else?

Quoted minimum erlang version is 17. Pretty sure I saw on the mailing list that 18 or 18.1 will be required on the next elixir bump.

Probably something you’ll double-check before you drop out of beta anyways but just wanted to notate it.

I found the book around pages 43, 44, and 45 to be a particularly rocky road. I was trying to understand the method that I wrote from the view and how EEX worked when I was suddenly told that the template I just created was “so fast” because it is a function (?!?) and that it uses helpers which appear magically out of nowhere which I can call myself…

Having looked at Phoenix (and Rails) in the past I was able to keep up with the information here, but I really think a reader new to Phoenix and/or new to Elixir might really be baffled by so many different concepts all together in such a short span. It is my opinion that they’re a bit jumbled here. Some more explanation might help.

With all due respect, It seems that this paragraph was written by someone for whom English was a second language (José?):

Phoenix.HTML is responsible for all HTML functionality, from generating links to working with forms. That module also introduces the notion of HTML safety: our applications are by default safe from cross-site scripting (XSS) attacks because Phoenix takes care of annotating only the markup it generates as safe. That’s why calling link returned a tuple, with the first element being the :safe atom.

The sentence structure and wording choices seem a bit out-of-order. I had to read the paragraph a couple of times to get the gist of it (of course… the problem might also be the fact that it’s rather late in the day here). I might reword it as follows:

Phoenix.HTML is responsible for the HTML functionality in views, from generating links, to working with forms. Reliance on this module is a big part of Phoenix’s approach to HTML safety. _{By default, applications are safe from cross-site scripting (XSS) attacks} because care is taken to ensure that the markup generated by this module is safe. In fact, that’s why the _link helper function returns a tuple. The first element of the tuple, the _:safe atom indicates that the markup in the second element came from Phoenix.HTML and is known to be safe content.

“Layouts also are just templates.”

If layouts are just templates, why is there a separate concept? Its not clear to me here.

After pouring over this section a couple of times, I think I see the distinction. Layouts are templates that are “owned” by controllers. They provide an common HTML structure for the controller, and the HTML generated by the actions (with their corresponding views) are substituted into that structure.

What I think is missing somewhere in the book up to this point, is a section describing the relationship between controllers, actions, layouts, and views from a conceptual level (with big square block diagrams and responsibilities for each block spelled out. perhaps right before the ‘building a controller’ section.

The Understanding Ecto section sets of by describing Ecto in terms of other persistence frameworks (Hibernate, Active Record, LINQ) but doesn’t ACTUALLY tell you what Ecto is or why it exists.

To draw an analogy I might tell you that a Ukulele is a musical instrument that combines features of the Braguesa and the Rajão. Unless you already know what those two instruments are however describing the Ukulele in those terms is meaningless.

I would expand this section to talk about what problem Ecto is intended to solve, on it’s own terms, and then draw comparison to other libraries that solve those same problems for folks that are familiar with them.

“Now that we have our Repo and our model configured, we need to add a migration to create our ”users" table with the schema for our User model."

What’s a migration? Why do I need one?

Even if you don’t want to explain it fully in this book, some handy pointers on where to learn more might be helpful.

That means that this group of routes will attempt to match all routes beginning with /.

Redundant “that”?

Adding the alias for Rumbl.User at this point (as the first code example in “Building Forms”) seems… weird. I think it should be in an extra step after we’ve completed this section, or done before the index + show actions were defined.

When restoring the Ecto.Repo back to working order, there’s a step missing.

The user also needs to uncomment the line “worker(Rumbl.Repo, []),” in lib/rumbl.ex

Part of the output from “mix phoenix.new hello” (from “We are all set!” to “iex -S mix phoenix.server”) has been set as normal text, rather than as monospaced command output. This makes it look like the instructions are in the book, rather than the mix output. The commands work (assuming you have postgres configured as it expects), but it makes things a bit confusing when, a couple of paragraphs later, it says “We’ll skip the instructions related to ecto since our application won’t use a database for now.”

On page 41, the text indicates:

In the file
lib/rumbl.ex, comment out the line that starts the repository:

1. Start the Ecto repository
2. worker(Rumbl.Repo, []),

On page 42, when the text indicates:
If you point your browser to [http]://localhost:4000/users…

Expected: The error message described in the text
What happened: Received a different error message about ecto.
How to fix: CTRL-C, CTRL-C, re-run mix phoenix.server

If a change in /lib requires a full-reload, it would be helpful to indicate in the text.

Really enjoying the book so far, keep up the good work.

“Specifically, we don’t want to users to access…”

It looks like the word “allow” is missing after the first “to”.

<%= text_input f, :username, placeholder: “Name”, class: “form-control” %>

Placeholder should be “Username”

“The browser pipeline accepts only HTML” – I might be wrong (and/or pedantic), but isn’t it more that it only services requests that have stated in their accepts header that they can handle HTML responses?

In the j_users query, “%j” is used in the ilike which won’t match any users. It’s probably meant to be ^“j%” whic also matches the [debug] line in the Repo.one query using j_users

The pipe syntax query at the top of the page doesn’t match the [debug] output below it. The query includes “ilike(u.name, ^”c“)” and the debug output only has the j ILIKE

On page 96 the process of moving authenticate/2 to authenticate_user/2 (and moving it from user_controller.ex to auth.ex) there is one piece missing that will cause a compile error when trying to do the “mix ecto.migrate” on page 98. The plug call in user_controller.ex needs to be updated from “plug :authenticate” to “plug :authenticate_user”

After typing in the CreateUsers migration I was left with several questions.

What types of fields can I add in a database (besides :string)?
What does the null:false mean (presumably that the field cannot be empty)?

I wanted to go into iex and look up the documentation for “add” but I ran into two problems. First, I have no idea in what module the add macro is defined. Presumably it would go in Ecto.Migrations, so that’s where I started. The second problem I ran into, however was an error from iex

Ecto.Migration was not compiled with docs

Well shoot.

Perhaps a sidebar box somewhere that explains how to compile dependencies with documentation and some pointers about where to find more information on ‘add’ and friends?

Section: The Layers of Phoenix
It seems to me that the diagram and the text do not match. Which goes after endpoint in the diagram, router or pipelines?

It is never mentioned that we need a running PostgreSQL server

There’s a figure that shows: connection |> endpoint |> router |> pipelines |> controller

The text that follows says: “A request comes into an endpoint. From there, a request goes into pipelines. … From there, requests go into our router layer.”

When first starting up hello world there isn’t any guide or mention of Postgres needing to be installed. A google led me to the docs which resolved the error.

The line `mix ecto.create` makes it blow up even though a database isn’t used yet. Perhaps passing the `—no-ecto` flag to phoenix.new would help resolve this?

(Mix) The database for Hello.Repo couldn’t be created, reason given: “psql: could not connect to server: Connection refused\
\\tIs the server running on host \\”localhost\\" (::1) and accepting\
\\tTCP/IP connections on port 5432?\
could not connect to server: Connection refused\
\\tIs the server running on host \\“localhost\\” (127.0.0.1) and accepting\
\\tTCP/IP connections on port 5432?\
".

The example code intending to show how to use the registration_changeset doesn’t actually make use of the function.

I believe the line

changeset = User.changeset(%User{}, user_params)

should read

changeset = User.registration_changeset(%User{}, user_params)

You say “In the endpoint module” with the assumption that people know where this is. I would recommend linking to it again, probably in brackets:

“In the endpoint module (lib/rumbl/endpoint.ex)…”

Under “Creating Users”, the code example doesn’t actually use the new “registration_changeset” function (like the text says), but incorrectly still uses the original “changeset” function.

(Great book so far!)

The explanation of the new layout code (handling logged in/logged out users) could be clearer… It says “If you’re watching closely, you can see that this link uses the session_path twice”, but there isn’t a link that uses session_path twice; then, “Breaking it down” uses a link with the text “signout”, which isn’t one of the links given.

Ecto.Queryable not implemented for Rumbl.User

Similar to another comment for page 41 this is the error that you get if you do not restart the server after making the changes to repo and UserController.

we’ll create user directory

should be

we’ll create the user directory

from(u in User,
where: fragment(“lower(username) = ?”,
^String.downcase(uname)))

I think you mean from(u in User,
where: fragment(“lower(username) = ?”,
^String.downcase(u.name)))

The second shell command on the page should be
`mix run priv/repo/seeds.exs` to simulate what the paragraph is saying, which is to run the previous command twice.

In the Video controller update action, you reference a watch path. That should be video_path

|> redirect(to: watch_path(conn, :show, video))
vs
|> redirect(to: video_path(conn, :show, video))

Before we move on, let’s check to see what happens
if someone runs the seeds file twice:
$ mix phoenix.gen.model Category categories name:string

(Ecto.ConstraintError) constraint error when attempting to insert model:
* unique: categories_name_index

The code should be
$ mix run priv/repo/seeds.exs
Since you’re running the seed file twice

First long paragraph has the typo “databased” at the end of the second line.

Should read “database”

You need to import Ecto.Query in order for this to work

video = Repo.one(from v in Video, limit: 1)

Should it be mentioned that in order to use the link helper in iex, iex should be started with iex -S mix instead of only iex?

iex(1)> Phoenix.HTML.Link.link(“Home”, to: “/”)

(UndefinedFunctionError) undefined function: Phoenix.HTML.Link.link/2 (module Phoenix.HTML.Link is not available)
Phoenix.HTML.Link.link(“Home”, [to: “/”]

When talking about the routes that get generated with `resources “/sessions”, etc.` it mentions the “GET new_session” URL being created - this is incorrect, the URL generated is “sessions/new”. (verified with mix phoenix.routes)

Following on from previous erratum, `POST session` and `DELETE session/:id` are also incorrect - they should be `sessions, `plural.

I think it’s worth pointing out here that this authentication code won’t work for any of the sample José, Chris or Bruce users - their password hashes are still the old plaintext values. You’ll get something like the following:

Request: POST /sessions

(exit) an exception was raised:
(MatchError) no match of right hand side value: [‘<3<3elixir’]
(comeonin) lib/comeonin/bcrypt.ex:113: Comeonin.Bcrypt.hashpw/2

The book doesn’t contain functionality for editing or deleting users, so should we be adding routes for those actions with `resources “/users”, UserController` ?

In the summary:
“We created a video model and used it to issue some queries across two models.”

The chapter doesn’t cover this - we generate the video scaffold, hook it up in the router, then look through the generated code. We don’t actually do any manual querying with it at all.

When returning a tuple of users and videos from Ecto:

[{%Rumble.User{…}, %Rumbl.Video{…}}]

Typo - Rumble should be Rumbl

Inserting a video with just a title of “hi” leads to errors down the track. By default, the model requires a url, title and description, and this skips those validations and inserts invalid data into the database.

Problem only comes to light later on on page 118 when it comes time to update the first video (which turns out to be this “hi” video) with a category ID - it doesn’t return {:ok, %Rumbl.Video{…}}, it returns {:error, %Ecto.Changeset{…}}.

Maybe it would be cute to continue the piping paradigm for the installation of the framework and its dependencies:

machine
|> Erlang (~> 17)
|> Elixir
|> Phoenix

(or even one-line it: machine |> Erlang |> Elixir |> Phoenix and use it as the title), especially since the section titles are a bit inconsistent in breaking the flow: “Elixir needs Erlang” followed by “Phoenix needs Elixir”.

I think the Layers Of Phoenix figure has the position of the router and pipelines functions reversed? Based on the text, it seems like the connection would be passed to pipelines first, then router.

Listing for user_controller.ex should use the new function registration_changeset like indicated in the lead in. However it still uses the old changeset function.

In the set of iex commands:

changeset = foreign_key_constraint(changeset, …)

won’t work without first “import Ecto.Changeset” as foreign_key_constraint/3 will be undefined in iex

It should be “User.registration_changeset” instead of User.changeset inside code example “authentication/rumbl/web/controllers/user_controller.ex”

Because the users created earlier in the book have their password_hash set to plaintext passwords, I dropped my Ecto tables (mix ecto drop) and created a seeds file to recreate those users:

alias Rumbl.Repo
alias Rumbl.User

Repo.insert!(User.registration_changeset(User{},{name: “Jose”, username: “josevalim”, password: “<3<3elixir”}))
Repo.insert!(User.registration_changeset(User{},{name: “Bruce”, username: “redrapids”, password: “7langs”}))
Repo.insert!(User.registration_changeset(User{},{name: “Chris”, username: “chrismccord”, password: “PheonixRocks”}))

Upon running the seeds file I was able to login as the test users.

Using the code as printed in the book, I got a deprecation warning:

the :name option in form_for/inputs_for is deprecated, please use :as instead
(phoenix_html) lib/phoenix_html/form_data.ex:47: Phoenix.HTML.FormData.Plug.Conn.to_form/2
(phoenix_html) lib/phoenix_html/form.ex:226: Phoenix.HTML.Form.form_for/4
(rumbl) web/templates/session/new.html.eex:2: Rumbl.SessionView.“new.html”/1
(phoenix) lib/phoenix/view.ex:197: Phoenix.View.render_within/3

I changed the “form_for” line to read:

<%= form_for conn, session_path(conn, :create), [as: :session], fn f -> %>

(note change from [name: :session] to [as: :session])

and the deprecation warning went away.

The figure that shows “how it all fits together.” is not helping me.

I am so used to an MVC model where the “Model” and the Repo are very closely tied together that seeing them separated is somewhat confusing.

I’m not sure what the “1, 2, 3” labels on the diagram are meant to show, nor is it clear what the colors and shapes are meant to convey.

Perhaps another diagram showing how the “traditional” MVC mechanism works and THEN a comparison showing how the Phoenix model of MVC is different would help?

Is it the model/repo that is the break between the pure and impure? (so the model and repo are together in traditional MVC, but in Phoenix’s MVC the repo become part of the controller because it is impure and has DB side effects)?

I know this diagram and associated discussion are meant to convey something important but I fear I may just not be getting it :-)

Also in the diagram on Page 89 there is a circle labelled “Mail”. What is that? Where did it come from?

CHANGE:
In Elixir, We might
TO:
In Elixir, we might

This line:
iex> Repo.delete category

Won’t work, since category was built without the foreign_key_constraint.

Should be:
iex> Repo.delete changeset

Several times throughout the book it is mentioned that the model functions should be pure.

However in the authentication chapter, the encrypted_password (generated by the comeonin library) is put into a changeset:

put_change(changeset, :password_hash, Comeonin.Bcrypt.hashpwsalt(pass))

There are two issues with this:

1) Using an external library in a changeset when we don’t know if the function is pure
2) The hashpwsalt function will generate a new password each time - so the model function is not pure.

The solutions are either:

* Generate the encrypted password somewhere where impure functions are encouraged (controller?)
* Add a note so that the reader is aware of the issue
* Add a function to ecto for example `put_change_fn(changeset, :password_hash, fn ->> Comeonin.Bcrypt.hashpwsalt(pass) end)

After making the changes in the controller, model and view, if we try to go to:

localhost:4000/users/new
we will get an error unless we stop and start the server. Should that be mentioned?

error] #PID<0.354.0> running Rumbl.Endpoint terminated
Server: localhost:4000 (http)
Request: GET /users/new

(exit) an exception was raised:
(Ecto.CastError) deps/ecto/lib/ecto/repo/queryable.ex:188: value `“new”` in `where` cannot be cast to type :id in query:

Would it be a good idea to also include delete and update for the user?

When starting up the hello app on Windows for the first time I am prompted with ‘Could not find “rebar”, which is needed to build dependency :fs I can install a local copy which is just used by Mix Shall I install rebar? [Yn]’ There isn’t any indication from the text in the book that this might happen. I responded with Y and installed it and it appears to be working but it was a little surprising to see this without being prepared by the text.

comeonin is now on version 1.2

defp deps do
[…,
{:comeonin, “~> 1.2”}]
end

In the Layers of Phoenix section you go over the layers of a request and mention that pipelines come before the router. In the diagram it is the other way around. “A request comes into an
endpoint. From there, a request goes into pipelines. As you might expect, a
pipeline groups functions together to handle common tasks. You might have
a pipeline for browser requests, and another for JSON requests. From there,
requests go into our router layer, which directs a request into the appropriate
controller.”

In the blue box of functions you have endpoint |> router |> pipelines |> controller but the text directly underneath says endpoint |> pipelines |> router |> controller.

My user_controller.ex file matches the linked one but it doesn’t validate password length and it’s not saving anything in the password_hash column of the database. There’s no mention of the registration_changeset in the code example or the linked controller file. I tried replacing the first mention of the User.changeset with User.registration_changeset and got an exception. I’m running Elixir 1.0.5 and Phoenix 1.0.3 and Erlang/OTP 18 [erts-7.0.3] [source] [64-bit].

Should
word.fetch! will raise if the given key does not exist,…

be
word.fetch! will raise an error if the given key does not exist,…

Filename of the first code snippet on the page `controllers_views_templates/listings/rumbl/web/controllers/user_controller.change1.ex` should not contain the term `change1` ?

That confused me for a bit, as I thought it was some kind of weird shorcut name for the file.

In the “Dangerous, insecure code!” section, the `table_name` variable doesn’t seem to be used.

“We’ve have fetched data…” should be “We have fetched data…” or “We’ve fetched data…”

The order in the pipeline “diagram” for “The Layers of Phoenix” isn’t the same as described in the text below (endpoint -> router -> pipelines vs. endpoint -> pipelines -> router).

In the ‘Validating Foreign Keys’ section, inside ‘iex’, the user has to first ‘import Ecto.Query’ or the ‘video = Repo.one(from v in Video, limit: 1’ line will return ‘undefined function from/2’.

In the sentence, “All of the routes after pipe_through :browser, which is all…” the word pipe_through is not in the monospace teletype font like the word :browser is even though this is a reference to a line in the previous code listing.

After running priv/repo/seeds.exs, we run it again to watch it fail. The command given this second time is incorrect. Rather than just running `mix run priv/repo/seeds.exs` again, it says to run `mix phoenix.gen.model Category categories name:string`. (This happens on ~ line 6).

In order for the sample code in iex to work, you need to also import Ecto.Query. Otherwise, the line(from the next page) `Repo.one(from v in Video, limit: 1)` throws this error: ‘protocol Enumerable not implemented for Rumbl.Video’

In Rumbl.Auth.login_by_username_and_pass, the third clause of the cond statement (true -> …) seems like it’ll never happen, since “user -> …” is a catch-all, no? Nor should it, probably; we better not reveal whether a username exists or not, to someone trying to log in.

In Rumbl.Auth.login_by_username_and_pass, as a general good practice, one might
make use of dummy_checkpw() for nonexistent users in order to avoid user
enumeration by timing attacks:

import Comeonin.Bcrypt, only: [checkpw: 2, dummy_checkpw: 0]

# …

def login_by_username_and_pass(conn, username, given_pass, opts) do
repo = Keyword.fetch!(opts, :repo)
user = repo.get_by(Rumbl.User, username: username)

case verify_password(given_pass, user) do
true ->
{:ok, login(conn, user)}
false ->
{:error, :unauthorized, conn}
end
end

def verify_password(given_pass, %Rumbl.User{password_hash: pw_hash}) do
checkpw(given_pass, pw_hash)
end
def verify_password(_given_pass, nil) do
dummy_checkpw()
end

“Tight your seatbelt” – isn’t the usual phrase “tighten your seatbelt”?

“… we’ll create a new controller explicitly for watching videos, along with it’s view and template” – should be “its template”.

In Ch. 5, the first code example has an error I believe. The code for file “authentication/rumbl/web/controllers/user_controller.ex” has the following:

```
changeset = User.changeset(%User{}, user_params)
```

Should be:

```
changeset = User.changeset(%User.registration_changeset(%User{}, params)
```

With the way it’s currently written, no changes are made to “user_controller.ex” and the passwords are not encrypted.

Then, we’ll create a new controller explicitly for watching videos, along with it’s view and template.

“it’s” should be “its”.

Shouldn’t the following:

changeset = User.registration_changeset(%User{}, user_params)

be

changeset = User.changeset(%User{}, user_params)

“Next, we implement a `onYouTubeReady` function” – the function seems to be actually called `onIframeReady`.

We generate a migration but there’s no reference to telling the user to run it. Should probably do that after filling in the contents, or adding the slug field to the model.

In the code listing for `echo/listings/rumbl/web/templates/user/new.change1.html.eex` file, there is a missing `<% end %>` that should close out the anonymous method passed to form_for as the last parameter.

Regarding my previous suggestion for the same page (above?), the User. registration_changeset is actually the correct one, as otherwise the password_hash is not saved and there is an error when trying to use sessions/new.

Typo: “Then, we call a as-yet undefined helper…”
Fix: “Then, we call an as-yet undefined helper…”

“If we inspect the HTML that was generated by visiting https[link] in our browser, we’ll see the following markup” - why is this https?

(link omitted because ‘hyperlinks are not allowed in errata’)

what query compositions looks like
should be
what query compositions look like

Video.changeset suddenly uses assoc_constraint instead of foreign_key_constraint; it would probably be helpful to avoid confusion if one or the other was used consistently, OR the change was explained to be for some particular reason.

Line 2 of the source listing is changeset = User.changeset(%User{}, user_params)

Surely this should be changeset = User.registration_changeset(%User{}, user_params) to actually use the new function.

The form of combined ‘if’ conditional and assignment used in Video.slugify_title doesn’t (to me at least) feel very explicit; the assignment in ‘if’ can easily be mistaken for a comparison, and it’s less clear what the actual return value is when it doesn’t find a :title in the changeset. I much prefer using ‘case’, as below:

case get_change(changeset, :title) do
nil -> changeset
title -> put_change(changeset, :slug, slugify(title))
end

If we are following from previous examples that we have used the alias for the Repo.User, shouldn’t we use:
from u in User
instead of:
from u in Rumbl.User

Perhaps the migration should also include handling existing data, to make sure we get slugs generated? Something like:

defmodule Rumbl.Repo.Migrations.AddSlugToVideo do
use Ecto.Migration

def up do
alter table(:videos) do
add :slug, :string
end

execute(“update videos set slug = regexp_replace(lower(title), ‘[^\\\\w]+’, ’’)”)
end

def down do
alter table(:videos) do
remove :slug
end
end
end

Not sure about page, it’s from reader software. The paragraph is called “The Layers Of Phoenix” and it shows a pipeline of a request, however the text description swaps the order, from endpoint |> router |> pipelines to endpoint |> pipelines |> router

Typo: “Ecto allows developers to enjoy many of the guarantees database offers in terms of data integrity”

Should be (if referring to databases in general): “Ecto allows developers to enjoy many of the guarantees databases offer in terms of data integrity”.
Should be (if referring to a database in general): “Ecto allows developers to enjoy many of the guarantees a database offers in terms of data integrity”.

In the paragraph:

“And we’re all set. Head over to your browser and visit localhost:4000/manage/videos. You’ll see an empty list of videos:”

the extra path element, “manage”, is wrong and should be removed. The paragraph should then read:

“And we’re all set. Head over to your browser and visit localhost:4000/videos. You’ll see an empty list of videos:”

I had to remove the “https…” in the above expressions because of your spam prevention.

btw, really enjoying the book; you present Phoenix in an eye-opening way. I’m beginning to suspect that Phoenix is a viable alternative for Rails for ALL web work, not just complex projects.

You have a missing “iex -S mix” at the beginning of the “Validating Foreign Keys” section as follows:

In addition to the steps here:

alias Rumbl.Category
alias Rumbl.Video
alias Rumbl.Repo

you also need to do

import Ecto.Query

If this is omitted, the the following instruction you suggest:

video = Repo.one(from v in Video, limit: 1)

fails w/ the error

(CompileError) iex:5: undefined function from/2

HTH

In the paragraph:

“And we’re all set. Head over to your browser and visit localhost:4000/manage/videos. You’ll see an empty list of videos:”

the extra path element, “manage”, is wrong and should be removed. The paragraph should then read:

“And we’re all set. Head over to your browser and visit localhost:4000/videos. You’ll see an empty list of videos:”

I had to remove the “https…” in the above expressions because of your spam prevention.

btw, really enjoying the book; you present Phoenix in an eye-opening way. I’m beginning to suspect that Phoenix is a viable alternative for Rails for ALL web work, not just complex projects.—Scott Smith

In the definition of the function “load_categories”, the expression

Repo.all from(c in Rumbl.Category,
order by: c.name,
select: {c.name, c.id})

must not have the open and close parenthesis; i.e. should read

Repo.all from c in Rumbl.Category,
order by: c.name,
select: {c.name, c.id}

Otherwise when you do “mix phoenix.server” before starting the Delete section on page 119, the console will complain:

Compilation error on file web/controllers/video_controller.ex

(SyntaxError) web/controllers/video_controller.ex:84: unexpected parentheses. If you are making a function call, do not insert spaces between the function name and the opening parentheses. Syntax error before: ‘(’

“Then, we use Comeonin to encrypt our password”.

You do hash the password, not encrypt it.

Search for 4948322 on stackoverflow for a description of the difference.

`changeset = User.changeset(%User{}, user_params)`

Should probably be:

`changeset = User.registration_changeset(%User{}, user_params)`

Though I notice that you do things differently in the dowloadable source code. There it’s:

`changeset = User.changeset(%User{}, :registration, user_params)`

The paragraphs says:

“The create action in the user controller must now use our new registration_changeset, like this:”

and the code is:

changeset = User.changeset(%User{}, user_params)

but according to what is written, should’t the code be like ?

changeset = User.registration_changeset(%User{}, user_params)

Should we leave an empty line on the show action between getting the video and rendering the view as in the above example for index?

create an unique index for it
should be
create a unique index fort it

at the end of this page, I think it’s missing import Ecto.Query . Or video = Repo.one(from v in Video, limit: 1) will raise (CompileError) iex:5: undefined function from/1

The text

“That create action picks of the inbound arguments for username as user and password as pass”

is a little confusing. Should it perhaps read

“That create action picks off the inbound arguments for username as user and password as pass”

In the text “…inbound arguments for username as user and password as pass.” The words username, user, and password are all in the monospace type used for code but the word “pass” is not. The word “pass” should be monospace type to maintain consistency.

The sentence that reads “Finally, we created categories for our videos.” is incorrect. We didn’t create any categories for videos in this chapter.

we’ll know the exactly when an annotation is added.
should be
we’ll know exactly when an annotation is added.

Pipeline diagram says

connection
|> endpoint
|> router
|> pipelines
|> controller

but text below suggest

connection
|> endpoint
|> pipelines
|> router
|> controller

In the listing for new.change1.html.eex, you’re missing a <% end %> (for the if)

the authenticate function needs to be modified to take a second parameter (_options?) in order to operate as a function plug.

In user_socket.ex, “Repo.get!(Rumbl.User, user_id)” should be “Rumbl.Repo.get!(Rumbl.User, user_id)”

and ‘def id(socket), do: “users_socket:” <> socket.assigns.user_id’ should be ‘def id(socket), do: “users_socket:#{socket.assigns.current_user.id}”’

“…Phoenix provides a 3-tuple join signature to both join the channel and sent a join response at the same time.”

should be:

“…Phoenix provides a 3-tuple join signature to both join the channel and send a join response at the same time.”

“Finally, we wired up a data-seek attribute on our renderAnnotation template, but we haven’t done anything with it yet.”

This was never wired up in any previous sep - need to change renderAnnotation to:

let template = document.createElement(“div”)
template.setAttribute(‘data-seek’, at)
template.innerHTML = `[${this.formatTime(at)}] ${user.username}: ${body}`

Line numbering in the JavaScript code listing makes it impossible to copy-paste in a sane way; the line numbers and dashes are copied together with the code.

user = Repo.get!(Rumbl.User, user_id)

should be:

user = Rumbl.Repo.get!(Rumbl.User, user_id)

The last line of user_socket.ex has a couple of problems.

def id(socket), do: “users_socket:” <> socket.assigns.user_id

1. The user_id is an Integer, which is not a valid argument to <>.

2. We never assigned the user_id in the first place. It should be:

def id(socket), do: “users_socket:%{socket.assigns.current_user.id}”

in this example:

iex> j_users = from u in users_count, where: ilike(u.name, ^{“%j”) #Ecto.Query<from u in Rumbl.User, where: ilike(u.name,}“%j”), select: count(“*”)>

you have the ilike string backwards. It should be “j%”, not %j

To get the code working I had to change two lines in connect in user_socket.ex to this:
user = Rumbl.Repo.get!(Rumbl.User, user_id)
{:ok, assign(socket, :user_id, Integer.to_string(user.id))}
(the lines are the :ok case).

I got error when trying to store user in assigns, so changed to user_id.

There’s a missing line of code, right after:

> We need only add an options variable, which we’ll ignore

I believe the missing line should add `_opts` as the second argument to `authenticate`:

` defp authenticate(conn, _opts) do `

In the 2nd paragraph after the code snippet, the following sentence sounds odd:

If one exists, we lookup it up and assign the result in the connection.

Maybe “lookup” should just be “look”. For example:

If one exists, we look it up and assign the result in the connection.

Missing code snippet after this sentence:

We can then change our index action back to it’s previous state, like this:

“We need only add an options variable, which we’ll ignore:..” is missing the appropriate code text. Similarly “…We can then change our index action back to it’s previous state, like this:…” is missing the code suggestion. I also could not find the appropriate code changes in the source code, yet I am receiving an error message.

Missing code snippet after the following sentence:

Let’s go back to the Rumbl.UserController.create action and change it to call the login function after we insert the user in the database:

In this part, there is missing code

we can satisfy that contract. We need only add an options variable, which
we’ll ignore:

**Missing code in this place

Needs something like this:

defp authenticate(conn, _opts) do

Now we can plug it in our controller, right after use Rumbl.Web:
plug :authenticate when action in [:index, :show]

I ran into an error where the scheduleMessages function would fail when it called Player.getCurrentTime() because the underlying implementation called this.player.getCurrentTime() on the iframe. That function wasn’t defined for some reason because i was running adblock— even though there were no ads on the video I was embedding. If you see an unrelated console error about not being able to connect to doubleclick.net, it’s actually related! Anyway, might want to warn the reader about adblock in the context of embedding videos. I hadn’t run into that particular trouble with the youtube player before.

Footnote 3 has an extra http: at the beginning.

The formatting makes it look like the standard output of “mix phoenix.new” is actually body text of the book. (Formatting error existed back to beta 1 version of the book.) At the top of the page the “$ mix phoenix.new hello” line is in color, indicating something I should type. However, all the text down through “$ iex -S mix phoenix.server” should be indented, black and white, and in a monospaced font, indicating that it is all output from the one command.

Repetition of “Said another way”:

“Said another way, for each request, a new conn would flow through all of the pipelines and then die.”

and then a couple of lines later:

Said another way, your socket is your ongoing conversation.

Unclear about what the second part of this sentence means: “Just before our app.js script, we render a script tag that attaches a userToken variable to the window from our conn.assigns, along with the entire Plug.conn struct.”

window.userToken = “<%= assigns[:user_token] %>”

We only seem to be doing the first part?

Based on the code that follows this paragraph, “socket.assigns” should probably be “conn.assigns”:

Next, we need to add the :user_token to socket.assigns whenever we have a current user. We already have code to assign the current user in Rumbl.Auth, so let’s handle this there:

Shouldn’t “token = Phoenix.Token.sign(conn, ”user socket“, user.id)” be “token = Phoenix.Token.sign(conn, ”user.socket“, user.id)” (missing dot between user and socket)?

When referencing the config/config.exs the actual config code that is shown differs from what is generated in version 1.0.3 of Phoenix.

Old code:
config :hello, Hello.Endpoint,
url: [host: “localhost”],
root: Path.expand(“..”, DIR),
secret_key_base: “QNU… …Oo/eLnw”,
debug_errors: false,
pubsub: [name: Hello.PubSub,
adapter: Phoenix.PubSub.PG2]

New Code:
config :hello, Hello.Endpoint,
url: [host: “localhost”],
root: Path.dirname(DIR),
secret_key_base: “7ol…10/tNtvx”,
render_errors: [accepts: ~w(html json)],
pubsub: [name: Hello.PubSub,
adapter: Phoenix.PubSub.PG2]

The youtu.be regex has a few issues. It’s not core to the book of course, but still, it could distract the reader if they notice the same things I did. This also simplifies the regex, giving the reader a bit less to process.

Some thoughts:

- could escape the period in the URL so it doesn’t match any character (good habit)

- good idea to use + instead of * if you expect the ID to be non-empty

- could use something like ~“” to avoid having to escape a bunch of slashes

- no need to escape & and ? within the square brackets
- no need to anchor/bound the regex with “^.*” before or “.*” after, given current usage

Before:

~r/^../

After:

~r“(?:youtu\\.be/|v/|e/|u/\\w+/|embed/|v=)(?[^#&?]+)”

^“%j” matches only users ending in “j”
^“j” would match users with “j” in their name, as intended

In the description below the code, the paragraph about `renderAtTime` (talking about `messagesToRender`, `this.messageQueue` and using map) doesn’t seem to relate to the actual code, which uses a simple filter.

iex> name = 123

iex> Repo.all(from u in Rumbl.User, where: u.name ^name) ** (Ecto.CastError) iex:4: value `123` in `where` cannot be cast to type :string in query: from u in Rumbl.User, where: u.name ^123

Should we not be interpolating name i.e. ^name instead of ^123 here to show that an integer will fail since the query expects a string.

“External data is unsafe, so we explicitly match on the string keys”

Would be good to clarify how strings/atoms relate to safety. I assume it is something like atoms not being GCed? Would be good to be explicit.

“making sure sensitive fields like role cannot be set externally”

Reference to “role” when we haven’t talked about it yet. I’m assuming this is a reference to something introduced later in the book.

I think it would also be good to mention what happens in the browser console after making the changes in app.change1.js. For example, in Firefox I get ‘Unable to join Object { reason=“unmatched topic”}’. I presume this is because we haven’t created the socket named “video:#{videoId}” on the server yet. Just worth a mention I think.

The generated Rumbl.UserSocket file is different in our apps - lots of commenting (which I can assume was left out for brevity), but the :longpoll transport was also commented out.

In the “Chris Says Why ES6” box, I think it would be great to have links to some resources on ES6, eg. detailing new features, syntax changes, etc. As someone reasonably familiar with “normal” JavaScript, a lot of this ES6 code looks completely foreign.

In first paragraph under “Creating the Channel”, the topic has an identifier of something like “video:#{video_id}”, not “video:video_id”. Gotta put the actual video ID in there.

Even without forwarding the raw payload, we have a large security hole - the current implementation does not escape HTML submitted by the user.

You miss instructing the user to actually run the migration created by generating the Annotation model.

“so add the has_many relationship to both your User and Video schema blocks in web/models/annotation.ex and web/models/user.ex”

should this be “web/models/user.ex and web/models/video.ex” ?

Similar to @musoumusic I was also getting a problem with this.player.getCurrentTime not being a function. I presume this is a timing thing and is being called before the player gets properly loaded - if I change the setTimeout call to 2000 instead of 1000 it appears to load correctly (but then of course you only get updates every two seconds). I think this code needs to be reworked a bit to only try things when the player is loaded.

The JavaScript code given to jump to the exact time the annotation was made only works if you don’t click on the displayed username - the username is in a `b` tag and therefore doesn’t have the `data-seek` attribute set.

Last paragraph says “will always have the value of in the field”, which would seem to be missing something between “of” and “in”.

in “channels/listings/rumbl/web/channels/user_socket.change2.ex”

This line fails:
user = Repo.get!(Rumbl.User, user_id)

Because in the current “user_socket.ex” file, `Repo` was not imported.

Unless I missed something in the current version book, there is no import/use/alias for `Rumbl.Repo`

I wonder if `use Rumbl.Web, :channel` should be added on the top of the file?

in the “Examining Our Changes to Generated Code” section, second paragraph, first line, the code says `belongs_to :user, Rumble.User`.

Using Rumble instead of Rumbl

"We set up some aliases and then traverse a list of category names, writing
them to the database. Let’s run the seeds file with mix run:

$ mix run priv/repo/seeds.exs

Presto! We have categories. Before we move on, let’s check to see what happens
if someone runs the seeds file twice:

$ mix phoenix.gen.model Category categories name:string

(Ecto.ConstraintError) constraint error when attempting to insert
model:

• unique: categories_name_index"

The second command is not the seed command, but the output does show what the seed command produces if you run it a second time.

Look a the function head.
should be
Look at the function head.

In the first paragraph, after “We need only add an options variable, which we’ll ignore:” there should be example but it’s missing in my version of the ebook (PDF).

When implementing log out functionality I was trying to figure out why my flash message wasn’t showing up after logging out. I figured out that `configure_session(conn, drop: true)` has to be changed to `delete_session(conn, :user_id)` if you want the flash message to appear. I think this could be made more clear.

Under the wrapping up section of Chapter 6 Ecto Queries, it states:

“In this chapter, we started with some Ecto queries in the console. We then generated a Video model with a relationship to User. Finally, we created categories for our videos. Along the way, we gained some insights.”

The sentence about creating categories for our videos is incorrect. That was never covered in the material in chapter 6.

The final bullet under the Wrapping Up section of chapter 6, it says:

“We created a video model and used it to issue some queries across two models.”

This is incorrect. No such exercise was conducted in this chapter.

Not the highest of priorities, but I know you can do better than this: “With our database ready, we can begin to use our database.”

;)

Second paragraph of “Defining the User Schema”, second sentence:
“The schema and fields macros”
It should be:
“The schema and field macros”
(Non-pluralised “field” macro name.)

In Chapter 6, while exploring the Ecto’s query interface there is an example showing query composition. The `j_users` query seems to have a typo:

~
j_users = from u ​in​ users_count, ​where:​ ilike(u.name, ^​“​​%j”​)
~

this will return all users with names ending in ‘j’.

I think that the correct query should be:

~
j_users = from u ​in​ users_count, ​where:​ ilike(u.name, ^​“​​j%”​)
~

On the code snippet user_controller.change2.ex there is one parameter missing that will result in an error (Elixir says there isn’t a defined function authenticate of arity 2). In the code for the next chapter this is corrected passing a second parameter _opts.

When I try to add a new annotation after we have added persistence for them I get the error:

(Ecto.ChangeError) value `“2”` for `Rumbl.Annotation.video_id` in `insert` does not match type :id

The id is being passed as a string instead of an integer, which it expects for type :id.

I fixed it by changing our join function in “video_channel.ex”

FROM:

def join(“videos:” <> video_id, _params, socket) do
{:ok, assign(socket, :video_id, video_id)}
end

TO:

def join(“videos:” <> video_id, _params, socket) do
case Integer.parse(video_id) do
{int, _} ->
{:ok, assign(socket, :video_id, int)}

_ ->
{:error}
end
end

“We composed a response by rendering an annotation.html view for every annotation in our list. Instead of building the list by hand”

Should say “annotation.json” rather than “annotation.html”

Getting the error to the console:

* this.player.getCurrentTime is not a function*

Most likely caused because the getCurrentTime function in the Timeout loop in the “scheduleMessages” function is fired before the YouTube iFrame is ready.

Fixed it by adding a conditional check in the Timeout loop to check if the iFrame is ready:

scheduleMessages(msgContainer, annotations){
setTimeout(() => {
if (window.onYouTubeIframeAPIReady) {
let ctime = Player.getCurrentTime()
let remaining = this.renderAtTime(annotations, ctime, msgContainer)
this.scheduleMessages(msgContainer, remaining)
}
}, 1000)
},

I was completely unable to get this to work with :httpc.request

It kept returning some kind of intermediate ad page or something. I ended up going with HTTPoison. Also, wolfram can be slow to respond so the timeouts had to be lengthened

Additionally, wolfram doesn’t always return a Result pod, the examples to use in iex return a Definition pod. I ended up restructuring a bit to grab Result, or Definitions if result was nil. gist(dot)github(dot)com/55b0c4df0f1679ff6536

URI.encode should be URI.encode_www_form

On page 118 we try to update a video with both an existing and non-existing category_id.

This will be failing with the following message for readers that just followed the book (without adding more videos or tweaking the input data):

{:error,
Ecto.Changeset{action: :update, changes:{category_id: 2},
constraints: [%{constraint: “videos_category_id_fkey”, field: :category_id,
message: “does not exist”, type: :foreign_key}],
errors: [url: “can’t be blank”, description: “can’t be blank”], filters: %{},
model: %Rumbl.Video{meta: #Ecto.Schema.Metadata<:loaded>,
category: #Ecto.Association.NotLoaded<association :category is not loaded>,
category_id: nil, description: nil, id: 1,
inserted_at: #Ecto.DateTime<2015-11-22T09:59:21Z>, title: “hi”,
updated_at: #Ecto.DateTime<2015-11-22T09:59:21Z>, url: nil,
user: #Ecto.Association.NotLoaded<association :user is not loaded>,
user_id: 1}, optional: [:category_id], opts: [source: :changeset],
params: %{“category_id” => 2}, repo: Rumbl.Repo,
required: [:url, :title, :description],
types: %{category_id: :id, description: :string, id: :id,
inserted_at: Ecto.DateTime, title: :string, updated_at: Ecto.DateTime,
url: :string, user_id: :id}, valid?: false, validations: []}}

As you can see it’s failing because when we created our first video in page 107 we didn’t add any description or url, both of which are required. This we directly inserted that model in the database without using changesets it went through without any issues.

In “Creating slugs” (starts page 132 in B4) we create a migration but never tell the reader to run that migration. This might be useful as I imagine people will run into issues because of that.

I implemented the authenticate function in Chapter 5 like this:

defp authenticate(conn, _opts) do
if !conn.assigns.current_user do
conn
|> put_flash(:error, “You must be logged in to access that page.”)
|> redirect(to: page_path(conn, :index))
|> halt()
end
conn
end

This formulation of the function makes it clearer (to me at least) that we return the connection object from the function regardless of whether the authentication was a success.

On page 78 and 79 of Chapter 5 there are three places where code is implied but not actually listed.

I know the book is in early release but there are no visible indications that would remind the authors to return to these sections and fill them in. So, here’s a list of places that need code listings on these pages:

Page 78:

We need only add an options variable, which we’ll ignore:

2nd paragraph

“Each channel module will have three ways receive events.”

should probably be

“Each channel module will have three ways to receive events.”

`{:ok, resp, assign(socket, :video_id, video_id)}` assigns a string to :video_id, but the ` build(:annotations, video_id: socket.assigns.video_id)` line, in `handle_in/3` just below it, expects :video_id to be an integer. Changing the line to use `video.id` fixes the issue:

{:ok, resp, assign(socket, :video_id, video.id)}

“Let’s recap that now:” sounds like it’s supposed to have a code fragment after it.

Between
Let’s go back to the Rumbl.UserController.create action and change it to call the login function after we insert the user in the database:

And
Register a new user and try to access the pages we have previously restricted. You’ll see the user can finally access them.

No code appears.

I changed my Rumbl.UserController.create action to add this line :
|> Rumbl.Auth.login(user)

First paragraph ends with “We need only add an options variable, which we’ll ignore:”
but the code isn’t shown.

Double “at”:

“This feature will probably seem a little tedious to you at at first, but it is the only way to guarantee your application has predictable performance when the amount of data grows.”

Excerpt From: Chris McCord, Bruce Tate, and José Valim. “Programming Phoenix (for Travis Graham).” iBooks.

We’ve built a generic [module module] to spawn compu- tations for queries.

should be

We’ve built a generic [module] to spawn compu- tations for queries.

Possibly left ‘our model to handle’ when adding ‘our controller and model to handle’ as an updated thought.

“Now that we’ve updated our model to handle our controller and model to handle new users, we need to add the new action to our router.”

Excerpt From: Chris McCord, Bruce Tate, and José Valim. “Programming Phoenix (for Travis Graham).” iBooks.

Missing “<% end %>” for complete context in the code snipit:

“​<​ form_for changeset, user_path(conn, ​:create​), ​fn​ f -> ​>​”

Excerpt From: Chris McCord, Bruce Tate, and José Valim. “Programming Phoenix (for Travis Graham).” iBooks.

The Repo in def connect is not aliased.
Either you need to add alias Rumbl.Repo or you have to call it explicitly.

I don’t understand what this means:

> Now that we’ve updated our model to handle our controller and model to handle new users…

In the section “Building a Feature”, the code section file path is started with “getting_started/listings/”, which probably makes sense if you are using the code downloads, but if you are following along the book example in the console, that doesn’t make a whole lot of sense. It would just be “hello/”

It seems that what’s returned by the Wolfram API has changed.
The xpath query on page 184 should be changed to:

xpath(~x“/queryresult/pod[contains(@title, ‘Definitions’)]/subpod/plaintext/text()”)

Otherwise you no longer get any results on page 186, when trying in the IEx console.

`usernmae` should be `username`.

Section: The Anatomy of a Plug
Paragraph: 1
Sentence: 2

The following
“There are two kinds of plugs: module plugs and functions plugs”
Should be:
“There are two kinds of plugs: module plugs and function plugs”
(de-pluralise “function”)

Section: Writing an Authentication Plug
Paragraph: 1
Sentence: 1

The following:
“The authentication process work in two stages.”
Should be:
“The authentication process works in two stages.”
(pluralise “work”)

Missing code block for the sentence:
“We can then change our index action back to it’s previous state, like this:”

The missing code block should be the original `index` function:
```
def index(conn, _params) do
users = Repo.all(User)
render conn, “index.html”, users: users
end
```

“Look a the function head.” => “Look at the function head”

html => json, as in:

“We composed a response by rendering an annotation.html view for every annotation in our list.”

=>

“We composed a response by rendering an annotation.json view for every annotation in our list.”

in the popup titled “Why brunch”, at the of the text its written:

about the video so we’ll know the exactly when an annotation is added.

The word “the” should not be there !?

It looks like there is a code snippet missing. Between “We need only add an options variable, which we’ll ignore:”

and

“Now we can plug it in our controller, right after use Rumbl.Web:”

The colon indicates that there should be a code example but there is nothing. I guess it is about adding the opts parameter to the authenticate function.

“It’s only job is to spawn a process and return {:ok, pid} …” – should be “its only job …”.

Seems to be a section missing after the text …

“We can then change our index action back to it’s previous state, like this:”

The function plug stuff on this page is confusing. I tried looking at the source code to see if i could figure out what was going on but got more confused as I can’t find the code in the source at that bit actually being used anywhere.

I think i know what the intention is but I feel it is missing a section of code - or a sample fragment - that would clear up how this could be used as a function plug.

The text says that Phoenix generates a file called config/prod.secrets.exs. The actual filename is config/prod.secret.exs. This singular/plural discrepancy is spread all over this section.

I realize that this doesn’t actually matter, since you can call it whatever you want, but it’s sloppy.

“with our hard-coded score of 90%.”

The hard-coded score is 95

In Rumbl.UserSocket.id/1, the binary concatenation fails; Suggest interpolation, using the current_user as

def id(socket), do: “users_socket:#{socket.assigns.current_user.id}”

Gary Fleshman

Let’s go back to the Rumbl.UserController.create action and change it to call the login function after we insert the user in the database:

——- NO CODE IS PROVIDED

run the backend_seeds.exs with the proper file extension, ‘exs’

agree that the solution described by Steve Domin (79233) is necessary for a query “what is elixir?”

unfortunately, the response for a query “what is the meaning of life?” lacks a “Definitions” title, but does contain a “Results” title

one solution would expand the xpath spec as follows:

|> xpath(~x“/queryresult/pod[contains(title, 'Definitions') or contains(title, ‘Result’)]
/subpod/plaintext/text()”)

nevertheless, this approach would not scale well to a larger number of expected titles

with a timeout value of 5_000 (millisec), the wolfram API consistently fails to return an answer for this query: Rumbl.InfoSys.compute(“what is elixir?”)

raising the timeout to 8_000 consistently succeeds for the same query

def id(socket), do: “users_socket:” <> socket.assigns.user_id

should be

def id(socket), do: “users_socket:#{socket.assigns.current_user.id}”

Since we only assigned `current_user` to socket, not `user_id`.

def handle_in(“new_annotation”, params, user, socket) do

Having `user` as a param is odd (and also broken), since that param is never actually passed in. This change seems to have come out of nowhere, since the user is pulled from the socket in all prior examples.

This line:
$ `mix test test/controllers/page_controller_test.exs:4

Should be:
$ mix test test/controllers/page_controller_test.exs:4

“The error message has everything we need to do move on” -> “The error message has everything we need to do in order to move on”

The sentence that read “Make the following changes to you web/channels/video_channel.ex.” should say “Make the following changes to your web/channels/video_channel.ex.” or possibly even “Make the following changes to web/channels/video_channel.ex.” to eliminate the pronoun altogether.

The sentence that reads “…in our channel so our users gets their annotation broadcast…” should read “…in our channel so our users get their annotation broadcast…”

In the codeblock for test/support/conn_case.ex you already include the `import Rumbl.TestHelpers` line, which threw me at first because I didn’t have this line in my file and wondered why.

Missing the definition for `put_current_user/2`. Should show:

```elixir
defp put_current_user(conn, user) do
token = Phoenix.Token.sign(conn, “user socket”, user.id)

conn
|> assign(:current_user, user)
|> assign(:user_token, token)
end
```

In the setup block the context of `config` is missing. After some debugging I found out that the arguments in the setup block are wrong, which should be something like `setup context do` and using `context[:login_as]` on the third line.

`setup %{conn: conn} do` -> `setup config do` on line 1 of the code example.

Create a web/controllers/auth_test.exs

should be

Create a test/controllers/auth_test.exs

The document code sample shows:

setup tags do
unless tags[:async] do
Ecto.Adapters.SQL.restart_test_transaction(Rumbl.Repo, [])
end
{:ok, conn: Phoenix.ConnTest.conn()} end

However, my generated code only returns :ok and the conn is established in page_controller_test.exs where page 127 says we don’t have to define it.

Confusing. I am not sure the advantage or how I have something different.

visit Phoenix.HMTL1. should read visit Phoenix.HTML

The value of this expression appears to be wrong:

iex> video = %Rumbl.Video{id: 1, slug: “hello”}
“/”

When I run it in my REPL I get the following:

iex> video = %Rumbl.Video{id: 1, slug: “hello”}
%Rumbl.Video{meta: #Ecto.Schema.Metadata<:built>

When you run ‘mix test’ later in the chapter, both instances of put_current_user(conn, user) from the code listing cause a compilation error: fuction put_current_user/2 undefined. Either add ‘alias Rumbl.TestHelpers’ in the module, or make the calls to Rumbl.TestHelpers.put_current_user() explicitly.

Says “We need only add an options variable, which
we’ll ignore:
Now we can plug it in our controller, right after use Rumbl.Web”

The code snippet is missing. It should be: " defp authenticate(conn, _options) do…."

The implementation of the bypass mechanism on auth.ex is using the private function put_current_user which was not defined until now

The error I got before using `bypass_through` was:

1) test authenticate_user halts when no current_user exists (Rumbl.AuthTest)
test/controllers/auth_test.exs:6
(KeyError) key :current_user not found in: %{}
stacktrace:
(rumbl) web/controllers/auth.ex:26: Rumbl.Auth.authenticate_user/2
test/controllers/auth_test.exs:7

and not:

1) test authenticate_user halts when no current_user exists (Rumbl.AuthTest)
test/controllers/auth_test.exs:6
(ArgumentError) flash not fetched, call fetch_flash/2
stacktrace:
(phoenix) lib/phoenix/controller.ex:990: Phoenix.Controller.get_flash/1
(phoenix) lib/phoenix/controller.ex:975: Phoenix.Controller.put_flash/3
(rumbl) web/controllers/auth.ex:63: Rumbl.Auth.authenticate_user/2
test/controllers/auth_test.exs:7

I might have just typo’d something but it worked as soon as I added the `setup` function as per the book.

“Now we can we re-run” -> “Now we can re-run”

“Now let’s run out tests” -> “Now let’s run our tests” (last paragraph)

Let’s break that down down

should be

Let’s break that down

We’ve built a generic module module to spawn …

should be

We’ve built a generic module to spawn …

After “We can then change our index action back to it’s previous state, like this: ”
Code should appear, I guess.

It seems that the example code for adding the optional options parameter to the authenticate function is missing.

For this code example, ```Repo.one from u in j_users, limit: 1```. It was said in a previous page (p. 88) that

“Repo.one does not mean ‘return the first result.’ It means ‘one result is expected, so if there’s more, fail.’”

So it is not clear why this code sample includes “limit: 1”. Wouldn’t it fail if there is not just one record? If so, why specify a limit?

The version of Elixir used on this page is 1.0.4, but the latest is 1.1.0. (very soon to be 1.2.0)

The version of Node is an older version, particularly v0.12.2. This should be changed to v4.2.3, or v5.3.0 (depending on LTS support or not). Personally, I’m using Node 5.3.0 and it’s working fine for me.

“Building a Feature” doesn’t explain why we want to tie the pieces together. It just says:

“First things first. Let’s tie a URL to a controller, a controller to a function, and a function to a view.”

I think this should be:

“We’re going to show you how easy it is to create a new page for this application. To make that happen, we’re going to add a brand new route, a new controller with a new function, and a view. Once we’ve done that, we’ll have this: show a picture”

The description of .ex files seems a bit disjointed if not paired with an explanation of .exs files:

“The .ex extension is for compiled Elixir files.”

I recommend changing this to:

“The .ex extension is for compiled Elixir files, while .exs is for Elixir scripts, which are not compiled.”

Show a picture of what happens after adding the “hello” route, and then accessing localhost:4000. While you explain you’ll get an error page, it’d be more helpful to a newbie to see that error page so that they know that they’re seeing the same thing you’re seeing.

“long-running [services|processes]” are mentioned twice on this page, but no example is given. An example might be helpful to really drive the point home.

“The browser pipeline will protect from forgery attacks, honor Accept headers, and fetch the session.”

What kind of forgery attacks, specifically? (I suspect CSRF)

The link “signout” was changed to “Log out” but has not been updated everywhere.
In particular:
link “signout”,
to: session_path(conn, :delete, current_user),
method: “delete”
Should read “Log out”

and
• with the text signout
should read:

• with the text Log out.

As others have mentioned for the missing: “Let’s go back to the Rumbl.UserController.create action and change it to call the login function after we insert the user in the database”.
|> Rumbl.Auth.login(user) worked for me.

“Update your lib/controllers/auth.ex”, I think that should read “Update your web/controllers/auth.ex” In other parts of the book, the Auth module was put in the web/ folder.

Directory/link is absent in the sentence:

“Just replace the layout with the one you’ll find at …”

On the video_channel.ex he is assigning video_id to the socket as a string. Later when persisting to the database I’m getting the following error:

(Ecto.ChangeError) value `“3”` for `Rumbl.Annotation.video_id` in `insert` does not match type :id

I’m casting the video_id to int before assigning it to the socket and it works fine

The tests are broken because the authentication bypass mechanism added on the integration tests chapter was removed

user = conn.assigns[:current_user] -> put_current_user(conn, user)

Since I upgrade phoenix to 1.1 according to Phoenix 1.0.x to 1.1.0 upgrade instructions
@current_user will not be found.

Thanks!

While going through the wrap up of Chapter 6, I’ve read “Finally, we created categories for our videos.” but can’t see any reference to categorizing the videos in the chapter.

I might be misunderstanding something here, but shouldn’t there a be a section talking about this?

Thanks,

In UserSocket.connect/2 function we ‘assign(socket, :current_user, user)’, however
in the UserSocket.id/1 we try to get value by :user_id key from assigns map, it produces quite nasty error. I hope I’ve helped.

j_users = from u in users_count, where: ilike(u.name, ^“%j”)

Should be

j_users = from u in users_count, where: ilike(u.name, ^“j%”)

(bottom of pg62) Pick one of “frontend” or “front end” or “front-end” and stick with it. Same with backend.

Missing code example after this paragraph:

“Let’s go back to the Rumbl.UserController.create action and change it to call the login function after we insert the user in the database:”

build(:videos)

Should be

Repo.build(:videos)

In the change history for B6.0 the link for the Umbrellas chapter links to the Testing MVC chapter

“generated by visting” should of course read ‘visiting’ (in chapter “Building Forms”)

The changes to “auth.ex” reference a put_current_user method that hasn’t been defined yet.

You don’t actually show the running of the `mix ecto.migrate` command here (although it’s pretty much implied).

At the top of this page, show a picture of the “You must be logged in to access that page”, along with the login fields. It will help readers solidify what they’re trying to accomplish.

So, we just went and pulled out the authenticate function from the user controller, and renamed it and popped it in to the Auth plug.

The way I follow is we are deleting the code from the user controller, but we don’t rename the usage of plug at the top of the user controller

Why did we spend nearly the whole chapter talking about the ins and outs of querying Repo and then just generating a form.

Feels like the teaching got ahead of the objective in this chapter

relationships/listings/rumbl/web/controllers/video_controller.change1.ex
defp user_videos(user) do
assoc(user, :videos)
end

Ecto.Model.assoc isn’t being imported so this code fails for me. Is there a missed instruction?

In Ch.6 when we create the video, it gets no user_id. I thought there was a mistake (mine or the book’s) and tried to fix it myself until I got to Ch. 7 and saw the solution there. I suggest adding a reassuring statement: “Fill out the form, and click “Submit”. You’ll see a list of your new videos, just as you should. (The user_id isn’t populated yet - we’ll take care of that in the next chapter.)"

It is not clear if we are to delete all the content in video_controller_test or just add in content.

This is the first page send_resp is mentioned. It isn’t explained at all how it works.

Earlier in the book (pg 117) you use foreign_key_constraint(:category_id). On pg 159 this has changed to assoc_constraint(:category) with no explanation. pg 159 seems to be the first place this is mentioned.

It is not clear where to put the implementation code beginning with:

defimpl Phoenix.Param, for: Rumbl.Video do

Near the end of this page it says “all helpers accept it as argument.” Seems like there is a word missing between “as” and “argument”. Perhaps the word is “an”?

While mentioned on 162 that the file path is lib/rumbl/permalink.ex, I think it should be shown in the code listing too.

It is not clear which file the code shown near the bottom of this page should go. A little bit of thinking tells me that it goes in the video model, but it would be nice for this to be made clear in the text.

new auth in auth plug

where did put_current_user come from? (I see it in the example code online, but I’ve lost it along the way)

The “Chris says…” box on this page talks about ES6, but this was first mentioned a few pages ago; specifically Page 155. I suggest moving this “Chris says…” box up to that first mention of ES6.

It is not clear here why the call and login functions from Rumbl.Auth are mentioned. There are no differences between these functions to what I already have. You might be able to get away without mentioning them here.

“so add the has_many relationship to both your User and Video schema blocks in web/models/annotation.ex and web/models/user.ex, like this:”

This is pointing to the wrong files. It should be web/models/user.ex, and web/models/video.ex.

I can’t find a reference to put_current_user/2 before page 131 while it was actually added in page 182 as part of the “Socket Authentication”

This confuses the reader and causes the enhanced test suggested on page 131 for “Preparing for Logged In Users” to fail.

def id(socket), do: “users_socket:#{socket.assigns.user_id}”

^ Above line should really be:
def id(socket), do: “users_socket:#{socket.assigns.current_user.id}”

Otherwise you get “ErlangError” with reason “%KeyError” because there is no “user_id” on socket.

“Next, we need to wire up our new relationships to our User and Video models. Both users and videos will have annotations, so add the has_many relationship to both your User and Video schema blocks in web/models/annotation.ex and web/models/user.ex, like this:”

^ Above paragraph refers to web/models/annotation.ex, but should be web/models/video.ex instead.

screencast.com/t/dCUV1TzDZ

In “join” function, I think you will have to cast the video_id to integer before assigning it on “socket”, like -> {video_id, _} = Integer.parse(video_id)

Otherwise, in “handle_in” function, Ecto seems to throw an error when checking changesets i.e. Rumbl.Annotation.changeset(params), if video_id is a string.

“Next, we did something new. We composed a response by rendering an annotation.html view for every annotation in our list.”

^ I think it should be “annotation.json”, not “annotation.html”?

Not an error,
Please specify the defimpl code fragment should be in the lib directory file,
I accidentally put in the the controller and it did not give any error and neither worked.

At the bottom of the page, I think you meant “router” instead of “browser”:

connection
|> endpoint
|> browser (should this be router?)
|> HelloController.world
|> HelloView.render(

For the “user_controller.ex” listing, I think two “aliases” are missing:
defmodule Rumbl.UserController do
use Rumbl.Web, :controller
alias Rumbl.Repo
alias Rumbl.User

def index(conn, _params) do
users = Repo.all(User)
render conn, “index.html”, users: users
end
end

In the last sentence of the page, it is said “each user will record and play back videos that must be saved and served quickly […].”

I believe that what was meant was “play back comments”

assert {:password, {“should be at least %{count} characters”, count: 6}}
- in changeset.errors

Should be

assert {:password, {“should be at least %{count} character(s)”, count: 6}}
- in changeset.errors

Rumbl.InfoSys.compute(“what is elixir?”) doesn’t work because the response doesn’t contain a pod with a title attribute of “Result”.

When re-enabling ecto, no mention is made of uncommenting the supervisor start line in rumbl.ex that we commented out on page 41. I’m pretty sure this is required to continue with the exercise.

“rumbrella/apps/info_sys/mix.exe” should be reumbrella/apps/infosys/mix.exs

On step 6 <- should not be html escaped.

When you mention code upgrading and introspection using an observer, it might be good to link to places where we could read more about these.

“Erlang’s OTP has been around from the beginning,”

From the beginning of what?

The book doesn’t lead you to make the change to the `setup` in conn_case.ex that provides `conn` to the tests. As a result, attempting to run the newly-added video_controller_test.exs code results in an initially confusing

(FunctionClauseError) no function clause matching in Rumbl.VideoControllerTest.“test requires user authentication on all actions”/1

because there is no arity of 1 without the setup addition.

The code on the site at /titles/phoenix/code/testing_mvc/listings/rumbl/test/support/conn_case.change1.ex includes that change but it isn’t mentioned specifically in the book.

There doesn’t appear to be a reason for the `import Ecto.Query, only: [from: 2]` line to exist within wolfram.ex.

The pod that I get back does not have a title attribute with “Result” it is:

Perhaps look for the one where “primary” is true?

The path is shown as rumbrella/apps/info_sys/mix.exe, but that should be rumbrella/apps/info_sys/mix.exs

It looks like you’re missing the step to copy the configuration for wolfram over from Rumbl to InfoSys.

The left-arrow for Step #6 (“Change the function”) is escaped to <

I think this config should be config :info_sys, :wolfram, :app_id.

When running the tests for the auth plug I get the following error:

1) test authenticate_user halts when no current_user exists (Rumbl.AuthTest)
test/controllers/auth_test.exs:6
(KeyError) key :current_user not found in: %{}
stacktrace:
(rumbl) web/controllers/auth.ex:51: Rumbl.Auth.authenticate_user/2
test/controllers/auth_test.exs:7

This is because on page 97 we defined authenticate_user like this:

def authenticate_user(conn, _opts) do
if conn.assigns.current_user do
[…]
else
[…]
end
end

Changing it to the below fixes the issue

def authenticate_user(conn, _opts) do
if conn.assigns[:current_user] do
[…]
else
[…]
end
end

In the 3rd and 4th paragraphs the line numbers don’t match with the actual assigns mentioned. It should be on line 6 and 18 rather than 5 and 17.

The authentication test example is missing a test for the `new` action. I suggest adding the following to the list:

```
get(conn, video_path(conn, :new))
```

The following excerpt from page 127, the testing chapter, is misleading:

> Also notice the setup block. It sets up database transactions and places a base `conn` into our test metadata. This is where the `%{conn: conn}` map comes from in our `page_controller_test`.

Except that no base `conn` is being set in the `setup` block, as shown below:

``` setup tags do
unless tags[:async] do
Ecto.Adapters.SQL.restart_test_transaction(Rumbl.Repo, [])
end

:ok
end
```

This page says we’ll see how `errors_on` comes into play with changeset tests, but we don’t actually use that function in any of the examples in this revision of the text.

If you forgot to restart the server and/or did the iex examples in a new shell you will end up getting the error “protocol Ecto.Queryable not implemented for Rumbl.User,…” as the lib is not hotreloaded after our change on page 41. See also orums.pragprog.com/forums/393/topics/13800
Maybe a notice in the book would help.

This might just be me, but I had to cast `socket.assigns.video_id` to an integer before Ecto would accept it as an id in the build function.

It seems that when introducing the Auth plug tests, the reported exception

“”"

(ArgumentError) flash not fetched, call fetch_flash/2
“”"

on page 136 doesn’t show up initially and instead we get the following error:

“”"

(KeyError) key :current_user not found in: %{}
“”"

Tracing this back to page 97 in the `authenticate_user` function, the “if” condition seems to expect the :current_user key to exist. Testing for the existence of the :current_user key fixes this issue:

“”"
if conn.assigns[:current_user] do
“”"

Third paragraph from the top “Our val function on the hand” -> “Our val function on the other hand”

We’ve hardcoded the score to 95 and yet the example shows it returning a score of 90.

```
iex> Rumbl.InfoSys.compute(“what is elixir?”) iex> flush()
[{:results, #Reference<0.0.1.9227>,
[%Rumbl.InfoSys.Result{backend: “wolfram”, score: 90,
text: “1 | noun | a sweet flavored liquid (usually containing …”,
url: nil}]}]
```

The explanation code below also mentions that it should be 95.

“A query like ”what is elixir?" indeed reports a list of Rumbl.InfoSys.Result{}’s, with our hard-coded score of 95."

“Next, we’ll use the new function in the index and show actions” is ambiguous. It could mean either the `new` function in the controller or the newly created function `user_videos`.

The validation error output code needs to be changed for the message from
<%= message %>
to
<%= translate_error message %>
otherwise an exception is thrown for ecto validation error messages that are tuples (e.g. length mismatch).

In the release notes for Beta 6.0 the first link is in reference to “Chapter 12: Observer and Umbrellas” but is actually a link to Chapter 8.

With Phoenix 1.1, <%= message %> doesn’t work when displaying error messages.
Chris pointed me to the right way which was <%= translate_error(message) %>.

Middle of the page, in the paragraph “You have seen the get macro before”:
`UsersController` should be `UserController`.

The “This is changing” box only says which assert type to use with phoenix 1.1, but not how the tests should look like, which would be extremely helpful. I’m using phoenix 1.1.1 and the assert_raise tests are green; not sure if this is intended or not.

The test “login with a valid email and pass” actually calls Auth.login_by_username_and_pass, the test description should be called “login with a valid username and password”.

As the #79185 by Joseph DiVita report, but his solution was not working for me. What I ddi was to change the getCurrentTime on player.js to

getCurrentTime(){ return this.player.getCurrentTime ? Math.floor(this.player.getCurrentTime() * 1000) : 0},

This is similar to #78964. The code that is responsible for testing the password is hashed is in explicitly put in the side effect free tests file. However, hashing a password is not a pure function. You can validate this by having an assertion on the result of the password hash and running the tests twice. This hash will be different.

In Phoenix 1.1.1, the Rumbl.Repo app is launched as a supervisor, and not a worker. I believe this also changed PDF pg 323 where the Rumbl.Repo is expected to log that it is restarting, after the Counter worker dies under the :one_for_all strategy. It doesn’t show up in the logs.

2nd paragraph of `Nesting Templates`:
`Then, whenever we build tables or listings or users…` should be `…of users…`

Bottom of the page:
“Now, it’s time to create a real database-backed Ecto repository. When you type the following commands…”
Since there is a single command to type, it should be “the following command”

The code snippet of web/web.ex and the sentence after that seems to be outdated, it references Ecto.Model, which is deprecated. The current code uses Ecto.Schema, and it has one more import as well.

First code snippet:

1. Start the Ecto repository
2. worker(Rumbl.Repo, []),

In the generated code this line is different:

1. supervisor(Rumbl.Repo, []),

The same issue is present on page 55.

@inner in web/templates/layout/app.html.eex has been changed in Phoenix 1.1.0 in favor of a more explicit call to render. This might be worth a footnote (or a link to the Pheonix changelog for v1.1.0 from 2015-12-16) although the Phoenix error message points you to exactly this change. :)

In the section ‘Using Umbrellas’
in the text below the
“mix​​ ​​new​​ ​​rumbrella​​ ​​—umbrella” command
‘config.exs’ is written as
‘config.exe’

The following code snippet:

```
<%= for {attr, message} <- f.errors do %>

```

leads to an exception: `protocol Phoenix.HTML.Safe not implemented for {“should be at least %{count} character(s)”, [count: 1]}`

(I’m running Elixir 1.2.0, Phoenix 1.1.2, and Ecto 1.1.1; I’m guessing it’s a version compatibility issue.)

I was able to fix it by replacing `message` with `translate_error(message)`.

In the middle of the page: Change “IDS” to “IDs”

In the test code block, line 5, the error message should have parens around the s in characters. like: `“should be at least %{count} character(s)”`

In Chapter 8, under the section “Testing Logged Out Users,” the tests do not pass…

(ArgumentError) cannot retrieve association :videos for empty list
stacktrace:
(ecto) lib/ecto.ex:494: Ecto.assoc/2
(rumbl) web/controllers/video_controller.ex:59: Rumbl.VideoController.edit/3
(rumbl) web/controllers/video_controller.ex:1: Rumbl.VideoController.action/2
(rumbl) web/controllers/video_controller.ex:1: Rumbl.VideoController.phoenix_controller_pipeline/2
(rumbl) lib/phoenix/router.ex:261: Rumbl.Router.dispatch/2
(rumbl) web/router.ex:1: Rumbl.Router.do_call/2
(rumbl) lib/rumbl/endpoint.ex:1: Rumbl.Endpoint.phoenix_pipeline/1
(rumbl) lib/phoenix/endpoint/render_errors.ex:34: Rumbl.Endpoint.call/2
(phoenix) lib/phoenix/test/conn_test.ex:194: Phoenix.ConnTest.dispatch/5
test/controllers/video_controller_test.exs:48

I initially thought this was an oversight/error with Phoenix after upgrading from 1.0.4 to 1.1.2 prior to the testing chapter. Before the chapter on testing, I was also using the previous version of the book B6.

When hashing existing users’ passwords via iex, user chrismccord comes with a too-short password: phx.

So when we execute

iex>
for u <- Repo.all(User) do
Repo.update!(User.registration_changeset(u, %{password: u.password_hash}))
end

registration_changeset rightly complains.

Changing chrismccords password to phxphx for instance will fix that.

Btw: good idea to add this password_hash snippet there!

The sentence reads: “Once Ecto fetched the association for us, and we can then reference the user.videos as needed.” I think there is a stray “and” in the middle there, and possibly also a comma. If I’m reading it right I think you might have wanted: “Once Ecto fetched the association for us we can then reference the user.videos as needed.”

It looks like the images for the mobi version aren’t showing up.

“Let’s look at that listen function on line 7” should be “.. line 20”.

`assert username: {“should be at most %{count} character(s)”, [count: 20]} in errors_on(%User{}, attrs)` doesn’t test the production code. The keyword list is interpreted as the sole argument of the `assert` macro. This line of code is the equivalent of `assert(true) in errors_on(%User{}, attrs)`, or really just `assert(true)` since the return value isn’t used. errors_on/2 isn’t part of the assertion, so it passes no matter what the function returns. (False positives like this are a good argument for a test-first approach.)

The line should read: `assert {:username, {“should be at most %{count} character(s)”, [count: 20]}} in errors_on(%User{}, attrs)`.

“To start our module, we import the functions we’ll need. SweetXml will help us
parse the XML we need, Ecto.Query will let us fetch the credentials we’ll need,
and Result has the struct for the results we will use.”

We did not Import Ecto.Query in wolfram.ex and there is no Ecto.Query in the code?

The wofram API got smarter in the meantime and delivers an answer for “a query” so that the statement that we get empty list back is not true anymore:
```
iex(1)> Rumbl.InfoSys.compute(“a query”)
[{#PID<0.362.0>, #Reference<0.0.1.993>}]
iex(2)> flush
{:results, #Reference<0.0.1.993>,
[%Rumbl.InfoSys.Result{backend: “wolfram”, score: 95,
text: “1 | noun | an instance of questioning\
2 | verb | pose a question”,
url: nil}]}
:ok
```

Halfway down page 104, the book states that Ecto.build_assoc will return an Ecto.Query, when in fact it returns a struct/Model object. If you try to pass that return into Repo.all, as instructed to by the book, you’ll get “(Protocol.UndefinedError) protocol Ecto.Queryable not implemented” error.

From the book: "Other times we just want to fetch the videos associated to a user, without storing them in the user struct, like this:
iex> query = Ecto.build_assoc(user, :videos)
#Ecto.Query<…>
iex> Repo.all(query)
[%Rumbl.Video{…}]

build_assoc is another convenient function from Ecto that returns an Ecto.Query with all videos scoped to the given user, or to a list of users. We convert this query into data by calling Repo.all. "

I believe the book should be referring to Ecto.assoc, not Ecto.build_assoc.

The earlier references to build_assoc at the top of page 104 seem fine.

You write “On line 10, we call into our Information System,…” the code snipped above that comment has no line numbering and the call is made in line 2.

There is a reference to Rumbl.repo, but this is in the Hello World example, I suspect it should be Hello.repo.

Update instructions to pull down phoenix 1.1.

mix archive.install github.com/phoenixframework/phoenix/releases/download/v1.1.2/phoenix_new-1.1.2.ez

or any other tempalte engine. Should be template

We’ll tie a URL to a a function

for our users controller —> user’s

start a interactive Elixir —> start an interactive Elixir session

“:transient - the child is restarted only if it terminates abnormally, with an exit reason than :normal…” - probably should say “other than :normal…”

tempalte

Repo is shown started as a worker, where later versions of Ecto specify starting it as a supervisor: /elixir-lang/ecto/blob/master/lib/ecto.ex#L52-L66

Ecto.Query is in the summary of the code example, but is not actually present in the code.

The sentence “and then update your repository by running migrations:” is colored in green.

Running mix ecto.migrate triggers a compilation of the new generated files, which fails with the following error:

Compiled web/models/video.ex

Compilation error on file web/controllers/video_controller.ex

(CompileError) web/controllers/video_controller.ex:25: undefined function video_path/2
(stdlib) lists.erl:1337: :lists.foreach/2
(stdlib) erl_eval.erl:669: :erl_eval.do_apply/6
(elixir) lib/kernel/parallel_compiler.ex:100: anonymous fn/4 in Kernel.ParallelCompiler.spawn_compilers/8

That’s why we need the view in first place.
-> “the”

The second `delete` statement should be

```
iex> Repo.delete changeset
{:error, changeset}
```

All code examples in the mobi version on a kindle 3g are unreadable (one letter wide boxes) See: www.dropbox.com/s/gin3xl1rz9qysuw/2016-01-21%2021.14.21.jpg?dl=0

In Chapter 10 there’s a technical error in the video_channel.ex code in all downloads and references.

In it the following section is provided:

{:ok, resp, assign(socket, :video_id, video_id)}

This SHOULD be:

{:ok, resp, assign(socket, :video_id, video.id)}

If you deploy this code as provided, when you add persistence later, your inserts will fail with the following error.

[error] GenServer #PID<0.366.0> terminating

(Ecto.ChangeError) value `“6”` for `Rumbl.Annotation.video_id` in `insert` does not match type :id
(ecto) lib/ecto/query/planner.ex:33: anonymous fn/6 in Ecto.Query.Planner.fields/4
(stdlib) lists.erl:1262: :lists.foldl/3
(ecto) lib/ecto/query/planner.ex:21: Ecto.Query.Planner.fields/4
(ecto) lib/ecto/repo/schema.ex:449: Ecto.Repo.Schema.dump_changes/5
(ecto) lib/ecto/repo/schema.ex:77: anonymous fn/11 in Ecto.Repo.Schema.do_insert/4
(ecto) lib/ecto/repo/schema.ex:477: anonymous fn/3 in Ecto.Repo.Schema.wrap_in_transaction/9
(ecto) lib/ecto/pool.ex:292: Ecto.Pool.with_rollback/3
(ecto) lib/ecto/adapters/sql.ex:582: Ecto.Adapters.SQL.transaction/8
(ecto) lib/ecto/pool.ex:244: Ecto.Pool.outer_transaction/6
(ecto) lib/ecto/adapters/sql.ex:551: Ecto.Adapters.SQL.transaction/3
(rumbl) web/channels/video_channel.ex:27: Rumbl.VideoChannel.handle_in/3
(phoenix) lib/phoenix/channel/server.ex:229: Phoenix.Channel.Server.handle_info/2
(stdlib) gen_server.erl:615: :gen_server.try_dispatch/4
(stdlib) gen_server.erl:681: :gen_server.handle_msg/5
(stdlib) proc_lib.erl:240: :proc_lib.init_p_do_apply/3
Last message: Phoenix.Socket.Message{event: “new_annotation”, payload:{“at” => 0, “body” => “a”}, ref: “166”, topic: “videos:6”}
State: Phoenix.Socket{assigns:{user_id: 6, video_id: “6”}, channel: Rumbl.VideoChannel, channel_pid: #PID<0.366.0>, endpoint: Rumbl.Endpoint, handler: Rumbl.UserSocket, id: “users_socket:6”, joined: true, pubsub_server: Rumbl.PubSub, ref: nil, serializer: Phoenix.Transports.WebSocketSerializer, topic: “videos:6”, transport: Phoenix.Transports.WebSocket, transport_name: :websocket, transport_pid: #PID<0.354.0>}

“Our new migration uses an alter_table function, one …”; should this be “alter macro” instead?

Similar to Steven Nunez’s input, prior to publishing, update pages to show latest software versions:

$ elixir -v
Elixir 1.2.1

$ mix local.hex

• creating ~/.mix/archives/hex-0.10.1.ez

And on page 22:

$ psql —version
psql (PostgreSQL) 9.5.0

$ node —version
v5.5.0

Typo in following paragraph:

If you receive database errors when running mix ecto.create, double check your Rumbl.Repo username and password values in config/dev.exs and match your system settings where necessary.

We create the Project with phoenix.new hello.
The Application name should be Hello and not Rumbl.

logging —> login (at least that’s why I think we wanna do at Facebook :) )

“Imagine that your boss lays down the requirement of logging into your application through Facebook.”

It says “This unique reference is just a byte that’s guaranteed to be globally unique”. Aren’t references 8 bytes?

At the top of page 106 (the function to look up all the videos for the user it is stated “We used the build_assoc function, also imported from Ecto,” when the code example simply says “assoc” - so either the code example or the description are wrong (or I don’t get it) :)

defp user_videos(user) do
assoc(user, :videos)
end

The screenshot of the error is incorrect… it refers to the Rumbl application, rather than the Hello throwaway app.

In defp user_videos(user), you are using assoc. But in the text describing that function (right below it) you are mentioning build_assoc.. Which one is correct?

You say, “Relational databases deal with relationships between tables.”

This seems to imply that the database is relational because some tables relate to others (through foreign keys). But that is not why it is relational. The tables themselves are the relations. The “relation” refers to the relation of the rows of a table to each other, not to rows in other tables. A relational database with only one table (relation) is still relational. See E. F. Codd’s original paper (sorry, won’t let me hyperlink).

I understand that it’s not a book on databases, but hopefully you don’t want to misinform readers even on peripheral material.

Response: Thanks for your comment. I think there’s a tension between writing in a more academic style and writing for a more general audience. I don’t think this sentence misinforms the readers in any meaningful way. Saying more at this point would bog the book down. I believe this paragraph captures the essence of what a relational database is without going into the original papers with relations, selections, projections, keys, candidate keys, etc. What’s important here is that where we specify relationships, we specify them through primary and foreign keys in data rather than hard wiring relationships in the schema, and I think we communicate this well enough.

The password test says they test that a password is at least 6 chars long, but the test is conducted with a 2 character password. I know this book is not directly about testing but I think it’d be important to test with values surrounding the edge case, e.g. 5 for a failure and 6 for a success :)

The screenshot shows an error message that includes a bulleted list, but in my code I get an error message below the field and a generic error up top.

and we’ll talk you through each layer of Phoenix

should be:

….. walk you …..

I was getting an error inserting the annotations into the database.

Changing this line:
|> build_assoc(:annotations, video_id: socket.assigns.video_id)

to this:
|> build_assoc(:annotations, video_id: String.to_integer(socket.assigns.video_id))

fixed the problem.

The resources macro `resources “/users”, UserController, only: [:index, :show, :new, :create]` on page 65 does not produce the routes shown on page 66 when the reader runs `$ mix phoenix.routes`

Page 66 show the following:
page_path GET
user_path GET
user_path GET
user_path GET
user_path GET
user_path POST
user_path PATCH /users/:id
PUT /users/:id
user_path DELETE /users/:id
/ Rumbl.PageController :index
/users Rumbl.UserController :index
/users/:id/edit Rumbl.UserController :edit
/users/new
/users/:id
/users
Rumbl.UserController :new
Rumbl.UserController :show
Rumbl.UserController :create
Rumbl.UserController :update
Rumbl.UserController :update
Rumbl.UserController :delete

But, ` [:index, :show, :new, :create]` would actually produce:
user_path GET /users Rumbl.UserController :index
user_path GET /users/new Rumbl.UserController :new
user_path GET /users/:id Rumbl.UserController :show
user_path POST /users Rumbl.UserController :create
page_path GET / Rumbl.PageController :index

“Once we have molded the data to the shape our business model requirements”, I guess this should be “… to the shape OF our business model req.”.

The command for installing Phoenix is outdated and no longer working.
v1.0.3/phoenix_new-1.0.3.ez

npm also shows a warning about a missing Licence field in the deps.
npm WARN EPACKAGEJSON hello No license field.

It would be great to mention that the default user and pass for the Postgres install should be “postgres” because the windows installer doesn’t provide a default password.

Command was given as:
iex>
for u <- Repo.all(User) do
Repo.update!(User.registration_changeset(u, %{password: u.password_hash}))
end
—-
This erred out until I first added: alias Rumbl.Repo

In this page you say “Now let’s try it out:” but (as far as I can see) you don’t explicitly provide the URL to hit using the web browser. It is obvious to me but others without experience in frameworks such as rails may struggle!

The book says to enter this into iex:

iex>
for u <- Repo.all(User) do
Repo.update!(User.registration_changeset(u, %{password: u.password_hash}))
end

However, in a new iex session there is no alias set for Rumbl.Repo and it fails with “module Repo is not available”

I suggest adding ‘alias Rumbl.Repo’ as the first command for the iex session.

“We will explore such strategies later on this chapter when
we talk about constraints.”

Should change to “later on in this chapter” for clarity. (addition of the word “in”)

The screenshot of the controller not found error appears to be for the Rumbl app created in the next chapter instead of the Hello app being discussed.

It’s minor but I though I would bring it up just in case.

Great book so far!

In the Processes and Channels section, “with the simple guaranties” should read “with the simple guarantees”.

In the section entitled “Fast”, the first sentence of the second paragraph reads “Let’s compare Phoenix with some of the frameworks that are.” This is not a complete sentence. The intent could perhaps be better conveyed as follows: “Let’s compare Phoenix with some of the other popular frameworks out there.”

On page 102:

iex> query = Ecto.build_assoc(user, :videos)

#Ecto.Query<…>

iex> Repo.all(query)

[%Rumbl.Video{…}]

The function call to Ecto.build_assoc/2 returns a %Rumbl.Video{…}, not the #Ecto.Query<…> you need to run Repo.all(query). The call needs to be to Ecto.assoc/2 (iex> query = Ecto.build_assoc(user, :videos)) to get the correct #Ecto.Query<…> returned.

Page 120 in Chapter 7 … This query:

iex(19)> Repo.all from u in User,
…(19)> join: v in assoc(u, :videos),
…(19)> join: c in assoc(v, :categories),
…(19)> on: c.name == “Comedy”,
…(19)> select: {u, v}

Should be:

iex(19)> Repo.all from u in User,
…(19)> join: v in assoc(u, :videos),
…(19)> join: c in assoc(v, :category),
…(19)> where: c.name == “Comedy”,
…(19)> select: {u, v}

In the ES6 template at the top of page 186, ${at} is technically user supplied input, too. It is sent from the client to the server (pg 185, top), then broadcast unfiltered (pg 186, bottom) via the socket. This is a cross-site scripting vulnerability. I would recommend using ${this.esc(at)} in this case, too.

Is:
“we briefly changed lib/rumbl/repo.ex to comment out the default Ecto repository”
Should be:
“we briefly changed lib/rumbl/repo.ex to remove the default Ecto repository”
The repository was removed on PDF page 44:
“let’s replace the default repository implementation in lib/rumbl/repo.ex with this shell” and a snippet without the “use Ecto.Repo, otp_app: :rumbl” line.

Is:
“but we don’t need all of that security.”
Should be:
“but we don’t need all of that security here.”

Link to Bypass.
Is: “hxxp://hexdocs.pm/ecto/Ecto.Migration.html”
Should be: “hxxps://hex.pm/packages/bypass” (no docs on hexdocs.pm)

Add wrap up, as promised page before. :)

In following section, build_assoc should be assoc:

Preload is great for bundling data together. Other times we just want to fetch the videos associated to a user, without storing them in the user struct, like this:

iex> query = Ecto.build_assoc(user, :videos) #Ecto.Query<…>

iex> Repo.all(query) [%Rumbl.Video{…}]

build_assoc is another convenient function …

“We used the build_assoc function, also imported from Ecto …”

should be

“We used the assoc function, also imported from Ecto …”

in:

join: v in assoc(u, :videos),
join: c in assoc(v, :categories)

:categories should have been :category

and on: should should be where:

“after choosing the remove category” should be “after choosing the removed category”

The test method uses an old syntax:

test “GET /” do
conn = get conn(), “/”
assert html_response(conn, 200) =~ “Welcome to Phoenix!”
end

should be

test “GET /”, %{conn: conn} do
conn = get conn, “/”
assert html_response(conn, 200) =~ “Welcome to Phoenix!”
end

In the code, there a multiple instances of the typo “usernmae” and “nmae” instead of "name.

In

if conn.assigns.current_user do
conn
else
…

current_user should be referenced as conn.assigns[:current_user]. Otherwise the first test on page 142

test “authenticate_user halts when no current_user exists”, %{conn: conn} do
conn = Auth.authenticate_user(conn, [])
assert conn.halted
end

will fail with a KeyError instead of the expected error (due to fetch_flash etc):

1) test authenticate_user halts when no current_user exists (Rumbl.AuthTest)
test/controllers/auth_test.exs:5
(KeyError) key :current_user not found in: %{}
stacktrace:
(rumbl) web/controllers/auth.ex:56: Rumbl.Auth.authenticate_user/2
test/controllers/auth_test.exs:6

Add the follow snippet to the bottom

should be

Add the following snippet to the bottom

“application pushes messages to to a client,”

repeated the word ‘to’

In ‘Jose Says’ section, “Wolphram” -> “Wolfram”

“and then our application boundaries like controllers and channels will convert them into atoms keys which we will rely on everywhere else inside Phoenix” - atom should be singular: ‘into atom keys’

“None of them come with the simple guaranties” guaranties should be guarantees

It sould be “Wolfram” not “Wolphram” in “Jose says …. Wolphram API” ;-)

Apologies. I was not logged in when I posted my previous erratum, so I can’t edit it. I was on the wrong terminal tab. The tests do pass.

That said, to get the tests to run on the book’s code, I did need to add the config/dev.exs file to get it to build (I added config/prod.exs, too, but don’t know if it would have built without it).

Also, I had to fix a line of code in /rumbrella/apps/rumbl/web/channels/video_channel.ex:13 to change `_params` to `params`. Once I’d made those changes, it compiled and the tests passed.

Again, sorry for the confusion.

Damn. You’d better check that test. I have to retract my retraction. The errata should be editable if one is logged in!

I will not attempt to stop confusing myself. Good luck with the book.

I was able to get all tests to run by using 1%2B+1 instead of 1%20%201:

So this:

defmodule InfoSys.Test.HTTPClient do
wolfram_xml File.read!("test/fixtures/wolfram.xml") def request(url) do url = to_string(url) cond do String.contains?(url, "1%20+%201") -> {:ok, {[], [], wolfram_xml}}
true -> {:ok, {[], [], “”}}
end
end
end

ExUnit.start()

becomes this:

defmodule InfoSys.Test.HTTPClient do
@wolfram_xml File.read!(“test/fixtures/wolfram.xml”)
def request(url) do
url = to_string(url)

cond do
String.contains?(url, “1+%2B+1”) -> {:ok, {[], [], @wolfram_xml}}
true -> {:ok, {[], [], “”}}
end
end
end

ExUnit.start()

I guess the URL encoder works differently. Hope this helps.

iex> alias Rumbl.User
iex> user = %{usernmae: “jose”, password: “elixir”}

username spelt incorrectly: usernmae

OK, too hasty! Noticed this was deliberate!

There is an issue with the .mobi version where the included images are not mapped to the correct locations in the text. That is, images which are displayed are usually not relevant to the surrounding text. A sanity pass over the PDF version indicates that images are mapped correctly in that format.

in the text it says the new config file should be rumbrella/apps/info_sys/config/text.exs whereas it must be rumbrella/apps/info_sys/config/test.exs

After doing phoenix.new to create a new application, you immediately list the 3 instructions:

$ cd hello
$ mix ecto.create
$ mix phoenix.server

Then a paragraph later you say:

At the bottom of the mix phoenix.new output, you can see a few sentences that tell you what to do next. We’ll skip the instructions related to ecto since our application won’t use a database for now. We will want to start Phoenix, though. Change into the hello directory and run the Phoenix web server through mix, which will start looking for requests on port 4000, like this:
$ cd hello
hello $ mix phoenix.server

The : tells Phoenix to create a parameter called

should be

That : tells Phoenix to create a parameter called

I’m using iBooks so the page number is likely incorrect; however, “we hand it of to the repository” should be “we hand it off to the repository” (right after adding alphabetical function to the Category model).

The code listed in this reference (otp/listings/rumbl/web/channels/video_channel.change1.ex) has the join function as

def join(“videos:” <> video_id, _params, socket) do

which causes a compilation error, it should be

def join(“videos:” <> video_id, params, socket) do

instead

The first paragraph on page 54 is confusing.

It says: “Rather than make you slog through a bunch of CSS and HTML, we’ll let you pull down the source code at your leisure.” Does pull down mean download or remove? If it means download, where’s the download link?

Also, please make this statement clearer: “Just replace the layout you find at web/templates/layout/app.html.eex with the one you can find there.” Where is there?

Mistake in username

user = %{usernmae: “jose”, password: “elixir”}

In the sentence: “To learn more about existing HTML helpers, visit the Phoenix.HMTL1 documenta- tion.”

Letters are transposed in the reference to the Phoenix.HTML documentation.

“Ecto is a wrapper that’s primarily intended for relational databases, allowing developers to read and persist data to underlying storages, like PostgreSQL”

The user of “storages” here seems strange. Maybe “storage systems”?

In the included server output for a channel having been joined, the ID on the JOIN line is not the same as that on the reply line.

Diff of suggested change:

[info] JOIN videos:2 to Rumbl.VideoChannel
Transport: Phoenix.Transports.WebSocket
Parameters: %{}
- [info] Replied videos:4 :ok
+ [info] Replied videos:2 :ok

Not using PDF.

Chapter 9, Creating Slugs : watching_videos/listings/rumbl/web/models/video.change1.ex
Unicode title like “猫 cat” causes error in slugify() function. Instead of this line:
|> String.replace(~r/[^\\w-]+/, “-”)

Use a unicode regex:
|> String.replace(~r/[^\\w-]+/u, “-”)

In the Wrapping Up section of Chapter 7, the following statement is wrong:

We used two forms of queries, a map-based syntax and a pipe-based syntax.

Instead it should say a keyword list-based syntax instead of map, since the Ecto query API takes a keyword list (important since it allows repeating keys!).

Not using PDF. iBooks portrait page 487/552.

Chapter 12, Using Umbrellas

info_sys/lib/info_sys.ex is modified to use InfoSys.Supervisor.start_link().
This modification is destroyed by later copying rumbl/lib/rumbl/info_sys.ex to info_sys/lib/info_sys.ex. The file should be copied and then the supervisor should be added.

1. Add the following after copying the file.
   use Application

def start(_type, _args) do
InfoSys.Supervisor.start_link()
end

Regarding the code for “Handling Disconnects”, VideoChannel should send the `last_seen_id` upon join instead of relying on video.js on calculating the `last_seen_id` based on the annotations returned. Because upon reconnect from a disconnection, and there are no fresh annotations sent, the calculated `last_seen_id` on video.js will be nil. And the next reconnection will cause duplicate annotations which we’re working to avoid.

I needed to add to the presented fixture to pass the accompanying test on [printed] Page 254. I needed to add a containing (minimally):