at-random 1.0.0

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format=documentation

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+
+gemspec

data/README.md

@@ -0,0 +1,33 @@
+# at-random
+
+    at-random [--random-seed seed] [--from HH[:MM]] [--to [HH[:MM]] [at-args]
+
+Picks some time
+between `--from` and `--to`
+(in 24-hour format)
+uniformly at random.
+Passes the remaining args
+(namely `[-q queue] [-f file] [-m]`)
+along with standard input
+to `at(1)` to run
+at that time.
+
+If `--from` is in the past,
+`at-random` will re-roll times
+until it gets one in the future.
+If `--to` is in the past,
+it will print an error message
+and exit nonzero.
+
+If `--random-seed` is passed,
+it will be used to seed the PRNG.
+
+
+This script can be used to implement random job start times in `cron(8)` with
+`crontab(5)` lines like the following:
+
+    # m h dom month dow command
+      0 0 0   *     0   at-random --from 12:00 --to 17:00 -f /home/bob/reflect
+
+which runs `at-random` at midnight every Sunday to tell `at(1)` to execute the
+contents of `/home/bob/reflect` some time between noon and five PM.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/at-random.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/at-random/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Steve Dee"]
+  gem.email         = ["steve@smartercode.net"]
+  gem.description   = %q{Pick a random time subject to some constraints, and fork `at` with the remaining args.}
+  gem.summary       = %q{Do things at random times}
+  gem.homepage      = "https://github.com/mrdomino/at-random"
+
+  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.name          = "at-random"
+  gem.require_paths = ["lib"]
+  gem.version       = AtRandom::VERSION
+
+  gem.add_development_dependency 'rspec', ['>= 2']
+  gem.add_development_dependency 'mocha'
+end

data/bin/at-random

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'at-random'
+
+exit AtRandom::App.new(ARGV).run

data/lib/at-random/app.rb

@@ -0,0 +1,44 @@
+require 'at-random/at_cmd'
+require 'at-random/pick_time'
+
+module AtRandom
+  class App
+    def initialize(argv=[])
+      @pick_time_opts = {}
+      while argv[0] =~ /--(from|to|random-seed)/
+        arg = argv.shift
+        if arg =~ /--from/
+          from_str = arg.length > 6 ? arg[7..-1] : argv.shift
+          @pick_time_opts[:from] = from_str
+        elsif arg =~ /--to/
+          to_str = arg.length > 4 ? arg[5..-1] : argv.shift
+          @pick_time_opts[:to] = to_str
+        elsif arg =~ /--random-seed/
+          @random_seed = arg.length > 13 ? arg[14..-1].to_i : argv.shift
+        end
+      end
+
+      if @pick_time_opts[:from] && @pick_time_opts[:from].length == 2
+        @pick_time_opts[:from] += ':00'
+      end
+
+      if @pick_time_opts[:to] && @pick_time_opts[:to].length == 2
+        @pick_time_opts[:to] += ':59'
+      end
+
+      @at_args = argv
+    end
+
+    def run
+      Kernel.srand(@random_seed) if @random_seed
+      @picked_time = PickTime.new @pick_time_opts
+      begin
+        AtCmd.new(@picked_time.time_s, @at_args).exec
+        0
+      rescue Exception => e
+        $stderr.puts e.message
+        -1
+      end
+    end
+  end
+end

data/lib/at-random/at_cmd.rb

@@ -0,0 +1,24 @@
+module AtRandom
+  class AtCmd
+    class InvalidTime < Exception; end
+
+    def initialize(*args)
+      if args[0]
+        timespec = args.shift
+        if !(timespec =~ /[0-2][0-9]:[0-5][0-9]/)
+          raise ArgumentError
+        end
+
+        if timespec < Time.now.strftime('%H:%M')
+          raise InvalidTime, "Timespec #{timespec} is earlier than now"
+        end
+
+        @exec_args = ['at', timespec, args].flatten
+      end
+    end
+
+    def exec
+      Process.exec(*@exec_args)
+    end
+  end
+end

data/lib/at-random/pick_time.rb

@@ -0,0 +1,34 @@
+module AtRandom
+  class PickTime
+    class ImpossibleRange < Exception; end
+
+    def initialize(opts={})
+      from_h, from_m = parse_time(opts[:from] || '00:00')
+      to_h, to_m = parse_time(opts[:to] || '23:59')
+      now_h, now_m = parse_time(Time.now.strftime('%H:%M'))
+
+      if now_h >= from_h
+        from_h = now_h
+        if now_m > from_m
+          from_m = now_m
+        end
+      end
+
+      if now_h > to_h || (now_h == to_h && now_m > to_m)
+        raise ImpossibleRange, 'Asked for :to sooner than now'
+      end
+
+      @hour = rand(to_h - from_h) + from_h
+      @minute = rand(to_m - from_m) + from_m
+    end
+
+    def time_s
+      format("%02d:%02d", @hour, @minute)
+    end
+
+  private
+    def parse_time(time_s)
+      time_s.split(':').map(&:to_i)
+    end
+  end
+end

data/lib/at-random/version.rb

@@ -0,0 +1,3 @@
+module AtRandom
+  VERSION = '1.0.0'
+end

data/lib/at-random.rb

@@ -0,0 +1,4 @@
+require 'at-random/app'
+require 'at-random/pick_time'
+require 'at-random/at_cmd'
+require 'at-random/version'

data/spec/at-random/app_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+require 'at-random/app'
+
+describe AtRandom::App do
+  let!(:mock_picked_time) { mock('PickTime') }
+  let!(:mock_at_cmd) { mock('AtCmd') }
+
+  before do
+    $stderr.stubs(:puts)
+    Kernel.stubs(:srand)
+
+    AtRandom::AtCmd.stubs(:new).returns(mock_at_cmd)
+    mock_at_cmd.stubs(:exec)
+    AtRandom::PickTime.stubs(:new).returns(mock_picked_time)
+    mock_picked_time.stubs(:time_s)
+  end
+
+  describe '#run' do
+    def run_with_good_args
+      argv = %w[--random-seed=20 --from=12:34 --to=13 -q q -m]
+      AtRandom::App.new(argv).run
+    end
+
+    shared_examples_for 'successful run' do
+      it 'picks a time to pass to `at`' do
+        picked_time = '12:35'
+        mock_picked_time.expects(:time_s).returns(picked_time)
+        AtRandom::AtCmd.expects(:new).with(picked_time, any_parameters)
+        subject
+      end
+
+      it 'calls AtCmd#exec' do
+        mock_at_cmd.expects(:exec)
+        subject
+      end
+    end
+
+    context 'with good arguments' do
+      subject { run_with_good_args }
+
+      context 'when successful' do
+        it_behaves_like 'successful run'
+
+        it 'passes appropriate arguments' do
+          Kernel.expects(:srand).with(20)
+          AtRandom::PickTime.expects(:new).
+            with(:from => '12:34', :to => '13:59').
+            returns(mock_picked_time)
+          AtRandom::AtCmd.expects(:new).with(anything, ['-q', 'q', '-m'])
+          subject
+        end
+      end
+
+      context 'when AtCmd raises an exception' do
+        before do
+          AtRandom::AtCmd.stubs(:new).raises(Exception, 'boom')
+        end
+
+        it { lambda { subject }.should_not raise_error }
+
+        it 'prints an error message to stderr' do
+          $stderr.expects(:puts).with(includes('boom'))
+          subject
+        end
+
+        it 'returns a negative number' do
+          subject.should be < 0
+        end
+      end
+    end
+
+    context 'without arguments' do
+      subject { AtRandom::App.new.run }
+
+      it_behaves_like 'successful run'
+    end
+  end
+
+  describe '.new' do
+    describe 'arguments' do
+      def run_with_arg(arg)
+        AtRandom::App.new([arg]).run
+      end
+
+      shared_examples_for 'parametrized argument' do |param|
+        it 'understands --arg=param' do
+          AtRandom::App.new(["#{subject}=#{param}"]).run
+        end
+
+        it 'understands --arg param' do
+          AtRandom::App.new([subject, param]).run
+        end
+      end
+
+      shared_examples_for 'time argument' do
+        it 'accepts HH' do
+          run_with_arg("#{subject}=23").should eq 0
+        end
+
+        it 'accepts HH:MM' do
+          run_with_arg("#{subject}=01:23").should eq 0
+        end
+      end
+
+      def run_with_time_arg(arg, time_s)
+        AtRandom::PickTime.expects(:new).
+          with(arg.to_sym => time_s).
+          returns(mock_picked_time)
+        run_with_arg("--#{arg}=#{time_s}")
+      end
+
+      describe '--from' do
+        subject { '--from' }
+
+        it_behaves_like 'time argument'
+
+        it_behaves_like 'parametrized argument', '01:23' do
+          before do
+            AtRandom::PickTime.expects(:new).
+              with(:from => '01:23').
+              returns(mock_picked_time)
+          end
+        end
+
+        it 'passes valid times to PickTime' do
+          run_with_time_arg 'from', '10:00'
+
+          run_with_time_arg 'from', '22:33'
+        end
+
+        it 'expands "HH" to "HH:00"' do
+          AtRandom::PickTime.expects(:new).
+            with(:from => '11:00').
+            returns(mock_picked_time)
+          run_with_arg("--from=11")
+        end
+      end
+
+      describe '--to' do
+        subject { '--to' }
+
+        it_behaves_like 'time argument'
+
+        it_behaves_like 'parametrized argument', '01:23' do
+          before do
+            AtRandom::PickTime.expects(:new).
+              with(:to => '01:23').
+              returns(mock_picked_time)
+          end
+        end
+
+        it 'passes to PickTime' do
+          run_with_time_arg 'to', '11:00'
+
+          run_with_time_arg 'to', '23:59'
+        end
+
+        it 'expands "HH" to "HH:59"' do
+          AtRandom::PickTime.expects(:new).
+            with(:to => '12:59').
+            returns(mock_picked_time)
+          run_with_arg("--to=12")
+        end
+      end
+
+      describe '--from and --to' do
+        specify 'both get passed to PickTime' do
+          AtRandom::PickTime.expects(:new).
+            with(:from => '23:05', :to => '23:04').
+            returns(mock_picked_time)
+          AtRandom::App.new(%w[--from=23:05 --to=23:04]).run
+        end
+      end
+
+      describe '--random-seed' do
+        subject { '--random-seed' }
+
+        it_behaves_like 'parametrized argument', 1234 do
+          before { Kernel.expects(:srand).with(1234) }
+        end
+
+        it 'seeds the rng' do
+          Kernel.expects(:srand).with(12345)
+          run_with_arg('--random-seed=12345')
+        end
+      end
+
+      describe '`at` args' do
+        specify 'get passed to `at`' do
+          AtRandom::AtCmd.expects(:new).with(anything, %w[-q a])
+          AtRandom::App.new(%w[-q a]).run
+        end
+
+        describe 'other `at-random` args' do
+          specify "aren't passed to `at`" do
+            AtRandom::AtCmd.expects(:new).with(anything, %w[-m])
+            AtRandom::App.new(%w[--from=10:00 --to=12:00 -m]).run
+          end
+        end
+      end
+    end
+  end
+end

data/spec/at-random/at_cmd_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+require 'at-random/at_cmd'
+
+describe AtRandom::AtCmd do
+  let!(:frozen_now) { Time.local(2015, 05, 25) }
+  before do
+    Time.stubs(:now).returns(frozen_now)
+    Process.stubs(:exec)
+  end
+
+  let(:timespec) { '12:30' }
+  let(:at_args) { [] }
+
+  let(:at_with_args) { AtRandom::AtCmd.new(timespec, at_args) }
+
+  describe '.new' do
+    subject { at_with_args }
+
+    describe 'timespec argument' do
+      context 'a valid time string' do
+        let(:timespec) { '12:34' }
+
+        context 'after now' do
+          let(:frozen_now) { Time.local(2012, 05, 25, 12, 33) }
+
+          it { lambda { subject }.should_not raise_error }
+        end
+
+        context 'before now' do
+          let(:frozen_now) { Time.local(2012, 05, 25, 12, 35) }
+
+          it { lambda { subject }.
+            should raise_error AtRandom::AtCmd::InvalidTime }
+        end
+      end
+
+      context 'a non-time string' do
+        let(:timespec) { 'as:df' }
+
+        it { lambda { subject }.should raise_error ArgumentError }
+      end
+
+      context 'a non-string' do
+        let(:timespec) { Time.local(2012, 05, 25, 12, 32) }
+
+        it { lambda { subject }.should raise_error ArgumentError }
+      end
+    end
+
+    describe 'at_args argument' do
+      context 'an array of `at` args' do
+        let(:at_args) { ['-f', 'foo', '-mv'] }
+
+        it { lambda { subject }.should_not raise_error }
+      end
+    end
+  end
+
+  describe '#exec' do
+    subject { at_with_args.exec }
+
+    it 'execs `at`' do
+      Process.expects(:exec).with('at', any_parameters)
+      subject
+    end
+
+    context 'with at args' do
+      let(:at_args) { ['-f', 'foo'] }
+
+      it 'passes arguments to `at`' do
+        Process.expects(:exec).with('at', anything, '-f', 'foo')
+        subject
+      end
+    end
+
+    describe '`at` timespec' do
+      it 'is the first argument to AtCmd.new' do
+        Process.expects(:exec).with('at', timespec, any_parameters)
+        subject
+      end
+    end
+  end
+end

data/spec/at-random/pick_time_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+require 'at-random/pick_time'
+
+describe AtRandom::PickTime do
+  let(:frozen_now) { Time.local(1970, 1, 1, 0, 0) }
+
+  before do
+    Time.stubs(:now).returns(frozen_now)
+  end
+
+  describe '#time_s' do
+    it 'is a time string' do
+      subject.time_s.should =~ /[012][0-9]:[0-5][0-9]/
+    end
+
+    it 'is a function of Kernel.rand' do
+      (1..20).map do |i|
+        Kernel.srand(i)
+        AtRandom::PickTime.new.time_s
+      end.uniq.length.should be_within(1).of(19)
+    end
+
+    it 'is the same every time for a given PickTime' do
+      subject.time_s.should eq subject.time_s
+    end
+  end
+
+  describe '.new' do
+    context 'with :from => "00:34"' do
+      subject { AtRandom::PickTime.new :from => "00:34" }
+
+      its(:time_s) { should be > '00:34' }
+
+      context 'at 17:36pm local' do
+        let(:frozen_now) { Time.at(Time.local(2012, 05, 16, 17, 36)) }
+
+        its(:time_s) { should be > '17:36' }
+      end
+    end
+
+    context 'with :to => "12:34"' do
+      subject { AtRandom::PickTime.new :to => '12:34' }
+
+      its(:time_s) { should be <= '12:34' }
+
+      context 'at 12:36pm local' do
+        let(:frozen_now) { Time.local(2012, 05, 16, 12, 36) }
+
+        it { lambda { subject }.should raise_error }
+      end
+    end
+  end
+end

data/spec/at-random/version_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+require 'at-random/version'
+
+describe AtRandom::VERSION do
+  it { should =~ /^[0-9]+\.[0-9]+\.[0-9]+$/ }
+end

data/spec/at_random_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+require 'at-random'
+
+describe AtRandom do
+  it 'includes submodules' do
+    subject.const_defined?('App').should be_true
+    subject.const_defined?('PickTime').should be_true
+    subject.const_defined?('AtCmd').should be_true
+    subject.const_defined?('VERSION').should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: at-random
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Steve Dee
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  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: Pick a random time subject to some constraints, and fork `at` with the
+  remaining args.
+email:
+- steve@smartercode.net
+executables:
+- at-random
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- at-random.gemspec
+- bin/at-random
+- lib/at-random.rb
+- lib/at-random/app.rb
+- lib/at-random/at_cmd.rb
+- lib/at-random/pick_time.rb
+- lib/at-random/version.rb
+- spec/at-random/app_spec.rb
+- spec/at-random/at_cmd_spec.rb
+- spec/at-random/pick_time_spec.rb
+- spec/at-random/version_spec.rb
+- spec/at_random_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mrdomino/at-random
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Do things at random times
+test_files:
+- spec/at-random/app_spec.rb
+- spec/at-random/at_cmd_spec.rb
+- spec/at-random/pick_time_spec.rb
+- spec/at-random/version_spec.rb
+- spec/at_random_spec.rb
+- spec/spec_helper.rb