bblib 0.3.0 → 0.4.1

data/lib/string/regexp.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Opal seems to be missing the extended flag, this MonkeyPatch prevents errors.
+if BBLib.in_opal?
+  class Regexp
+    EXTENDED = 2
+  end
+end
+
+module BBLib
+  REGEXP_MODE_HASH = {
+    i: Regexp::IGNORECASE,
+    m: Regexp::MULTILINE,
+    x: Regexp::EXTENDED
+  }.freeze
+
+  REGEXP_OPTIONS = {
+    i: [:ignore_case, :ignorecase, :i, :case_insensitive, Regexp::IGNORECASE],
+    m: [:multiline, :multi_line, :m, Regexp::MULTILINE],
+    x: [:extended, :x, Regexp::EXTENDED]
+  }.freeze
+end
+
+class Regexp
+  def self.from_s(str, *options, ignore_invalid: false)
+    opt_map = options.map { |o| BBLib::REGEXP_OPTIONS.find { |k, v| o == k || o == k.to_s || v.include?(o) || v.include?(o.to_s.to_sym) }.first }.compact
+    return Regexp.new(str, opt_map.inject(0) { |s, x| s += BBLib::REGEXP_MODE_HASH[x] }) if str.encap_by?('(') || !str.start_with?('/')
+    str += opt_map.join
+    mode = 0
+    unless str.end_with?('/')
+      str.split('/').last.chars.uniq.each do |l|
+        raise ArgumentError, "Invalid Regexp mode: '#{l}'" unless ignore_invalid || BBLib::REGEXP_MODE_HASH[l.to_sym]
+        mode += (BBLib::REGEXP_MODE_HASH[l.to_sym] || 0)
+      end
+      str = str[0..(str.rindex('/') || -1)]
+    end
+    Regexp.new(str.uncapsulate('/', limit: 1), mode)
+  end
+end
+
+class String
+  def to_regex(*options, ignore_invalid: false)
+    Regexp.from_s(self, *options, ignore_invalid: ignore_invalid)
+  end
+end

data/lib/string/roman.rb

@@ -1,53 +1,48 @@
 
+# frozen_string_literal: true
 module BBLib
-
+  ROMAN_NUMERALS = { 1000 => 'M', 900 => 'CM', 500 => 'D', 400 => 'CD', 100 => 'C', 90 => 'XC', 50 => 'L',
+                     40 => 'XL', 10 => 'X', 9 => 'IX', 5 => 'V', 4 => 'IV', 3 => 'III', 2 => 'II', 1 => 'I' }.freeze
   # Converts any integer up to 1000 to a roman numeral
-  def self.to_roman num
+  def self.to_roman(num)
     return num.to_s if num > 1000
-     roman = {1000 => 'M', 900 => 'CM', 500 => 'D', 400 => 'CD', 100 => 'C', 90 => 'XC', 50 => 'L',
-              40 => 'XL', 10 => 'X', 9 => 'IX', 5 => 'V', 4 => 'IV', 3 => 'III', 2 => 'II', 1 => 'I'}
-    numeral = ""
-    roman.each do |n, r|
+    numeral = ''
+    ROMAN_NUMERALS.each do |n, r|
       while num >= n
-        num-= n
-        numeral+= r
+        num -= n
+        numeral += r
       end
     end
     numeral
   end
 
-  def self.string_to_roman str
+  def self.string_to_roman(str)
     sp = str.split ' '
     sp.map do |s|
       if s.drop_symbols.to_i.to_s == s.drop_symbols && !(s =~ /\d+\.\d+/)
-        s = s.sub(s.scan(/\d+/).first.to_s, BBLib.to_roman(s.to_i))
+        s.sub(s.scan(/\d+/).first.to_s, BBLib.to_roman(s.to_i))
       else
         s
       end
-    end.join ' '
+    end.join(' ')
   end
 
-
-  def self.from_roman str
+  def self.from_roman(str)
     sp = str.split(' ')
     (0..1000).each do |n|
       num = BBLib.to_roman n
