Modern era update

.formatter.exs

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

README.md

@@ -9,7 +9,7 @@ by adding `expline` to your list of dependencies in `mix.exs`:
 
 ```elixir
 def deps do
-  [{:expline, "~> 0.1.0"}]
+  [{:expline, "~> 0.2"}]
 end
 ```
 

lib/expline.ex

@@ -13,19 +13,25 @@ defmodule Expline do
   building, read the `Expline.Spline` module documentation.
   """
 
-  @typep state() :: Expline.Spline.t
+  @typep state() :: Expline.Spline.t()
 
   @doc """
   Builds a spline from the provided list of points and holds the state in a
   process without links (outside of a supervision tree).
 
   See `start_link/2` for more information.
   """
-  @spec start(list(Expline.Spline.point()), GenServer.options()) :: {:ok, pid()}
-                                                                  | {:error, {:already_started, pid()}}
-                                                                  | {:error, Expline.Spline.creation_error()}
+  @spec start(list(Expline.Spline.point()), {:graceful_shutdown, boolean()} | GenServer.options()) ::
+          {:ok, pid()}
+          | {:error, {:already_started, pid()}}
+          | {:error, Expline.Spline.creation_error()}
   def start(points, opts \\ []) do
-    GenServer.start(__MODULE__, [points], opts)
+    {graceful_shutdown, opts} = Keyword.pop(opts, :graceful_shutdown, false)
+
+    case GenServer.start(__MODULE__, {graceful_shutdown, [points]}, opts) do
+      {:error, {:shutdown, reason}} -> {:error, reason}
+      other -> other
+    end
   end
 
   @doc """
@@ -36,21 +42,34 @@ defmodule Expline do
 
   ## Options and more information
 
+  - `graceful_shutdown` when `true`, gracefully shuts down `GenServer`
+    without a crash report, default: `false`
+
   See `GenServer.start_link/3` for more information.
   """
-  @spec start_link(list(Expline.Spline.point()), GenServer.options()) :: {:ok, pid()}
-                                                                       | {:error, {:already_started, pid()}}
-                                                                       | {:error, Expline.Spline.creation_error()}
+  @spec start_link(
+          list(Expline.Spline.point()),
+          {:graceful_shutdown, boolean()} | GenServer.options()
+        ) ::
+          {:ok, pid()}
+          | {:error, {:already_started, pid()}}
+          | {:error, Expline.Spline.creation_error()}
   def start_link(points, opts \\ []) do
-    GenServer.start_link(__MODULE__, [points], opts)
+    {graceful_shutdown, opts} = Keyword.pop(opts, :graceful_shutdown, false)
+
+    case GenServer.start_link(__MODULE__, {graceful_shutdown, [points]}, opts) do
+      {:error, {:shutdown, reason}} -> {:error, reason}
+      other -> other
+    end
   end
 
-  def init([list_of_points]) do
+  def init({graceful_shutdown, [list_of_points]}) do
     case Expline.Spline.from_points(list_of_points) do
       {:ok, spline} ->
         {:ok, spline}
+
       {:error, reason} ->
-        {:stop, reason}
+        {:stop, if(graceful_shutdown, do: {:shutdown, reason}, else: reason)}
     end
   end
 
@@ -61,17 +80,20 @@ defmodule Expline do
   `t:Expline.Spline.interpolation_error/0` will be returned.
   """
 
-  @spec interpolate(GenServer.server(), float(), timeout()) :: {:ok, Expline.Spline.point()}
-                                                             | {:error, Expline.Spline.interpolation_error()}
+  @spec interpolate(GenServer.server(), float(), timeout()) ::
+          {:ok, Expline.Spline.point()}
+          | {:error, Expline.Spline.interpolation_error()}
   def interpolate(server, x, timeout \\ 5000) when is_float(x) do
     GenServer.call(server, {:interpolate, x}, timeout)
   end
 
-  @spec handle_call({:interpolate, Expline.Spline.dependent_value()}, GenServer.from(), state()) :: {:reply, {:ok, Expline.Spline.point()}, state()}
+  @spec handle_call({:interpolate, Expline.Spline.dependent_value()}, GenServer.from(), state()) ::
+          {:reply, {:ok, Expline.Spline.point()}, state()}
   def handle_call({:interpolate, x}, _from, spline) do
     case Expline.Spline.interpolate(spline, x) do
       {:ok, y} ->
         {:reply, {:ok, {x, y}}, spline}
+
       {:error, reason} ->
         {:reply, {:error, reason}, spline}
     end