maennchen
diff --git a/‎lib/crontab/cron_expression.ex‎
Lines changed: 54 additions & 15 deletions b/‎lib/crontab/cron_expression.ex‎
Lines changed: 54 additions & 15 deletions
diff --git a/‎lib/crontab/cron_expression/composer.ex‎
Lines changed: 2 additions & 0 deletions b/‎lib/crontab/cron_expression/composer.ex‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎lib/crontab/cron_expression/parser.ex‎
Lines changed: 16 additions & 17 deletions b/‎lib/crontab/cron_expression/parser.ex‎
Lines changed: 16 additions & 17 deletions
@@ -8,6 +8,7 @@ defmodule Crontab.CronExpression do
   @type t :: %Crontab.CronExpression{
           extended: boolean,
           reboot: boolean,
+          on_ambiguity: [ambiguity_opt],
           second: [value(second)],
           minute: [value(minute)],
           hour: [value(hour)],
@@ -17,7 +18,9 @@ defmodule Crontab.CronExpression do
           year: [value(year)]
         }
 
-  @type interval :: :second | :minute | :hour | :day | :month | :weekday | :year
+  @type ambiguity_opt :: :prior | :subsequent
+
+  @type interval :: :second | :minute | :hour | :day | :month | :weekday | :year | :ambiguity_opts
 
   @typedoc deprecated: "Use Crontab.CronExpression.min_max/1 instead"
   @type min_max :: {:-, time_unit, time_unit}
@@ -63,7 +66,7 @@ defmodule Crontab.CronExpression do
   @typedoc deprecated: "Use Calendar.[second|minute|hour|day|month|day_of_week|year]/0 instead"
   @type time_unit :: second | minute | hour | day | month | weekday | year
 
-  @type condition(name, time_unit) :: {name, [value(time_unit)]}
+  @type condition(name, time_unit) :: {name, [value(time_unit) | ambiguity_opt]}
   @type condition ::
           condition(:second, Calendar.second())
           | condition(:minute, Calendar.minute())
@@ -72,6 +75,7 @@ defmodule Crontab.CronExpression do
           | condition(:month, Calendar.month())
           | condition(:weekday, Calendar.day_of_week())
           | condition(:year, Calendar.year())
+          | condition(:ambiguity_opts, [ambiguity_opt()])
 
   @type condition_list :: [condition]
 
@@ -89,9 +93,15 @@ defmodule Crontab.CronExpression do
       +-------------- :second Second             (range: 0-59)
 
   The `:extended` attribute defines if the second is taken into account.
+  When using localized DateTime, the `:on_ambiguity` attribute defines
+  whether the scheduler should return the prior or subsequent time when
+  the next run DateTime is ambiguous. `:on_ambiguity` defaults to `[]`
+  which means run DateTimes that fall within the ambiguous times would
+  be skipped. To run on both, set it as `[:prior, :subsequent]`.
   """
   defstruct extended: false,
             reboot: false,
+            on_ambiguity: [],
             second: [:*],
             minute: [:*],
             hour: [:*],
@@ -108,6 +118,7 @@ defmodule Crontab.CronExpression do
       iex> ~e[*]
       %Crontab.CronExpression{
         extended: false,
+        on_ambiguity: [],
         second: [:*],
         minute: [:*],
         hour: [:*],
@@ -116,9 +127,10 @@ defmodule Crontab.CronExpression do
         weekday: [:*],
         year: [:*]}
 
-      iex> ~e[*]e
+      iex> ~e[*]ep
       %Crontab.CronExpression{
         extended: true,
+        on_ambiguity: [:prior],
         second: [:*],
         minute: [:*],
         hour: [:*],
@@ -127,9 +139,22 @@ defmodule Crontab.CronExpression do
         weekday: [:*],
         year: [:*]}
 
+      iex> ~e[1 2 3 4 5 6 7]eps
+      %Crontab.CronExpression{
+        extended: true,
+        on_ambiguity: [:prior, :subsequent],
+        second: [1],
+        minute: [2],
+        hour: [3],
+        day: [4],
+        month: [5],
+        weekday: [6],
+        year: [7]}
+
       iex> ~e[1 2 3 4 5 6 7]e
       %Crontab.CronExpression{
         extended: true,
+        on_ambiguity: [],
         second: [1],
         minute: [2],
         hour: [3],
@@ -139,9 +164,18 @@ defmodule Crontab.CronExpression do
         year: [7]}
   """
   @spec sigil_e(binary, charlist) :: t
