perception 0.1.5

data/lib/perception/perception_private.rb

@@ -0,0 +1,231 @@
+
+require File.join(File.dirname(__FILE__), '..', 'perception' )  if $0 == __FILE__ 
+
+module Perception #:nodoc
+
+  
+  # Eine SeeSession-Instanz entspricht einer Session mit der Konsole.
+  class SeeSession
+    @@instance = nil
+    attr_accessor :time_last, :delayed_newlines, :level, :indent, :out
+    
+    # ------------------------------------------------------------------------------
+    #  Verwalten
+    #    
+    
+    # Liefert die eine notwendige Instanz 
+    def self.instance
+        return @@instance   if @@instance
+        @@instance = SeeSession.new
+        @@instance
+    end
+    
+    
+    def initialize
+      init
+    end
+    
+    
+    def init
+      # früher
+      @string_last        = ''                # enthält den letzten ausgegebenen String (damit man ihn löschen und wiederherstellen kann)
+      @time_last          = nil               # enthält den Zeitpunkt des letzten Prints
+      @method_last        = nil               # enthält die Methode, mit der der letzte String geprinted wurde      
+      @call_stack_last    = 0                 # Wie lang war der Stack beim letzten #see?
+
+      # jetzt
+      @speed              = nil               # nil = unverzögert, 1= lesbar, 2 = lesbar / doppelt so schnell, 0.5 = lesbar / halb so schnell 
+      @cursor_now         = 0                 # enthält die aktuelle Position des Cursors 
+      @method_now         = nil               # mit welcher Methode wird der aktuelle Print ausgeführt?     
+      @call_stack_now     = 0                 # Wie lang ist der Stack beim aktuellen #see? 
+      @indent             = SEE_INDENT_START  # sollen die Prints automatisch eingerückt werden?
+      @level              = SEE_LEVEL_START   # aktueller Einrückungslevel    
+      
+      # nächstes
+      @delayed_newlines   = 1                 # Mit wie vielen Newline-Zeichen soll der nächste Print beginnen? (Newlines werden verzögert, damit man noch löschen kann)
+      @delayed_clear      = false             # Soll der nächste Print den vorhergehenden überschreiben? 
+      
+      @logger             = nil               # wird erst bei Bedarf erzeugt
+      @out                = Set.new           # Wohin geht der Output? , :log
+      @out << :console    
+    end
+    
+
+    
+    
+    
+    
+    # ------------------------------------------------------------------------------
+    #  Ausgeben
+    #      
+    
+    def wait!(string_akt)
+      return unless @time_last 
+      verstrichene_zeit = Time.now - @time_last   
+      alter_string = @string_last.strip.chomp.scan(/\w+/)
+      neuer_string = string_akt.strip.chomp.scan(/\w+/)
+      differenz_information = Math.sqrt((alter_string - neuer_string).size + 0.3 )
+      time_for_perception = (differenz_information * SEE_PERCEPTION_TIME_PER_WORD * @speed ) / 1000
+      if verstrichene_zeit  < time_for_perception
+        sleep (time_for_perception - verstrichene_zeit)
+      end
+      nil
+    end # wait
+    
+    
+    def adjust_level
+      @call_stack_now   = caller.size 
+      call_stack_diff = @call_stack_now - @call_stack_last
+      # puts "call_stack_diff=#{ call_stack_diff }"
+      # puts    
+      if @indent 
+        if    call_stack_diff > 0  &&  @call_stack_last != 0
+          @level += 1 
+        elsif call_stack_diff < 0  &&  @level > 1
+          @level -= 1      
+        end
+      end  
+      nil
+    end
+    
+    
+    def clear_indent!
+      @call_stack_last  = 0      # wie direkt nach der Initialisierung 
+      @call_stack_now   = 0       
+      @level            = SEE_LEVEL_START 
+      nil
+    end
+    
+
+
+    
+    
+    # Gibt das see aus
+    def process_print( input, options={} )
+    
+      # vorbereiten
+      @method_now       = options[:method]  || :puts    
+      self.clear!                    if @delayed_clear       
+      self.adjust_level
+      newlines = self.process_newline           if @delayed_newlines > 0
+      
+      # ausgeben
+      case @method_now
+      
+        when :puts
+          result = input.inspect_or_to_s    
+          self.wait!(result)          if @speed
+          printout(result)            
+          @delayed_newlines += 1      # das newline wird erst später eingefügt  
+          
+        when :pp
+          result = input.inspect_see
+          self.wait!(result)          if @speed
+          printout(result)    
+          @delayed_newlines += 1      # und das newline später eingefügt         
+      
+        when :print  
+          result = input.inspect_or_to_s   
+          self.wait!(result)          if @speed
+          printout(result)   
+          
+        when :multi
+          result = ''
+          result = PPP::pp(input, result, 200)  # normal prettyprint
+          result = PPP.beautify_multi(result)  
+          self.wait!(result)          if @speed
+          printout(result)    
+          @delayed_newlines += 1      # und das newline später eingefügt              
+
+      end # case
+        
+      # verwalten
+      @string_last      = result.dup  
+      @time_last        = Time.now       
+      @method_last      = @method_now
+      @call_stack_last  = @call_stack_now
+      return (newlines ||'') + result
+    end # def
+    
+    
+    # Führt die aufgeschobenen Newlines aus. Ohne Berücksichtigung der Zeit.
+    def process_newline    
+      result = "\n" * @delayed_newlines     
+      self.clear!                    if @delayed_clear 
+      printout(result)
+      @delayed_newlines = 0    
+      return result
+    end    
+    
+    
+    def printout(string, backward=nil)
+      if @out.include?(:console)
+        spacer = (' '*SEE_TAB_WIDTH * @level)
+        outputstring = string.gsub(/\n/,    ("\n" + spacer)   )      
+        Kernel.print(spacer)          if @cursor_now == 0      
+        Kernel.print(outputstring) 
+      end
+      if @out.include?(:log)
+        # spacer = seee.bench.inspect_see + (' '*SEE_TAB_WIDTH * @level) + '       '
+        spacer = ''      
+        outputstring = string.gsub(/\n/,    ("\n" + spacer)   )      
+        logger << (spacer)          if @cursor_now == 0      
+        logger << (outputstring)   
+      end
+      
+      # TODO: \n berücksichtigen
+      unless backward
+        @cursor_now += outputstring.size 
+      else
+        @cursor_now -= backward  
+      end
+    end
+    
+
+
+
+  end # class
+
+
+
+
+
+
+
+end # module
+
+
+class Object
+  
+  # Liefert entweder inspect oder to_s, je nach Klassenzugehörigkeit
+  # Explizite Typabfrage ohne duck typing!
+  def inspect_or_to_s
+    return 'empty'            if self == ''
+    return self.to_s          if self.class == String
+    return self.inspect_see   if self.class == Time
+    return self.inspect_see   if self.kind_of?(Numeric)
+    return self.inspect_see   if self.kind_of?(Set)
+    return self.inspect
+  end
+
+end # class
+
+
+
+
+
+
+ 
+ 
+# -----------------------------------------------------------------------------------------
+#  ausprobieren
+#
+if $0 == __FILE__ then
+
+  require File.join(File.dirname(__FILE__), '..', '..', 'demo', 'demo_pp' )    
+  Perception::DemoSee.see_all_demos     
+
+end # if
+
+
+  

