kyanite 0.3.1

data/lib/kyanite/string/nested.rb

@@ -0,0 +1,253 @@
+
+class String
+  
+  
+  # Gibt die passende gegenteilige Klammer zurück
+  # '('.anti          ->  ')'
+  # '{'.anti          ->  '}'
+  # ']'.anti          ->  '['
+  # '<hallo>'.anti    ->  '</hallo>'
+  # '</hallo>'.anti   ->  '<hallo>'
+  def anti
+    if self.size == 1
+      return self.tr('([{<)]}>',')]}>([{<')
+    else
+      if self =~ /<([^\/].*)>/
+        return "</#{$1}>"
+      elsif self =~ /<\/(.*)>/
+        return "<#{$1}>"        
+      end
+    end
+    return self
+  end    
+  
+  
+  
+  # Findet das nächste zueinander passende Klammerpaar ab Position start.
+  # Liefert die Positionen der Klammern als Range.
+  # Bsp.: 'Hallo(welt)wort'.index_bracket  ->  5..10
+  def index_bracket( pattern=nil, start=0, last_found = nil )
+    return nil if self.empty?
+    pattern = /[{<\[]/ unless pattern    
+    # pattern = /['"({<(\[]/  unless pattern 
+    debug = false
+    puts 'untersuche ' + self[start..-1]     if debug
+    found = self.index(pattern, start) 
+    puts "found=#{found}"                    if debug
+    return last_found unless found
+    pattern_anti = self[found..found].anti
+    startpunkt = found
+    loop do
+      found_next =  self.index( pattern,      startpunkt+1 ) || 9999999
+      found_anti =  self.index( pattern_anti, startpunkt+1 ) 
+      puts "found_next=#{found_next}"        if debug
+      puts "found_anti=#{found_anti}"        if debug
+      break unless found_anti
+      return found..found_anti   if found_anti <= found_next
+      # puts
+      # puts
+      # puts
+      # puts
+      # puts
+      # puts "start=#{(start).inspect_pp}"
+      # puts "pattern=#{(pattern).inspect_pp}"
+      # puts "found_next=#{(found_next).inspect_pp}"
+      # puts "found..found_anti=#{(found..found_anti).inspect_pp}"
+      rekursiv_result = self.index_bracket(pattern, found_next, found..found_anti)
+      return found..found_anti unless rekursiv_result
+      startpunkt = rekursiv_result.last
+      puts "startpunkt=#{startpunkt}"        if debug
+    end # loop
+    nil
+  end
+  
+  
+  # Wendet den Block auf eine hierarchisch definierte Auswahl des Strings an.
+  # Beispiele siehe Tests.
+  def mask( options={}, &block )
+  
+    # vorbereiten
+    debug = false
+    result = self.dup
+    
+    level_start =   options[:level_start]   || 1
+    level_end =     options[:level_end]     || 99999
+    level_akt =     options[:level_akt]     || 0
+    #level_akt += 1 if with_brackets    
+    pattern =       options[:pattern]       || /[{<\[]/ # /['"({<\[]/ ist langsam
+    skip_empty =    options[:skip_empty]    || false
+    param_level =   options[:param_level]   || false    # übergibt dem Block zusätzlich die Nummer des aktuellen Levels
+    with_brackets = options[:with_brackets] || false  # übergibt dem Block auch die Brackets, Beispiel siehe Tests!!
+    
+    raise ArgumentError, "level_start can't be nil"             unless level_start 
+    raise ArgumentError, "level_end can't be nil"               unless level_end 
+    raise ArgumentError, 'level_end has to be >= level_start'   unless level_end >= level_start
+    if debug 
+      puts "level_start=#{level_start}"   
+      puts "level_end=#{level_end}"   
+      puts "level_akt=#{level_akt}"    
+      puts
+    end          
+    geklammert = result.index_bracket(pattern)
+    puts "geklammert=#{geklammert}"  if debug
+    
+    
+    # Los geht's: geklammert, Klammern werden nicht mit übergeben 
+    if geklammert 
+      if !with_brackets
+        if geklammert.first > 0
+          pre =   result[0..geklammert.first-1]
+        else
+          pre =   ''
+        end
+        bra =     result[geklammert.first..geklammert.first]
+        mid =     result[geklammert.first+1..geklammert.last-1]
+        ket =     result[geklammert.last..geklammert.last]
+        if geklammert.last < (result.size-1)
+          past =  result[geklammert.last+1..-1]
+        else
+          past =  ''
+        end  
+      else # with_brackets
+        if geklammert.first > 0
+          pre =   result[0..geklammert.first]
+        else
+          pre =   result[geklammert.first..geklammert.first]
+        end
+        bra =     ''
+        mid =     result[geklammert.first+1..geklammert.last-1]
+        ket =     ''
+        if geklammert.last < (result.size-1)
+          past =  result[geklammert.last..-1]
+        else
+          past =  result[geklammert.last..geklammert.last]
+        end        
+      end
+      if debug 
+        puts "1pre=#{pre}"   
+        puts "1bra=#{bra}"   
+        puts "1mid=#{mid}"   
+        puts "1ket=#{ket}"   
+        puts "1past=#{past}"   
+        puts
+      end     
+      
+      # yield
+      if ( (level_start..level_end)  === level_akt  &&  (!pre.empty? || !skip_empty) )     
+        if param_level
+          pre =  yield(pre,level_akt)   
+        else
+          pre =  yield(pre) 
+        end
+      end # if yield
+      mid =  mid.mask(  options.merge({:level_akt => level_akt+1}), &block )
+      past = past.mask( options, &block )
+      if debug 
+        puts "2pre=#{pre}"   
+        puts "2bra=#{bra}"   
+        puts "2mid=#{mid}"   
+        puts "2ket=#{ket}"   
+        puts "2past=#{past}"   
+        puts
+      end
+      
+      return (pre||'') + bra + (mid||'') + ket + (past||'')
+
+      
+    
+    # Los geht's: keine Klammern
+    else
+      # yield
+      
+      if ( (level_start..level_end)  === level_akt  &&  (!result.empty? || !skip_empty ) ) 
+
+        puts "result=#{result}\n" if debug
+        if param_level
+          result =  yield(result,level_akt)   
+        else
+          result=  yield(result) 
+        end      
+      end # if yield
+    return (result||'')       
+    end      
+
+    raise 'no go'
+      
+  end # def
+
+
+  # Liefert die Verschachtelungstiefe
+  def nestinglevel(pattern=/[{<(\[]/)
+    result = 0
+    self.mask( :level_start => 0,
+               :pattern => pattern,
+               :param_level => true ) { |s,l| 
+               if l > result
+                result = l
+                s
+               else
+               s
+               end
+               }
+    result
+  end
+
+  
+  
+
+
+  
+
+end # class
+
+
+class NilClass
+  def anti;                       nil;            end
+  def index_bracket;              nil;            end
+  def mask(*a);                   nil;            end
+  def nestinglevel;               0;              end    
+end
+
+
+
+# ------------------------------------------------------------------------------
+#  Tests
+#    
+
+
+if $0 == __FILE__ 
+
+  require File.join(File.dirname(__FILE__), '..', '..', '..', 'test', 'string', 'test_nested' )   
+
+end # if
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/kyanite/string/random.rb

@@ -0,0 +1,69 @@
+
+unless defined? STRING_RANDOM_BASIS
+  string_random_basis = Hash.new
+  password = [('0'..'9'),('A'..'Z'),('a'..'z')].map {|range| range.to_a}.flatten   
+  string_random_basis[:password] = password
+  
+  de_hauf = [ [ 'ß', 3 ],
+              [ 'ä', 5 ],
+              [ 'ö', 3 ],
+              [ 'ü', 8 ],    
+              [ 'a', 51 ],
+              [ 'b', 19 ],
+              [ 'c', 30 ],
+              [ 'd', 51 ],
+              [ 'e', 174 ],
+              [ 'f', 17 ],
+              [ 'g', 30 ],
+              [ 'h', 48 ],
+              [ 'i', 76 ],
+              [ 'j', 3 ],
+              [ 'k', 12 ],
+              [ 'l', 34 ],
+              [ 'm', 25 ],
+              [ 'n', 98 ],
+              [ 'o', 23 ],
+              [ 'p', 8 ],
+              [ 'q', 1 ],    
+              [ 'r', 70 ],
+              [ 's', 72 ],
+              [ 't', 61 ],
+              [ 'u', 40 ],
+              [ 'v', 7 ],
+              [ 'w', 19 ],
+              [ 'x', 1 ],
+              [ 'y', 1 ],
+              [ 'z', 11 ]]
+  de_array = []
+  de_hauf.each do | buchstabe, haufigkeit |
+    de_array +=  [buchstabe]*haufigkeit
+  end      
+  string_random_basis[:de] = de_array
+  STRING_RANDOM_BASIS = string_random_basis
+end
+
+class String
+
+    # Zufällige Reihenfolge
+    def shuffle(separator=//)
+      split(separator).shuffle.join('')
+    end
+
+    # In-place-Variante von shuffle
+    def shuffle!(separator=//)
+      self.replace( shuffle(separator) )
+    end
+
+    
+    def String.random( type=:de, size=16)
+      (0...size).map { STRING_RANDOM_BASIS[type][Kernel.rand(STRING_RANDOM_BASIS[type].size)] }.join    
+    end    
+
+end
+
+
+class NilClass
+  def shuffle;                      nil;            end
+  def shuffle!;                     nil;            end    
+end
+

data/lib/kyanite/string/split.rb

@@ -0,0 +1,136 @@
+ 
+
+ require 'facets/string/shatter' 
+ require 'kyanite/string/cast' 
+ require 'kyanite/enumerable' 
+ require 'kyanite/array/array'
+ 
+ 
+# ---------------------------------------------------------------------------------------------------------------------------------
+# :section: Aufsplitten
+#
+# Aus {Facets/String}[http://facets.rubyforge.org/rdoc/Core/classes/String.html] eingefügt:
+# * <tt>shatter(re)</tt> :: Breaks a string up into an array based on a regular expression. Similar to +scan+, but includes the matches.       
+#
+class String
+
+    
+    # Returns _n_ characters of the string. If _n_ is positive
+    # the characters are from the beginning of the string.
+    # If _n_ is negative from the end of the string.
+    #
+    # Alternatively a replacement string can be given, which will
+    # replace the _n_ characters. 
+    # Example:
+    #   'abcde'.nchar(2)  =>      'ab'
+    #   'abcde'.nchar(2,'')  =>   'cde'
+    #
+    # NICHT die Version aus Facets verwenden!!!
+    # Tests siehe TestKyaniteStringSplit#test_nchar   
+    def nchar(n, replacement=nil)
+      if replacement
+        return self   if n == 0     
+        return ''     if (n.abs >= self.length)      
+        s = self.dup
+        n > 0 ? (s[0...n] = replacement) : (s[n..-1] = replacement)
+        return s
+        
+      # ohne replacement  
+      else
+        return ''   if n == 0
+        return self if (n.abs > self.length)
+        n > 0 ? self[0...n] : self[n..-1]
+      end
+    end
+    
+    
+    # Schneidet eine String auf eine Maximallänge. Bsp.:
+    #   'Hallo'.cut(3) => 'Hal'
+    # 
+    # Tests siehe TestKyaniteStringSplit#test_cut    
+    def cut(len=5)
+        return '' if len <= 0
+        self[0..len-1]
+    end        
+    
+    
+    # Erzwingt eine bestimmte Länge
+    # 
+    # Tests siehe TestKyaniteStringSplit#test_fixsize        
+    def fixsize( len )
+      return '' if len <= 0
+      if self.size < len
+        self.ljust(len)
+      else
+          self[0..len-1]
+      end
+    end    
+
+    
+    # Schneidet einen String in Stücke. 
+    # Wie lang die Stücke sind, sagt der Parameter (Format: einzelner Integer oder Array of Integer).
+    # Gibt alle Stücke zurück plus den Rest, der übrigbleibt.
+    # 
+    # Beispiele & Tests siehe TestKyaniteStringSplit#test_split_by_index      
+    def split_by_index(idx)     
+      if idx.kind_of?(Integer)
+       [nchar(idx)] + [nchar(idx,'')]
+        
+      elsif idx.kind_of?(Array)
+       [nchar(idx[0])] + nchar(idx[0],'').split_by_index(idx.shift_complement)           
+        
+      end # if
+    end
+    
+    
+    
+    # Extrahiert einen Teilstring anhand zweier regulärer Ausdrücke. Beispiel:
+    #   string = '<select id="hallo"><option value="0">none</option></select>'
+    #   string.extract(/select.*?id="/,'"')  =>  'hallo'
+    #
+    def extract( start_regexp, stop_regexp )
+      split(start_regexp)[1].split(stop_regexp)[0]
+    end    
+        
+
+
+        
+    # Trennt einen String in numerische und alphanumerische Teile auf.
+    # Funktioniert derzeit nur mit positiven Integers. Bsp.:
+    #  'abc123'.split_numeric  >>  ['abc',123]   (Array)
+    #  '123abc'.split_numeric  >>  [123,'abc']   (Array)
+    #  '123'.split_numeric     >>  123           (Integer)
+    #  'abc'.split_numeric     >>  'abc'         (String)
+    #
+    # Das funktioniert sogar mit mehr als zwei Teilen:
+    #  '123abc456'.split_numeric  >>  [123,'abc',456]
+    #  'abc123def'.split_numeric  >>  ['abc',123,'def']         
+    #
+    # Tests siehe TestKyaniteStringSplit#test_split_numeric
+    def split_numeric
+        result = shatter(/\d+/).collect{ |i| i.to_integer_optional }
+        return result[0]    if ( result.is_collection? && result.size == 1 )
+        return result
+    end
+    
+
+    # Trennt numerische Teile ab und entfernt abschließende Whitespaces, Bindestriche, Unterstriche und Punkte.
+    # Wird z.B. für die Generierung des Doku-Pfades verwendet. 
+    #
+    # Tests siehe TestKyaniteStringClear
+    def without_versioninfo
+        shatter(/\d+/)[0].strip.chomp('_').chomp('-').chomp('.')
+    end        
+    
+end
+
+
+class NilClass
+  def nchar(*a);                          nil;            end  
+  def cut(*a);                            '';             end  
+  def split_by_index(*a);                 nil;            end  
+  def extract(*a);                        nil;            end  
+  def split_numeric;                      nil;            end  
+  def without_versioninfo;          nil;            end    
+end
+