Take :exclude_date into consideration when :count exists

lib/recurring_events.ex

@@ -132,8 +132,8 @@ defmodule RecurringEvents do
     |> by_set_position(rules)
     |> drop_before(date)
     |> prepend(date)
-    |> drop_after(rules)
     |> drop_exclude(rules)
+    |> drop_after(rules)
   end
 
   defp drop_exclude(dates, %{exclude_date: excludes}) do

lib/recurring_events/frequency.ex

@@ -65,6 +65,9 @@ defmodule RecurringEvents.Frequency do
   defp get_step(%{interval: interval}), do: interval
   defp get_step(%{}), do: 1
 
-  defp get_count(%{count: count}), do: count
+  defp add_count(%{exclude_date: dates}), do: dates |> Enum.count()
+  defp add_count(%{}), do: 0
+
+  defp get_count(%{count: count} = rules), do: count + add_count(rules)
   defp get_count(%{}), do: :infinity
 end

lib/recurring_events/monthly.ex

@@ -61,6 +61,9 @@ defmodule RecurringEvents.Monthly do
   defp get_step(%{interval: interval}), do: interval
   defp get_step(%{}), do: 1
 
-  defp get_count(%{count: count}), do: count
+  defp add_count(%{exclude_date: dates}), do: dates |> Enum.count()
+  defp add_count(%{}), do: 0
+
+  defp get_count(%{count: count} = rules), do: count + add_count(rules)
   defp get_count(%{}), do: :infinity
 end

lib/recurring_events/weekly.ex

@@ -81,6 +81,9 @@ defmodule RecurringEvents.Weekly do
   defp get_step(%{interval: interval}), do: interval
   defp get_step(%{}), do: 1
 
-  defp get_count(%{count: count}), do: count
+  defp add_count(%{exclude_date: dates}), do: dates |> Enum.count()
+  defp add_count(%{}), do: 0
+
+  defp get_count(%{count: count} = rules), do: count + add_count(rules)
   defp get_count(%{}), do: :infinity
 end

lib/recurring_events/yearly.ex

@@ -52,6 +52,9 @@ defmodule RecurringEvents.Yearly do
   defp get_step(%{interval: interval}), do: interval
   defp get_step(%{}), do: 1
 
-  defp get_count(%{count: count}), do: count
+  defp add_count(%{exclude_date: dates}), do: dates |> Enum.count()
+  defp add_count(%{}), do: 0
+
+  defp get_count(%{count: count} = rules), do: count + add_count(rules)
   defp get_count(%{}), do: :infinity
 end

test/ical_rrul_test.exs

@@ -1270,6 +1270,68 @@ defmodule RR.IcalRrulTest do
     assert expect == result |> Enum.take(expect |> Enum.count())
   end
 
+  describe "count shoud be resolbed after exclude dates" do
+    test "when freq: :daily" do
+      result =
+        RR.take(
+          %{
+            date_start: ~D[2018-01-01],
+            exclude_date: ~D[2018-01-01],
+            freq: :daily,
+            count: 1
+          },
+          99
+        )
+
+      assert [~D[2018-01-02]] == result
+    end
+
+    test "when freq: :weekly" do
+      result =
+        RR.take(
+          %{
+            date_start: ~D[2018-01-01],
+            exclude_date: ~D[2018-01-01],
+            freq: :weekly,
+            count: 1
+          },
+          99
+        )
+
+      assert [~D[2018-01-08]] == result
+    end
+
+    test "when freq: :monthly" do
+      result =
+        RR.take(
+          %{
+            date_start: ~D[2018-01-01],
+            exclude_date: ~D[2018-01-01],
+            freq: :monthly,
+            count: 1
+          },
+          99
+        )
+
+      assert [~D[2018-02-01]] == result
+    end
+
+    test "when freq: :yearly" do
+      result =
+        RR.take(
+          %{
+            date_start: ~D[2018-01-01],
+            exclude_date: ~D[2018-01-01],
+            freq: :yearly,
+            count: 1
+          },
+          99
+        )
+
+      assert [~D[2019-01-01]] == result
+    end
+  end
+
   def listify({a, b, c}), do: {listify(a), listify(b), listify(c)}
   def listify({a, b}), do: {listify(a), listify(b)}
   def listify(a) when is_integer(a), do: [a]