kyanite 0.3.1

data/lib/kyanite/numeric/integer.rb

@@ -0,0 +1,34 @@
+
+class Integer
+
+  # Wandelt eine Sekundenzahl-seit-1970 in ein Time-Objekt
+  def to_time
+    return nil if self > 2099999999     # geht leider nur bis ins Jahr 2036 
+    ::Time.at(self)                     # ohne die Doppelpunkte sucht Ruby die Methode at in ::Time und wirft einen Error
+  end     
+  
+  # <tt> self </tt>   
+  #
+  # Test: TestInteger#test_triviales
+  def to_integer;                     self;            end     
+  
+  # <tt> self </tt>    
+  #
+  # Test: TestInteger#test_triviales
+  def to_integer_optional;            self;            end  
+  
+  # <tt> self </tt>    
+  #
+  # Test: TestInteger#test_triviales
+  def dup;                            self;            end        
+  
+end # class
+
+
+
+class NilClass
+  def to_time;                        nil;            end   
+end
+
+
+

data/lib/kyanite/numeric/numeric.rb

@@ -0,0 +1,45 @@
+
+class Numeric
+
+  # Zahlen sind schon numerisch:
+  # <tt> self </tt>       
+  def split_numeric #:nodoc:
+      self 
+  end    
+
+
+  # Zahlen sind nicht empty:
+  # <tt> false </tt>       
+  def empty? #:nodoc:
+      false 
+  end  
+  
+  
+  # siehe ::Array#shift_complement:
+  # <tt> nil </tt>       
+  def shift_complement #:nodoc:
+    nil
+  end    
+  
+  
+  # Wandelt 0 in nil um
+  def to_nil(*args)
+    return nil  if self == 0
+    self
+  end
+  
+  
+  # nil-sicheres subtrahieren 
+  def substract(other)
+    return nil if other.nil?
+    self - other
+  end
+  
+  
+    
+end # class
+
+
+class NilClass
+  def substract(other); nil; end
+end

data/lib/kyanite/operation.rb

@@ -0,0 +1,5 @@
+
+
+require 'kyanite/operation/call_tracker'
+require 'kyanite/operation/regexp'
+require 'kyanite/operation/unit_test'

data/lib/kyanite/operation/call_tracker.rb

@@ -0,0 +1,69 @@
+
+
+
+# http://oreilly.com/catalog/9780596523695/
+# Ruby Cookbook, by Lucas Carlson and Leonard Richardson
+# Copyright 2006 O'Reilly Media
+#
+class CallTracker
+
+  # Initialize and start the trace.
+  def initialize(show_stack_depth=1)
+    @show_stack_depth = show_stack_depth
+    @to_trace = Hash.new { |h,k| h[k] = {} }
+    start
+    at_exit { stop }
+  end
+
+  # Register a class/method combination as being interesting. Subsequent calls
+  # to the method will be tallied by tally_calls.
+  def register(klass, method_symbol)	
+    @to_trace[klass][method_symbol] = {}
+  end
+
+  # Tells the Ruby interpreter to call tally_calls whenever it's about to
+  # do anything interesting.
+  def start
+    set_trace_func method(:tally_calls).to_proc
+  end
+
+  # Stops the profiler, and prints a report of the interesting calls made
+  # while it was running.
+  def stop(out=$stderr)
+    set_trace_func nil
+    report(out)
+  end
+
+  # If the interpreter is about to call a method we find interesting,
+  # increment the count for that method.
+  def tally_calls(event, file, line, symbol, binding, klass)
+    if @to_trace[klass] and @to_trace[klass][symbol] and 
+	(event == 'call' or event =='c-call')
+      stack = caller
+      stack = stack[1..(@show_stack_depth ? @show_stack_depth : stack.size)]
+      @to_trace[klass][symbol][stack] ||= 0
+      @to_trace[klass][symbol][stack] += 1
+    end    
+  end  
+
+  # Prints a report of the lines of code that called interesting
+  # methods, sorted so that the the most active lines of code show up
+  # first.
+  def report(out=$stderr)
+    first = true
+    @to_trace.each do |klass, symbols|
+      symbols.each do |symbol, calls| 
+        total = calls.inject(0) { |sum, ct| sum + ct[1] }        
+        padding = total.to_s.size
+        separator = (klass.is_a? Class) ? '#' : '.'
+        plural = (total == 1) ? '' : 's'
+        stack_join = "\n" + (' ' * (padding+2))
+        first ? first = false : out.puts
+        out.puts "#{total} call#{plural} to #{klass}#{separator}#{symbol}"
+        (calls.sort_by { |caller, times| -times }).each do |caller, times|
+          out.puts " %#{padding}.d #{caller.join(stack_join)}" % times
+        end       
+      end
+    end
+  end
+end

