1.0.2 - Added better error handling

Author: nshafer

.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

.gitignore

@@ -50,6 +50,7 @@ fabric.properties
 
 # Editor-based Rest Client
 .idea/httpRequests
+
 ### Elixir template
 /_build
 /cover
@@ -61,3 +62,5 @@ erl_crash.dump
 *.beam
 /config/*.secret.exs
 
+# VS Code
+.elixir_ls

.idea/encodings.xml

@@ -10,7 +10,7 @@ Add plug_assign to your list of dependencies in `mix.exs`:
 
 ```elixir
     def deps do
-      [{:plug_assign, "~> 1.0.0"}]
+      [{:plug_assign, "~> 1.0.2"}]
     end
 ```
 
@@ -20,32 +20,104 @@ Fetch and install the dependencies
     $ mix deps.get
 ```
 
-Define assigns as part of your plug stack
+## Basic Usage
+
+Define assigns as part of any plug stack.
 
 ```elixir
     plug Plug.Assign, foo: "bar", bar: true, baz: 42
 ```
 
-Or Set variables for templates to use in a Phoenix Pipeline
+This will set the given key/value pairs in the `assigns` map of the Plug.Conn, for you to use
+in controllers, views, and templates.
+
+One way to use this is to set variables so you can quickly determine where you are in your app.
 
 ```elixir
+    pipeline :browser do
+      ...
+      plug Plug.Assign, admin: false
+    end
+
     pipeline :admin do
       plug Plug.Assign, admin: true
     end
 ```
 
-Or directly in a Phoenix Controller
+And then use that in a template, such as your layout.
+
+```html
+  <%= if @admin do %>
+    <p>Hello, Administrator</p>
+  <% end %>
+```
+
+Since you can use this anywhere you can use a plug, you can also use it in a Phoenix Controller.
+
+```elixir
+    defmodule HelloWeb.Admin.PostController do
+      use HelloWeb, :controller
+
+      plug Plug.Assign, section: :posts
+      ...
+    end
+```
+
+```html
+  <h1><%= @section %></h1>
+```
+
+If you want to only assign a variable for certain actions, you can use the `plug ... when` format,
+but be careful that bare keyword lists are only accepted as the last arguments of a macro call,
+which is no longer the case with a `when` clause, so add the square brackets `[]` around your
+assigns, or use a map instead.
 
 ```elixir
-    defmodule Blog.Admin.PostController do
-      use Blog.Web, :Controller
+    defmodule HelloWeb.Admin.PostController do
+      use HelloWeb, :controller
 
-      plug Plug.Assign, subsection: :posts
-      plug Plug.Assign, %{read_request: true} when action in [:index, :show]
+      plug Plug.Assign, [read_request: true] when action in [:index, :show]
+      plug Plug.Assign, %{write_request: true} when action in [:edit, :new, :create, :update, :delete]
       ...
     end
 ```
 
+## Accessing in templates
+
+If you're using an assign in a template that may not have been set, you can't use the
+`@variable` format without throwing an error, so use one of the following techniques instead:
+
+- Access shortcut: `assigns[:admin]` - Returns `nil` if not set.
+- Map.get/2: `Map.get(assigns, :admin)` - Returns `nil` if not set.
+- Map.get/3: `Map.get(assigns, :admin, false) - `Returns `false` if not set.
+
+```html
+  <%= if assigns[:admin] do %>
+    <p>Hello, Administrator</p>
+  <% end %>
+```
+
+## Assignment formats
+
+Assigns can be either a keyword list
+
+```elixir
+    plug Plug.Assign, foo: "bar", bar: true, baz: 42
+```
+
+Or a map, as long as the keys are atoms.
+
+```elixir
+    plug Plug.Assign, %{foo: "foo", bar: true, baz: 42}
+    plug Plug.Assign, %{:foo => "foo", :bar => true, :baz => 42}
+```
+
+Any attempt to pass it anything else will throw an exception.
+
+```bash
+** (ArgumentError) Invalid assignment, must be a keyword list or map with all keys as atoms
+```
+
 ## Generate documentation
 
 ```bash

.idea/inspectionProfiles/Project_Default.xml

@@ -4,7 +4,7 @@ defmodule Plug.Assign do
 
   ## Example
 
-      plug Plug.Assign, foo: "bar", bar: true, baz: 42
+      plug Plug.Assign, foo: "foo", bar: true, baz: 42
 
   ## Example of use in a Phoenix Pipeline
 
@@ -24,14 +24,30 @@ defmodule Plug.Assign do
   """
 
   @behaviour Plug
+  @invalid_type "Invalid assignment, must be a keyword list or map with all keys as atoms."
 
   import Plug.Conn
+  require Logger
 
-	def init(assigns), do: assigns
+  def init(assigns) when is_list(assigns) or is_map(assigns), do: assigns
+  def init(_), do: raise(ArgumentError, message: @invalid_type)
 
-	def call(conn, assigns) do
-		Enum.reduce assigns, conn, fn {k, v}, conn ->
-			assign(conn, k, v)
-		end
-	end
+  def call(conn, assigns) do
+    Enum.reduce(assigns, conn, fn
+      {k, v}, conn when is_atom(k) ->
+        assign(conn, k, v)
+
+      {k, _}, conn ->
+        Logger.warn("[Plug.Assign] Invalid key: #{inspect(k)}. Keys must be an atom.")
+        conn
+
+      var, conn ->
+        Logger.warn(
+          "[Plug.Assign] Invalid assign: #{inspect(var)}. Assigns must be {:key, value}. " <>
+            "Use a keyword list or a map with all keys as atoms."
+        )
+
+        conn
+    end)
+  end
 end