perception 0.1.5

data/lib/perception/string_spread.rb

@@ -0,0 +1,155 @@
+
+require 'perception'      if $0 == __FILE__ 
+require 'kyanite/array_of_enumerables'
+
+
+module Perception #:nodoc
+  module StringSpreadI #:nodoc
+  
+
+  def analyze_columns(options={})
+  
+    # vorbereiten
+    stretch =       options[:stretch]       || 1    # soviel wird zu jedem Tabstop hinzuaddiert  
+  
+    # mehrzeilige Darstellung
+    if self.include?("\n")  
+      result = ArrayOfEnumerables.new
+      self.split("\n").each do |zeile|
+        # print zeile.inspect_pp
+        # print zeile.analyze_columns(options).inspect_pp
+        # print "\n"
+        result << zeile.analyze_columns(options)
+      end
+      result.compact!
+      result = result.rectangle 
+      result.transpose!
+      #pp result
+      result2 = result.collect { |spalte| (spalte.sort[-1]) + stretch}
+      #pp result2
+      return result2
+     
+    
+    
+    # einzeilig   -- TODO: Fehler beheben
+    else
+
+      # weiter vorbereiten
+      level_start =   options[:level_start]   || 1
+      level_end =     options[:level_end]     || 1
+      search =        options[:search]        || ','
+
+      # funktioniert nicht 100%ig. Fehler bei einem mehrzeiligen Hash, dessen Values Gleichheitszeichen enthalten.
+      # Hier verhindert wahrscheinlich die erste Zeile die Maskierung des Gleichheitszeichens -- sie enthält die {-Klammer.       
+      result = self.mask(   :level_start => level_start,
+                            :level_end   => level_end                     
+                          ) {|s| s.tr(search, Perception::PPP_SEARCH)}     
+      #pp result.split(Perception::PPP_SEARCH)
+      
+      result = result.split(Perception::PPP_SEARCH).collect {|e| e.strip.size + stretch}    
+      return result     if result.size > 1
+      return nil
+      
+    end # if Rekursion
+  end # def    
+  
+  
+  
+  # Erzwingt ein bestimmtes Zeichen nur an Tabstop-Positionen
+  # Mit position_add= 0 werden die Spaces vor dem gefundenen Zeichen eingefügt.
+  # Standard ist position_add= search.size, damit werden die Spaces hinter den gefundenen Zeichen eingefügt.    
+  # Mit PPP_ANTI_NEWLINE werden Zeilen markiert, bei denen anschließend noch das \n entfernt werden kann.
+  def spread_line(tabstops=[], search=/,/, position_add=nil, start=0)
+    #puts "spread_line, self=#{self.inspect_pp} tabstops=#{tabstops.join('-')}"
+    position_add = search.inspect.size-2       unless position_add
+    leading_spaces = self.size - self.lstrip.size
+    
+    
+    # das auszurichtende Zeichen finden
+    pos_found = self.index(search, start) 
+    return self if pos_found.nil?
+    anti_newline = (self[pos_found+position_add..-1].strip == '' ?  PPP_ANTI_NEWLINE  :  '')
+
+    
+    # Tabstops bestimmen: Modus feste Tabstops  
+    if tabstops.size > 1                    
+      pos_shift = 0    
+      tabstops.each do |ts|
+        if ts >= pos_found
+          pos_shift = ts        + leading_spaces
+          break
+        end
+      end # do     
+    end # modus
+    
+    # Tabstops bestimmen: Modus "Tabstop alle n Zeichen"  bzw. Fallback, wenn feste Tabstops nicht ausreichend waren
+    if (tabstops.size == 1  ||  pos_shift == 0  )
+      pos_shift = ((pos_found/tabstops[0]) + 1) * tabstops[0]   + leading_spaces
+    end # if modus
+    
+    # Tabstops einfügen
+    if pos_found < pos_shift
+      self.insert(pos_found+position_add, (' '*(pos_shift - pos_found - 1)) + anti_newline )
+    end
+    spread_line(tabstops, search, position_add, pos_shift + 1)  
+  end # def   
+  
+  
+  
+  def spread(options={})
+    # vorbereiten
+    level_start =   options[:level_start]   || 1
+    level_end =     options[:level_end]     || 1
+    search =        options[:search]        || '='
+    tabstops =      options[:tabstops]    
+    position_add =  options[:position_add]   # Mit position_add= 0 werden die Spaces vor dem gefundenen Zeichen eingefügt.
+                                             # Standard ist position_add= search.size, damit werden die Spaces hinter den gefundenen Zeichen eingefügt.    
+    return self       if tabstops.empty?  
+
+    # Spalte ausrichten
+    self.mask( :level_start => level_start,
+               :level_end   => level_end
+           #    :with_brackets => true  
+               ) { |s|     
+      s_neu = s.split("\n").collect do | zeile | 
+        zeile.spread_line(tabstops, search, position_add)
+      end.join("\n")
+      replaces = [[/\x1F\n */ ,''],[/\x1F */ ,' ']]  # PPP_ANTI_NEWLINE = 31.chr
+      s_neu.mgsub(replaces)
+    } # mask    
+  end # def  
+
+ 
+
+  end # module
+end # module
+
+class String #:nodoc:
+  include Perception::StringSpreadI
+end
+
+
+
+
+
+# -----------------------------------------------------------------------------------------
+#  ausprobieren
+#
+if $0 == __FILE__ then
+
+  # require File.join(File.dirname(__FILE__), '..', '..', 'demo', 'demo_pp' )    
+  # Perception::DemoSee.see_all_demos     
+  
+  require 'rbconfig'
+  require 'facets/to_hash'
+
+
+  include Config
+  see CONFIG.to_a[0..-1].to_h  
+  #see CONFIG.to_a[1..5].to_h  
+
+end # if
+
+
+
+

