vcs 0.1 → 0.2.148

data/ruby_ex/yaml/chop_header.rb

@@ -0,0 +1,23 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004 LRDE. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id: header 98 2004-09-29 12:07:43Z ertai $
+
+require 'yaml'
+
+module YAML
+
+  def self.chop_header ( io )
+    aStr = io.gets
+    unless aStr =~ /^---/
+      io.rewind
+      raise Exception, "First line is not valid: `#{aLine}'"
+    end
+    io.each do |aLine|
+      break if aLine =~ /^---/
+      aStr += aLine
+    end
+    YAML::load(aStr)
+  end
+
+end # module YAML

data/ruby_ex/yaml/transform.rb

@@ -0,0 +1,449 @@
+# Author:: Marco Tessari  <marco.tessari@epita.fr>.
+# Copyright:: Copyright (c) 2004 TTK Team. All rights reserved.
+# License:: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: transform.rb 199 2005-04-22 22:37:45Z ertai $
+
+# TODO: Raised exception must be completed with a descritpion
+# TODO: Fix bug on Array see test_higher_level_on_array
+# TODO: Comment code.
+# TODO: Write more tests.
+# TODO: Make it stream.
+# TODO: Add the possibility to write '//' to match all node with deep n.
+# TODO: Add the && and ||.
+# TODO: Optimize, skip if no more node to match.
+# TODO: separate dot implemantation.
+
+require 'yaml/yregexpath'
+
+module YAML
+
+  class Transformer
+    private
+
+    # FIXME: Implement all ruby types. 
+    class ::Object # :nodoc:
+      def yaml_doc_traverse ( activated )
+        raise ArgumentError, "can't traverse class #{self.class}"
+      end
+    end
+    
+    class ::Hash # :nodoc:
+      # FIXME: Are we sure we want to traverse like that? (by stage)
+      def yaml_doc_traverse ( activated )
+        new_activated = []
+        sons = []
+        self.each do |key, value|
+          activated.each do |n|
+            new_activated += n.match(key, value)
+            sons << value unless value.is_a?(String)
+          end
+        end
+        activated += new_activated
+        sons.yaml_doc_traverse(activated)
+      end
+    end
+    
+    class ::Array # :nodoc:
+      def yaml_doc_traverse ( activated )
+        self.each { |e| e.yaml_doc_traverse(activated) }
+      end
+    end
+
+    class Node
+      attr_reader :name, :values
+
+      Struct.new( 'Value', :regexp, :remember, :associated )
+      
+      def initialize ( name )
+        raise ArgumentError unless name.is_a?(Regexp)
+        @name = name
+        @values = []
+        @uid = @@cpt
+        @@cpt += 1
+        # Save a node to handle the '#' feature.
+        @saved_node_key = nil
+        @saved_node_value = nil
+      end
+      @@cpt = 0
+
+      # Return the associated nodes of a value
+      # Add the value if not present.
+      def get_associated ( value, remember=false )
+        val = @values.find { |e| e.regexp == value and e.remember == remember }
+        if val.nil?
+          val = Struct::Value.new(value, remember, [])
+          @values << val
+        end
+        return val.associated
+      end
+
+      # Dottify a node.
+      def dottify ( stream )
+        # Declare node
+        stream << "#{unique_name} [shape=box, color=blue, label=#{self}]\n"
+        # Print node links with values
+        stream << "#{unique_name} -> { rank=same; "
+        @values.each_index { |i| stream << "value#{@uid}_#{i}; " }
+        stream << "}\n"
+        # Declare each values and links
+        @values.each_with_index do |val, i|
+          stream << "value#{@uid}_#{i} [shape=box, color=yellow, label=\"/"
+          stream << val.regexp.source << '/'
+          stream << ' #' if val.remember
+          stream << "\"]\n" 
+          stream << "value#{@uid}_#{i} -> { rank=same; "
+          val.associated.each { |match| stream << "#{match.unique_name}; " }
+          stream << "} \n"
+          val.associated.each { |match| match.dottify(stream) }
+        end
+      end
+
+      def match (  key, value )
+        return [] unless key =~ @name
+        activated = []
+        @values.each do |val|
+          if ! value.is_a?(String) or value =~ val.regexp
+            save_node_set(key, value) if val.remember
+            val.associated.each do |n|
+              if n.is_a?(Match)
+                # There must be a remembered node in the path.
+                p self unless has_saved_node?
+                n[@saved_node_key, @saved_node_value]
+              else
+                n.save_node_set(@saved_node_key,
+                                @saved_node_value) if has_saved_node?
+                activated << n
+              end
+            end
+            save_node_reset if val.remember
+          end
+        end
+        save_node_reset
+        return activated
+      end
+
+      def save_node_set ( key, value )
+        raise RuntimeError unless @saved_node_key.nil?
+        @saved_node_key = key
+        raise RuntimeError unless @saved_node_value.nil?
+        @saved_node_value = value
+      end
+
+      def save_node_reset
+        @saved_node_key = nil
+        @saved_node_value = nil
+      end
+
+      def has_saved_node?
+        return ! (@saved_node_key.nil? and @saved_node_value.nil?)
+      end
+
+      def unique_name
+        "node#{@uid}"
+      end
+      
+      # Human readable name.
+      def to_s
+        "\"/#{@name.source}/\""
+      end
+    end
+
+    class Root
+      attr_reader :children
+
+      def initialize
+        @name = 'root'
+        @children = []
+      end
+
+      def dottify ( stream )
+        stream << "#{self} [shape=circle, color=red, label=#{self}]\n"
+        stream << "#{self} -> { rank=same; "
+        @children.each { |e| stream << "#{e.unique_name} " }
+        stream << "}\n"
+        @children.each { |e| e.dottify(stream) }
+      end
+
+      def to_s
+        'root'
+      end
+
+      alias unique_name to_s 
+    end
+
+    class Match
+      
+      def initialize ( name=nil, &block )
+        @block = block
+        @name = name
+        @uid = @@cpt
+        @@cpt += 1
+      end
+      @@cpt = 0
+
+      def dottify ( stream )
+        stream << "match#{@uid} [shape=circle, color=green, label=#{self}]\n"
+      end
+
+      def call ( key, value )
+        @block[key, value]
+      end
+
+      alias [] call
+
+      def unique_name
+        "match#{@uid}"
+      end
+
+      def to_s
+        @name.nil? ? unique_name : "\"#{@name}\""
+      end
+    end
+
+    public
+    # Constructor.
+    def initialize
+      @rootgraph = Root.new
+      @graph = []
+      @activated = []
+    end
+
+    # Register the given block and compile the path.
+    def add ( path, name=nil, &block)
+      raise ArgumentError unless (path.kind_of?(YRegexPath))
+      raise ArgumentError if (block.nil?)
+      current_nodes = path.root ? @rootgraph.children : @graph
+      add_segment(path.segments, path.wanted_node_index,
+                  current_nodes, name, &block)
+    end
+    alias register add
+
+    def add_segment ( seg, remember_index, current_nodes, name, &block )
+      if (seg.empty?)
+        current_nodes << Match.new(name, &block)
+        return
+      end
+      updated = false
+      searched_name, searched_value = seg.shift
+      searched_value =  /.*/ if searched_value.nil?
+      current_nodes.collect! do |n|
+       if (n.is_a?(Node) and n.name == searched_name)
+         updated = true
+         update_node(n, searched_value, seg, remember_index, name, &block)
+        else
+          n
+        end
+      end
+      unless (updated)
+        current_nodes << update_node(Node.new(searched_name), searched_value,
+                                     seg, remember_index, name, &block)
+      end
+    end
+    private :add_segment
+
+    def update_node ( node, value, segment, remember_index, name, &block )
+      sons = node.get_associated(value, remember_index == 1)
+      add_segment(segment, remember_index - 1, sons, name, &block)
+      return node
+    end
+
+    # Print graph in a file in doty format
+    def dottify ( filename )
+      File.open(filename, 'w') do |f|
+        f << <<EOF
+/* Compiled rules graph visualisation by YSLT */
+digraph "Compiled rules" {
+node [style=filled]
+edge [style=solid, arrowtail=none]
+rankdir=LR
+EOF
+        @rootgraph.dottify(f)
+        @graph.each do |n|
+          n.dottify(f)
+        end
+        f << "}\n"
+      end
+    end
+
+    # Reset position to root.
+    def reset
+      @activated = @rootgraph.children + @graph
+    end
+
+    # Clear compiled rules.
+    def clear
+      initialize
+    end
+
+    # Traverse an entire YAML tree.
+    def traverse ( tree )
+      reset
+      tree.yaml_doc_traverse(@activated)
+    end
+
+    # Work like XLST.
+    # Traverse all tree and return a list of element that match the path.
+    def self.traverse ( path, tree, &block )
+      p = self.new
+      p.add(path, &block)
+      p.traverse(tree)
+    end
+
+  end # class Transformer
+
+end # module YAML
+
+if defined? TEST_MODE or $0 == __FILE__
+
+  require 'test/unit'
+
+  class Transformer < Test::Unit::TestCase
+    
+    def test_compiled
+      # Initialization.
+      engine = nil
+      str = ''
+      assert_nothing_raised { engine = YAML::Transformer.new }
+
+      # Build.
+      assert_nothing_raised do
+        engine.add(YAML::YRegexPath.new('/name')) do |key, value|
+          assert_instance_of(String, key)
+          str += "#{value} is"
+        end
+      end
+      assert_nothing_raised do
+        engine.add(YAML::YRegexPath.new('/name=Akli/boss')) do |key, value|
+          assert_instance_of(String, key)
+          str += ' a boss'
+        end
+      end
+      assert_nothing_raised do
+        engine.add(YAML::YRegexPath.new('/jobs/professor=EPITA/class')) do |k,v|
+          assert_instance_of(String, k)
+          str += e
+        end
+      end
+      assert_nothing_raised do
+        engine.add(YAML::YRegexPath.new('toto#titi'), 'unused') do
+          str += 'Why am I HERE???'
+        end
+      end
+
+      # Display.
+      assert_nothing_raised { engine.dottify('compiled.dot') }
+      `dot compiled.dot 2> /dev/null`
+      assert_equal(0, $?, 'Cannot display the graph')
+      
+      # Traverse.
+      tree = {
+        'name' => 'Akli A.',
+        'tel' => '06932359',
+        'address' => '23 boulevard voltaire',
+        'jobs' => [
+          {
+            'professor' => 'EPITA',
+            'boss' => 'MindSuite',
+            'god' => 'world',
+          }
+        ]
+      }
+      assert_nothing_raised { engine.traverse(tree) }
+      assert_equal(str, 'Akli A. is a boss a boss a boss')
+    end
+
+    def test_unique
+      names = []
+      tree = {
+        'users' => [
+          {
+            'name' => 'Sea',
+            'tel' => '111'
+          },
+          {
+            'name' => 'Sex',
+            'tel' => '222'
+          },
+          {
+            'name' => 'Sun',
+            'tel' => '333'
+          }
+        ]
+      }
+      YAML::Transformer.traverse(YAML::YRegexPath.new('name=Se'), tree) do
+        |k,v| names << v
+      end
+      assert_equal(['Sea', 'Sex'], names)
+    end
+
+    def test_higher_level_on_hash
+      email = ''
+      tree = {
+        'Name' => 'Foo',
+        'FirstName' => 'Bar',
+        'Emails' => {
+          'home' => 'foo312@coldmail.com',
+          'work' => 'bfoo@staff.com',
+          'edu' =>  'bar.foo@school.edu'
+        }
+      }
+      path = YAML::YRegexPath.new('Emails#.*=.*\.edu')
+      YAML::Transformer.traverse(path, tree) do |key, value|
+        assert_instance_of(Hash, value)
+        email += "#{value['home']}"
+      end
+      assert_equal('foo312@coldmail.com', email)
+    end
+
+#     def test_higher_level_on_array
+#       users = []
+#       tree = {
+#         'users' => [
+#           {
+#             'name' => 'Sea',
+#             'tel' => '111'
+#           },
+#           {
+#             'name' => 'Sex',
+#             'tel' => '222'
+#           },
+#           {
+#             'name' => 'Sun',
+#             'tel' => '333'
+#           }
+#         ]
+#       }
+#       YAML::Transformer.traverse(YAML::YRegexPath.new('users#name=Se'), tree) do
+#         |key, value|
+#         assert_instance_of(Array, value)
+#         value.each do |e|
+#           users << "#{e['name']} (#{e['tel']})"
+#         end
+#       end
+#       p users
+#       #assert_equal(['Sea (111)', 'Sex (222)'], users)
+#     end
+
+    def test_errors
+      engine = nil
+      assert_nothing_raised { engine = YAML::Transformer.new }
+
+      # Not an YRegexPath gived.
+      assert_raise(ArgumentError) do
+        engine.add('/name') { |key, value| str += "error" }
+      end
+
+#       # Block with only one parameter.
+#       assert_raise(ArgumentError) do
+#         engine.add(YAML::YRegexPath.new('/name')) { |key| str += "error" }
+#       end
+      
+      # No block ginven.
+      assert_raise(ArgumentError) do
+        engine.add(YAML::YRegexPath.new('/name'))
+      end
+    end
+  end
+end