Rename Various variables to cron_interval

lib/crontab/cron_expression/composer.ex

@@ -20,8 +20,8 @@ defmodule Crontab.CronExpression.Composer do
 
   """
   @spec compose(CronExpression.t) :: binary
-  def compose(cron_interval = %CronExpression{}) do
-    cron_interval
+  def compose(cron_expression = %CronExpression{}) do
+    cron_expression
       |> CronExpression.to_condition_list
       |> compose_interval
       |> Enum.join(" ")

lib/crontab/cron_expression/parser.ex

@@ -75,15 +75,15 @@ defmodule Crontab.CronExpression.Parser do
 
   """
   @spec parse(binary, boolean) :: result
-  def parse(cron_format, extended \\ false)
+  def parse(cron_expression, extended \\ false)
   def parse("@" <> identifier, _) do
     special(String.to_atom(identifier))
   end
-  def parse(cron_format, true) do
-    interpret(String.split(cron_format, " "), @extended_intervals, %CronExpression{extended: true})
+  def parse(cron_expression, true) do
+    interpret(String.split(cron_expression, " "), @extended_intervals, %CronExpression{extended: true})
   end
-  def parse(cron_format, false) do
-    interpret(String.split(cron_format, " "), @intervals, %CronExpression{})
+  def parse(cron_expression, false) do
+    interpret(String.split(cron_expression, " "), @intervals, %CronExpression{})
   end
 
   @doc """
@@ -104,23 +104,23 @@ defmodule Crontab.CronExpression.Parser do
 
   """
   @spec parse!(binary, boolean) :: CronExpression.t | no_return
-  def parse!(cron_format, extended \\ false) do
-    case parse(cron_format, extended) do
+  def parse!(cron_expression, extended \\ false) do
+    case parse(cron_expression, extended) do
       {:ok, result} -> result
       {:error, error} -> raise error
     end
   end
 
   @spec interpret([binary], [CronExpression.interval], CronExpression.t) :: CronExpression.t | {:error, binary}
-  defp interpret([head_format | tail_format], [head_interval | tail_interval], cron_interval) do
-    conditions = interpret head_interval, head_format
+  defp interpret([head_format | tail_format], [head_expression | tail_expression], cron_expression) do
+    conditions = interpret head_expression, head_format
     case conditions do
-      {:ok, ok_conditions} -> patched_cron_interval = Map.put(cron_interval, head_interval, ok_conditions)
-        interpret(tail_format, tail_interval, patched_cron_interval)
+      {:ok, ok_conditions} -> patched_cron_expression = Map.put(cron_expression, head_expression, ok_conditions)
+        interpret(tail_format, tail_expression, patched_cron_expression)
       _ -> conditions
     end
   end
-  defp interpret([], _, cron_interval), do: {:ok, cron_interval}
+  defp interpret([], _, cron_expression), do: {:ok, cron_expression}
   defp interpret(_, [], _), do: {:error, "The Cron Format String contains to many parts."}
   @spec interpret(CronExpression.interval, binary) :: {:ok, [CronExpression.value]} | {:error, binary}
   defp interpret(interval, format) do

lib/crontab/date_checker.ex

@@ -18,8 +18,8 @@ defmodule Crontab.DateChecker do
 
   """
   @spec matches_date?(CronExpression.t, NaiveDateTime.t) :: boolean
-  def matches_date?(cron_interval = %CronExpression{}, execution_date) do
-    cron_interval
+  def matches_date?(cron_expression = %CronExpression{}, execution_date) do
+    cron_expression
       |> CronExpression.to_condition_list
       |> matches_date?(execution_date)
   end

lib/crontab/scheduler.ex

@@ -26,15 +26,15 @@ defmodule Crontab.Scheduler do
 
   """
   @spec get_next_run_date(CronExpression.t, NaiveDateTime.t, integer) :: result