data/lib/perception/test.rb

@@ -0,0 +1,114 @@
+
+require 'test/unit/util/backtracefilter'
+require 'kyanite/general/kernel'
+
+module Perception
+  module BacktraceFilter
+  
+        CALLER_RE = /(.*):([0-9]+)(:in \`(.*)')?/
+        def parse_caller( input )
+          input.collect do |c|
+            captures = CALLER_RE.match(c)
+            [captures[1], captures[2], captures[4]]
+          end
+        end
+        
+        def parse_test_name( input )
+          test_full_name = input.split('(')
+          test_class     = test_full_name[1][0..-2]
+          test_method    = test_full_name[0]
+          [test_class, test_method]
+        end
+
+  
+        def filter_backtrace_perception(backtrace, header)
+          result = filter_backtrace(backtrace, nil)
+          result = result.collect { |zeile| zeile.gsub(RUBYDIR,'RUBYDIR').gsub($0, "###  #{$0}" ) }
+          result = parse_caller(result).collect {  |file, line, method| 
+            [ File.dirname(file), 
+              File.basename(file), 
+              line,
+              method ] unless method =~ /^assert_/
+          }
+          result.compact!
+          result.unshift header                    if header 
+        # result.unshift %w{DIR FILE METHOD LINE}  unless result.size == 1
+          result = result.inspect_see.
+            mask( :with_brackets  => true,
+                  :level_start    => 0,
+                  :level_end      => 1,
+                  :pattern     => /\[/                                 
+                ) {|s| s.tr('[]',' ')}  
+
+          result = result.
+            mask( :with_brackets  => true,
+                  :level_start    => 0,
+                  :level_end      => 1,
+                  :pattern     => /\'/                                 
+                ) {|s| s.tr("',",' ')}  
+                
+          result 
+        end 
+  
+ end
+end
+  
+
+module Test
+  module Unit
+  
+  
+    class Error
+      include Perception::BacktraceFilter
+      def long_display
+        test_class, test_method = parse_test_name(@test_name)      
+        header = ['', test_class, '', '']
+        backtrace = filter_backtrace_perception(@exception.backtrace, header) 
+        "Error:    #{message.tr("`","'")}\n#{backtrace}\n\n\n\n"
+      end      
+    end # class
+    
+    
+    class Failure
+      include Perception::BacktraceFilter    
+      include Util::BacktraceFilter    
+      def long_display
+        test_class, test_method = parse_test_name(@test_name)     
+        header = ['', test_class, '', '']     
+        backtrace = filter_backtrace_perception(location, header)      
+        "Failure:  #{message.tr("`","'")}\n#{backtrace}\n\n\n\n"
+      end    
+    end # class
+  
+  
+  end
+end    
+      
+      
+      
+      
+
+module Perception
+  module Assertions  
+   
+    def assert_equal(expected, actual, message=nil)
+      if expected.kind_of?(Float)  &&  actual.kind_of?(Float)   
+        full_message = build_message(message, "<?> with some delta expected but was\n#{' '*15}<?>\n", expected, actual)
+        delta = 0.0000000000001
+        assert_block(full_message) { (expected - actual).abs <= delta }      
+      else
+        full_message = build_message(message, "<?> expected but was\n#{' '*15}<?>\n", expected, actual)
+        assert_block(full_message) { expected == actual }    
+      end
+    end  
+    
+  end
+end          
+
+module Test
+  module Unit
+    class TestCase
+      include Perception::Assertions
+    end
+  end
+end           

data/lib/perception.rb

@@ -0,0 +1,36 @@
+
+if $:.include?(File.dirname(__FILE__))  ||  $:.include?(File.expand_path(File.dirname(__FILE__)))
+  # puts 'Path schon aktuell'
+else
+  $:.unshift(File.dirname(__FILE__)) 
+end
+
+
+# Die Versionsnummer steht ausserdem 
+#   * im Script '2 install gem.bat'
+#   * in der gem-Verkn�pfung
+module Perception
+  VERSION = '0.1.5'
+end
+
+
+
+$KCODE = 'UTF8'
+require 'pp'
+require 'set'
+require 'kyanite/string/mgsub'
+require 'kyanite/string/nested'
+require 'kyanite/general/callerutils'
+require 'kyanite/array/array'
+
+
+require 'perception/const' 
+require 'perception/perception_private'        
+require 'perception/perception_main'   
+require 'perception/ppp' 
+require 'perception/test' 
+require 'perception/string_spread' 
+require 'perception/numeric' 
+require 'perception/date_and_time' 
+require 'perception/logging' 
+ 

data/test/_start_all.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# 
+#	Führt alle Tests aus
+#
+
+
+	# Test-Verzeichnis der Applikation
+	test_verzeichnis = File.expand_path(File.dirname(__FILE__) )    
+    
+	Dir["#{test_verzeichnis}/test_*.rb"].sort.each { |t| require t }

data/test/test_date_and_time.rb

@@ -0,0 +1,54 @@
+
+require 'kyanite/unit_test'
+require 'perception'
+
+class TestPerceptionDateAndTime < UnitTest
+
+  def setup
+    seee.init  
+    seee.out = []
+  end
+
+  
+  def test_010_time_inspect
+    test = Time.at(1296702800) 
+    assert_equal '2011-02-03 Thursday 04:13:20',    test.inspect_pp
+    assert_equal '2011-02-03 Thursday 04:13:20',    test.inspect_see
+    assert_equal '2011-02-03  04:13',               test.inspect_see(:precision => 1)
+    assert_equal '03.Feb.2011',                     test.inspect_see(:norm => :de, :precision => 0)
+  end
+  
+  
+  def test_020_time_see
+    test = Time.at(1296702800) 
+    assert_equal "\n2011-02-03 Thursday 04:13:20",    see_print(test)
+    setup
+    assert_equal "\n2011-02-03 Thursday 04:13:20",    see_puts(test)
+    setup 
+    assert_equal "\n2011-02-03 Thursday 04:13:20",    see_pp(test)  
+    setup
+    assert_equal "\n2011-02-03 Thursday 04:13:20",    see(test)  
+    setup     
+  end
+
+ 
+  
+  
+end # class
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/test/test_numeric.rb

@@ -0,0 +1,104 @@
+
+require 'kyanite/unit_test'
+require 'perception'
+
+
+class TestPerceptionNumeric < UnitTest
+  
+  def setup
+    seee.init  
+    seee.out = []
+  end
+  
+  
+  def test_010_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 ]
+    expect = [12600,    1260,     124,       100,    100,   99.9, 12,   12, 12.6,     1.26,     1.5, 0, 0.126,     0.0126,     0.00126,     0.000126]
+    result = test.collect { |t| t.significant }
+    assert_equal expect, result
+  end
+  
+  
+  def test_020_float_inspect
+    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, ]
+    expect =  ['7 210 000     ',
+               '  553 000     ',
+               '   12 600     ',
+               '     1260     ',
+               '      124     ',
+               '      100     ',
+               '      100     ',
+               '       99,9   ',
+               '       12     ',
+               '       12     ',
+               '       12,6   ',
+               '        1,26  ',
+               '        1,5   ',
+               '        0     ',
+               '        0,126 ',
+               '        0,0126',
+               '       0,00126',
+               '      0,000126']    
+    result= test.collect { |t| t.to_f.inspect_see }   
+    assert_equal expect, result
+    
+    result= test.collect { |t| see(t.to_f).gsub("\n",'') }      
+    assert_equal expect, result
+  end
+    
+    
+  def test_030_integer_inspect    
+    assert_equal '        0',                     0.inspect_see             
+    assert_equal '    -1000',                    -1000.inspect_see             
+    assert_equal '-87 200 000',                  -87213541.inspect_see      
+    assert_equal   '988 000 000 000 000 128',     987654321987654321.inspect_see   # Das ist falsch. Rubys Umwandlung to_i funktioniert hier nicht.
+    assert_equal '9 990 000 000 000 000 000',    9987654321987654321.inspect_see   # Das ist wieder richtig.
+  end  
+  
+  
+  def test_040_see
+    test   = 0
+    result = '        0' 
+    assert_equal "\n" + result,              see(test);        setup
+    assert_equal "\n" + result,              see_pp(test);     setup
+    assert_equal "\n" + result,              see_puts(test);   setup
+    assert_equal "\n" + result,              see_print(test);  setup      
+    assert_equal "\n" + result,              see_print(test);  setup      
+    
+    test   = 9987654321987654321
+    result = '9 990 000 000 000 000 000'    
+    assert_equal "\n" + result,              see(test);        setup
+    assert_equal "\n" + result,              see_pp(test);     setup
+    assert_equal "\n" + result,              see_puts(test);   setup
+    assert_equal "\n" + result,              see_print(test);  setup       
+    assert_equal "\n" + result,              see_print(test);  setup       
+
+    test   = -0.000314162353463463136537846595
+    result = '     -0,000314'
+    assert_equal "\n" + result,              see(test);        setup
+    assert_equal "\n" + result,              see_pp(test);     setup
+    assert_equal "\n" + result,              see_puts(test);   setup
+    assert_equal "\n" + result,              see_print(test);  setup       
+    assert_equal "\n" + result,              see_print(test);  setup       
+  end
+ 
+  
+  
+end # class
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+