class IceCubeCron::ExpressionParser

Parses the incoming expression and splits it into meaningful parts.

Constants

EXPRESSION_PART_DEFAULTS
EXPRESSION_PART_KEYS

Public Class Methods

new(*expression) click to toggle source

Create a parsed expression

Takes a hash of cron expression parts.

### Expression values:

  • interval

  • year

  • month

  • day

  • weekday

# File lib/ice_cube_cron/expression_parser.rb, line 41
def initialize(*expression)
  expression_parts = expression.last.is_a?(::Hash) ? expression.last : {}

  expression_str = expression[0].is_a?(::String) ? expression[0] : nil
  expression_parts.merge!(string_to_expression_parts(expression_str))

  self.expression_hash = EXPRESSION_PART_DEFAULTS.dup

  expression_parts.each do |name, val|
    begin
      send("#{name}=", val)
    rescue NoMethodError
      raise ArgumentError, "Invalid parameter: #{name}"
    end
  end
end
sanitize_day_param(param) click to toggle source

Sanitize given value to a valid day parameter

# File lib/ice_cube_cron/expression_parser.rb, line 95
def self.sanitize_day_param(param)
  return nil if param.blank?
  return param if param.is_a?(::Array)
  return [param] if param.is_a?(::Integer)

  param.to_s.split(',').map do |element|
    next -1 if element == 'L'

    ExpressionParser.sanitize_integer_array_param(element)
  end.flatten.uniq
end
sanitize_integer_array_param(param) click to toggle source

Sanitize given value to an integer array

# File lib/ice_cube_cron/expression_parser.rb, line 122
def self.sanitize_integer_array_param(param)
  return nil if param.blank?
  return param if param.is_a?(::Array)
  return [param] if param.is_a?(::Integer)

  param.split(',').map do |element|
    if element =~ /[0-9]+\-[0-9]+/
      parts = element.split('-')
      (parts[0].to_i..parts[1].to_i).to_a
    else
      element.to_i
    end
  end.flatten.uniq
end
sanitize_integer_param(param, default = nil) click to toggle source

Sanitize given value to an integer

# File lib/ice_cube_cron/expression_parser.rb, line 110
def self.sanitize_integer_param(param, default = nil)
  return default if param.blank?

  param.to_i
end
sanitize_week_day_param(param) click to toggle source

Sanitize given value to a valid weekday parameter

# File lib/ice_cube_cron/expression_parser.rb, line 141
def self.sanitize_week_day_param(param)
  return nil if param.blank?

  param.to_s.split(',').map do |element|
    if element =~ /[0-9]+#[0-9]+/
      parts = element.split('#')
      { ExpressionParser.sanitize_integer_param(parts[0]) => ExpressionParser.sanitize_integer_array_param(parts[1]) }
    elsif element =~ /[0-9]+L/
      { ExpressionParser.sanitize_integer_param(element) => [-1] }
    else
      ExpressionParser.sanitize_integer_param(element)
    end
  end
end

Private Instance Methods

split_parts_and_interval(expression_str) click to toggle source

Split a cron string and extract the LAST interval that appears

# File lib/ice_cube_cron/expression_parser.rb, line 161
def split_parts_and_interval(expression_str)
  interval = nil
  parts = expression_str.split(/ +/).map do |part|
    part, part_interval = part.split('/')
    interval = part_interval unless part_interval.blank?
    next nil if part.blank? || part == '*'

    part
  end

  [parts, interval]
end
string_to_expression_parts(expression_str) click to toggle source

Split string expression into parts

# File lib/ice_cube_cron/expression_parser.rb, line 177
def string_to_expression_parts(expression_str)
  return {} if expression_str.nil?

  parts, interval = split_parts_and_interval(expression_str)

  expression_parts = ::Hash[EXPRESSION_PART_KEYS.zip(parts)]
  expression_parts.reject! do |_key, value|
    value.nil?
  end
  expression_parts[:interval] = interval unless interval.nil?

  expression_parts
end