data/lib/perception/ppp.rb

@@ -0,0 +1,377 @@
+
+require File.join(File.dirname(__FILE__), '..', 'perception' )  if $0 == __FILE__ 
+
+class PPP < PP
+
+
+  # ------------------------------------------------------------------------------
+  #  
+  #   
+
+  def self.pp(obj, out=$>, width=79 )
+    q = PPP.new(out, width, "\n")
+    q.guard_inspect_key {q.pp(obj)}
+    q.flush
+    #$pp = q
+    out
+  end  
+  
+  # sorgt dafür, dass Listen länger als 3 Elemente untereinander ausgegeben werden
+  def seplist(list, sep=nil, iter_method=:each) # :yield: element
+    sep = lambda { comma_newline }   if (sep.kind_of?(Integer)  &&  list.size > sep )
+    sep = lambda { comma_breakable } if (sep.nil? || sep.kind_of?(Integer))
+    first = true
+    list.__send__(iter_method) {|*v|
+      if first
+        first = false
+      else
+        sep.call
+      end
+      yield(*v)
+    }
+  end
+    
+  def comma_newline
+    text ","
+    breakable('',9999)   
+  end    
+
+  
+  # Hashes mit mehr als drei Keys werden untereinander dargestellt
+  def pp_hash(obj)
+    group(1, '{', '}') {
+      seplist(obj, 3, :each_pair) {|k, v|
+        group {
+          pp k
+          text '=>'
+          group(1) {
+            breakable ''
+            pp v
+          }
+        }
+      }
+    }
+  end  
+  
+  
+  
+  
+  # ------------------------------------------------------------------------------
+  #  
+  #     
+  
+
+  
+  
+  # Nachbearbeitung des PrettyPrint-Results
+  def self.beautify(string)
+    begin
+      result = string# .gsub!("`","'")
+      result = beautify_focus_level1(result)
+      case classify_structure(string)
+        when :object      then  result = beautify_object(result)        
+        when :hash        then  result = beautify_hash(result)             
+        when :array_1dim  then  result = beautify_array_1dim(result)      
+        when :array_2dim  then  result = beautify_array_2dim(result)    
+      end  
+      return result
+    # rescue
+      # return string
+    end
+  end # def
+  
+  
+  # Klassifiziert die Struktur eines Objektes für die Ausgabe
+  def self.classify_structure(object)
+  
+    # Hash
+    return :hash  if object =~ /^\{.*=>.*\}/m     
+    
+    # Object
+    return :object  if object =~ /^#<.*>$/m       
+  
+    # Eindimensionales Array
+    # oder Objekt, das sich wie ein Array ausdruckt -- vor der eckigen Klammer ist ein Identifier erlaubt, z.B. WP[ 1, 2, 3]  
+    return :array_1dim  if object =~ /^[A-Z_0-9a-z]{0,30}\[[^\[].*[^\]]\]$/m 
+    
+    # Zweidimensionales Array
+    # Anfang prüfen: Zwei eckige Klammern auf, danach keine eckige Klammer auf
+    # oder alternativ ein Text zwischen den beiden Klammern auf
+    return :array_2dim  if object =~ /^\[[A-Z_0-9a-z]{0,30}\[[^\[]/m
+    #return self unless object =~ /[^\]]\]\]$/   # Ende prüfen: Zwei eckige Klammern zu, davor keine eckige Klammer zu  
+       
+  end  
+  
+  
+  
+  # Level 2+ : nur noch eine Zeile  
+  # Level 3+ : komplexe Objekte zusammenkürzen  
+  def self.beautify_focus_level1(string) 
+    #return string
+    replaces = [[/\n/, ''], [/ {2,}/,' ']]
+    result = string
+    result = string.mask( :level_start => 2 ) { |s| s.mgsub(replaces)}
+    result = result.mask( :level_start => 3 ) { |s| (s =~ /@.*=.*/ ? '' : s) } 
+    return result
+  end  
+  
+  
+  
+  # Object
+  def self.beautify_object(string) 
+    result = string
+    result.gsub!(/= *\n */m, '=' )  # unnötigen Zeilenumbruch vermeiden
+    result = result.mask( :level_start  => 1, 
+                          :level_end    => 1,
+                          :pattern      => /</  ) { |s| s.gsub(/=/, ' = ')} 
+    replaces = [ [/ @/, '  @'], [/= #/,'=#'] ]  # Unterobjekte formatieren
+    result = result.mask( :level_start  => 2, 
+                          :level_end    => 2 ) { |s| s.mgsub(replaces)}    
+    result = result.mask( :level_start  => 4 ) { |s| ''}    
+
+    tabstops = result.analyze_columns(  :level_start  => 0,     
+                                        :level_end    => 0,
+                                        :search       => '=' )  || [25]
+    tabstops2 = []
+    tabstops2 << tabstops[0] 
+    tabstops2 << tabstops[0] + 5
+
+    result = result.spread( :level_start  => 1,     
+                            :level_end    => 1,
+                            :search       => /=[^>=]/,
+                            :position_add => 1,            # alle '=' links                              
+                            :tabstops     => tabstops2 )   
+                        
+    result
+  end
+  
+  
+  
+  # Hash
+  def self.beautify_hash(string) 
+    result = string
+    result.gsub!(/=> *\n */m, '=>' )  # unnötigen Zeilenumbruch vermeiden
+    
+    # mehrzeilige Darstellung
+    if result.include?("\n")
+      result = string.mask( :level_start => 1, 
+                            :level_end   => 1,
+                            :pattern     => /\{/ ) { |s| s.gsub(/=>/, ' =>')}
+      
+      # Pfeil retten    
+      result = result.mask( :level_start => 2,
+                            :pattern     => /\{/ ) { |s| s.gsub('=>', Perception::PPP_PFEIL)}     
+
+      # Unterobjekte formatieren 
+      replaces = [ [/, /,',  '] ]     
+      result = result.mask( :level_start => 2,
+                            :level_end   => 2 ) { |s| s.mgsub(replaces)}                               
+      
+      # Tiefere Level retten
+      result = result.mask( :level_start    => 1,  
+                            :with_brackets  => true,
+                            :pattern        => /\{/ 
+                          ) { |s| s.tr(Perception::PPP_TR_ARRAY_P[0..5], Perception::PPP_TR_ARRAY_Q)}   
+
+      tabstops = result.analyze_columns(  :level_start  => 0,     
+                                          :level_end    => 0,
+                                          :search       => '='   )  || [25]
+      tabstops2 = []
+      tabstops2 << tabstops[0] + 1
+      tabstops2 << tabstops[0] + 5
+      
+      # ausrichten
+      result = result.spread( :level_start  => 1,     
+                              :level_end    => 1,
+                              :search       => /=>/,
+                              :position_add => 0,      # alle '=>' übereinander  
+                              :tabstops     => tabstops2 )   
+      result.gsub!('=>','=>  ')
+
+      # Tiefere Level zurück
+      result = result.mask( :level_start    => 1, 
+                            :with_brackets  => true,                             
+                            :pattern        => /\{/  
+                          ) { |s| s.tr(Perception::PPP_TR_ARRAY_Q, Perception::PPP_TR_ARRAY_R)}  
+
+      # Pfeil zurück
+      result = result.mask( :level_start => 2,
+                            :pattern     => /\{/ )  { |s| s.gsub(Perception::PPP_PFEIL, '=>')}       
+      
+          
+
+    # einzeilige Darstellung
+    else
+      result = string.mask( :level_start => 1, 
+                            :level_end   => 1,
+                            :pattern     => /\{/ ) { |s| s.gsub(/, /, ',  ')}
+      
+    end
+
+    result
+  end      
+  
+  
+  
+  # Eindimensionales Array
+  # oder Objekt, das sich wie ein Array ausdruckt -- vor der eckigen Klammer ist ein Identifier erlaubt, z.B. WP[ 1, 2, 3]   
+  def self.beautify_array_1dim(string) 
+    return string
+    # tabstops = result[1..-2].analyze_columns( :level_start  => 0,     
+                                              # :level_end    => 0,
+                                              # :search       => ',',
+                                              # :stretch      => 0  )   
+    # tabstops = [25]   if tabstops.empty?
+    # maxtab = tabstops.sort[-1]    
+
+
+    # result = result.spread( :level_start  => 1,     
+                            # :level_end    => 1,
+                            # :tabstops     => (1..10).collect {|i| i * (maxtab+1)},
+                            # :search       => ',',
+                            # :position_add => 1 )
+  end      
+  
+  
+  
+  # Zweidimensionales Array  
+  # very hackish
+  def self.beautify_array_2dim(string) 
+    result = string
+
+    # Komma retten
+    result = result.mask( :level_start => 3,
+                          :pattern     => /['"({<\[]/
+                        ) { |s| s.tr(',', Perception::PPP_KOMMA)} 
+    
+    # Tiefere Level retten
+    result = result.mask( :level_start    => 2,  
+                          :with_brackets  => true,                           
+                          :pattern        => /\[/ 
+                        ) { |s| s.tr(Perception::PPP_TR_ARRAY_P, Perception::PPP_TR_ARRAY_Q)}
+    
+    # zeilenweise 
+    replaces = [[/,[^\n]/, ", \n "]]
+    result = result.mask( :level_start => 1, 
+                          :level_end   => 1, 
+                          :pattern     => /\[/ 
+                        ) { |s| s.mgsub(replaces)}       
+
+    # Tabstops 
+    tabstops = result[1..-2].analyze_columns( :level_start  => 1,     
+                                              :level_end    => 1,
+                                              :search       => ',',
+                                              :stretch      => 1  )   || [25]    
+    tabstops2 = []   
+    tabstops.each do |t|
+      tabstops2 << t + (tabstops2[-1]||0)      
+    end
+
+    # ausrichten
+    result = result.spread(  :level_start => 2,     
+                             :level_end   => 2,
+                             :tabstops    => tabstops2,
+                             :search      => /,/   )      
+
+    # Tiefere Level zurück
+    result = result.mask( :level_start    => 2, 
+                          :with_brackets  => true,                           
+                          :pattern        => /\[/  
+                        ) { |s| s.tr(Perception::PPP_TR_ARRAY_Q, Perception::PPP_TR_ARRAY_R)}    
+
+    #Komma zurück
+    result = result.mask( :level_start => 3,
+                          :pattern     => /['"({<\[]/
+                        ) { |s| s.gsub(Perception::PPP_KOMMA, ',')} 
+    
+    return result    
+
+  end        
+  
+  
+  # Mehrere Ausgaben in einer Zeile.
+  # Die einzelnen Ausgaben liegen als Array vor.
+  # Das Ergebnis soll aber nicht wie ein Array ausssehen.
+  def self.beautify_multi(string)
+    result = string
+    result = beautify_focus_level1(result)    
+    result = result.mask(     :level_start    => 1,
+                              :level_end      => 1,
+                              :pattern     => /\[/                               
+                        ) {|s| s.tr(',', Perception::PPP_KOMMA)}      
+    result = result.spread_line( [25], Perception::PPP_KOMMA, 0 )
+    
+    # Äußeres Array entfernen
+    result = result.tr(Perception::PPP_TR_ALL,'')
+    result = result.mask(     :with_brackets  => true,
+                              :level_start    => 0,
+                              :level_end      => 0,
+                              :pattern     => /\[/                                 
+                        ) {|s| s.tr('[]','')}          
+    return result
+  end # def  
+  
+  
+      
+  
+  
+  
+
+end # class
+
+
+class String
+  def pretty_print(q)
+    q.text "'#{self}'"
+  end
+end
+
+class Set
+  def pretty_print(q)
+    q.group(1, '{', '}') {
+      q.seplist(self) {|v|
+        q.pp v
+      }
+    }
+  end
+
+  def pretty_print_cycle(q)
+    q.text(empty? ? '{}' : '{...}')
+  end
+end
+
+
+class Dictionary
+  def inspect
+    ary = []
+    each {|k,v| ary << k.inspect + "=>" + v.inspect}
+    '{' + ary.join(", ") + '}'
+  end
+end
+
+
+class Dictionary
+  def pretty_print(q)
+    q.pp_hash self
+  end
+
+  def pretty_print_cycle(q)
+    q.text(empty? ? '{}' : '{...}')
+  end
+end
+
+
+
+
+
+
+
+
+# -----------------------------------------------------------------------------------------
+#  Tests
+#
+if $0 == __FILE__ then
+
+  require File.join(File.dirname(__FILE__), '..', '..', 'test', 'test_ppp' )     
+
+end # if