ttk 0.1.576

data/lib/ttkd.rb

@@ -0,0 +1,51 @@
+# Author::    Nicolas Despres  <nicolas.despres@gmail.com>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: ttkd.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  # Standard library requirements
+  require 'drb'
+
+  # RubyEx requirements
+  require 'daemon'
+  require 'drb/drb_service'
+  require 'drb/insecure_protected_methods.rb'
+  require 'observable'
+
+  # TTKd library requirements
+  require 'ttk'
+
+  #
+  # Autoload modules
+  #
+  module Daemons
+    include TTKModule
+  end
+
+  module Testers
+    include TTKModule
+  end
+
+  module Services
+    include TTKModule
+  end
+
+  module Monitors
+    include TTKModule
+  end
+
+  module Fetchers
+    include TTKModule
+  end
+
+  class SymTbl
+    include DRb::DRbUndumped
+
+  end
+
+end # module TTK
+
+

data/ruby_ex/abstract.rb

@@ -0,0 +1,246 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: abstract.rb 185 2005-04-01 12:29:54Z polrop $
+
+
+#FIXME: find a way to be thread safe.
+
+
+require 'module/instance_method_visibility'
+
+
+module Concrete; end
+
+
+# When this module is included into a class, this class can't be instantiate
+# any more until the Concrete module is included too. This module cannot be
+# included if the Concrete module has been included before in one of the
+# class' superclass.
+module Abstract
+
+  def self.included(klass)
+    super
+    if klass.include?(Concrete)
+      raise(TypeError, "#{klass} - cannot make abstract a concrete class")
+    end
+    klass.module_eval do
+      class << self
+        unless private_method_defined?(:concrete_new)
+          alias_method :concrete_new, :new
+          visibility = instance_method_visibility('new')
+          def new(*args, &block)
+            raise(TypeError, "cannot instantiate an abstract class #{name}")
+          end
+          send(visibility, :new)
+          private :concrete_new
+        end
+      end
+    end
+  end
+
+end # module Abstract
+
+
+# Include this module in an abstract class to make it concrete and so, to be
+# able to instantiate it again. This module can be included if and only if the
+# Abstract module has been included before in one of the class' superclass.
+module Concrete
+
+  def self.included(klass)
+    super
+    unless klass.include?(Abstract)
+      raise(TypeError, "#{klass} - not an abstract class")
+    end
+    klass.module_eval do
+      class << self
+        visibility = instance_method_visibility('new')
+        def new(*args, &block)
+          concrete_new(*args, &block)
+        end
+        send(visibility, :new)
+      end
+
+      def is_a?(klass)
+        klass == Abstract ? false : super(klass)
+      end
+    end
+  end
+
+end # module Concrete
+
+
+class Class
+
+  def abstract?
+    include?(Abstract) ? (not include?(Concrete)) : false;
+  end
+
+end # class Class
+
+
+if (not defined? ABSTRACT_TESTED) and (defined? TEST_MODE or __FILE__ == $0)
+ABSTRACT_TESTED = true
+
+
+require 'test/unit/ui/yaml/testrunner'
+require 'singleton'
+
+
+class AbstractTest < Test::Unit::TestCase
+
+  class R; end
+
+  class A
+    include Abstract
+
+    attr_reader :initialized
+
+    def initialize(toto=nil)
+      @initialized = true
+    end
+
+  end
+
+  class B < A; end
+
+  def test_abstract
+    assert_nothing_raised { R.new }
+    assert(A.include?(Abstract))
+    assert_raises(TypeError) { A.new }
+    assert_raises(TypeError) { B.new }
+    assert_raises(TypeError) do
+      AbstractTest.module_eval %q{
+        class D
+          include Concrete
+          include Abstract
+        end
+      }
+    end
+  end
+
+  class C < A
+    include Concrete
+
+    attr_reader :toto
+
+    def initialize(toto=nil)
+      super
+      @toto = toto
+    end
+  end
+
+  class CC < C; end
+
+  def test_concrete
+    assert_raises(TypeError) do
+      AbstractTest.module_eval %q{ class D; include Concrete; end }
+    end
+    assert(C.new.initialized)
+    assert_nil(C.new.toto)
+    assert_equal('toto', C.new('toto').toto)
+    assert(CC.new.initialized)
+    assert_equal(SC.instance, SC.instance)
+    assert_equal(SCC.instance, SCC.instance)
+    assert_not_equal(SC.instance, SCC.instance)
+  end
+
+  class SA
+    include Singleton
+    include Abstract
+
+    attr_reader :initialized
+
+    def initialize(toto=nil)
+      @initialized = true
+    end
+
+  end
+
+  class SB < SA; end
+
+  def test_abstract_singleton
+    assert(SA.include?(Abstract))
+    assert_raises(NoMethodError) { SA.new }
+    assert_raises(TypeError) { SA.instance }
+    assert_raises(NoMethodError) { SB.new }
+    assert_raises(TypeError) { SB.instance }
+    assert_raises(TypeError) do
+      AbstractTest.module_eval %q{
+        class SD; include Concrete; include Abstract; end
+      }
+    end
+  end
+
+  class SC < SA
+    include Concrete
+
+  end
+
+  class SCC < SC; end
+
+  def test_concrete_singleton
+    assert_raises(TypeError) do
+      AbstractTest.module_eval %q{ class SD; include Concrete; end }
+    end
+    assert_raises(NoMethodError) { SC.new }
+    assert(SC.instance.initialized)
+    assert(SCC.instance.initialized)
+    assert_equal(SC.instance, SC.instance)
+    assert_equal(SCC.instance, SCC.instance)
+    assert_not_equal(SC.instance, SCC.instance)
+  end
+
+  class IsA; include Abstract; end
+  class IsB < IsA; include Concrete; end
+
+  def test_is_a
+    assert(! IsB.new.is_a?(Abstract))
+    assert(IsB.new.is_a?(IsA))
+    assert(IsB.include?(Abstract))
+  end
+
+  def test_abstract?
+    assert(IsA.abstract?)
+    assert(! IsB.abstract?)
+  end
+
+  class AArg
+    include Abstract
+
+    attr_reader :arg
+
+    def initialize(arg)
+      @arg = arg
+    end
+
+  end
+
+  class CArg < AArg
+    include Concrete
+  end
+
+  def test_arg
+    assert_nothing_raised { CArg.new('toto') }
+    assert_raises(ArgumentError) { CArg.new }
+  end
+
+  class AA_; include Abstract; end
+  class BB_ < AA_; include Abstract; end
+  class CC_ < BB_; include Concrete; end
+  class DD_ < CC_; include Concrete; end
+
+  def test_double_abstract
+    assert_raises(TypeError) { AA_.new }
+    assert_raises(TypeError) { BB_.new }
+    assert_nothing_raised { CC_.new }
+    assert_nothing_raised { DD_.new }
+  end
+
+end # class AbstractTest
+
+
+end
+

