ttk 0.1.580 → 0.2.0

data/lib/ttk/Tools/io/dispatch.rb

@@ -1,31 +0,0 @@
-# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
-# License::   LGPL
-# $Id: dispatch.rb 567 2005-04-13 08:00:06Z polrop $
-
-
-require 'io/ext'
-require 'io/filters'
-
-class IO
-
-  class Dispatch
-
-    include IO::ImplIndent
-
-    def initialize(*filters)
-      @of = filters
-    end
-
-    def method_missing(*args)
-      @of.each { |of| of.send(*args) }
-    end
-
-    def <<(arg)
-      @of.each { |of| of << arg }
-      self
-    end
-
-  end
-
-end

data/lib/ttk/Tools/io/ext.rb

@@ -1,70 +0,0 @@
-# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
-# License::   LGPL
-# $Id: ext.rb 567 2005-04-13 08:00:06Z polrop $
-
-
-require 'delegate'
-
-class IO
-  module ImplIndent
-    def indent(x='  ', &block)
-      old = "#@indent"
-#      p "old: `#@indent'"
-      @indent += x.is_a?(Numeric) ? '  ' * x : x.to_s
-#      p "ind: `#@indent'"
-      yield(self)
-      @indent = old
-    end
-  end
-
-  module ImplPrintIO
-    def print_io(io)
-      io.each do |line|
-	line.chomp!
-	self.puts line
-      end
-    end
-  end
-
-  module ImplPrintFile
-    def print_file(file)
-      fh = File.new(file, 'r')
-      self.print_io fh
-      fh.close
-    end
-  end
-
-  module ImplExt
-    def dash
-      self.puts '-'
-    end
-
-    include IO::ImplIndent
-    include IO::ImplPrintIO
-    include IO::ImplPrintFile
-  end
-
-  class Ext < DelegateClass(IO)
-    include ImplIndent
-  end
-end
-
-
-#FIXME: adapt me to a real unit test suite
-# if __FILE__ == $0
-
-#   class A < DelegateClass(IO) # :nodoc:
-#     def syswrite(x)
-#       super('--'+x)
-#     end
-#     def write(x)
-#       super('--'+x)
-#     end
-#   end
-
-#   a = A.new($stdout)
-
-#   a << 'foo'
-
-# end

data/lib/ttk/Tools/io/filters.rb

@@ -1,71 +0,0 @@
-# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
-# License::   LGPL
-# $Id: filters.rb 567 2005-04-13 08:00:06Z polrop $
-
-
-require 'io/ext'
-require 'delegate'
-
-class IO
-  class InputFilter < DelegateClass(IO)
-    def initialize(input, &block)
-      @input = input
-      @block = block
-    end
-    def each(&block)
-      @input.each { |line| block[@block[line]] }
-    end
-    def each_byte(&block)
-      @input.each_byte { |line| block[@block[line]] }
-    end
-    def each_line(&block)
-      @input.each_line { |line| block[@block[line]] }
-    end
-    def getc
-      @block[@input.getc]
-    end
-    def gets
-      @block[@input.getc]
-    end
-    def read
-      @block[@input.read]
-    end
-    def readlines
-      @input.readlines.map(&@block)
-    end
-    alias readchar getc
-    alias readline gets
-  end
-
-  class OutputFilter < DelegateClass(IO)
-    def initialize(output, &block)
-      @output = output
-      @block = block
-    end
-    def <<(o)
-      @output.write @block[o.to_s]
-      self
-    end
-    def print(*args)
-      @output.print args.map { |x| @block[x.to_s] }
-    end
-    def printf(fmt, *args)
-      @output.printf fmt, args.map { |x| @block[x] }
-    end
-    def putc(c)
-      @output.putc @block[c]
-    end
-    def puts(*args)
-      if args.size == 0
-	@output.print @block["\n"]
-      else
-	@output.print args.map { |x| @block[x.to_s] }
-      end
-    end
-    def write(o)
-      @output.write @block[o.to_s]
-    end
-  end
-end
-

