vcs 0.2.148 → 0.3.0

data/ruby_ex/yaml/chop_header.rb

@@ -1,23 +0,0 @@
-# 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

@@ -1,449 +0,0 @@
-# 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