-  def sigil_e(cron_expression, options)
-  def sigil_e(cron_expression, [?e]), do: Parser.parse!(cron_expression, true)
-  def sigil_e(cron_expression, _options), do: Parser.parse!(cron_expression, false)
+  def sigil_e(cron_expression, options \\ [?l]) do
+    Parser.parse!(
+      cron_expression,
+      ?e in options,
+      cond do
+        ?p in options and ?s in options -> [:prior, :subsequent]
+        ?p in options -> [:prior]
+        ?s in options -> [:subsequent]
+        true -> []
+      end
+    )
+  end
 
   @doc """
   Convert `Crontab.CronExpression` struct to tuple List.
@@ -155,7 +189,8 @@ defmodule Crontab.CronExpression do
         {:day, [3]},
         {:month, [4]},
         {:weekday, [5]},
-        {:year, [6]}]
+        {:year, [6]},
+        {:ambiguity_opts, []}]
 
       iex> Crontab.CronExpression.to_condition_list %Crontab.CronExpression{
       ...> extended: true, second: [0], minute: [1], hour: [2], day: [3], month: [4], weekday: [5], year: [6]}
@@ -165,7 +200,8 @@ defmodule Crontab.CronExpression do
         {:day, [3]},
         {:month, [4]},
         {:weekday, [5]},
-        {:year, [6]}]
+        {:year, [6]},
+        {:ambiguity_opts, []}]
 
   """
   @spec to_condition_list(t) :: condition_list
@@ -176,7 +212,8 @@ defmodule Crontab.CronExpression do
       {:day, interval.day},
       {:month, interval.month},
       {:weekday, interval.weekday},
-      {:year, interval.year}
+      {:year, interval.year},
+      {:ambiguity_opts, interval.on_ambiguity}
     ]
   end
 
@@ -200,14 +237,16 @@ defmodule Crontab.CronExpression do
         iex> IO.inspect %Crontab.CronExpression{extended: true}
         ~e[* * * * * * *]e
 
+        iex> import Crontab.CronExpression
+        iex> IO.inspect %Crontab.CronExpression{extended: true, on_ambiguity: [:prior, :subsequent]}
+        ~e[* * * * * * *]eps
     """
     @spec inspect(CronExpression.t(), any) :: String.t()
-    def inspect(cron_expression = %CronExpression{extended: false}, _options) do
-      "~e[" <> Composer.compose(cron_expression) <> "]"
-    end
-
-    def inspect(cron_expression = %CronExpression{extended: true}, _options) do
-      "~e[" <> Composer.compose(cron_expression) <> "]e"
+    def inspect(cron_expression = %CronExpression{}, _options) do
+      prior = if(:prior in cron_expression.on_ambiguity, do: "p", else: "")
+      subsequent = if(:subsequent in cron_expression.on_ambiguity, do: "s", else: "")
+      extended = if(cron_expression.extended, do: "e", else: "")
+      "~e[" <> Composer.compose(cron_expression) <> "]#{extended}#{prior}#{subsequent}"
     end
   end
 end
@@ -55,6 +55,8 @@ defmodule Crontab.CronExpression.Composer do
     compose_interval(tail, opts)
   end
 
+  defp compose_interval([{:ambiguity_opts, _} | tail], opts), do: compose_interval(tail, opts)
+
   defp compose_interval([{_, conditions} | tail], opts) do
     [
       Enum.map_join(conditions, ",", fn condition -> compose_condition(condition) end)
 
@@ -72,32 +72,31 @@ defmodule Crontab.CronExpression.Parser do
       iex> Crontab.CronExpression.Parser.parse "* * * * *"
       {:ok,
         %Crontab.CronExpression{day: [:*], hour: [:*], minute: [:*],
-        month: [:*], weekday: [:*], year: [:*]}}
+        month: [:*], weekday: [:*], year: [:*], on_ambiguity: []}}
 
       iex> Crontab.CronExpression.Parser.parse "* * * * *", true
       {:ok,
         %Crontab.CronExpression{extended: true, day: [:*], hour: [:*], minute: [:*],
-        month: [:*], weekday: [:*], year: [:*], second: [:*]}}
+        month: [:*], weekday: [:*], year: [:*], second: [:*], on_ambiguity: []}}
 
       iex> Crontab.CronExpression.Parser.parse "fooo"
       {:error, "Can't parse fooo as minute."}
 
   """
