laborantin 0.0.21 → 0.1.2

data/Rakefile

@@ -56,7 +56,13 @@ spec = Gem::Specification.new do |s|
           'lib/laborantin/extra/commands/git.rb',
           'lib/laborantin/extra/commands/git/check.rb',
           'lib/laborantin/extra/commands/git/run.rb',
-          'lib/laborantin/extra/vectorial_product.rb'
+          'lib/laborantin/extra/vectorial_product.rb',
+          'lib/laborantin/core/selector.rb',
+          'lib/laborantin/core/dependencies.rb',
+          'lib/laborantin/core/verifications.rb',
+          'lib/laborantin/core/resolutions.rb',
+          'lib/laborantin/core/dependency_solver.rb',
+          'lib/laborantin/core/exports.rb',
         ]
 
         s.require_path = 'lib'

data/TODO

@@ -1,3 +1,4 @@
+*modularize logging
 new data structure:
   in config files (both env and scenarii):
     reference every rundir
@@ -17,7 +18,6 @@ commands:
   optimize (given a goal)
   estimate (cost, duration, 
     whatever defined by the user, only total sum, products?)
-  infos (gives info about the running environment)
 config dir:
 	extra libraries to require
 general:

data/lib/laborantin.rb

@@ -34,7 +34,7 @@ end
 
 
 module Laborantin
-  VERSION = '0.0.21'
+  VERSION = '0.1.2'
   AUTHORS = ['Lucas Di Cioccio']
   WEBSITE = 'http://dicioccio.fr/laborantin'
   LICENSE = 'GNU GPL version 3'

data/lib/laborantin/core/analysis.rb

@@ -25,6 +25,9 @@ autoload :ERB, 'erb'
 
 require 'laborantin/core/describable'
 require 'laborantin/core/multi_name'
+require 'laborantin/core/selector'
+require 'laborantin/core/dependencies'
+require 'laborantin/core/exports'
 
 module  Laborantin
   # An Analysis is a handy way to reload and filter the various scenarii that were
@@ -32,26 +35,14 @@ module  Laborantin
   class Analysis
     extend Metaprog::Describable
     extend Metaprog::MultiName
+    include Metaprog::Selector
+    include Metaprog::Dependencies
+    include Metaprog::Exports
 
     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
@@ -62,26 +53,6 @@ module  Laborantin
         @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)
@@ -96,12 +67,6 @@ module  Laborantin
       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|
@@ -109,6 +74,7 @@ module  Laborantin
         instance_eval &a[:blk]
         puts "done"
       end
+      save_exports
     end
 
     # TODO: more flexible
@@ -146,54 +112,27 @@ module  Laborantin
       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
+    def export_file(mode='r', &blk)
+      output('exports.yaml', mode, &blk) 
     end
 
-    # Load first the environments, then the scenarii.
-    def load_from_results
-      load_environments
-      load_scenarii
+    def export_path
+      output_path('exports.yaml')
     end
 
-    # Sets the various handy instance variables:
-    # * @plots
-    # * @tables
-    def set_instance_vars
-      @plots = self.class.plots.dup
-      @tables = self.class.tables.dup
-    end
+    attr_reader :command
 
-    # 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 
+    # Just loads the environments and scenarii from the resultdir.
+    def initialize(command = nil)
+      @command = command
+      load_prior_results
     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
+    def runner
+      command.runner if command
     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
+    private
 
     # Nice way to iterate on @scenarii
     def each_scenario

data/lib/laborantin/core/dependencies.rb

@@ -0,0 +1,37 @@
+
+require 'laborantin/core/verifications'
+
+module Laborantin
+  module Metaprog
+    module Dependencies
+      class Dependency
+        include Metaprog::Describable
+        include Metaprog::Verifications
+        attr_reader :name
+        def initialize(name)
+          @name = name
+        end
+      end
+
+      def self.included(klass)
+        klass.extend ClassMethods
+        klass.dependencies = []
+      end
+
+      module ClassMethods
+        attr_accessor :dependencies
+
+        def dependencies
+          @dependencies ||= []
+        end
+
+        def dependency(name,&blk)
+          dep = Dependency.new(name)
+          dep.instance_eval &blk
+          dependencies << dep
+          dep
+        end
+      end
+    end
+  end
+end

