ttk 0.1.580 → 0.2.0

data/ruby_ex/abstract_node.rb

@@ -1,85 +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: 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

@@ -1,18 +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: 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

@@ -1,101 +0,0 @@
-# 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

data/ruby_ex/attributed_class.rb

@@ -1,304 +0,0 @@
-# Copyright: Copyright (c) 2004  Nicolas Pouillard. All rights reserved.
-# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# License: Gnu General Public License.
-
-# $LastChangedBy: ertai $
-# $Id: attributed_class.rb 186 2005-04-03 00:07:45Z ertai $
-
-
-# Extension to have inherited, class attributes,
-# Where each class have his own attributes set.
-module AttributedClass
-
-  class Attribute
-
-    attr_reader :name, :descr, :klass, :default_proc
-    attr_accessor :default
-
-    @@default_proc = nil
-
-    def initialize ( name, descr, *args, &block )
-      raise ArgumentError, 'need a symbol' unless name.is_a? Symbol
-      @name, @descr = name, descr
-      @default, @klass = nil, nil
-      @mandatory = false
-      @visible = true
-      if block_given?
-        @default_proc = block
-      else
-        @default_proc = @@default_proc
-      end
-      other = []
-
-      args.each do |arg|
-        case arg
-        when :mandatory then @mandatory = true
-        when :invisible then @visible = false
-        else other << arg
-        end
-      end
-
-      case other.size
-      when 1
-        if other[0].is_a? Class
-          @klass = [other[0]]
-        elsif other[0].is_a? Array and other[0].all? { |k| k.is_a? Class }
-          @klass = other[0]
-        else
-          @default = other[0]
-        end
-      when 2
-        a, b = other
-        if a.is_a? Class and b.is_a? a
-          @klass, @default = [a], b
-        elsif a.is_a? Array and
-              a.all? { |k| k.is_a? Class } and
-              a.any? { |k| b.is_a? k }
-          @klass, @default = a, b
-        elsif b.is_a? Class and a.is_a? b
-          @klass, @default = [b], a
-        elsif b.is_a? Array and
-              b.all? { |k| k.is_a? Class } and
-              b.any? { |k| a.is_a? k }
-          @klass, @default = b, a
-        else
-          raise ArgumentError, 'need a Class and a default value'
-        end
-      when 0
-      else raise ArgumentError, 'too many values'
-      end
-
-      # removed because it causes some probleme when distributed such a class
-      #[@name, @descr, @default].each { |x| x.freeze }
-    end
-
-    def visible?
-      @visible
-    end
-
-    def invisible?
-      !@visible
-    end
-
-    def mandatory?
-      @mandatory
-    end
-
-    def valid? ( anObject )
-      return false if mandatory? and anObject.nil?
-      @klass.nil? or @klass.empty? or @klass.any? { |k| anObject.is_a? k }
-    end
-
-
-    def self.set_default_proc ( &block )
-      @@default_proc = block
-    end
-      
-    
-    def help ( output=STDERR )
-      output << "#@name: #@descr"
-      output << " [#@klass]" unless @klass.nil?
-      other = []
-      other << 'mandatory' if mandatory?
-      other << 'invisible' if invisible?
-      output << " (#{other.join(', ')})" unless other.empty?
-      output
-    end
-
-    def inspect
-      help('#<') + '>'
-    end
-
-  end # class Attribute
-
-
-  class MethodAttribute < Attribute
-    VISIBILITIES = [ :private, :protected, :public, :unknown ]
-    attr_reader :visibility
-    def private?
-      @visibility == :private
-    end
-    def protected?
-      @visibility == :protected
-    end
-    def public?
-      @visibility == :public
-    end
-    def initialize ( name, descr, *args )
-      vis = args.find { |arg| VISIBILITIES.include? arg }
-      args.delete(vis) unless vis.nil?
-      @visibility = vis || :unknown
-      super(name, descr, *args)
-    end
-  end # class MethodAttribute
-
-
-  class AttributeError < Exception
-
-    def initialize ( anObject, anAttr, val=nil )
-      if val.nil?
-        super "Missing the #{anAttr.name} attribute for `#{anObject}'"
-      else
-        super "Attribute #{anAttr.name} wait for a `#{anAttr.klass}' not " +
-              "`#{val}' in #{anObject}"
-      end
-    end
-
-  end # class AttributeError
-
-
-  def self.included ( aClass )
-
-    aClass.module_eval do
-
-      def initialize_attributes ( *default_proc_args )
-        self.class.attributes.each do |attr|
-          next if attr.is_a? MethodAttribute
-          if attr.default_proc.nil? and attr.default.nil?
-            instance_variable_set("@#{attr.name}", nil)
-          else
-            unless attr.default_proc.nil?
-              pr = attr.default_proc
-              if pr.arity == default_proc_args.size
-                default = pr[*default_proc_args]
-              else
-                default = pr[attr, *default_proc_args]
-              end
-              attr.default = default
-            end
-            send "#{attr.name}=", attr.default
-          end
-        end
-      end
-
-      def self.set_default_proc ( &block )
-        Attribute.set_default_proc(&block)
-      end
-
-      def each_attribute ( &block )
-        self.class.attributes.each do |attr|
-          block[attr, send(attr.name)]
-        end
-      end
-
-      def each_variable_attribute ( &block )
-        self.class.attributes.each do |attr|
-          next if attr.is_a? MethodAttribute
-          block[attr, send(attr.name)]
-        end
-      end
-
-      def each_method_attribute ( &block )
-        self.class.attributes.each do |attr|
-          next unless attr.is_a? MethodAttribute
-          block[attr, send(attr.name)]
-        end
-      end
-
-      def check_attribute ( attr, anObject )
-        unless attr.valid? anObject
-          raise AttributeError.new(self, attr, anObject)
-        end
-      end
-
-      def check_attributes
-        each_variable_attribute(&method(:check_attribute))
-      end
-
-      def self.help ( output=STDERR )
-        output.puts "#{self.to_s}:"
-        attributes.each do |attr|
-          output << '  '
-          attr.help(output)
-          output.puts '.'
-        end
-      end
-
-      def self.attributes
-        unless defined? @attributes
-          if superclass and superclass.respond_to? :attributes
-            @attributes = superclass.attributes.dup
-          else
-            @attributes = []
-          end
-        end
-        @attributes
-      end
-
-      def self.attribute ( name, descr, *args, &block )
-        attr = Attribute.new(name, descr, *args, &block)
-        unless method_defined? name
-          if att = get_attribute(name, MethodAttribute)
-            attributes.delete(att)
-          end
-          attr_reader name
-        end
-        meth = "#{name}="
-        unless method_defined? meth
-          if att = get_attribute(meth, MethodAttribute)
-            attributes.delete(att)
-          end
-          attr_writer name
-        end
-        attributes << attr
-      end
-
-      def self.method_attribute ( name, descr, *args, &block )
-        # unless method_defined? name
-          # raise ArgumentError, "Undefined method #{name}"
-        # end
-        attr = MethodAttribute.new(name, descr, *args, &block)
-        attributes << attr
-      end
-
-      def self.get_attribute ( name, type=nil )
-        if type.nil?
-          attributes.find { |attr| attr.name == name }
-        else
-          attributes.find { |attr| attr.name == name && attr.is_a?(type) }
-        end
-      end
-
-    end
-
-  end
-
-end # module AttributedClass
-
-
-
-if defined? TEST_MODE or $0 == __FILE__
-
-  require 'test/unit'
-  class AttributedClassTest < Test::Unit::TestCase
-
-    def test_simple
-      c = Class.new
-      assert_nothing_raised do
-        c.module_eval { include AttributedClass }
-      end
-      assert_equal([], c.attributes)
-      assert_nothing_raised do
-        c.module_eval { attribute :foo, 'foofoo', 42 }
-      end
-      cc, d, dd = nil, nil, nil
-      assert_nothing_raised { cc = c.new }
-      assert_equal(nil, cc.foo)
-      assert_nothing_raised { cc.initialize_attributes }
-      assert_equal(42, cc.foo)
-      assert_nothing_raised { cc.foo = 32 }
-      assert_equal(32, cc.foo)
-      assert_nothing_raised { d = Class.new(c) }
-      assert_nothing_raised do
-        d.module_eval { attribute :bar, 'foofoo', :mandatory }
-      end
-      assert_nothing_raised { dd = d.new }
-      assert_nothing_raised { dd.initialize_attributes }
-      assert_raise(AttributedClass::AttributeMissingError) do
-        dd.check_attributes
-      end
-    end
-
-  end # class AttributedClassTest
-
-end