data/lib/kyanite/operation/rake.rb

@@ -0,0 +1,101 @@
+
+# Dirty patch unter Windows um rake doc:plugins zum Laufen zu bringen: http://dev.rubyonrails.org/ticket/6608
+
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+# Doku der M�glichkeiten in einem RakeTask siehe http://rake.rubyforge.org/files/doc/rakefile_rdoc.html
+
+
+#  ----------------------------------------------------------------------------------------------
+#  Rake initialisieren
+#  
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+  
+
+#   ----------------------------------------------------------------------------------------------
+#   Erg�nzung: Alte Tasks entfernen
+#   sonst kann man sie n�mlich nicht �berschreiben!
+#   Beispiel: remove_task 'test:plugins'     
+#   Quelle: http://matthewbass.com/2007/03/07/overriding-existing-rake-tasks/
+#   dies hier stimmt nicht: http://www.dcmanges.com/blog/modifying-rake-tasks
+   
+Rake::TaskManager.class_eval do
+  def remove_task(task_name)
+    @tasks.delete(task_name.to_s)
+  end
+end
+
+def remove_task(task_name)
+  Rake.application.remove_task(task_name)
+end
+
+
+#  ----------------------------------------------------------------------------------------------
+#  Taskliste versch�nern und als Default Task 
+#  
+
+
+
+remove_task 'default'  # wichtig!
+# desc 'Zeige eine Liste aller verfuegbaren Rake-Tasks'
+task :default do
+  Rake.application.options.show_task_pattern = //
+  Rake.application.display_tasks_and_comments(:kurz) 
+end
+
+
+module Rake # :nodoc:
+  class Application # :nodoc:
+    # Display the tasks and dependencies.
+    def display_tasks_and_comments( myoptions = nil )
+      $rake_tasks_ausblenden  = []      unless defined? $rake_tasks_ausblenden
+      namespace_akt           = ''
+      namespace_prev          = ''
+      newline_allowed         = true
+      displayable_tasks       = tasks.select { |t| t.comment && t.name =~ options.show_task_pattern }
+      width                   = displayable_tasks.collect { |t| t.name.length }.max
+      all_namespaces          = []
+      skipped_tasks           = []
+      displayable_tasks.each do |t|
+        foo = t.name.split(':')
+        next if foo.size < 2
+        all_namespaces << foo[0]
+      end
+      all_namespaces.uniq!
+      #puts all_namespaces.join(',')
+
+      
+      # Mit Namespace oder Taskname == Namespace
+      displayable_tasks.each do |t|
+        next                    if ( myoptions == :kurz  &&  $rake_tasks_ausblenden.include?(t.name) )
+        foo =  t.name.split(':')
+        if  foo.size < 2
+          unless all_namespaces.include?(foo[0]) # Taskname == Namespace 
+            skipped_tasks << t
+            next                  
+          end        
+        end        
+        namespace_akt = foo[0]
+        puts "\n"               if namespace_akt != namespace_prev  
+        printf "#{name} %-#{width}s  # %s\n", t.name, t.comment
+        namespace_prev = namespace_akt.dup
+      end # do      
+      
+      puts "\n"
+      skipped_tasks.each do |t|
+        next if ( myoptions == :kurz && $rake_tasks_ausblenden.include?(t.name) )
+        printf "#{name} %-#{width}s  # %s\n", t.name, t.comment
+      end # do        
+      
+      
+      
+      puts "\nsee full task list with rake -T"  #unless ($rake_tasks_ausblenden.empty?  ||  myoptions == :kurz )
+      puts "\nsee full task list with rake -T"  unless ($rake_tasks_ausblenden.empty?  ||  myoptions == :kurz )
+      
+    end
+  end
+end

data/lib/kyanite/operation/regexp.rb

