uttk 0.3.1.2

data/lib/uttk/dumpers/Yaml.rb

@@ -0,0 +1,138 @@
+# 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/dumpers/Yaml.rb 21970 2006-02-19T22:15:36.271512Z pouillar  $
+
+class Symbol
+  alias_method :old_to_yaml, :to_yaml
+  def to_yaml ( opts={} )
+    if YAML.have_option? opts, :uttk
+      self.to_s.to_yaml(opts)
+    else
+      old_to_yaml(opts)
+    end
+  end
+end
+
+class OHash
+  def to_yaml ( opts={} )
+    if YAML.have_option? opts, :uttk
+      YAML::quick_emit(self.object_id, opts) do |out|
+        out.seq('') do |seq|
+          self.each do |k,v|
+            seq.add( { k => v } )
+          end
+        end
+      end
+    else
+      super
+    end
+  end
+end
+
+
+module Uttk
+
+  module Dumpers
+
+    class Yaml < Dumper
+      include Concrete
+
+      MAP_INDENT = 2
+      MAP_SHIFT = ' ' * MAP_INDENT
+      OMAP_SHIFT = ' ' * 4
+
+      def initialize ( *a, &b )
+        super
+        @indent = ''
+        @stack_indent = []
+        @endl = true
+        puts '---'
+        @opts = {:uttk => true, :Inline => true}
+      end
+
+
+      def new_node ( path, node )
+        super
+        options = nil
+        if ! path.nil? and ! path.empty?
+          options = path.last.options
+        end
+        puts unless @endl
+        @stack_indent << @indent
+        self << @indent
+        if options.nil? or not options[:ordered]
+          @indent += MAP_SHIFT
+        else
+          self << '- '
+          @indent += OMAP_SHIFT
+        end
+        self << clean_to_yaml(node.segment) << ':'
+        if type = node.options[:type]
+          if type.is_a? Class
+            # FIXME handle this better
+            if HAVE_YAML_TAGURI
+              self << ' !' << type.taguri.sub(/^tag:.*?:/, '')
+            else
+              self << ' ' << type.to_yaml_type
+            end
+          else
+            self << ' !' << type.to_s
+          end
+        end
+        @endl = false
+      end
+      protected :new_node
+
+
+      def new_leaf ( path, leaf )
+        super
+        val = leaf
+        return if val.respond_to?(:hidden)
+        if val.is_a?(String) and val =~ /\n/
+          if val =~ /\A[ \t]/
+            val = "|#{MAP_INDENT}\n#{val}"
+          else
+            val = "|\n#{val}"
+          end
+          val.chomp!
+        else
+          val = clean_to_yaml(val)
+          val = "\n" + val if val =~ /\n/ and val !~ /^\n/
+        end
+        val.gsub!(/[ \t]*\n/, "\n#@indent")
+        print ' ', val, "\n"
+        @endl = true
+      end
+      protected :new_leaf
+
+
+      def up ( path )
+        super
+        @indent = @stack_indent.pop || ''
+      end
+      protected :up
+
+
+      def clean_to_yaml ( val )
+        val = val.to_yaml(@opts)
+        val.sub!(/^--- /, '')
+        val.chomp!
+        val.gsub!(/(^\s*)- \n\s+([^\s-])/, '\1- \2')
+        val = '""' if val == "''"
+        val
+      end
+      private :clean_to_yaml
+
+
+      def update ( *a, &b )
+        super
+        flush
+      end
+
+    end # class Yaml
+
+  end # module Dumpers
+
+end # module Uttk
+

data/lib/uttk/filters.rb