data/ruby_ex/abstract_node.rb

@@ -0,0 +1,85 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: abstract_node.rb 186 2005-04-03 00:07:45Z ertai $
+
+
+require 'abstract'
+require 'array_each_pair'
+
+class AbstractNode
+  include Abstract
+
+  def initialize(data=nil, *sub_nodes)
+    @data = data
+    self.each_node { |sub_node| check_sub_node_type(sub_node) }
+  end
+
+  attr_reader :data, :sub_nodes
+
+  def [](index)
+    @sub_nodes[index]
+  end
+
+  def []=(index, sub_node)
+    check_sub_node_type(sub_node)
+    @sub_nodes[index] = sub_node
+  end
+
+  def merge!(sub_nodes)
+    sub_nodes.each { |index, sub_node| self[index] = sub_node }
+  end
+
+  def each_pair(&block)
+    @sub_nodes.each_pair { |index, sub_node| block[index, sub_node] }
+  end
+
+  def each_node(&block)
+    @sub_nodes.each_pair { |index, sub_node| block[sub_node] }
+  end
+
+  alias :each :each_node
+
+  def each_index(&block)
+    @sub_nodes.each_pair { |index, sub_node| block[index] }
+  end
+
+  def delete(index)
+    @sub_nodes.delete(index)
+  end
+
+  def nb_sub_nodes
+    @sub_nodes.size
+  end
+
+  alias size nb_sub_nodes
+  alias length nb_sub_nodes
+
+  def leaf?
+    @sub_nodes.empty?
+  end
+
+  def pre_depth_first(index=nil, &block)
+    block[index, self]
+    @sub_nodes.each_pair do |index, sub_node|
+      sub_node.pre_depth_first(index, &block)
+    end
+    nil
+  end
+
+#   FIXME: implement me
+#   def breadth_first(&block)
+#   end
+
+  protected
+  def check_sub_node_type(sub_node)
+    unless sub_node.is_a?(self.class)
+      raise(TypeError, "`#{sub_node}' - must be a #{self.class}")
+    end
+  end
+
+end # class AbstractNode
+
+

