ruby_ex 0.1.1

data/src/uri/ssh.rb

@@ -0,0 +1,87 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id$
+
+require 'uri_ex'
+
+module URI
+
+  class Ssh < Generic
+
+    SCHEME = 'ssh'.freeze
+    DEFAULT_HOST = 'localhost'.freeze
+    DEFAULT_PORT = 22
+    DEFAULT_QUERY = ''.freeze
+    SCP = 'scp'.to_cmd.freeze
+
+    COMPONENT = [
+      :scheme,
+      :userinfo,
+      :host,
+      :path,
+      :query
+    ].freeze
+
+    def self.build ( args )
+      tmp = Util::make_components_hash(self, args)
+      return super(tmp)
+    end
+
+    def mk_opts
+      opts = []
+      opts << '-q'
+      opts << '-P' << @port if @port != DEFAULT_PORT
+      return opts if @query.nil?
+      @query.split(/,/).map do |x|
+        k, v = x.split(/=/)
+        if k.size == 1
+          opts << "-#{k}"
+        else
+          opts << "--#{k}"
+        end
+        opts << v unless v.nil?
+      end
+      opts
+    end
+
+    def mk_arg
+      "#@user@#@host:#{@path.gsub(/^\//, '')}"
+    end
+
+    def checkout
+      out = TempPath.new('checkout', pathname.basename.to_s)
+      SCP[mk_opts, mk_arg, out].run(self.runner)
+    end
+
+    def save
+      checkout.save
+    end
+
+    def commit ( aPath )
+      SCP[mk_opts, aPath, mk_arg].run(self.runner)
+    end
+
+  end # class Ssh
+
+  @@schemes[Ssh::SCHEME.upcase] = Ssh
+
+  test_section __FILE__ do
+    class SshTest < Test::Unit::TestCase
+      def test_basic
+        assert_nothing_raised { @uri = URI.parse('ssh://foo@bar') }
+        assert_equal(['-q'], @uri.mk_opts)
+        assert_nothing_raised { @uri = URI.parse('ssh://foo@bar:42') }
+        assert_equal(['-q', '-P', 42], @uri.mk_opts)
+      end
+      def test_with_query
+        assert_nothing_raised do
+          @uri = URI.parse('ssh://foo@bar/qux?a=b,c,d=e,f,ghi,jkl=mno')
+        end
+        ref = ['-q', '-a', 'b', '-c', '-d', 'e', '-f', '--ghi', '--jkl', 'mno']
+        assert_equal(ref, @uri.mk_opts)
+      end
+    end # class SshTest
+  end
+
+end # module URI

data/src/uri/svn.rb

@@ -0,0 +1,113 @@
+# Copyright: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: svn.rb 237 2005-05-17 19:01:52Z ertai $
+
+require 'uri_ex'
+require 'abstract'
+
+module URI
+
+  class Svn < Generic
+
+    COMPONENT = [
+      :scheme,
+      :host,
+      :path
+    ].freeze
+    SVN = 'svn'.to_cmd.freeze
+    SVNADMIN = 'svnadmin'.to_cmd.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')
+      tmp.mkpath
+      target = to_s.sub(/^svn\./, '')
+      tmp += pathname.basename
+      SVN['checkout', target, tmp].run(self.runner)
+    end
+
+    def save
+      raise SaveError unless scheme.downcase == 'svn.file'
+      repos = pathname
+      raise SaveError unless (repos + 'format').exist?
+      out = TempPath.new('save', "#{repos.basename}.svndump")
+      cmd = SVNADMIN['dump', repos, '--incremental', '--quiet'] > out
+      cmd.run(self.runner)
+    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
+
+    class SvnFileScheme < AbstractSvnScheme
+      include Concrete
+      SCHEME = 'SVN.FILE'
+    end
+
+  end
+
+  SvnSchemes.svn_schemes.each_key do |name|
+    @@schemes[name] = Svn
+  end
+
+end # module URI

data/src/uri_ex.rb

@@ -0,0 +1,71 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: uri_ex.rb 266 2005-06-01 14:27:18Z ertai $
+
+require 'uri'
+require 'ruby_ex'
+require 'commands'
+
+
+module URI
+
+  class CheckoutError < Exception
+  end
+
+  class CommitError < Exception
+  end
+
+  class SaveError < Exception
+  end
+
+  class Generic
+
+    #
+    # To make all uris command verbose you can change or modify the global
+    # command runner: URI::Generic.runner.make_verbose!
+    #
+    class_inheritable_accessor :runner
+
+    self.runner = Commands::Runners::System.new.raise_on_failures
+    self.runner.command_data_factory.command_data_class = Commands::Datas::Temp
+
+    def pathname
+      Pathname.new(path)
+    end
+
+    def pathname= ( path )
+      self.path = path.to_s
+    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
+
+    def commit
+      raise CommitError, "Can't commit a #{self.class}"
+    end
+
+    def save
+      raise SaveError, "Can't save a #{self.class}"
+    end
+
+    def add_query ( arg )
+      if query.nil?
+        self.query = arg
+      else
+        self.query += ',' + arg
+      end
+    end
+
+  end # module Generic
+
+end # module URI

data/src/verbose_object.rb

@@ -0,0 +1,70 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id: verbose_object.rb 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+
+module Verbosify
+
+  SKIP_METHODS = %w[ instance_eval ]
+
+  def self.extend_object ( anObject )
+    anObject.methods.each do |meth|
+      next if meth =~ /__.*__/
+      next if SKIP_METHODS.include? meth
+      anObject.instance_eval %Q{
+        def #{meth} ( *a, &b )
+          __log__(:#{meth}, *a, &b)
+          super
+        end
+      }
+    end
+    anObject.instance_eval do
+      def verbose_object?
+        true
+      end
+      def __log__ ( *a )
+        STDERR.puts "LOG: #{a.inspect}"
+      end
+    end
+  end
+
+end # module Verbosify
+
+
+class VerboseObject
+
+  def initialize ( anObject )
+    @obj = anObject
+  end
+
+  instance_methods.each do |meth|
+    next if meth =~ /__.*__/
+    module_eval %Q{
+      def #{meth} ( *a, &b )
+        method_missing(:#{meth}, *a, &b)
+      end
+    }
+  end
+
+  def verbose_object?
+    true
+  end
+
+  def __log__ ( *a )
+    STDERR.puts "LOG: #{a.inspect}"
+  end
+
+  def method_missing ( *a, &b )
+    __log__(*a)
+    @obj.__send__(*a, &b)
+  end
+
+end # class VerboseObject
+
+class Object
+  def verbose_object?
+    false
+  end
+end # class Object

data/src/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 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+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
+
+
+test_section __FILE__ do
+
+  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/src/yaml/chop_header.rb

@@ -0,0 +1,24 @@
+# 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 'ruby_ex'
+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/src/yaml/transform.rb

@@ -0,0 +1,450 @@
+# 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 266 2005-06-01 14:27:18Z 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 'ruby_ex'
+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
+
+test_section __FILE__ do
+
+  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.
+      TempPath.new do |dot_file|
+        assert_nothing_raised { engine.dottify(dot_file) }
+        `dot #{dot_file} 2> /dev/null`
+        # assert_equal(0, $?, 'Cannot display the graph')
+      end
+      
+      # 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