kyanite 0.3.1

data/lib/kyanite/symbol.rb

@@ -0,0 +1,19 @@
+
+class Symbol
+  
+    def empty?;                         false;           end  
+    def dup;                            self;            end  
+    
+    def +(other)
+      (self.to_s + other.to_s).to_sym
+    end
+    
+    def <=>(other)
+      self.to_s <=> other.to_s
+    end
+    
+    def size
+      self.to_s.size
+    end
+    
+end 

data/lib/kyanite/tree.rb

@@ -0,0 +1,99 @@
+
+
+require 'tree'
+
+# -----------------------------------------------------------------------------------------
+# Ergänzungen zu rubytree 0.5.2
+#
+module Tree
+  class TreeNode
+    attr_reader :childrenHash
+   
+    
+    # kann jetzt auch mit Symbolen umgehen
+    def to_s
+      ":#{@name}"
+      # "Node Name: #{@name}" +
+        # " Content: #{@content || '<Empty>'}" + 
+        # " Parent: #{(isRoot?()  ? '<None>' : @parent.name)}" + 
+        # " Children: #{@children.length}" +
+        # " Total Nodes: #{size()}"
+    end  
+    
+    
+    # funktioniert jetzt  
+    def printTree(level = 0, breite = 8)
+
+      if isRoot? 
+        print "*"
+        
+      elsif level == 0
+        print 'X'
+      
+      else
+        print "|" unless parent.isLastSibling?
+        print(" " * (level - 1 ) * breite)
+        print(isLastSibling? ? "+" : "|")
+        print "---"
+        print(hasChildren? ? "+" : ">")
+      end
+
+      puts " #{name}"
+
+      children { |child| child.printTree(level + 1)}
+      nil
+    end    
+    
+    
+    # anders als [] wird der gesamte Baum durchsucht
+    # Liefert den ersten Treffer 
+    def find( node_name )
+      return self               if self.name == node_name
+      result = self[node_name]
+      return result if result
+      children do |c| 
+        next if c.children.empty?
+        #puts "durchsuche #{c.name}"
+        result = c.find(node_name)
+        return result if result
+      end
+      nil
+    end
+    
+    
+    # Liefert ein Array aller untergeordneten Child-Keys. 
+    # Es wird der gesamte Baum durchsucht.
+    def all_child_keys
+      result = @childrenHash.keys || []
+        children do |c| 
+        #puts "durchsuche #{c}"
+          next if c.childrenHash.empty?
+          result += c.all_child_keys
+        end      
+      result
+    end
+    
+    
+    
+    
+  end # class
+end # module  
+
+
+
+
+
+
+
+ 
+
+
+    
+    
+    
+    
+    
+    
+    
+    
+    

data/lib/kyanite/undoable.rb

@@ -0,0 +1,2 @@
+
+require 'kyanite/general/undoable' 

data/lib/kyanite/unit_test.rb

@@ -0,0 +1,2 @@
+
+require 'kyanite/operation/unit_test'

data/test/_start_all.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# 
+#	Führt alle Tests aus
+#
+
+     
+	# Test-Verzeichnis der Applikation
+	test_verzeichnis = File.expand_path(File.dirname(__FILE__) )    
+    
+	Dir["#{test_verzeichnis}/test_*.rb"].sort.each { |t| require t }
+	Dir["#{test_verzeichnis}/array/test_*.rb"].sort.each { |t| require t }
+	Dir["#{test_verzeichnis}/enumerable/test_*.rb"].sort.each { |t| require t }
+	Dir["#{test_verzeichnis}/general/test_*.rb"].sort.each { |t| require t }
+	Dir["#{test_verzeichnis}/numeric/test_*.rb"].sort.each { |t| require t }
+	Dir["#{test_verzeichnis}/string/test_*.rb"].sort.each { |t| require t }
+
+  

data/test/array/test_array.rb