@@ -0,0 +1,23 @@
+ 
+
+
+class String
+
+  # Zeigt das Ergebnis eines Matches mit einer Regular Expression. Erleichtert das Entwickeln regul�rer Ausdr�cke.
+  # 
+  def show_regexp(re)
+      if self =~ re
+          "#{$`}<<#{$&}>>#{$'}"
+      else
+          "no match"
+      end # if
+  end  
+
+end
+
+
+class NilClass
+  def show_regexp(*a);                          nil;            end 
+end
+
+

data/lib/kyanite/operation/unit_test.rb

@@ -0,0 +1,53 @@
+
+require 'test/unit'
+require 'kyanite/general/kernel'      # smart_load_path
+begin
+  require 'perception'   
+rescue
+end
+
+class UnitTest < Test::Unit::TestCase # :nodoc:
+
+  # Meldet den aktuell durchlaufenden Test
+  def test0 #:nodoc:
+    name = self.class.to_s.gsub(/^.*::/, '')
+    name.gsub!(/^Test/, '')
+    name.gsub!(/^[0-9]+/, '')
+    if name != 'UnitTest'  
+      print "\n #{name} "
+    else
+     puts
+     puts
+    end
+  end  
+  
+  
+
+  
+
+
+end
+
+
+
+
+# ---------------------------------------------------------
+# Ausprobieren
+#
+if $0 == __FILE__ 
+
+class Test030Blatest < UnitTest # :nodoc:
+
+  def test_bla
+    # 1 / 0 
+    assert false
+  end
+
+end
+
+
+
+
+
+end
+

data/lib/kyanite/optimizer.rb

@@ -0,0 +1,119 @@
+
+require 'perception'              if $0 == __FILE__ 
+
+# Drei Stufen für Marshall sind denkbar:
+# * kein Marshal
+# * Marshal.load(Marshal.dump) beim Schreiben. Dadurch sind Schreibzugriffe teuer, Lesezugriffe aber billig
+# * Marshal.dump beim Schreiben, Marshal.load beim Lesen. Dadurch sind Lese- und Schreibzugriffe teuer, 
+#   die im Optimizer gespeicherten Objekte sind aber abgeschottet und geschützt.
+#
+class Optimizer < Hash
+
+#@@marshal = true
+
+  # def initialize( options={} )
+    # @@marshal = options[:marshal]  || true
+  # end
+  
+  
+  def matchpoints_max
+    return nil  if size == 0  
+    keys.max
+  end
+  
+  
+  
+  def matchpoints_min
+    return nil  if size == 0  
+    keys.min
+  end  
+  
+  
+  # Liefert den Content mit den meisten Matchpoints. Mit
+  # content_max(0)      erhält man den ersten Content mit maximalen Matchpoints, mit
+  # content_max(-1)     den letzten Content mit maximalen Matchpoints und mit 
+  # content_max(0..-1)  alle Contents mit maximalen Matchpoints (dann als Array).
+  #
+  def content_max(range=0..0)
+    return nil  if size == 0
+    range = (range..range) if range.kind_of?(Fixnum)    
+    if (range.end - range.begin) == 0
+      return Marshal.load(self[keys.max][range.begin])
+    else
+      result = []
+      self[keys.max][range].each do | m |
+        result << Marshal.load(m)
+      end
+      return result
+    end
+  end
+  
+  
+  # siehe content_max
+  def content_min(range=0..0)
+    return nil  if size == 0
+    range = (range..range) if range.kind_of?(Fixnum)    
+    if (range.end - range.begin) == 0
+      return Marshal.load(self[keys.min][range.begin])
+    else
+      result = []
+      self[keys.min][range].each do | m |
+        result << Marshal.load(m)
+      end
+      return result
+    end
+  end 
+  
+  
+  
+  def push( matchpoints, content, options={} )
+    if self.has_key?(matchpoints) 
+      self[matchpoints] << Marshal.dump(content) 
+    else
+      self[matchpoints] = [ Marshal.dump(content) ]
+    end
+  end
+  
+  
+  
+  def cleanup
+    return false if size <= 2
+    keys.sort[1..-2].each do | key | 
+      self.delete(key)
+    end
+    true
+  end
+  
+  
+  def delete_min
+    return false if size <= 1
+    self.delete(keys.min)
+    true
+  end  
+  
+  
+  def delete_max
+    return false if size <= 1
+    self.delete(keys.max)
+    true
+  end    
+
+
+
+
+
+end #class
+
+
+
+
+
+
+
+
+
+
+
+
+
+