-      if !sp.select{ |i| i[/#{num}/i]}.empty?
-        for i in 0..(sp.length-1)
-          if sp[i].drop_symbols.upcase == num
-            sp[i] = sp[i].sub(num ,n.to_s)
-          end
-        end
+      next if sp.select { |i| i[/#{num}/i] }.empty?
+      (0..(sp.length-1)).each do |i|
+        sp[i] = sp[i].sub(num, n.to_s) if sp[i].drop_symbols.upcase == num
       end
     end
     sp.join ' '
   end
-
 end
 
-class Fixnum
+class Integer
   def to_roman
-    BBLib.to_roman self.to_i
+    BBLib.to_roman to_i
   end
 end
 
@@ -56,15 +51,7 @@ class String
     BBLib.from_roman self
   end
 
-  def from_roman!
-    replace self.from_roman
-  end
-
   def to_roman
     BBLib.string_to_roman self
   end
-
-  def to_roman!
-    replace self.to_roman
-  end
 end

data/lib/system/bbsystem.rb

@@ -0,0 +1,42 @@
+module BBLib
+  # A string representation of the command line that evoked this ruby instance (platform agnostic)
+  def self.cmd_line(*args, include_args: true, include_ruby: true, prefix: nil, suffix: nil)
+    args = ARGV if args.empty?
+    include_ruby = false if special_program?
+    "#{prefix}#{include_ruby ? Command.quote(Gem.ruby) : nil} #{Command.quote($PROGRAM_NAME)}" \
+    " #{include_args ? args.map { |a| Command.quote(a) }.join(' ') : nil}#{suffix}"
+      .strip
+  end
+
+  # EXPERIMENTAL: Reloads the original file that was called
+  # Use at your own risk, this could cause some weird issues
+  def self.reload(include_args: true)
+    return false if special_program?
+    load cmd_line(*args, include_ruby: false, include_args: include_args)
+  end
+
+  # EXPERIMENTAL: Restart the ruby process that is currently running.
+  # Use at your own risk
+  def self.restart(*args, include_args: true, stay_alive: 1)
+    exit(0)
+  rescue SystemExit
+    opts = BBLib::OS.windows? ? { new_pgroup: true } : { pgroup: true }
+    pid = spawn(cmd_line(*args, include_args: include_args, prefix: (BBLib::OS.windows? ? 'start ' : nil)), **opts)
+    Process.detach(pid)
+    sleep(stay_alive)
+    exit(0) if special_program?
+  end
+
+  SPECIAL_PROGRAMS = ['pry', 'irb.cmd', 'irb'].freeze
+
+  def self.special_program?
+    SPECIAL_PROGRAMS.include?($PROGRAM_NAME)
+  end
+
+  module Command
+    def self.quote(arg)
+      arg =~ /\s+/ ? "\"#{arg}\"" : arg.to_s
+    end
+  end
+
+end

data/lib/time/bbtime.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
 require_relative 'task_timer'
 require_relative 'cron'
 
 module BBLib
-
   # Parses known time based patterns out of a string to construct a numeric duration.
-  def self.parse_duration str, output: :sec, min_interval: :sec
+  def self.parse_duration(str, output: :sec, min_interval: :sec)
     msecs = 0.0
 
     # Parse time expressions such as 04:05.
@@ -20,7 +20,7 @@ module BBLib
     end
 
     # Parse expressions such as '1m' or '1 min'
-    TIME_EXPS.each do |k, v|
+    TIME_EXPS.each do |_k, v|
       v[:exp].each do |e|
         numbers = str.downcase.scan(/(?=\w|\D|\A)\d*\.?\d+[[:space:]]*#{e}(?=\W|\d|\z)/i)
         numbers.each do |n|
@@ -28,109 +28,130 @@ module BBLib
         end
       end
     end
-
-    msecs / (TIME_EXPS[output][:mult] rescue 1)
+    msecs / TIME_EXPS[output][:mult]
   end
 
   # Turns a numeric input into a time string.
-  def self.to_duration num, input: :sec, stop: :milli, style: :medium
-    return nil unless Numeric === num || num > 0
-    if ![:full, :medium, :short].include?(style) then style = :medium end
+  def self.to_duration(num, input: :sec, stop: :milli, style: :medium)
+    return nil unless num.is_a?(Numeric)
+    return '0' if num.zero?
+    style = :medium unless [:long, :medium, :short].include?(style)
     expression = []
-    n, done = num * TIME_EXPS[input.to_sym][:mult], false
+    n = num * TIME_EXPS[input.to_sym][:mult]
+    done = false
     TIME_EXPS.reverse.each do |k, v|
-      next unless !done
-      if k == stop then done = true end
+      next if done
+      done = true if k == stop
       div = n / v[:mult]
-      if div >= 1
-        val = (done ? div.round : div.floor)
-        expression << "#{val}#{v[:styles][style]}#{val > 1 && style != :short ? "s" : nil}"
-        n-= val.to_f * v[:mult]
-      end
+      next unless div >= 1
+      val = (done ? div.round : div.floor)
+      expression << "#{val}#{v[:styles][style]}#{val > 1 && style != :short ? 's' : nil}"
+      n -= val.to_f * v[:mult]
     end
-    expression.join ' '
+    expression.join(' ')
+  end
+
+  def self.to_nearest_duration(num, input: :sec, style: :medium)
+    n = num * TIME_EXPS[input.to_sym][:mult]
+    stop = nil
+    TIME_EXPS.each do |k, v|
+      stop = k if v[:mult] <= n
+    end
+    stop = :year unless stop
+    to_duration(num, input: input, style: style, stop: stop)
   end
 
   TIME_EXPS = {
     yocto: {
       mult: 0.000000000000000000001,
-      styles: {full: ' yoctosecond', medium: ' yocto', short: 'ys'},
-      exp: ['yoctosecond', 'yocto', 'yoctoseconds', 'yoctos', 'ys']
+      styles: { long: ' yoctosecond', medium: ' yocto', short: 'ys' },
+      exp: %w(yoctosecond yocto yoctoseconds yoctos ys)
     },
     zepto: {
       mult: 0.000000000000000001,
-      styles: {full: ' zeptosecond', medium: ' zepto', short: 'zs'},
-      exp: ['zeptosecond', 'zepto', 'zeptoseconds', 'zeptos', 'zs']
+      styles: { long: ' zeptosecond', medium: ' zepto', short: 'zs' },
+      exp: %w(zeptosecond zepto zeptoseconds zeptos zs)
     },
     atto: {
       mult: 0.000000000000001,
-      styles: {full: ' attosecond', medium: ' atto', short: 'as'},
-      exp: ['attoseconds', 'atto', 'attoseconds', 'attos', 'as']
+      styles: { long: ' attosecond', medium: ' atto', short: 'as' },
+      exp: %w(attoseconds atto attoseconds attos as)
     },
     femto: {
       mult: 0.000000000001,
-      styles: {full: ' femtosecond', medium: ' fempto', short: 'fs'},
-      exp: ['femtosecond', 'fempto', 'femtoseconds', 'femptos', 'fs']
+      styles: { long: ' femtosecond', medium: ' fempto', short: 'fs' },
+      exp: %w(femtosecond fempto femtoseconds femptos fs)
     },
     pico: {
       mult: 0.000000001,
-      styles: {full: ' picosecond', medium: ' pico', short: 'ps'},
-      exp: ['picosecond', 'pico', 'picoseconds', 'picos', 'ps']
+      styles: { long: ' picosecond', medium: ' pico', short: 'ps' },
+      exp: %w(picosecond pico picoseconds picos ps)
     },
     nano: {
       mult: 0.000001,
-      styles: {full: ' nanosecond', medium: ' nano', short: 'ns'},
-      exp: ['nanosecond', 'nano', 'nanoseconds', 'nanos', 'ns']
+      styles: { long: ' nanosecond', medium: ' nano', short: 'ns' },
+      exp: %w(nanosecond nano nanoseconds nanos ns)
     },
     micro: {
       mult: 0.001,
-      styles: {full: ' microsecond', medium: ' micro', short: 'μs'},
-      exp: ['microsecond', 'micro', 'microseconds', 'micros', 'μs']
+      styles: { long: ' microsecond', medium: ' micro', short: 'μs' },
+      exp: %W(microsecond micro microseconds micros \u03BCs)
     },
     milli: {
       mult: 1,
-      styles: {full: ' millisecond', medium: ' mil', short: 'ms'},
-      exp: ['ms', 'mil', 'mils', 'milli', 'millis', 'millisecond', 'milliseconds', 'milsec', 'milsecs', 'msec', 'msecs', 'msecond', 'mseconds']},
+      styles: { long: ' millisecond', medium: ' mil', short: 'ms' },
+      exp: %w(ms mil mils milli millis millisecond milliseconds milsec milsecs msec msecs msecond mseconds)
+    },
     sec: {
       mult: 1000,
-      styles: {full: ' second', medium: ' sec', short: 's'},
-      exp: ['s', 'sec', 'secs', 'second', 'seconds']},
+      styles: { long: ' second', medium: ' sec', short: 's' },
+      exp: %w(s sec secs second seconds)
+    },
     min: {
-      mult: 60000,
-      styles: {full: ' minute', medium: ' min', short: 'm'},
-      exp: ['m', 'mn', 'mns', 'min', 'mins', 'minute', 'minutes']},
+      mult: 60_000,
+      styles: { long: ' minute', medium: ' min', short: 'm' },
+      exp: %w(m mn mns min mins minute minutes)
+    },
     hour: {
-      mult: 3600000,
-      styles: {full: ' hour', medium: ' hr', short: 'h'},
-      exp: ['h', 'hr', 'hrs', 'hour', 'hours']},
+      mult: 3_600_000,
+      styles: { long: ' hour', medium: ' hr', short: 'h' },
+      exp: %w(h hr hrs hour hours)
+    },
     day: {
-      mult: 86400000,
-      styles: {full: ' day', medium: ' day', short: 'd'},
-      exp: ['d', 'day', 'days']},
+      mult: 86_400_000,
+      styles: { long: ' day', medium: ' day', short: 'd' },
+      exp: %w(d day days)
+    },
     week: {
-      mult: 604800000,
-      styles: {full: ' week', medium: ' wk', short: 'w'},
-      exp: ['w', 'wk', 'wks', 'week', 'weeks']},
+      mult: 604_800_000,
+      styles: { long: ' week', medium: ' wk', short: 'w' },
+      exp: %w(w wk wks week weeks)
+    },
     month: {
-      mult: 2592000000,
-      styles: {full: ' month', medium: ' mo', short: 'mo'},
-      exp: ['mo', 'mon', 'mons', 'month', 'months', 'mnth', 'mnths', 'mth', 'mths']},
+      mult: 2_592_000_000,
+      styles: { long: ' month', medium: ' mo', short: 'mo' },
+      exp: %w(mo mon mons month months mnth mnths mth mths)
+    },
     year: {
-      mult: 31536000000,
-      styles: {full: ' year', medium: ' yr', short: 'y'},
-      exp: ['y', 'yr', 'yrs', 'year', 'years']}
-  }
-
+      mult: 31_536_000_000,
+      styles: { long: ' year', medium: ' yr', short: 'y' },
+      exp: %w(y yr yrs year years)
+    }
+  }.freeze
 end
 
 class String
