kyanite 0.3.1

data/lib/kyanite/general.rb

@@ -0,0 +1,8 @@
+
+  require 'kyanite/general/callerutils'
+  require 'kyanite/general/classutils'
+  require 'kyanite/general/kernel'
+  require 'kyanite/general/nil'
+  require 'kyanite/general/object'
+  require 'kyanite/general/true_false'   
+  require 'kyanite/general/undoable'   

data/lib/kyanite/general/callerutils.rb

@@ -0,0 +1,128 @@
+
+require 'kyanite/string/include'
+
+# ==Tools for Kernel#caller
+#
+class CallerUtils
+
+  # Untersucht den Call-Stack. Liefert die Größe des Stacks oder den letzten Eintrag.
+  #
+  # Options: 
+  #   :skip    Ignoriere caller, die das angegebene Fragment enthalten   (String oder Array)
+  #   :mode    Welche Art von Ergebnis soll geliefert werden? 
+  #            :caller (Standard) liefert den Caller, 
+  #            :size liefert die Größe das Call-Stacks
+  #
+  # Beispiel:        
+  #  CallerUtils.mycaller(:skip => ['perception', 'ruby\gems', 'ruby/gems', 'test/unit'])
+  #  => "R:/_Eigene_Projekte_unter_SVN/kyanite/lib/kyanite/general/callerutils.rb:100"
+  #       
+  def self.mycaller(options={})
+    skip = options[:skip] || []
+    skip = [skip]   if skip.kind_of?(String)
+    mode = options[:mode] || :caller
+    result = nil     
+    size = caller.size  
+    if skip.empty?
+      return caller[0]  if mode == :caller
+      return size       if mode == :size
+    end
+    caller.each_with_index do | c, i |
+#puts "caller=#{c}"
+#puts "skip=#{skip.inspect_pp}"
+      next if c.include?(skip)
+#puts "ok! \n"
+      if mode == :caller
+        result = c
+      elsif mode == :size
+        result = (size - i)
+      end # if mode           
+      break
+    end # each caller
+    # puts "mycaller=#{result}"  
+    result
+  end # def
+
+
+  
+  # Ermittelt das Hauptverzeichnis eines Callers auf heuristischem Wege.
+  # Der Name des Hauptverzeichnisses entspricht meist dem Namen der Applikation oder Library.
+  #
+  # Beispiel:
+  #   my_caller  = CallerUtils.mycaller(:skip => ['perception', 'ruby\gems', 'ruby/gems', 'test/unit']) 
+  #   CallerUtils.mycaller_maindir(my_caller)           
+  #   => "R:/_Eigene_Projekte_unter_SVN/kyanite"
+  #
+  def self.mycaller_maindir(mycaller)
+    dir_caller =File.dirname(mycaller)
+    array_caller = dir_caller.split('/')
+    array_caller = dir_caller.split("\\") if array_caller.size == 1
+#require 'pp'
+#pp array_caller
+    indicatorfiles = %W{Init Boot History License Manifest Rakefile README ReadMe Readme Setup}
+    check = []
+    (-array_caller.size).upto(-1) do |lev|
+      indicatorfiles.each do | f |
+        next if array_caller[lev..lev] == '..'
+        check << array_caller[0..lev].join('/') + "/#{f}.rb"
+        check << array_caller[0..lev].join('/') + "/#{f}.txt"
+        check << array_caller[0..lev].join('/') + "/#{f}"
+        check << array_caller[0..lev].join('/') + "/#{f.downcase}.rb"
+        check << array_caller[0..lev].join('/') + "/#{f.downcase}.txt"
+        check << array_caller[0..lev].join('/') + "/#{f.downcase}"          
+      end
+    end  
+      #return check
+      maindir = ''
+      check.uniq.each do | try |
+        # puts "try #{try}"
+        maindir = try
+        break if File.exist?(try)
+      end
+      # puts "mycaller_maindir=#{File.dirname(maindir) }"
+      return File.dirname(maindir) 
+    end    
+  
+  
+  # def self.caller_full(options={})
+    # caller
+  # end  
+  
+  
+end # class
+
+
+
+# ==================================================================================
+# Ausprobieren
+#
+if $0 == __FILE__ 
+
+           
+           
+           
+        require 'pp'
+        my_caller  = CallerUtils.mycaller(:skip => ['perception', 'ruby\gems', 'ruby/gems', 'test/unit']) 
+        my_maindir = CallerUtils.mycaller_maindir(my_caller)            if my_caller
+        pp my_maindir
+
+
+
+
+
+
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/kyanite/general/classutils.rb

