kyanite 0.3.1

data/lib/kyanite/rake.rb

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

data/lib/kyanite/range.rb

@@ -0,0 +1,54 @@
+
+require 'facets/range/combine'
+require 'facets/range/within'
+require 'kyanite/enumerable'             # is_collection? ist f�r Ranges false
+
+
+# Aus Facets eingef�gt:
+# * umbrella(r)
+# * within?
+# * combine(r)
+#
+class Range
+
+  # Invertiert den Range, mit dem ein Ausschnitt eines Strings oder eines Arrays bestimmt wird.
+  # Liefert einen Range, mit dem der inverse Teil des Strings ausgew�hlt werden kann.
+  # Beispiele siehe TestKyaniteRange.
+  #
+  def invert_index
+  
+    # hinteren Teil ausgeben
+    if first == 0
+      return (1..0)           if last == -1     # leer
+      return (last+1..-1)                       # hinterer Teil
+
+    # vorderen Teil ausgeben
+    else 
+      return (0..first-1)     if last == -1     # vorderer Teil
+      
+    end
+    
+    # �u�ere Teile ausgeben
+    return [(first..-1).invert_index, (0..last).invert_index]
+  end # def
+
+ 
+  
+end # class
+  
+  
+  
+
+
+class NilClass
+  def invert_index;                         nil;              end     
+  def umbrella(*a);                   nil;              end     
+  def combine(*a);                    nil;              end     
+  def within?(*a);                    nil;              end     
+end
+
+    
+  
+    
+    
+    

data/lib/kyanite/set.rb

