ttk 0.1.580 → 0.2.0

data/ruby_ex/uri/ftp_ex.rb

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

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

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

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

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

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

@@ -1,447 +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 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