@@ -0,0 +1,246 @@
+
+
+require 'facets/kernel/singleton_class'     # Easy access to an object‘s "special" class, otherwise known as it‘s eigen or meta class.
+require 'facets/class/descendents'          # Methode   descendents 
+
+
+# 
+# Class
+# 
+
+class Class
+  
+  # Vergleichsoperator: Alphabetisch. 
+  def <=>(other) 
+      ( ( self.to_s ) <=> ( other.to_s ) )
+  end   
+  
+  
+  # Unscharfer Vergleich zweier Klassen, z.B. für Tests
+  def =~(other)
+    return true   if self == other
+    return true   if self.descendents.include?(other)
+    return true   if other.descendents.include?(self)
+    return false
+  end  
+
+  # <tt> self </tt>
+  def to_class 
+    self
+  end     
+
+  
+  # Wandelt eine Klasse in einen Klassennamen um, der nur Kleinbuchstaben enthält.
+  #
+  # Tests siehe TestKyaniteClassutils
+  #
+  def to_classname
+    self.to_s.demodulize.underscore
+  end         
+  
+end # class
+
+
+
+
+# 
+# Symbol
+#
+  
+class Symbol
+
+  # Wandelt einen String in einen Klassennamen. 
+  #   'MeinModul::EineKlasse'  =>  eine_klasse
+  #
+  # Tests und Beispiele siehe TestKyaniteClassutils
+  #
+   def to_classname 
+      self.to_s.to_classname
+  end
+
+  # Wandelt einen Klassennamen in eine Klasse.
+  #
+  # Akzeptiert sowohl CamelCase als auch down_case.
+  #
+  # Tests und Beispiele siehe TestKyaniteClassutils
+  #
+  def to_class 
+      self.to_s.to_class
+  end   
+
+end # class 
+
+
+
+
+  
+# 
+# String
+#  
+  
+class String  
+
+  # Wandelt einen Klassennamen in eine Klasse.
+  #
+  # Akzeptiert sowohl CamelCase als auch down_case.
+  #
+  # Tests und Beispiele siehe TestKyaniteClassutils
+  # 
+  def to_class
+      self.camelize.constantize
+  rescue
+      return nil
+  end
+  
+  
+  # Wandelt einen String in einen Klassennamen. 
+  #   'MeinModul::EineKlasse'  =>  eine_klasse
+  #
+  # Tests und Beispiele siehe TestKyaniteClassutils
+  #
+  def to_classname
+      self.demodulize.underscore
+  end
+
+end
+
+
+
+# 
+# String, from ActiveSupport
+#  
+
+#
+# ActiveSupport
+# --------------
+#
+# Copyright (c) 2005 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+
+class String
+
+
+  # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
+  #
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples:
+  #   "ActiveRecord".underscore         # => "active_record"
+  #   "ActiveRecord::Errors".underscore # => active_record/errors
+  # From ActiveSupport, Copyright (c) 2005 David Heinemeier Hansson  
+  #  
+  def underscore
+    self.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+  
+  
+  
+  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
+  # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+  #
+  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+  #
+  # Examples:
+  #   "active_record".camelize                # => "ActiveRecord"
+  #   "active_record".camelize(:lower)        # => "activeRecord"
+  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+  # From ActiveSupport, Copyright (c) 2005 David Heinemeier Hansson  
+  #  
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      self.first + camelize(self)[1..-1]
+    end
+  end  
+  
+  
+  # Removes the module part from the expression in the string.
+  #
+  # Examples:
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+  #   "Inflections".demodulize                                       # => "Inflections"
+  # From ActiveSupport, Copyright (c) 2005 David Heinemeier Hansson  
+  #  
+  def demodulize
+    self.gsub(/^.*::/, '')
+  end  
+  
+  
+
+  # Tries to find a constant with the name specified in the argument string:
+  #
+  #   "Module".constantize     # => Module
+  #   "Test::Unit".constantize # => Test::Unit
+  #
+  # The name is assumed to be the one of a top-level constant, no matter whether
+  # it starts with "::" or not. No lexical context is taken into account:
+  #
+  #   C = 'outside'
+  #   module M
+  #     C = 'inside'
+  #     C               # => 'inside'
+  #     "C".constantize # => 'outside', same as ::C
+  #   end
+  #
+  # NameError is raised when the name is not in CamelCase or the constant is
+  # unknown.
+  # From ActiveSupport, Copyright (c) 2005 David Heinemeier Hansson  
+  #
+  def constantize
+    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
+      raise NameError, "#{self.inspect} is not a valid constant name!"
+    end
+
+    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+  end
+  
+end # class  
+
+
+class NilClass
+  def camelize;                 nil;                  end 
+  def constantize;              nil;                  end 
+  def demodulize;               nil;                  end 
+  def to_class;                 nil;                  end    
+  def to_classname;             '';                   end    
+  def underscore;               nil;                  end 
+end
+
+
+
+
+
+
+
+
+
+
+
+  
+  

