kyanite 0.6.1 → 0.7.0

data/lib/kyanite/string/include.rb

@@ -1,17 +1,22 @@
 # ruby encoding: utf-8
+# ü
+if $0 == __FILE__ 
+  require 'drumherum'
+  smart_init
+end
+
 class String
 
-  # ---------------------------------------------------------------------------------------------------------------------------------
-  # :section: include
-  #  
-  
+  # @!group Miscellaneous
+    
+  # @private
   alias :old_include? :include?
   
-  # Nimmt jetzt auch ein Array an. 
-  # Die Array-Elemente werden ODER-verknüpft, d.h. 
-  # include? ist true, wenn für mindestens eines der Elemente include? true ist.
-  # Alle Strings includen '', [] oder nil. 
-  # Andersherum enthält nil niemals irgendwas (nil.include?  => false)
+  # Now also accepts an Array as input parameter. 
+  # The array elements are ORed, i.e. +include?+ is true if +old_include?+ is true for at least one element of the array. 
+  # All strings include +''+, +[]+ or +nil+. 
+  # +Nil+ does not include anything: +nil.include?  => false+
+  #
   def include?(input)
     return true if input.nil?
     return true if input.empty?
@@ -35,6 +40,8 @@ if defined? TransparentNil
   end
 end
 
+
+
 # -----------------------------------------------------------------------------------------
 #  ausprobieren
 #

data/lib/kyanite/string/list.rb

@@ -1,15 +1,28 @@
 # ruby encoding: utf-8
+# ü
+if $0 == __FILE__ 
+  require 'drumherum'
+  smart_init
+end
+
 require 'transparent_nil'
 require 'kyanite/symbol'
 
 class String
 