@@ -0,0 +1,219 @@
+
+require 'set'
+require 'kyanite/enumerable'             # is_collection?
+require 'kyanite/general/kernel'         # silence_warnings
+require 'kyanite/dictionary'             # Geordneter Hash
+require 'kyanite/symbol'                 # damit man auch Symbols aufnehmen kann
+require 'kyanite/hash'                   # Korrektur der Methoden hash und eql?
+
+
+# Set OrderedSet SortedSet Array
+#
+# = Unterschiede der verschiedenen Set-Klassen
+# * Ein {Set}[http://www.ruby-doc.org/core/classes/Set.html] ist ungeordnet.                 
+#   Beispiele:  TestKyaniteSet#test_set
+# * Ein OrderedSet ist geordnet, es behält die ursprüngliche Reihenfolge, wird aber nicht kontinuierlich neu sortiert.
+#   Es sei denn, man sorgt dafür mit Dictionary#order_by      
+#   Beispiele:  TestKyaniteSet#test_ordered_set
+# * Ein {SortedSet}[http://www.ruby-doc.org/core/classes/SortedSet.html] ist geordnet und sortiert. Es behält immer die Sortierung.       
+#   Beispiele:  TestKyaniteSet#test_sorted_set
+#
+class Set
+
+  # Fügt das Element an das Set an.
+  def push(elt)
+    self << elt
+  end
+  
+  
+  # Vergleichsoperator, Standardsortierung: Size
+  def <=>(other)
+    self.size <=> other.size
+  end
+  
+  # def hash_raw
+    # @hash
+  # end
+  
+  # Liefert irgendein Element.  
+  def first
+    @hash.each do |key, value|
+      return key
+    end  
+  end #def
+  
+  
+  # Liefert irgendein anderes Element.  
+  def last
+    first = nil
+    @hash.each do |key, value|
+      if first.nil?
+        first = key
+        next
+      else
+        return key
+      end #if
+    end #do 
+  end #def 
+  
+end
+
+
+# Set OrderedSet SortedSet Array
+#
+# Ein OrderedSet ist geordnet, es behält die ursprüngliche Reihenfolge, wird aber nicht kontinuierlich neu sortiert.
+# Es sei denn, man sorgt dafür mit Dictionary#order_by  
+#
+class OrderedSet < Set
+
+  def initialize(enum = nil, &block) # :yields: o
+    @hash ||= Dictionary.new
+    enum.nil? and return
+    if block
+      enum.each { |o| add(block[o]) }
+    else
+      merge(enum)
+    end
+  end
+  
+  
+  # Liefert das n-te Element.
+  def [](index)
+    @hash.order[index]
+  end
+  
+  
+  def zugrundeliegendes_dictionary # :nodoc:
+    @hash
+  end
+  
+  # Liefert ein entsprechendes Array.
+  # Diese Methode ist schnell. Es muss nichts umgeformt werden. Andere Methoden können also gerne auf to_a basieren. 
+  def to_a 
+    @hash.order
+  end  
+  
+
+  def ==(other)
+    silence_warnings do   
+      self.to_a.to_set == other.to_a.to_set
+    end
+  end  
+
+  # Wie Array#index
+  def index(object)
+    self.to_a.index(object)
+  end
+  
+  def each
+    to_a.each { |e| yield( e ) }
+    self
+  end
+  
+  def order_by( &block )
+    @hash.order_by( &block )
+  end
+  
+  def first
+    self[0]
+  end
+  
+  def last
+    self[-1]
+  end    
+  
+  
+  
+end # class
+  
+  
+# Set OrderedSet SortedSet Array
+#
+# Ein {SortedSet}[http://www.ruby-doc.org/core/classes/SortedSet.html] ist geordnet und sortiert. Es behält immer die Sortierung.       
+# Beispiele:  TestKyaniteSet#test_sorted_set
+#
+class SortedSet 
+
+  # Liefert das n-te Element.
+  # ineffizient!!
+  def [](index)
+    self.to_a[index]
+  end
+  
+  def first
+    self[0]
+  end
+  
+  def last
+    self[-1]
+  end  
+  
+  # das war mal auskommentiert, wird aber von nat_lang gebraucht
+  def unshift(e) # :nodoc:
+    self << e
+  end
+  
+  def to_sorted_set
+    self
+  end    
+  
+end # class 
+
+
+
+
+  
+class Array
+
+  # Liefert ein OrderedSet, das dem Array entspricht. 
+  # Übersicht über die verschiedenen Set-Klassen siehe Set.
+  # Tests siehe TestKyaniteSet#test_ordered_set    
+  def to_ordered_set
+    OrderedSet.new(self)
+  end
+  
+  # Liefert ein SortedSet, das dem Array entspricht. 
+  # Übersicht über die verschiedenen Set-Klassen siehe Set.  
+  # Tests siehe TestKyaniteSet#test_sorted_set
+  def to_sorted_set
+    SortedSet.new(self)
+  end      
+  
+  
+end # class
+  
+  
+
+
+class NilClass
+  def to_set;                         Set.new;              end     
+  def to_sorted_set;                  SortedSet.new;        end     
+  def to_ordered_set;                 OrderedSet.new;       end     
+end
+
+
+class Object
+  def to_set; Set.new([self]); end
+end
+
+    
+# ==================================================================================
+# Ausprobieren
+#
+if $0 == __FILE__ 
+
+  require 'perception'
+  test = [:a, :b, :c].to_ordered_set
+  see :test # .inspect_see
+  see_pp test
+  seee.process_print( test, :method => :pp )
+  see :test# .inspect_see
+
+end
+
+
+    
+  
+    
+    
+    

data/lib/kyanite/smart_load_path.rb

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

data/lib/kyanite/string.rb

@@ -0,0 +1,13 @@
+
+require 'kyanite/enumerable'            
+
+require 'kyanite/string/cast'
+require 'kyanite/string/chars'
+require 'kyanite/string/diff'
+require 'kyanite/string/div'
+require 'kyanite/string/include'
+require 'kyanite/string/list'
+require 'kyanite/string/mgsub'
+require 'kyanite/string/nested'
+require 'kyanite/string/random'
+require 'kyanite/string/split'

data/lib/kyanite/string/cast.rb

@@ -0,0 +1,104 @@
+
+require 'kyanite/numeric/integer'
+ 
+
+class String
+
+  # ---------------------------------------------------------------------------------------------------------------------------------
+  # :section: Umwandeln
+  # Siehe auch KlippsteinMail::String#to_email_address und  KlippsteinMail::String#to_domain           
+
+    
+    
+    # Wandelt einen String in den plausibelsten Identifier um:
+    #   self.strip.to_integer_optional
+    #
+    # Tests & Beispiele siehe TestString#test_to_identifier
+    def to_identifier
+      self.strip.to_integer_optional
+    end        
+        
+        
+    # Wandelt einen String in einen Integer, auch dann, wenn die Zahl hinten angehängt wurde.
+    # Im Gegensatz zu to_i wird nil zurückgegeben, wenn keine Zahl drin war. 
+    # 
+    # Beispiele & Tests siehe TestString#test_to_integer      
+    def to_integer
+        return nil                 unless self =~ /\d/
+        firsttry = self.to_i
+        return firsttry         if firsttry != 0
+        return self.scan(/\d+/)[0].to_i 
+    end
+
+
+    # Wandelt einen String in einen Integer.
+    # Im Gegensatz zu to_i wird self zurückgegeben, wenn der String nicht mit einer Zahl beginnt.
+    # Leere Strings werden in NIL umgewandelt. 
+    # 
+    # Beispiele & Tests siehe TestString#test_to_integer_optional    
+    def to_integer_optional
+        return nil                  if self.empty?
+        return self                 unless (self =~ /^\d/  || self =~ /^-\d/ )
+        return self.to_i
+    end
+    
+
+    def to_nil
+      return self unless self.empty?
+      nil
+    end    
+        
+        
+
+ 
+    unless defined? HEX_CHARS
+      HEX_CHARS = '0123456789abcdef'.freeze
+    end
+
+    def to_x
+      hex = ''
+      each_byte { |byte|
+        # To get a hex representation for a char we just utilize
+        # the quotient and the remainder of division by base 16.
+        q, r = byte.divmod(16)
+        hex << HEX_CHARS[q] << HEX_CHARS[r]
+      }
+      hex
+    end
+    
+    
+    def from_x
+      str, q, first = '', 0, false
+      each_byte { |byte|
+        # Our hex chars are 2 bytes wide, so we have to keep track
+        # of whether it's the first or the second of the two.
+        #
+        # NOTE: inject with each_slice(2) would be a natural fit,
+        # but it's kind of slow...
+        if first = !first
+          q = HEX_CHARS.index(byte)
+        else
+          # Now we got both parts, so let's do the
+          # inverse of divmod(16): q * 16 + r
+          str << q * 16 + HEX_CHARS.index(byte)
+        end
+      }
+      str
+    end
+    
+
+end
+
+
+class NilClass
+  def to_identifier;                  nil;            end
+  def to_integer;                     nil;            end
+  def to_integer_optional;            nil;            end
+  def to_nil(*a);                     nil;            end  
+  def to_x;                           nil;            end  
+  def from_x;                         nil;            end  
+end
+
+
+
+

data/lib/kyanite/string/chars.rb

