uttk 0.3.1.2

data/lib/uttk/logger/path.rb

@@ -0,0 +1,202 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/lib/uttk/logger/path.rb 22244 2006-02-25T10:48:53.146614Z pouillar  $
+
+require 'forwardable'
+
+module Uttk
+
+  class Logger
+
+    class Segment
+      attr_accessor :segment, :options
+      def initialize ( segment, options=nil )
+        raise if segment.is_a? Segment
+        @segment, @options = segment, (options || {})
+      end
+      def initialize_copy ( rhs )
+        @segment, @options = rhs.segment.try_dup, rhs.options.dup
+      end
+      def == ( rhs )
+        rhs.is_a?(self.class) && @segment == rhs.segment && @options == rhs.options
+      end
+      def self.quote ( s )
+        s.gsub(/(?:([\/\]\[])|\\(.))/, '\\\\\1\2')
+      end
+      def quoted_segment
+        Segment.quote(@segment.to_s)
+      end
+      def regexp_quoted_segment
+        Segment.quote(Regexp.quote(@segment.to_s))
+      end
+    end # class Segment
+
+    class Path
+
+      def initialize ( anArray=[] )
+        @contents = []
+        anArray.each { |x| self << x }
+      end
+
+      def initialize_copy ( rhs )
+        @contents = rhs.instance_variable_get(:@contents).map { |x| x.dup }
+      end
+
+      extend Forwardable
+
+      def_delegators :@contents, :map, :size, :each, :each_with_index, :[],
+                     :empty?, :last, :pop, :delete_if
+
+
+      def << ( seg )
+        @contents <<
+          case seg
+            when Segment then seg
+            else Segment.new seg
+          end
+      end
+
+
+      def to_a
+        map { |x| x.segment }
+      end
+
+
+      def + ( rhs )
+        if rhs.is_a? Path
+          tab = rhs.instance_variable_get(:@contents)
+        else
+          tab = rhs.to_a
+        end
+        self.class.new(@contents + tab)
+      end
+
+
+      def to_s
+        '/' + map { |x| x.quoted_segment }.join('/')
+      end
+
+
+      def inspect
+        return '/' if @contents.empty?
+        result = ''
+        each do |seg|
+          result << '/' << seg.quoted_segment
+          unless seg.options.empty?
+            opts = []
+            opts << 'ordered' if seg.options[:ordered]
+            if type = seg.options[:type]
+              opts << "type: #{type}"
+            end
+            result << '[' << opts.join(', ') << ']'
+          end
+        end
+        result
+      end
+
+      def to_regex_path_string
+        '/' + map { |x| x.regexp_quoted_segment }.join('/')
+      end
+
+
+      def to_regex_path
+        RegexPath.new(to_regex_path_string)
+      end
+
+
+      def rpath ( re, &block )
+        # We work with uncaptured path here
+
+        args = []
+
+        raise NotImplementedError unless re.root? or re.final?
+
+        re_segs = re.segments
+        segs = to_a
+
+        if re.final?
+          re_segs = re_segs.reverse
+          segs = segs.reverse
+        end
+
+        re_segs.zip(segs).each do |re_seg, seg|
+          if re.negative?
+            break if seg.nil? or re_seg !~ seg.to_s
+            return
+          else
+            return if seg.nil?
+            if match_data = re_seg =~ seg.to_s
+              args << match_data.to_a[1..-1]
+            else
+              return
+            end
+          end
+        end
+
+        args.reverse! if re.final?
+
+        block[self, *args.flatten]
+        nil
+      end
+
+
+      def rpath_prefix ( re )
+        re_segs = re.segments
+        re_segs.zip(to_a).each_with_index do |args, i|
+          re_seg, seg = args
+          return false if seg.nil?
+          return false unless re_seg =~ seg.to_s
+          re_seg = re_segs[i+1]
+          return true if re_seg and re_seg.captured?
+        end
+
+        raise ArgumentError, 'no capture'
+      end
+
+
+      def lpath_prefix ( re )
+        re_segs = re.segments
+        re_segs.zip(to_a).each_with_index do |args, i|
+          re_seg, seg = args
+          return true if seg.nil?
+          return false unless re_seg =~ seg.to_s
+          re_seg = re_segs[i+1]
+          return true if re_seg and re_seg.captured?
+        end
+
+        raise ArgumentError, 'no capture'
+      end
+
+
+      def to_logger_path
+        self
+      end
+
+      def == ( rhs )
+        rhs.is_a?(self.class) && @contents == rhs.instance_variable_get(:@contents)
+      end
+
+    end # class Path
+
+  end # class Logger
+
+end # module Uttk
+
+
+
+class Array
+
+  def to_logger_path
+    obj = Uttk::Logger::Path.new
+    each do |x|
+      if x.is_a? Array
+        obj << Uttk::Logger::Segment.new(*x)
+      else
+        obj << x
+      end
+    end
+    obj
+  end
+
+end # class Array

data/lib/uttk/logger/section_node.rb

@@ -0,0 +1,214 @@
+# Author::    Nicolas Despres  <nicolas.despres@gmail.com>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /fey/uttk/trunk/lib/uttk/logger/section_node.rb 8778 2005-09-26T04:34:48.103938Z ertai  $
+
+
+module Uttk
+
+  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 Uttk
+
+

data/lib/uttk/logger/severity.rb

@@ -0,0 +1,63 @@
+# Author::    Nicolas Despres  <nicolas.despres@gmail.com>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /fey/uttk/trunk/lib/uttk/logger/severity.rb 8778 2005-09-26T04:34:48.103938Z ertai  $
+
+
+module Uttk
+
+  class Logger
+
+    module Severity
+
+      @@labels = %w(DEBUG VERBOSE_INFO INFO WARN ERROR FATAL UNKNOWN)
+      @@lower = 0
+      @@higher = @@labels.size - 1
+
+      @@labels.each_with_index do |label, i|
+        const_set(label, i)
+      end
+
+      module_function
+
+      def lower
+        @@lower
+      end
+
+      def higher
+        @@higher
+      end
+
+      def unshift(*levels)
+        levels.each do |l|
+          @@lower -= 1
+          const_set(l, @@lower)
+          @@labels.unshift(l)
+        end
+      end
+
+      def push(*levels)
+        levels.each do |l|
+          @@higher += 1
+          const_set(l, @@higher)
+          @@labels.push(l)
+        end
+      end
+
+      # FIXME add the insert method
+
+      def label(level)
+        @@labels[level]
+      end
+
+      def labels
+        @@labels
+      end
+
+    end # module Severity
+
+  end # class Logger
+
+end # module Uttk
+
+