ttk 0.1.576

data/ruby_ex/uri/ftp_ex.rb

@@ -0,0 +1,37 @@
+# Copyright: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: ftp_ex.rb 159 2005-02-18 12:07:23Z polrop $
+
+require 'uri_ex'
+require 'uri/ftp'
+require 'net/ftp'
+require 'mktemp'
+
+module URI
+
+  class FTP
+
+    def checkout
+      tmp = TempPath.new('checkout', pathname.basename.to_s)
+
+      begin
+        Net::FTP.open(host) do |ftp|
+          ftp.login
+          ftp.passive = true
+          ftp.getbinaryfile(path, tmp)
+        end
+
+      rescue Exception => ex
+        tmp.unlink if tmp.exist?
+        raise CheckoutError, "Cannot checkout #{to_s} (error: #{ex.short_pp})"
+      end
+
+      tmp
+    end
+
+  end # class FTP
+
+end # module URI

data/ruby_ex/uri/http_ex.rb

@@ -0,0 +1,43 @@
+# Copyright: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: http_ex.rb 159 2005-02-18 12:07:23Z polrop $
+
+require 'exception'
+require 'uri_ex'
+require 'uri/http'
+require 'net/http'
+require 'mktemp'
+
+module URI
+
+  class HTTP
+
+    def checkout
+      tmp = TempPath.new('checkout', pathname.basename.to_s)
+
+      begin
+        uri = URI.parse(ENV['http_proxy'] || '')
+        proxy_auth = [uri.host, uri.port, uri.user, uri.password]
+
+        Net::HTTP::Proxy(*proxy_auth).start(host) do |http|
+          tmp.open('w') do |out|
+            http.get(path) do |str|
+              out.print str
+            end
+          end
+        end
+
+      rescue Exception => ex
+        tmp.unlink if tmp.exist?
+        raise CheckoutError, "Cannot checkout #{to_s} (error: #{ex.short_pp})"
+      end
+
+      tmp
+  end
+
+  end # class HTTP
+
+end # module URI

data/ruby_ex/uri/svn.rb

@@ -0,0 +1,101 @@
+# Copyright: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: svn.rb 159 2005-02-18 12:07:23Z polrop $
+
+require 'uri_ex'
+require 'abstract'
+
+module URI
+
+  class Svn < Generic
+
+    COMPONENT = [
+      :scheme,
+      :host,
+      :path
+    ].freeze
+
+    def self.build ( args )
+      tmp = Util::make_components_hash(self, args)
+      return super(tmp)
+    end
+
+    def checkout
+      # klass = SvnSchemes.guess(scheme)
+      # klass.new
+      tmp = TempPath.new('svn-checkout')
+      out = TempPath.new('svn-checkout-out')
+      err = TempPath.new('svn-checkout-err')
+      tmp.mkpath
+      target = to_s.sub(/^svn\./, '')
+      tmp += pathname.basename
+      unless system "svn checkout #{target} #{tmp} > #{out} 2> #{err}"
+        raise CheckoutError, to_s
+      end
+      [tmp, out, err]
+    end
+
+  end # class Svn
+
+  module SvnSchemes
+
+    def self.guess ( aScheme )
+      init
+      @@svn_schemes[aScheme]
+    end
+
+    def self.init
+      return if defined? @@svn_schemes
+      @@svn_schemes = {}
+      constants.each do |const|
+        klass = const_get(const)
+        next if klass.abstract?
+        @@svn_schemes[klass.scheme] = klass
+      end
+      @@svn_schemes.freeze
+    end
+
+    def self.svn_schemes
+      init
+      @@svn_schemes
+    end
+
+    class AbstractSvnScheme
+      include Abstract
+
+      def self.scheme
+        const_get(:SCHEME)
+      end
+
+    end
+
+    class SvnScheme < AbstractSvnScheme
+      include Concrete
+      SCHEME = 'SVN'
+    end
+
+    class SvnSshScheme < AbstractSvnScheme
+      include Concrete
+      SCHEME = 'SVN+SSH'
+    end
+
+    class SvnHttpScheme < AbstractSvnScheme
+      include Concrete
+      SCHEME = 'SVN.HTTP'
+    end
+
+    class SvnHttpsScheme < AbstractSvnScheme
+      include Concrete
+      SCHEME = 'SVN.HTTPS'
+    end
+
+  end
+
+  SvnSchemes.svn_schemes.each_key do |name|
+    @@schemes[name] = Svn
+  end
+
+end # module URI

