Module: Fugit::Cron::Parser

Includes:
Raabro
Defined in:
lib/fugit/cron.rb

Constant Summary collapse

WEEKDAYS = 
%w[ sunday monday tuesday wednesday thursday friday saturday ]
WEEKDS = 
WEEKDAYS.collect { |d| d[0, 3] }
MONTHS = 
%w[ - jan feb mar apr may jun jul aug sep oct nov dec ]

Instance Method Summary collapse

Instance Method Details

#_dom(i) ⇒ Object 



618
 
# File 'lib/fugit/cron.rb', line 618

def _dom(i); seq(nil, i, :hyphen, :dom); end

#_dow(i) ⇒ Object 



620
 
# File 'lib/fugit/cron.rb', line 620

def _dow(i); seq(nil, i, :hyphen, :dow); end

#_hou(i) ⇒ Object 



617
 
# File 'lib/fugit/cron.rb', line 617

def _hou(i); seq(nil, i, :hyphen, :hou); end

#_mon(i) ⇒ Object 



619
 
# File 'lib/fugit/cron.rb', line 619

def _mon(i); seq(nil, i, :hyphen, :mon); end

#_mos(i) ⇒ Object 



616
 
# File 'lib/fugit/cron.rb', line 616

def _mos(i); seq(nil, i, :hyphen, :mos); end

#_tz(i) ⇒ Object 



677
 
# File 'lib/fugit/cron.rb', line 677

def _tz(i); alt(:tz, i, :_tz_delta, :_tz_name); end

#_tz_delta(i) ⇒ Object 



674
675
676
 
# File 'lib/fugit/cron.rb', line 674

def _tz_delta(i)
  rex(nil, i, / +[-+]([01][0-9]|2[0-4]):?(00|15|30|45)/)
end

#_tz_name(i) ⇒ Object 



671
672
673
 
# File 'lib/fugit/cron.rb', line 671

def _tz_name(i)
  rex(nil, i, / +[A-Z][a-zA-Z0-9+\-]+(\/[A-Z][a-zA-Z0-9+\-_]+){0,2}/)
end

#classic_cron(i) ⇒ Object 



679
680
681
 
# File 'lib/fugit/cron.rb', line 679

def classic_cron(i)
  seq(:ccron, i, :lmin_, :lhou_, :ldom_, :lmon_, :ldow, :_tz, '?')
end

#comma(i) ⇒ Object 



604
 
# File 'lib/fugit/cron.rb', line 604

def comma(i); str(nil, i, ','); end

#cron(i) ⇒ Object 



686
687
688
 
# File 'lib/fugit/cron.rb', line 686

def cron(i)
  alt(:cron, i, :second_cron, :classic_cron)
end

#dom(i) ⇒ Object 



610
 
# File 'lib/fugit/cron.rb', line 610

def dom(i); rex(:dom, i, /(-?(3[01]|[12][0-9]|0?[1-9])|last|l)/i); end

#dom_elt(i) ⇒ Object 



646
 
# File 'lib/fugit/cron.rb', line 646

def dom_elt(i); alt(:elt, i, :slash, :sorws_dom); end

#dow(i) ⇒ Object 



612
 
# File 'lib/fugit/cron.rb', line 612

