laborantin 0.0.14 → 0.0.21

data/lib/laborantin.rb

@@ -21,34 +21,21 @@ Copyright (c) 2009, Lucas Di Cioccio
 
 =end
 
-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 File.join(File.dirname(__FILE__), 'laborantin', 'core', 'monkey_patches')
+[ 'laborantin/core/scenario',
+  'laborantin/core/parameter',
+  'laborantin/core/parameter_hash',
+  'laborantin/core/environment',
+  'laborantin/core/analysis',
+  'laborantin/core/command',
+  'laborantin/core/monkey_patches'
+].each do |dep|
+  require dep
+end
+
 
 module Laborantin
-  VERSION = '0.0.14'
+  VERSION = '0.0.21'
   AUTHORS = ['Lucas Di Cioccio']
-  WEBSITE = 'http://dicioccio.fr'
+  WEBSITE = 'http://dicioccio.fr/laborantin'
   LICENSE = 'GNU GPL version 3'
-
-  @@rootdir = '.'
-
-  # The root of the arborescence for Laborantin. Usually the directory created
-  # via the scripts.
-  def self.rootdir
-    @@rootdir || '.'
-  end
-
-  # Specifies the rootdir, dir is a path (instance of String, not a Dir object).
-  def self.rootdir=(dir='.')
-    @@rootdir = dir
-  end
-
-  # The path to the results (needs the Laborantin.rootdir).
-  def self.resultdir
-    File.join(Laborantin.rootdir, 'results')
-  end
-
 end

data/lib/laborantin/core/analysis.rb

