colonel 0.1.4

data/.gitignore

@@ -0,0 +1,18 @@
+*.rbc
+*.sassc
+.sass-cache
+capybara-*.html
+.rspec
+/.bundle
+/vendor/bundle
+/log/*
+/tmp/*
+/db/*.sqlite3
+/public/system/*
+/coverage/
+/spec/tmp/*
+**.orig
+rerun.txt
+pickle-email-*.html
+.idea/
+.DS_Store

data/.rvmrc

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+rvm_trust_rvmrcs_flag=1
+rvm_gemset_create_on_use_flag=1
+rvm use ruby-1.9.3@colonel

data/.yardopts

@@ -0,0 +1,7 @@
+--markup markdown
+--markup-provider redcarpet
+--charset utf-8
+--readme README.md
+-
+README.md
+LICENSE

data/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+gem 'sinatra'
+gem 'actionpack'
+gem 'shotgun'
+gem 'thin'
+gem 'sqlite3'
+gem 'vegas'
+gem 'rake'
+
+# sinatra extensions
+gem 'sinatra-authorization'
+
+#front-end
+gem 'haml'
+gem 'coffee-script'
+
+# Specify your gem's dependencies in rand.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,66 @@
+PATH
+  remote: .
+  specs:
+    colonel (0.1.4)
+      coffee-script
+      haml
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (2.3.2)
+      activesupport (= 2.3.2)
+    activesupport (2.3.2)
+    coffee-script (2.2.0)
+      coffee-script-source
+      execjs
+    coffee-script-source (1.4.0)
+    daemons (1.1.9)
+    eventmachine (1.0.0)
+    execjs (1.4.0)
+      multi_json (~> 1.0)
+    haml (4.0.0)
+      tilt
+    multi_json (1.6.1)
+    rack (1.5.2)
+    rack-protection (1.3.2)
+      rack
+    rake (10.0.3)
+    redcarpet (1.17.2)
+    shotgun (0.9)
+      rack (>= 1.0)
+    sinatra (1.3.4)
+      rack (~> 1.4)
+      rack-protection (~> 1.3)
+      tilt (~> 1.3, >= 1.3.3)
+    sinatra-authorization (1.0.0)
+      sinatra (>= 0.9.1.1)
+    sqlite3 (1.3.7)
+    thin (1.5.0)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    tilt (1.3.3)
+    vegas (0.1.11)
+      rack (>= 1.0.0)
+    yard (0.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  actionpack
+  coffee-script
+  colonel!
+  haml
+  rake
+  redcarpet (~> 1.17)
+  shotgun
+  sinatra
+  sinatra-authorization
+  sqlite3
+  thin
+  vegas
+  yard (~> 0.7.5)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 santaux
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+Colonel
+=======
+
+Gem for cron jobs editing by web GUI. Web GUI is based on Sinatra, Vegas
+and Twitter Bootstrap.
+
+## Usage
+
+Add colonel to your Gemfile:
+
+    gem 'colonel', :git => 'git@github.com:santaux/colonel.git'
+
+Install it:
+
+    bundle
+
+Run application into your terminal and use:
+
+    bundle exec colonel
+
+Stop application when you want:
+
+    bundle exec colonel -K
+
+Or use it directly through your irb/rails console:
+
+    require 'colonel'
+    builder = Colonel::Builder.new
+    jobs = builder.parse
+
+## Screenshots
+![Jobs list](https://github.com/santaux/colonel/raw/master/screenshots/jobs_list.png "jobs list")
+![Job editing](https://github.com/santaux/colonel/raw/master/screenshots/job_editing.png "job editing")
+![Job deleting](https://github.com/santaux/colonel/raw/master/screenshots/job_deleting.png "job deleting")
+![New job validating](https://github.com/santaux/colonel/raw/master/screenshots/new_job_validating.png "new job validating")

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'yard'
+
+YARD::Rake::YardocTask.new

data/bin/colonel

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+begin
+  require 'vegas'
+rescue LoadError
+  require 'rubygems'
+  require 'vegas'
+end
+require 'colonel/server'
+
+Vegas::Runner.new(Colonel::Server, 'colonel')

data/colonel.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'colonel/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "colonel"
+  gem.version       = Colonel::VERSION
+  gem.authors       = ["santaux"]
+  gem.email         = ["santaux@gmail.com"]
+  gem.description   = %q{Gem for managing cron jobs with web GUI}
+  gem.summary       = %q{Gem for managing cron jobs with web GUI}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "vegas", "~> 0.1.2"
+  gem.add_dependency "sinatra", ">= 0.9.2"
+  gem.add_dependency "haml"
+  gem.add_dependency "coffee-script"
+  gem.add_development_dependency "redcarpet", "~> 1.17"
+  gem.add_development_dependency "yard", "~> 0.7.5"
+end

data/lib/colonel.rb

@@ -0,0 +1,18 @@
+require "colonel/version"
+require 'colonel/array'
+
+# TODO: Rewrite views with helpers
+# TODO: Add ActiveModel methods to classes
+# TODO: Add ability to import/export crontab files
+# TODO: Move it to gem as rails engine
+# TODO: Make import/output of templates
+module Colonel
+  require 'colonel/builder'
+  require 'colonel/crontab'
+  require 'colonel/job'
+  require 'colonel/parser'
+end
+
+class Array
+  include Colonel::Array
+end

data/lib/colonel/array.rb

@@ -0,0 +1,9 @@
+module Colonel
+  module Array
+    %w[second third fourth fifth].each_with_index do |name,index|
+      define_method name do
+        self[index+1]
+      end unless method_defined? name
+    end
+  end
+end

data/lib/colonel/builder.rb

@@ -0,0 +1,55 @@
+# example:
+# builder = Colonel::Builder.new
+# jobs = builder.parse
+module Colonel
+  class Builder
+    def initialize(opts={})
+      Job.clear_amount
+      @all_flag = opts[:all_flag].nil? ? true : opts[:all_flag]
+    end
+
+    def user
+      @_user ||= `whoami`.chomp
+    end
+
+    def crontab
+      @_crontab ||= Crontab.new(user)
+    end
+
+    def parse
+      @jobs ||= []
+      crontab.reject_useless.each do |line|
+        @jobs << Parser.new(line, :all_flag => @all_flag).execute
+      end
+      @jobs
+    end
+
+    def update_crontab
+      crontab.update(@jobs)
+    end
+
+    def find_job(id)
+      @jobs.select { |j| j.id == id.to_i }.first
+    end
+
+    def get_job_index(id)
+      @jobs.each_with_index { |j,i| return i if j.id == id.to_i }
+    end
+
+    # TODO: Refactor it! To complicated!
+    def update_job(opts={})
+      index = get_job_index(opts[:id])
+      job = find_job(opts[:id])
+      @jobs[index] = job.update(opts)
+    end
+
+    def add_job(opts={})
+      @jobs << Job.new( Parser::Schedule.new(opts[:schedule]), Parser::Command.new(opts[:command]))
+    end
+
+    def destroy_job(id)
+      index = get_job_index(id)
+      @jobs.delete_at index
+    end
+  end
+end

data/lib/colonel/crontab.rb

@@ -0,0 +1,73 @@
+require 'tempfile'
+
+module Colonel
+  class Crontab
+    def initialize(user)
+      @user = user
+    end
+
+    def read
+      @tab = `crontab -l`
+    end
+
+    def lines
+      @_lines ||= read.split(/\n/)
+    end
+
+    def reject_useless
+      lines.reject { |line| reject_if_wrong(line) }
+    end
+
+    def reject_if_wrong(line)
+      !line.match /^(\d+|\*)/
+    end
+
+    def update(jobs)
+      update_tab(jobs)
+      write
+    end
+
+    def update_tab(jobs)
+      tab_lines = jobs.map do |j|
+        [
+          TimeCreator.new(
+            minutes:  j.schedule.minutes,
+            hours:    j.schedule.hours,
+            days:     j.schedule.days,
+            months:   j.schedule.months,
+            weekdays: j.schedule.weekdays,
+          ).generate,
+          j.command.get
+        ].join("\t\t\t")
+      end
+      tab_lines
+      @tab = "# --- Updated with Colonel ---\n" + tab_lines.join("\n") + "\n# --- \n"
+    end
+
+    def write_to_temp
+      @tempfile = Tempfile.new("#{@user}_crontab_temp")
+      @tempfile.write(@tab)
+      @tempfile.close
+    end
+
+    def write
+      write_to_temp
+      `crontab #{@tempfile.path}`
+      @tempfile.delete
+    end
+
+    class TimeCreator
+      def initialize(opts={})
+        @minutes = opts[:minutes]
+        @hours = opts[:hours]
+        @days = opts[:days]
+        @months = opts[:months]
+        @weekdays = opts[:weekdays]
+      end
+
+      def generate
+        [@minutes, @hours, @days, @months, @weekdays].map { |t| t.is_a?(Array) ? t.join(",") : t }.join(" ")#.join("\t")
+      end
+    end
+  end
+end

data/lib/colonel/job.rb

@@ -0,0 +1,31 @@
+module Colonel
+  class Job
+
+    attr_reader :id, :schedule, :command
+
+    def initialize(schedule, command)
+      @schedule = schedule
+      @command = command
+
+      increase_amount
+      @id = @@amount
+    end
+
+    def self.clear_amount
+      @@amount = 0
+    end
+
+    def update(opts={})
+      @schedule = Parser::Schedule.new(opts[:schedule])
+      @command  = Parser::Command.new(opts[:command])
+
+      self
+    end
+
+    private
+
+    def increase_amount
+      @@amount = @@amount ? @@amount+1 : 1
+    end
+  end
+end

data/lib/colonel/parser.rb

@@ -0,0 +1,248 @@
+module Colonel
+  class Parser
+
+    SCHEDULE_SIZE = 5
+    PERIOD  = /@hourly|@daily|@weekly|@monthly|@yearly/
+
+    def initialize(text, opts={})
+      @all_flag = opts[:all_flag].nil? ? true : opts[:all_flag]
+      filtered_text = replace_periods(text)
+      @tokens = scan_tokens(filtered_text)
+    end
+
+    def scan_tokens(text)
+      text.scan(/[\S]+/)
+    end
+
+    def replace_periods(text)
+      period = text.scan(PERIOD).first
+      if period
+        time_string = case period
+                        when "@hourly"
+                          "0 * * * *"
+                        when "@daily"
+                          "0 0 * * *"
+                        when "@weekly"
+                          "0 0 * * 0"
+                        when "@monthly"
+                          "0 0 1 * *"
+                        when "@yearly"
+                          "0 0 1 1 *"
+                      end
+        text.gsub(/^(#{PERIOD})/, time_string)
+      else
+        text
+      end
+    end
+
+    def schedule_tokens
+      @tokens.first(SCHEDULE_SIZE)
+    end
+
+    def command_tokens
+      @tokens.last(@tokens.size - SCHEDULE_SIZE)
+    end
+
+    def execute
+      Job.new Schedule.new(schedule_tokens: schedule_tokens, all_flag: @all_flag), Command.new(command_tokens)
+    end
+
+    class Command
+      def initialize(data)
+        if data.is_a?(Array)
+          @command_tokens = data
+        else
+          @_string = data
+        end
+      end
+
+      def get
+        @_string ||= @command_tokens.join(' ')
+      end
+
+      def exist?
+        @_string.size > 0
+      end
+    end
+
+    # Class to store parsed time fields values
+    class Schedule
+
+      def initialize(opts={})
+        @schedule_tokens = opts[:schedule_tokens]
+        @all_flag = opts[:all_flag].nil? ? true : opts[:all_flag]
+
+        @_minutes   = opts[:minutes]
+        @_hours     = opts[:hours]
+        @_days      = opts[:days]
+        @_months    = opts[:months]
+        @_weekdays  = opts[:weekdays]
+      end
+
+      def minutes
+        @_minutes ||= TimeParser.new(@schedule_tokens.first, :minute, @all_flag).result
+      end
+
+      def hours
+        @_hours ||= TimeParser.new(@schedule_tokens.second, :hour, @all_flag).result
+      end
+
+      def days
+        @_days ||= TimeParser.new(@schedule_tokens.third, :day, @all_flag).result
+      end
+
+      def months
+        @_months ||= TimeParser.new(@schedule_tokens.fourth, :month, @all_flag).result
+      end
+
+      def weekdays
+        @_weekdays ||= TimeParser.new(@schedule_tokens.fifth, :weekday, @all_flag).result
+      end
+
+      %w[minutes hours days months weekdays].each do |method|
+        define_method "#{method}_string" do
+          result = send(method)
+          result.is_a?(Array) ? result.join(', ') : result.to_s
+        end
+      end
+    end
+
+    # Class to parse time fields from crontab line.
+    class TimeParser
+      DIGIT   = /\d{1,2}/
+      ALL     = /\*/
+      COMMA   = /\,/
+      DASH    = /\-/
+      RANGE   = /#{DIGIT}#{DASH}#{DIGIT}/
+      DEVIDE  = /#{ALL}\/#{DIGIT}|#{RANGE}\/#{DIGIT}/
+      DEVIDER = /\//
+
+      def tokens
+        @tokens
+      end
+
+      # if all_flag is true -> return :all result if all?
+      def initialize(time_expression, time_type, all_flag=true)
+        @time_type = time_type
+        @tokens = time_expression.scan(/#{COMMA}|#{DEVIDE}|#{RANGE}|#{DIGIT}|#{ALL}/)
+        @all_flag = all_flag
+      end
+
+      def ast
+        @_ast ||= expression
+      end
+
+      def result
+        unique = ast.flatten.uniq
+        unique.pop if unique.last.nil? #remove nil element
+        if all?(unique) && @all_flag
+          :all
+        else
+          unique
+        end
+      end
+
+      def min_time_value
+        @_min_time_value ||= case @time_type
+                               when :minute
+                                 0
+                               when :hour
+                                 0
+                               when :day
+                                 1
+                               when :month
+                                 1
+                               when :weekday
+                                 0
+                             end
+      end
+
+      def max_time_value
+        @_max_time_value ||= case @time_type
+                               when :minute
+                                 59
+                               when :hour
+                                 23
+                               when :day
+                                 31
+                               when :month
+                                 12
+                               when :weekday
+                                 6
+                             end
+      end
+
+      private
+
+      def next_token
+        @tokens.shift
+      end
+
+      def next_token_safe
+        @tokens.first
+      end
+
+      def second_token_safe
+        @tokens.second
+      end
+
+      def expression
+        token = next_token
+
+        case token
+          when nil
+            return nil
+          when DEVIDE
+            return [devide(token), expression]
+          when RANGE
+            return [range(token), expression]
+          when DIGIT
+            return [digit(token), expression]
+          when ALL
+            return [all(token), expression]
+          when COMMA
+            return expression
+          else
+            raise "Unknown token: #{token}!"
+        end
+      end
+
+      def digit(token)
+        return token
+      end
+
+      def all(token)
+        return (min_time_value..max_time_value).to_a
+      end
+
+      def devide(token)
+        case token
+          when /#{RANGE}#{DEVIDER}#{DIGIT}/
+            up, bottom = token.split(DEVIDER)
+            range(up).select do |x|
+              x % bottom.to_i == 0
+            end
+          when /#{ALL}#{DEVIDER}#{DIGIT}/
+            up, bottom = token.split(DEVIDER)
+            (min_time_value..max_time_value).select do |x|
+              x % bottom.to_i == 0
+            end
+        end
+      end
+
+      def range(token)
+        min, max = token.split(DASH)
+        (min..max).to_a
+      end
+
+      def correct?(array)
+        array.all? { |el| el <= max_time_value } and array.all? { |el| el >= min_time_value }
+      end
+
+      def all?(array)
+        array.count-1 == max_time_value-min_time_value
+      end
+
+    end
+  end
+end