cronex 0.2.0

data/lib/cronex/description/seconds.rb

@@ -0,0 +1,23 @@
+module Cronex
+  class SecondsDescription < Description
+    def single_item_description(expression)
+      expression
+    end
+
+    def interval_description_format(expression)
+      format(resources.get('every_x_seconds'), expression)
+    end
+
+    def between_description_format(expression)
+      resources.get('seconds_through_past_the_minute')
+    end
+
+    def description_format(expression)
+      resources.get('at_x_seconds_past_the_minute')
+    end
+
+    def starting_description_format(expression)
+      resources.get('starting') + ' ' + description_format(expression)
+    end
+  end
+end

data/lib/cronex/description/year.rb

@@ -0,0 +1,23 @@
+module Cronex
+  class YearDescription < Description
+    def single_item_description(expression)
+      DateTime.new(Integer(expression)).strftime('%Y')
+    end
+
+    def interval_description_format(expression)
+      format(', ' + resources.get('every_x') + ' ' + plural(expression, resources.get('year'), resources.get('years')), expression)
+    end
+
+    def between_description_format(expression)
+      ', ' + resources.get('between_description_format')
+    end
+
+    def description_format(expression)
+      ', ' + resources.get('only_in')
+    end
+
+    def starting_description_format(expression)
+      resources.get('starting') + ' ' + resources.get('in_x')
+    end
+  end
+end

data/lib/cronex/errors.rb

@@ -0,0 +1,4 @@
+module Cronex
+  ExpressionError = Class.new(StandardError)
+  ResourceError = Class.new(StandardError)
+end

data/lib/cronex/exp_descriptor.rb

