laborantin 0.0.2 → 0.0.6

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/gempackagetask'
 
 spec = Gem::Specification.new do |s|
         s.name = 'laborantin'
-        s.version = '0.0.2'
+        s.version = '0.0.6'
         s.platform = Gem::Platform::RUBY
         s.summary = "A measurement batch facilitator"
 
@@ -14,14 +14,24 @@ spec = Gem::Specification.new do |s|
 
         s.files = ['README', 'LICENSE', 'gpl-3.0.txt',
 	       	'Rakefile', 'TODO', 
+		'bin/labor',
+		'bin/files/README.erb',
+		'bin/files/TODO.erb',
+		'bin/files/config/ftp.yaml.erb',
+		'bin/files/config/xmpp.yaml.erb',
+		'bin/files/environments/environment.rb.erb',
+		'bin/files/scenarii/scenario.rb.erb',
 		'lib/laborantin.rb',
 		'lib/laborantin/core/environment.rb',
 		'lib/laborantin/core/parameter.rb',
 		'lib/laborantin/core/parameter_hash.rb',
 		'lib/laborantin/core/scenario.rb',
-		'lib/laborantin/additions/xmpp_logger.rb' ]
+		'lib/laborantin/core/monkey_patches.rb',
+	]
 
         s.require_path = 'lib'
+	s.bindir = 'bin'
+	s.executables = ['labor']
 
         s.has_rdoc = false
 end

data/bin/files/README.erb

@@ -0,0 +1,29 @@
+The "<%= File.dirname __FILE__ %>" directory has been created by Laborantin <%= Laborantin::VERSION %>.
+It is important to understand the hierarchy of Laborantin's directory
+before moving any file.
+
+Laborantin has created several files:
+
+<%= File.dirname __FILE__ %>/
+|-- README                # This file.
+|-- TODO                  # A file where you should track what is left.
+|-- config                # Configuration for Laborantin's command.
+|   |-- ftp.yaml            # Account config for FTP exports.
+|   `-- xmpp.yaml           # Account config for XMPP Logging. 
+|-- environments          # Your measurement environments.
+|-- results               # The results of the various run.
+|-- scenarii              # Your scenarii.
+`-- scripts               # A dir to place your additional scripts.
+
+In addition to this, it has created one environnment ruby file per 
+-e argument as well as one scenario ruby file per -s argument.
+
+When executing a laborantin run command, Laborantin will scan the current
+directory for environments and scenarii.
+
+See <%= Laborantin::WEBSITE %> for further information.
+
+Laborantin has been written by:
+- <%= Laborantin::AUTHORS.join("\n- ") %>
+
+Laborantin is licensend under the <%= Laborantin::LICENSE %>.

data/bin/files/TODO.erb

@@ -0,0 +1,2 @@
+Store in <%= __FILE__ %> file what remains to do.
+

data/bin/files/config/ftp.yaml.erb

@@ -0,0 +1,6 @@
+--- 
+:pass: secret
+:host: example.foo
+:port: 22
+:nick: bar
+:enable: false

data/bin/files/config/xmpp.yaml.erb

@@ -0,0 +1,7 @@
+--- 
+:pass: secret
+:nick: foobar@example.bar
+:receivers: 
+- bidule@truc.chose
+- machin@carabistouille.bof
+:enable: false

data/bin/files/environments/environment.rb.erb

@@ -0,0 +1,13 @@
+# environments/<%= e %>.rb
+
+class <%= e.camelize %> < Laborantin::Environment
+
+  describe "Place your description here"
+
+  verify :good_platform?
+
+  def good_platform?
+    RUBY_PLATFORM =~ /linux/
+  end
+
+end

data/bin/files/scenarii/scenario.rb.erb

@@ -0,0 +1,5 @@
+# scenarii/<%= s %>.rb
+
+class <%= s.camelize %> < Laborantin::Scenario
+  describe "put your decription here"
+end

data/bin/labor

