kyanite 0.3.1

data/lib/kyanite/general/nil.rb

@@ -0,0 +1,64 @@
+
+
+# -----------------------------------------------------------------------------------------
+# Nil  -- hier nur Ruby Core-Methoden!
+#
+
+class NilClass
+  
+    # Spezielle Rückgaben
+
+    def <<(element);                    [element];      end     
+    def empty?;                         true;           end      
+    def length;                         0;              end
+    def size;                           0;              end
+    def count(*a);                      0;              end
+    def split(*a);                      [];             end
+    def =~(other);                      false;          end
+    def include?(*a);                   false;          end    # redundante Definition
+    
+    # Rückgabe nil
+    def -(other);                       nil;            end    
+    def +(other);                       nil;            end    
+    def <(*a);                          nil;            end   
+    def <=>(*a);                        nil;            end
+    def >(*a);                          nil;            end    
+    def abs;                            nil;            end    
+    def chop;                           nil;            end    
+    def clear;                          nil;            end
+    def code;                           nil;            end       
+    def collect(&block);                nil;            end    
+    def compact;                        nil;            end
+    def downcase;                       nil;            end  
+    def dup;                            nil;            end
+    def each(*a);                       nil;            end    
+  # def first;                          nil;            end
+    def grep(*a);                       nil;            end   
+    def gsub!(*a);                      nil;            end   
+    def gsub(*a);                       nil;            end   
+    def join;                           nil;            end  
+  # def last;                           nil;            end    
+    def pop(*a);                        nil;            end 
+    def push(*a);                       nil;            end    
+    def split(*a);                      nil;            end   
+    def strip!(*a);                     nil;            end   
+    def strip(*a);                      nil;            end   
+    def sub(*a);                        nil;            end      
+    def to_i;                           nil;            end  
+    def to_integer;                     nil;            end  
+    def to_sym;                         nil;            end  
+    def uniq!;                          nil;            end   
+    def uniq;                           nil;            end   
+    def [](*a);                         nil;            end
+    def []=(*a);                        nil;            end   
+
+end
+
+
+
+
+
+
+
+
+

data/lib/kyanite/general/object.rb

@@ -0,0 +1,86 @@
+
+# Multibyte-Unterstützung von ActiveSupport
+$KCODE = 'UTF8' 
+require 'active_support'
+
+class Object
+ 
+    # <tt> false </tt>    
+    #
+    # Test siehe TestTrueFalse#test_blank. 
+    def blank? 
+        false
+    end     
+
+    # Quelle: Facets http://facets.rubyforge.org/quick/rdoc/core/classes/Kernel.html#M000379
+    def respond(sym, *args)
+      return nil if not respond_to?(sym)
+      send(sym, *args)
+    end    
+    
+    
+    def deep_copy
+      Marshal.load( Marshal.dump( self ) )
+    end
+
+    
+    # Ist ein Objekt numerisch?
+    #
+    # Tests & Beispiele siehe TestObject#test_is_numeric
+    def is_numeric?
+      Float self 
+    rescue Exception => e
+      false 
+    end        
+    
+    
+    # <tt> false </tt>    
+    def empty? 
+        false
+    end  
+
+    
+
+    
+    
+    # Liefert nil, wenn die Condition erfüllt ist. Sonst self.
+    #
+    def to_nil(condition = :empty) 
+        return nil         if self.respond(condition.to_s + '?')
+        return self
+    end    
+    
+    
+    # Liefert nil, wenn die Condition nicht erfüllt ist. Sonst self.
+    #
+    def to_nil_unless(condition = :empty) 
+        return nil         unless self.respond(condition.to_s + '?')
+        return self
+    end    
+
+
+    # Findet den Namen einer Ruby-Konstanten anhand seines Wertes.
+    # Funktioniert so nicht. Seltsamersweise funktioniert es aber, wenn man den Quelltext dieser Methode direkt ausführt.
+    # Verwendet in der Info-Ansicht des Scaffoldings.
+    #
+    def name_of_constant(wert_der_konstanten)
+      Object.constants.find { |c| Object.const_get(c) == wert_der_konstanten}
+    end    
+end
+
+
+
+
+class NilClass
+ 
+  def blank?;                         false;          end     
+  def is_numeric?;                    false;          end
+  def to_nil;                         nil;            end   
+  def to_nil_unless(*a);              nil;            end   
+  def name_of_constant(*a);           nil;            end   
+end
+
+
+
+
+