@@ -0,0 +1,106 @@
+
+require 'kyanite/unit_test'
+require 'kyanite/smart_load_path'; smart_load_path
+require 'perception'                                if $0 == __FILE__    
+
+require 'kyanite/array/array'
+require 'kyanite/numeric/numeric'
+require 'kyanite/set'
+
+
+# Tests für Array
+# 
+class TestKyaniteArray < UnitTest 
+  
+  def test_rephrase_index
+    test = [ :a, :b, :c, :d]
+    0.upto(3) do | i |
+      i_inv = test.rephrase_index(i)
+      i_neg = test.rephrase_index(i, :neg)
+      i_pos = test.rephrase_index(i, :pos)
+      # print "\n#{test[i]}   #{i}   #{i_inv}"
+      
+      assert_not_equal  i,      i_inv    
+      assert_not_equal  i,      i_neg    
+      assert_equal      i_neg,  i_inv    
+      assert_equal      i,      i_pos   
+      assert_equal test[i],   test[i_inv]
+      assert_equal test[i],   test[i_pos]
+      assert_equal test[i],   test[i_neg]
+    end # do
+    
+    -4.upto(-1) do | i |
+      i_inv = test.rephrase_index(i)
+      i_neg = test.rephrase_index(i, :neg)
+      i_pos = test.rephrase_index(i, :pos)
+      # print "\n#{test[i]}   #{i}   #{i_inv}"
+      
+      assert_not_equal  i,      i_inv    
+      assert_not_equal  i,      i_pos    
+      assert_equal      i_pos,  i_inv    
+      assert_equal      i,      i_neg   
+      assert_equal test[i],   test[i_inv]
+      assert_equal test[i],   test[i_pos]
+      assert_equal test[i],   test[i_neg]
+    end # do    
+    
+    [4, 5, -5, -6].each do |i|
+      i_inv = test.rephrase_index(i)
+      i_neg = test.rephrase_index(i, :neg)
+      i_pos = test.rephrase_index(i, :pos)
+      # print "\nx   #{i}   #{i_inv}"  
+      assert_equal      i,      i_neg         
+      assert_equal      i,      i_pos         
+      assert_equal      i,      i_neg         
+      assert_equal test[i],   test[i_inv]
+      assert_equal test[i],   test[i_pos]
+      assert_equal test[i],   test[i_neg]    
+    end
+    
+  end
+  
+  
+
+  
+  def test_array_diff
+      a = [1,2,3,4,5, :a, 'b']
+      b = [1,2,4,5,6,'a',:c]
+
+      assert_equal [3,:a,'b'],                a - b                
+      assert_equal [3,:a,'b', 3,:a,'b'],      a + a - b             
+      assert_equal [6, 'a', :c],              b - a
+      assert_equal [],                        b - b
+      assert_equal [],                        a - a
+  end
+
+
+  def test_array_shift_complement
+      assert_equal [2,3],   [1,2,3].shift_complement
+      assert_equal 3,       [1,2,3].shift_complement.shift_complement
+      assert_equal nil,     [1,2,3].shift_complement.shift_complement.shift_complement
+  end
+
+
+  
+ 
+  
+    
+  
+  def test_divide
+    numbers = [1, 3, 4, 6, 9, 10, 11]
+    result = numbers.divide { |i,j| (i - j).abs == 1 }
+    assert_equal [[11, 10, 9], [6], [1], [3, 4]],  result
+  end
+  
+  
+  
+end # class 
+
+
+
+
+
+
+
+
+

data/test/array/test_matrix2.rb