-  def parse_duration output: :sec, min_interval: :sec
-    BBLib.parse_duration self, output:output, min_interval:min_interval
+  def parse_duration(output: :sec, min_interval: :sec)
+    BBLib.parse_duration self, output: output, min_interval: min_interval
   end
 end
 
 class Numeric
-  def to_duration input: :sec, stop: :milli, style: :medium
+  def to_duration(input: :sec, stop: :milli, style: :medium)
     BBLib.to_duration self, input: input, stop: stop, style: style
   end
+
+  def to_nearest_duration(*args)
+    BBLib.to_nearest_duration(self, *args)
+  end
 end

data/lib/time/cron.rb

@@ -1,171 +1,213 @@
+# frozen_string_literal: true
 module BBLib
-
   class Cron
-    attr_reader :exp, :parts, :time
+    include Effortless
+    attr_str :expression, default: '* * * * * *'
+    attr_reader :parts, serialize: false
 
-    def initialize exp = '* * * * * *'
-      @parts   = Hash.new
-      self.exp = exp
+    def next(exp = expression, count: 1, time: Time.now)
+      self.expression = exp unless exp == expression
+      closest(count: count, time: time, direction: 1)
     end
 
-    def closest exp = @exp, direction:1, count: 1, time: Time.now
-      if exp then self.exp = exp end
-      results = []
-      return results unless @exp
-      (1..count).each{ |i| results.push next_time(i == 1 ? time : results.last, direction) }
-      count <= 1 ? results.first : results.reject{ |r| r.nil? }
+    def prev(exp = expression, count: 1, time: Time.now)
+      self.expression = exp unless exp == expression
+      closest(count: count, time: time, direction: -1)
     end
 
