win32-taskscheduler 2.0.1 → 2.0.4

data/Gemfile

@@ -1,3 +0,0 @@
-source "https://rubygems.org"
-
-gemspec

data/README.md

@@ -1,78 +0,0 @@
-# Description
-
-[![Gem Version](https://badge.fury.io/rb/win32-taskscheduler.svg)](https://badge.fury.io/rb/win32-taskscheduler)
-
-The win32-taskscheduler library is a Ruby interface to the MS Windows Task Scheduler. It is analogous to the Unix cron daemon.
-
-# Installation
-
-```
-gem install win32-taskscheduler
-```
-
-# Synopsis
-
-```ruby
-require 'win32/taskscheduler'
-include Win32
-
-ts = TaskScheduler.new
-
-# Create a trigger that starts on April 25, 2014 at 11:05 pm. The trigger
-# will run on the first and last week of the month, on Monday and Friday,
-# in the months of April and May.
-#
-trigger = {
-  :start_year   => 2014,
-  :start_month  => 4,
-  :start_day    => 25,
-  :start_hour   => 23,
-  :start_minute => 5,
-  :trigger_type => TaskScheduler::MONTHLYDOW,
-  :type => {
-    :weeks        => TaskScheduler::FIRST_WEEK | TaskScheduler::LAST_WEEK,
-    :days_of_week => TaskScheduler::MONDAY | TaskScheduler::FRIDAY,
-    :months       => TaskScheduler::APRIL | TaskScheduler::MAY
-  }
-}
-
-ts.new_work_item('my_notepad', trigger)
-ts.application_name = 'notepad.exe'
-ts.activate('my_notepad')
-```
-
-# Documentation
-
-If you installed this library as a gem then the documentation was built for you and can be viewed if your gem server is running. There is also some documentation on the github wiki page.
-
-# Acknowledgements
-
-This library was modeled to some degree on the Win32::TaskScheduler Perl module by Umberto Nicoletti. However, there are some differences. Please see the documentation for details.
-
-# Warranty
-
-This package is provided "as is" and without any express or implied warranties, including, without limitation, the implied warranties of merchantability and fitness for a particular purpose.
-
-# Known Issues
-
-Some versions of Ruby have been known to segfault when attempting to create a task. If this happens you will need to upgrade your version of Ruby. Or, at least, your version of win32ole.
-
-In some cases JRuby appears to raise a native exception rather than a Ruby exception on failure. This should be mostly harmless.
-
-Please submit any bug reports to the project page at:
-
-<http://github.com/chef/win32-taskscheduler>
-
-# Copyright
-
-- (C) 2003-2017 Daniel J. Berger All Rights Reserved
-- (C) 2018 Chef Software, Inc. All Rights Reserved
-
-# License
-
-Artistic 2.0
-
-# Authors
-
-- Park Heesob
-- Daniel Berger

data/RELEASE_NOTES.md

@@ -1,14 +0,0 @@
-<!---
-This file is reset every time a new release is done. The contents of this file are for the currently unreleased version.
-
-Example Note:
-
-## Example Heading
-Details about the thing that changed that needs to get included in the Release Notes in markdown.
--->
-
-# win32-taskscheduler 0.4.1 release notes:
-In this release we have fixed issue as below:
-
--- Fix the issue of "no mapping" while creating Windows task for SYSTEM USERS. [Issue: https://github.com/chef/chef/issues/7227]
-

data/Rakefile

@@ -1,38 +0,0 @@
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require 'rspec/core/rake_task'
-
-CLEAN.include("**/*.gem", "**/*.rbc")
-
-namespace 'gem' do
-  desc 'Build the win32-taskscheduler gem'
-  task :create => [:clean] do
-    require 'rubygems/package'
-    spec = eval(IO.read('win32-taskscheduler.gemspec'))
-    Gem::Package.build(spec, true)
-  end
-
-  desc 'Install the win32-taskscheduler library as a gem'
-  task :install => [:create] do
-    file = Dir['win32-taskscheduler*.gem'].first
-    sh "gem install -l #{file}"
-  end
-end
-
-desc 'Run the example code'
-task :example do
-  ruby '-Iib examples/taskscheduler_example.rb'
-end
-
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList["spec/**/*_spec.rb", "spec/**/**/*_spec.rb"].to_a
-end
-
-desc 'Run the test suite for the win32-taskscheduler library'
-Rake::TestTask.new do |t|
-  t.verbose = true
-  t.warning = true
-end
-
-task :default => :test

data/VERSION

@@ -1 +0,0 @@
-2.0.1

data/appveyor.yml

@@ -1,40 +0,0 @@
-version: "ole-{build}"
-
-os: Windows server 2012
-platform:
-  - x64
-
-cache:
-  - vendor/bundle
-
-clone_folder: c:\projects\win32-taskscheduler
-clone_depth: 1
-branches:
-  only:
-    - ole
-
-environment:
-  matrix:
-    - ruby_version: "25-x64"
-    - ruby_version: "25"
-    - ruby_version: "24-x64"
-    - ruby_version: "24"
-
-install:
-  - systeminfo
-  - winrm quickconfig -q
-  - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
-  - echo %PATH%
-  - bundle config --local path vendor/bundle # use the cache we define above
-
-build_script:
-  - bundle install || bundle install || bundle install
-
-before_test:
-  - ruby --version
-  - gem --version
-  - bundler --version
-  - bundle env
-
-test_script:
-  - bundle exec rake spec

data/examples/taskscheduler_example.rb

@@ -1,54 +0,0 @@
-#######################################################################
-# taskscheduler_example.rb
-#
-# A test script for general futzing. You can run this example via the
-# 'example' rake task.
-#
-# Modify as you see fit.
-#######################################################################
-require "win32/taskscheduler"
-require "fileutils"
-require "pp"
-include Win32
-
-puts "VERSION: " + TaskScheduler::VERSION
-
-ts = TaskScheduler.new
-
-trigger = {
-  start_year: 2009,
-  start_month: 4,
-  start_day: 11,
-  start_hour: 7,
-  start_minute: 14,
-  trigger_type: TaskScheduler::DAILY,
-  type: { "days_interval" => 1 }
-}
-
-unless ts.enum.grep(/foo/).length > 0
-  ts.new_work_item("foo", trigger)
-  ts.application_name = "notepad.exe"
-  puts "Task Added"
-end
-
-ts.activate("foo")
-ts.priority = TaskScheduler::IDLE
-ts.working_directory = "C:\\"
-
-puts "App name: " + ts.application_name
-puts "Creator: " + ts.creator
-puts "Exit code: " + ts.exit_code.to_s
-puts "Max run time: " + ts.max_run_time.to_s
-puts "Next run time: " + ts.next_run_time.to_s
-puts "Parameters: " + ts.parameters
-puts "Priority: " + ts.priority.to_s
-puts "Status: " + ts.status
-puts "Trigger count: " + ts.trigger_count.to_s
-puts "Trigger string: " + ts.trigger_string(0)
-puts "Working directory: " + ts.working_directory
-puts "Trigger: "
-
-pp ts.trigger(0)
-
-ts.delete("foo")
-puts "Task deleted"

data/spec/functional/win32/taskscheduler/time_calc_helper_spec.rb

@@ -1,392 +0,0 @@
-require 'win32/taskscheduler/time_calc_helper'
-require 'spec_helper'
-
-RSpec.describe Win32::TaskScheduler::TimeCalcHelper do
-  let(:object) { klass.new }
-  let(:klass) do
-    Class.new do
-      include Win32::TaskScheduler::TimeCalcHelper
-    end
-  end
-
-  describe 'Format Test:' do
-    context 'An Invalid Date-Time string' do
-      time_str = 'An Invalid String'
-      let(:time_details) { object.time_details(time_str) }
-      it 'Returns an empty hash' do
-        expect(time_details).to be_a(Hash)
-        expect(time_details).to be_empty
-      end
-    end
-
-    context 'A valid Date string' do
-      time_str = 'P1Y2M3D'
-      let(:time_details) { object.time_details(time_str) }
-      it 'Returns a valid Hash with only Date values' do
-        expect(time_details).to be_a(Hash)
-        expect(time_details[:year]).to eql('1')
-        expect(time_details[:month]).to eql('2')
-        expect(time_details[:day]).to eql('3')
-        expect(time_details[:hour]).to be_nil
-        expect(time_details[:min]).to be_nil
-        expect(time_details[:sec]).to be_nil
-      end
-    end
-
-    context 'A valid Time string' do
-      time_str = 'PT4H5M6S'
-      let(:time_details) { object.time_details(time_str) }
-      it 'Returns a valid Hash with only Time values' do
-        expect(time_details).to be_a(Hash)
-        expect(time_details[:year]).to be_nil
-        expect(time_details[:month]).to be_nil
-        expect(time_details[:day]).to be_nil
-        expect(time_details[:hour]).to eql('4')
-        expect(time_details[:min]).to eql('5')
-        expect(time_details[:sec]).to eql('6')
-      end
-    end
-
-    context 'A valid Date-Time string' do
-      time_str = 'P1Y2M3DT4H5M6S'
-      let(:time_details) { object.time_details(time_str) }
-      it 'returns a valid Hash with values' do
-        expect(time_details).to be_a(Hash)
-        expect(time_details[:year]).to eql('1')
-        expect(time_details[:month]).to eql('2')
-        expect(time_details[:day]).to eql('3')
-        expect(time_details[:hour]).to eql('4')
-        expect(time_details[:min]).to eql('5')
-        expect(time_details[:sec]).to eql('6')
-      end
-    end
-
-    context 'An Unformatted Date-Time string' do
-      time_str = 'P2M3D1YT6S5M4H'
-      let(:time_details) { object.time_details(time_str) }
-      it 'Returns a valid Hash with values' do
-        expect(time_details).to be_a(Hash)
-        expect(time_details[:year]).to eql('1')
-        expect(time_details[:month]).to eql('2')
-        expect(time_details[:day]).to eql('3')
-        expect(time_details[:hour]).to eql('4')
-        expect(time_details[:min]).to eql('5')
-        expect(time_details[:sec]).to eql('6')
-      end
-    end
-
-    context 'A Date-Time string with few parameters' do
-      time_str = 'P1Y2MT3M4S'
-      let(:time_details) { object.time_details(time_str) }
-      it 'Returns a valid Hash with selected values' do
-        expect(time_details).to be_a(Hash)
-        expect(time_details[:year]).to eql('1')
-        expect(time_details[:month]).to eql('2')
-        expect(time_details[:day]).to be_nil
-        expect(time_details[:hour]).to be_nil
-        expect(time_details[:min]).to eql('3')
-        expect(time_details[:sec]).to eql('4')
-      end
-    end
-  end
-
-  describe 'Year conversion:' do
-    # Time.now to be a Non-Leap Year(0001-01-01 00:00:00), So that
-    # Tests suites will be independant of their execution Time
-    before(:each) do
-      allow(Time).to receive(:now).and_return(Time.new(1))
-    end
-
-    let(:current_time) { Time.new(1) }
-    context 'on given year' do
-      time_str = 'P1Y'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected year' do
-        expect(next_time.year).to eql(current_time.year + 1)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'on given months' do
-      time_str = 'P12M'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected year' do
-        expect(next_time.year).to eql(current_time.year + 1)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'on given days' do
-      time_str = 'P365D'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected year' do
-        expect(next_time.year).to eql(current_time.year + 1)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'by given year and month' do
-      time_str = 'P1Y12M'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected year' do
-        expect(next_time.year).to eql(current_time.year + 2)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'by given year, months and days' do
-      time_str = 'P1Y12M365D'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'Returns the actual incremented day' do
-        expect(next_time.year).to eql(current_time.year + 3)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-  end
-
-  describe 'Month conversion:' do
-    # Time.now to be a Non-Leap Year(0001-01-01 00:00:00), So that
-    # Tests suites will be independant of their execution Time
-    before(:each) do
-      allow(Time).to receive(:now).and_return(Time.new(1))
-    end
-
-    let(:current_time) { Time.new(1) }
-    context 'on given month' do
-      time_str = 'P1M'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected month' do
-        expect(next_time.year).to eql(current_time.year)
-        expect(next_time.month).to eql(current_time.month + 1)
-        expect(next_time.day).to eql(current_time.day)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'on given days' do
-      # Since we are running test on 1st month, next month will occur in 31 days
-      time_str = 'P31D'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected month' do
-        expect(next_time.year).to eql(current_time.year)
-        expect(next_time.month).to eql(current_time.month + 1)
-        expect(next_time.day).to eql(current_time.day)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'by given month and days' do
-      # Since we are running test on 1st month, next month will occur in 31 days
-      time_str = 'P1M31D'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected month' do
-        expect(next_time.year).to eql(current_time.year)
-        expect(next_time.month).to eql(current_time.month + 2)
-        expect(next_time.day).to eql(current_time.day)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-  end
-
-  describe 'Day conversion:' do
-    # Time.now to be a Non-Leap Year(0001-01-01 00:00:00), So that
-    # Tests suites will be independant of their execution Time
-    before(:each) do
-      allow(Time).to receive(:now).and_return(Time.new(1))
-    end
-
-    let(:current_time) { Time.new(1) }
-    context 'on given days' do
-      time_str = 'P1D'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected days' do
-        expect(next_time.year).to eql(current_time.year)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day + 1)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'on given hours' do
-      time_str = 'PT24H'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected days' do
-        expect(next_time.year).to eql(current_time.year)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day + 1)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'on given minutes' do
-      time_str = 'PT1440M'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected days' do
-        expect(next_time.year).to eql(current_time.year)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day + 1)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'on given seconds' do
-      time_str = 'PT86400S'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected days' do
-        expect(next_time.year).to eql(current_time.year)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day + 1)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'By the given days, hours, minutes and seconds' do
-      time_str = 'P1DT24H1440M86400S'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected days' do
-        expect(next_time.year).to eql(current_time.year)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day + 4)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-  end
-
-  describe 'Minute conversion:' do
-    # Time.now to be a Non-Leap Year(0001-01-01 00:00:00), So that
-    # Tests suites will be independant of their execution Time
-    before(:each) do
-      allow(Time).to receive(:now).and_return(Time.new(1))
-    end
-
-    let(:current_time) { Time.new(1) }
-    context 'on given minute' do
-      time_str = 'PT1M'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected minutes' do
-        expect(next_time.year).to eql(current_time.year)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min + 1)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'on given seconds' do
-      time_str = 'PT60S'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected minutes' do
-        expect(next_time.year).to eql(current_time.year)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min + 1)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'By given minutes and seconds' do
-      time_str = 'PT1M60S'
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected minutes' do
-        expect(next_time.year).to eql(current_time.year)
-        expect(next_time.month).to eql(current_time.month)
-        expect(next_time.day).to eql(current_time.day)
-        expect(next_time.hour).to eql(current_time.hour)
-        expect(next_time.min).to eql(current_time.min + 2)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-  end
-
-  describe 'Date-Time conversions:' do
-    # For a single string given in leap/non-leap year
-    time_str = 'P400Y500M600DT700H800M900S'
-
-    context 'In a non leap year' do
-      let(:current_time) { Time.new(1) }
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected values' do
-        allow(Time).to receive(:now).and_return(Time.new(1))
-
-        expect(next_time.year).to eql(current_time.year + 443)
-        expect(next_time.month).to eql(current_time.month + 4)
-        expect(next_time.day).to eql(current_time.day + 21)
-        expect(next_time.hour).to eql(current_time.hour + 17)
-        expect(next_time.min).to eql(current_time.min + 35)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-
-    context 'In a leap year' do
-      let(:current_time) { Time.new(0) }
-      let(:time_seconds) { object.time_in_seconds(time_str) }
-      let(:next_time) { current_time + time_seconds }
-      it 'returns expected values' do
-        allow(Time).to receive(:now).and_return(Time.new(0))
-
-        # 1 Day less for the same string
-        expect(next_time.year).to eql(current_time.year + 443)
-        expect(next_time.month).to eql(current_time.month + 4)
-        expect(next_time.day).to eql(current_time.day + 20)
-        expect(next_time.hour).to eql(current_time.hour + 17)
-        expect(next_time.min).to eql(current_time.min + 35)
-        expect(next_time.sec).to eql(current_time.sec)
-      end
-    end
-  end
-end