@@ -0,0 +1,231 @@
+#core/analysis.rb
+
+=begin
+
+This file is part of Laborantin.
+
+Laborantin is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Laborantin is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Laborantin.  If not, see <http://www.gnu.org/licenses/>.
+
+Copyright (c) 2009, Lucas Di Cioccio
+
+=end
+
+autoload :ERB, 'erb'
+
+require 'laborantin/core/describable'
+require 'laborantin/core/multi_name'
+
+module  Laborantin
+  # An Analysis is a handy way to reload and filter the various scenarii that were
+  # run. You can easily filter on them.
+  class Analysis
+    extend Metaprog::Describable
+    extend Metaprog::MultiName
+
+    class << self
+      # A hash with two items, this might change later but KISS for now.
+      attr_accessor :selectors
+
+      # An array
+      attr_accessor :analyses
+
+      # Add a selector to filter for the analysis only the runs that pass the selector.
+      # * sym objects (sym currently must be :environments or 
+      # :scenarii).
+      # * ary is a set of classes, only runs of this classes will be loaded
+      # * if a block is passed, only the instances for which the block is
+      # evaluated as true will be selected  (the block must take one parameter:
+      # the tested instance)
+      def select(sym, ary=[], &blk) 
+        @selectors ||= {} 
+        @selectors[sym] = {:klasses => ary, :blk => blk} 
+      end
+
+      # Adds an analysis to this class.
+      # str is a description of the added analysis params is a hash of
+      # parameters for this analysis, specifically, the :type parameters allows
+      # you to differenciate the kind of analysis for repors TODO: more info on
+      # that, tells that we can directly use Analysis.plot and Analysis.table
+      # methods
+      def analyze(str, params = {}, &blk) 
+        @analyses << {:str => str, :params => params, :blk => blk} 
+      end
+
+      def plot(title, args, &blk)
+          args ||= {}
+          hash = args.merge({:type => :plot})
+          analyze(title, hash, &blk)
+      end
+
+      def table(title, args, &blk)
+          args ||= {}
+          hash = args.merge({:type => :table})
+          analyze(title, hash, &blk)
+      end
+
+      def plots
+        analyses.select{|a| a[:params][:type] == :plots}
+      end
+
+      def tables
+        analyses.select{|a| a[:params][:type] == :tables}
+      end
+
+      @@all = []
+
+      def inherited(klass)
+        @@all << klass
+        klass.select(:environments,[Laborantin::Environment])
+        klass.select(:scenarii,[Laborantin::Scenario])
+        klass.analyses = []
+      end
+
+      def all
+        @@all
+      end
+    end # << self
+
+    # An array of the Environments that could be loaded from the result directory.
+    attr_accessor :environments
+
+    # An array of the Scenarii that could be loaded from the result directory.
+    attr_reader :scenarii
+
+    # TODO : recode this, maybe as nothing to do here
+    def analyze 
+      self.class.analyses.each do |a|
+        puts "(#{a[:str]})"
+        instance_eval &a[:blk]
+        puts "done"
+      end
+    end
+
+    # TODO: more flexible
+    def report(tpl_path=nil)
+      tpl = ERB.new(File.read(tpl_path))
+      File.open("reports/#{self.class.name}.html", 'w') do |f|
+        f.puts tpl.result(binding)
+      end
+    end
+
+    def output_dirname
+      self.class.cli_name
+    end
+
+    def output_dirpath
+      File.join('.', 'reports', output_dirname)
+    end
+
+    def create_output_dir
+      FileUtils.mkdir_p(output_dirpath) unless File.directory?(output_dirpath)
+    end
+
+    def output_path(name)
+      File.join(output_dirpath, name)
+    end
+
+    def output(name, mode='r')
+      create_output_dir
+      File.open(output_path(name), mode) do |f|
+        yield f
+      end
+    end
+
+    def table(name, struct)
+      Table.new(name, struct, self.output_path(name))
+    end
+
+    private
+
+    # Just loads the environments and scenarii from the resultdir.
+    def initialize(*args, &blk)
+      load_from_results
+      set_instance_vars
+    end
+
+    # Load first the environments, then the scenarii.
+    def load_from_results
+      load_environments
+      load_scenarii
+    end
+
+    # Sets the various handy instance variables:
+    # * @plots
+    # * @tables
+    def set_instance_vars
+      @plots = self.class.plots.dup
+      @tables = self.class.tables.dup
+    end
+
+    # Will try to load environments and set the @environments variable to an
+    # array of all the Environment instance that match the :environments class
+    # selector (set with Analysis#select).
+    def load_environments 
+      envs = Laborantin::Environment.scan_resdir('results')
+      @environments = envs.select do |env| 
+        select_instance?(env, self.class.selectors[:environments])
+      end 
+    end
+
+    # Same as load_environments, but for Scenario instances and :scenarii
+    # selector.
+    def load_scenarii
+      scii = @environments.map{|e| e.populate}.flatten
+      @scenarii = scii.select do |sc|
+        select_instance?(sc, self.class.selectors[:scenarii])
+      end
+    end
+
+    # Handy test to see if an object (that should be an instance of Environment
+    # or Scenario) matches the selector.
+    def select_instance?(obj, selector)
+      blk = selector[:blk]
+      (selector[:klasses].any?{|k| obj.is_a? k} ) and
+      (blk ? blk.call(obj) : true)
+    end
+
+    # Nice way to iterate on @scenarii
+    def each_scenario
+      @scenarii.each do |sc|
+        yield sc
+      end
+    end
+
+    # Nice way to iterate on @environments
+    def each_environment
+      @environments.each do |env|
+        yield env
+      end
+    end
+
+    # The list of parameters spanned from the scenarii.
+    # e.g. scenario 1, params = A => a1, B => b1
+    #      scenario 2, params = A => a2, B => b2
+    #      scenario 3, params = C => c3
+    #      parameters = A => [a1, a2], B => [b1, b2], C => [c3]
+    def parameters
+      unless @parameters
+        @parameters = {}
+        each_scenario do |sc|
+          sc.params.each_pair do |name, value|
+            @parameters[name] ||= []
+            @parameters[name] << value unless @parameters[name].include?(value)
+          end
+        end
+      end
+      @parameters
+    end
+
+  end
+end

data/lib/laborantin/core/command.rb