@@ -0,0 +1,128 @@
+# Author::    Nicolas Despr�s  <nicolas.despres@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/lib/uttk/filters.rb 22057 2006-02-20T21:40:27.185401Z pouillar  $
+
+
+module Uttk
+
+  module Filters
+
+    def self.[] ( *yaml_desc )
+      joined_yaml_desc = yaml_desc.join(', ')
+      joined_yaml_desc.sub!(/^\s+/, '')
+      if joined_yaml_desc[0,1] != '{' and joined_yaml_desc[0,1] != '['
+        full_doc = "--- {#{joined_yaml_desc}}"
+      else
+        full_doc = "--- #{joined_yaml_desc}"
+      end
+      create_backend(YAML.load(full_doc)).flatten
+    end
+
+    def Symbol.yaml_load ( val )
+      val.to_sym
+    end
+
+    def Integer.yaml_load ( val )
+      val.to_i
+    end
+
+    class FilterOption
+      attr_reader :option
+      def initialize ( anObject )
+        @option = anObject
+      end
+      def to_hash
+        { self.class.name.demodulize.underscore.to_sym => option }
+      end
+      def self.yaml_load ( anObject )
+        new(superclass.name.demodulize.sub(/Option$/, '').constantize.yaml_load(anObject))
+      end
+    end
+
+    class SymbolOption < FilterOption
+    end
+
+    class RegexpOption < FilterOption
+    end # class RegexpOption
+
+    class IntegerOption < FilterOption
+    end # class IntegerOption
+
+    class BooleanOption < FilterOption
+      def self.yaml_load ( anObject )
+        new(anObject)
+      end
+    end # class BooleanOption
+
+    class Action < SymbolOption
+      have YamlExtension
+    end
+
+    class Keep < RegexpOption
+      have YamlExtension
+    end # class Keep
+
+    class Skip < RegexpOption
+      have YamlExtension
+    end # class Skip
+
+    class Width < IntegerOption
+      have YamlExtension
+    end # class Width
+
+    class Prune < BooleanOption
+      have YamlExtension
+    end # class Prune
+
+    class << self
+      def create_backend ( desc )
+        case desc
+        when Array
+          desc.map { |elt| create_backend(elt) }
+        when String
+          [create_backend_leaf(desc, STDOUT)]
+        when Hash
+          desc.map do |k, v|
+            create_backend_leaf(k, *create_backend(v).flatten)
+          end
+        when FilterOption
+          [desc]
+        when nil
+          [STDOUT]
+        else
+          raise OptionParser::InvalidArgument,
+                "need a string or a hash not #{desc.inspect}"
+        end
+      end
+      private :create_backend
+
+      def create_backend_leaf ( aConst, *args )
+        unless aConst.is_a? String
+          raise OptionParser::InvalidArgument,
+                "need a string not #{aConst.inspect}"
+        end
+        if aConst =~ ConstRegexp::RB_CONST
+          if Dumpers.const_defined? aConst
+            return Dumpers.const_get(aConst).new(*args)
+          else
+            if Filters.const_defined? aConst
+              mod = Filters
+            elsif PathFilters.const_defined? aConst
+              mod = PathFilters
+            else
+              return aConst.to_path.open('w')
+            end
+            options, observers = args.partition { |arg| arg.is_a? FilterOption }
+            options = options.inject({}) { |accu, opt| accu.merge! opt.to_hash }
+            return mod.const_get(aConst).new(observers, options)
+          end
+        end
+        aConst.to_path.open('w')
+      end
+      private :create_backend_leaf
+    end
+
+  end # module Filters
+
+end # module Uttk

data/lib/uttk/filters/Buffer.rb