data/lib/kyanite/general/kernel.rb

@@ -0,0 +1,105 @@
+
+require 'facets/timer'
+require 'rbconfig'
+
+unless defined? WINDOWS  
+  WINDOWS = /djgpp|(cyg|ms|bcc)win|mingw/ =~ RUBY_PLATFORM ? RUBY_PLATFORM : false       
+end
+
+unless defined? RUBYDIR
+  RUBYDIR = Config::CONFIG['prefix']
+end
+
+
+module KyaniteKernel 
+
+  # Wiederholt einen Block so lange, bis die Zeit abgelaufen ist.
+  # Liefert die Anzahl der Durchläufe, die in dieser Zeit möglich waren.
+  # Alle Exceptions werden abgefangen (=> fehlerhafte Blöcke scheinen schneller zu laufen)
+  def repeat_n_seconds( n=1, &block )
+    timer = Timer.new(n) 
+    begin
+      timer.start
+        count = 0
+        until false
+          count += 1
+          yield block
+        end
+      timer.stop
+    rescue TimeoutError 
+      return count      
+    rescue 
+      return count  
+    rescue 
+      return count             
+    end # begin 
+  end # def
+  
+  
+  
+  # Quelle: Rails http://api.rubyonrails.org/classes/Kernel.html#M001639
+  def silence_warnings
+       old_verbose, $VERBOSE = $VERBOSE, nil
+       yield
+    ensure
+       $VERBOSE = old_verbose
+  end    
+  
+  
+  def smart_load_path(__file__ = nil)
+    __file__ = caller[0] unless __file__
+    dir_caller =File.dirname(__file__)
+    patharray = dir_caller.split('/')
+    patharray = dir_caller.split("\\")       if patharray.size == 1  
+    libpath = File.join(patharray)   
+    patharray.size.times do |i|
+      break   if File.directory?( File.join(patharray, 'lib') ) 
+      patharray << '..'
+    end
+    newpath = File.join(patharray,'lib')  
+    if $:.include?(newpath)
+      return false
+    else
+      $:.unshift(newpath)  
+      return true
+    end
+    
+  end  #def
+
+  
+  
+
+  
+  
+  
+  
+end # class
+
+class Object
+  include KyaniteKernel
+end
+
+
+# ---------------------------------------------------------
+# Ausprobieren
+#
+if $0 == __FILE__ 
+require 'perception'
+# pp RUBYDIR
+
+smart_load_path(__FILE__)
+$LOAD_PATH.each do |path|
+puts path
+end
+
+end
+
+
+
+
+
+
+
+
+
+