winever 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in winever.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Maxime Handfield Lapointe
+
+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,66 @@
+# Winever
+
+Winever is a gem that adds features to the [whenever](https://github.com/javan/whenever) gem, making it also compatible
+with Windows, without breaking anything when using Whenever only.
+
+Winever creates and removes tasks in the Windows task scheduler using [win32-taskscheduler](https://github.com/djberg96/win32-taskscheduler).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'winever'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install
+
+## Usage
+
+Winever adds the command `winever` which behaves similarly to `whenever`.
+
+You can use `winever` without parameters to list a "cron file" using an internal syntax. It will tell you which of the
+jobs of your schedule are supported and which ones aren't. Just like with Whenever, you can use `winever -i` to install/update
+the jobs on your Windows machine and `winever -c` to remove them.
+
+Winever creates tasks in Windows' task scheduler. In order for a job to be compatible with Winever, it needs to have an
+additional option: task_name. Note that this task_name will have an identifier (similar to Whenever's comment in the crontab)
+added as suffix to enable Winever to remove old tasks when needed.
+
+```ruby
+every 1.day, at: '00:30 am' do
+  rake 'my_backup_task', :task_name => 'MyAppBackup'
+end
+```
+
+If you define new job_types in your schedule. Then you will need to define them differently for Winever. To do so, first add
+`require 'winever'` to the top of your schedule file. This will add the function `winever?` to your schedule, which you can
+use to define some tasks only for Windows or for Linux, and to define a job_type differently for Whenever and for Winever.
+This is the basic line for create a job_type for Winever.
+
+```ruby
+if winever?
+  job_type :something, ":task_folder|:task_name|:path|command_you_want_executed_here :output"
+else
+  job_type :something, "cd :path && command_you_want_executed_here :output"
+end
+```
+
+The pipes (|) are important, so make sure not to remove any.
+If your task doesn't need to be run in the folder of your application (like the existing job_type "command" of Whenever),
+then remove the :path (leaving the pipes around it intact).
+
+As of right now the only type of schedule that is supported are the daily ones (run once per day, at a specific time, every day).
+Pull requests welcomed to add more, cron_entry.rb should be the only file needing edit for that.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/winever

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'winever'
+require 'optparse'
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: whenever [options]"
+  opts.on('-i', '--update [identifier]', 'Default: full path to schedule.rb file') do |identifier|
+    options[:update] = true
+    options[:identifier] = identifier if identifier
+  end
+  opts.on('-c', '--clear [identifier]') do |identifier|
+    options[:clear] = true
+    options[:identifier] = identifier if identifier
+  end
+  opts.on('-s', '--set [variables]', 'Example: --set \'environment=staging&path=/my/sweet/path\'') do |set|
+    options[:set] = set if set
+  end
+  opts.on('-f', '--load-file [schedule file]', 'Default: config/schedule.rb') do |file|
+    options[:file] = file if file
+  end
+  opts.on('-k', '--cut [lines]', 'Cut lines from the top of the cronfile') do |lines|
+    options[:cut] = lines.to_i if lines
+  end
+  opts.on('-v', '--version') { puts "Winever v#{Winever::VERSION}"; exit(0) }
+end.parse!
+
+Winever::CommandLine.execute(options)

data/lib/winever.rb

@@ -0,0 +1,20 @@
+require 'winever/version'
+require 'whenever'
+
+# A very tiny monkey patch of whatever, adding a function useable in the schedule to know if this is going through winever.
+module Whenever
+  class JobList
+    # We are running from winever
+    def winever?
+      Winever::WheneverInterface.run_from_winever?
+    end
+  end
+end
+
+
+module Winever
+  autoload :CommandLine, 'winever/command_line'
+  autoload :CronEntry, 'winever/cron_entry'
+  autoload :TaskManager, 'winever/task_manager'
+  autoload :WheneverInterface, 'winever/whenever_interface'
+end

data/lib/winever/command_line.rb

@@ -0,0 +1,54 @@
+module Winever
+  class CommandLine
+    def self.execute options={}
+      new(options).run
+    end
+
+    def initialize options={}
+      @options = options
+
+      @options[:file]       ||= 'config/schedule.rb'
+      @options[:cut]        ||= 0
+      @options[:identifier] ||= default_identifier
+
+      unless File.exists?(@options[:file])
+        warn("[fail] Can't find file: #{@options[:file]}")
+        exit(1)
+      end
+
+      if [@options[:update], @options[:clear]].compact.length > 1
+        warn("[fail] Can only update or clear. Choose one.")
+        exit(1)
+      end
+
+      unless @options[:cut].to_s =~ /[0-9]*/
+        warn("[fail] Can't cut negative lines from the crontab #{options[:cut]}")
+        exit(1)
+      end
+      @options[:cut] = @options[:cut].to_i
+    end
+
+
+    def run
+      if @options[:update]
+        Winever::TaskManager.update_tasks(@options)
+      elsif @options[:clear]
+        Winever::TaskManager.clear_tasks(@options)
+      else
+        puts Winever::WheneverInterface.cron(@options)
+        puts "## [message] Above is your schedule file converted to cron-winever syntax; your crontab  file /scheduled tasks were not updated."
+        puts "## [message] Run `winever --help' for more options."
+        exit(0)
+      end
+    end
+
+    #protected
+
+    def default_identifier
+      File.expand_path(@options[:file])
+    end
+
+  end
+
+
+end

data/lib/winever/cron_entry.rb

@@ -0,0 +1,58 @@
+module Winever
+  class CronEntry
+    attr_accessor :cron_time, :task_folder, :task_name, :working_directory, :parameters, :cron_line
+
+    def self.from_cron_output cron_output, include_invalid=false
+      entries = cron_output.split("\n").select(&:present?).map{|o| new(o)}
+      entries = entries.select(&:valid?) unless include_invalid
+      entries
+    end
+
+    def triggers
+      # For now, we don't support anything other than specific time.
+      # But it is possible to handle almost all cron schedule options in the task scheduler of Windows.
+      # It doesn't help that win32-taskscheduler also seems to only support one trigger per task.
+      return [] unless valid_triggers?
+
+      cron_minute, cron_hour, cron_day, cron_month, cron_dow = @cron_time_parts
+      trigger = {
+          :start_year => Date.today.year,
+          :start_month => Date.today.month,
+          :start_day => Date.today.day,
+          :start_hour => cron_hour.to_i,
+          :start_minute => cron_minute.to_i,
+          :trigger_type => Win32::TaskScheduler::TASK_TIME_TRIGGER_DAILY
+      }
+
+      [trigger]
+    end
+
+    def initialize(cron_line)
+      @cron_line = cron_line
+      @cron_parts = cron_line.split("|", 5)
+      @cron_time, @task_folder, @task_name, @working_directory, @parameters = @cron_parts
+      @cron_time_parts = @cron_time.split(/ +/)
+    end
+
+    def valid?
+      invalid_reason.nil?
+    end
+
+    def valid_triggers?
+      return false if @cron_time_parts.length < 5
+      cron_minute, cron_hour, cron_day, cron_month, cron_dow = @cron_time_parts
+
+      return false if [cron_day, cron_month, cron_dow].detect{|v| v != '*'}
+      return false if [cron_minute, cron_hour].detect{|v| (v =~ /^\d+$/).nil? }
+
+      true
+    end
+
+    def invalid_reason
+      return "Doesn't match the Winever format" unless @cron_parts.length == 5
+      return "Doesn't have a task_name specified" unless @task_name.present?
+      return "The schedule is either invalid or not supported" unless valid_triggers?
+      nil
+    end
+  end
+end

data/lib/winever/setup_schedule.rb

@@ -0,0 +1,13 @@
+
+if winever?
+  set :job_template, "|:job"
+
+  # Overwrite to put tasks in a different subfolder of the task scheduler.
+  # Right now, anything other than \\ will break clear_tasks, so don't change folder for now.
+  set :task_folder, "\\"
+
+  job_type :command, ":task_folder|:task_name||:task :output"
+  job_type :rake,    ":task_folder|:task_name|:path|:bundle_command rake :task --silent :environment_variable=:environment :output"
+  job_type :script,  ":task_folder|:task_name|:path|:bundle_command script/:task :environment_variable=:environment :output"
+  job_type :runner,  ":task_folder|:task_name|:path|:runner_command -e :environment ':task' :output"
+end

data/lib/winever/task_manager.rb

@@ -0,0 +1,158 @@
+module Winever
+  class TaskManager
+    def self.has_task_scheduler?
+      return @has_task_scheduler unless @has_task_scheduler.nil?
+      begin
+        require 'win32/taskscheduler'
+        @has_task_scheduler = true
+      rescue LoadError => e
+        @has_task_scheduler = false
+      end
+      @has_task_scheduler
+    end
+
+    def has_task_scheduler?
+      self.class.has_task_scheduler?
+    end
+
+    def self.clear_tasks options={}
+      new(options).clear_tasks_except
+    end
+
+    def self.update_tasks options={}
+      new(options).update_tasks
+    end
+
+    def initialize options={}
+      if !has_task_scheduler?
+        raise "Cannot use win32/taskscheduler on this system. Are you on windows?"
+      end
+
+      @options = options
+    end
+
+    def password
+      return @password.presence if @password
+      require 'highline/import'
+      prompt = <<-PRMP.gsub(/^ +/, '')
+        To setup tasks correctly, the password of the current user account is needed.
+        You can leave it empty, but without the password, the task will only be run the user is logged on and will open a black
+        console window while running.
+        You can manually go edit the scheduled task to add the password manually if you prefer not to give it to Winever, but you will need to go do that every time you edit the tasks through Winever, for each task.
+        Enter the password of the current user (or just press enter to skip):
+      PRMP
+
+      pw = ask(prompt){|q| q.echo = false}
+      while pw.present? && !validate_password(pw)
+        prompt = <<-PRMP.gsub(/^ +/, '')
+          Invalid password entered.
+          Enter the password of the current user (or just press enter to skip):
+        PRMP
+        pw = ask(prompt){|q| q.echo = false}
+      end
+
+
+      #TODO get the password somehow.
+      # require File.expand_path('../../extensions/password', __FILE__)
+      # password = Password.ask("Enter password for current user account of the machine to setup tasks: ")
+      # validate_password(password)
+
+      @password = pw
+      pw.presence
+    end
+
+    def create_tasks
+      cron_entries = Winever::WheneverInterface.valid_cron_entries(@options)
+
+      created_task_names = []
+      cron_entries.each do |cron_entry|
+        created_task_names << create_task(cron_entry)
+      end
+      created_task_names
+    end
+
+    def update_tasks
+      task_names = create_tasks
+      clear_tasks_except(task_names)
+    end
+
+    def clear_tasks_except keep_tasks=[]
+      ts = Win32::TaskScheduler.new
+      task_names = ts.tasks.select{|tn| tn.end_with?('.' + identifier)}
+      task_names = task_names.reject{|tn| keep_tasks.include?(tn)}
+
+      task_names.each{|tn| ts.delete(tn)}
+    end
+
+    def create_task cron_entry
+      task_name = generate_task_name(cron_entry.task_name)
+
+      # Replacing the /dev/null by NUL
+      parameters = cron_entry.parameters.gsub(/([\s'"])\/dev\/null([\s'"])/, '\1NUL\2')
+
+      pw = password
+      trigger = cron_entry.triggers.first
+      work_directory = cron_entry.working_directory
+
+      ts = Win32::TaskScheduler.new(nil, nil, cron_entry.task_folder, true)
+      begin
+        ts.password = pw
+        ts.new_work_item(task_name, trigger)
+        ts.application_name = 'cmd'
+        ts.parameters = '/C ' + parameters
+        ts.working_directory = work_directory
+        ts.activate(task_name)
+      rescue
+        raise 'Failed at setting the task up. It might have been partially created/updated. This most likely means a bad password was entered.'
+      end
+
+      task_name
+    end
+
+    def generate_task_name task_name
+      "#{task_name}.#{identifier}"
+    end
+
+    def identifier
+      # Removing the characters blocked by the windows file system. The single quote is just for simplicity.
+      iden = @options[:identifier].gsub(/[:\/\\<>:"|?*']/, '_')
+      raise 'Identifier must contain at least one letter or number.' unless iden =~ /\w/
+      iden
+    end
+
+    def validate_password password
+      # Validate a password by trying to create a task with it. If it fails, then the password is wrong.
+      # Will delete the created task after.
+      ts = Win32::TaskScheduler.new
+      base_test_task_name = test_task_name = "Winever_test_task"
+      i = 0
+      while ts.exists?(test_task_name)
+        i += 1
+        test_task_name = "#{base_test_task_name}_#{i}"
+      end
+
+      trigger = { :start_year   => 2000,
+                  :start_month  => 6,
+                  :start_day    => 12,
+                  :start_hour   => 13,
+                  :start_minute => 17,
+                  :trigger_type => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE}
+
+      ts.new_work_item(test_task_name, trigger)
+      valid = false
+      begin
+        ts.password = password
+        ts.application_name = "cmd"
+        valid = true
+      rescue
+        ts.password = nil
+        valid = false
+      end
+      ts.delete(test_task_name)
+
+      return valid
+    end
+
+  end
+
+end

data/lib/winever/version.rb

@@ -0,0 +1,3 @@
+module Winever
+  VERSION = "0.1.0"
+end

data/lib/winever/whenever_interface.rb

@@ -0,0 +1,64 @@
+module Winever
+  module WheneverInterface
+    def self.run_from_winever?
+      @run_from_winever || false
+    end
+
+    def self.raw_cron options={}
+      # The output of whenever with the custom job_types and job_template.
+      options[:file]       ||= 'config/schedule.rb'
+      options[:cut]        ||= 0
+      options[:identifier] ||= File.expand_path(options[:file])
+
+      schedule = if options[:string]
+                   options[:string]
+                 elsif options[:file]
+                   File.read(options[:file])
+                 end
+
+      # Prepending out own setup for the schedule to override the existing job_types and job_template.
+      options[:string] = File.read(File.dirname(__FILE__)+"/setup_schedule.rb") + "\n" + schedule
+
+      @run_from_winever = true
+      output = Whenever.cron(options)
+      @run_from_winever = false
+      output
+    end
+
+    def self.valid_cron_entries options={}
+      # Array of CronEntry containing only the entry that we support.
+      Winever::CronEntry.from_cron_output(raw_cron(options))
+    end
+
+    def self.all_cron_entries options={}
+      # Array of CronEntry containing only the entry that we support.
+      Winever::CronEntry.from_cron_output(raw_cron(options), true)
+    end
+
+    def self.cron options={}
+      entries = all_cron_entries(options)
+      valid_entries = entries.select(&:valid?)
+      invalid_entries = entries.reject(&:valid?)
+
+
+      output = "# Valid tasks for Winever in internal format:\n"
+      if valid_entries.present?
+        output << valid_entries.map(&:cron_line).join("\n\n")
+      else
+        output << "No valid entries"
+      end
+      output << "\n\n"
+
+      if invalid_entries.present?
+        output << "\n# Invalid entries for Winever in internal format:\n"
+        invalid_entries.each do |invalid_entry|
+          output << "# #{invalid_entry.invalid_reason}\n"
+          output << "#{invalid_entry.cron_line}\n\n"
+        end
+      end
+      output
+    end
+  end
+
+
+end

data/winever.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'winever/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "winever"
+  spec.version       = Winever::VERSION
+  spec.authors       = ["Maxime Handfield Lapointe"]
+  spec.email         = ["hunter_spawn@hotmail.com"]
+  spec.description   = %q{Make it possible to use the Whenever gem's clean ruby syntax for writing and deploying tasks in the windows scheduler, using the same schedule file.}
+  spec.summary       = %q{Make it possible to use the Whenever gem on Windows.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "whenever", ">= 0.9.1"
+  spec.add_dependency "highline", ">= 0.5.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: winever
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Maxime Handfield Lapointe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: whenever
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Make it possible to use the Whenever gem's clean ruby syntax for writing
+  and deploying tasks in the windows scheduler, using the same schedule file.
+email:
+- hunter_spawn@hotmail.com
+executables:
+- winever
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/winever
+- lib/winever.rb
+- lib/winever/command_line.rb
+- lib/winever/cron_entry.rb
+- lib/winever/setup_schedule.rb
+- lib/winever/task_manager.rb
+- lib/winever/version.rb
+- lib/winever/whenever_interface.rb
+- winever.gemspec
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2189449078382166788
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2189449078382166788
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Make it possible to use the Whenever gem on Windows.
+test_files: []