ruby_ex 0.1.1

data/src/const_regexp.rb

@@ -0,0 +1,57 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: const_regexp.rb 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+
+module ConstRegexp
+
+  RB_INST_VAR = /^@[A-Za-z_][A-Za-z0-9_]*$/
+  RB_CLASS_VAR = /^@@[A-Za-z_][A-Za-z0-9_]*$/ #FIXME: concat with RB_INST_VAR
+  RB_LOCAL_VAR = /^[a-z_][A-Za-z0-9_]*$/
+  RB_METHOD = /^[a-z_][A-Za-z0-9_]*[=?!]?$/
+  RB_REGEXP = /^\/([^\\]|\\.)*\/$/
+  RB_CONST = /^[A-Z][a-zA-Z0-9_]*$/
+
+  CRYPTED_STRING = /^[A-Za-z0-9.\/]{13}$/
+
+  DRB_URI = /^([^:]+):\/\/([^:]+):(\d+)$/
+
+
+
+end # module ConstRegexp
+
+
+#
+# Unit test suite
+#
+test_section __FILE__ do
+
+
+class ConstRegexpTest < Test::Unit::TestCase
+
+  include ConstRegexp
+
+  #
+  # Tests
+  #
+  def test_rb_regexp
+    assert_match(RB_REGEXP, '//')
+    assert_no_match(RB_REGEXP, '')
+    assert_match(RB_REGEXP, '/\//')
+    assert_match(RB_REGEXP, '/\/\//')
+    assert_match(RB_REGEXP, '/reg\/e/')
+    assert_no_match(RB_REGEXP, '/\\/')
+    assert_match(RB_REGEXP, '/\\\\/')
+    assert_match(RB_REGEXP, '/\e/')
+    assert_no_match(RB_REGEXP, '/\/')
+  end
+
+end # class ConstRegexpTest
+
+
+end
+

data/src/daemon.rb

@@ -0,0 +1,135 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: daemon.rb 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'pathname'
+require 'singleton'
+
+require 'ruby_ex'
+require 'observable'
+require 'observable_pool'
+require 'service_manager'
+
+
+class Daemon
+  include Singleton
+  include ServiceManager
+  include Observable
+  include ObservablePool
+
+  module Notification
+
+    START         = :daemon_notification_start
+    STOP          = :daemon_notification_stop
+    WORKDIR       = :daemon_notification_workdir
+    CONFIG        = :daemon_notification_config
+    CLEAN_WORKDIR = :daemon_notification_clean_workdir
+    DETACH        = :daemon_notification_detach
+    SIGNAL_TRAPS  = :daemon_notification_signal_traps
+    RELOAD_CONFIG = :daemon_notification_reload_config
+
+  end # module Notification
+
+  def initialize
+    @config = nil
+    @workdir = Pathname.new('')
+    @detached = false
+    add_observable(self)
+    @logger = nil
+  end
+
+  def config=(config)
+    unless config.nil? or config.respond_to?(:__load__)
+      raise(NoMethodError, 'configuration class need to respond to `load\'')
+    end
+    @config = config
+    changed
+    notify_observers(Notification::CONFIG, @config)
+    @config
+  end
+
+  attr_reader :config
+
+  def workdir=(workdir)
+    unless workdir.to_s.empty?
+      unless File.directory?(workdir)
+        raise(ArgumentError, "`#{workdir}' - not a directory")
+      end
+      Dir.chdir(workdir)
+    end
+    @workdir = Pathname.new(workdir)
+    changed
+    notify_observers(Notification::WORKDIR, @workdir)
+    @workdir
+  end
+
+  attr_reader :workdir
+
+  def clean_workdir
+    @workdir.each_entry do |p|
+      next if p.to_s =~ /^\./
+      (@workdir + p).rmtree
+    end
+    changed
+    notify_observers(Notification::CLEAN_WORKDIR)
+    nil
+  end
+
+  def detach
+    return if @detached
+    @detached = true
+    if pid = fork # father
+      exit
+    else # son
+      Dir.chdir(@workdir.to_s.empty? ? '/' : @workdir.to_s)
+      Process.setsid
+      STDIN.close
+      STDOUT.close
+      STDERR.close
+    end
+    changed
+    notify_observers(Notification::DETACH)
+    nil
+  end
+
+  def detached?
+    @detached
+  end
+
+  def logger=(logger)
+    delete_global_observer(@logger) unless @logger.nil?
+    @logger = logger
+    add_global_observer(@logger)
+    changed
+    notify_observers(Notification::START)
+  end
+
+  attr_reader :logger
+
+  def stop_daemon
+    stop_services
+    changed
+    notify_observers(Notification::STOP)
+    exit
+  end
+
+  def reload_config
+    unless @config.nil?
+      @config.__load__
+      changed
+      notify_observers(Notification::RELOAD_CONFIG)
+      @config
+    end
+  end
+
+  def start_daemon(*args)
+  end
+
+end # class Daemon
+
+
+#FIXME: test me somehow

