jenkins_cron 0.0.2

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ryosuke IWANAGA
+
+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,49 @@
+# JenkinsCron
+
+Simple DSL to define Jenkins scheduled jobs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jenkins_cron'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jenkins_cron
+
+## Usage
+
+    $ cat config/jenkins.yml
+    server_url: "http://jenkins.dev"
+
+    $ cat config/schedule/foo.rb
+    job :test1 do
+      command "whoami", user: "riywo"
+      timer every: 3.minute
+    end
+
+    $ jenkins_cron update foo
+    I, [2013-07-25T04:33:41.887344 #52816]  INFO -- : Obtaining jobs matching filter 'foo-test1'
+    I, [2013-07-25T04:33:41.887470 #52816]  INFO -- : GET /api/json
+    I, [2013-07-25T04:33:42.205541 #52816]  INFO -- : Posting the config.xml of 'foo-test1'
+    I, [2013-07-25T04:33:42.205642 #52816]  INFO -- : GET /api/json
+    I, [2013-07-25T04:33:42.228267 #52816]  INFO -- : POST /job/foo-test1/config.xml
+    I, [2013-07-25T04:33:42.955815 #52816]  INFO -- : Obtaining views based on filter 'foo'
+    I, [2013-07-25T04:33:42.955938 #52816]  INFO -- : GET /api/json
+
+## DSL
+
+TODO: Write documentation
+
+## 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,10 @@
+require "bundler/gem_tasks"
+
+task :default => [:spec]
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.rspec_opts = %w[-cfs -r ./spec/spec_helper.rb]
+  end
+rescue LoadError => e
+end

data/bin/jenkins_cron

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "jenkins_cron"
+
+JenkinsCron::CLI.start(ARGV)

data/jenkins_cron.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jenkins_cron/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jenkins_cron"
+  spec.version       = JenkinsCron::VERSION
+  spec.authors       = ["Ryosuke IWANAGA"]
+  spec.email         = ["riywo.jp@gmail.com"]
+  spec.description   = %q{A DSL for Jenkins cron job}
+  spec.summary       = %q{Simple DSL to define Jenkins scheduled jobs}
+  spec.homepage      = "https://github.com/riywo/jenkins_cron"
+  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 "thor"
+  spec.add_dependency "jenkins_api_client", "~> 0.13.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/jenkins_cron.rb

@@ -0,0 +1,13 @@
+require "jenkins_cron/version"
+require "jenkins_cron/cli"
+require "jenkins_cron/jenkins"
+require "jenkins_cron/schedule"
+require "jenkins_cron/job"
+require "jenkins_cron/job/command"
+require "jenkins_cron/job/timer"
+
+require "jenkins_cron/extentions/jenkins_api_client/job"
+
+module JenkinsCron
+  # Your code goes here...
+end

data/lib/jenkins_cron/cli.rb

@@ -0,0 +1,51 @@
+require "thor"
+require "yaml"
+
+class JenkinsCron::CLI < Thor
+  class_option :config, type: :string, aliases: "-c", default: "config/jenkins.yml", desc: "Jenkins config file"
+
+  desc "update NAME", "Update Jenkins using config/schedule/NAME.rb"
+  def update(name)
+    schedule = JenkinsCron::Schedule.load(name, schedule_file(name))
+    jenkins.update(schedule)
+  end
+
+  desc "version", "Display jenkins_cron version"
+  map ["-v", "--version"] => :version
+  def version
+    puts JenkinsCron::VERSION
+  end
+
+  private
+
+  def jenkins
+    @jenkins ||= JenkinsCron::Jenkins.new(config)
+  end
+
+  def config
+    @config ||= YAML.load_file(config_file)
+  rescue SyntaxError
+    error("Can't parse config file: #{config_file}")
+  end
+
+  def config_file
+    @config_file ||= options[:config]
+    unless File.exists? @config_file
+      error("Can't find config file: #{@config_file}")
+    end
+    @config_file
+  end
+
+  def schedule_file(name)
+    file = "config/schedule/#{name}.rb"
+    unless File.exists? file
+      error("Can't find schedule file: #{file}")
+    end
+    file
+  end
+
+  def error(message)
+    puts "ERROR: #{message}"
+    exit 1
+  end
+end

data/lib/jenkins_cron/extentions/jenkins_api_client/job.rb

@@ -0,0 +1,137 @@
+require "jenkins_api_client"
+
+module JenkinsApi
+  class Client
+    class Job
+      def build_freestyle_config(params)
+        # Supported SCM providers
+        supported_scm = ["git", "subversion", "cvs"]
+
+        # Set default values for params that are not specified.
+        raise ArgumentError, "Job name must be specified" \
+          unless params.is_a?(Hash) && params[:name]
+        if params[:keep_dependencies].nil?
+          params[:keep_dependencies] = false
+        end
+        if params[:block_build_when_downstream_building].nil?
+          params[:block_build_when_downstream_building] = false
+        end
+        if params[:block_build_when_upstream_building].nil?
+          params[:block_build_when_upstream_building] = false
+        end
+        params[:concurrent_build] = false if params[:concurrent_build].nil?
+        if params[:notification_email]
+          if params[:notification_email_for_every_unstable].nil?
+            params[:notification_email_for_every_unstable] = false
+          end
+          if params[:notification_email_send_to_individuals].nil?
+            params[:notification_email_send_to_individuals] ||= false
+          end
+        end
+        # SCM configurations and Error handling.
+        unless supported_scm.include?(params[:scm_provider]) ||
+          params[:scm_provider].nil?
+          raise "SCM #{params[:scm_provider]} is currently not supported"
+        end
+        if params[:scm_url].nil? && !params[:scm_provider].nil?
+          raise 'SCM URL must be specified'
+        end
+        if params[:scm_branch].nil? && !params[:scm_provider].nil?
+          params[:scm_branch] = "master"
+        end
+        if params[:scm_use_head_if_tag_not_found].nil?
+          params[:scm_use_head_if_tag_not_found] = false
+        end
+
+        # Child projects configuration and Error handling
+        if params[:child_threshold].nil? && !params[:child_projects].nil?
+          params[:child_threshold] = 'failure'
+        end
+
+        @logger.debug "Creating a freestyle job with params: #{params.inspect}"
+
+        # Build the Job xml file based on the parameters given
+        builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') { |xml|
+          xml.project {
+            xml.actions
+            xml.description
+            xml.keepDependencies "#{params[:keep_dependencies]}"
+            xml.properties
+            # SCM related stuff
+            if params[:scm_provider] == 'subversion'
+              # Build subversion related XML portion
+              scm_subversion(params, xml)
+            elsif params[:scm_provider] == "cvs"
+              # Build CVS related XML portion
+              scm_cvs(params, xml)
+            elsif params[:scm_provider] == "git"
+              # Build Git related XML portion
+              scm_git(params, xml)
+            else
+              xml.scm(:class => "hudson.scm.NullSCM")
+            end
+            # Restrict job to run in a specified node
+            if params[:restricted_node]
+              xml.assignedNode "#{params[:restricted_node]}"
+              xml.canRoam "false"
+            else
+              xml.canRoam "true"
+            end
+            xml.disabled "false"
+            xml.blockBuildWhenDownstreamBuilding(
+              "#{params[:block_build_when_downstream_building]}")
+            xml.blockBuildWhenUpstreamBuilding(
+              "#{params[:block_build_when_upstream_building]}")
+            if params[:timer]
+              xml.triggers.vector {
+                xml.send("hudson.triggers.TimerTrigger") {
+                  xml.spec params[:timer]
+                }
+              }
+            else
+              xml.triggers.vector
+            end
+            xml.concurrentBuild "#{params[:concurrent_build]}"
+            # Shell command stuff
+            xml.builders {
+              if params[:shell_command]
+                xml.send("hudson.tasks.Shell") {
+                  xml.command "#{params[:shell_command]}"
+                }
+              end
+            }
+            # Adding Downstream projects
+            xml.publishers {
+              # Build portion of XML that adds child projects
+              child_projects(params, xml) if params[:child_projects]
+              # Build portion of XML that adds email notification
+              notification_email(params, xml) if params[:notification_email]
+              # Build portion of XML that adds skype notification
+              skype_notification(params, xml) if params[:skype_targets]
+            }
+            xml.buildWrappers
+          }
+        }
+        builder.to_xml
+      end
+
+      def create_freestyle(params)
+        xml = build_freestyle_config(params)
+        create(params[:name], xml)
+      end
+
+      def update_freestyle(params)
+        xml = build_freestyle_config(params)
+        post_config(params[:name], xml)
+      end
+
+      def create_or_update_freestyle(params)
+        if exists?(params[:name])
+          update_freestyle(params)
+        else
+          create_freestyle(params)
+        end
+      end
+    end
+  end
+end

data/lib/jenkins_cron/jenkins.rb

@@ -0,0 +1,18 @@
+require "jenkins_api_client"
+
+class JenkinsCron::Jenkins
+  def initialize(config)
+    @client = JenkinsApi::Client.new(config)
+  end
+
+  def update(schedule)
+    schedule.each_jobs do |job|
+      @client.job.create_or_update_freestyle(job.params.dup)
+    end
+
+    @client.view.create_list_view(
+      name: schedule.name,
+      regex: "^#{schedule.name}-.+",
+    ) unless @client.view.exists?(schedule.name)
+  end
+end

data/lib/jenkins_cron/job.rb

@@ -0,0 +1,31 @@
+class JenkinsCron::Job
+  attr_reader :name, :params
+
+  def initialize(schedule, name, &block)
+    @schedule = schedule
+    @name = name
+    @params = { name: "#{@schedule.name}-#{@name}" }
+    instance_eval(&block)
+    @params.freeze
+  end
+
+  private
+
+  def command(command, opts = {})
+    cmd = JenkinsCron::Job::Command.new(command, opts)
+    @params[:shell_command] = cmd.shell_command
+  end
+
+  def timer(opts = {}, &block)
+    timer = JenkinsCron::Job::Timer.new(opts, &block)
+    if @params[:timer].nil?
+      @params[:timer] = timer.to_s
+    else
+      @params[:timer] += "\n" + timer.to_s
+    end
+  end
+
+  def options(key, value)
+    @params[key] = value
+  end
+end

data/lib/jenkins_cron/job/command.rb

@@ -0,0 +1,43 @@
+class JenkinsCron::Job::Command
+  def initialize(command, opts = {})
+    @command = command
+    @opts    = opts
+  end
+
+  def shell_command
+    script  = export_env
+    script += "#{sh} -c '#{command}'\n"
+  end
+
+  private
+
+  def export_env
+    env = @opts[:env] || {}
+    export = ""
+    env.each do |key, value|
+      export += "export #{key}=#{value}\n"
+    end
+    export
+  end
+
+  def sh
+    if @opts[:user]
+      #TODO use each user's shell
+      "sudo -u #{@opts[:user]} -H bash -l"
+    else
+      "bash"
+    end
+  end
+
+  def cd
+    if @opts[:cwd]
+      "cd #{@opts[:cwd].shellescape} && "
+    else
+      ""
+    end
+  end
+
+  def command
+    "#{cd}#{@command}"
+  end
+end

data/lib/jenkins_cron/job/timer.rb

@@ -0,0 +1,177 @@
+require "active_support/all"
+require "chronic"
+
+class JenkinsCron::Job::Timer
+  OPTS = [:every, :at, :min, :hour, :day, :month, :day_w, :once_an_hour, :once_a_day, :once_a_month, :once_a_day_w]
+  DAYS_W = [:Sunday, :Monday, :Tuesday, :Wednesday, :Thursday, :Friday, :Saturday]
+  WEEKDAY = [:Monday, :Tuesday, :Wednesday, :Thursday, :Friday]
+  WEEKEND = [:Sunday, :Saturday]
+  def initialize(opts = {}, &block)
+    initialize_with_opts(opts) if opts.size > 0
+    instance_eval(&block)      if block_given?
+  end
+
+  def to_s
+    "#{min} #{hour} #{day} #{month} #{day_w}"
+  end
+  alias :inspect :to_s
+
+  private
+
+  def initialize_with_opts(opts)
+    opts.each do |opt, value|
+      next unless OPTS.include?(opt)
+      send("initialize_#{opt}", value)
+    end
+  end
+
+  def initialize_every(time)
+    case time
+      when 0.seconds...1.minute
+        raise ArgumentError, "Must be in minutes or higher"
+      when 1.minute...1.hour
+        min   every: time/60
+      when 1.hour...1.day
+        min   :once
+        hour  every: (time/60/60).round
+      when 1.day...1.month
+        min   :once
+        hour  :once
+        day   every: (time/60/60/24).round
+      when 1.month..12.months
+        min   :once
+        hour  :once
+        day   :once
+        month every: (time/60/60/24/30).round
+      when *DAYS_W
+        min   :once
+        hour  :once
+        day_w DAYS_W.index(time)
+      when :Weekday
+        min   :once
+        hour  :once
+        day_w WEEKDAY.map {|d| DAYS_W.index(d) }
+      when :Weekend
+        min   :once
+        hour  :once
+        day_w WEEKEND.map {|d| DAYS_W.index(d) }
+      else
+        raise ArgumentError, "Invalid every option '#{time}'"
+    end
+  end
+
+  def initialize_at(time)
+    at = time.is_a?(String) ? Chronic.parse(time) : time
+    raise ArgumentError, "Invalid at option '#{time}'" if at.nil?
+    hour at.hour
+    min  at.min
+  end
+
+  def initialize_min(time)
+    min time
+  end
+
+  def initialize_hour(time)
+    hour time
+  end
+
+  def initialize_day(time)
+    day time
+  end
+
+  def initialize_month(time)
+    month time
+  end
+
+  def initialize_day_w(time)
+    day_w time
+  end
+
+  def initialize_once_an_hour(time)
+    min   :once
+    hour  time
+  end
+
+  def initialize_once_a_day(time)
+    min   :once
+    hour  :once
+    day   time
+  end
+
+  def initialize_once_a_month(time)
+    min   :once
+    hour  :once
+    day   :once
+    month time
+  end
+
+  def initialize_once_a_day_w(time)
+    min   :once
+    hour  :once
+    time = case time
+      when Array
+        time.map { |d| DAYS_W.include?(d) ? DAYS_W.index(d) : d }
+      else
+        DAYS_W.include?(time) ? DAYS_W.index(time) : time
+    end
+    day_w time
+  end
+
+  def min(*args)
+    @min = Field.new(*args) if(@min.nil? or args.length > 0)
+    @min
+  end
+
+  def hour(*args)
+    @hour = Field.new(*args) if(@hour.nil? or args.length > 0)
+    @hour
+  end
+
+  def day(*args)
+    @day = Field.new(*args) if(@day.nil? or args.length > 0)
+    @day
+  end
+
+  def month(*args)
+    @month = Field.new(*args) if(@month.nil? or args.length > 0)
+    @month
+  end
+
+  def day_w(*args)
+    @day_w = Field.new(*args) if(@day_w.nil? or args.length > 0)
+    @day_w
+  end
+
+  class Field
+    def initialize(*args)
+      @opts = args.last.is_a?(Hash) ? args.pop : {}
+      @every = @opts[:every] if @opts.has_key? :every
+
+      case args.length
+        when 0
+          @value = (@every.nil? or @every == 1) ? "*" : "H"
+        when 1
+          @value = args[0] == :once ? "H" : args[0]
+        else
+          @value = args
+      end
+    end
+
+    def to_s
+      unless @string
+        @string = case @value
+          when Range
+            "H(#{@value.first}-#{@value.last})"
+          when Array
+            @value.join(",")
+          when Fixnum
+            @value.to_s
+          when "H","*"
+            @value
+        end
+        @string += "/#{@every}" if (!@every.nil? and @every != 1)
+      end
+      @string
+    end
+  end
+end

data/lib/jenkins_cron/schedule.rb

@@ -0,0 +1,31 @@
+class JenkinsCron::Schedule
+  attr_reader :name
+
+  def initialize(name, &block)
+    @name = name
+    @jobs = {}
+    instance_eval(&block) if block_given?
+  end
+
+  def self.load(name, file_path)
+    block = File.read(file_path)
+    new(name) { eval(block) }
+  end
+
+  def each_jobs
+    @jobs.each do |name, job|
+      yield job
+    end
+  end
+
+  def job(job_name, &block)
+    if block_given? # initialize
+      @jobs[job_name] = JenkinsCron::Job.new(self, job_name, &block)
+    else
+      @jobs[job_name]
+    end
+  end
+
+  private
+
+end

data/lib/jenkins_cron/version.rb

@@ -0,0 +1,3 @@
+module JenkinsCron
+  VERSION = "0.0.2"
+end

data/spec/jenkins_cron/job/command_spec.rb

@@ -0,0 +1,15 @@
+describe JenkinsCron::Job::Command do
+  it "create a simple example of job/command" do
+    cmd = JenkinsCron::Job::Command.new "env | sort"
+    expect(cmd.shell_command).to eq(<<-EOF)
+bash -c 'env | sort'
+EOF
+  end
+  it "create an example of job/command with options" do
+    cmd = JenkinsCron::Job::Command.new "env | sort", env: {PORT: 5000}, user: "app", cwd: "/var/app"
+    expect(cmd.shell_command).to eq(<<-EOF)
+export PORT=5000
+sudo -u app -H bash -l -c 'cd /var/app && env | sort'
+EOF
+  end
+end

data/spec/jenkins_cron/job/timer_spec.rb

@@ -0,0 +1,85 @@
+describe JenkinsCron::Job::Timer do
+  it "is a first test" do
+    timer = JenkinsCron::Job::Timer.new do
+      hour every: 3
+      min  :once
+    end
+    expect(timer.to_s).to eq("H H/3 * * *")
+  end
+
+  it "is a second test" do
+    timer = JenkinsCron::Job::Timer.new do
+      month every: 3
+      day   (1..15), every: 2
+      day_w 1,5
+      hour  1
+      min   :once
+    end
+    expect(timer.to_s).to eq("H 1 H(1-15)/2 H/3 1,5")
+  end
+
+  it "is a third test" do
+    timer = JenkinsCron::Job::Timer.new every: 3.hours
+    expect(timer.to_s).to eq("H H/3 * * *")
+  end
+
+  it "is a forth test" do
+    timer = JenkinsCron::Job::Timer.new every: 2.weeks
+    expect(timer.to_s).to eq("H H H/14 * *")
+  end
+
+  it "is a fifth test" do
+    timer = JenkinsCron::Job::Timer.new every: 3.hours, min: 29
+    expect(timer.to_s).to eq("29 H/3 * * *")
+  end
+
+  it "is a sixth test" do
+    timer = JenkinsCron::Job::Timer.new every: 2.days, at: "10:00 pm"
+    expect(timer.to_s).to eq("0 22 H/2 * *")
+  end
+
+  it "is a seventh test" do
+    timer = JenkinsCron::Job::Timer.new every: :Monday
+    expect(timer.to_s).to eq("H H * * 1")
+  end
+
+  it "is a eightth test" do
+    timer = JenkinsCron::Job::Timer.new every: :Weekday
+    expect(timer.to_s).to eq("H H * * 1,2,3,4,5")
+  end
+
+  it "is a nineth test" do
+    timer = JenkinsCron::Job::Timer.new every: :Weekend, at: "7:00 pm"
+    expect(timer.to_s).to eq("0 19 * * 0,6")
+  end
+
+  it "is a tenth test" do
+    timer = JenkinsCron::Job::Timer.new every: 1.day, month: 4
+    expect(timer.to_s).to eq("H H * 4 *")
+  end
+
+  it "is a eleventh test" do
+    timer = JenkinsCron::Job::Timer.new once_an_hour: 10
+    expect(timer.to_s).to eq("H 10 * * *")
+  end
+
+  it "is a twelfth test" do
+    timer = JenkinsCron::Job::Timer.new once_an_hour: [3,6,12]
+    expect(timer.to_s).to eq("H 3,6,12 * * *")
+  end
+
+  it "is a thirteenth test" do
+    timer = JenkinsCron::Job::Timer.new once_a_day: [3,6,12], hour: 10
+    expect(timer.to_s).to eq("H 10 3,6,12 * *")
+  end
+
+  it "is a fourteenth test" do
+    timer = JenkinsCron::Job::Timer.new once_a_month: [3,6,12], day: 15
+    expect(timer.to_s).to eq("H H 15 3,6,12 *")
+  end
+
+  it "is a fifteenth test" do
+    timer = JenkinsCron::Job::Timer.new once_a_day_w: [:Monday, :Friday]
+    expect(timer.to_s).to eq("H H * * 1,5")
+  end
+end

data/spec/jenkins_cron/job_spec.rb

@@ -0,0 +1,15 @@
+describe JenkinsCron::Job do
+  it "create a simple example of job" do
+    schedule = JenkinsCron::Schedule.new :schedule1
+    job = JenkinsCron::Job.new schedule, :test1 do
+      command "echo test1"
+      timer every: 5.minute
+      timer every: :Monday
+    end
+
+    expect(job.name).to be(:test1)
+    expect(job.params[:name]).to eq("schedule1-test1")
+    expect(job.params[:shell_command]).to eq("bash -c 'echo test1'\n")
+    expect(job.params[:timer]).to eq("H/5 * * * *\nH H * * 1")
+  end
+end

data/spec/jenkins_cron/schedule_spec.rb

@@ -0,0 +1,24 @@
+describe JenkinsCron::Schedule do
+  it "create a simple example of schedule" do
+    schedule = JenkinsCron::Schedule.new :group1 do
+      job :test1 do
+        options :shell_command, "echo test1"
+        options :timer, "* * * * *"
+      end
+
+      job :test2 do
+        options :shell_command, "echo test2"
+        options :timer, "* * * * *"
+      end
+    end
+
+    expect(schedule.name).to eq(:group1)
+
+    expect(schedule.job(:test1)).to be_true
+    expect(schedule.job(:test2)).to be_true
+    expect(schedule.job(:test3)).to be_false
+
+    expect(schedule.job(:test1).params[:shell_command]).to eq("echo test1")
+    expect(schedule.job(:test2).params[:shell_command]).to eq("echo test2")
+  end
+end

data/spec/jenkins_cron_spec.rb

@@ -0,0 +1,6 @@
+describe JenkinsCron do
+  describe "VERSION" do
+    subject { JenkinsCron::VERSION }
+    it { should be_a String }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require "rspec"
+require "jenkins_cron"

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: jenkins_cron
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Ryosuke IWANAGA
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jenkins_api_client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: A DSL for Jenkins cron job
+email:
+- riywo.jp@gmail.com
+executables:
+- jenkins_cron
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/jenkins_cron
+- jenkins_cron.gemspec
+- lib/jenkins_cron.rb
+- lib/jenkins_cron/cli.rb
+- lib/jenkins_cron/extentions/jenkins_api_client/job.rb
+- lib/jenkins_cron/jenkins.rb
+- lib/jenkins_cron/job.rb
+- lib/jenkins_cron/job/command.rb
+- lib/jenkins_cron/job/timer.rb
+- lib/jenkins_cron/schedule.rb
+- lib/jenkins_cron/version.rb
+- spec/jenkins_cron/job/command_spec.rb
+- spec/jenkins_cron/job/timer_spec.rb
+- spec/jenkins_cron/job_spec.rb
+- spec/jenkins_cron/schedule_spec.rb
+- spec/jenkins_cron_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/riywo/jenkins_cron
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Simple DSL to define Jenkins scheduled jobs
+test_files:
+- spec/jenkins_cron/job/command_spec.rb
+- spec/jenkins_cron/job/timer_spec.rb
+- spec/jenkins_cron/job_spec.rb
+- spec/jenkins_cron/schedule_spec.rb
+- spec/jenkins_cron_spec.rb
+- spec/spec_helper.rb