kyanite 0.3.1

data/lib/kyanite/string/chars_const.rb

@@ -0,0 +1,190 @@
+
+# Multibyte-Unterstützung von ActiveSupport
+$KCODE = 'UTF8' 
+require 'active_support'
+
+require 'facets/dictionary'
+require 'kyanite/nil'
+require 'kyanite/string/div'
+
+
+
+
+unless defined?(TR_UPCASE_ALL_REGEXP)
+  base = Dictionary.new
+  base['a'] = '     àáâă  äãā  åạą æ ảấầắằ а       '
+  base['A'] = '     ÀÁÂĂ  ÄÃĀ  ÅẠĄ Æ ẢẤẦẮẰ А       '
+  base['b'] = '     б           ' 
+  base['B'] = '     Б                 ' 
+  base['c'] = '     ćĉč çċ цч           '
+  base['C'] = '     ĆĈČ ÇĊ ЦЧ            '
+  base['d'] = '     ď ðđ д            '
+  base['D'] = '     Ď ÐĐ Д            '
+  base['e'] = '     èéêěĕ  ëēėę  ế еэ         '
+  base['E'] = '     ÈÉÊĚĔ  ËĒĖĘ  Ế ЕЭ         '
+  base['f'] = '     ф  '
+  base['F'] = '     Ф  '
+  base['g'] = '     ĝğġ ģ г           '
+  base['G'] = '     ĜĞĠ Ģ Г           '
+  base['h'] = '     ĥħ х                '
+  base['H'] = '     ĤĦ Х                '
+  base['i'] = '     ìíîĭ ïĩīı     į  ij ий'
+  base['I'] = '     ÌÍÎĬ ÏĨĪİ     Į  IJ ИЙ'
+  base['j'] = '	    ĵ юя    '
+  base['J'] = '	    Ĵ ЮЯ    '
+  base['k'] = '     ķĸ к        '
+  base['K'] = '     Ķĸ К      '
+  base['l'] = '     ĺ ľłļŀ л     '
+  base['L'] = '     Ĺ ĽŁĻĿ Л     '
+  base['m'] = '     м   '
+  base['M'] = '     М   '
+  base['n'] = '     ńň  ñņʼnŋ н     '
+  base['N'] = '     ŃŇ  ÑŅʼnŊ Н     '
+  base['o'] = '     òóôŏ öõō  øőơ œ о      '
+  base['O'] = '     ÒÓÔŎ ÖÕŌ  ØŐƠ Œ О      '
+  base['p'] = '     п   '
+  base['P'] = '     П   '
+  base['q'] = nil
+  base['Q'] = nil
+  base['r'] = '     ŕř  ŗ р           '
+  base['R'] = '     ŔŘ  Ŗ Р           '
+  base['s'] = '     śŝš ßş сшщ          '
+  base['S'] = '     ŚŜŠ ߪ СШЩ          '
+  base['t'] = '     ţťŧþ т        '
+  base['T'] = '     ŢŤŦÞ Т        '
+  base['u'] = '     ùúûŭ üũū  ůűųư у	     '
+  base['U'] = '     ÙÚÛŬ ÜŨŪ  ŮŰŲƯ У	     '
+  base['v'] = '     в'
+  base['V'] = '     В               '
+  base['w'] = '     ŵ               '
+  base['W'] = '     Ŵ               '
+  base['x'] = nil
+  base['X'] = nil
+  base['y'] = '     ýŷ   ÿ      '
+  base['Y'] = '     ÝŶ   Ÿ      '
+  base['z'] = '     źżž жз   '
+  base['Z'] = '     ŹŻŽ ЖЗ   '
+  
+  
+
+
+
+  allkeys = 'abcdefghijklmnopqrstuvwxyz'
+  #allkeys = 'snk'
+
+  # Spaces entfernen
+  allkeys.split(//).each do |key|
+    next unless base[key]
+    base[key].strip!.gsub!(' ','').gsub!(' ','')
+    base[key.upcase].strip!.gsub!(' ','').gsub!(' ','')
+  end
+
+
+  # upcase und downcase
+  tr_upcase = ''
+  tr_downcase = ''
+  allkeys.split(//).each do |key|
+    next unless base[key]
+    tr_downcase += base[key]   
+    tr_upcase   += base[key.upcase]  
+  end
+  
+  tr_upcase2       = ''
+  tr_downcase2     = ''
+  tr_downcase_only = ''
+  tr_upcase.mb_chars.split(//).each_with_index do |c, i|
+    if c == tr_downcase.mb_chars[i..i]   
+      tr_downcase_only += c
+    else
+      tr_upcase2   += c
+      tr_downcase2 += tr_downcase.mb_chars[i..i]   
+    end
+  end  
+
+TR_DOWNCASE_ONLY = tr_downcase_only
+
+
+  # reduce alphabet
+  tr_full    = ''
+  tr_reduced = ''
+  allkeys.split(//).each do |key|
+    next unless base[key]     
+    tr_full    += base[key]       
+    # tr_reduced += key * base[key].jsize               
+    tr_reduced += key * base[key].mb_chars.size               
+    tr_full    += base[key.upcase]   
+    # tr_reduced += key.upcase * base[key.upcase].jsize  
+    tr_reduced += key.upcase * base[key.upcase].mb_chars.size   
+  end
+  
+  tr_full2    = ''
+  tr_reduced2 = ''  
+  tr_full.mb_chars.split(//).each_with_index do |c, i|
+    next if ( TR_DOWNCASE_ONLY.include?(c)                          && 
+              (tr_reduced[i..i] == tr_reduced[i..i].upcase)   )
+      tr_full2    += c
+      tr_reduced2 += tr_reduced[i..i]
+  end
+  
+
+  TR_UPCASE    = tr_upcase2
+  TR_DOWNCASE  = tr_downcase2
+  TR_FULL      = tr_full2
+  TR_REDUCED   = tr_reduced2
+  TR_UPCASE_ALL_REGEXP = /^[A-ZÀÁÂĂÄÃĀÅẠĄÆẢẤẦẮẰАБĆĈČÇĊЦЧĎÐĐДÈÉÊĚĔËĒĖĘẾЕЭФĜĞĠĢГĤĦХÌÍÎĬÏĨĪİĮIJИЙĴЮЯĶКĹĽŁĻĿЛМŃŇÑŅŊНÒÓÔŎÖÕŌØŐƠŒОПŔŘŖРŚŜŠŞСШЩŢŤŦÞТÙÚÛŬÜŨŪŮŰŲƯУВŴÝŶŸŹŻŽЖЗ]/   
+  
+end # unless defined?
+
+
+
+
+
+
+# -----------------------------------------------------------------------------------------
+# Ausprobieren
+#
+if $0 == __FILE__ then
+
+  require 'perception'
+  rawlog "\n----------------------------------------------------------\n\n"
+  
+  rawlog 'TR_DOWNCASE_ONLY=     '
+  rawlog TR_DOWNCASE_ONLY
+  rawlog "\n" 
+  
+  rawlog 'TR_FULL=     '
+  rawlog TR_FULL
+  rawlog "\n"
+  rawlog 'TR_REDUCED=  '
+  rawlog TR_REDUCED
+  rawlog "\n"  
+  
+  rawlog 'TR_UPCASE=   '
+  rawlog TR_UPCASE
+  rawlog "\n"
+  rawlog 'TR_DOWNCASE= '
+  rawlog TR_DOWNCASE
+  rawlog "\n"
+  
+
+
+
+
+
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/kyanite/string/diff.rb

@@ -0,0 +1,78 @@
+ 
+
+
+class String
+
+        
+# ---------------------------------------------------------------------------------------------------------------------------------
+# :section: overlap / diff
+#          
+        
+  # Gibt den gemeinsamen Teil zweier Strings aus (von vorne gezählt).  
+  #    
+  # Beispiele & Tests siehe TestString#test_overlap    
+  def overlap(b)
+      return ''         if b.nil?
+      b = b.to_str
+      return self     if self == b
+      return ''         if self[0] != b[0]
+
+      n = [self.size, b.size].min
+      (0..n).each { |i|  return self[0..i-1] unless self[i] == b[i] }
+  end    
+
+  
+  # Liefert den Unterschied zwischen zwei Strings zurück.
+  # Im Zweifelsfall immer den längsten String.
+  # Wenn dann immer noch Zweifel, dann self. 
+  #    
+  # Beispiele & Tests siehe TestString#test_diff    
+  def diff(b)
+      return self     if b.nil?
+      b = b.to_str
+      return ''        if self == b        # kein Unterschied
+  
+    a = self 
+    a,b = b,a     if a.size >= b.size        # a ist jetzt k�rzer oder gleichlang wie b
+    overlap = a.overlap(b)
+    return self if overlap == ''
+    return b.split(overlap)[1]
+  end    
+
+  
+  
+  # Liefert zugleich overlap und diff zurück.
+  # Symmetrie: Rechnet man overlap + diff, so erhält man immer den längsten der beiden ursprünglichen Strings.
+  # Waren beide gleichlang, so erhält man self.
+  # overlapdiff braucht genauso viel Zeit wie diff alleine. 
+  #
+  # Beispiele & Tests siehe TestString#test_overlapdiff    
+  def overlapdiff(b)
+      return '', self     if b.nil?
+      b = b.to_str
+      return self,''        if self == b        # kein Unterschied
+  
+    a = self 
+    a,b = b,a     if a.size >= b.size        # a ist jetzt k�rzer oder gleichlang wie b
+    overlap = a.overlap(b)
+    return overlap, self if overlap == ''
+    return overlap, b.split(overlap)[1]
+  end        
+
+
+
+end
+
+
+
+class NilClass
+  def overlap(*a);              '';             end  
+  def diff(b);                  b;              end  
+  def overlapdiff(b);           ['', b];        end  
+end
+
+
+
+
+
+

data/lib/kyanite/string/div.rb

@@ -0,0 +1,19 @@
+
+
+
+class String
+
+  # Wörter zählen
+  def count_words
+    n = 0
+    scan(/\b\S+\b/) { n += 1}
+    n
+  end     
+  
+
+end
+
+
+class NilClass
+    def count_words;                   0;          end  
+end

data/lib/kyanite/string/include.rb

@@ -0,0 +1,43 @@
+
+class String
+  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)
+  def include?(input)
+    return true if input.nil?
+    return true if input.empty?
+    if ( input.respond_to?(:each)  &&  !input.kind_of?(String) )
+     input.each do |frag|
+        return true if include?(frag)
+     end
+     false
+    else
+      old_include?(input)
+    end
+  end # def
+end
+
+
+class NilClass
+    def include?(*a);                   false;          end  
+end
+
+
+# -----------------------------------------------------------------------------------------
+#  ausprobieren
+#
+if $0 == __FILE__ then
+
+  # puts 'hallo'.include?('ll')
+  # puts 'hallo'.include?('lh')
+  #puts 'hallo'.include?(['gg'])
+  #puts 'hallo'.include?(['lh','gg'])
+  puts 'hallo'.include?('')
+  puts 'hallo'.include?(nil)
+  puts nil.include?(nil)
+
+end # if

data/lib/kyanite/string/list.rb

@@ -0,0 +1,84 @@
+
+require 'kyanite/nil'
+require 'kyanite/symbol'
+
+class String
+
+# ---------------------------------------------------------------------------------------------------------------------------------
+# :section: Listen / Datenbank
+#      
+  
+  
+  # Listet Text auf. Beispiele siehe Tests!
+  def list_with(  elemente, options = {}, &block )
+  
+    options = { :pre    => %q{'},
+                :post   => %q{'},
+                :sep    => ' OR ',
+                :empty => 'FALSE'}.merge(options)
+
+    
+    # keine Liste angegeben
+    return options[:empty]     if elemente.empty? 
+    
+    
+    # einzelnen String oder einzelnes Symbol angegeben -> ohne Separator ausgeben
+    if elemente.kind_of?(String)  ||  !elemente.respond_to?(:each_index) 
+      e = elemente.dup
+      e = yield e               if block_given?    
+      return "#{self}#{options[:pre]}#{e}#{options[:post]}"     
+    end
+    
+    
+    # Liste hat nur ein Element -> ohne Separator ausgeben
+    if elemente.size <= 1  
+      e = elemente[0].dup
+      e = yield e               if block_given?    
+      return "#{self}#{options[:pre]}#{e}#{options[:post]}"     
+    end      
+    
+    
+    # Liste hat mehrere Elemente
+    result = ''
+    elemente[0..-2].each do |e|
+      # Die vorderen Elemente mit Separator
+      e = yield e               if block_given?
+      result += "#{self}#{options[:pre]}#{e}#{options[:post]}#{options[:sep]}"  
+    end
+      # Letztes Element ohne Separator 
+      e = elemente[-1].dup
+      e = yield elemente[-1]    if block_given?
+      result += "#{self}#{options[:pre]}#{e}#{options[:post]}" 
+    result
+  end
+
+
+  
+  # Gibt eine SQL-RegExp zurück, mit der man in Postgres kommaseparierte Listen duchsuchen kann.  
+  # Anwendung: Model Merkmal, has_many :dienste_req
+  # 
+  def sql_regexp_for_kommaliste
+     '[, ]'  + self  + '[, ]'          + '|' +       # match mittendrin
+     '^'     + self  + '[, ]'          + '|' +       # match am Anfang
+     '[, ]'  + self  + '$'             + '|' +       # match am Ende
+     '^'     + self  + '$'                           # match von Anfang bis Ende
+  end 
+  
+  
+  # macht aus einer MySQL-Enum-Angabe ein Array
+  #
+  def enum_to_array
+    self[5..-2].gsub("'",'').split(',').collect {|i| [i,i] }
+  end    
+
+  
+
+end
+
+
+class NilClass
+  def list_with(*a);                       nil;            end
+  def sql_regexp_for_kommaliste;           nil;            end
+  def enum_to_array;                       nil;            end
+end
+

data/lib/kyanite/string/mgsub.rb

@@ -0,0 +1,35 @@
+
+class String
+ 
+  # Mehrere Patterns mit einer RegExp replacen.
+  # Ruby Cookbook Seite 32 
+  # "between".mgsub([[/ee/, 'AA'], [/e/, 'E']])      # Good code
+  # => "bEtwAAn"
+  #  
+  def mgsub(key_value_pairs=[].freeze)
+    regexp_fragments = key_value_pairs.collect { |k,v| k }
+    gsub(Regexp.union(*regexp_fragments)) do |match|
+      key_value_pairs.detect{|k,v| k =~ match}[1]
+    end	
+  end   
+  # http://oreilly.com/catalog/9780596523695/
+  # Ruby Cookbook, by Lucas Carlson and Leonard Richardson
+  # Copyright 2006 O'Reilly Media  
+ 
+ end # class 
+ 
+ 
+class NilClass
+  def mgsub(*a);                       nil;            end
+end
+ 
+ 
+ 
+# -----------------------------------------------------------------------------------------
+#  ausprobieren
+#
+if $0 == __FILE__ then
+
+  puts "between".mgsub([[/ee/, 'AA'], [/e/, 'E']])  
+
+end # if