data/src/diff.rb

@@ -0,0 +1,665 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: diff.rb 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+
+module Diff
+
+  def diff(other, recursive=true)
+    gen_diff(other, recursive) {|a, b| a == b}
+  end
+
+  def gen_diff(other, recursive=true, &comp)
+    result = {
+      :similar => {},
+      :different => {},
+      :missing => {},
+      :additional => {}
+    }
+    if not other.is_a?(self.class)
+      result[:different] = {:self => self.class, :other => other.class}
+      return result
+    end
+    self.each_pair do |k, v|
+      if other.has_key?(k)
+        if comp[v, other[k]]
+          result[:similar][k] = v
+        else
+          if recursive and v.respond_to?(:gen_diff)
+            diff_result = v.gen_diff(other[k], recursive, &comp)
+          else
+            diff_result = {:self => v, :other => other[k]}
+          end
+          result[:different][k] = diff_result unless diff_result.no_diff?
+        end
+      else
+        result[:additional][k] = v
+      end
+    end
+    other.each_pair do |k, v|
+      if not self.has_key?(k)
+        result[:missing][k] = v
+      end
+    end
+    result
+  end
+
+  def no_diff?
+    self[:different] == {} and self[:missing] == {} and self[:additional] == {}
+  end
+
+end # module Diff
+
+
+class Array
+
+  include Diff
+
+  def each_pair
+    for i in 0...length do
+      yield(i, self[i])
+    end
+  end
+
+  def has_index?(i)
+    0 <= i and i < length
+  end
+
+  alias has_key? has_index?
+
+end # class Array
+
+
+class Hash
+
+  include Diff
+
+  def no_diff?
+    self[:different] == {} and self[:missing] == {} and self[:additional] == {}
+  end
+
+end # class Hash
+
+
+#
+# Unit test suite
+#
+test_section __FILE__ do
+
+
+#FIXME: Tidy me because some of my test are duplicated.
+
+
+class DiffTest < Test::Unit::TestCase
+
+  #
+  # Setup
+  #
+  class A < Array ; end
+  class H < Hash ; end
+
+  #
+  # Tests
+  #
+  def test_empty
+    h = []
+    other_h = []
+    result_h = h.diff(h)
+    assert_equal(true, result_h.no_diff?)
+    assert_equal({}, result_h[:similar])
+  end
+
+  def test_simple_similar
+    other_h = h = [ 'toto' => 'tata' ]
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => { 0 => { 'toto' => 'tata' } },
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_additional
+    h = [ 'toto' => 'tata' ]
+    other_h = []
+    result_h = {
+      :additional => { 0 => { 'toto' => 'tata' } },
+      :missing => {},
+      :similar => {},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_missing
+    h = []
+    other_h = [ 'toto' => 'tata' ]
+    result_h = {
+      :additional => {},
+      :missing => { 0 => { 'toto' => 'tata' } },
+      :similar => {},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_different
+    h = [ 'tutu' ]
+    other_h = [ 'tata' ]
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {},
+      :different => {0 => {:self => 'tutu', :other => 'tata'}},
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_several_similar
+    other_h = h = [ 'toto', 'tata']
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {0 => 'toto', 1 => 'tata'},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_several_additional
+    h = [ 'toto', 'tata' ]
+    other_h = []
+    result_h = {
+      :additional => {0 => 'toto', 1 => 'tata'},
+      :missing => {},
+      :similar => {},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_several_missing
+    h = []
+    other_h = [ 'toto', 'tata' ]
+    result_h = {
+      :additional => {},
+      :missing => {0 => 'toto', 1 => 'tata'},
+      :similar => {},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_several_different
+    h = [ 'foo', 'tutu' ]
+    other_h = [ 'bar', 'tata' ]
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {},
+      :different => {
+        0 => {:self => 'foo', :other => 'bar'},
+        1 => {:self => 'tutu', :other => 'tata'},
+      }
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_missing_missing
+    h = []
+    other_h = []
+    h[0] = 'toto'
+    other_h[1] = 'foo'
+    result_h = {
+      :additional => {},
+      :missing => {1 => 'foo'},
+      :similar => {},
+      :different => {0 => {:self => 'toto', :other => nil}}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_additional_similar
+    h = [ 'foo', 'toto' ]
+    other_h = [ 'foo' ]
+    result_h = {
+      :additional => {1 => 'toto'},
+      :missing => {},
+      :similar => {0 => 'foo'},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_additional_different
+    h = [ 'toto', 'tata' ]
+    other_h = [ 'foo' ]
+    result_h = {
+      :additional => {1 => 'tata'},
+      :missing => {},
+      :similar => {},
+      :different => {0 => { :self => 'toto', :other => 'foo' } }
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_missing_similar
+    h = [ 'foo' ]
+    other_h = [ 'foo', 'toto' ]
+    result_h = {
+      :additional => {},
+      :missing => {1 => 'toto'},
+      :similar => {0 => 'foo'},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_missing_different
+    h = ['foo']
+    other_h = ['bor', 'toto']
+    result_h = {
+      :additional => {},
+      :missing => {1 => 'toto'},
+      :similar => {},
+      :different => {0 => {:self => 'foo', :other => 'bor'}}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_similar_different
+    h = ['bar', 'toto']
+    other_h = ['bor', 'toto']
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {1 => 'toto'},
+      :different => {0 => {:self => 'bar', :other => 'bor'}}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_nested_similar_different
+    h = [['toto', 'bar'], 'tata']
+    other_h = [['toto', 'bor'], 'tata']
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {1 => 'tata'},
+      :different => {0 => {
+          :additional => {},
+          :missing => {},
+          :similar => {0 => 'toto'},
+          :different => {1 => {:self => 'bar', :other => 'bor'}}
+        }
+      }
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_nested_different_different
+    h = [['toto', 'bar'], 'tata']
+    other_h = [['toto', 'bor'], 'tutu']
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {},
+      :different => {
+        0 => {
+          :additional => {},
+          :missing => {},
+          :similar => {0 => 'toto'},
+          :different => {1 => {:self => 'bar', :other => 'bor'}}
+        },
+        1 => {:self => 'tata', :other => 'tutu'}
+      }
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_similar_different_additional
+    h = ['goo', 'wrong', 'add']
+    other_h = ['goo', 'bar']
+    result_h = {
+      :additional => {2 => 'add'},
+      :missing => {},
+      :similar => {0 => 'goo'},
+      :different => {1 => {:self => 'wrong', :other => 'bar'}}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_diff_class
+    h = ['bar', 'tata']
+    other_h = {0 => 'bar', 1 => 'tata'}
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {},
+      :different => {:self => Array, :other => Hash}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_diff_inherited_class
+    h = A.new(['bar', 'tata'])
+    other_h = {0 => 'bar', 1 => 'tata'}
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {},
+      :different => {:self => A, :other => Hash}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_array_in_hash
+    h = {'toto' => 'tata', 'foo' => ['goo', 'wrong', 'add']}
+    other_h = {'toto' => 'tata', 'foo' => ['goo', 'bar']}
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {'toto' => 'tata'},
+      :different => {'foo' => {
+          :additional => {2 => 'add'},
+          :missing => {},
+          :similar => {0 => 'goo'},
+          :different => {1 => {:self => 'wrong', :other => 'bar'}}
+        }
+      }
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_no_recursion
+    h = [['toto', 'bar'], 'tata']
+    other_h = [['toto', 'bor'], 'tutu']
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {},
+      :different => {0 => {
+          :self => ['toto', 'bar'],
+          :other => ['toto', 'bor']
+        },
+                     1 => {
+          :self => 'tata',
+          :other => 'tutu'
+        }
+      }
+    }
+    assert_equal(result_h, h.diff(other_h,false))
+  end
+
+  def test_other_comp_fun
+    h = [['false']]
+    other_h = [[false]]
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => { 0 => ['false']},
+      :different => {}
+    }
+    assert_equal(result_h, h.gen_diff(other_h, true) {|a, b| a.to_s == b.to_s})
+  end
+
+  def test_empty2
+    other_h = h = {}
+    diff_h = h.diff(h)
+    assert_equal(true, diff_h.no_diff?)
+    assert_equal({}, diff_h[:similar])
+  end
+
+  def test_simple_similar2
+    other_h = h = { 'toto' => 'tata' }
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => { 'toto' => 'tata' },
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_additional2
+    h = { 'toto' => 'tata' }
+    other_h = {}
+    result_h = {
+      :additional => { 'toto' => 'tata' },
+      :missing => {},
+      :similar => {},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_missing2
+    h = {}
+    other_h = { 'toto' => 'tata' }
+    result_h = {
+      :additional => {},
+      :missing => { 'toto' => 'tata' },
+      :similar => {},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_different2
+    h = { 'toto' => 'tutu' }
+    other_h = { 'toto' => 'tata' }
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {},
+      :different => { 'toto' => { :self => 'tutu', :other => 'tata' } }
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_several_similar2
+    other_h = h = { 'toto' => 'tata', 'foo' => 'bar' }
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => { 'toto' => 'tata', 'foo' => 'bar' },
+      :different => {}
+    }
+    diff = h.diff(other_h)
+    assert_equal(result_h, diff)
+    assert_equal(true, diff.no_diff?)
+  end
+
+  def test_several_additional2
+    h = { 'toto' => 'tata', 'foo' => 'bar' }
+    other_h = {}
+    result_h = {
+      :additional => { 'toto' => 'tata', 'foo' => 'bar' },
+      :missing => {},
+      :similar => {},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_several_missing2
+    h = {}
+    other_h = { 'toto' => 'tata', 'foo' => 'bar' }
+    result_h = {
+      :additional => {},
+      :missing => { 'toto' => 'tata', 'foo' => 'bar' },
+      :similar => {},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_several_different2
+    h = { 'toto' => 'tutu', 'foo' => 'bor' }
+    other_h = { 'toto' => 'tata', 'foo' => 'bar' }
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {},
+      :different => {
+        'toto' => { :self => 'tutu', :other => 'tata' },
+        'foo' => { :self => 'bor', :other => 'bar' },
+      }
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_missing_missing2
+    h = { 'toto' => 'tata' }
+    other_h = { 'foo' => 'bar' }
+    result_h = {
+      :additional => { 'toto' => 'tata' },
+      :missing => { 'foo' => 'bar' },
+      :similar => {},
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_additional_similar2
+    h = { 'toto' => 'tata', 'foo' => 'bar' }
+    other_h = { 'foo' => 'bar' }
+    result_h = {
+      :additional => { 'toto' => 'tata' },
+      :missing => {},
+      :similar => { 'foo' => 'bar' },
+      :different => {}
+    }
+    diff = h.diff(other_h)
+    assert_equal(result_h, diff)
+    assert_equal(false, diff.no_diff?)
+  end
+
+  def test_simple_additional_different2
+    h = { 'toto' => 'tata', 'foo' => 'bar' }
+    other_h = { 'foo' => 'bor' }
+    result_h = {
+      :additional => { 'toto' => 'tata' },
+      :missing => {},
+      :similar => {},
+      :different => { 'foo' => { :self => 'bar', :other => 'bor' } }
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_missing_similar2
+    h = { 'foo' => 'bar' }
+    other_h = { 'foo' => 'bar', 'toto' => 'tata' }
+    result_h = {
+      :additional => {},
+      :missing => { 'toto' => 'tata' },
+      :similar => { 'foo' => 'bar' },
+      :different => {}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_missing_different2
+    h = { 'foo' => 'bar' }
+    other_h = { 'foo' => 'bor', 'toto' => 'tata' }
+    result_h = {
+      :additional => {},
+      :missing => { 'toto' => 'tata' },
+      :similar => {},
+      :different => { 'foo' => { :self => 'bar', :other => 'bor' } }
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_simple_similar_different2
+    h = { 'foo' => 'bar', 'toto' => 'tata' }
+    other_h = { 'foo' => 'bor', 'toto' => 'tata' }
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => { 'toto' => 'tata' },
+      :different => { 'foo' => { :self => 'bar', :other => 'bor' } }
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_nested_similar_different2
+    h = {'foo' => {'toto' => 'tata', 'foo' => 'bar'}, 'toto' => 'tata'}
+    other_h = {'foo' => {'toto' => 'tata', 'foo' => 'bor'}, 'toto' => 'tata'}
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {'toto' => 'tata'},
+      :different => {'foo' => {
+          :additional => {},
+          :missing => {},
+          :similar => {'toto' => 'tata'},
+          :different => {'foo' => {:self => 'bar', :other => 'bor'}}
+        }
+      }
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_diff_class2
+    h = {0 => 'bar', 1 => 'tata'}
+    other_h = ['bar', 'tata']
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {},
+      :different => {:self => Hash, :other => Array}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_diff_inherited_class2
+    h = H.new(0 => 'bar', 1 => 'tata')
+    other_h = ['bar', 'tata']
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {},
+      :different => {:self => H, :other => Array}
+    }
+    assert_equal(result_h, h.diff(other_h))
+  end
+
+  def test_no_recursion2
+    h = {'foo' => {'toto' => 'tata', 'foo' => 'bar'}, 'toto' => 'tata'}
+    other_h = {'foo' => {'toto' => 'tata', 'foo' => 'bor'}, 'toto' => 'tata'}
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {'toto' => 'tata'},
+      :different => {'foo' => {
+          :self => {'toto' => 'tata', 'foo' => 'bar'},
+          :other => {'toto' => 'tata', 'foo' => 'bor'}
+        }
+      }
+    }
+    assert_equal(result_h, h.diff(other_h, false))
+  end
+
+  def test_other_comp_fun2
+    h = {'foo' => {'toto' => 'false', 'foo' => '0'}}
+    other_h = {'foo' => {'toto' => false, 'foo' => 0}}
+    result_h = {
+      :additional => {},
+      :missing => {},
+      :similar => {'foo' => {'toto' => 'false', 'foo' => '0'}},
+      :different => {}
+    }
+    assert_equal(result_h, h.gen_diff(other_h, true) {|a, b| a.to_s == b.to_s})
+  end
+
+end # class DiffTest
+
+
+end
+