data/ruby_ex/uri_ex.rb

@@ -0,0 +1,35 @@
+# Copyright: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: uri_ex.rb 159 2005-02-18 12:07:23Z polrop $
+
+require 'uri'
+
+module URI
+
+  class CheckoutError < Exception
+  end
+
+  class Generic
+
+    def pathname
+      Pathname.new(path)
+    end
+
+    def to_yaml_type
+      '!uri'
+    end     
+
+    def to_yaml ( opts={} )
+      "!uri #{to_s}"
+    end
+
+    def checkout
+      raise CheckoutError, "Can't checkout a #{self.class}"
+    end
+
+  end # module Generic
+
+end # module URI

data/ruby_ex/version.rb

@@ -0,0 +1,66 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: version.rb 101 2005-01-15 07:58:58Z polrop $
+
+
+class Version
+  include Comparable
+
+  attr_accessor :major, :minor, :revision
+
+  def initialize(major, minor, revision)
+    @major = major
+    @minor = minor
+    @revision = revision
+  end
+
+  def <=>(other)
+    if @major == other.major
+      if @minor == other.minor
+        @revision <=> other.revision
+      else
+        @minor <=> other.minor
+      end
+    else
+      @major <=> other.major
+    end
+  end
+
+  def to_s
+    "#@major.#@minor.#@revision"
+  end
+
+  def to_a
+    [ @major, @minor, @revision ]
+  end
+
+end # class Version
+
+
+if defined? TEST_MODE or __FILE__ == $0
+
+
+require 'test/unit/ui/yaml/testrunner'
+
+
+class VersionTest < Test::Unit::TestCase
+
+  def test_simple
+    assert(Version.new(1, 2, 3) < Version.new(1, 2, 4))
+    assert(Version.new(1, 2, 4) > Version.new(1, 2, 3))
+    assert(Version.new(1, 2, 3) == Version.new(1, 2, 3))
+    assert(Version.new(1, 3, 3) > Version.new(1, 2, 3))
+    assert(Version.new(1, 2, 3) < Version.new(1, 3, 3))
+    assert(Version.new(2, 2, 3) > Version.new(1, 2, 3))
+    assert(Version.new(1, 2, 3) < Version.new(2, 2, 3))
+  end
+
+end # class VersionTest
+
+
+end
+
+

data/ruby_ex/yaml/basenode_ext.rb

@@ -0,0 +1,63 @@
+# Copyright: Copyright (c) 2004  Nicolas Pouillard. All rights reserved.
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: basenode_ext.rb 53 2004-12-02 22:24:03Z ertai $
+
+require 'yaml'
+require 'yaml/basenode'
+
+module YAML
+
+  module BaseNode
+
+    def ordered_children_with_index
+      arr = children_with_index
+      arr.sort! { |a,b| b[0].object_id <=> a[0].object_id } unless arr.nil?
+      arr
+    end
+
+    def ordered_children_indexes
+      arr = ordered_children_with_index
+      arr.map! { |x| x[1] } unless arr.nil?
+      arr
+    end
+    
+    def ordered_children
+      arr = children
+      arr.map! { |x| x[0] } unless arr.nil?
+      arr
+    end
+    
+  end # module BaseNode
+
+end # module YAML
+
+
+if defined? TEST_MODE or $0 == __FILE__
+
+  require 'test/unit'
+  class BaseNodeExtTest < Test::Unit::TestCase
+
+    def basenode_checker ( my, ref )
+      node = YAML::parse(my)
+      assert_equal(node.ordered_children_indexes, ref)
+    end
+
+    def test_basenode1
+      basenode_checker('--- { d: 4, a: 1, b: 2, c: 3 }', ["d", "a", "b", "c"])
+    end
+
+    def test_basenode2
+      basenode_checker('--- { a: 1, d: 42, b: 2, c: 3 }', ["a", "d", "b", "c"])
+    end
+
+    def test_basenode3
+      basenode_checker(
+        '--- { a: :"1", d: "foo", b: [2,3], c: {} }', ["a", "d", "b", "c"])
+    end
+  
+  end # class BaseNodeExtTest
+
+end

data/ruby_ex/yaml/transform.rb

@@ -0,0 +1,447 @@
+# 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 186 2005-04-03 00:07: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
+
+      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