data/ruby_ex/array_each_pair.rb

@@ -0,0 +1,18 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: cache.rb 173 2005-03-29 09:41:46Z polrop $
+
+
+class Array
+
+  # Basically, do the same as each_with_index but yield the arguments in
+  # reverse order. Thus an array can be assume in certain cases to a hash.
+  def each_pair(&block)
+    each_with_index { |x, i| block[i, x] }
+  end
+
+end # class Array
+

data/ruby_ex/ask.rb

@@ -0,0 +1,101 @@
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright: Copyright (c) 2004, 2005 Nicolas Pouillard. All rights reserved.
+# License: GNU General Public License (GPL).
+
+# $LastChangedBy: ertai $
+# $Id: ask.rb 187 2005-04-03 00:11:56Z ertai $
+
+ANSWERS = [ :y, :n ]
+ANSWER_NOT_VALID = 'Not a valid answer, please answer correctly'
+
+# `ask', ask the user to answer, to your question.
+#
+# Example:
+#   ask('Commiting, are you sure', :n)
+#
+#   produce => Commiting, are you sure (y/N): 
+#   and wait your answer.
+def ask ( aQuestion, theDefaultAnswer=:y, cin=STDIN, cout=STDOUT, cerr=STDERR )
+  
+  yn = case theDefaultAnswer
+       when :y then ' [Y/n]: '
+       when :n then ' [y/N]: '
+       else raise ArgumentError, "not valid default answer #{theDefaultAnswer}"
+       end
+
+  loop do
+    cout.print aQuestion, yn
+    cout.flush
+
+    answer = cin.readline.chomp.downcase
+    
+    return theDefaultAnswer if answer.empty?
+
+    answer = answer.to_sym
+
+    return answer if ANSWERS.include? answer
+
+    cerr.puts ANSWER_NOT_VALID
+    cout.puts
+  end
+
+end
+
+if defined? TEST_MODE or $0 == __FILE__
+
+require 'test/unit'
+class AskTest < Test::Unit::TestCase
+
+  def ask_checker ( question, default, answer, ref, out, err )
+    require 'stringio'
+    cin, cout, cerr = StringIO.new, StringIO.new, StringIO.new
+    cin.puts answer
+    cin.rewind
+    res = ask(question, default, cin, cout, cerr)
+    cout.rewind
+    cerr.rewind
+    assert_equal(res, ref, 'bad return value')
+    assert_equal(cout.readlines.join, out, 'bad standard output')
+    assert_equal(cerr.readlines.join, err, 'bad error output')
+  end
+
+  def test_bad_default
+    assert_raise(ArgumentError) { ask_checker('Q', :foo, '', :y, [], []) }
+    assert_nothing_raised do
+      ask_checker('Q', :y, 'y', :y, 'Q [Y/n]: ', '')
+    end
+    assert_nothing_raised do
+      ask_checker('Q', :n, 'y', :y, 'Q [y/N]: ', '')
+    end
+  end
+
+  def test_valid_default_yes
+    ask_checker('Q', :y, 'y', :y, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, 'Y', :y, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, 'n', :n, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, 'N', :n, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, '',  :y, 'Q [Y/n]: ', '')
+  end
+
+  def test_valid_default_no
+    ask_checker('Q', :n, 'y', :y, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, 'Y', :y, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, 'n', :n, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, 'N', :n, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, '',  :n, 'Q [y/N]: ', '')
+  end
+
+  def test_invalid_answer
+    ask_checker('Q', :n, "bad\ny", :y,
+                "Q [y/N]: \nQ [y/N]: ", ANSWER_NOT_VALID + "\n")
+    ask_checker('Q', :y, "ad\n\n", :y,
+                "Q [Y/n]: \nQ [Y/n]: ", ANSWER_NOT_VALID + "\n")
+  end
+
+  def test_ask1
+    ask_checker('Q', :y, 'y', :y, 'Q [Y/n]: ', '')
+  end
+
+end # class AskTest
+
+end