-  def get_next_run_date(cron_interval, date, max_runs \\ @max_runs)
-  def get_next_run_date(cron_interval = %CronExpression{extended: false}, date, max_runs) do
-    case get_run_date(cron_interval, clean_date(date, :seconds), max_runs, :increment) do
+  def get_next_run_date(cron_expression, date, max_runs \\ @max_runs)
+  def get_next_run_date(cron_expression = %CronExpression{extended: false}, date, max_runs) do
+    case get_run_date(cron_expression, clean_date(date, :seconds), max_runs, :increment) do
       {:ok, date} -> {:ok, date}
       error = {:error, _} -> error
     end
   end
-  def get_next_run_date(cron_interval = %CronExpression{extended: true}, date, max_runs) do
-    get_run_date(cron_interval, clean_date(date, :microseconds), max_runs, :increment)
+  def get_next_run_date(cron_expression = %CronExpression{extended: true}, date, max_runs) do
+    get_run_date(cron_expression, clean_date(date, :microseconds), max_runs, :increment)
   end
 
   @doc """
@@ -54,8 +54,8 @@ defmodule Crontab.Scheduler do
 
   """
   @spec get_next_run_date!(CronExpression.t, NaiveDateTime.t, integer) :: NaiveDateTime.t | no_return
-  def get_next_run_date!(cron_interval, date, max_runs \\ @max_runs) do
-    case get_next_run_date(cron_interval, date, max_runs) do
+  def get_next_run_date!(cron_expression, date, max_runs \\ @max_runs) do
+    case get_next_run_date(cron_expression, date, max_runs) do
       {:ok, result} -> result
       {:error, error} -> raise error
     end
@@ -152,15 +152,15 @@ defmodule Crontab.Scheduler do
 
   """
   @spec get_previous_run_date(CronExpression.t, NaiveDateTime.t, integer) :: result
-  def get_previous_run_date(cron_interval, date, max_runs \\ @max_runs)
-  def get_previous_run_date(cron_interval = %CronExpression{extended: false}, date, max_runs) do
-    case get_run_date(cron_interval, date, max_runs, :decrement) do
+  def get_previous_run_date(cron_expression, date, max_runs \\ @max_runs)
+  def get_previous_run_date(cron_expression = %CronExpression{extended: false}, date, max_runs) do
+    case get_run_date(cron_expression, date, max_runs, :decrement) do
       {:ok, date} -> {:ok, reset(date, :seconds)}
       error = {:error, _} -> error
     end
   end
-  def get_previous_run_date(cron_interval = %CronExpression{extended: true}, date, max_runs) do
-    get_run_date(cron_interval, date, max_runs, :decrement)
+  def get_previous_run_date(cron_expression = %CronExpression{extended: true}, date, max_runs) do
+    get_run_date(cron_expression, date, max_runs, :decrement)
   end
 
 
@@ -183,8 +183,8 @@ defmodule Crontab.Scheduler do
 
   """
   @spec get_previous_run_date!(CronExpression.t, NaiveDateTime.t, integer) :: NaiveDateTime.t | no_return
-  def get_previous_run_date!(cron_interval, date, max_runs \\ @max_runs) do
-    case get_previous_run_date(cron_interval, date, max_runs) do
+  def get_previous_run_date!(cron_expression, date, max_runs \\ @max_runs) do
+    case get_previous_run_date(cron_expression, date, max_runs) do
       {:ok, result} -> result
       {:error, error} -> raise error
     end
@@ -270,16 +270,16 @@ defmodule Crontab.Scheduler do
   defp get_run_date(_, _, 0, _) do
     {:error, "No compliant date was found for your interval."}
   end
-  defp get_run_date(cron_interval = %CronExpression{extended: false}, date, max_runs, direction) do
+  defp get_run_date(cron_expression = %CronExpression{extended: false}, date, max_runs, direction) do
     condition_list = case direction do
-      :increment -> CronExpression.to_condition_list(cron_interval)
-      :decrement -> Enum.reverse(CronExpression.to_condition_list(cron_interval))
+      :increment -> CronExpression.to_condition_list(cron_expression)
+      :decrement -> Enum.reverse(CronExpression.to_condition_list(cron_expression))
     end
 
     get_run_date(condition_list, reset(date, :seconds), max_runs, direction)
   end