-  @spec parse(binary, boolean) :: result
-  def parse(cron_expression, extended \\ false)
+  @spec parse(binary, boolean, [CronExpression.ambiguity_opt()]) :: result
+  def parse(cron_expression, extended \\ false, ambiguity_opts \\ [])
 
-  def parse("@" <> identifier, _) do
+  def parse("@" <> identifier, _, _) do
     special(String.downcase(identifier))
   end
 
-  def parse(cron_expression, true) do
-    interpret(String.split(cron_expression, " "), @extended_intervals, %CronExpression{
-      extended: true
-    })
-  end
+  def parse(cron_expression, is_extended, ambiguity_opts) do
+    format = if(is_extended, do: @extended_intervals, else: @intervals)
 
-  def parse(cron_expression, false) do
-    interpret(String.split(cron_expression, " "), @intervals, %CronExpression{})
+    interpret(String.split(cron_expression, " "), format, %CronExpression{
+      extended: is_extended,
+      on_ambiguity: ambiguity_opts
+    })
   end
 
   @doc """
@@ -107,19 +106,19 @@ defmodule Crontab.CronExpression.Parser do
 
       iex> Crontab.CronExpression.Parser.parse! "* * * * *"
       %Crontab.CronExpression{day: [:*], hour: [:*], minute: [:*],
-        month: [:*], weekday: [:*], year: [:*]}
+        month: [:*], weekday: [:*], year: [:*], on_ambiguity: []}
 
       iex> Crontab.CronExpression.Parser.parse! "* * * * *", true
       %Crontab.CronExpression{extended: true, day: [:*], hour: [:*], minute: [:*],
-        month: [:*], weekday: [:*], year: [:*], second: [:*]}
+        month: [:*], weekday: [:*], year: [:*], second: [:*], on_ambiguity: []}
 
       iex> Crontab.CronExpression.Parser.parse! "fooo"
       ** (RuntimeError) Can't parse fooo as minute.
 
   """
-  @spec parse!(binary, boolean) :: CronExpression.t()
-  def parse!(cron_expression, extended \\ false) do
-    case parse(cron_expression, extended) do
+  @spec parse!(binary, boolean, [CronExpression.ambiguity_opt()]) :: CronExpression.t()
+  def parse!(cron_expression, extended \\ false, ambiguity_opts \\ []) do
+    case parse(cron_expression, extended, ambiguity_opts) do
       {:ok, result} -> result
       {:error, error} -> raise error
     end
Original file line number	Diff line number	Diff line change
`@@ -55,6 +55,8 @@ defmodule Crontab.CronExpression.Composer do`
`55`	`55`	`compose_interval(tail, opts)`
`56`	`56`	`end`
`57`	`57`
	`58`	`+ defp compose_interval([{:ambiguity_opts, _} \| tail], opts), do: compose_interval(tail, opts)`
	`59`	`+`
`58`	`60`	`defp compose_interval([{_, conditions} \| tail], opts) do`
`59`	`61`	`[`
`60`	`62`	`Enum.map_join(conditions, ",", fn condition -> compose_condition(condition) end)`