def dow(i); rex(:dow, i, /([0-7]|#{WEEKDS.join('|')})/i); end

#dow_elt(i) ⇒ Object 



648
 
# File 'lib/fugit/cron.rb', line 648

def dow_elt(i); alt(:elt, i, :slash, :sorws_dow); end

#dow_elt_(i) ⇒ Object 



655
 
# File 'lib/fugit/cron.rb', line 655

def dow_elt_(i); alt(nil, i, :h_dow, :mod_dow, :dow_elt); end

#dow_hash(i) ⇒ Object 



614
 
# File 'lib/fugit/cron.rb', line 614

def dow_hash(i); rex(:hash, i, /#(-?[1-5]|last|l)/i); end

#h_dow(i) ⇒ Object 



653
 
# File 'lib/fugit/cron.rb', line 653

def h_dow(i); seq(:elt, i, :dow, :dow_hash); end

#hou(i) ⇒ Object 



609
 
# File 'lib/fugit/cron.rb', line 609

def hou(i); rex(:hou, i, /(2[0-4]|[01]?[0-9])/); end

#hou_elt(i) ⇒ Object 



645
 
# File 'lib/fugit/cron.rb', line 645

def hou_elt(i); alt(:elt, i, :slash, :sorws_hou); end

#hyphen(i) ⇒ Object 



603
 
# File 'lib/fugit/cron.rb', line 603

def hyphen(i); str(nil, i, '-'); end

#ldom_(i) ⇒ Object 



667
 
# File 'lib/fugit/cron.rb', line 667

def ldom_(i); seq(nil, i, :list_dom, :s); end

#lhou_(i) ⇒ Object 



666
 
# File 'lib/fugit/cron.rb', line 666

def lhou_(i); seq(nil, i, :list_hou, :s); end

#list_dom(i) ⇒ Object 



660
 
# File 'lib/fugit/cron.rb', line 660

def list_dom(i); jseq(:dom, i, :dom_elt, :comma); end

#list_dow(i) ⇒ Object Also known as: ldow 



662
 
# File 'lib/fugit/cron.rb', line 662

def list_dow(i); jseq(:dow, i, :dow_elt_, :comma); end

#list_hou(i) ⇒ Object 



659
 
# File 'lib/fugit/cron.rb', line 659

def list_hou(i); jseq(:hou, i, :hou_elt, :comma); end

#list_min(i) ⇒ Object 



658
 
# File 'lib/fugit/cron.rb', line 658

def list_min(i); jseq(:min, i, :mos_elt, :comma); end

#list_mon(i) ⇒ Object 



661
 
# File 'lib/fugit/cron.rb', line 661

def list_mon(i); jseq(:mon, i, :mon_elt, :comma); end

#list_sec(i) ⇒ Object 



657
 
# File 'lib/fugit/cron.rb', line 657

def list_sec(i); jseq(:sec, i, :mos_elt, :comma); end

#lmin_(i) ⇒ Object 



665
 
# File 'lib/fugit/cron.rb', line 665

def lmin_(i); seq(nil, i, :list_min, :s); end

#lmon_(i) ⇒ Object 



668
 
# File 'lib/fugit/cron.rb', line 668

def lmon_(i); seq(nil, i, :list_mon, :s); end

#lsec_(i) ⇒ Object 



664
 
# File 'lib/fugit/cron.rb', line 664

def lsec_(i); seq(nil, i, :list_sec, :s); end

#mod(i) ⇒ Object 



650
 
# File 'lib/fugit/cron.rb', line 650

def mod(i); rex(:mod, i, /%\d+(\+\d+)?/); end

#mod_dow(i) ⇒ Object 



652
 
# File 'lib/fugit/cron.rb', line 652

def mod_dow(i); seq(:elt, i, :dow, :mod); end

#mon(i) ⇒ Object 



611
 
# File 'lib/fugit/cron.rb', line 611

def mon(i); rex(:mon, i, /(1[0-2]|0?[1-9]|#{MONTHS[1..-1].join('|')})/i); end

#mon_elt(i) ⇒ Object 



647
 
# File 'lib/fugit/cron.rb', line 647

def mon_elt(i); alt(:elt, i, :slash, :sorws_mon); end

#mos(i) ⇒ Object

min or sec



608
 
# File 'lib/fugit/cron.rb', line 608

def mos(i); rex(:mos, i, /[0-5]?\d/); end

#mos_elt(i) ⇒ Object

ssws: slash or sorws



644
 
# File 'lib/fugit/cron.rb', line 644

def mos_elt(i); alt(:elt, i, :slash, :sorws_mos); end

#r_dom(i) ⇒ Object 



625
 
# File 'lib/fugit/cron.rb', line 625

def r_dom(i); seq(nil, i, :dom, :_dom, '?'); end

#r_dow(i) ⇒ Object 



627
 
# File 'lib/fugit/cron.rb', line 627

def r_dow(i); seq(nil, i, :dow, :_dow, '?'); end

#r_hou(i) ⇒ Object 



624
 
# File 'lib/fugit/cron.rb', line 624

def r_hou(i); seq(nil, i, :hou, :_hou, '?'); end

#r_mon(i) ⇒ Object 



626
 
# File 'lib/fugit/cron.rb', line 626

def r_mon(i); seq(nil, i, :mon, :_mon, '?'); end

#r_mos(i) ⇒ Object

r: range



623
 
# File 'lib/fugit/cron.rb', line 623

def r_mos(i); seq(nil, i, :mos, :_mos, '?'); end

#rewrite_bound(k, t) ⇒ Object

rewriting the parsed tree



692
693
694
695
696
697
698
699
700
 
# File 'lib/fugit/cron.rb', line 692

def rewrite_bound(k, t)

  s = t.string.downcase

  (k == :mon && MONTHS.index(s)) ||
  (k == :dow && WEEKDS.index(s)) ||
  ((k == :dom) && s[0, 1] == 'l' && -1) || # L, l, last
  s.to_i
end

#rewrite_cron(t) ⇒ Object 



753
754
755
756
757
758
759
760
761
762
763
764
765
 
# File 'lib/fugit/cron.rb', line 753

def rewrite_cron(t)

  hcron = t
    .sublookup(nil) # go to :ccron or :scron
    .subgather(nil) # list min, hou, mon, ...
    .inject({}) { |h, tt|
      h[tt.name] = tt.name == :tz ? rewrite_tz(tt) : rewrite_entry(tt)
      h }

  z, tz = hcron[:tz]; return nil if z && ! tz

  hcron
end

#rewrite_elt(k, t) ⇒ Object 



710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
 
# File 'lib/fugit/cron.rb', line 710

def rewrite_elt(k, t)

  at, zt, slt, hat, mot = nil; t.subgather(nil).each do |tt|
    case tt.name
    when :slash then slt = tt
    when :hash then hat = tt
    when :mod then mot = tt
    else if at; zt ||= tt; else; at = tt; end
    end
  end

  sl = slt ? slt.string[1..-1].to_i : nil

  ha = hat ? hat.string[1..-1] : nil
  ha = -1 if ha && ha.upcase[0, 1] == 'L'
  ha = ha.to_i if ha

  mo = mot ? rewrite_mod(k, mot) : nil

  a = at ? rewrite_bound(k, at) : nil
  z = zt ? rewrite_bound(k, zt) : nil

  #a, z = z, a if a && z && a > z
    # handled downstream since gh-27

  [ a, z, sl, ha, mo ]
end

#rewrite_entry(t) ⇒ Object 



738
739
740
741
742
743
 
# File 'lib/fugit/cron.rb', line 738

def rewrite_entry(t)

  t
    .subgather(:elt)
    .collect { |et| rewrite_elt(t.name, et) }
end

#rewrite_mod(k, t) ⇒ Object 



702
703
704
705
706
707
708
 
# File 'lib/fugit/cron.rb', line 702

def rewrite_mod(k, t)

  mod, plus = t.string
    .split(/[%+]/).reject(&:empty?).collect(&:to_i)

  [ mod, plus || 0 ]
end

#rewrite_tz(t) ⇒ Object 



745
746
747
748
749
750
751
 
# File 'lib/fugit/cron.rb', line 745

def rewrite_tz(t)

  s = t.string.strip
  z = EtOrbi.get_tzone(s)

  [ s, z ]
end

#s(i) ⇒ Object

piece parsers bottom to top



601
 
# File 'lib/fugit/cron.rb', line 601

def s(i); rex(nil, i, /[ \t]+/); end

#second_cron(i) ⇒ Object 



682
683
684
 
# File 'lib/fugit/cron.rb', line 682

def second_cron(i)
  seq(:scron, i, :lsec_, :lmin_, :lhou_, :ldom_, :lmon_, :ldow, :_tz, '?')
end

#slash(i) ⇒ Object 



606
 
# File 'lib/fugit/cron.rb', line 606

def slash(i); rex(:slash, i, /\/\d\d?/); end

#sor_dom(i) ⇒ Object 



632
 
# File 'lib/fugit/cron.rb', line 632

def sor_dom(i); alt(nil, i, :star, :r_dom); end

#sor_dow(i) ⇒ Object 



634
 
# File 'lib/fugit/cron.rb', line 634

def sor_dow(i); alt(nil, i, :star, :r_dow); end

#sor_hou(i) ⇒ Object 



631
 
# File 'lib/fugit/cron.rb', line 631

def sor_hou(i); alt(nil, i, :star, :r_hou); end

#sor_mon(i) ⇒ Object 



633
 
# File 'lib/fugit/cron.rb', line 633

def sor_mon(i); alt(nil, i, :star, :r_mon); end

#sor_mos(i) ⇒ Object

sor: star or range



630
 
# File 'lib/fugit/cron.rb', line 630

def sor_mos(i); alt(nil, i, :star, :r_mos); end

#sorws_dom(i) ⇒ Object 



639
 
# File 'lib/fugit/cron.rb', line 639

def sorws_dom(i); seq(nil, i, :sor_dom, :slash, '?'); end

#sorws_dow(i) ⇒ Object 



641
 
# File 'lib/fugit/cron.rb', line 641

def sorws_dow(i); seq(nil, i, :sor_dow, :slash, '?'); end

#sorws_hou(i) ⇒ Object 



638
 
# File 'lib/fugit/cron.rb', line 638

def sorws_hou(i); seq(nil, i, :sor_hou, :slash, '?'); end

#sorws_mon(i) ⇒ Object 



640
 
# File 'lib/fugit/cron.rb', line 640

def sorws_mon(i); seq(nil, i, :sor_mon, :slash, '?'); end

#sorws_mos(i) ⇒ Object

sorws: star or range with slash



637
 
# File 'lib/fugit/cron.rb', line 637

def sorws_mos(i); seq(nil, i, :sor_mos, :slash, '?'); end

#star(i) ⇒ Object 



602
 
# File 'lib/fugit/cron.rb', line 602

def star(i); str(nil, i, '*'); end