refactor: Mix format

Author: zookzook

.formatter.exs

@@ -1,4 +1,17 @@
 # Used by "mix format"
 [
-  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"],
+  line_length: 250,
+  locals_without_parens: [
+    # MongoDB
+    after_load: :*,
+    before_dump: :*,
+    attribute: :*,
+    collection: :*,
+    embeds_many: :*,
+    # Test
+    ## Assertions
+    assert_receive_event: :*,
+    refute_receive_event: :*
+  ]
 ]

lib/bson.ex

@@ -3,24 +3,21 @@ defmodule BSON do
   Functions for encoding and decoding BSON documents.
   """
 
-  @type t :: document | String.t | atom | number | boolean | BSON.Binary.t |
-             BSON.ObjectId.t | BSON.Regex.t |
-             BSON.JavaScript.t | BSON.Timestamp.t | BSON.LongNumber.t | [t]
-  @type document :: %{atom => BSON.t} | %{String.t => BSON.t} |
-                    [{atom, BSON.t}] | [{String.t, BSON.t}]
+  @type t :: document | String.t() | atom | number | boolean | BSON.Binary.t() | BSON.ObjectId.t() | BSON.Regex.t() | BSON.JavaScript.t() | BSON.Timestamp.t() | BSON.LongNumber.t() | [t]
+  @type document :: %{atom => BSON.t()} | %{String.t() => BSON.t()} | [{atom, BSON.t()}] | [{String.t(), BSON.t()}]
 
   @doc """
   Encode a BSON document to `iodata`.
   """
   @spec encode(document) :: iodata
   def encode(map) when is_map(map) do
     case Map.has_key?(map, :__struct__) do
-       true  -> BSON.Encoder.encode(Map.to_list(map))
-       false -> BSON.Encoder.encode(map)
+      true -> BSON.Encoder.encode(Map.to_list(map))
+      false -> BSON.Encoder.encode(map)
     end
   end
 
-  def encode([{_, _}|_] = keyword) do
+  def encode([{_, _} | _] = keyword) do
     BSON.Encoder.encode(keyword)
   end
 
@@ -30,6 +27,6 @@ defmodule BSON do
   @spec decode(iodata) :: document
   def decode(iodata) do
     IO.iodata_to_binary(iodata)
-    |> BSON.Decoder.decode
+    |> BSON.Decoder.decode()
   end
 end

lib/bson/decimal128.ex

@@ -1,41 +1,39 @@
 defmodule BSON.Decimal128 do
-
   @moduledoc """
     see https://en.wikipedia.org/wiki/Decimal128_floating-point_format
   """
 
   use Bitwise
 
   @signed_bit_mask 1 <<< 63
-  @combination_mask 0x1f
+  @combination_mask 0x1F
   @combintation_infinity 30
   @combintation_nan 31
-  @exponent_mask 0x3fff
+  @exponent_mask 0x3FFF
   @exponent_bias 6176
   @max_exponent 6111
   @min_exponent -6176
-  @s_nan_mask  0x1 <<< 57
-  @significand_mask ((0x1 <<< 49)-1)
-  @low_mask 0xffffffffffffffff
+  @s_nan_mask 0x1 <<< 57
+  @significand_mask (0x1 <<< 49) - 1
+  @low_mask 0xFFFFFFFFFFFFFFFF
 
   def decode(<<_::little-64, high::little-64>> = bits) do
-    is_negative = (high &&& @signed_bit_mask) == (@signed_bit_mask)
-    combination = (high >>> 58 &&& @combination_mask)
+    is_negative = (high &&& @signed_bit_mask) == @signed_bit_mask
+    combination = high >>> 58 &&& @combination_mask
     two_highest_bits_set = combination >>> 3 == 3
     is_infinity = two_highest_bits_set && combination == @combintation_infinity
-    is_nan = case {(two_highest_bits_set && combination) == @combintation_nan, (high &&& @s_nan_mask) == @s_nan_mask} do
-      {true, true}  -> :sNan
-      {true, false} -> :qNan
-                  _ -> false
-    end
+
+    is_nan =
+      case {(two_highest_bits_set && combination) == @combintation_nan, (high &&& @s_nan_mask) == @s_nan_mask} do
+        {true, true} -> :sNan
+        {true, false} -> :qNan
+        _ -> false
+      end
 
     exponent = exponent(high, two_highest_bits_set)
 
     value(
-      %{is_negative: is_negative,
-        is_infinity: is_infinity,
-        is_nan: is_nan,
-        two_highest_bits_set: two_highest_bits_set},
+      %{is_negative: is_negative, is_infinity: is_infinity, is_nan: is_nan, two_highest_bits_set: two_highest_bits_set},
       coef(bits),
       exponent
     )
@@ -48,73 +46,88 @@ defmodule BSON.Decimal128 do
   """
   def encode(%Decimal{sign: -1, coef: :inf}) do
     low = 0
-    high = 0x3e <<< 58
+    high = 0x3E <<< 58
     <<low::little-64, high::little-64>>
   end
+
   def encode(%Decimal{coef: :inf}) do
     low = 0