@@ -0,0 +1,226 @@
+#!/usr/bin/env ruby
+
+require	'optparse'
+#require 'rubygems'
+require 'laborantin'
+#require '../lib/laborantin'
+require	'fileutils'
+require 'find'
+require 'erb'
+
+class Command
+  attr_accessor :name, :description, :parser, :block, :options, :args
+
+  @@all = []
+
+  def initialize(name, description='')
+    @@all << self
+    @name = name
+    @description = description
+    @options = {}
+    @args = []
+    yield self
+  end
+
+  def self.all
+    @@all
+  end
+
+  def self.for_name(name)
+    @@all.find{|c| c.name == name}
+  end
+
+  def opts(&argblk)
+    @parser =  OptionParser.new &argblk
+    script_name = File.basename($0)
+    @parser.summary_indent = "\t"
+    @parser.banner = %{Usage: #{script_name} #{name} [OPTIONS] [env1 [env2 ..]]}
+    @parser.banner << %{\n#{description}} unless description.empty?
+  end
+
+  def parse!(args)
+    begin
+      @args = @parser.parse args
+    rescue OptionParser::InvalidOption => err
+      puts err
+      puts @parser
+      exit
+    end
+  end
+
+  def execute(&blk)
+    @block = blk
+  end
+
+  def execute!
+    self.instance_eval &@block if @block
+  end
+end
+
+Command.new('create', 'prepares a dir for laborantin measurements') do |c|
+  c.options[:scenarii] = []
+  c.options[:environments] = []
+  c.options[:force] = false
+  c.opts do |o|
+    o.on('-s', '--scenarii=OPTIONAL', 'scenarii to build, comma separated', Array) {|c.options[:scenarii]|}
+    o.on('-e', '--environments=OPTIONAL', 'environments to prepare, comma separated', Array) {|c.options[:environments]|}
+    o.on_tail('-f', '--force', 'force overwrite') {|c.options[:force]|}
+    o.on_tail('-h', '--help', 'shows this help and exit') {puts o; exit}
+  end
+
+  c.execute do 
+    dir = args.shift
+    p dir #not for debug
+    unless c.options[:force]
+      begin
+	FileUtils.mkdir dir
+      rescue Errno::EEXIST => err
+	puts "Directory already exists, use -f/--force to overwrite (will overwrite all generated files, use at your own risk)."
+	exit 
+      end
+    end
+    %w{environments scenarii results config scripts}.each do |w|
+      path = File.join( dir, w )
+      p path #not for debug
+      FileUtils.mkdir_p path
+    end
+    %w{README TODO config/ftp.yaml config/xmpp.yaml}.each do |w|
+      res_path = File.join(dir, w)
+      p res_path #not for debug
+      File.open(res_path, 'w') do |f|
+	tpl = ''
+	tpl_path = (File.join(File.dirname(__FILE__), 'files', "#{w}.erb"))
+	File.open(tpl_path) do |tf|
+	  tpl = tf.read
+	end
+	erb = ERB.new tpl
+	erb.filename = res_path
+	f.puts erb.result(binding)
+      end
+    end
+    @options[:scenarii].each do |s|
+      res_path = File.join(dir, 'scenarii', "#{s}.rb")
+      p res_path #not for debug
+      File.open(res_path, 'w') do |f|
+	tpl = ''
+	tpl_path = (File.join(File.dirname(__FILE__), 'files', 'scenarii', 'scenario.rb.erb'))
+	File.open(tpl_path) do |tf|
+	  tpl = tf.read
+	end
+	erb = ERB.new tpl
+	erb.filename = res_path
+	f.puts erb.result(binding)
+      end
+    end
+    @options[:environments].each do |e|
+      res_path = File.join(dir, 'environments', "#{e}.rb")
+      p res_path #not for debug
+      File.open(res_path, 'w') do |f|
+	tpl = ''
+	tpl_path = (File.join(File.dirname(__FILE__), 'files', 'environments', 'environment.rb.erb'))
+	File.open(tpl_path) do |tf|
+	  tpl = tf.read
+	end
+	erb = ERB.new tpl
+	erb.filename = res_path
+	f.puts erb.result(binding)
+      end
+    end
+  end
+end
+
+Command.new('describe', "describes a laborantin's work") do |c|
+  c.opts do |o|
+    o.on_tail('-h', '--help', 'shows this help and exit') {puts o; exit}
+  end
+  c.execute do
+    FileUtils.cd(args.first || '.')
+    Find.find('environments', 'scenarii') do |f|
+      require f if File.extname(f) == '.rb'
+    end
+
+    Laborantin::Environment.all.each {|e| p e}
+    Laborantin::Scenario.all.each {|s| p s}
+  end
+end
+
+
+
+
+Command.new('run', 'actually perform measurements') do |c|
+  c.options[:scenarii] = []
+  c.options[:environments] = []
+  c.options[:filter] = ''
+  c.opts do |o|
+    o.on('-s', '--scenarii=OPTIONAL', 'scenarii to build, comma separated', Array) {|c.options[:scenarii]|}
+    o.on('-e', '--environments=OPTIONAL', 'environments to prepare, comma separated', Array) {|c.options[:environments]|}
+    o.on('-p', '--parameters=OPTIONAL', 'filter parameters (ruby hash format)', String) {|c.options[:filter]|}
+    o.on_tail('-h', '--help', 'shows this help and exit') {puts o; exit}
+  end
+  c.execute do 
+    dir = args.first || '.'
+    FileUtils.cd(dir)
+    Find.find('environments', 'scenarii') do |f|
+      require f if File.extname(f) == '.rb'
+    end
+
+    envs = if c.options[:environments].empty?
+	     Laborantin::Environment.all
+	   else
+	     c.options[:environments].map!{|e| e.camelize}
+	     Laborantin::Environment.all.select{|e| c.options[:environments].include? e.name}
+	   end
+
+    scii = if c.options[:scenarii].empty?
+	     Laborantin::Scenario.all
+	   else
+	     c.options[:scenarii].map!{|e| e.camelize}
+	     Laborantin::Scenario.all.select{|e| c.options[:scenarii].include? e.name}
+	   end
+
+    params = eval @options[:filter] unless @options[:filter].empty?
+    params.each_key{|k| params[k] = [params[k]].flatten} if params
+
+    envs.each do |eklass|
+      env = eklass.new
+      unless eklass.verifications.find{|v| not env.send(v)} #TODO: pass into class, rescue errors
+	env.prepare!
+	env.log "Running matching scenarii", :info #TODO: pass the logging+running in the env
+	scii.each do |sklass|
+	  sklass.parameters.merge! params if params
+	  env.log sklass.parameters.inspect
+	  sklass.parameters.each_config do |cfg|
+	    sc = sklass.new(env, cfg)
+	    sc.prepare!
+	    sc.perform!
+	    sc.analyze!
+	  end
+	end
+	env.log "Scenarii performed", :info
+	env.analyze!
+      end
+    end
+  end
+end
+
+=begin
+TODO: replay, scan, push, pull
+=end
+
+cmd = Command.for_name ARGV.first
+
+if cmd
+  cmd.parse!(ARGV.dup[1 .. -1])
+  cmd.execute!
+else
+  if ARGV.empty?
+    puts %{#{$0} v.#{Laborantin::VERSION}: No command given
+
+      Usage: #{$0} <command> [options ...]
+      <command> among: #{Command.all.map{|c| c.name}.join(', ')} 
+
+      use #{$0} <command> --help for help on a specific command}
+  else
+    print "unknown command #{ARGV.first}"
+  end
+end

data/lib/laborantin/core/environment.rb

@@ -21,84 +21,86 @@ Copyright (c) 2009, Lucas Di Cioccio
 
 =end
 
-
 require 'time'
 require 'logger'
 require 'fileutils'
 
 module Laborantin
   class Environment
+    @@all = []
+    @@rootdir = '.'
+    class << self
+      attr_accessor :verifications, :description, :envdir
 
-    attr_accessor :scenarii, :dates, :name, :loggers
+      def rootdir=(dir='.')
+	@@rootdir = dir
+      end
 
-    def initialize(name='results', &blk)
-      @loggers = []
-      @name = name
-      @scenarii = []
-      @dates = {}
-      self.instance_eval &blk if block_given?
-    end
+      def rootdir
+	@@rootdir || '.'
+      end
 
-    def scenario(sc_name, desc='', &blk)
-      raise ArgumentError.new("Scenario #{sc_name} already exists for #{name}") if has_scenario?(sc_name)
-      klass = Class.new(Scenario)
-      scenarii << klass
-      klass.name = sc_name
-      klass.description = desc
-      klass.env  = self
-      klass.instance_eval &blk
-    end
+      def resultdir
+	@@resultdir = File.join(@@rootdir, 'results')
+      end
 
-    def log!(logger=Logger.new(STDOUT))
-      @loggers << logger
-    end
+      def inherited(klass)
+	klass.verifications = []
+	klass.description = ''
+	@@all << klass
+      end
 
-    def run_scenarii!
-      @dates[:begin] = Time.now
-      FileUtils.mkpath(env_dirname)  #TODO: clean that
-      log!(Logger.new(File.join(env_dirname, 'environment.log')))
-      @scenarii.each do |sc|
-	info scenario_start_msg(sc)
-	sc.parameters.each_config do |cfg|
-	  info "--- #{cfg.inspect}"
-	  perform_scenario(sc, cfg)
-	end
-	info scenario_end_msg(sc)
+      def verify(*args)
+	self.verifications = [*args].flatten
       end
-      @dates[:end] = Time.now
-    end
 
-    def env_rootname
-      File.join( '.', name.to_s)
-    end
+      def describe(str)
+	self.description = str
+      end
+      
+      def to_s
+	"#{self.name}:\n\t#{self.description}"
+      end
 
-    def env_dirname
-      File.join( env_rootname, @dates[:begin].strftime("%Y-%h-%d_%H-%M-%S") )
-    end
+      def all
+	@@all
+      end
+
+      def envdir
+	File.join(resultdir, self.name.duck_case)
+      end
 
-    def perform_scenario(sc, cfg)
-      sc.new(cfg).perform!
     end
 
-    def info(msg)
-      @loggers.each{|l| l.info(msg)}
+    attr_accessor :rundir, :date, :loggers
+
+    def initialize(dir='.')
+      @date = Time.now
+      @rundir = File.join(self.class.envdir, date_str)
+      @loggers = []
     end
 
-    def debug(msg)
-      @loggers.each{|l| l.debug(msg)}
+    def prepare!
+      FileUtils.mkdir_p(rundir) #TODO: ensure unicity
+      @loggers << Logger.new(File.join(rundir, 'environment.log'))
+      @loggers << Logger.new(STDOUT)
+      log(self.class.description, :info) unless self.class.description.empty?
+      log "Directories prepared"
     end
 
-    def has_scenario?(name)
-      @scenarii.find{|sc| sc.name == name}
+    def analyze!
+      #TODO
     end
 
-    def scenario_start_msg(sc)
-      ">>> [#{sc.name}] at #{Time.now}"
+    def log(str, lvl=:debug)
+      @loggers.each{|l| l.send(lvl, str)}
     end
 
-    def scenario_end_msg(sc)
-      "<<< [#{sc.name}] at #{Time.now}"
+    private
+
+    def date_str
+      date.strftime("%Y-%h-%d_%H-%M-%S")
     end
 
-  end
-end
+  end # class
+end # module

data/lib/laborantin/{additions/xmpp_logger.rb → core/monkey_patches.rb}

@@ -1,4 +1,4 @@
-#additions/xmpp_logger.rb
+#core/monkey_patchs.rb
 
 =begin
 
@@ -21,14 +21,12 @@ Copyright (c) 2009, Lucas Di Cioccio
 
 =end
 
-require	'xmpp4log'
-
-module Laborantin
-  class Environment
-    def log_xmpp!(user, pass, listeners, level=Logger::DEBUG)
-      xmpp = XMPPLogger.new(user, pass, listeners)
-      xmpp.level = level
-      log! xmpp
-    end
+class String
+  def camelize
+    self.split('_').map{|i| i.capitalize}.join('')
+  end
+  def duck_case
+    self.gsub(/([A-Z])/){|s| "_#{$1.downcase}"}.sub(/^_/,'')
   end
 end
+

data/lib/laborantin/core/parameter.rb

@@ -23,10 +23,11 @@ Copyright (c) 2009, Lucas Di Cioccio
 
 module Laborantin
   class ParameterRange
-    attr_accessor :name
+    attr_accessor :name, :description
     def initialize(name)
       @name = name
       @values = []
+      @description = ''
     end
 
     def values(*args)
@@ -39,5 +40,13 @@ module Laborantin
 	yield v
       end
     end
+
+    def describe(str)
+      @description = str
+    end
+
+    def to_s
+      "#{values.inspect}\n\t\t#{@description}"
+    end
   end
 end

data/lib/laborantin/core/parameter_hash.rb

@@ -35,5 +35,9 @@ module Laborantin
 	yield cfg
       end
     end
+
+    def to_s
+      keys.inject(''){|s,k| s + "\t- #{k}: #{self[k]}.\n"}
+    end
   end
 end

data/lib/laborantin/core/scenario.rb

@@ -29,13 +29,31 @@ require 'yaml'
 
 module Laborantin
   class Scenario
+    @@all = []
     class << self
-      attr_accessor :parameters, :hooks, :name, :env, :description
+      attr_accessor :description, :parameters, :products, :hooks
+
       def inherited(klass)
 	klass.parameters = ParameterHash.new
-	klass.hooks = {}
+	klass.description = ''
+	klass.products = []
+	klass.hooks = {:setup => [], :teardown => []}
+	@@all << klass
+      end
+
+      def describe(str)
+	self.description = str
+      end
+
+      def setup(*args)
+	self.hooks[:setup] = [*args].flatten
+      end
+
+      def teardown(*args)
+	self.hooks[:teardown] = [*args].flatten
       end
 
+
       def parameter(name, &blk)
 	raise ArgumentError.new("Parameter #{name} already exists") if self.parameters[name]
 	param = ParameterRange.new(name)
@@ -43,49 +61,102 @@ module Laborantin
 	self.parameters[name] = param
       end
 
-      def hook(hook, &blk)
-	self.hooks[hook] = blk
+      def produces(*args)
+	self.products = [*args].flatten
+      end
+
+      def to_s
+	"#{self.name}:\n\t#{self.description}\n#{self.parameters}"
       end
 
-      def run(&blk)
-	define_method(:run, &blk)
+      def all
+	@@all
       end
-    end # class <<
 
-    attr_accessor :params, :result_dirname, :start_date
+      def scenardir(env=nil)
+	envdir = env.rundir || '.'
+	File.join(envdir, self.name.duck_case)
+      end
+    end # class << 
 
-    def initialize(params={})
+    attr_reader :params, :environment, :date, :rundir
+    
+    def initialize(env, params={})
+      @environment = env
       @params = params
-      @start_date = Time.now
-      prepare_dir
+      @date = Time.now
+      @rundir = File.join(self.class.scenardir(environment), date_str)
     end
 
-    def prepare_dir
-      #TODO: allow configuration for this
-      @result_dirname = File.join( self.class.env.env_dirname, 
-				  self.class.name.to_s,
-				  start_date.strftime("%Y-%h-%d_%H-%M-%S") )
-      config_file = File.join( @result_dirname, 'config.txt' )
-      FileUtils.mkpath( @result_dirname )
-      File.open( config_file, 'w+') {|f| f.puts YAML.dump( [Time.now, params] ) }
+    def prepare!
+      log(self.class.description, :info) unless self.class.description.empty?
+      log self.params.inspect, :info
+      log "Preparing directory #{rundir}"
+      FileUtils.mkdir_p(rundir)  #TODO: ensure unicity
+      log "Storing configuration in YAML format"
+      File.open( config_path, 'w') {|f| f.puts YAML.dump( [date, params] ) }
     end
 
     def perform!
-      call_hook :before
-      raw_result_file = File.join( @result_dirname, 'result.raw') 
-      File.open( raw_result_file, 'w+') do |f|
-	f.puts run
+      call_hooks :setup
+      log "Starting measurement"
+      raw_result_file('w') do |f|
+	run do |l|
+	  f.puts l
+	end
+      end
+      log "Measurement finished"
+      call_hooks :teardown
+    end
+
+    def analyze!
+      self.class.products.each do |name|
+	log "Producing #{name}"
+	product_file(name.to_s, 'w') do |f|
+	  send name do |l|
+	    f.puts l
+	  end
+	end
+	log "Product #{name} done"
       end
-      call_hook :after
     end
 
-    def call_hook(name)
-      blk = self.class.hooks[name]
-      self.instance_eval(&blk) if blk
+    private
+
+    def call_hooks(name)
+      log "Calling #{name} hooks"
+      self.class.hooks[name].each{|sym| send sym}
+    end
+
+    def date_str
+      date.strftime("%Y-%h-%d_%H-%M-%S")
+    end
+
+    def log(*args)
+      environment.log *args
+    end
+
+    def product_path(resultname, brutname=false)
+      resultname = "result.#{resultname}.txt" unless brutname
+      File.join(rundir, resultname)
+    end
+
+    def product_file(resultname, mode='r', brutname=false)
+      File.open(product_path(resultname, brutname), mode) do |f|
+        yield f
+      end
+    end
+
+    def config_path
+      product_path('config.yaml', true)
+    end
+
+    def raw_result_path
+      product_path('result.raw', true)
     end
 
-    def debug(msg)
-      self.class.env.debug msg
+    def raw_result_file(mode='r')
+      product_file('result.raw', mode, true){|f| yield f}
     end
 
   end # class

data/lib/laborantin.rb

@@ -25,104 +25,11 @@ require File.join(File.dirname(__FILE__), 'laborantin', 'core', 'scenario')
 require File.join(File.dirname(__FILE__), 'laborantin', 'core', 'parameter')
 require File.join(File.dirname(__FILE__), 'laborantin', 'core', 'parameter_hash')
 require File.join(File.dirname(__FILE__), 'laborantin', 'core', 'environment')
-
-require 'optparse'
+require File.join(File.dirname(__FILE__), 'laborantin', 'core', 'monkey_patches')
 
 module Laborantin
-  VERSION = '0.0.1'
+  VERSION = '0.0.4'
   AUTHORS = ['Lucas Di Cioccio']
   WEBSITE = 'http://dicioccio.fr'
-
-  @@env = []
-
-  def environment(name='results', &blk)
-    env = Environment.new(name)
-    env.instance_eval &blk
-    @@env << env
-  end
-
-  def show_env(e)
-    puts "+==/ #{e.name} /==="
-    e.scenarii.each do |s|
-      puts "| #{s.name} : #{s.description} "
-	s.parameters.each_pair do |n, pa|
-	puts "|   [#{pa.name}] => #{pa.values.inspect}"
-	end
-    end
-    puts '+' + '=' * (e.name.to_s.size + 8)
-  end
-
-  def run_env(e)
-    e.run_scenarii!
-  end
-
-  def scan_scenario(s)
-    realisations = Dir.entries(s).select{|path| not path =~ /^\./ }
-    puts "|       [#{File.basename(s)}] => #{realisations.size} "
-  end
-
-  def scan_env(e)
-    puts "+==/ #{e} /==="
-    result_dir = e
-
-    if File.directory?(result_dir)
-      runs = Dir.entries(result_dir).select{|path| not path =~ /^\./}
-      runs.each do |r|
-	puts "|   ° #{r}"
-	env_rootname = File.join(result_dir, r)
-	scenarii = Dir.entries(env_rootname).select{|path| not path =~ /^\./}
-	scenarii.each do |s|
-	  s = File.join(env_rootname, s)
-	  scan_scenario(s) if File.directory?(s)
-	end
-      end
-    end
-    puts '+' + '=' * (e.size + 8)
-  end
-
-  at_exit do
-
-    #Default opts
-    OPTIONS = { :list => false,
-                :run  => false,
-		:scan => false,
-                :replay => false }
-
-    #Parsing
-    ARGV.options do |o|
-      script_name = File.basename($0)
-      o.set_summary_indent("\t")
-      o.banner = "Usage: #{script_name} [OPTIONS] [env1 [env2 ..]]"
-      o.on("-d", "--describe", "Describe available environments") { |OPTIONS[:list]| }
-      o.on("-r", "--run", "Run environments") { |OPTIONS[:run]| }
-      o.on("-s", "--scan", "Eye-candy scan for environments results") {|OPTIONS[:scan]|}
-      o.on_tail("-h", "--h", "Show this help.") {puts o; exit}
-      o.parse!
-    end
-
-    #Parsing remaining args
-    env_list = if ARGV.empty?
-      @@env
-    else
-      ARGV.map{|n| @@env.find{|e| e.name.to_s == n} }.compact
-    end
-
-    #Running wrt to the opts
-    if OPTIONS[:list]
-	env_list.each {|e| show_env(e) }
-	exit
-    end
-
-    if OPTIONS[:run]
-	env_list.each {|e| run_env(e) }
-	exit
-    end
-
-    if OPTIONS[:scan]
-      env_list.each {|e| scan_env(e.env_rootname)}
-      exit
-    end
-
-    puts "Run with -h or --help for help"
-  end
+  LICENSE = 'GNU GPL version 3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: laborantin
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.6
 platform: ruby
 authors: 
 - Di Cioccio Lucas
@@ -9,14 +9,14 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-16 00:00:00 +02:00
+date: 2009-07-20 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
 description: 
 email: lucas.dicioccio<@nospam@>frihd.net
-executables: []
-
+executables: 
+- labor
 extensions: []
 
 extra_rdoc_files: []
@@ -27,12 +27,19 @@ files:
 - gpl-3.0.txt
 - Rakefile
 - TODO
+- bin/labor
+- bin/files/README.erb
+- bin/files/TODO.erb
+- bin/files/config/ftp.yaml.erb
+- bin/files/config/xmpp.yaml.erb
+- bin/files/environments/environment.rb.erb
+- bin/files/scenarii/scenario.rb.erb
 - lib/laborantin.rb
 - lib/laborantin/core/environment.rb
 - lib/laborantin/core/parameter.rb
 - lib/laborantin/core/parameter_hash.rb
 - lib/laborantin/core/scenario.rb
-- lib/laborantin/additions/xmpp_logger.rb
+- lib/laborantin/core/monkey_patches.rb
 has_rdoc: false
 homepage: http://rubyforge.org/projects/laborantin
 post_install_message: