ttk 0.1.576

data/lib/ttk/loaders/YamlOld.rb

@@ -0,0 +1,65 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: YamlOld.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+require 'yaml'
+
+class Object # :nodoc:
+  def yaml_load_map
+    self
+  end
+end
+
+class Array # :nodoc:
+  def yaml_load_map
+    map { |x| x.yaml_load_map }
+  end
+end
+
+class Hash # :nodoc:
+  def yaml_load_map
+    res = {}
+    each do |k,v|
+      k = k.to_s.to_sym unless k.is_a? Symbol or k.is_a? Integer
+      if k == :class or k == :strategy
+        if k == :class
+          k = :strategy
+        end
+        unless v.is_a? Strategies::Strategy
+          v = v.to_s
+          if v =~ /TestT/
+            v.gsub!(/TestTBase/, 'Strategy')
+            v.gsub!(/TTK::Test::TestT/, 'TTK::Strategies::')
+            v.gsub!(/Test::TestT/, 'Strategies::')
+            v.gsub!(/TestT/, '')
+          end
+        end
+        res[k] = Loaders.get_class(v)
+      elsif k == :content
+        res[:contents] = v.yaml_load_map
+      else
+        res[k] = v.yaml_load_map
+      end
+    end
+    res
+  end
+end
+
+module TTK
+
+  module Loaders
+
+    class YamlOld < Loader
+      include Concrete
+
+      def load_doc(io)
+	YAML::load(io).yaml_load_map
+      end
+
+    end # class Yaml
+
+  end # module Loaders
+
+end # module TTK

data/lib/ttk/logger.rb

