ruby_ex 0.1.2 → 0.2.0

data/lib/module/instance_method_visibility.rb

@@ -1,13 +1,10 @@
-# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
-# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
-# License: Gnu General Public License.
+# Copyright:: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author::    Nicolas Despres  <polrop@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: instance_method_visibility.rb 339 2005-09-06 23:27:27Z ertai $
 
-# $LastChangedBy: polrop $
-# $Id: instance_method_visibility.rb 279 2005-06-05 17:46:53Z ertai $
 
-require 'ruby_ex'
-
-class Module
+module InstanceMethodVisibility
 
   def instance_method_visibility(name)
     if private_method_defined?(name)
@@ -22,50 +19,54 @@ class Module
     end
   end
 
+end # module InstanceMethodVisibility
+
+class Module
+  include InstanceMethodVisibility
 end # class Module
 
+module InstanceMethodVisibility
 
-test_section __FILE__ do
+  test_section __FILE__ do
 
+    class InstanceMethodVisibilityTest < Test::Unit::TestCase
 
+      class A
 
-class InstanceMethodVisibilityTest < Test::Unit::TestCase
+        def pub; end
+        def pri; end
+        def pro; end
 
-  class A
+        public :pub
+        private :pri
+        protected :pro
 
-    def pub; end
-    def pri; end
-    def pro; end
+      end # class A
 
-    public :pub
-    private :pri
-    protected :pro
+      def test_simple
+        assert_equal(:public, A.instance_method_visibility('pub'))
+        assert_equal(:private, A.instance_method_visibility('pri'))
+        assert_equal(:protected, A.instance_method_visibility('pro'))
+        assert_raises(NoMethodError) { A.instance_method_visibility('new') }
+      end
 
-  end # class A
+      class AA
+        def f; end
+      end
+      class BB < AA
+        private :f
+      end
 
-  def test_simple
-    assert_equal(:public, A.instance_method_visibility('pub'))
-    assert_equal(:private, A.instance_method_visibility('pri'))
-    assert_equal(:protected, A.instance_method_visibility('pro'))
-    assert_raises(NoMethodError) { A.instance_method_visibility('new') }
-  end
+      def test_inheritance
+        assert_equal(:public, AA.instance_method_visibility('f'))
+        assert(! BB.public_method_defined?('f'))
+        assert_equal(:private, BB.instance_method_visibility('f'))
+      end
 
-  class AA
-    def f; end
-  end
-  class BB < AA
-    private :f
-  end
+    end # class InstanceMethodVisibilityTest
 
-  def test_inheritance
-    assert_equal(:public, AA.instance_method_visibility('f'))
-    assert(! BB.public_method_defined?('f'))
-    assert_equal(:private, BB.instance_method_visibility('f'))
   end
 
-end # class InstanceMethodVisibilityTest
-
-
-end
+end # module InstanceMethodVisibility
 
 

data/lib/node.rb

@@ -5,7 +5,6 @@
 # $LastChangedBy: polrop $
 # $Id: node.rb 171 2005-03-29 09:12:47Z polrop $
 
-require 'ruby_ex'
 
 class Node
 

data/lib/object_monitor.rb

@@ -3,10 +3,9 @@
 # License: Gnu General Public License.
 
 # $LastChangedBy: ertai $
-# $Id: object_monitor.rb 279 2005-06-05 17:46:53Z ertai $
+# $Id: object_monitor.rb 339 2005-09-06 23:27:27Z ertai $
 
 
-require 'ruby_ex'
 require 'observable'
 
 

data/lib/object_monitor_activity.rb

@@ -3,10 +3,9 @@
 # License: Gnu General Public License.
 
 # $LastChangedBy: ertai $
-# $Id: object_monitor_activity.rb 279 2005-06-05 17:46:53Z ertai $
+# $Id: object_monitor_activity.rb 339 2005-09-06 23:27:27Z ertai $
 
 
-require 'ruby_ex'
 require 'observable'
 
 