data/lib/laborantin/core/dependency_solver.rb

@@ -0,0 +1,30 @@
+
+module Laborantin
+  # Poor man's dependency greedy and recursive algorithm raises an error after
+  # two consecutive calls with the same previoulsy_wrong dependencies list
+  # we rely on the implementer to not create dependency loops.
+  # The whole dependency design is extremely wasteful, but it works.
+  module DependencySolver
+    def resolve_dependencies(obj, previously_wrong=[])
+      valid, wrong = obj.class.dependencies.partition do |dep|
+        dep.valid?(obj)
+      end
+
+      if wrong.empty?
+        puts "all dependencies met"
+      else
+        puts "unmet dependencies: #{wrong.map(&:name).join(' ')}"
+        if previously_wrong == wrong
+          raise RuntimeError, "already tried resolving these dependencies"
+        else
+          wrong.each do |dep|
+            # Since iterating changes the status of the dependency, we may want to re-test if a dep is valid or not.
+            # the assumption is that resolving a dep costs more than testing if it's valid or not
+            dep.verifications.each{|v| v.resolve!(obj)} unless dep.valid?(obj) 
+          end
+          resolve_dependencies(obj, wrong)
+        end
+      end
+    end
+  end
+end

data/lib/laborantin/core/exports.rb

@@ -0,0 +1,45 @@
+
+
+module Laborantin
+  module Metaprog
+    module Exports
+
+      def save_exports
+        log "saving exports: #{exports}" if respond_to? :log
+        export_file('w') do |f|
+          f.puts YAML.dump(exports)
+        end
+      end
+
+      def load_exports
+        path = export_path
+        if File.file?(path)
+          YAML.load_file(path)
+        end
+      end
+
+      def export_path
+        raise NotImplementedError, "should override"
+      end
+
+      def export_file
+        raise NotImplementedError, "should override"
+      end
+
+      def exports
+        @exports ||= load_exports || {}
+      end
+
+      def export(name, mime='plain/text')
+        log "#{mime}: #{name}" if respond_to? :log
+        exports[name] ||= mime
+      end
+
+      def plots
+        hash = exports
+        hash.keys.select{|k| hash[k] =~ /^image/}
+      end
+
+    end
+  end
+end

data/lib/laborantin/core/resolutions.rb

@@ -0,0 +1,39 @@
+
+module Laborantin
+  module Metaprog
+    module Resolutions
+      module InstanceMethods
+        attr_accessor :resolutions
+
+        def resolutions
+          @resolutions ||= []
+        end
+
+        def resolve(name=nil, &blk)
+          dep = Resolution.new(name, &blk)
+          resolutions << dep
+          dep
+        end
+
+        def resolve!(*ary)
+          resolutions.map{|r| r.resolve!(*ary)}
+        end
+      end
+
+      include InstanceMethods
+
+      class Resolution
+        attr_reader :name, :block
+        def initialize(name, &blk)
+          @name = name
+          @block = blk
+        end
+
+        def resolve!(*ary)
+          raise RuntimeError, "no block to resolve #{self}" unless block
+          block.call(*ary)
+        end
+      end
+    end
+  end
+end

data/lib/laborantin/core/scenario.rb

@@ -33,6 +33,9 @@ require 'laborantin/core/hookable'
 require 'laborantin/core/configurable'
 require 'laborantin/core/multi_name'
 require 'laborantin/core/table'
+require 'laborantin/core/selector'
+require 'laborantin/core/dependencies'
+require 'laborantin/core/exports'
 
 module Laborantin
 
