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 



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

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

#_dow(i) ⇒ Object 



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

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

#_hou(i) ⇒ Object 



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

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

#_mon(i) ⇒ Object 



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

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

#_mos(i) ⇒ Object 



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

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

#_sorws_dow(i) ⇒ Object 



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

def _sorws_dow(i); alt(nil, i, :h_dow, :sorws_dow); end

#_tz(i) ⇒ Object 



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

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

#_tz_delta(i) ⇒ Object 



463
464
465
 
# File 'lib/fugit/cron.rb', line 463

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

#_tz_name(i) ⇒ Object 



460
461
462
 
# File 'lib/fugit/cron.rb', line 460

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 



468
469
470
 
# File 'lib/fugit/cron.rb', line 468

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

#comma(i) ⇒ Object 



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

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

#core_dom(i) ⇒ Object 



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

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

#core_dow(i) ⇒ Object 



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

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

#core_hou(i) ⇒ Object 



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

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

#core_mon(i) ⇒ Object 



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

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

#core_mos(i) ⇒ Object

min or sec



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

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

#cron(i) ⇒ Object 



475
476
477
 
# File 'lib/fugit/cron.rb', line 475

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

#dom(i) ⇒ Object 



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

def dom(i); core_dom(i); end

#dow(i) ⇒ Object 



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

def dow(i); core_dow(i); end

#dow_hash(i) ⇒ Object 



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

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

#h_dow(i) ⇒ Object 



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

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

#hou(i) ⇒ Object 



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

def hou(i); core_hou(i); end

#hyphen(i) ⇒ Object 



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

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

#ldom_(i) ⇒ Object 



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

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

#lhou_(i) ⇒ Object 



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

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

#list_dom(i) ⇒ Object 



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

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

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



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

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

#list_hou(i) ⇒ Object 



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

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

#list_min(i) ⇒ Object 



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

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

#list_mon(i) ⇒ Object 



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

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

#list_sec(i) ⇒ Object 



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

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

#lmin_(i) ⇒ Object 



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

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

#lmon_(i) ⇒ Object 



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

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

#lsec_(i) ⇒ Object 



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

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

#mon(i) ⇒ Object 



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

def mon(i); core_mon(i); end

#mos(i) ⇒ Object 



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

def mos(i); core_mos(i); end

#r_dom(i) ⇒ Object 



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

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

#r_dow(i) ⇒ Object 



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

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

#r_hou(i) ⇒ Object 



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

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

#r_mon(i) ⇒ Object 



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

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

#r_mos(i) ⇒ Object

r: range



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

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

#rewrite_cron(t) ⇒ Object 



525
526
527
528
529
530
531
532
533
534
535
536
537
 
# File 'lib/fugit/cron.rb', line 525

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 



491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
 
# File 'lib/fugit/cron.rb', line 491

def rewrite_elt(k, t)

  (a, z), others = t
    .subgather(nil)
    .partition { |tt| ![ :hash, :slash ].include?(tt.name) }
  s = others.find { |tt| tt.name == :slash }
  h = others.find { |tt| tt.name == :hash }

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

  a = a ? to_i(k, a) : nil
  z = z ? to_i(k, z) : nil
  a, z = z, a if a && z && a > z

  [ a, z, s ? s.string[1..-1].to_i : nil, h ]
end

#rewrite_entry(t) ⇒ Object 



510
511
512
513
514
515
 
# File 'lib/fugit/cron.rb', line 510

def rewrite_entry(t)

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

#rewrite_tz(t) ⇒ Object 



517
518
519
520
521
522
523
 
# File 'lib/fugit/cron.rb', line 517

def rewrite_tz(t)

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

  [ s, z ]
end

#s(i) ⇒ Object

piece parsers bottom to top



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

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

#second_cron(i) ⇒ Object 



471
472
473
 
# File 'lib/fugit/cron.rb', line 471

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

#slash(i) ⇒ Object 



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

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

#sor_dom(i) ⇒ Object 



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

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

#sor_dow(i) ⇒ Object 



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

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

#sor_hou(i) ⇒ Object 



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

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

#sor_mon(i) ⇒ Object 



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

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

#sor_mos(i) ⇒ Object

sor: star or range



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

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

#sorws_dom(i) ⇒ Object 



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

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

#sorws_dow(i) ⇒ Object 



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

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

#sorws_hou(i) ⇒ Object 



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

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

#sorws_mon(i) ⇒ Object 



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

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

#sorws_mos(i) ⇒ Object

sorws: star or range with slash



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

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

#star(i) ⇒ Object 



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

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

#to_i(k, t) ⇒ Object

rewriting the parsed tree



481
482
483
484
485
486
487
488
489
 
# File 'lib/fugit/cron.rb', line 481

def to_i(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