data/lib/observable.rb

@@ -3,10 +3,9 @@
 # License: Gnu General Public License.
 
 # $LastChangedBy: ertai $
-# $Id: observable.rb 279 2005-06-05 17:46:53Z ertai $
+# $Id: observable.rb 339 2005-09-06 23:27:27Z ertai $
 
 
-require 'ruby_ex'
 require 'observer'
 
 

data/lib/observable_pool.rb

@@ -3,10 +3,9 @@
 # License: Gnu General Public License.
 
 # $LastChangedBy: ertai $
-# $Id: observable_pool.rb 279 2005-06-05 17:46:53Z ertai $
+# $Id: observable_pool.rb 339 2005-09-06 23:27:27Z ertai $
 
 
-require 'ruby_ex'
 require 'observable'
 require 'thread'
 

data/lib/{orderedhash.rb → ordered_hash.rb}

@@ -18,11 +18,10 @@
 #
 
 # $LastChangedBy: ertai $
-# $Id: orderedhash.rb 279 2005-06-05 17:46:53Z ertai $
+# $Id: ordered_hash.rb 339 2005-09-06 23:27:27Z ertai $
 
-require 'ruby_ex'
 
-module OrderedHash_ext
+module OrderedHash
 
   def store ( a, b )
     @order.push a unless has_key? a
@@ -118,6 +117,30 @@ module OrderedHash_ext
     to_a.to_s
   end
 
+  def inspect
+    arr = to_a.map{ |k, v| "#{k.inspect}=>#{v.inspect}" }
+    '{(ordered) ' + arr.join(', ') + ' }'
+  end
+
+  def pretty_print ( q )
+    q.group(1, '{(ordered) ', '}') {
+      q.seplist(self, nil, :each_pair) {|k, v|
+        q.group {
+          q.pp k
+          q.text '=>'
+          q.group(1) {
+            q.breakable ''
+            q.pp v
+          }
+        }
+      }
+    }
+  end
+
+  def pretty_print_cycle(q)
+    q.text(empty? ? '{(ordered)}' : '{(ordered) ...}')
+  end
+
   def update ( hsh2 )
     hsh2.each { |k,v| self[k] = v }
     self
@@ -142,7 +165,7 @@ module OrderedHash_ext
     !@order.nil?
   end
 
-end # module OrderedHash_ext
+end # module OrderedHash
 
 
 class OHash < Hash
@@ -151,7 +174,7 @@ class OHash < Hash
 
   alias :unordered_keys :keys
 
-  include OrderedHash_ext
+  include OrderedHash
 
   def initialize ( *a )
     @order = unordered_keys
@@ -227,6 +250,19 @@ test_section __FILE__ do
       check_ordered({}, [[2, 3], [4, 3]])
     end
 