data/lib/kyanite/general/true_false.rb

@@ -0,0 +1,65 @@
+
+
+class TrueClass  
+     
+  # <tt> 1 </tt>    
+  def to_i; 1; end
+  
+  # <tt> self </tt>   
+  def strip; self; end
+  
+  # <tt> self </tt>   
+  def dup; self; end      
+  
+  def <=>(other)
+    return 1 if ! other
+    return 0
+  end  
+  
+  def blank?; false; end
+  
+  
+end # class 
+
+
+
+
+
+class FalseClass
+      
+  # <tt> 0 </tt>    
+  def to_i; 0; end
+  
+  # <tt> self </tt>   
+  def strip; self; end  
+  
+  # <tt> self </tt>   
+  def dup; self; end    
+  
+  # TestTrueFalse#test_raumschiff_operator
+  def <=>(other)
+    return -1 if other
+    return 0
+  end    
+ 
+  
+  # umdefiniert!
+  #
+  # TestTrueFalse#test_blank  
+  def blank?; self; end
+  
+
+  
+end 
+
+
+
+
+
+	
+	
+	
+	
+	
+	
+	

data/lib/kyanite/general/undoable.rb

@@ -0,0 +1,24 @@
+
+module Undoable
+
+  @@undoable_history = Hash.new
+
+  def save(method=:dup)
+    return if self == @@undoable_history[self.object_id] # nichts zu tun
+    @@undoable_history[self.object_id] = self.send(method)
+  end
+
+  def load_and_keep
+    @@undoable_history[self.object_id]
+  end
+  
+  def load_and_delete
+    @@undoable_history.delete(self.object_id)
+  end  
+  
+  def self.clear
+    @@undoable_history.clear
+  end
+
+
+end

data/lib/kyanite/hash.rb

