perception 0.1.5

data/lib/perception/numeric.rb

@@ -0,0 +1,194 @@
+
+require File.join(File.dirname(__FILE__), '..', 'perception' )  if $0 == __FILE__ 
+
+module Perception #:nodoc
+
+ module NumericI 
+
+    
+    # Formatiert eine Zahl so, dass sie leicht menschenlesbar wird: 
+    # - Quasi-rechtsbündig (mit dem Komma als Bezugspunkt, abhängig von der Klassenzugehörigkeit der Zahl)
+    # - vorangestellte Währungszeichen oder angefügte Einheiten, ohne die Bündigkeit zu zerstören    
+    # - intelligente Ausweichstrategie, wenn der vorgegebene Platz nicht ausreicht
+    # - nur die signifikanten Stellen werden angegeben, damit die Größenordnung leicht erfasst werden kann
+    # - Tausendertrennzeichen wenn nötig
+    #
+    # Optionen sind:
+    # * :precision   Wieviel signifikante Stellen sollen ausgegeben werden? Default: 3
+    # * :space_l     Wieviel Platz wird vor dem Komma eingeplant? 
+    # * :space_r     wie :space, bezieht sich aber nur auf den Nachkommateil. Wird abhängig davon vorbelegt, ob self Integer oder Float ist.
+    # * :separator   Kommazeichen 
+    # * :delimiter   Tausendertrennzeichen
+    # * :pre         wird direkt vor der Zahl ausgegeben  (z.B. €)
+    # * :past        wird direkt nach der Zahl ausgegeben (z.B. %)      
+    #
+    # Für eine schlichte linksbündige Ausgabe reicht die Methode #significant!               
+    # vgl. http://de.wikipedia.org/wiki/Wikipedia:Schreibweise_von_Zahlen
+    #
+    def inspect_see(options={})
+      precision =         options[:precision]   ||  3
+      pre  =              options[:pre]         ||  ''
+      past  =             options[:past]        ||  ''      
+      space_l =           options[:space_l]     ||  9 + pre.size  
+      space_r =           options[:space_r]     ||  (self.kind_of?(Integer) ?  (0+past.size) : (5+past.size))    # Integer oder Float?
+      separator =         options[:separator]   ||  ','
+      delimiter  =        options[:delimiter]   ||  ' '
+
+      
+      # auf die signifikanten Stellen reduzieren und aufteilen
+      zusammengestrichen = self.significant(precision)
+      zahlenteile = zusammengestrichen.to_s.split('.')
+      
+      # Tausendertrennzeichen und Pre
+      zahlenteile[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")    if self.abs >= 10000
+      zahlenteile[0] = pre + zahlenteile[0]                                 unless pre.empty?
+      
+      # übereinanderstehende Formatierung 
+      result = zahlenteile[0].rjust(space_l) 
+      if zahlenteile[1]
+        
+        result += (separator + zahlenteile[1] + past).ljust( space_r )
+        #result += separator + (zahlenteile[1]).ljust( space_r-1 )
+      else      
+        result += past + (' ' * (space_r-past.size)) 
+      end
+      
+      # zu großen Platzbedarf korrigieren
+      if result.size >= space_l+space_r+1
+        if (space_l - zahlenteile[0].size) < ((space_r-1) - zahlenteile[1].size)
+          return result.strip.ljust(space_l+space_r)#.gsub(/ /,'_')  # linksbündig ausgeben
+        else
+          return result.strip.rjust(space_l+space_r)#.gsub(/ /,'_')  # rechtsbündig ausgeben 
+        end
+        
+      # Platz reicht aus  
+      else
+        return result#.gsub(/ /,'_')
+      end
+       
+    end
+    
+    
+    # Streicht überflüssige Stellen weg.
+    # Wandelt in Integer um, wenn das ohne Informationsverlust möglich ist.
+    # Überflüssig sind Stellen, die 
+    # * jenseits der Messprecision liegen oder
+    # * nicht von Menschen wahrgenommen werden (stattdessen stören sie die Rezeption)
+    # 
+    def significant( precision = 3)
+    
+        # sprintf mit gemischter Schreibweise
+        fucking_c_lib_result = sprintf("%.#{precision}g", self)
+        fucking_c_lib_result =~ /^(.*)e/
+        meine_zahl = $+ || fucking_c_lib_result            
+        exponent = $'
+        # pp meine_zahl
+        # pp exponent
+        
+        #  ohne Exponent
+        if exponent.nil?
+          result = meine_zahl.to_f
+          if result.abs >= (10**(precision-1))  ||  result == result.to_i
+            return result.to_i
+          else
+            return result
+          end          
+         
+        # mit Exponent
+        else
+     
+          result = meine_zahl.to_f * 10**(exponent.to_i)
+          if exponent[0..0] == '+' 
+            return result.to_i
+          
+          else
+            return result
+
+          end
+        
+        end # Expontent?
+    end # def significant      
+    
+
+  end # module NumericI 
+end # module Perception
+
+
+class Numeric #:nodoc:
+  include Perception::NumericI
+end
+
+class NilClass #:nodoc:
+    def size(*a);                       0;              end  
+end
+
+
+
+
+
+
+
+# -----------------------------------------------------------------------------------------
+# Ausprobieren, Tests
+#
+
+
+if $0 == __FILE__ then
+
+  # Hier einstellen, was laufen soll
+  $run = :inspect_see
+  $run = :significant
+  #$run = :tests
+  
+  case $run 
+  
+
+  when :significant #------------------------------------------------------------------------
+  
+    test = [12567.89, 1256.789, 123.56789, 100.01, 100.0, 99.9, 12.0, 12, 12.56789, 1.256789, 1.5, 0, 0.1256789,0.01256789,0.001256789,0.0001256789, ]
+    test.each do |t|
+      see_print t.to_s.rjust(15)
+      see_print t.significant.to_s.rjust(15)
+      see_print (t * -1).significant.to_s.rjust(15)
+      see_print "\n"
+    end
+    
+    
+  when :inspect_see #------------------------------------------------------------------------    
+    
+    test = [7213541, 553337, 12567.89, 1256.789, 123.56789, 100.01, 100.0, 99.9, 12.0, 12, 12.56789, 1.256789, 1.5, 0, 0.1256789,0.01256789,0.001256789,0.0001256789, ]
+    test.each do |t|
+      t = t*-1    
+      see_print t.to_s.rjust(15) +      ' ########'     + t.to_f.inspect_see + "########\n"  
+      t = t*-1
+      see_print t.to_s.rjust(15) +      ' ########'     + t.to_f.inspect_see + "########\n"  
+    end    
+    
+  when :tests #------------------------------------------------------------------------------     
+  
+    require File.join(File.dirname(__FILE__), '..', '..', 'test', 'test_numeric' )     
+    
+    
+  else #--------------------------------------------------------------------------------------
+  
+    see '$run einstellen!'
+    
+  
+  end # case
+end # if
+
+
+
+
+ 
+
+
+    
+    
+    
+    
+    
+    
+    
+    
+    

data/lib/perception/perception_main.rb

@@ -0,0 +1,317 @@
+
+require File.join(File.dirname(__FILE__), '..', 'perception' )  if $0 == __FILE__ 
+
+require 'kyanite/array/array'
+require 'kyanite/enumerable/structure'   # Methode contentclass
+
+# Get auto-intended output on your console without any configuration,
+# temporary prints, printing two items in one line without destroying the structure. 
+# Optionally slows down printing to readable speed, depending on the complexity of the output.
+
+
+
+  
+
+# Perception: Human perceptible printouts
+# ========================================
+#
+# Welcome to Perception. It's a intuitive toolkit for simple everyday debugging. 
+# Perception offers a powerfull replacement for print, puts and pp.
+# You get auto-intended and structured output on your console without any configuration.
+# Perception also offers temporary printouts (overwritten by the next print),
+# printing two informations in one line without destroying the structure and
+# optionally slows down printing to readable speed, depending on the complexity of the output.
+#
+module Perception #:nodoc
+  
+  # Eine SeeSession-Instanz entspricht einer Session mit der Konsole.
+  class SeeSession  
+    
+    # Turns automatic indention ON. 
+    def indent!
+      @indent           = true
+      @level            = SEE_LEVEL_START
+      @call_stack_last  = 0
+      @call_stack_now   = 0 
+      nil      
+    end
+    
+    
+    # Turns automatic indention OFF.    
+    def left!
+      @indent           = false
+      @level            = SEE_LEVEL_START
+      @call_stack_last  = 0
+      @call_stack_now   = 0 
+      nil
+    end    
+
+    
+    # Undos the last print. 
+    # Note: Indention will get lost.
+    def clear!     
+      return if @cursor_now <= SEE_TAB_WIDTH * @level    
+      return if @string_last.empty?
+      return unless @out.include?(:console)
+      self.wait!('')                   if @speed
+      printout(  ("\b" * @string_last.size) + (" " * @string_last.size) + ("\b" * @string_last.size),     @string_last.size  )
+      @string_last      = ''  
+      @method_last      = nil      
+      @time_last        = Time.now         
+      @delayed_newlines = 0   
+      @delayed_clear    = false  
+      nil
+    end  
+    
+    
+    # Marks the last print as temporary.
+    # The following print will overwrite it. 
+    # Note: Indention will get lost.    
+    def temp! 
+      @delayed_clear = true   
+      nil
+    end        
+  
+    
+    # Slows down output to readable speed. 
+    # The speed depends on the length and the complexity of the printing.
+    # You can adjust the speed with the parameter:
+    # * slow! 1    -->  same as slow!
+    # * slow! 2    -->  slow, but double speed
+    # * slow! 0.5  -->  even slower 
+    # * slow! nil  -->  full speed (same as fast!)
+    def slow!(speed=1)
+      @speed = speed  
+      nil
+    end  
+
+    
+    # Adjusts printing speed to full speed.
+    # This is used after slow!
+    def fast!
+      @speed = nil 
+      nil
+    end      
+
+    
+    # Returns the time in seconds since the last #see-printout. 
+    def bench
+      return 0 unless @time_last
+      return (Time.now - @time_last)   
+    end    
+
+    
+    # Shows two informations in one line. See the demo.
+    #
+    # Via seee.flash! können zwei Informationen abwechselnd in der gleichen Zeile angezeigt werden.
+    # Das ist nützlich, wenn man bestimmte Werte anzeigen will ohne das Gesamtlayout zu zerstören.
+    # 
+    # Ohne Angabe eines Zweittextes wird der Ersttext einfach zum Blinken gebracht. Nachträglich, also wenn er schon ausgegeben ist.
+    # Das ist sehr nützlich, wenn man bestimme Werte verfolgen will.  
+    #
+    def flash!(alternativtext=' ', how_many=6)
+      string_bak = @string_last.dup
+      method_bak = @method_last    
+      method_bak = :puts         if method_bak == :pp
+      speed_bak = @speed
+      if speed_bak
+        seee.slow!(speed_bak * 0.8)
+      else
+        seee.slow!
+      end
+      how_many.times do 
+        seee.clear!
+        seee.temp!
+        process_print( alternativtext,  {:method => :print          } )
+        seee.clear!
+        process_print( string_bak, {:method => method_bak } )         
+      end
+      @speed = speed_bak 
+      return alternativtext
+    end # def
+    
+
+  end # class
+end # module
+
+
+
+
+
+class Object
+
+# ------------------------------------------------------------------------------
+#  Wrapper for SeeSession
+#  
+  
+  # Returns the SeeSession-Object. Offers the following methods: 
+  # * seee.indent!
+  # * seee.left!
+  # * seee.clear!
+  # * seee.slow!
+  # * seee.fast!
+  # * seee.temp!
+  # * seee.flash!
+  # * seee.bench
+  #
+  def seee
+    return Perception::SeeSession.instance
+  end  
+  
+  
+  # This is the main method. It prints out objects. See the demo.
+  def see(input=:kein_input, *rest)
+
+    if input == :kein_input  
+      seee.process_print( "\n", :method => :puts )
+      return ''
+    end        
+    
+    return seee.process_print( ( [input] + rest), :method => :multi )    unless rest.empty?
+    return see_puts(input)              if input.class == String
+    return see_pp(input)                if input.class == Hash
+    return see_puts(input)              unless (input.respond_to?(:compact)  ||  input.instance_variables )   # Ordinäre Objekte macht puts
+    return see_pp(input)        # Den Rest macht pp    
+                            
+  end # def
+  
+  
+  def see_each(input)
+    if self.contentclass == Array
+      see_puts '['
+      input.each {|elt| see elt} 
+      see_puts']'
+    end
+    input.each {|elt| see elt}     
+  end
+  
+
+
+  # Like see, but temporary print. 
+  # The following print will overwrite it. 
+  # Note: Indention will get lost.      
+  def see_temp(input=:kein_input)
+    if input == :kein_input  
+      seee.delayed_newlines += 1   
+      return ''
+    end          
+    see_print input
+    seee.temp!
+  end
+  
+  
+  # Shows two informations in one line. See the demo.
+  def see_flash(input=:kein_input, alternativtext=' ', times=6)
+    if input == :kein_input  
+      seee.delayed_newlines += 1   
+      return ''
+    end        
+    see_puts input
+    seee.flash!(alternativtext,times)   if input != :kein_input     
+  end
+  
+  
+  # Like see, but forces behavior like the originally puts method. 
+  # So you get a newline after every print.
+  # Note: All newlines are delayed. This offers you to undo the print.    
+  def see_puts(input=:kein_input)
+    if input == :kein_input  
+      seee.delayed_newlines += 1   
+      return ''
+    end   
+    seee.process_print( input, :method => :puts )
+  end    
+
+  
+  # Like see, but forces behavior like the originally print method.  
+  # So you have fully control over your newlines. 
+  # Note: If you use "\n", #see will indent it. See SEE_LEVEL_START.
+  def see_print(input=$_)
+    return seee.process_print( input, :method => :print )
+  end
+  
+  
+  # Like see, but forces behavior like the originally pp method.   
+  def see_pp(input=:kein_input)
+    if input == :kein_input  
+      seee.delayed_newlines += 1   
+      return ''
+    end   
+    return seee.process_print( input, :method => :pp )
+  end    
+  
+  
+
+  
+  
+
+  # Waits for you / the user to press a key.
+  # Returns the key.
+  # Display it with #{wait_for_key.chr.inspect}.
+  # Note: Indention will get lost.   
+  def wait_for_key(message='Press any key')
+    seee.clear_indent!
+    #seee.level -= 1 # Zählt nicht als Level
+    see_temp message
+    unless defined?(HighLine)
+      require 'highline/import'
+      HighLine.send(:public, :get_character)
+    end
+    input = HighLine.new
+    return input.get_character  
+  end
+  
+ 
+  # Like inspect, but uses the PrettyPrint library. 
+  # Returns the output of pp as String.    
+  def inspect_pp( wrap = 200 )
+    result = ''
+    return PPP::pp(self, result, wrap) 
+  end   
+  
+  
+  # inspect_pp with beautification 
+  def inspect_see( wrap = 200 )
+    result = ''
+    result = PPP::pp(self, result, wrap)  # normal prettyprint
+    result = PPP.beautify(result)
+    return result
+  end       
+   
+  
+    
+  
+  
+  # 
+  # def ljust(width)
+    # try_inspect = self.inspect
+  # end
+  
+
+end # class
+
+
+
+
+
+
+
+
+
+ 
+ 
+if $0 == __FILE__ then
+  require File.join(File.dirname(__FILE__), '..', '..', 'demo', 'demo_pp' )    
+  Perception::DemoSee.see_all_demos     
+
+end # if
+
+
+
+
+
+
+
+
+
+