@@ -0,0 +1,189 @@
+module Cronex
+
+  CASINGS  = [:title, :sentence, :lower]
+  SEGMENTS = [:seconds, :minutes, :hours, :dayofmonth, :month, :dayofweek, :year, :timeofday, :full]
+
+  SPECIAL_CHARS = ['/', '-', ',', '*']
+
+  CRONEX_OPTS = {
+    casing: :sentence,
+    verbose: false,
+    zero_based_dow: true,
+    use_24_hour_time_format: false,
+    throw_exception_on_parse_error: true
+  }
+
+  class ExpressionDescriptor
+    attr_accessor :expression, :expression_parts, :options, :parsed, :resources
+
+    def initialize(expression, options = {}, locale = nil)
+      @expression = expression
+      @options = CRONEX_OPTS.merge(options)
+      @expression_parts = []
+      @parsed = false
+      @resources = Cronex::Resource.new(locale)
+    end
+
+    def to_hash
+      Hash[SEGMENTS.take(7).zip(expression_parts)]
+    end
+
+    def description(type = :full)
+      desc = ''
+
+      begin
+        unless parsed
+          parser = Parser.new(expression, options)
+          @expression_parts = parser.parse
+          @parsed = true
+        end
+
+        desc = case type
+        when :full
+          full_description(expression_parts)
+        when :timeofday
+          time_of_day_description(expression_parts)
+        when :hours
+          hours_description(expression_parts)
+        when :minutes
+          minutes_description(expression_parts)
+        when :seconds
+          seconds_description(expression_parts)
+        when :dayofmonth
+          day_of_month_description(expression_parts)
+        when :month
+          month_description(expression_parts)
+        when :dayofweek
+          day_of_week_description(expression_parts)
+        when :year
+          year_description(expression_parts)
+        else
+          seconds_description(expression_parts)
+        end
+      rescue StandardError => e
+        if options[:throw_exception_on_parse_error]
+          raise e
+        else
+          desc = e.message
+          puts "Exception parsing expression: #{e}"
+        end
+      end
+
+      desc
+    end
+
+    def seconds_description(expression_parts)
+      desc = SecondsDescription.new(resources)
+      desc.segment_description(expression_parts[0], resources.get('every_second'))
+    end
+
+    def minutes_description(expression_parts)
+      desc = MinutesDescription.new(resources)
+      desc.segment_description(expression_parts[1], resources.get('every_minute'))
+    end
+
+    def hours_description(expression_parts)
+      desc = HoursDescription.new(resources)
+      desc.segment_description(expression_parts[2], resources.get('every_hour'))
+    end
+
+    def year_description(expression_parts)
+      desc = YearDescription.new(resources, options)
+      desc.segment_description(expression_parts[6], ', ' + resources.get('every_year'))
+    end
+
+    def day_of_week_description(expression_parts)
+      desc = DayOfWeekDescription.new(resources, options)
+      desc.segment_description(expression_parts[5], ', ' + resources.get('every_day'))
+    end
+
+    def month_description(expression_parts)
+      desc = MonthDescription.new(resources)
+      desc.segment_description(expression_parts[4], '')
+    end
+
+    def day_of_month_description(expression_parts)
+      exp = expression_parts[3].gsub('?', '*')
+      if exp == 'L'
+        description = ', ' + resources.get('on_the_last_day_of_the_month')
+      elsif exp == 'LW' || exp == 'WL'
+        description = ', ' + resources.get('on_the_last_weekday_of_the_month')
+      else
+        match = exp.match(/(\d{1,2}W)|(W\d{1,2})/)
+        if match
+          day_num = Integer(match[0].gsub('W', ''))
+          day_str = day_num == 1 ? resources.get('first_weekday') : format(resources.get('weekday_nearest_day'), day_num)
+          description = format(', ' + resources.get('on_the_of_the_month'), day_str)
+        else
+          desc = DayOfMonthDescription.new(resources)
+          description = desc.segment_description(exp, ', ' + resources.get('every_day'))
+        end
+      end
+      description
+    end
+
+    def time_of_day_description(expression_parts)
+      sec_exp, min_exp, hour_exp = expression_parts
+      description = ''
+      if [sec_exp, min_exp, hour_exp].all? { |exp| !Cronex::Utils.include_any?(exp, SPECIAL_CHARS) }
+        # specific time of day (i.e. 10 14)
+        description += resources.get('at') + ' ' + Cronex::Utils.format_time(hour_exp, min_exp, sec_exp)
+      elsif min_exp.include?('-') && !min_exp.include?('/') && !min_exp.include?(',') && !Cronex::Utils.include_any?(hour_exp, SPECIAL_CHARS)
+        # Minute range in single hour (e.g. 0-10 11)
+        min_parts = min_exp.split('-')
+        description += format(
+          resources.get('every_minute_between'),
+          Cronex::Utils.format_time(hour_exp, min_parts[0]),
+          Cronex::Utils.format_time(hour_exp, min_parts[1]))
+      elsif hour_exp.include?(',') && !Cronex::Utils.include_any?(min_exp, SPECIAL_CHARS)
+        # Hours list with single minute (e.g. 30 6,14,16)
+        hour_parts = hour_exp.split(',')
+        description += resources.get('at')
+        h_parts = hour_parts.map { |part| ' ' + Cronex::Utils.format_time(part, min_exp) }
+        description += h_parts[0...-1].join(',') + ' ' + resources.get('and') + h_parts.last
+      else
+        sec_desc = seconds_description(expression_parts)
+        min_desc = minutes_description(expression_parts)
+        hour_desc = hours_description(expression_parts)
+        description += sec_desc
+        description += ', ' if description.size > 0 && !min_desc.empty?
+        description += min_desc
+        description += ', ' if description.size > 0 && !hour_desc.empty?
+        description += hour_desc
+      end
+      description
+    end
+
+    def full_description(expression_parts)
+      time_segment = time_of_day_description(expression_parts)
+      dom_desc = day_of_month_description(expression_parts)
+      month_desc = month_description(expression_parts)
+      dow_desc = day_of_week_description(expression_parts)
+      year_desc = year_description(expression_parts)
+      day_desc = expression_parts[3] == '*' ? dow_desc : dom_desc
+      description = format('%s%s%s%s', time_segment, day_desc, month_desc, year_desc)
+      description = transform_verbosity(description, options[:verbose])
+      description = transform_case(description, options[:casing])
+      description
+    end
+
+    def transform_case(desc, case_type = :lower)
+      case case_type
+      when :sentence
+        desc.sub(/\w+/, &:capitalize)
+      when :title
+        desc.gsub(/\w+/, &:capitalize)
+      else
+        desc.downcase
+      end
+    end
+
+    def transform_verbosity(desc, verbose = false)
+      return desc if verbose
+      parts = %w(every_minute every_hour every_day)
+      parts.each { |part| desc.gsub!(resources.get(part.gsub('_', '_1_')), resources.get(part)) }
+      parts.each { |part| desc.gsub!(', ' + resources.get(part), '') }
+      desc
+    end
+  end
+end

