Enable credo spec check

And add all the needed specs for credo to pass

Author: jjcarstens

.credo.exs

@@ -6,7 +6,7 @@
       checks: [
         {Credo.Check.Readability.LargeNumbers, only_greater_than: 86400},
         {Credo.Check.Readability.ParenthesesOnZeroArityDefs, parens: true},
-        # {Credo.Check.Readability.Specs, tags: []},
+        {Credo.Check.Readability.Specs, tags: []},
 
         # Report TODO comments, but don't fail the check
         {Credo.Check.Design.TagTODO, exit_status: 0}

lib/jeff/bus.ex

@@ -11,37 +11,47 @@ defmodule Jeff.Bus do
             conn: nil,
             controlling_process: nil
 
+  @type t :: %__MODULE__{}
+
+  @spec new(keyword()) :: t()
   def new(_opts \\ []) do
     %__MODULE__{}
   end
 
+  @spec add_device(t(), keyword()) :: t()
   def add_device(bus, opts \\ []) do
     device = Device.new(opts)
     _bus = register(bus, device.address, device)
   end
 
+  @spec remove_device(t(), byte()) :: t()
   def remove_device(%{poll: poll, registry: registry} = bus, address) do
     registry = Map.delete(registry, address)
     poll = Enum.reject(poll, &(&1 == address))
     %{bus | poll: poll, registry: registry}
   end
 
+  @spec get_device(t(), byte()) :: Device.t()
   def get_device(%{registry: registry}, address) do
     Map.fetch!(registry, address)
   end
 
+  @spec registered?(t(), byte()) :: boolean()
   def registered?(%{registry: registry}, address) do
     is_map_key(registry, address)
   end
 
+  @spec put_device(t(), Device.t()) :: t()
   def put_device(%{cursor: cursor} = bus, device) do
     register(bus, cursor, device)
   end
 
+  @spec put_device(t(), byte(), Device.t()) :: t()
   def put_device(bus, address, device) do
     register(bus, address, device)
   end
 
+  @spec current_device(%__MODULE__{cursor: byte(), registry: map()}) :: Device.t()
   def current_device(%{cursor: cursor} = bus) do
     get_device(bus, cursor)
   end
@@ -55,6 +65,7 @@ defmodule Jeff.Bus do
     _bus = register(bus, cursor, device)
   end
 
+  @spec tick(t()) :: t()
   def tick(%{cursor: nil, poll: []} = bus) do
     poll = addresses(bus)
     %{bus | poll: poll}
@@ -93,11 +104,13 @@ defmodule Jeff.Bus do
     register(bus, device)
   end
 
+  @spec send_command(t(), Jeff.Command.t()) :: t()
   def send_command(bus, %{address: address} = command) do
     device = get_device(bus, address) |> Device.send_command(command)
-    _bus = register(bus, address, device)
+    register(bus, address, device)
   end
 
+  @spec receive_reply(t(), Jeff.Reply.t()) :: t()
   def receive_reply(bus, reply) do
     %{bus | reply: reply}
   end

lib/jeff/command.ex

@@ -36,7 +36,7 @@ defmodule Jeff.Command do
           address: byte(),
           code: byte(),
           data: binary(),
-          name: atom(),
+          name: name(),
           caller: reference()
         }
 
@@ -83,6 +83,10 @@ defmodule Jeff.Command do
   }
   @codes Map.new(@names, fn {code, name} -> {name, code} end)
 
+  @type name :: unquote(Enum.reduce(Map.values(@names), &{:|, [], [&1, &2]}))
+  @type code :: unquote(Enum.reduce(Map.keys(@names), &{:|, [], [&1, &2]}))
+
+  @spec new(Jeff.osdp_address(), name(), keyword()) :: t()
   def new(address, name, params \\ []) do
     {caller, params} = Keyword.pop(params, :caller)
 
@@ -116,6 +120,8 @@ defmodule Jeff.Command do
   defp encode(ACURXSIZE, size: size), do: <<size::size(16)-little>>
   defp encode(ABORT, _params), do: nil
 
+  @spec code(name()) :: code()
   def code(name), do: @codes[name]
+  @spec name(code()) :: name()
   def name(code), do: @names[code]
 end

lib/jeff/command/challenge_data.ex

