ttk 0.1.580 → 0.2.0

data/ruby_ex/const_regexp.rb

@@ -1,59 +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: const_regexp.rb 83 2004-12-16 13:06:42Z polrop $
-
-
-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
-#
-if defined? TEST_MODE or $0 == __FILE__
-
-
-require 'test/unit/ui/yaml/testrunner'
-
-
-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/ruby_ex/daemon.rb

@@ -1,134 +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: daemon.rb 144 2005-01-30 14:12:16Z polrop $
-
-
-require 'pathname'
-require 'singleton'
-
-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/ruby_ex/diff.rb

@@ -1,667 +0,0 @@
-# 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 186 2005-04-03 00:07:45Z ertai $
-
-
-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
-#
-if defined? TEST_MODE or $0 == __FILE__
-
-
-#FIXME: Tidy me because some of my test are duplicated.
-
-
-require 'test/unit/ui/yaml/testrunner'
-
-
-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
-