@@ -0,0 +1,237 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: logger.rb 571 2005-04-13 14:41:22Z polrop $
+
+
+require 'observer'
+
+require 'ttk/logger/severity'
+require 'ttk/logger/to_ttk_log'
+require 'ttk/logger/section_node'
+require 'ttk/logger/path'
+require 'ttk/logger/verbosity'
+
+
+module TTK
+
+  class Logger
+
+    include Observable
+
+    TYPES = [ :map, :seq ]
+
+    MESSAGES = [ :new_node, :new_leaf, :up, :close ]
+
+    def initialize ( *observers )
+      @path = []
+      observers.flatten.each { |obs| add_observer(obs) }
+      @closed = false
+      @sections = []
+      @section_tree = SectionNode.new('all')
+      @severity_level = Severity::DEBUG
+      @nb_log_msg = 0
+      @verbosity = Verbosity.new
+      @verbosity_level = 0
+    end
+
+    attr_reader :severity_level
+
+    def severity_level=(severity_level)
+      if severity_level.is_a?(String)
+        severity_level = Severity.const_get(severity_level.to_s.upcase)
+      end
+      if Severity.lower <= severity_level and severity_level <= Severity.higher
+        @severity_level = severity_level
+      else
+        raise(ArgumentError, "`#{severity_level}' - invalid severity level")
+      end
+    end
+
+    attr_accessor :section_tree
+
+    def active_section(active, *section_names)
+      @sections = @section_tree.set_active_section(active, *section_names)
+      nil
+    end
+
+    def active_section?(section_name)
+      @sections.include?(section_name)
+    end
+
+    attr_reader :verbosity
+
+    def verbosity=(verbosity)
+      unless verbosity.is_a?(Verbosity)
+        raise(ArgumentError,
+              "`#{verbosity}' - must inherit from Verbosity")
+      end
+      @verbosity = verbosity
+    end
+
+    attr_reader :verbosity_level
+
+    def verbosity_level=(verbosity_level)
+      if verbosity_level < 0
+        raise(ArgumentError,
+              "`#{verbosity_level}' - " +
+              'verbosity level must be positive or null')
+      end
+      @verbosity_level = verbosity_level
+    end
+
+    def log(severity_level=nil, *section_names, &block)
+      severity_level ||= Severity.higher
+      return true if severity_level < @severity_level
+      if section_names.empty?
+        format_log_message(severity_level, section_names, &block)
+      else
+        section_names.each do |s|
+          if @sections.include?(s)
+            format_log_message(severity_level, section_names, &block)
+            break
+          end
+        end
+      end
+    end
+
+    def format_log_message(severity_level, section_names, &block)
+      new_node("log_#@nb_log_msg") do
+        if @verbosity_level == 0
+          block[].to_ttk_log(self)
+        else
+          for i in 1..@verbosity_level do
+            @verbosity.class.level_fields(i).each do |field|
+              self[field] = @verbosity.send(field,
+                                            severity_level,
+                                            section_names)
+            end
+          end
+          self['message'] = block[]
+        end
+      end
+      @nb_log_msg += 1
+    end
+    protected :format_log_message
+
+    def new_node ( node, type=:map, &block )
+      raise ArgumentError, "bad node type: #{type}" unless TYPES.include? type
+      node = node.to_s.to_sym unless node.is_a? Symbol or node.is_a? Integer
+
+      begin
+        @path << [node, type]
+        notif :new_node, @path.dup
+      rescue Exception => ex
+        up if block_given?
+        raise ex
+      end
+
+      if block_given?
+        begin
+          block[]
+        ensure
+          up
+        end
+      end
+    end
+
+    def up
+      @path.pop
+      notif :up, @path.dup
+    end
+
+    def new_leaf ( x )
+      notif :new_leaf, @path.dup, x
+    end
+
+    def []= ( k, v )
+      new_node(k) do
+        v.to_ttk_log(self)
+      end
+    end
+
+    def << ( v )
+      v.to_ttk_log(self)
+    end
+
+    def method_missing ( key, *a, &b )
+      str = key.to_s
+      case str
+      when /^(.*)=$/
+        self[$1.to_sym] = a[0]
+      when /^log_/
+        begin
+          args = make_log_arguments(str)
+          args.concat([ *a ])
+          self.log(*args, &b)
+        rescue ArgumentError
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def make_log_arguments(str)
+      if str =~ /^log_([A-Za-z0-9]+)(.*)$/
+        args = []
+        begin
+          args << Severity.const_get($1.upcase)
+        rescue NameError
+          raise(NameError, "`#{$1}' - unknown severity level")
+        end
+        while $2 =~ /^_([A-Za-z0-9]+)(.*)$/
+          args << $1
+        end
+        args
+      else
+        raise(ArgumentError, "`#{str}' - bad format")
+      end
+    end
+
+    def path
+      Path.new(@path)
+    end
+
+    def path_size
+      @path.size
+    end
+
+    def to_s
+      "#<#{self.class} path=#{path}>"
+    end
+
+    alias :inspect :to_s
+
+    # FIXME : WARNING
+    #
+    # r = Logger.new
+    # r.new_node(:root)
+    # r.update(:new_node, [:another_path], :foo) # it's incorrect
+    def update ( msg, *args )
+      notif(msg, *args) if MESSAGES.include? msg
+    end
+
+    def notif ( *args )
+      changed
+      notify_observers(*args)
+    end
+
+    private :notif, :notify_observers, :changed
+
+    def close
+      unless @closed
+        @closed = true
+        notif(:close)
+      end
+    end
+
+    def closed?
+      @closed
+    end
+
+  end # class Logger
+
+end # module TTK
+
+

data/lib/ttk/logger/path.rb

@@ -0,0 +1,23 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: path.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  class Logger
+
+    class Path < Array
+
+      def to_s
+        '/' + map{ |x| x[0] }.join('/')
+      end
+
+      alias :inspect :to_s
+
+    end # class Path
+
+  end # class Logger
+
+end # module TTK

data/lib/ttk/logger/section_node.rb

