geminfo 0.1.0

data/path/gems/win32console-1.3.2-x86-mingw32/extra/Console_ANSI.rdoc

@@ -0,0 +1,302 @@
+#  
+#  = NAME
+#  
+#  Win32::Console::ANSI - Ruby extension to emulate ANSI console on Win32 system.
+#  
+#  = SYNOPSIS
+#  
+#    require "Win32::Console::ANSI"
+#  
+#    puts "\e[1;34mThis text is bold blue.\e[0m"
+#    puts "This text is normal.""
+#    puts "\e[33;45;1mBold yellow on magenta.\e[0m"
+#    puts "This text is normal."
+#  
+#  With the Term::ANSIColor module one increases the readability:
+#  
+#    require "Win32::Console::ANSI"
+#    require "Term::ANSIColor"
+#  
+#    puts color 'bold blue'
+#    puts "This text is bold blue."
+#    puts color 'reset'
+#    puts "This text is normal."
+#    puts colored ("Bold yellow on magenta.", 'bold yellow on_magenta')
+#    puts "This text is normal."
+#  
+#  And even more with Term::ANSIScreen:
+#  
+#    require "Win32::Console::ANSI;
+#    require "Term::ANSIScreen qw/:color :cursor :screen/;
+#  
+#    locate 1, 1; puts "@ This is (1,1)", savepos;
+#    puts locate(24,60), "@ This is (24,60)"; loadpos;
+#    puts down(2), clline, "@ This is (3,16)";
+#    setscroll 1, 20;
+#    color 'black on white'; clline;
+#    puts "This line is black on white.";
+#    puts color 'reset'; puts "This text is normal.";
+#    puts colored ("This text is bold blue.", 'bold blue');
+#    puts "This text is normal.";
+#    puts colored ['bold blue'], "This text is bold blue.";
+#    puts "This text is normal.";
+#  
+#  = DESCRIPTION
+#  
+#  Windows NT/2000/XP does not support ANSI escape sequences in Win32 Console
+#  applications. This module emulates an ANSI console for the script which
+#  uses it.
+#  
+#  
+#  == Escape sequences for Cursor Movement
+#  
+#     * \e[#A
+#  
+#       CUU: CUrsor Up: Moves the cursor up by the specified number of lines without
+#       changing columns. If the cursor is already on the top line, this sequence
+#       is ignored. \e[A is equivalent to \e[1A.
+#  
+#     * \e[#B
+#  
+#       CUD: CUrsor Down: Moves the cursor down by the specified number of lines
+#       without changing columns. If the cursor is already on the bottom line,
+#       this sequence is ignored. \e[B is equivalent to \e[1B.
+#  
+#     * \e[#C
+#  
+#       CUF: CUrsor Forward: Moves the cursor forward by the specified number of
+#       columns without changing lines. If the cursor is already in the
+#       rightmost column, this sequence is ignored. \e[C is equivalent to \e[1C.
+#  
+#     * \e[#D
+#  
+#        CUB: CUrsor Backward: Moves the cursor back by the specified number of
+#        columns without changing lines. If the cursor is already in the leftmost
+#        column, this sequence is ignored. \e[D is equivalent to \e[1D.
+#  
+#     * \e[#E
+#  
+#        CNL: Cursor Next Line: Moves the cursor down the indicated # of rows, to
+#        column 1. \e[E is equivalent to \e[1E.
+#  
+#     * \e[#F
+#  
+#        CPL: Cursor Preceding Line: Moves the cursor up the indicated # of rows,
+#        to column 1. \e[F is equivalent to \e[1F.
+#  
+#     * \e[#G
+#  
+#        CHA: Cursor Horizontal Absolute: Moves the cursor to indicated column in
+#        current row. \e[G is equivalent to \e[1G.
+#  
+#     * \e[#;#H
+#  
+#        CUP: CUrsor Position: Moves the cursor to the specified position. The first #
+#        specifies the line number, the second # specifies the column.
+#        If you do not specify a position, the cursor moves to the
+#        home position: the upper-left corner of the screen (line 1, column 1).
+#  
+#     * \e[#;#f
+#  
+#        HVP: Horizontal and Vertical Position.
+#        Works the same way as the preceding escape sequence.
+#  
+#     * \e[s
+#  
+#        SCP: Save Cursor Position: Saves the current cursor position. You can move
+#        the cursor to the saved cursor position by using the Restore Cursor
+#        Position sequence.
+#  
+#     * \e[u
+#  
+#        RCP: Restore Cursor Position: Returns the cursor to the position stored
+#        by the Save Cursor Position sequence.
+#  
+#  == Escape sequences for Display Edition
+#  
+#     * \e[#J
+#  
+#        ED: Erase Display:
+#  
+#           * \e[0J
+#  
+#              Clears the screen from cursor to end of display. The cursor position is unchanged.
+#  
+#           * \e[1J
+#  
+#              Clears the screen from start to cursor. The cursor position is unchanged.
+#  
+#            * \e[2J
+#  
+#              Clears the screen and moves the cursor to the home position (line 1, column 1).
+#  
+#         \e[J is equivalent to \e[0J. (Some terminal/emulators respond to \e[J as if
+#         it were \e[2J. Here, the default is 0; it's the norm)
+#  
+#     * \e[#K
+#  
+#        EL: Erase Line:
+#  
+#     * \e[0K
+#  
+#        Clears all characters from the cursor position to the end of the line
+#        (including the character at the cursor position).
+#        The cursor position is unchanged.
+#  
+#     * \e[1K
+#  
+#        Clears all characters from start of line to the cursor position.
+#        (including the character at the cursor position).
+#        The cursor position is unchanged.
+#  
+#     * \e[2K
+#  
+#        Clears all characters of the whole line.
+#        The cursor position is unchanged.
+#  
+#        \e[K is equivalent to \e[0K.
+#  
+#     * \e[#L
+#  
+#        IL: Insert Lines: The cursor line and all lines below it move down # lines,
+#        leaving blank space. The cursor position is unchanged. The bottommost #
+#        lines are lost. \e[L is equivalent to \e[1L.
+#  
+#     * \e[#M
+#  
+#        DL: Delete Line: The block of # lines at and below the cursor are  deleted;
+#        all  lines below  them  move up # lines to fill in the gap, leaving # blank
+#        lines at the bottom of the screen.  The cursor position is unchanged.
+#        \e[M is equivalent to \e[1M.
+#  
+#     * \e#\@
+#  
+#        ICH: Insert CHaracter: The cursor character and all characters to the right
+#        of it move right # columns, leaving behind blank space.
+#        The cursor position is unchanged. The rightmost # characters on the line are lost.
+#  
+#     * \e[#P
+#  
+#        DCH: Delete CHaracter: The block of # characters at and to the right of the
+#        cursor are deleted; all characters to the right of it move left # columns,
+#        leaving behind blank space. The cursor position is unchanged.
+#        \e[P is equivalent to \e[1P.
+#  
+#  
+#  == Escape sequences for Set Graphics Rendition
+#  
+#     * \e[#;...;#m
+#  
+#        SGM: Set Graphics Mode: Calls the graphics functions specified by the
+#        following values. These specified functions remain active until the next
+#        occurrence of this escape sequence. Graphics mode changes the colors and
+#        attributes of text (such as bold and underline) displayed on the
+#        screen.
+#  
+#        * Text attributes
+#  
+#         0    All attributes off
+#         1    Bold on
+#         4    Underscore on
+#         7    Reverse video on
+#         8    Concealed on
+#  
+#         21   Bold off
+#         24   Underscore off
+#         27   Reverse video off
+#         28   Concealed off
+#  
+#        * Foreground colors
+#  
+#         30    Black
+#         31    Red
+#         32    Green
+#         33    Yellow
+#         34    Blue
+#         35    Magenta
+#         36    Cyan
+#         37    White
+#  
+#        * Background colors
+#  
+#         40    Black
+#         41    Red
+#         42    Green
+#         43    Yellow
+#         44    Blue
+#         45    Magenta
+#         46    Cyan
+#         47    White
+#  
+#       \e[m is equivalent to \e0m.
+#  
+#  == Escape sequences for Select Character Set
+#  
+#     * \e(U
+#  
+#        Select null mapping - straight to character from the codepage of the console.
+#  
+#     * \e(K
+#  
+#        Select Windows to DOS mapping, if the corresponding map exist; no effect
+#        otherwise. This is the default mapping (if the map exist, of course). It's
+#        useful becarequire "one types the script with a Windows-based editor (using a
+#        Windows codepage) and the script prints its messages on the console using
+#        another codepage: without translation, the characters with a code greatest
+#        than 127 are different and the printed messages may be not readable.
+#  
+#        The conversion is done by the module Encode if it is installed (it's a
+#        standard module with Perl5.8, not Ruby yet). Otherwise, the conversion is limited to the
+#        following couples:
+#  
+#           WinLatin1 (cp1252)  to DOSLatin1  (cp850)
+#           WinLatin1 (cp1252)  to DOSLatinUS (cp437)
+#           WinLatin2 (cp1250)  to DOSLatin2  (cp852)
+#           WinCyrillic(cp1251) to DOSCyrillic (cp855)
+#  
+#     * \e(#X
+#  
+#        This escape sequence is I<not> standard! It's an experimental one, just for
+#        fun :-)
+#  
+#        If <i>and only if</i> the console uses an Unicode police, it is possible to
+#        change its codepage with this escape sequence. No effect with an ordinary
+#        "Raster Font". (For Windows NT/2000/XP the currently available Unicode
+#        console font is the Lucida Console TrueType font.)
+#        # is the number of the codepage needed, 855 for cp855 for instance.
+#  
+#  
+#  = LIMITATIONS
+#  
+#     * Due to DOS-console limitations, the blink mode (text attributes 5 and 25) is not implemented.
+#  
+#  = SEE ALSO
+#  
+#  <b>Win32::Console</b>, <b>Term::ANSIColor</b>, <b>Term::ANSIScreen</b>.
+#  
+#  = AUTHOR
+#  
+#  J-L Morel jl_morel@bribes.org
+#  
+#  Home page: http://www.bribes.org/perl/wANSIConsole.html
+#
+#  Gonzalo Garramu�o GGarramuno@aol.com   Ruby port
+#  
+#  = CREDITS
+#  
+#  Render unto C�sar the things which are C�sar's...
+#  
+#  This module requires the module Win32::Console. Thanks to Aldo Calpini.
+#  
+#  The method used to overload the print function is due to Matt Sergeant
+#  (see his module Win32::ASP).
+#  
+#  = COPYRIGHT
+#  
+#  Copyright (c) 2004 Gonzalo Garramu�o. All rights reserved.
+#  Copyright (c) 2003 J-L Morel. All rights reserved.
+#  
+#  This program is free software; you can redistribute it and/or modify it under
+#  the terms of the Artistic License.
+#  
+#  