@@ -0,0 +1,170 @@
+
+require 'facets/hash/merge'                   # Methoden reverse_merge, reverse_merge!
+require 'active_support/core_ext/hash/slice'  # Slice a hash to include only the given keys. 
+require 'kyanite/enumerable'                  # is_collection?
+
+class Hash
+  include ActiveSupport::CoreExtensions::Hash::Slice
+end
+
+#
+# Aus {Facets/Hash}[http://facets.rubyforge.org/api/core/classes/Hash.html] eingefügt:
+# * *reverse_merge*      <tt>(other_hash) </tt>        Beispiel: <tt>options.reverse_merge!(:key => default_value)</tt>
+#  
+#
+# ==Generelle Anmerkungen zu Hashes
+# * Definiert man in irgendeinem Objekt die Methode <tt>==(other)</tt>, so muss man auch die Methode +hash+ neu definieren! 
+# * Rubys +delete+ und +delete_if+ verändern den Hash! Siehe TestHash#test_delete
+#
+#
+class Hash
+
+
+  if RUBY_VERSION < "1.9"
+    # Credit: Paul Murur http://mucur.name/posts/when-is-a-set-not-a-set
+    # Create a hash based on the keys and values.
+    def hash
+      keys.hash + values.hash + (default ? default.hash : 0)
+    end
+
+    # Credit: Paul Murur http://mucur.name/posts/when-is-a-set-not-a-set
+    # To determine whether two hashes are the same, compare
+    # their hashes.
+    def eql?(other)
+      hash == other.hash
+    end
+  end # Ruby Version
+
+
+ 
+  # Entfernt alle Key-Value-Paare mit <b>nil-Keys</b> in-place.
+  #
+  # Tests: TestHash#test_delete
+  def compact_keys!
+      delete_if {|key, value| key.nil? }
+  end
+  
+  
+  # Entfernt alle alle Key-Value-Paare mit <b>nil-Values</b> in-place.
+  #
+  # Tests: TestHash#test_compact
+  def compact_values!
+      delete_if {|key, value| value.nil? }
+  end    
+
+  
+  # Entfernt das Key-Value-Paar mit einem bestimmten Key in-place. 
+  # Rückgabe ist der modifizierte Hash (im Gegensatz zur +delete+-Methode, die das entfernte Key-Value-Paar zurückgibt! ).
+  def delete_key(key)
+    delete_if { |k,v| k == key }
+  end        
+  
+  # Entfernt alle Key-Value-Paare mit einem bestimmten Value in-place.
+  #     
+  def delete_value(value)
+    delete_if { |k,v| v == value }
+  end
+    
+    
+  # erzwingt ein Array der Länge 1, wenn sowohl Einzelwerte als auch Arrays erlaubt sind. 
+  # Beispiel:<tt>    inputoptions = options.arrayize(:skip, :debug)  </tt>
+  # 
+  def arrayize(*keys)
+    keys.each do |k|
+      if self[k]  &&  !self[k].respond_to?(:first) 
+        self[k] =  [self[k]]
+      end
+    end
+        
+    self
+  end
+  
+  
+  # Greift auf den Hash mit nicht-ganz-passenden Schlüsseln zu
+  def fuzzyget(key, level = 3)
+    try = self[key]
+    return try    if try  ||  level <= 0
+    try = self[key.to_s.downcase2]
+    return try    if try  ||  level <= 1   
+    try = self[key.to_s.mysqlize]
+    return try    if try  ||  level <= 2       
+  end    
+
+  
+  # Liefert die Verteilung der Size / Class / etc. aller Values. 
+  # Die Keys werden ignoriert.
+  #
+  def distribution( mode = :size)
+    verteilung = Hash.new
+    each do | key, element |
+      value = element.respond(mode)
+      if verteilung.has_key?(value)
+        verteilung[value] += 1
+      else
+        verteilung[value] = 1
+      end # if      
+    end #each
+    verteilung.to_a.sort   
+  end  
+  
+  
+  # liefert irgendein Value  
+  def first
+    self.each do |key, value|
+      return value
+    end  
+  end #def
+  
+  
+  # liefert irgendein anderes Value  
+  def last
+    first = nil
+    self.each do |key, value|
+      if first.nil?
+        first = value
+        next
+      else
+        return value
+      end #if
+    end #do 
+  end #def 
+ 
+
+   
+    
+
+ end #class   
+ 
+
+class NilClass
+  def compact_keys!;          nil;            end   
+  def compact_values!;        nil;            end   
+  def delete_key(*a);         nil;            end   
+  def delete_value(*a);       nil;            end   
+  def arrayize(*a);           nil;            end   
+  def fuzzyget(*a);           nil;            end   
+end
+
+    
+    
+    
+    # ---------------------------------------------------------
+# Ausprobieren
+#
+if $0 == __FILE__ 
+
+  require 'perception'
+  test = {:b => 2, :a => 1,  :c => 3}
+  see test.first
+  see test.last
+  
+  
+
+
+end
+    
+    
+    
+    
+    
+    

data/lib/kyanite/matrix2.rb

@@ -0,0 +1,2 @@
+
+require 'kyanite/array/matrix2' 

data/lib/kyanite/nil.rb

@@ -0,0 +1,3 @@
+
+require 'kyanite/general/nil'
+ 

data/lib/kyanite/numeric.rb

@@ -0,0 +1,4 @@
+
+require 'kyanite/numeric/float'
+require 'kyanite/numeric/integer'
+require 'kyanite/numeric/numeric'

data/lib/kyanite/numeric/float.rb

@@ -0,0 +1,26 @@
+
+Infinity = 1.0/0        unless defined? Infinity
+Googol   = 10**100      unless defined? Googol
+
+
+class Float
+
+  # 1.9 == 1.8 + 0.1               => false
+  # 1.9.approx(1.8 + 0.1)          => true
+  # 98.6.approx(98.66)             => false
+  # 98.6.approx(98.66, 0.001)      => true
+  # Copyright 2006 O'Reilly Media, Ruby Cookbook, by Lucas Carlson and Leonard Richardson
+  #
+  def approx(other, relative_epsilon=Float::EPSILON, epsilon=Float::EPSILON)
+    difference = other - self
+    return true if difference.abs <= epsilon
+    relative_error = (difference / (self > other ? self : other)).abs
+    return relative_error <= relative_epsilon
+  end
+  # http://oreilly.com/catalog/9780596523695/
+  # Ruby Cookbook, by Lucas Carlson and Leonard Richardson
+  # Copyright 2006 O'Reilly Media  
+
+
+  
+end