@@ -0,0 +1,234 @@
+#core/command.rb
+
+=begin
+
+This file is part of Laborantin.
+
+Laborantin is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Laborantin is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Laborantin.  If not, see <http://www.gnu.org/licenses/>.
+
+Copyright (c) 2009, Lucas Di Cioccio
+
+=end
+
+require 'laborantin/core/completeable'
+
+module Laborantin
+  # The Command is a way to extend the labor script to help you modularize your
+  # work, and call the commands both via the command line, or in your scripts.
+  # This class provides parsing facilities. Namespacing (i.e., mapping between
+  # classes and command line is done in the Runner .  Internal labor Commands
+  # are actually implemented this way.
+  class Command
+
+    # An Option for a Command, to help us building a nice DSL for you.
+    class Option
+
+      include Metaprog::Completeable
+
+      # The name of the option.
+      attr_reader :name
+      
+      # The short option flag of the command line (e.g. '-t')
+      attr_reader :cli_short
+      
+      # The long option flag of the command line (e.g. '--trust')
+      attr_reader :cli_long
+      
+      # The description to provide feedback/help.
+      attr_reader :description
+     
+      # The default value of this option.
+      attr_reader :default_value
+     
+      # The type to expect for a value (give a class among those understood by OptParse)
+      attr_reader :default_type
+
+      def initialize(name)
+        @name = name
+      end
+
+      # Sets the cli_short option flag (e.g. short '-t')
+      def short(str)
+        @cli_short = str
+      end
+
+      # Sets the cli_long option flag (e.g. long '--trust')
+      def long(str)
+        @cli_long = str
+      end
+
+      # Sets the description of the option.
+      def describe(str)
+        @description = str
+      end
+
+      # Sets the default value of the option.
+      def default(val)
+        @default_value = val
+      end
+
+      # Sets the type to expect for the option.
+      def type(klass)
+        @default_type = klass
+      end
+
+      # Returns the description followed by the default value in parenthesis.
+      def description_with_default
+        "#{description} (default: #{default_value})."
+      end
+    end
+
+    # An Array to store all the commands.
+    @@all = []
+
+    extend Enumerable
+
+    # Once we've extended Enumerable, it's easy to find new commands.
+    def self.each
+      @@all.each{|e| yield e}
+    end
+
+    class << self
+
+      include Metaprog::Completeable
+
+      # The description string of a command, will be used on command line help.
+      attr_accessor :description
+
+      # Wether or not this command is a plumbery one.
+      attr_accessor :plumbery
+      
+      # An Array contining the possible options of this command.
+      attr_accessor :options
+     
+      # The block of execution for the instances of this commands.
+      # By default, this will raise an exception.
+      # TODO: transform the block into a default method.
+      attr_accessor :block
+     
+      # The command name, can be set, this is useful when the class has no name
+      # (e.g. an object created with Class.new(Command)), or if you want to use
+      # another name for this command.
+      attr_accessor :command_name
+
+      # By default, the name of the class, or an empty string if none (this can
+      # lead to big issues, so I'm still considering returning nil if a command
+      # has no name nor command_name.
+      def command_name
+        (@command_name || self.name ) || ''
+      end
+
+      # When a new Command class is created, sets up default value, and store
+      # the new class in the known commands.
+      def inherited(klass)
+        klass.description = ''
+        klass.options = []
+        klass.block = lambda { raise RuntimeError.new("no execution block for #{klass}") }
+        @@all << klass
+      end
+
+      # Set the description string.
+      def describe(str=nil)
+        self.description = str
+      end
+
+      # Sets the plumbery flag.
+      def plumbery!(val=true)
+        self.plumbery = val
+      end
+
+      # Returns true if the plumbery flag is true.
+      def plumbery?
+        self.plumbery && true
+      end
+
+      # Opposite of plumbery?
+      def porcelain?
+        not self.plumbery?
+      end
+
+      # Set the execution block (executed in the scope of the instance).
+      # XXX this might well be changed into requiring ppl to define an "execute" method.
+      def execute(&blk)
+        self.block = blk
+      end
+
+      # Assign a new option to this command class, which name is name
+      # (preferably, give Symbol or String).  The blk is evaluated in the scope
+      # of a new Option instance.
+      # Giving a name is required, because it is also the key of the command.opts hash.
+      def option(name, &blk)
+        arg = Option.new(name) 
+        arg.instance_eval &blk
+        self.options << arg
+      end
+    end # << self
+
+    # A hash containing a merge of the defaults options of the class and the
+    # extra options provided to the run method.
+    # Think of it like the '--path=/some/path' options of a command line.
+    # Options are labeled but not ordered, arguments are the opposite.
+    attr_reader :opts
+
+    # An array containing the arguments of the command. 
+    # Think of it like the trailing arguments of a command line.
+    # Arguments are ordered but not labeled, options are the opposite.
+    attr_reader :args
+
+    # The Runner object that will executes the command.
+    attr_accessor :runner
+
+    # Initializes a new instance of command.  Will first set the runner if
+    # provided, then will initialize default options and arguments.
+    def initialize(runner=nil)
+      @runner = runner
+      initialize_opts
+      initialize_args
+    end
+
+    # Runs the command by merging the options with extra_opts and evaluating
+    # the block stored in the class.
+    def run(args=[], extra_opts={})
+      @opts.merge!(extra_opts)
+      @args = args
+      self.instance_eval &self.class.block
+    end
+
+    # Forward a line to the runner if it respond to a puts method too.
+    # Fallback on Kernel.puts if there is no runner or the runner does 
+    # not respond to puts.
+    def puts(line)
+      if runner and runner.respond_to?(:puts)
+        runner.puts(line)
+      else
+        Kernel.puts(line)
+      end
+    end
+
+    private
+
+    # Just initialize the opts to an empty Array
+    def initialize_args
+      @args = []
+    end
+
+    # Grabs the default values of the options from the class of the command.
+    def initialize_opts
+      @opts = {}
+      self.class.options.each do |arg|
+        @opts[arg.name] = arg.default_value
+      end
+    end
+  end
+end