-    high = 0x1e <<< 58
+    high = 0x1E <<< 58
     <<low::little-64, high::little-64>>
   end
+
   def encode(%Decimal{coef: :qNaN}) do
     low = 0
-    high = 0x1f <<< 58
+    high = 0x1F <<< 58
     <<low::little-64, high::little-64>>
   end
+
   def encode(%Decimal{coef: :sNaN}) do
     low = 0
-    high = 0x3f <<< 57
+    high = 0x3F <<< 57
     <<low::little-64, high::little-64>>
   end
+
   def encode(%Decimal{sign: sign, coef: significand, exp: exponent}) when exponent >= @min_exponent and exponent <= @max_exponent do
     biasedExponent = exponent + @exponent_bias
-    low  = significand &&& @low_mask
-    high = (significand >>> 64) &&& @significand_mask ## mask max significand
+    low = significand &&& @low_mask
+    ## mask max significand
+    high = significand >>> 64 &&& @significand_mask
     high = bor(high, biasedExponent <<< 49)
-    high = case sign do
-      1 -> high
-      _ -> bor(high, @signed_bit_mask)
-    end
+
+    high =
+      case sign do
+        1 -> high
+        _ -> bor(high, @signed_bit_mask)
+      end
 
     <<low::little-64, high::little-64>>
   end
+
   def encode(%Decimal{exp: exponent}) do
     message = "Exponent is out of range for Decimal128 encoding, #{exponent}"
     raise ArgumentError, message
   end
 
   defp exponent(high, _two_highest_bits_set = true) do
-    biased_exponent = (high >>> 47) &&& @exponent_mask
+    biased_exponent = high >>> 47 &&& @exponent_mask
     biased_exponent - @exponent_bias
   end
+
   defp exponent(high, _two_highest_bits_not_set) do
-    biased_exponent = (high >>> 49) &&& @exponent_mask
+    biased_exponent = high >>> 49 &&& @exponent_mask
     biased_exponent - @exponent_bias
   end
 
   defp value(%{is_negative: true, is_infinity: true}, _, _) do
     %Decimal{sign: -1, coef: :inf}
   end
+
   defp value(%{is_negative: false, is_infinity: true}, _, _) do
     %Decimal{coef: :inf}
   end
+
   defp value(%{is_nan: :qNan}, _, _) do
     %Decimal{coef: :qNaN}
   end
+
   defp value(%{is_nan: :sNan}, _, _) do
     %Decimal{coef: :sNaN}
   end
+
   defp value(%{two_highest_bits_set: true}, _, _) do
     %Decimal{sign: 0, coef: 0, exp: 0}
   end
+
   defp value(%{is_negative: true}, coef, exponent) do
     %Decimal{sign: -1, coef: coef, exp: exponent}
   end
+
   defp value(_, coef, exponent) do
     %Decimal{coef: coef, exp: exponent}
   end
 
   defp coef(<<low::little-64, high::little-64>>) do
-    bor((high &&& 0x1ffffffffffff) <<< 64, low)
+    bor((high &&& 0x1FFFFFFFFFFFF) <<< 64, low)
   end
-end
+end

lib/bson/decoder.ex

@@ -10,9 +10,10 @@ defmodule BSON.Decoder do
 
   def documents(binary), do: documents(binary, [])
   def documents("", acc), do: Enum.reverse(acc)
+
   def documents(binary, acc) do
     {doc, rest} = document(binary)
-    documents(rest, [doc|acc])
+    documents(rest, [doc | acc])
   end
 
   defp type(@type_float, <<0, 0, 0, 0, 0, 0, 240::little-integer-size(8), 127::little-integer-size(8), rest::binary>>) do
@@ -141,11 +142,11 @@ defmodule BSON.Decoder do
     {key, rest} = cstring(rest)
     {value, rest} = type(type, rest)
 
-    doc_fields(rest, [{key, value}|acc])
+    doc_fields(rest, [{key, value} | acc])
   end
 
   defp doc_fields("", acc) do
-    acc |> Enum.reverse |> Enum.into(%{})
+    acc |> Enum.reverse() |> Enum.into(%{})
   end
 
   defp list(<<size::int32, rest::binary>>) do
@@ -160,11 +161,11 @@ defmodule BSON.Decoder do
     {^ix_string, rest} = cstring(rest)
     {value, rest} = type(type, rest)
 
-    list_elems(rest, ix + 1, [value|acc])
+    list_elems(rest, ix + 1, [value | acc])
   end
 
   defp list_elems("", _ix, acc) do
-    acc |> Enum.reverse
+    acc |> Enum.reverse()
   end
 
   defp cstring(binary) do

lib/bson/encoder.ex

@@ -115,7 +115,9 @@ defmodule BSON.Encoder do
 
           {value, type} =
             case Mongo.Encoder.impl_for(value) do
-              nil -> {encode(value), type(value)}
+              nil ->
+                {encode(value), type(value)}
+
               _ ->
                 new_value = value |> Mongo.Encoder.encode()
                 {encode(new_value), type(new_value)}