-    def next exp = @exp, count: 1, time: Time.now
-      closest exp, count:count, time:time, direction:1
+    def expression=(e)
+      e = e.to_s.downcase
+      SPECIAL_EXP.each { |x, v| e = x if v.include?(e) }
+      @expression = e
+      parse
+      e
     end
 
-    def prev exp = @exp, count: 1, time: Time.now
-      closest exp, count:count, time:time, direction:-1
+    def self.next(exp, count: 1, time: Time.now)
+      BBLib::Cron.new(exp).next(count: count, time: time)
     end
 
-    def exp= e
-      SPECIAL_EXP.each{ |x, v| if v.include?(e) then e = x end }
-      @exp = e
-      parse
+    def self.prev(exp, count: 1, time: Time.now)
+      BBLib::Cron.new(exp).prev(count: count, time: time)
     end
 
-    def self.next exp, count: 1, time: Time.now
-      t = BBLib::Cron.new(exp).next(count:count, time:time)
+    def self.valid?(exp)
+      !(numeralize(exp) =~ /\A(.*?\s){4,5}.*?\S\z/).nil?
     end
 
-    def self.prev exp, count: 1, time: Time.now
-      BBLib::Cron.new(exp).prev(count:count, time:time)
+    def valid?(exp)
+      BBLib::Cron.valid?(exp)
     end
 