@@ -0,0 +1,162 @@
+
+
+require 'kyanite/unit_test'
+require 'kyanite/smart_load_path'; smart_load_path
+require 'perception'                                if $0 == __FILE__    
+
+require 'kyanite/matrix2'
+require 'kyanite/general/nil'   
+
+# require 'benchmark'
+# include Benchmark
+
+
+class TestKyaniteMatrix2 < UnitTest
+
+
+  #
+  # Normale Matrix testen: Zellen und Zeilen
+  #
+  def test_matrix_zellen_und_zeilen
+  # Initialisierung
+  zeile0 = ['Ueberschrift', 'Spalte1', 'Spalte2']
+  zeile1 = ['Zeile1', 'Wert 1.1', 'Wert 1.2']
+  zeile2 = ['Zeile2', 'Wert 2.1', 'Wert 2.2']
+  zeile3 = ['Zeile3', 'Wert 3.1', 'Wert 3.2', 'Wert 3.3']
+  zeile4 = ['Zeile4', 'Wert 4.1', 'Wert 4.2']
+
+  table = [zeile0, zeile1, zeile2, zeile3, zeile4]    # dies ist noch ein Array
+  mymatrix = Matrix2.new(table)                       # und dies ist eine Matrix2
+  assert_kind_of Matrix2, mymatrix
+   
+  
+  # Zellen-Funktionen testen
+  assert_equal 'Wert 2.2',      mymatrix[2][2]
+  mymatrix.set_element!(2,2,'Hallo 2.2')
+  assert_equal 'Hallo 2.2',     mymatrix[2][2]
+  
+
+  #  Zeilen-Funktionen testen
+  assert_equal 	zeile2,                   mymatrix.row(2)
+  assert_equal 	mymatrix.row(2).size,     mymatrix.column_size	   
+  assert_nil                              mymatrix.row(99)
+  assert_nil                              mymatrix.row(-99)
+  assert_equal 	0,                        mymatrix.row(99).size
+  mymatrix.set_row!(3, zeile4)  
+  assert_equal	mymatrix.row(3),          mymatrix.row(4)
+  mymatrix[3][0] = 'Z3'	
+  mymatrix.set_element!(3,0,'ZEILE3')	
+  mymatrix.set_element!(3,1,'WERT 3.1')	
+  mymatrix.set_element!(3,2,'WERT 3.2')	
+  assert_not_equal mymatrix.row(3),       mymatrix.row(4)
+  
+  zeile5 = ['Zeile5', 'Wert 5.1', 'Wert 5.2']
+  mymatrix.set_row!(5, zeile5)  	
+  end
+
+
+
+
+  # 
+  # Normale Matrix testen: resize_to_header
+  #	
+  def test_resize_to_header
+  # Erneute Initialisierung
+  zeile0 = ['Ueberschrift', 'Spalte1', 'Spalte2']
+  zeile1 = ['Zeile1', 'Wert 1.1', 'Wert 1.2']
+  zeile2 = ['Zeile2', 'Wert 2.1']
+  zeile3 = ['Zeile3', 'Wert 3.1', 'Wert 3.2', 'Wert 3.3']
+  zeile4 = ['Zeile4', 'Wert 4.1', 'Wert 4.2']
+  zeile5 = ['Zeile5']
+  mymatrix = Matrix2.new([zeile0, zeile1, zeile2, zeile3, zeile4, zeile5])	
+
+  
+  # clean4view(0) testen -- Resize to header 
+  assert_equal 16,            mymatrix.flatten.size
+  assert_equal 18,            mymatrix.clean4view(0).flatten.size
+  assert_equal 16,            mymatrix.flatten.size	
+  mymatrix.clean4view!(0)
+  assert_equal 18,            mymatrix.flatten.size		
+  assert_equal 18,            mymatrix.clean4view(0).flatten.size
+  assert_kind_of Matrix2,     mymatrix.clean4view(0)	
+  mymatrix.clean4view!
+  assert_kind_of Matrix2,     mymatrix   
+  end
+  
+  
+  
+  
+  # 
+  # Normale Matrix testen: Spalten
+  #	
+  def test_spalten
+  # Erneute Initialisierung
+  zeile0 = ['Ueberschrift', 'Spalte1', 'Spalte2']
+  zeile1 = ['Zeile1', 'Wert 1.1', 'Wert 1.2']
+  zeile2 = ['Zeile2', 'Wert 2.1']
+  zeile3 = ['Zeile3', 'Wert 3.1', 'Wert 3.2', 'Wert 3.3']
+  zeile4 = ['Zeile4', 'Wert 4.1', 'Wert 4.2']
+  zeile5 = ['Zeile5']
+  mymatrix = Matrix2.new([zeile0, zeile1, zeile2, zeile3, zeile4, zeile5])		
+  
+  #  Spalten-Funktionen testen
+  assert_equal 	mymatrix.column(2).size,            mymatrix.row_size
+  assert_nil                                        mymatrix.column(99)
+  assert_nil                                        mymatrix.column(-99)
+  assert_equal 	0,                                  mymatrix.column(99).size	
+  spalte2 = mymatrix.column(2)
+  mymatrix.set_column!(3, spalte2)
+  mymatrix.set_column!(4, spalte2)
+  assert_equal 	mymatrix.column(2),                 mymatrix.column(3)
+  assert_equal 	mymatrix.column(2),                 mymatrix.column(4)
+  assert_equal 30,                                  mymatrix.flatten.size
+  end
+
+  
+  
+  # 
+  # Matrix mit Fehlern testen
+  #	
+  def test_fehlerhalte_matrix
+  # Erneute Initialisierung
+  zeile0 = ['X', 'Spalte1', nil, 'Spalte3']
+  zeile1 = [ nil, 'Wert 1.1', 'Wert 1.2','Wert 1.3']
+  zeile2 = []
+  zeile3 = nil
+  zeile4 = ['Zeile4', 'Wert 4.1', 'Wert 4.2']	
+  zeile5 = [ nil , nil, nil, nil, nil, nil, nil, nil]
+  zeile6 = ['Zeile6', nil, 'Wert 6.2', 'Wert 6.3']	
+  zeile7 = ['Zeile7', 'Wert 7.1', 'Wert 7.2', 'Wert 7.3']	
+  zeile8 = ['Zeile8', 'Wert 8.1', nil, 'Wert 8.3']	
+  zeile9 = ['Zeile9', 'Wert 9.1', nil, 'Wert 9.3', 'Wert 9.4']	
+
+  
+  assert_not_nil 	          zeile0.row_to_nil
+  assert_nil 		            zeile1.row_to_nil
+  assert_nil 		            zeile2.row_to_nil
+  assert_nil 		            zeile3.row_to_nil
+  assert_not_nil 	          zeile4.row_to_nil
+  assert_nil 		            zeile5.row_to_nil	
+  assert_not_nil 	          zeile6.row_to_nil	
+  
+  
+  errormatrix = Matrix2.new([zeile0, zeile1, zeile2, zeile3, zeile4, zeile5, zeile6, zeile7, zeile8, zeile9])								
+  
+
+  # assert_equal 37,          errormatrix.flatten.size
+  # assert_equal 40,          errormatrix.clean4view(0).flatten.size
+  # assert_equal 24,          errormatrix.clean4view(1).flatten.size
+  # assert_equal 18,          errormatrix.clean4view(2).flatten.size
+
+  end
+
+  
+
+
+
+
+
+
+
+
+end # class 

