Fix warnings, linting and add specs

Author: matehat

.editorconfig

@@ -0,0 +1,8 @@
+[*.ex]
+trim_trailing_whitespace = true
+indent_size = 2
+indent_style = space
+
+[cqex.code-workspace,*.json]
+indent_size = 2
+indent_style = space

lib/cqex.ex

@@ -1,7 +1,44 @@
 defmodule CQEx do
+  @moduledoc false
+
   require Record
 
-  Record.defrecord :cql_query, [
+  @type consistency_values ::
+          :all
+          | :any
+          | :each_quorum
+          | :local_one
+          | :local_quorum
+          | :one
+          | :quorum
+          | :three
+          | :two
+          | 0
+          | 1
+          | 2
+          | 3
+          | 4
+          | 5
+          | 6
+          | 7
+          | 10
+
+  @type serial_consistency_values ::
+          :local_serial
+          | :serial
+          | :undefined
+          | 8
+          | 9
+
+  @type batch_mode_values ::
+          :counter
+          | :logged
+          | :unlogged
+          | 0
+          | 1
+          | 2
+
+  Record.defrecord(:cql_query,
     statement: <<>>,
     values: [],
     reusable: nil,
@@ -11,28 +48,40 @@ defmodule CQEx do
     consistency: :one,
     serial_consistency: nil,
     value_encode_handler: nil
-  ]
+  )
+
+  @type cql_query ::
+          {:cql_query, iodata(), Keyword.t() | Map.t(), boolean | :undefined, boolean, integer,
+           :undefined | binary, consistency_values(), serial_consistency_values(),
+           :undefined | fun}
 
-  Record.defrecord :cql_query_batch, [
+  Record.defrecord(:cql_query_batch,
     consistency: :one,
     mode: :logged,
     queries: []
-  ]
+  )
 
-  Record.defrecord :cql_schema_changed, [
+  @type cql_query_batch ::
+          {:cql_query_batch, consistency_values(), batch_mode_values(), [cql_query]}
+
+  Record.defrecord(:cql_schema_changed, [
     :change_type,
     :target,
     :keyspace,
     :name,
     :args
-  ]
+  ])
+
+  @type cql_schema_changed :: {:cql_schema_change, any, any, any, any, any}
 
-  Record.defrecord :cql_result, [
+  Record.defrecord(:cql_result,
     columns: [],
     dataset: [],
     cql_query: nil,
     client: nil
-  ]
+  )
+
+  @type cql_result :: {:cql_result, any, any, any, any}
 
   defmodule Error do
     defexception [:message, :stack]
@@ -42,26 +91,25 @@ defmodule CQEx do
 
   defmacro consistency do
     %{
-      any:            0,
-      one:            1,
-      two:            2,
-      three:          3,
-      quorum:         4,
-      all:            5,
-      local_quorum:   6,
-      each_quorum:    7,
-      serial:         8,
-      local_serial:   9,
-      local_one:      10
+      any: 0,
+      one: 1,
+      two: 2,
+      three: 3,
+      quorum: 4,
+      all: 5,
+      local_quorum: 6,
+      each_quorum: 7,
+      serial: 8,
+      local_serial: 9,
+      local_one: 10
     }
   end
 
   defmacro batch_mode do
     %{
-      logged:   0,
+      logged: 0,
       unlogged: 1,
-      counter:  2
+      counter: 2
     }
   end
 end
-

lib/cqex/client.ex

@@ -1,37 +1,68 @@
 defmodule CQEx.Client do
-  import CQEx.Helpers
+  @moduledoc false
+
   import CQEx, only: :macros
 
-  defdelegate new,             to: :cqerl, as: :get_client
-  defdelegate new(a),          to: :cqerl, as: :get_client
-  defdelegate new(a, b),       to: :cqerl, as: :get_client
+  defdelegate new, to: :cqerl, as: :get_client
+  defdelegate new(a), to: :cqerl, as: :get_client
+  defdelegate new(a, b), to: :cqerl, as: :get_client
+
+  @type client_value ::
+          :cqerl.client()
+          | CQEx.Result.t()
+          | CQEx.cql_result()
+          | CQEx.Result.SchemaChanged.t()
+          | CQEx.Result.Empty.t()
 
+  @spec close(client_value) :: :ok
   def close(client) do
     client
     |> CQEx.Client.get()
     |> :cqerl.close_client()
   end
 
-  defbang new
-  defbang new(a)
-  defbang new(a, b)
+  @spec new! :: :cqerl.client()
+  def new!() do
+    case new() do
+      {:ok, client} ->
+        client
+    end
+  end
+
+  @spec new!(:cqerl.inet()) :: :cqerl.client()
+  def new!(a) do
+    case new(a) do
+      {:ok, client} ->
+        client
+    end
+  end
+
+  @spec new!(:cqerl.inet(), Keyword.t()) :: :cqerl.client()
+  def new!(a, b) do
+    case new(a, b) do
+      {:ok, client} ->
+        client
+    end
+  end
 
-  def get(client={p, r}) when is_pid(p) and is_reference(r) do
+  @spec get(client_value) :: :cqerl.client()
+  def get(client = {p, r}) when is_pid(p) and is_reference(r) do
     client
   end
+
   def get(%CQEx.Result{record: cql_result(client: client)}) do
     client
   end
+
   def get(cql_result(client: client)) do
     client
   end
+
   def get(%CQEx.Result.SchemaChanged{client: client}) do
     client
   end
+
   def get(%CQEx.Result.Empty{client: client}) do
     client
   end
-  def get(_) do
-    nil
-  end
 end

lib/cqex/cluster.ex

@@ -1,5 +1,7 @@
 defmodule CQEx.Cluster do
-  defdelegate add(a),       to: :cqerl_cluster, as: :add_nodes
-  defdelegate add(a, b),    to: :cqerl_cluster, as: :add_nodes
+  @moduledoc false
+
+  defdelegate add(a), to: :cqerl_cluster, as: :add_nodes
+  defdelegate add(a, b), to: :cqerl_cluster, as: :add_nodes
   defdelegate add(a, b, c), to: :cqerl_cluster, as: :add_nodes
 end