-    def self.valid? exp
-      !(numeralize(exp) =~ /\A(.*?\s){4,5}.*?\S\z/).nil?
+    def self.numeralize(exp)
+      REPLACE.each do |k, v|
+        v.each do |r|
+          exp = exp.to_s.gsub(r.to_s, k.to_s)
+        end
+      end
+      exp
     end
 
-    def valid? exp
-      BBLib::Cron.valid?(exp)
+    def time_match?(time)
+      (@parts[:minute].empty? || @parts[:minute].include?(time.min)) &&
+      (@parts[:hour].empty? || @parts[:hour].include?(time.hour)) &&
+      (@parts[:day].empty? || @parts[:day].include?(time.day)) &&
+      (@parts[:weekday].empty? || @parts[:weekday].include?(time.wday)) &&
+      (@parts[:month].empty? || @parts[:month].include?(time.month)) &&
+      (@parts[:year].empty? || @parts[:year].include?(time.year))
     end
 
     private
 
-      def parse
-        return nil unless @exp
-        pieces, i = @exp.split(' '), 0
-        PARTS.each do |part, info|
-          @parts[part] = parse_cron_numbers(pieces[i], info[:min], info[:max], Time.now.send(info[:send]))
-          i+=1
-        end
+    def simple_init(*args)
+      @parts = {}
+      self.expression = args.first if args.first.is_a?(String)
+    end
+
+    def parse
+      @parts = {}
+      PARTS.keys.zip(@expression.split(' ')).to_h.each do |part, piece|
+        info = PARTS[part]
+        @parts[part] = parse_cron_numbers(piece, info[:min], info[:max], Time.now.send(info[:send]))
       end
+    end
 
-      def self.numeralize exp
-        exp = exp.to_s.downcase
-        REPLACE.each do |k, v|
-          v.each do |r|
-            exp = exp.gsub(r.to_s, k.to_s)
-          end
+    def parse_cron_numbers(exp, min, max, qmark)
+      numbers = []
+      return numbers if exp == '*'
+      exp = Cron.numeralize(exp).gsub('?', qmark.to_s).gsub('*', "#{min}-#{max}")
+      exp.scan(/\*\/\d+|\d+\/\d+|\d+-\d+\/\d+/).each do |s|
+        range = s.split('/').first.split('-').map(&:to_i) + [max]
+        divisor = s.split('/').last.to_i
+        Range.new(*range[0..1]).each_with_index do |i, index|
+          numbers.push(i) if index.zero? || (index % divisor).zero?
         end
-        exp
+        exp = exp.sub(s, '')
       end
+      exp.scan(/\d+\-\d+/).each do |e|
+        nums = e.scan(/\d+/).map(&:to_i)
+        numbers.push(Range.new(*nums).to_a)
+      end
+      numbers.push(exp.scan(/\d+/).map(&:to_i))
+      numbers.flatten.uniq.sort.reject { |r| r < min || r > max }
+    end
 