data/lib/cronex/parser.rb

@@ -0,0 +1,92 @@
+module Cronex
+
+  DAYS   = Date::ABBR_DAYNAMES.map(&:upcase)
+  MONTHS = Date::ABBR_MONTHNAMES[1..-1].map(&:upcase)
+
+  DAY_NUM   = Hash[DAYS.zip(0..(DAYS.size - 1))]
+  MONTH_NUM = Hash[MONTHS.zip(1..MONTHS.size)]
+
+  # abbr dayname => long dayname
+  DAY_DAY = Hash[DAYS.zip(Date::DAYNAMES.map(&:upcase))]
+
+  class Parser
+    attr_accessor :expression, :options
+
+    def initialize(expression, options = {})
+      @expression = expression
+      @options = options
+    end
+
+    def parse(exp = expression)
+      parsed_parts = Array.new(7, '')
+
+      fail ExpressionError, 'Error: Expression null or emtpy' unless Cronex::Utils.present?(exp)
+      parts = sanitize(exp).split(' ')
+      len = parts.size
+
+      if len < 5
+        fail ExpressionError, "Error: Expression only has #{len} parts. At least 5 parts are required"
+      elsif len == 5
+        # 5 part CRON so shift array past seconds element
+        parsed_parts.insert(1, *parts)
+      elsif len == 6
+        # if last element ends with 4 digits, a year element has been supplied and no seconds element
+        if parts.last.match(/\d{4}$/)
+          parsed_parts.insert(1, *parts)
+        else
+          parsed_parts.insert(0, *parts)
+        end
+      elsif len == 7
+        parsed_parts = parts
+      else
+        fail ExpressionError, "Error: Expression has too many parts (#{len}). Expression must not have more than 7 parts"
+      end
+
+      parsed_parts = parsed_parts.take(7) # ; p parsed_parts
+      normalize(parsed_parts, options)
+    end
+
+    def sanitize(exp = expression)
+      # remove extra spaces
+      exp = exp.strip.gsub(/\s+/, ' ').upcase
+      # convert non-standard day names (e.g. THURS, TUES) to 3-letter names
+      DAY_DAY.each do |day, longname|
+        matched = exp.scan(/\W*(#{day}\w*)/).flatten.uniq
+        matched.each { |m| exp.gsub!(m, day) if longname.include?(m) }
+      end
+      exp
+    end
+
+    def normalize(expression_parts, options = {})
+      parts = expression_parts.dup
+
+      # convert ? to * only for DOM and DOW
+      parts[3].gsub!('?', '*')
+      parts[5].gsub!('?', '*')
+
+      # Convert 0/, 1/ to */
+      parts[0].gsub!('0/', '*/') if parts[0].start_with?('0/') # seconds
+      parts[1].gsub!('0/', '*/') if parts[1].start_with?('0/') # minutes
+      parts[2].gsub!('0/', '*/') if parts[2].start_with?('0/') # hours
+      parts[3].gsub!('1/', '*/') if parts[3].start_with?('1/') # day of month
+      parts[4].gsub!('1/', '*/') if parts[4].start_with?('1/') # month
+      parts[5].gsub!('1/', '*/') if parts[5].start_with?('1/') # day of week
+
+      # convert */1 to *
+      parts = parts.map { |part| part == '*/1' ? '*' : part }
+
+      # convert SUN-SAT format to 0-6 format
+      DAY_NUM.each { |day, i| i += 1 if !options[:zero_based_dow]; parts[5].gsub!(day, i.to_s) }
+
+      # convert JAN-DEC format to 1-12 format
+      MONTH_NUM.each { |month, i| parts[4].gsub!(month, i.to_s) }
+
+      # convert 0 second to (empty)
+      parts[0] = '' if parts[0] == '0'
+
+      # convert 0 DOW to 7 so that 0 for Sunday in zeroBasedDayOfWeek is valid
+      parts[5] = '7' if (!options || options[:zero_based_dow]) && parts[5] == '0' # ; p parts
+      parts
+    end
+  end
+end

data/lib/cronex/resource.rb

@@ -0,0 +1,33 @@
+module Cronex
+
+  RESOURCES_DIR = File.expand_path('../../../resources', __FILE__)
+
+  class Resource
+    attr_reader :locale, :messages
+
+    def initialize(loc = :en)
+      self.locale = loc || :en
+    end
+
+    def locale=(loc)
+      result = load(loc)
+      if result.nil? || result.empty?
+        fail ResourceError, "Error: Invalid resource file for '#{loc}' locale"
+      else
+        @locale = loc
+        @messages = result
+      end
+    end
+
+    def load(loc)
+      file = File.join(RESOURCES_DIR,  "resources_#{loc}.yml")
+      fail ResourceError, "Resource file #{file} for '#{loc}' locale not found" unless File.exist?(file)
+      YAML.load_file(file)
+    end
+
+    def [](key)
+      @messages[key]
+    end
+    alias_method :get, :[]
+  end
+end

data/lib/cronex/utils.rb

@@ -0,0 +1,43 @@
+module Cronex
+  module Utils
+    extend self
+
+    def present?(str)
+      !str.to_s.strip.empty?
+    end
+
+    def include_any?(str, chars)
+      chars.any? { |char| str.include?(char) }
+    end
+
+    def number?(str)
+      Integer(str) rescue nil
+    end
+
+    def day_of_week_name(number)
+      Date::DAYNAMES[number.to_i % 7]
+    end
+
+    def format_minutes(minute_expression)
+      if minute_expression.include?(',')
+        minute_expression.split(',').map { |m| format('%02d', m) }.join(',')
+      else
+        format('%02d', minute_expression)
+      end
+    end
+
+    def format_time(hour_expression, minute_expression, second_expression = '')
+      hour = Integer(hour_expression)
+      period = hour >= 12 ? 'PM' : 'AM'
+      hour -= 12 if hour > 12
+      minute = Integer(minute_expression)
+      minute = format('%02d', minute)
+      second = ''
+      if Cronex::Utils.present?(second_expression)
+        second = Integer(second_expression)
+        second = ':' + format('%02d', second)
+      end
+      format('%s:%s%s %s', hour, minute, second, period)
+    end
+  end
+end

data/lib/cronex/version.rb

@@ -0,0 +1,3 @@
+module Cronex
+  VERSION = '0.2.0'
+end

data/resources/resources_en.yml

@@ -0,0 +1,56 @@
+# resources_en.yml
+---
+expression_empty_exception:         'Expression cannot be null or empty'
+interval_description_format:        'every %s days of the week'
+between_description_format:         '%s through %s'
+between_weekday_description_format: '%s through %s'
+on_the_day_of_the_month:            'on the {{nth}} %s of the month'
+on_the_of_the_month:                'on the %s of the month'
+on_the_last_of_the_month:           'on the last %s of the month'
+on_the_last_day_of_the_month:       'on the last day of the month'
+on_the_last_weekday_of_the_month:   'on the last weekday of the month'
+between_days_of_the_month:          'between day %s and %s of the month'
+seconds_through_past_the_minute:    'seconds %s through %s past the minute'
+between_x_and_y:                    'between %s and %s'
+past_the_hour:                      'past the hour'
+at_x_seconds_past_the_minute:       'at %s seconds past the minute'
+minutes_through_past_the_hour:      'minutes %s through %s past the hour'
+on_day_of_the_month:                'on day %s of the month'
+first_weekday:                      'first weekday'
+weekday_nearest_day:                'weekday nearest day %s'
+starting:             'starting'
+only_on:              'only on %s'
+only_in:              'only in %s'
+every_x_seconds:      'every %s seconds'
+every_minute_between: 'Every minute between %s and %s'
+every_second:         'every second'
+every_minute:         'every minute'
+every_1_minute:       'every 1 minute'
+every_hour:           'every hour'
+every_1_hour:         'every 1 hour'
+every_day:            'every day'
+every_1_day:          'every 1 day'
+every_year:           'every year'
+every_x:              'every %s'
+at_x:                 'at %s'
+on_x:                 'on %s'
+in_x:                 'in %s'
+first:   first
+second:  second
+third:   third
+fourth:  fourth
+fifth:   fifth
+time_pm: PM
+time_am: AM
+and:     and
+at:      At
+day:     day
+days:    days
+hour:    hour
+hours:   hours
+minute:  minute
+minutes: minutes
+month:   month
+months:  months
+year:    year
+years:   years