@@ -0,0 +1,119 @@
+# Author::    Yannick Lacaute <lacaut_y@epita.fr>
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: Buffer.rb 645 2005-07-11 21:52:01 thor $
+
+
+module Uttk
+
+  module Filters
+
+    #
+    # This basic filter observe a logger and
+    # bufferize all received messages, with a tree formatting.
+    # The buffer can be flushed when the data are not usefull
+    # anymore. That imply that another entity, a kind of controller,
+    # should always be connected to this class.
+    #
+    # The buffer is simple, all notified datas are directly putted inside,
+    # and when a flush is needed (or asked) it erases all datas. So, it
+    # is possible to think to a new class, derived from this one, which
+    # examin more precisely the notifications, and stock into the buffer
+    # just the desired. It could do the same for flush the buffer, just clear
+    # some part of the buffer. The tool Rpath could be very usefull to do that.
+    #
+    # The messages are putted into the buffer in order to make a tree,
+    # only with Hash and OHash objects. So, that tree could be given at
+    # any time.
+    #
+    # The main utiliy of this class is to provide exactly all the
+    # datas that another entity want. Moreover, that ones are given
+    # under a tree form, which allow simple navigation inside, especialy
+    # with the Rpath tool.
+    #
+    class Buffer < Filter
+      include Concrete
+
+      attr_reader :buffer
+
+      def initialize(*a, &b)
+        super
+        reset
+      end
+
+      def reset
+        @buffer = {}
+        @path = [@buffer]
+        @last_node = nil
+        @reset_planned = false
+      end
+
+      alias :clear :reset
+
+      def new_node ( path, node )
+        super
+        value = (node.options[:ordered]) ? OHash.new : {}
+        value[:strategy] = node.options[:type] if node.options.has_key? :type
+        @path.last[node.segment] = value
+        @path << value
+        @last_node = node.segment
+      end
+      protected :new_node
+
+      def new_leaf ( path, leaf )
+        super
+        if @last_node.nil?
+          @buffer = leaf
+          @path = [@buffer]
+        else
+          father = @path[-2]
+          if father[@last_node].is_a? Hash
+            father[@last_node] = leaf
+          else
+            father[@last_node] = [father[@last_node], leaf]
+          end
+        end
+      end
+      protected :new_leaf
+
+      def up ( path )
+        super
+        @path.pop if @path.size > 1
+      end
+      protected :up
+
+      def close
+        super
+        notif :new_leaf, [], @buffer
+        @reset_planned = true
+      end
+      protected :close
+
+      def update ( *a, &b )
+        reset if @reset_planned
+        super
+      end
+
+      def empty?
+        @buffer.is_a? Hash and @buffer.empty?
+      end
+
+      module Assertions
+
+        attr_accessor :buffer
+
+        def assert_buffer ( ref )
+          assert_equal(ref, @buffer.buffer)
+        end
+
+        def assert_not_buffer ( ref )
+          assert_not_equal(ref, @buffer.buffer)
+        end
+
+      end # module Assertions
+
+    end # class Buffer
+
+  end # module Filters
+
+end # Uttk

data/lib/uttk/filters/Compact.rb

@@ -0,0 +1,75 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /w/fey/uttk/trunk/lib/uttk/filters/Compact.rb 21844 2006-02-17T17:26:59.771162Z pouillar  $
+
+
+module Uttk
+
+  module Filters
+
+    class Compact < Id
+      include Concrete
+
+      class InternalError < Exception
+      end
+
+      def initialize ( *a, &b )
+        super
+        @record = {}
+      end
+
+
+      def new_node ( path, node )
+        if type = node.options[:type]
+          unless type.is_a? Class
+            if type.is_a? String and type =~ /^[A-Z]([a-zA-Z_]|::)*$/
+              type = eval type
+            else
+              raise ArgumentError, "bad type name #{type} : #{type.class}"
+            end
+          end
+          # We record the flow if the type is NOT a subclass of Composite nor
+          # a subclass of SubCmd (SubCmd and Composite included)
+          unless type <= Strategies::Composite or type <= Strategies::SubCmd
+            @record[path.to_s] = [Buffer.new, node]
+          end
+        end
+        if node.segment == :attributes
+          @record[path.to_s] = [Buffer.new, node]
+        end
+      end
+      protected :new_node
+
+
+      def up ( path )
+        if buf = @record[path.to_s] # If this path was recorded
+          @record.delete path.to_s
+          path << buf.last
+          # We dump it as leaf
+          leaf = buf.first.buffer.rpath_find(:first, path.to_regex_path_string)
+          raise InternalError, 'in Compact#up the leaf cannot be nil' if leaf.nil?
+          notif :new_leaf, path, leaf
+        end
+        super
+      end
+      protected :up
+
+
+      def new_leaf ( path, leaf )
+        if @record.empty?
+          # We are recording nothing so we transmit the message as is.
+          super
+        else
+          # Each buffer receive the message
+          @record.each do |path_s, buf|
+            buf.first.update(:new_leaf, path, leaf)
+          end
+        end
+      end
+
+    end # class Compact
+
+  end # module Filters
+
+end # module Uttk