-      def parse_cron_numbers exp, min, max, qmark
-        numbers = Array.new
-        exp     = Cron.numeralize(exp)
-        exp     = exp.gsub('?', qmark.to_s)
-        exp.scan(/\*\/\d+|\d+\/\d+|\d+-\d+\/\d+/).each do |s|
-          range, divisor = s.split('/').first, s.split('/').last.to_i
-          if range == '*'
-            range = (min..max)
-          elsif range =~ /\d+\-\d+/
-            range = (range.split('-').first.to_i..range.split('-').last.to_i)
-          else
-            range = (range.to_i..max)
-          end
-          index = 0
-          range.each do |i|
-            if index == 0 || index % divisor.to_i == 0
-              numbers.push i
-            end
-            index+=1
-          end
-          exp = exp.sub(s, '')
-        end
-        numbers.push exp.scan(/\d+/).map{ |m| m.to_i }
-        exp.strip.scan(/\d+\-\d+/).each do |e|
-          nums = e.scan(/\d+/).map{ |n| n.to_i }
-          numbers.push (nums.min..nums.max).map{ |n| n }
-        end
-        numbers.flatten.sort.uniq.reject{ |r| r < min || r > max }
+    def closest(direction: 1, count: 1, time: Time.now)
+      return unless @expression
+      results = (1..count).flat_map do |_i|
+        time = next_time(time + 60 * direction, direction)
       end
+      count <= 1 ? results.first : results.compact
+    end
 
-      def next_day time, direction
-        return nil unless time
-        weekdays, days, months, years = @parts[:weekday], @parts[:day], @parts[:month], @parts[:year]
-        date, safety = nil, 0
-        while date.nil? && safety < 50000
-          if (days.empty? || days.include?(time.day)) && (months.empty? || months.include?(time.month)) && (years.empty? || years.include?(time.year)) && (weekdays.empty? || weekdays.include?(time.wday))
-            date = time
-          else
-            time+= 24*60*60*direction
-            # time = Time.new(time.year, time.month, time.day, 0, 0)
-          end
-          safety+=1
+    def next_time(time, direction)
+      original = time.dup
+      safety = 0
+      methods = [:next_year, :next_month, :next_weekday, :next_day, :next_hour, :next_min]
+      until safety >= 1_000_000 || time_match?(time)
+        methods.each do |sym|
+          time = send(sym, time, direction)
         end
-        return nil if safety == 50000
-        time
+        safety += 1
       end
+      time - (time.sec.zero? ? 0 : original.sec)
+    end
 
-      def next_time time, direction
-        orig, fw = time.to_f, (direction == 1)
-        current = next_day(time, direction)
-        return nil unless current
-        if (fw ? current.to_f > orig : current.to_f < orig)
-          current = Time.new(current.year, current.month, current.day, (fw ? 0 : 23), (fw ? 0 : 59))
-        else
-          current+= (fw ? 60 : -60)
-        end
-        while !@parts[:day].empty? && !@parts[:day].include?(current.day) || !@parts[:hour].empty? && !@parts[:hour].include?(current.hour) || !@parts[:minute].empty? && !@parts[:minute].include?(current.min)
-          day = [current.day, current.month, current.year]
-          current+= (fw ? 60 : -60)
-          if day != [current.day, current.month, current.year] then current = next_day(current, direction) end
-          return nil unless current
+    def next_min(time, direction)
+      return time if @parts[:minute].empty?
+      time += 60 * direction until @parts[:minute].include?(time.min)
+      time
+    end
+
+    def next_hour(time, direction)
+      return time if @parts[:hour].empty?
+      until @parts[:hour].include?(time.hour)
+        time -= time.min * 60 if direction.positive?
+        time += (59 - time.min) * 60 if direction.negative?
+        time += 60*60 * direction
+      end
+      time
+    end
+
+    def next_day(time, direction)
+      return time if @parts[:day].empty?
+      time += 24*60*60 * direction until @parts[:day].include?(time.day)
+      time
+    end
+
+    def next_weekday(time, direction)
+      return time if @parts[:weekday].empty?
+      time += 24*60*60 * direction until @parts[:weekday].include?(time.wday)
+      time
+    end
+
+    def next_month(time, direction)
+      return time if @parts[:month].empty?
+      until @parts[:month].include?(time.month)
+        original = time.month
+        min      = direction.positive? ? 0 : 59
+        hour     = direction.positive? ? 0 : 23
+        day      = direction.positive? ? 1 : 31
+        month = BBLib.loop_between(time.month + direction, 1, 12)
+        year  = if direction.positive? && month == 1
+                  time.year + 1
+                elsif direction.negative? && month == 12
+                  time.year - 1
+                else
+                  time.year
+                end
+        time  = Time.new(year, month, day, hour, min)
+        if direction.negative? && time.month == original
+          time -= 24 * 60 * 60 while time.month == original
         end
