Merge branch 'implement-protocols'

Author: keathley

lib/circular_buffer.ex

@@ -9,17 +9,21 @@ defmodule CircularBuffer do
   ```
   """
 
+  defstruct [:q, :max_size, :count]
+
+  alias __MODULE__, as: CB
+
   @doc """
   Creates a new circular buffer with a given size.
   """
   def new(size) when is_integer(size) and size > 0 do
-    %{q: :queue.new(), max_size: size, count: 0}
+    %CB{q: :queue.new(), max_size: size, count: 0}
   end
 
   @doc """
   Inserts a new item into the next location of the circular buffer
   """
-  def insert(cb, item) do
+  def insert(%CB{}=cb, item) do
     if cb.count < cb.max_size do
       %{cb | q: :queue.cons(item, cb.q), count: cb.count + 1}
     else
@@ -28,15 +32,15 @@ defmodule CircularBuffer do
         |> :queue.drop_r
         |> (fn q -> :queue.cons(item, q) end).()
 
-      %{cb | q: new_q}
+      %CB{cb | q: new_q}
     end
   end
 
   @doc """
   Converts a circular buffer to a list. The list is ordered from oldest to newest
   elements based on their insertion order.
   """
-  def to_list(cb) do
+  def to_list(%CB{}=cb) do
     cb.q
     |> :queue.reverse
     |> :queue.to_list
@@ -45,7 +49,7 @@ defmodule CircularBuffer do
   @doc """
   Returns the newest element in the buffer
   """
-  def newest(cb) do
+  def newest(%CB{}=cb) do
     case :queue.peek(cb.q) do
       {_, val} -> val
       :empty -> nil
@@ -55,10 +59,55 @@ defmodule CircularBuffer do
   @doc """
   Returns the oldest element in the buffer
   """
-  def oldest(cb) do
+  def oldest(%CB{}=cb) do
     case :queue.peek_r(cb.q) do
       {_, val} -> val
       :empty -> nil
     end
   end
+
+  @doc """
+  Checks the buffer to see if its empty
+  """
+  def empty?(%CB{}=cb) do
+    :queue.is_empty(cb.q)
+  end
+
+  defimpl Enumerable do
+    def count(cb) do
+      {:ok, cb.count}
+    end
+
+    def member?(cb, element) do
+      {:ok, :queue.member(element, cb.q)}
+    end
+
+    def reduce(cb, acc, fun) do
+      Enumerable.List.reduce(CB.to_list(cb), acc, fun)
+    end
+
+    def slice(cb) do
+      {:ok, cb.count, &Enumerable.List.slice(CB.to_list(cb), &1, &2)}
+    end
+  end
+
+  defimpl Collectable do
+    def into(original) do
+      collector_fn = fn
+        cb, {:cont, elem} -> CB.insert(cb, elem)
+        cb, :done -> cb
+        _cb, :halt -> :ok
+      end
+
+      {original, collector_fn}
+    end
+  end
+
+  defimpl Inspect do
+    import Inspect.Algebra
+
+    def inspect(cb, opts) do
+      concat(["#CircularBuffer<", to_doc(CB.to_list(cb), opts), ">"])
+    end
+  end
 end

test/circular_buffer_test.exs

@@ -26,6 +26,37 @@ defmodule CircularBufferTest do
     end
   end
 
+  property "can tell the current number of elements" do
+    forall {size, is} <- {pos_integer(), list(integer())} do
+      buffer = Enum.reduce(is, CB.new(size), fn i, cb -> CB.insert(cb, i) end)
+      Enum.count(buffer) == min(size, length(is))
+    end
+  end
+
+  property "member?/1" do
+    items = such_that({a, b} <- {pos_integer(), pos_integer()}, when: a != b)
+    forall {a, b} <- items do
+      cb = CB.new(1) |> CB.insert(a)
+      !Enum.member?(cb, b) && Enum.member?(cb, a)
+    end
+  end
+
+  property "implements Enumerable" do
+    forall is <- list(integer()) do
+      buffer = Enum.reduce(is, CB.new(length(is)+1), fn i, cb -> CB.insert(cb, i) end)
+
+      Enum.reduce(buffer, 0, fn acc, i -> acc + i end) == Enum.sum(is)
+    end
+  end
+
+  property "can be collected" do
+    forall {size, is} <- size_and_list() do
+      buffer = Enum.reduce(is, CB.new(size), fn i, cb -> CB.insert(cb, i) end)
+
+      Enum.into(is, CB.new(size)) == buffer
+    end
+  end
+
   property "the number of elements never exceeds the size of the buffer" do
     forall {size, is} <- size_and_list() do
       buffer = Enum.reduce(is, CB.new(size), fn i, cb -> CB.insert(cb, i) end)
@@ -76,6 +107,11 @@ defmodule CircularBufferTest do
     end
   end
 
+  test "can be inspected" do
+    str = inspect(Enum.into([1,2,3,4], CB.new(4)))
+    assert str == "#CircularBuffer<[1, 2, 3, 4]>"
+  end
+
   def size_and_list do
     let size <- pos_integer() do
       let is <- ints(size*2, []) do