-# ---------------------------------------------------------------------------------------------------------------------------------
-# :section: List / Database
-# See TestKyaniteStringList for tests and examples.     
+
+# @!group Database-Helper 
   
   
-  # Listet Text auf. Beispiele siehe TestKyaniteStringList
+  # Generates WHERE clause from {Array}.
+  #  
+  # Example:
+  #  array = ['Anna','Birte','Charlie']
+  #  "kisses_from = ".list_with(array)
+  #  => "kisses_from = 'Anna' OR kisses_from = 'Birte' OR kisses_from = 'Charlie'"
+  #
+  # See tests and more examples {TestKyaniteStringList here}.
+  # @return [String]
   def list_with(  elemente, options = {}, &block )
   
     options = { :pre    => %q{'},
@@ -54,9 +67,9 @@ class String
 
 
   
-  # Gibt eine SQL-RegExp zurück, mit der man in Postgres kommaseparierte Listen duchsuchen kann.  
-  # Anwendung: Model Merkmal, has_many :dienste_req
-  # 
+  # Returns SQL-RegExp for searching in Postgres comma-separated list.
+  # @return [String]
+  #
   def sql_regexp_for_kommaliste
      '[, ]'  + self  + '[, ]'          + '|' +       # match mittendrin
      '^'     + self  + '[, ]'          + '|' +       # match am Anfang
@@ -65,7 +78,8 @@ class String
   end 
   
   
-  # macht aus einer MySQL-Enum-Angabe ein Array
+  # Converts MySQL-Enum to {Array}.
+  # @return [Array]
   #
   def enum_to_array
     self[5..-2].gsub("'",'').split(',').collect {|i| [i,i] }
@@ -83,3 +97,19 @@ if defined? TransparentNil
   end
 end
 
+
+# -----------------------------------------------------------------------------------------
+# Ausprobieren
+#
+if $0 == __FILE__ then
+
+require 'kyanite/string/chars'
+    array = ['Anna','Birte','Charlie']
+    puts "kisses_from = ".list_with(array)  
+
+
+
+
+
+end
+

data/lib/kyanite/string/misc.rb

@@ -0,0 +1,64 @@
+# ruby encoding: utf-8
+# ü
+if $0 == __FILE__ 
+  require 'drumherum'
+  smart_init
+end
+
+
+
+
+# @!macro string
+class String
+
+
+  # @!group Miscellaneous
+
+
+  # Counts the number of words.
+  # @return [Integer] number of words
+  def count_words
+    n = 0
+    scan(/\b\S+\b/) { n += 1}
+    n
+  end  
+   
+   
+  # String substitution like +gsub+, but replaces multible patterns in one turn. Example:
+  #  "between".mgsub([[/ee/, 'II'], [/e/, 'E']])      
+  #  => "bEtwIIn"  
+  # Tests {TestKyaniteStringMisc here}.
+  # @return [String]
+  def mgsub(search_and_replace_pairs)
+    patterns = search_and_replace_pairs.collect { |search, replace| search }
+    gsub(Regexp.union(*patterns)) do |match|
+      search_and_replace_pairs.detect{ |search, replace| search =~ match}[1]
+    end	
+  end     
+  
+
+end
+
+
+if defined? TransparentNil
+  class NilClass
+
+    # @return 0
+    def count_words;                   0;          end  
+    
+    def mgsub(*a);                     nil;        end    
+    
+  end
+end
+
+
+
+# -----------------------------------------------------------------------------------------
+#  ausprobieren
+#
+if $0 == __FILE__ then
+
+  puts "between".mgsub([[/ee/, 'II'], [/e/, 'E']])  
+  puts "between".mgsub([])  
+
+end # if

data/lib/kyanite/string/nested.rb

@@ -1,21 +1,27 @@
 # ruby encoding: utf-8
+# ü
+if $0 == __FILE__ 
+  require 'drumherum'
+  smart_init
+end
+
 class String
 
 # ---------------------------------------------------------------------------------------------------------------------------------
-# :section: Nested
+# @!group Nested
 # See TestKyaniteStringNested for tests and examples.   
 #
   
   
-  # Gibt die passende gegenteilige Klammer zurück
-  # '('.anti          ->  ')'
-  # '{'.anti          ->  '}'
-  # ']'.anti          ->  '['
-  # '<hallo>'.anti    ->  '</hallo>'
-  # '</hallo>'.anti   ->  '<hallo>'
+  # Returns the matching opposite bracket. Examples:
+  #  '('.anti          ->  ')'
+  #  '{'.anti          ->  '}'
+  #  ']'.anti          ->  '['
+  #  '<hallo>'.anti    ->  '</hallo>'
+  #  '</hallo>'.anti   ->  '<hallo>'
   #
-  # See TestKyaniteStringNested for tests and examples.  
-  #  
+  # See tests and examples {TestKyaniteStringNested#test_010_anti here}.  
+  # @return [String] opposite bracket 
   def anti
     if self.size == 1
       return self.tr('([{<)]}>',')]}>([{<')
@@ -31,11 +37,12 @@ class String
   
   
   
-  # 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
-  #
-  # See TestKyaniteStringNested for tests and examples.   
+  # Returns the positions of the next bracket pair. Example:
+  #  'Hello(welt)wort'.index_bracket  ->  5..10
+  # See tests and examples {TestKyaniteStringNested#test_020_index_bracket here}.    
+  # @return [Range] Positions of brackets
+  # @param start [Integer] Search from this starting position
+  # @param pattern [RegExp, String] Search only this type of bracket 
   #  
   def index_bracket( pattern=nil, start=0, last_found = nil )
     return nil if self.empty?
@@ -73,10 +80,20 @@ class String
   end
   
   
-  # Wendet den Block auf eine hierarchisch definierte Auswahl des Strings an.
+  # Applies the block to a hierarchically defined substring of the string.
   #
-  # See TestKyaniteStringNested for tests and examples.  
-  #  
+  # See tests and examples {TestKyaniteStringNested#test_030_mask_ungeklammert here}.    
+  # @return [String] 
+  # @param options [Hash] 
+  # @option options [Integer] :level_start
+  # @option options [Integer] :level_end
+  # @option options [Integer] :level_akt
+  # @option options [RegExp, String] :pattern
+  # @option options [Boolean] :skip_empty
+  # @option options [Boolean] :param_level
+  # @option options [Boolean] :with_brackets
+  # @param block [Block] 
+  #    
   def mask( options={}, &block )
   
     # vorbereiten
@@ -189,10 +206,10 @@ class String
   end # def
 
 
-  # Liefert die Verschachtelungstiefe.
-  #
-  # See TestKyaniteStringNested for tests and examples.  
-  #    
+
+  # Returns the depth of nesting (number of nesting levels). 
+  # @return [Integer] Depth of nesting 
+  # @param pattern [RegExp, String] Search only this type of bracket  
   def nestinglevel(pattern=/[{<(\[]/)
     result = 0
     self.mask( :level_start => 0,
@@ -237,7 +254,7 @@ end
 
 if $0 == __FILE__ 
 
-  require File.join(File.dirname(__FILE__), '..', '..', '..', 'test', 'string', 'test_nested' )   
+  
 
 end # if
 

data/lib/kyanite/string/random.rb

@@ -1,66 +1,124 @@
 # ruby encoding: utf-8
-
-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
+# ü
+if $0 == __FILE__ 
+  require 'drumherum'
+  smart_init
 end
 
+
 class String
 
+  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
+    
+    en_hauf = [ [ '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 ]]
+    en_array = []
+    en_hauf.each do | buchstabe, haufigkeit |
+      en_array +=  [buchstabe]*haufigkeit
+    end      
+    string_random_basis[:en] = en_array  
+    
+    STRING_RANDOM_BASIS = string_random_basis
+  end
+
+
   # ---------------------------------------------------------------------------------------------------------------------------------
-  # :section: Random
+  # @!group Random
   #  
 
-    # Zufällige Reihenfolge
+    # Reorder string in random order. Example:
+    #  "Random order".shuffle
+    #  => "oeo rdRdnmar"
+    # @return [String]
     def shuffle(separator=//)
       split(separator).shuffle.join('')
     end
 
-    # In-place-Variante von shuffle
+    # In-place-variant of {#shuffle +shuffle+}. 
+    # @return [String]     
     def shuffle!(separator=//)
       self.replace( shuffle(separator) )
     end
 
-    
-    def String.random( type=:de, size=16)
+    # Generates a random string. 
+    # Example:
+    #  String.random( :de, 20)
+    #  => brräbkpßrdirnenshrnh
+    #
+    #  String.random( :en, 20)
+    #  => euduwmtenohrtnaeewsc
+    #
+    #  String.random( :password, 20)
+    #  => PzAAGW2ALsbJRnljI6ho    
+    #
+    # @param type [Symbol] Char base with letter frequency of the random string (+:de+, +:en+ or +:password+)
+    # @param size [Integer] Length of the random string
+    # @return [String] Random string    
+    def String.random( type=:en, size=16)
       (0...size).map { STRING_RANDOM_BASIS[type][Kernel.rand(STRING_RANDOM_BASIS[type].size)] }.join    
     end    
 
@@ -72,3 +130,15 @@ if defined? TransparentNil
     def shuffle!;                     nil;            end    
   end
 end
+
+
+# -----------------------------------------------------------------------------------------
+# Ausprobieren
+#
+if $0 == __FILE__ then
+
+    puts String.random( :password, 20)  
+
+
+
+end