-        current - current.sec
       end
+      time
+    end
 
-      PARTS = {
-        minute:  {send: :min, min:0, max:59, size: 60},
-        hour:    {send: :hour, min:0, max:23, size: 60*60},
-        day:     {send: :day, min:1, max:31, size: 60*60*24},
-        month:   {send: :month, min:1, max:12},
-        weekday: {send: :wday, min:0, max:6},
-        year:    {send: :year, min:0, max:90000}
-      }
-
-      REPLACE = {
-        0  => [:sunday, :sun],
-        1  => [:monday, :mon, :january, :jan],
-        2  => [:tuesday, :tues, :february, :feb],
-        3  => [:wednesday, :wednes, :tue, :march, :mar],
-        4  => [:thursday, :thurs, :wed, :april, :apr],
-        5  => [:friday, :fri, :thu, :may],
-        6  => [:saturday, :sat, :june, :jun],
-        7  => [:july, :jul],
-        8  => [:august, :aug],
-        9  => [:september, :sept, :sep],
-        10 => [:october, :oct],
-        11 => [:november, :nov],
-        12 => [:december, :dec]
-      }
-
-      SPECIAL_EXP = {
-        '0 0 * * * *'  => ['@daily', '@midnight', 'daily', 'midnight'],
-        '0 12 * * * *' => ['@noon', 'noon'],
-        '0 0 * * 0 *'  => ['@weekly', 'weekly'],
-        '0 0 1 * * *'  => ['@monthly', 'monthly'],
-        '0 0 1 1 * *'  => ['@yearly', '@annually', 'yearly', 'annually'],
-        '? ? ? ? ? ?'  => ['@reboot', '@restart', 'reboot', 'restart']
-      }
+    def next_year(time, direction)
+      return time if @parts[:year].empty?
+      until @parts[:year].include?(time.year)
+        day   = direction.positive? ? 1 : 31
+        hour  = direction.positive? ? 0 : 23
+        min   = direction.positive? ? 0 : 59
+        month = direction.positive? ? 1 : 12
+        time  = Time.new(time.year + direction, month, day, hour, min)
+      end
+      time
+    end
 
+    PARTS = {
+      minute:  { send: :min, min: 0, max: 59, size: 60 },
+      hour:    { send: :hour, min: 0, max: 23, size: 60*60 },
+      day:     { send: :day, min: 1, max: 31, size: 60*60*24 },
+      month:   { send: :month, min: 1, max: 12 },
+      weekday: { send: :wday, min: 0, max: 6 },
+      year:    { send: :year, min: 0, max: 3_000 }
+    }.freeze
+
+    REPLACE = {
+      0  => [:sunday, :sun],
+      1  => [:monday, :mon, :january, :jan],
+      2  => [:tuesday, :tues, :february, :feb],
+      3  => [:wednesday, :wednes, :tue, :march, :mar],
+      4  => [:thursday, :thurs, :wed, :april, :apr],
+      5  => [:friday, :fri, :thu, :may],
+      6  => [:saturday, :sat, :june, :jun],
+      7  => [:july, :jul],
+      8  => [:august, :aug],
+      9  => [:september, :sept, :sep],
+      10 => [:october, :oct],
+      11 => [:november, :nov],
+      12 => [:december, :dec]
+    }.freeze
+
+    SPECIAL_EXP = {
+      '0 0 * * * *'  => ['@daily', '@midnight', 'daily', 'midnight'],
+      '0 12 * * * *' => ['@noon', 'noon'],
+      '0 0 * * 0 *'  => ['@weekly', 'weekly'],
+      '0 0 1 * * *'  => ['@monthly', 'monthly'],
+      '0 0 1 1 * *'  => ['@yearly', '@annually', 'yearly', 'annually'],
+      '? ? ? ? ? ?'  => ['@reboot', '@restart', 'reboot', 'restart']
+    }.freeze
   end
-
 end