@@ -50,9 +53,12 @@ module Laborantin
   class Scenario
     include Metaprog::Datable
     include Metaprog::Configurable
-    extend Metaprog::Describable
-    extend Metaprog::Hookable
-    extend Metaprog::MultiName
+    extend  Metaprog::Describable
+    extend  Metaprog::Hookable
+    extend  Metaprog::MultiName
+    include  Metaprog::Selector
+    include Metaprog::Dependencies
+    include Metaprog::Exports
 
     @@all = []
 
@@ -98,10 +104,11 @@ module Laborantin
 
       # Prepares attributes' default values whenever a subclass is created.
       def inherited(klass)
-        klass.parameters = ParameterHash.new
-        klass.description = ''
-        klass.products = []
-        klass.hooks = {:setup => [], :teardown => []}
+        klass.parameters = ParameterHash.new.replace(self.parameters || {})
+        klass.description = "#{self.description} (child of #{self})"
+        klass.products = self.products ? self.products.dup : []
+        klass.hooks = Hash.new.replace(self.hooks || {:setup => [], :teardown => []})
+        klass.selectors = Hash.new.replace(self.selectors || {})
         @@all << klass
       end
 
@@ -173,7 +180,12 @@ module Laborantin
     # so wait one sec between several runs of same Scenario
     #
     def prepare!
-      log(self.class.description, :info) unless self.class.description.empty?
+      log "Loading prior results:" 
+      load_prior_results
+      log "Got #{scenarii.size} scenarios in #{environments.size} environments"
+      log "Description:"
+      log(self.class.description || 'no description', :info) 
+      log "Parameters:"
       log self.params.inspect, :info
       log "Preparing directory #{rundir}"
       FileUtils.mkdir_p(rundir)  #TODO: ensure unicity
@@ -202,6 +214,7 @@ module Laborantin
       end
       log "Measurement finished"
       call_hooks :teardown
+      save_exports
     end
 
     # For each product define with Scenario.produces, and in its order,
@@ -217,6 +230,7 @@ module Laborantin
           end
         end
       end
+      save_exports
     end
 
     # Returns the absolute path to a product file (see File.join) If brutname
@@ -266,14 +280,12 @@ module Laborantin
       Table.new(name, struct, self.product_path(name))
     end
 
-    private
+    def export_file(mode='r', &blk)
+      product_file('exports.yaml', mode, true, &blk) 
+    end
 
-    def call_hooks(name)
-      log "Calling #{name} hooks"
-      self.class.hooks[name].each do |sym| 
-        log "(#{sym})" 
-        send sym
-      end
+    def export_path
+      product_path('exports.yaml', true)
     end
 
     def log(*args)
@@ -287,5 +299,15 @@ module Laborantin
     def runner
       environment.runner
     end
+
+    private
+
+    def call_hooks(name)
+      log "Calling #{name} hooks"
+      self.class.hooks[name].each do |sym| 
+        log "(#{sym})" 
+        send sym
+      end
+    end
   end # class
 end

data/lib/laborantin/core/selector.rb

@@ -0,0 +1,68 @@
+
+module Laborantin
+  module Metaprog
+    module Selector
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        # A hash with two items, this might change later but KISS for now.
+        attr_accessor :selectors
+
+        # 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
+      end
+
+      # 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
+
+      # Load first the environments, then the scenarii.
+      def load_prior_results
+        load_environments
+        load_scenarii
+      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)
+        return true unless selector
+        blk = selector[:blk]
+        (selector[:klasses].any?{|k| obj.is_a? k} ) and
+        (blk ? blk.call(obj) : true)
+      end
+
+    end
+  end
+end

data/lib/laborantin/core/table.rb

@@ -17,7 +17,7 @@ module Laborantin
     end
 
     def header
-      @header || [comment, fields].flatten.join(separator)
+      @header || [comment, fields].flatten.join(separator).strip
     end
 
     class Filler < Proc