data/lib/ttk/filters/BasicLogger.rb

@@ -1,30 +0,0 @@
-# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
-# License::   LGPL
-# $Id: BasicLogger.rb 567 2005-04-13 08:00:06Z polrop $
-
-
-require 'logger'
-
-module TTK
-
-  module Filters
-
-    class BasicLogger < Filter
-      include Concrete
-
-      #FIXME: create a new logger and dump it to an extra files given in
-      #       argument
-      def initialize ( log=nil )
-#        @log = log.is_a?(Logger) ? log : LOG
-      end
-
-      def update ( msg, *args )
-#	@log.info "#{msg.to_s.ljust 14}, args: #{args.inspect}"
-      end
-
-    end # class BasicLogger
-
-  end # module Filters
-
-end # TTK

data/lib/ttk/loaders/OYaml.rb

@@ -1,60 +0,0 @@
-# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
-# License::   LGPL
-# $Id: OYaml.rb 567 2005-04-13 08:00:06Z polrop $
-
-
-require 'yaml/basenode_ext'
-
-module TTK
-
-  module Loaders
-
-    # OYaml: Ordered Yaml
-    class OYaml < Loader
-      include Concrete
-
-      def load_doc(io)
-	YAML::parse(io).ttk_loader_oyaml_transform
-      end
-
-    end # class OYaml
-
-
-    module ::YAML
-
-      module BaseNode
-
-        def ttk_loader_oyaml_transform
-          @type_id = nil unless defined? @type_id
-          t = nil
-          if @value.is_a? Hash
-            t = OHash.new
-            ordered_children_with_index.each do |v, k|
-              k = k.to_s.to_sym unless k.is_a? Symbol or k.is_a? Integer
-              if k == :strategy
-                t[k] = TTK::Loaders.get_class(v.value)
-              else
-                t[k] = v.ttk_loader_oyaml_transform
-              end
-            end
-          elsif @value.is_a? Array
-            t = []
-            @value.each do |v|
-              t.push v.ttk_loader_oyaml_transform
-            end
-          else
-            t = @value
-          end
-          YAML.transfer(@type_id, t)
-        end
-
-      end # module BaseNode
-
-    end # module ::YAML
-
-  end # module Loaders
-
-end # module TTK
-
-

data/lib/ttk/loaders/YamlOld.rb

@@ -1,65 +0,0 @@
-# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
-# License::   LGPL
-# $Id: YamlOld.rb 567 2005-04-13 08:00:06Z polrop $
-
-
-require 'yaml'
-
-class Object # :nodoc:
-  def yaml_load_map
-    self
-  end
-end
-
-class Array # :nodoc:
-  def yaml_load_map
-    map { |x| x.yaml_load_map }
-  end
-end
-
-class Hash # :nodoc:
-  def yaml_load_map
-    res = {}
-    each do |k,v|
-      k = k.to_s.to_sym unless k.is_a? Symbol or k.is_a? Integer
-      if k == :class or k == :strategy
-        if k == :class
-          k = :strategy
-        end
-        unless v.is_a? Strategies::Strategy
-          v = v.to_s
-          if v =~ /TestT/
-            v.gsub!(/TestTBase/, 'Strategy')
-            v.gsub!(/TTK::Test::TestT/, 'TTK::Strategies::')
-            v.gsub!(/Test::TestT/, 'Strategies::')
-            v.gsub!(/TestT/, '')
-          end
-        end
-        res[k] = Loaders.get_class(v)
-      elsif k == :content
-        res[:contents] = v.yaml_load_map
-      else
-        res[k] = v.yaml_load_map
-      end
-    end
-    res
-  end
-end
-
-module TTK
-
-  module Loaders
-
-    class YamlOld < Loader
-      include Concrete
-
-      def load_doc(io)
-	YAML::load(io).yaml_load_map
-      end
-
-    end # class Yaml
-
-  end # module Loaders
-
-end # module TTK

data/ruby_ex/abstract.rb

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