data/path/gems/win32console-1.3.2-x86-mingw32/lib/Win32/Console/ANSI.rb

@@ -0,0 +1,357 @@
+# encoding: utf-8
+
+#
+# Win32::Console::ANSI
+#
+# Copyright 2004 - Gonzalo Garramuno
+# Licensed under GNU General Public License or Perl's Artistic License
+#
+# Based on Perl's Win32::Console::ANSI
+# Copyright (c) 2003 Jean-Louis Morel <jl_morel@bribes.org>
+# Licensed under GNU General Public License or Perl's Artistic License
+#
+require "Win32/Console"
+
+
+module Kernel
+
+  # Kernel#putc is equivalent to $stdout.putc, but
+  # it doesn't use $stdout.putc.  We redefine it to do that
+  # so that it will buffer the escape sequences properly.
+  # See Win32::Console::ANSI::IO#putc
+  remove_method :putc
+  def putc(int)
+    $stdout.putc(int)
+  end
+
+end
+
+module Win32
+  class Console
+    module ANSI
+
+      class IO < IO
+
+        VERSION = '0.05'
+        DEBUG = nil
+
+        require "win32/registry"
+
+        include Win32::Console::Constants
+
+        FD_STD_MAP = {
+          :stdout => [1, STD_OUTPUT_HANDLE],
+          :stderr => [2, STD_ERROR_HANDLE]
+        }
+
+        # @todo: encode is another perl module
+        EncodeOk = false
+
+        # Retrieving the codepages
+        cpANSI = nil
+        Win32::Registry::HKEY_LOCAL_MACHINE.open('SYSTEM\CurrentControlSet\Control\Nls\CodePage' ) { |reg|
+          cpANSI = reg['ACP']
+        }
+
+        STDERR.puts "Unable to read Win codepage #{cpANSI}" if DEBUG && !cpANSI
+
+
+        cpANSI = 'cp'+(cpANSI ? cpANSI : '1252')      # Windows codepage
+        OEM = Win32::Console::OutputCP()
+        cpOEM = 'cp' + OEM.to_s                       # DOS codepage
+        @@cp = cpANSI + cpOEM
+
+        STDERR.puts "EncodeOk=#{EncodeOk} cpANSI=#{cpANSI} "+
+          "cpOEM=#{cpOEM}" if DEBUG
+
+        @@color = { 30 => 0,                                               # black foreground
+              31 => FOREGROUND_RED,                                  # red foreground
+              32 => FOREGROUND_GREEN,                                # green foreground
+              33 => FOREGROUND_RED|FOREGROUND_GREEN,                 # yellow foreground
+              34 => FOREGROUND_BLUE,                                 # blue foreground
+              35 => FOREGROUND_BLUE|FOREGROUND_RED,                  # magenta foreground
+              36 => FOREGROUND_BLUE|FOREGROUND_GREEN,                # cyan foreground
+              37 => FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE, # white foreground
+              40 => 0,                                               # black background
+              41 => BACKGROUND_RED,                                  # red background
+              42 => BACKGROUND_GREEN,                                # green background
+              43 => BACKGROUND_RED|BACKGROUND_GREEN,                 # yellow background
+              44 => BACKGROUND_BLUE,                                 # blue background
+              45 => BACKGROUND_BLUE|BACKGROUND_RED,                  # magenta background
+              46 => BACKGROUND_BLUE|BACKGROUND_GREEN,                # cyan background
+              47 => BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE, # white background
+        }
+
+        def initialize(fd_std = :stdout)
+          fd, handle = FD_STD_MAP[fd_std]
+          super(fd, 'w')
+          @Out = Win32::Console.new(handle)
+          @x = @y = 0           # to save cursor position
+
+          # None of these calls will work, when we are redirected
+          unless redirected?
+            @default_foreground = @Out.DefaultForeground
+            @default_background = @Out.DefaultBackground
+            @default_bold       = @Out.DefaultBold
+            @default_underline  = @Out.DefaultUnderline
+          end
+
+          @foreground = @default_foreground
+          @background = @default_background
+          @bold       = @default_bold
+          @underline  = @default_underline
+          @revideo =
+          @concealed = nil
+          @conv = 1        # char conversion by default
+          @buffer = []
+          STDERR.puts "Console Mode=#{@Out.Mode}" if DEBUG
+        end
+
+        # this redefined #putc buffers escape sequences but passes
+        # other values to #write as normal.
+        def putc(int)
+          int = int.ord if RUBY_VERSION >= "1.9"
+          if @buffer.empty?
+            # match \e
+            unless int == 27
+              write(int.chr)
+            else
+              @buffer << int
+            end
+          else
+            @buffer << int
+            case int
+            # match m, J, L, M, @, P, A, B, C, D, E, F, G, H, f, s, u, U, K, X
+            when 109, 74, 76, 77, 64, 80, 65, 66, 67, 68, 
+                  69, 70, 71, 72, 102, 115, 117, 85, 75, 88
+              write(@buffer.pack("c*"))
+              @buffer.clear
+            end
+          end
+        end
+
+        # #write checks if $stdout is going to the console
+        # or if it's being redirected.
+        # When to the console, it passes the string to
+        # _PrintString to be parsed for escape codes.
+        #
+        # When redirected, it passes to WriteFile to allow escape
+        # codes and all to be output.  The application that is
+        # handling the redirected IO should handle coloring.
+        # For Ruby applications, this means requiring Win32Conole again.
+        def write(*s)
+          if redirected?
+            s.each{ |x| @Out.WriteFile(x.dup.to_s) }
+          else
+            s.each{ |x| _PrintString(x) }
+          end
+        end
+
+        # Returns true if output is being redirected to something other then a
+        # terminal.
+        #
+        # For now just checks the status of Win32::Console#redirected?
+        def redirected?
+          @Out.redirected?
+        end
+
+        private
+
+        def _PrintString(t)
+          s = t.dup.to_s
+          while s != ''
+            if s.sub!( /([^\e]*)?\e([\[\(])([0-9\;\=]*)([a-zA-Z@])(.*)/, '\5')
+              @Out.Write((_conv("#$1")))
+              if $2 == '['
+                case $4
+                when 'm'        # ESC[#;#;....;#m Set display attributes
+                  attributs = $3.split(';')
+                  attributs.push(nil) unless attributs  # ESC[m == ESC[;m ==...==ESC[0m
+                  attributs.each do |attr|
+                    atv = attr.to_i
+                    case atv
+                    when 0  # ESC[0m reset
+                      @foreground = @default_foreground
+                      @background = @default_background
+                      @bold       = @default_bold
+                      @underline  = @default_underline
+                      @revideo =
+                      @concealed = nil
+                    when 1
+                      @bold = 1
+                    when 21
+                      @bold = nil
+                    when 4
+                      @underline = 1
+                    when 24
+                      @underline = nil
+                    when 7
+                      @revideo = 1
+                    when 27
+                      @revideo = nil
+                    when 8
+                      @concealed = 1
+                    when 28
+                      @concealed = nil
+                    when 30..37
+                      @foreground = atv - 30
+                    when 40..47
+                      @background = atv - 40
+                    end
+                  end
+
+                  if @revideo
+                    attribut = @@color[40+@foreground] |
+                      @@color[30+@background]
+                  else
+                    attribut = @@color[30+@foreground] |
+                      @@color[40+@background]
+                  end
+                  attribut |= FOREGROUND_INTENSITY if @bold
+                  attribut |= BACKGROUND_INTENSITY if @underline
+                  @Out.Attr(attribut)
+                when 'J'
+                  if !$3 or $3 == ''  # ESC[0J from cursor to end of display
+                    info = @Out.Info()
+                    s = ' ' * ((info[1]-info[3]-1)*info[0]+info[0]-info[2]-1)
+                    @Out.WriteChar(s, info[2], info[3])
+                    @Out.Cursor(info[2], info[3])
+                  elsif $3 == '1' # ESC[1J erase from start to cursor.
+                    info = @Out.Info()
+                    s = ' ' * (info[3]*info[0]+info[2]+1)
+                    @Out.WriteChar(s, 0, 0)
+                    @Out.Cursor(info[2], info[3])
+                  elsif $3 == '2' # ESC[2J Clear screen and home cursor
+                    @Out.Cls()
+                    @Out.Cursor(0, 0)
+                  else
+                    STDERR.print "\e#$2#$3#$4" if DEBUG # if ESC-code not implemented
+                  end
+                when 'K'
+                  info = @Out.Info()
+                  if !$3 or $3 == ''                  # ESC[0K Clear to end of line
+                    s = ' ' * (info[7]-info[2]+1)
+                    @Out.Write(s)
+                    @Out.Cursor(info[2], info[3])
+                  elsif $3=='1'   # ESC[1K Clear from start of line to cursor
+                    s = ' '*(info[2]+1)
+                    @Out.WriteChar(s, 0, info[3])
+                    @Out.Cursor(info[2], info[3])
+                  elsif $3=='2'   # ESC[2K Clear whole line.
+                    s = ' '* info[0]
+                    @Out.WriteChar(s, 0, info[3])
+                    @Out.Cursor(info[2], info[3])
+                  end
+                when 'L'  # ESC[#L Insert # blank lines.
+                  n = $3 == ''? 1 : $3.to_i  # ESC[L == ESC[1L
+                  info = @Out.Info()
+                  @Out.Scroll(0, info[3], info[0]-1, info[1]-1,
+                              0, info[3] + n.to_i,
+                               ' '[0], @Out.Attr(),
+                               0, 0, 10000, 10000)
+                  @Out.Cursor(info[2], info[3])
+                when 'M'   # ESC[#M Delete # line.
+                  n = $3 == ''? 1 : $3.to_i  # ESC[M == ESC[1M
+                  info = @Out.Info();
+                  @Out.Scroll(0, info[3]+n, info[0]-1, info[1]-1,
+                              0, info[3],
+                              ' '[0], @Out.Attr(),
+                              0, 0, 10000, 10000)
+                  @Out.Cursor(info[2], info[3])
+                when 'P'   # ESC[#P Delete # characters.
+                  n = $3 == ''? 1 : $3.to_i  # ESC[P == ESC[1P
+                  info = @Out.Info()
+                  n = info[0]-info[2] if info[2]+n > info[0]-1
+                  @Out.Scroll(info[2]+n, info[3] , info[0]-1, info[3],
+                              info[2], info[3],
+                              ' '[0], @Out.Attr(),
+                              0, 0, 10000, 10000)
+                  s = ' ' * n
+                  @Out.Cursor(info[0]-n, info[3])
+                  @Out.Write(s)
+                  @Out.Cursor(info[2], info[3])
+                when '@'      # ESC[#@ Insert # blank Characters
+                  s = ' ' * $3.to_i
+                  info = @Out.Info()
+                  s << @Out.ReadChar(info[7]-info[2]+1, info[2], info[3])
+                  s = s[0..-($3.to_i)]
+                  @Out.Write(s);
+                  @Out.Cursor(info[2], info[3])
+                when 'A'     # ESC[#A Moves cursor up # lines
+                  (x, y) = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[A == ESC[1A
+                  @Out.Cursor(x, y-n)
+                when 'B'    # ESC[#B Moves cursor down # lines
+                  (x, y) = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[B == ESC[1B
+                  @Out.Cursor(x, y+n)
+                when 'C'    # ESC[#C Moves cursor forward # spaces
+                  (x, y) = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[C == ESC[1C
+                  @Out.Cursor(x+n, y)
+                when 'D'    # ESC[#D Moves cursor back # spaces
+                  (x, y) = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[D == ESC[1D
+                  @Out.Cursor(x-n, y)
+                when 'E'    # ESC[#E Moves cursor down # lines, column 1.
+                  x, y = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[E == ESC[1E
+                  @Out.Cursor(0, y+n)
+                when 'F'    # ESC[#F Moves cursor up # lines, column 1.
+                  x, y = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[F == ESC[1F
+                  @Out.Cursor(0, y-n)
+                when 'G'   # ESC[#G Moves cursor column # in current row.
+                  x, y = @Out.Cursor()
+                  n = $3 == ''? 1 : $3.to_i;  # ESC[G == ESC[1G
+                  @Out.Cursor(n-1, y)
+                when 'f' # ESC[#;#f Moves cursor to line #, column #
+                  y, x = $3.split(';')
+                  x = 1 unless x    # ESC[;5H == ESC[1;5H ...etc
+                  y = 1 unless y
+                  @Out.Cursor(x.to_i-1, y.to_i-1) # origin (0,0) in DOS console
+                when 'H' # ESC[#;#H  Moves cursor to line #, column #
+                  y, x = $3.split(';')
+                  x = 1 unless x    # ESC[;5H == ESC[1;5H ...etc
+                  y = 1 unless y
+                  @Out.Cursor(x.to_i-1, y.to_i-1) # origin (0,0) in DOS console
+                when 's'       # ESC[s Saves cursor position for recall later
+                  (@x, @y) = @Out.Cursor()
+                when 'u'       # ESC[u Return to saved cursor position
+                  @Out.Cursor(@x, @y)
+                when 'U'     # ESC(U no mapping
+                  @conv = nil
+                when 'K'     # ESC(K mapping if it exist
+                  @Out.OutputCP(OEM)      # restore original codepage
+                  @conv = 1
+                when 'X'     # ESC(#X codepage **EXPERIMENTAL**
+                  @conv = nil
+                  @Out.OutputCP($3)
+                else
+                  STDERR.puts "\e#$2#$3#$4 not implemented" if DEBUG # ESC-code not implemented
+                end
+              end
+            else
+              @Out.Write(_conv(s))
+              s=''
+            end
+          end
+        end
+
+        def _conv(s)
+          if @concealed
+            s.gsub!( /\S/,' ')
+          end
+          return s
+        end
+
+      end
+
+# end print overloading
+
+    end
+  end
+end
+
+$stdout = Win32::Console::ANSI::IO.new(:stdout)
+$stderr = Win32::Console::ANSI::IO.new(:stderr)