-  defp get_run_date(cron_interval = %CronExpression{extended: true}, date, max_runs, direction) do
-    cron_interval
+  defp get_run_date(cron_expression = %CronExpression{extended: true}, date, max_runs, direction) do
+    cron_expression
       |> CronExpression.to_condition_list
       |> get_run_date(reset(date, :microseconds), max_runs, direction)
   end

test/crontab/functional_test.exs

@@ -86,14 +86,14 @@ defmodule Crontab.FunctionalTest do
     @previous_search_date previous_search_date
     @matches_now matches_now
     test "test " <> @cron_expression <> " from " <> NaiveDateTime.to_iso8601(@start_date) <> " equals " <> NaiveDateTime.to_iso8601(@next_search_date) do
-      {:ok, cron_interval} = Crontab.CronExpression.Parser.parse(@cron_expression)
-      assert Crontab.CronExpression.Composer.compose(cron_interval) == @written_cron_expression
-      assert Crontab.Scheduler.get_next_run_date(cron_interval, @start_date) == {:ok, @next_search_date}
+      {:ok, cron_expression} = Crontab.CronExpression.Parser.parse(@cron_expression)
+      assert Crontab.CronExpression.Composer.compose(cron_expression) == @written_cron_expression
+      assert Crontab.Scheduler.get_next_run_date(cron_expression, @start_date) == {:ok, @next_search_date}
       case @previous_search_date do
-        :none -> assert Crontab.Scheduler.get_previous_run_date(cron_interval, @start_date) == {:error, "No compliant date was found for your interval."}
-        _ -> assert Crontab.Scheduler.get_previous_run_date(cron_interval, @start_date) == {:ok, @previous_search_date}
+        :none -> assert Crontab.Scheduler.get_previous_run_date(cron_expression, @start_date) == {:error, "No compliant date was found for your interval."}
+        _ -> assert Crontab.Scheduler.get_previous_run_date(cron_expression, @start_date) == {:ok, @previous_search_date}
       end
-      assert Crontab.DateChecker.matches_date?(cron_interval, @start_date) == @matches_now
+      assert Crontab.DateChecker.matches_date?(cron_expression, @start_date) == @matches_now
     end
   end
 
@@ -116,14 +116,14 @@ defmodule Crontab.FunctionalTest do
     @previous_search_date previous_search_date
     @matches_now matches_now
     test "extended test " <> @cron_expression <> " from " <> NaiveDateTime.to_iso8601(@start_date) <> " equals " <> NaiveDateTime.to_iso8601(@next_search_date) do
-      {:ok, cron_interval} = Crontab.CronExpression.Parser.parse(@cron_expression, true)
-      assert Crontab.CronExpression.Composer.compose(cron_interval) == @written_cron_expression
-      assert Crontab.Scheduler.get_next_run_date(cron_interval, @start_date) == {:ok, @next_search_date}
+      {:ok, cron_expression} = Crontab.CronExpression.Parser.parse(@cron_expression, true)
+      assert Crontab.CronExpression.Composer.compose(cron_expression) == @written_cron_expression
+      assert Crontab.Scheduler.get_next_run_date(cron_expression, @start_date) == {:ok, @next_search_date}
       case @previous_search_date do
-        :none -> assert Crontab.Scheduler.get_previous_run_date(cron_interval, @start_date) == {:error, "No compliant date was found for your interval."}
-        _ -> assert Crontab.Scheduler.get_previous_run_date(cron_interval, @start_date) == {:ok, @previous_search_date}
+        :none -> assert Crontab.Scheduler.get_previous_run_date(cron_expression, @start_date) == {:error, "No compliant date was found for your interval."}
+        _ -> assert Crontab.Scheduler.get_previous_run_date(cron_expression, @start_date) == {:ok, @previous_search_date}
       end
-      assert Crontab.DateChecker.matches_date?(cron_interval, @start_date) == @matches_now
+      assert Crontab.DateChecker.matches_date?(cron_expression, @start_date) == @matches_now
     end
   end
 end