Crontab.CronExpression (crontab v1.2.0)

View Source

The Crontab.CronExpression module / struct.

Summary

Functions

Defines the Cron interval.

Create a %Crontab.CronExpression{} via sigil.

Convert Crontab.CronExpression struct to tuple List.

Types

ambiguity_opt()

@type ambiguity_opt() :: :prior | :subsequent

condition()

@type condition() ::
  condition(:second, Calendar.second())
  | condition(:minute, Calendar.minute())
  | condition(:hour, Calendar.hour())
  | condition(:day, Calendar.day())
  | condition(:month, Calendar.month())
  | condition(:weekday, Calendar.day_of_week())
  | condition(:year, Calendar.year())
  | condition(:ambiguity_opts, [ambiguity_opt()])

condition(name, time_unit)

@type condition(name, time_unit) :: {name, [value(time_unit) | ambiguity_opt()]}

condition_list()

@type condition_list() :: [condition()]

day()

This type is deprecated. Use Calendar.day/0 instead.
@type day() :: Calendar.day()

hour()

This type is deprecated. Use Calendar.hour/0 instead.
@type hour() :: Calendar.hour()

interval()

@type interval() ::
  :second | :minute | :hour | :day | :month | :weekday | :year | :ambiguity_opts

min_max()

This type is deprecated. Use Crontab.CronExpression.min_max/1 instead.
@type min_max() :: {:-, time_unit(), time_unit()}

min_max(time_unit)

@type min_max(time_unit) :: {:-, time_unit, time_unit}

minute()

This type is deprecated. Use Calendar.minute/0 instead.
@type minute() :: Calendar.minute()

month()

This type is deprecated. Use Calendar.month/0 instead.
@type month() :: Calendar.month()

second()

This type is deprecated. Use Calendar.second/0 instead.
@type second() :: Calendar.second()

t()

@type t() :: %Crontab.CronExpression{
  day: [value(day())],
  extended: boolean(),
  hour: [value(hour())],
  minute: [value(minute())],
  month: [value(month())],
  on_ambiguity: [ambiguity_opt()],
  reboot: boolean(),
  second: [value(second())],
  weekday: [value(weekday())],
  year: [value(year())]
}

time_unit()

This type is deprecated. Use Calendar.[second|minute|hour|day|month|day_of_week|year]/0 instead.
@type time_unit() ::
  second() | minute() | hour() | day() | month() | weekday() | year()

value()

value(time_unit)

@type value(time_unit) ::
  time_unit
  | :*
  | :L
  | {:L, value(time_unit)}
  | {:/, time_unit | :* | min_max(time_unit), pos_integer()}
  | min_max(time_unit)
  | {:W, time_unit | :L}
  | {:"#", time_unit, pos_integer()}

weekday()

This type is deprecated. Use Calendar.day_of_week/0 instead.
@type weekday() :: Calendar.day_of_week()

year()

This type is deprecated. Use Calendar.year/0 instead.
@type year() :: Calendar.year()

Functions

%Crontab.CronExpression{}

(struct)

Defines the Cron interval.

* * * * * * *
| | | | | | |
| | | | | | +-- :year Year                 (range: 1900-3000)
| | | | | +---- :weekday Day of the Week   (range: 1-7, 1 standing for Monday)
| | | | +------ :month Month of the Year   (range: 1-12)
| | | +-------- :day Day of the Month      (range: 1-31)
| | +---------- :hour Hour                 (range: 0-23)
| +------------ :minute Minute             (range: 0-59)
+-------------- :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].

sigil_e(cron_expression, options \\ ~c"l")

@spec sigil_e(
  binary(),
  charlist()
) :: t()

Create a %Crontab.CronExpression{} via sigil.

Examples

iex> ~e[*]
%Crontab.CronExpression{
  extended: false,
  on_ambiguity: [],
  second: [:*],
  minute: [:*],
  hour: [:*],
  day: [:*],
  month: [:*],
  weekday: [:*],
  year: [:*]
}

iex> ~e[*]ep
%Crontab.CronExpression{
  extended: true,
  on_ambiguity: [:prior],
  second: [:*],
  minute: [:*],
  hour: [:*],
  day: [:*],
  month: [:*],
  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],
  day: [4],
  month: [5],
  weekday: [6],
  year: [7]
}

to_condition_list(interval)

@spec to_condition_list(t()) :: condition_list()

Convert Crontab.CronExpression struct to tuple List.

Examples

iex> Crontab.CronExpression.to_condition_list(%Crontab.CronExpression{
...>   minute: [1],
...>   hour: [2],
...>   day: [3],
...>   month: [4],
...>   weekday: [5],
...>   year: [6]
...> })
[
  {:minute, [1]},
  {:hour, [2]},
  {:day, [3]},
  {:month, [4]},
  {:weekday, [5]},
  {: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]
...> })
[
  {:second, [0]},
  {:minute, [1]},
  {:hour, [2]},
  {:day, [3]},
  {:month, [4]},
  {:weekday, [5]},
  {:year, [6]},
  {:ambiguity_opts, []}
]