data/test/enumerable/test_enumerable_enumerables.rb

@@ -0,0 +1,46 @@
+
+require 'kyanite/unit_test'
+require 'kyanite/smart_load_path'; smart_load_path
+require 'perception'                                if $0 == __FILE__    
+
+require 'kyanite/enumerable/enumerable_enumerables'
+
+class Array
+  include EnumerableEnumerables
+end
+
+
+# Tests für EnumerableEnumerables
+# 
+class TestKyaniteEnumerableEnumerables < UnitTest
+  
+  def test_rectangle1
+    test = []
+    test << [  :a,   :b,   :c  ]
+    test << [   1,    2,    3  ]
+    test << [ 'i', 'ii', 'iii' ]
+    assert_equal test,              test.rectangle
+    assert_equal test,              test.rectangle.rectangle
+    assert_equal test.transpose,    test.rectangle.transpose.rectangle
+  end
+  
+  
+  
+  def test_rectangle2
+    test = []
+    test << [  :a,   :b,   :c       ]
+    test << [   1,    2,    3,   4  ]
+    test << [ 'i', 'ii' ]
+    
+    expc = []
+    expc << [  :a,   :b,   :c  ]
+    expc << [   1,    2,    3  ]
+    expc << [ 'i', 'ii', nil   ]    
+    
+    
+    assert_equal expc,              test.rectangle
+    assert_equal expc,              test.rectangle.rectangle
+    assert_equal expc.transpose,    test.rectangle.transpose.rectangle
+  end    
+
+end # class