@@ -43,8 +43,8 @@ module Laborantin
       end
       line = strings.join(separator)
       if check
-        if line.start_with?(comment)
-          raise ArgumentError, "line starting with comment\n#{line}"
+        if line.start_with?(comment) and (not comment.empty?)
+          raise ArgumentError, "line starting with comment\n#{line}" 
         end
         expected = struct.members.size
         got = line.split(separator).size

data/lib/laborantin/core/verifications.rb

@@ -0,0 +1,48 @@
+require 'laborantin/core/resolutions'
+
+module Laborantin
+  module Metaprog
+    module Verifications
+      module InstanceMethods
+        attr_accessor :verifications
+
+        def verifications
+          @verifications ||= []
+        end
+
+        def verify(name, &blk)
+          dep = Verification.new(name)
+          dep.instance_eval &blk
+          verifications << dep
+          dep
+        end
+
+        def valid?(*ary)
+          verifications.inject(true){|b,verif| b && verif.correct?(*ary)}
+        end
+      end
+
+      include InstanceMethods
+
+      class Verification
+        include Metaprog::Describable
+        include Metaprog::Resolutions
+        attr_reader :name, :block
+        def initialize(name)
+          @name = name
+        end
+
+        def check(&blk)
+          @block = blk
+        end
+
+        def correct?(*ary)
+          raise RuntimeError, "no block for verification #{self}" unless block
+          block.call(*ary) && valid?(*ary)
+        end
+
+        include InstanceMethods
+      end
+    end
+  end
+end

data/lib/laborantin/runner/commands/analyze.rb

@@ -21,9 +21,13 @@ Copyright (c) 2009, Lucas Di Cioccio
 
 =end
 
+require 'laborantin/core/dependency_solver'
+
 module Laborantin
   module Commands
     class Analyze < Command
+      include DependencySolver
+
       describe "Runs the analyses"
 
       option(:analyses) do
@@ -50,7 +54,9 @@ module Laborantin
 
         anae.each do |klass|
           puts "Analyzing: #{klass.name}"
-          klass.new.analyze
+          analysis = klass.new(self)
+          resolve_dependencies(analysis)
+          analysis.analyze
         end
       end
     end

data/lib/laborantin/runner/commands/run.rb

@@ -22,12 +22,14 @@ Copyright (c) 2009, Lucas Di Cioccio
 =end
 
 require 'laborantin'
+require 'laborantin/core/dependency_solver'
 require 'logger'
 require 'fileutils'
 
 module Laborantin
   module Commands
     class Run < Command
+      include DependencySolver
       describe 'Runs all set of scenarios and environments'
 
       option(:scenarii) do
@@ -110,6 +112,7 @@ module Laborantin
 
                   sc = sklass.new(env, cfg)
                   sc.prepare!
+                  resolve_dependencies(sc)
                   sc.perform!
                   sc.analyze! if opts[:analyze]
                 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: laborantin
 version: !ruby/object:Gem::Version 
+  hash: 31
   prerelease: false
   segments: 
   - 0
-  - 0
-  - 21
-  version: 0.0.21
+  - 1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Lucas Di Cioccio
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-09 00:00:00 -04:00
+date: 2011-07-21 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -68,6 +69,12 @@ files:
 - lib/laborantin/extra/commands/git/check.rb
 - lib/laborantin/extra/commands/git/run.rb
 - lib/laborantin/extra/vectorial_product.rb
+- lib/laborantin/core/selector.rb
+- lib/laborantin/core/dependencies.rb
+- lib/laborantin/core/verifications.rb
+- lib/laborantin/core/resolutions.rb
+- lib/laborantin/core/dependency_solver.rb
+- lib/laborantin/core/exports.rb
 has_rdoc: true
 homepage: http://dicioccio.fr/laborantin
 licenses: []
@@ -82,6 +89,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -90,6 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"