@@ -1,5 +1,6 @@
 defmodule Jeff.Command.ChallengeData do
   @moduledoc false
 
+  @spec encode(server_rnd: binary()) :: binary()
   def encode(server_rnd: rnd), do: rnd
 end

lib/jeff/command/encryption_key.ex

@@ -5,10 +5,14 @@ defmodule Jeff.Command.EncryptionKey do
 
   defstruct [:key, type: @secure_channel_base_key]
 
+  @type t :: %__MODULE__{key: binary(), type: 0x01}
+
+  @spec new(key: binary()) :: t()
   def new(key: key) do
     %__MODULE__{key: key}
   end
 
+  @spec encode(key: binary()) :: <<_::24>>
   def encode(params) do
     %{key: key, type: type} = new(params)
     <<type, key_length(key)>> <> key

lib/jeff/command/encryption_server.ex

@@ -1,4 +1,5 @@
 defmodule Jeff.Command.EncryptionServer do
   @moduledoc false
+  @spec encode(cryptogram: binary()) :: binary()
   def encode(cryptogram: cryptogram), do: cryptogram
 end

lib/jeff/command/output_settings.ex

@@ -17,6 +17,7 @@ defmodule Jeff.Command.OutputSettings do
   | 0x06 | Set the temporary state to OFF, resume permanent state on timeout |
   """
 
+  @spec encode(output: pos_integer(), code: pos_integer(), timer: pos_integer()) :: <<_::32>>
   def encode(output: output, code: code, timer: timer) do
     <<output, code, timer::size(2)-unit(8)-little>>
   end

lib/jeff/command/text_settings.ex

@@ -10,11 +10,13 @@ defmodule Jeff.Command.TextSettings do
             length: 0x00,
             content: ""
 
+  @spec new(keyword()) :: %__MODULE__{}
   def new(params \\ []) do
     settings = struct(__MODULE__, params)
     %{settings | length: byte_size(settings.content)}
   end
 
+  @spec encode(keyword()) :: <<_::48>>
   def encode(params) do
     settings = new(params)
 

lib/jeff/control_info.ex

@@ -1,10 +1,12 @@
 defmodule Jeff.ControlInfo do
   @moduledoc false
 
+  @spec encode(Jeff.Message.t()) :: byte()
   def encode(%{sequence: seq, check_scheme: cs, security?: sec}) do
     encode(seq, cs, sec)
   end
 
+  @spec encode(byte(), Jeff.Device.check_scheme(), boolean()) :: byte()
   def encode(sequence, check_scheme, security?) do
     check_scheme =
       case check_scheme do
@@ -28,6 +30,7 @@ defmodule Jeff.ControlInfo do
     byte
   end
 
+  @spec decode(byte() | integer()) :: {integer(), Jeff.Device.check_scheme(), boolean()}
   def decode(<<byte>>), do: decode(byte)
 
   def decode(byte) when is_integer(byte) do

lib/jeff/device.ex

@@ -28,6 +28,7 @@ defmodule Jeff.Device do
 
   @offline_threshold_ms 8000
 
+  @spec new(keyword()) :: t()
   def new(params \\ []) do
     secure_channel = SecureChannel.new()
 
@@ -36,6 +37,7 @@ defmodule Jeff.Device do
     |> Map.put(:secure_channel, secure_channel)
   end
 
+  @spec inc_sequence(t()) :: t()
   def inc_sequence(%{sequence: n} = device) do
     %{device | sequence: next_sequence(n)}
   end
@@ -53,17 +55,20 @@ defmodule Jeff.Device do
 
   defp next_sequence(n), do: rem(n, 3) + 1
 
+  @spec online?(t()) :: boolean()
   def online?(%{last_valid_reply: nil}), do: false
 
   def online?(%{last_valid_reply: last_valid_reply}) do
     last_valid_reply - System.monotonic_time(:millisecond) < @offline_threshold_ms
   end
 
+  @spec send_command(t(), Command.t()) :: t()
   def send_command(%{commands: commands} = device, command) do
     commands = :queue.in(command, commands)
     %{device | commands: commands}
   end
 
+  @spec next_command(t()) :: {t(), Command.t()}
   def next_command(%{sequence: 0, address: address} = device) do
     command = Command.new(address, POLL)
     {device, command}