+    def test_inspect
+      hsh = OHash['z', 1, 'a', 2, 'c', 3] 
+      hsh2 = OHash['a', 2, 'z', 1, 'c', 3] 
+      assert_equal('{(ordered) "z"=>1, "a"=>2, "c"=>3 }', hsh.inspect)
+      assert_equal('{(ordered) "a"=>2, "z"=>1, "c"=>3 }', hsh2.inspect)
+    end
+    
+    def test_pretty_print
+      require 'pp'
+      hsh = OHash['z', 1, 'a', 2, 'c', 3] 
+      assert_match(/^\{\(ordered\) /, PP.pp(hsh, ''))
+    end
+    
     def test_little_ordered
       a = (0..11).to_a
       h = OHash[*a]

data/lib/pp_hierarchy.rb

@@ -5,9 +5,8 @@
 # $LastChangedBy: polrop $
 # $Id: hierarchy.rb 145 2005-01-30 14:16:14Z polrop $
 
-require 'ruby_ex'
 
-class Hash
+module PpHierarchy
 
   # Pretty print a hash symbolizing a class hierarchy.
   def pp_hierarchy(prefix=//, abstract=false)
@@ -27,4 +26,10 @@ class Hash
     end
   end
 
+end # module PpHierarchy
+
+class Hash
+
+  include PpHierarchy
+
 end # class Hash

data/lib/r_path.rb

@@ -0,0 +1,307 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: r_path.rb 339 2005-09-06 23:27:27Z ertai $
+
+require 'regex_path'
+
+class Object
+
+  #
+  # RPath is a sort of the well known XPath. XPath is XML and RPath is
+  # obviously built for Ruby.
+  #
+  # When you have a Ruby tree -- by tree I mean a complex data structure  with
+  # no cycles -- you can search something into it:
+  #
+  # tree = {
+  #   :A => {
+  #     :AA  => { :AAA => 'foo' },
+  #     'AB' => [ :AB1, 2, 'a b 3' ],
+  #   },
+  #   :B => {
+  #     'foo' => { :home => 'here',       :email => 'foo@foo.com' },
+  #     'bar' => { :home => "bar's home", :email => 'bar@foo.bar' },
+  #     'baz' => { :home => 'nowhere',    :email => 'baz@bar.com' }
+  #   }
+  # }
+  #
+  # tree.rpath('/A/AA/AAA/') { |x| p x } # => 'foo'
+  #
+  # But we are dealing with regexp so if you want just this path you need:
+  # tree.rpath('/^A$/^AA$/^AAA$/') { |x| p x } # => 'foo'
+  #
+  # But if you are lazy you can type that:
+  # tree.rpath('/A/AA//') { |x| p x } # => 'foo'
+  # or
+  # tree.rpath('///AAA/') { |x| p x } # => 'foo'
+  #
+  # tree.rpath('/B//home/nowhere') { |x| p x } # => 'nowhere'
+  #
+  # But you would prefer get the complete baz record, so to do that you
+  # can mark your dezired levels with `*'.
+  #
+  # tree.rpath('/B//*home/nowhere') { |x| p x[:email] } # => 'baz@bar.com'
+  #
+  # tree.rpath('/B//*home/ere') { |x| p x[:email] }
+  # => 'foo@foo.com'
+  # => 'baz@bar.com'
+  #
+  # tree.rpath('/B//*home/(.*)') { |tree, home| p [home, tree[:email]] }
+  # => [ 'here', 'foo@foo.com' ]
+  # => [ "bar's home", 'bar@foo.bar' ]
+  # => [ 'nowhere', 'baz@bar.com' ]
+  #
+  def rpath ( re, &block )
+    raise ArgumentError, 'no block given' unless block_given?
+    re = RegexPath.new(re) unless re.is_a? RegexPath
+    regex_path_match(re, nil, [], &block)
+    nil
+  end
+
+  #
+  # Act like rpath it does not take a block but
+  #
+  def rpath_select ( re )
+    results = []
+    re = RegexPath.new(re) unless re.is_a? RegexPath
+    regex_path_match(re, nil, []) do |x|
+      results << x
+    end
+    results
+  end
+
+  #
+  # Like rpath_select with match datas
+  #
+  def rpath_select_match_data ( re )
+    results = []
+    re = RegexPath.new(re) unless re.is_a? RegexPath
+    regex_path_match(re, nil, []) do |*a|
+      results << a
+    end
+    results
+  end
+
+  #
+  # mode = [:first, :all]
+  # rpath_find :all is like rpath_select
+  # rpath_find :first is the first element of rpath_select
+  #
+  def rpath_find ( mode, re )
+    results = rpath_select(re)
+    case mode
+    when :all   then results
+    when :first then results.first
+    else raise "Bad mode `#{mode}' for rpath_find"
+    end
+  end
+
+  def regex_path_match ( re, trees, args, &block ) # :nodoc:
+    to_s.regex_path_match(re, trees, args, &block)
+  end
+
+end # class Object
+
+
+
+class Hash
+
+  def regex_path_match ( re, trees, args, &block ) # :nodoc:
+    trees = (trees || []) + [self] if re.starred?
+
+    if re.empty?
+      trees ||= [self]
+      trees.each { |tree| block[tree, *args] }
+    else
+      seg, tail_re = re.split
+      each do |key, val|
+        match_data = seg =~ key.to_s
+        if match_data
+          sub_args = args + match_data.to_a[1..-1]
+          val.regex_path_match(tail_re, trees, sub_args, &block)
+        end
+      end
+    end
+  end
+
+end # class Hash
+
+
+class Array
+
+  def regex_path_match ( re, trees, args, &block ) # :nodoc:
+    each do |x|
+      x.regex_path_match(re, trees, args, &block)
+    end
+  end
+
+end # class Array
+
+
+class String
+
+  def regex_path_match ( re, trees, args, &block ) # :nodoc:
+    seg, tail_re = re.split
+
+    trees = (trees || []) + [self] if re.starred?
+
+    if (seg.nil? or match_data = seg =~ self) and tail_re.empty?
+      trees ||= [self]
+      args = args + match_data.to_a[1..-1] if defined? match_data and match_data
+      trees.each { |tree| block[tree, *args] }
+    end
+  end
+
+end # class String
+
+
+module RPath
+
+  test_section __FILE__ do
+
+    class RPathTest < Test::Unit::TestCase
+
+      def assert_rpath_base ( re, ref, ref_match=[] )
+        select = @tree.rpath_select_match_data(re)
+        my = []
+        select.map { |x, *a| my << a unless a.empty? }
+        [ref.flatten, select.map { |a| a.first }, ref_match, my]
+      end
+
+      def assert_rpath ( re, ref, ref_match=[] )
+        ref1, my1, ref2, my2 = assert_rpath_base(re, ref, ref_match)
+        assert_equal(ref1, my1, 'trees are not equal')
+        assert_equal(ref2, my2, 'match datas are not equal')
+      end
+
+      def assert_rpath_set ( re, ref, ref_match=[] )
+        ref1, my1, ref2, my2 = assert_rpath_base(re, ref, ref_match)
+        assert_equal(ref1.to_set, my1.to_set, 'trees are not equal')
+        assert_equal(ref2.to_set, my2.to_set, 'match datas are not equal')
+      end
+
+      def setup
+        @tree = {
+          'Name' => 'Foo',
+          'FirstName' => 'Bar',
+          'Emails' => {
+            'home' => 'foo312@coldmail.com',
+            'work' => 'bfoo@staff.com',
+            'edu' =>  'bar.foo@school.edu'
+          },
+          'Phones' => ['101', '202', '203'],
+          'Deep' => { 'A' => { 'B' => ['1', 2, 'a', '3'], 'C' => '4' } },
+          'users' => [
+            {
+              'name' => 'Sea',
+              'tel' => '111'
+            },
+            {
+              'name' => 'Sex',
+              'tel' => '222'
+            },
+            {
+              'name' => 'Sun',
+              'tel' => '333'
+            },
+            {
+              'foo' => 'SeSe',
+              'tel' => '222'
+            },
+          ]
+        }
+      end
+
+      def test_simple
+        assert_rpath('Name', ['Foo', 'Bar'])
+        assert_rpath('^Name', ['Foo'])
+        assert_rpath('tName', ['Bar'])
+        assert_rpath('Emails/home', ["foo312@coldmail.com"])
+        assert_rpath('Emails/edu', ["bar.foo@school.edu"])
+        assert_rpath('Name/home', [])
+        assert_rpath('Phone/101', ['101'])
+        assert_rpath('Phone/\d0\d', ["101", "202", "203"])
+        assert_rpath('Phone/20\d', ["202", "203"])
+        assert_rpath('Deep/\d', [])
+        assert_rpath('Deep/A', [{"B"=>["1", 2, "a", "3"], "C"=>"4"}])
+        assert_rpath('Deep/.*/\d', [])
+        assert_rpath('Deep//\d', [])
+        assert_rpath('Deep///\d', ['1', '2', '3', '4'])
+
+        assert_rpath('Name/Foo', ['Foo'])
+        assert_rpath('Name/Foo/Bar', [])
+        assert_rpath('/E/o/com', ["foo312@coldmail.com", "bfoo@staff.com"])
+        assert_rpath('//o/com', ["foo312@coldmail.com", "bfoo@staff.com"])
+
+        assert_rpath('///Se', ["Sea", "Sex", "SeSe"])
+
+        assert_rpath('//a/Se', ["Sea", "Sex"])
+        assert_rpath('/users/name/Se[ax]', ["Sea", "Sex"])
+        assert_rpath('/users//S[eu].', ["Sea", "Sex", 'Sun', 'SeSe'])
+        assert_rpath('/users//S[eu].$', ["Sea", "Sex", 'Sun'])
+
+        assert_rpath('//*a/Sea', ['name' => 'Sea', 'tel' => '111'])
+
+        assert_rpath('//*a/Se', [{"name"=>"Sea", "tel"=>"111"},
+                                 {"name"=>"Sex", "tel"=>"222"}])
+
+        assert_rpath('//*a/*Se', [{"name"=>"Sea", "tel"=>"111"}, 'Sea',
+                                  {"name"=>"Sex", "tel"=>"222"}, 'Sex'])
+
+        assert_rpath('/*/*a/*Se', [@tree, {"name"=>"Sea", "tel"=>"111"}, 'Sea',
+                                   @tree, {"name"=>"Sex", "tel"=>"222"}, 'Sex'])
+      end
+
+      def test_example
+        foo = { :home => 'here',       :email => 'foo@foo.com' }
+        bar = { :home => "bar's home", :email => 'bar@foo.bar' }
+        baz = { :home => 'nowhere',    :email => 'baz@bar.com' }
+        @tree = {
+          :A => {
+            :AA  => { :AAA => 'foo' },
+            'AB' => [ :AB1, 2, 'a b 3' ],
+          },
+          :B => {
+            'foo' => foo,
+            'bar' => bar,
+            'baz' => baz
+          }
+        }
+
+        assert_rpath('/A/AA/AAA/', ['foo'])
+
+        assert_rpath('/^A$/^AA$/^AAA$/', ['foo'])
+
+        assert_rpath('/A/AA//', ['foo'])
+        assert_rpath('///AAA/', ['foo'])
+
+        assert_rpath('/B//home/nowhere', ['nowhere'])
+
+        assert_rpath('/B//*home/nowhere', [baz])
+
+        assert_rpath_set('/B//*home/ere', [foo, baz])
+
+        assert_rpath_set('/B//*home/(.*)', [foo, bar, baz],
+                         [['here'], ["bar's home"], ['nowhere']])
+      end
+
+      def test_match_data
+        assert_rpath('^N(a)me', ['Foo'], [['a']])
+        assert_rpath('N(a)m(e)', ['Foo', 'Bar'], [["a", "e"], ["a", "e"]])
+        assert_rpath('/(.*)/(.*o.*)/(.*com.*)',
+                     ["foo312@coldmail.com", "bfoo@staff.com"],
+                     [["Emails", "home", "foo312@coldmail.com"],
+                      ["Emails", "work", "bfoo@staff.com"]])
+        assert_rpath('/users/name/Se([ax])', ["Sea", "Sex"], [["a"], ["x"]])
+      end
+
+      def test_rpath
+        assert_nothing_raised { @tree.rpath('/A/AA/AAA/') { |x|  } }
+      end
+
+    end # class RPathTest
+
+  end
+
+end # module RPath