@@ -0,0 +1,184 @@
+
+# Multibyte-Unterstützung von ActiveSupport
+$KCODE = 'UTF8' 
+require 'active_support'
+
+# reicht aber noch nicht, damit funktioniert tr noch nicht. 
+# Hier hilft jcode. 
+require 'jcode'
+
+require 'kyanite/string/mgsub'
+require 'kyanite/string/chars_const'
+
+  
+unless defined? MYSQL_REPLACES
+  MYSQL_REPLACES =  [                 
+                                      [/ä/,    'a'], 
+                                      [/ö/,    'o'],  
+                                      [/ü/,    'u'],        
+                                      [/Ä/,    'a'], 
+                                      [/Ö/,    'o'],  
+                                      [/Ü/,    'u'],      
+                                      [/ss/,   'ß'],      
+                                      [/SS/,   'ß']     
+                    ]  
+end    
+    
+    
+   
+   
+
+
+class String
+
+    # ---------------------------------------------------------------------------------------------------------------------------------
+    # :section: clear / format text
+    #     
+
+    # Reduziert den String auf ein Base94-Encoding.
+    # * Wandelt àáâăäãāåạąæảấầắằÀÁÂĂÄÃĀÅẠĄÆẢẤẦẮẰ usw. in aaaaaaaaaaaaaaaaAAAAAAAAAAAAAAAA usw. um 
+    # * entfernt anschließend alle Nicht-Asciizeichen
+    # * entfernt außerdem alle nichtdruckbaren Asciizeichen
+    # * Vorsicht: Newlines werden auch entfernt
+    # 
+    #
+    # Tests & Beispiele siehe TestKyaniteStringClear     
+    def reduce94( options={} )
+      dup.reduce94!
+    end        
+    
+    def reduce94!( options={} )   
+      self.tr!(TR_FULL, TR_REDUCED)
+      self.delete!('^ -~')
+      self
+    end    
+    
+    # Reduziert den String auf ein Base53-Encoding, 
+    # bestehend aus Großbuchstaben, Minuszeichen und zu Kleinbuchstaben umgeformten Sonderzeichen.
+    # Alle reduzierten Zeichen sind aber *klein*, streng genommen handelt es sich also um ein Base52-Encoding.
+    # Wandelt z.B. àáâăäãāåạąæảấầắằÀÁÂĂÄÃĀÅẠĄÆẢẤẦẮẰ usw. in aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa usw. um. 
+    # 
+    #
+    # Tests & Beispiele siehe TestKyaniteStringClear        
+    def reduce53( options={} )
+      dup.reduce53!(options)
+    end        
+    
+    
+    def reduce53!( options={} )
+      if options[:camelcase]  
+        self.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1-\2')
+        self.gsub!(/([a-z\d])([A-Z])/,'\1-\2')
+      end
+      self.tr!('abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') 
+      self.gsub!( 'ß', options[:german_sz] )        if options[:german_sz]      
+      self.tr!(TR_FULL, TR_REDUCED.downcase)  
+      unless options[:space]
+        self.delete!('^- A-Za-z')
+      else
+        self.tr!('^- A-Za-z', ' ')      
+      end
+      self.gsub!(/-+/,  ' ')          
+      self.gsub!(/\s+/, ' ')      
+      self.strip!   
+      self.gsub!(/ /,   '-')           
+      self
+    end        
+    
+    
+
+    
+    # Formt einen String so um, dass man auch mit utf8_general_ci verglichene Strings wiedererkennen kann
+    #
+    # Tests & Beispiele siehe TestKyaniteStringClear     
+    def mysqlize
+      self.mb_chars.tidy_bytes.mgsub(MYSQL_REPLACES).downcase.to_s
+    end           
+    
+
+    
+    # macht die nötigen Korrekturen für EmailAddress und Domain.
+    #
+    # Tests & Beispiele siehe TestKyaniteStringClear 
+    # def strip_downcase_iconv
+                #to          #from 
+      # Iconv.new('iso-8859-1','utf-8').iconv(self.strip.downcase2)
+    # rescue
+      # self.strip.downcase2
+    # end    
+    
+    
+    
+    # ---------------------------------------------------------------------------------------------------------------------------------
+    # :section: Groß- und Kleinschreibung
+    #   
+    
+    # Ein Überschreiben von downcase führt in Kombination mit ActiveSupport zu seltsamen Ergebnissen!
+    def downcase2 
+      self.tr(TR_UPCASE, TR_DOWNCASE).downcase
+    end    
+    
+    def downcase2! 
+      self.tr!(TR_UPCASE, TR_DOWNCASE).downcase!
+    end        
+    
+    
+    # Ein Überschreiben von upcase führt in Kombination mit ActiveSupport zu seltsamen Ergebnissen!       
+    def upcase2
+      self.tr(TR_DOWNCASE, TR_UPCASE).upcase
+    end      
+    
+    def upcase2!
+      self.tr!(TR_DOWNCASE, TR_UPCASE).upcase!
+    end      
+    
+    
+    # Erster Buchstabe groß?
+    def capitalized?
+      self =~ TR_UPCASE_ALL_REGEXP
+    end   
+
+    def upcase?
+      (self == self.upcase)
+    end
+    
+    def downcase?
+      (self == self.upcase)
+    end    
+
+end
+
+
+
+
+
+class NilClass
+  def reduce94;                     nil;            end
+  def reduce94!;                    nil;            end
+  def reduce53;                     nil;            end
+  def reduce53!;                    nil;            end  
+  def capitalized?;                 false;          end  
+  def downcase2;                    nil;            end    
+  def downcase2!;                   nil;            end    
+  def mysqlize;                     nil;            end  
+# def strip_downcase_iconv;         nil;            end  
+  def upcase2;                      nil;            end  
+  def upcase2!;                     nil;            end  
+end
+
+
+# -----------------------------------------------------------------------------------------
+# Ausprobieren
+#
+if $0 == __FILE__ then
+
+  require 'perception'
+  
+  see 'Höllo'.reduce53
+
+
+
+end
+
+
+