@@ -0,0 +1,214 @@
+# Author::    Nicolas Despres  <nicolas.despres@gmail.com>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: section_node.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  class Logger
+
+    # Implement a tree of section. A section node has a name and a `active'
+    # flag that say if the section node is on/off. A section tree verifies the
+    # following property:
+    #
+    #    a node is active iff at least one of its sub nodes is active
+    #
+    # Obviously, when activating a node, all its sub nodes are also activated.
+    class SectionNode
+
+      def initialize(name, *sub_sections)
+        self.name = name
+        @sub_sections = {}
+        sub_sections.each { |s| self << s }
+        @active = false
+      end
+
+      attr_reader :name
+
+      def name=(new_name)
+        @name = new_name.to_s
+      end
+
+      def sub_sections
+        @sub_sections.values
+      end
+
+      def [](name)
+        @sub_sections[name]
+      end
+
+      def []=(name, sub_section)
+        check_sub_section_type(sub_section)
+        sub_section.name = name
+        @sub_sections[sub_section.name] = sub_section
+      end
+
+      def <<(sub_section)
+        check_sub_section_type(sub_section)
+        @sub_sections[sub_section.name] = sub_section
+      end
+
+      def push(*sub_sections)
+        sub_sections.each { |ss| self << ss }
+      end
+
+      def active=(new_active)
+        active_tree(new_active)
+        @active
+      end
+
+      def active?
+        @active
+      end
+
+      def active_tree(new_active)
+        accu = []
+        active_tree_rec(new_active, accu) unless new_active == @active
+        accu
+      end
+
+      def active_tree_rec(new_active, accu)
+        @active = new_active
+        accu << @name
+        @sub_sections.each_value { |s| s.active_tree_rec(new_active, accu) }
+      end
+      protected :active_tree_rec
+
+      # Active the given section name in the tree. Return an array of all the
+      # section name that have been activated. The returned array is empty if
+      # the section name doesn't exists in the tree.
+      def active_section(section_name)
+        accu = []
+        active_section_rec(section_name, accu)
+        accu
+      end
+
+      def active_section_rec(section_name, accu)
+        if @name == section_name
+          accu.concat(active_tree(true))
+          true
+        else
+          ret = false
+          @sub_sections.each_value do |s|
+            if s.active_section_rec(section_name, accu)
+              @active = true
+              accu << @name
+              ret = true
+              break
+            end
+          end
+          ret
+        end
+      end
+      protected :active_section_rec
+
+      # Unactive the given section name in the tree. Return an array of all the
+      # section name that have been unactivated. The returned array is empty if
+      # the section name doesn't exists in the tree or if none section have
+      # been unactivated.
+      def unactive_section(section_name)
+        accu = []
+        unactive_section_rec(section_name, accu)
+        accu
+      end
+
+      def unactive_section_rec(section_name, accu)
+        if @name == section_name
+          accu.concat(active_tree(false))
+          true
+        else
+          not_unactivable = ret = false
+          @sub_sections.each_value do |s|
+            ret ||= s.unactive_section_rec(section_name, accu)
+            not_unactivable ||= s.active?
+          end
+          if ret and (not not_unactivable)
+            @active = false
+            accu << @name
+            true
+          else
+            false
+          end
+        end
+      end
+      protected :unactive_section_rec
+
+      def set_active_section(active, *section_names)
+        section = []
+        section_names.each do |s|
+          section.concat(active ? active_section(s) : unactive_section(s))
+        end
+        section.uniq!
+        section
+      end
+
+      def each(&block)
+        @sub_sections.each(&block)
+      end
+
+      alias :each_pair :each
+
+      def each_section(&block)
+        @sub_sections.each_value(&block)
+      end
+
+      alias :each_value :each_section
+
+      def each_label(&block)
+        @sub_sections.each_key(&block)
+      end
+
+      alias :each_key :each_label
+
+      def delete(name)
+        @sub_sections.delete(name)
+      end
+
+      def clear(name)
+        @sub_sections.clear
+      end
+
+      def nb_sub_sections
+        @sub_sections.size
+      end
+
+      alias :size :nb_sub_sections
+      alias :length :nb_sub_sections
+
+      def leaf?
+        @sub_sections.empty?
+      end
+
+      def pre_depth_first(&block)
+        block[self]
+        @sub_sections.each_value { |s| s.pre_depth_first(&block) }
+        nil
+      end
+
+      def find(name)
+        if @name == name
+          self
+        else
+          @sub_sections.each_value do |s|
+            ret = s.find(name)
+            return ret unless ret.nil?
+          end
+          nil
+        end
+      end
+
+      protected
+      def check_sub_section_type(sub_section)
+        unless sub_section.is_a?(self.class)
+          raise(TypeError, "`#{sub_section}' - must be a #{self.class}")
+        end
+      end
+
+    end # class SectionNode
+
+  end # class Logger
+
+end # module TTK
+
+