ansi 1.0.0

data/lib/ansi/string.rb

@@ -0,0 +1,249 @@
+require 'ansi/code'
+#require 'ansi/layout/split'
+#require 'clio/facets/string'
+
+# Create a new Ansi::String object.
+def ANSI.string(str)
+  ANSI::String.new(str)
+end
+
+# Clio Strings stores a regular string (@text) and
+# a Hash mapping character index to ansicodes (@marks).
+# For example is we have the string:
+#
+#   "Big Apple"
+#
+# And applied the color red to it, the marks hash would be:
+#
+#   { 0=>[:red] , 9=>[:clear] }
+#
+# TODO: In the future we may be able to subclass String,
+# instead of delegating via @text, but not until it is more compatible.
+#
+class ANSI::String
+
+  CLR = ANSI::Code.clear
+
+  attr :text
+  attr :marks
+
+  # New Ansi::String
+  def initialize(text=nil, marks=nil)
+    @text  = (text  || '').to_s
+    @marks = marks  || []
+    yield(self) if block_given?
+  end
+
+  # Convert Ansi::String object to normal String.
+  # This converts the intental markup codes to ANSI codes.
+  def to_s
+    s = text.dup
+    m = marks.sort do |(a,b)|
+      v = b[0] <=> a[0]
+      if v == 0
+        (b[1] == :clear or b[1] == :reset) ? -1 : 1
+      else
+        v
+      end
+    end
+    m.each do |(index, code)|
+      s.insert(index, ANSICode.__send__(code))
+    end
+    #s << CLR unless s =~ /#{Regexp.escape(CLR)}$/  # always end with a clear
+    s
+  end
+
+  # Ansi::String is a type of String.
+  alias_method :to_str, :to_s
+
+  # The size of the base text.
+  def size ; text.size ; end
+
+  # Upcase the string.
+  def upcase  ; self.class.new(text.upcase, marks) ; end
+  def upcase! ; text.upcase! ; end
+
+  # Downcase the string.
+  def downcase  ; self.class.new(text.upcase, marks) ; end
+  def downcase! ; text.upcase! ; end
+
+  # Add one String to another, or to a regular String.
+  def +(other)
+    case other
+    when String
+      ntext  = text + other.text
+      nmarks = marks.dup
+      omarks = shift_marks(0, text.size, other.marks)
+      omarks.each{ |(i, c)| nmarks << [i,c] }
+    else
+      ntext  = text + other.to_s
+      nmarks = marks.dup
+    end
+    self.class.new(ntext, nmarks)
+  end
+
+  #
+  #def |(other)
+  #  Split.new(self, other)
+  #end
+
+  #
+  #def lr(other, options={})
+  #  Split.new(self, other, options)
+  #end
+
+  # slice
+  def slice(*args)
+    if args.size == 2
+      index, len = *args
+      endex  = index+len
+      new_text  = text[index, len]
+      new_marks = []
+      marks.each do |(i, v)|
+        new_marks << [i, v] if i >= index && i < endex
+      end
+      self.class.new(new_text, new_marks)
+    elsif args.size == 1
+      rng = args.first
+      case rng
+      when Range
+        index, endex = rng.begin, rng.end
+        new_text  = text[rng]
+        new_marks = []
+        marks.each do |(i, v)|
+          new_marks << [i, v] if i >= index && i < endex
+        end
+        self.class.new(new_text, new_marks)
+      else
+        nm = marks.select do |(i,c)|
+          marks[0] == rng or ( marks[0] == rng + 1 && [:clear, :reset].include?(marks[1]) )
+        end
+        self.class.new(text[rng,1], nm)
+      end
+    else
+      raise ArgumentError
+    end
+  end
+
+  #
+  alias_method :[], :slice
+
+  # This is more limited than the normal String method.
+  # It does not yet support a block, and +replacement+
+  # won't substitue for \1, \2, etc.
+  #
+  # TODO: block support.
+  def sub!(pattern, replacement=nil, &block)
+    mark_changes = []
+    text = @text.sub(pattern) do |s|
+      index  = $~.begin(0)
+      replacement = block.call(s) if block_given?
+      delta  = (replacement.size - s.size)
+      mark_changes << [index, delta]
+      replacement
+    end
+    marks = @marks
+    mark_changes.each do |index, delta|
+      marks = shift_marks(index, delta, marks)
+    end
+    @text  = text
+    @marks = marks
+    self
+  end
+
+  # See #sub!.
+  def sub(pattern,replacement=nil, &block)
+    dup.sub!(pattern, replacement, &block)
+  end
+
+  #
+  def gsub!(pattern, replacement=nil, &block)
+    mark_changes   = []
+    mark_additions = []
+    text = @text.gsub(pattern) do |s|
+      index = $~.begin(0)
+      replacement = block.call(self.class.new(s)) if block_given?
+      if self.class===replacement
+        adj_marks = replacement.marks.map{ |(i,c)| [i+index,c] }
+        mark_additions.concat(adj_marks)
+        replacement = replacement.text
+      end
+      delta = (replacement.size - s.size)
+      mark_changes << [index, delta]
+      replacement
+    end
+    marks = @marks
+    mark_changes.each do |(index, delta)|
+      marks = shift_marks(index, delta, marks)
+    end
+    marks.concat(mark_additions)
+    @text  = text
+    @marks = marks
+    self
+  end
+
+  # See #gsub!.
+  def gsub(pattern, replacement=nil, &block)
+    dup.gsub!(pattern, replacement, &block)
+  end
+
+  #
+  def ansi(code)
+    m = marks.dup
+    m.unshift([0, code])
+    m.push([size, :clear])
+    self.class.new(text, m)
+  end
+  alias_method :color, :ansi
+
+  #
+  def ansi!(code)
+    marks.unshift([0, ansicolor])
+    marks.push([size, :clear])
+  end
+  alias_method :color!, :ansi!
+
+  def red        ; color(:red)      ; end
+  def green      ; color(:green)    ; end
+  def blue       ; color(:blue)     ; end
+  def black      ; color(:black)    ; end
+  def magenta    ; color(:magenta)  ; end
+  def yellow     ; color(:yellow)   ; end
+  def cyan       ; color(:cyan)     ; end
+
+  def bold       ; ansi(:bold)       ; end
+  def underline  ; ansi(:underline)  ; end
+
+  def red!       ; color!(:red)     ; end
+  def green!     ; color!(:green)   ; end
+  def blue!      ; color!(:blue)    ; end
+  def black!     ; color!(:black)   ; end
+  def magenta!   ; color!(:magenta) ; end
+  def yellow!    ; color!(:yellow)  ; end
+  def cyan!      ; color!(:cyan)    ; end
+
+  def bold!      ; ansi!(:bold)      ; end
+  def underline! ; ansi!(:underline) ; end
+
+private
+
+  #
+  def shift_marks(index, delta, marks=nil)
+    new_marks = []
+    (marks || @marks).each do |(i, c)|
+      case i <=> index
+      when -1
+        new_marks << [i, c]
+      when 0, 1
+        new_marks << [i+delta, c]
+      end
+    end
+    new_marks
+  end
+
+  #
+  def shift_marks!(index, delta)
+    @marks.replace(shift_marks(index, delta))
+  end
+
+end

data/lib/ansi/terminal.rb

@@ -0,0 +1,43 @@
+#
+# This library is based of HighLine's SystemExtensions
+# by James Edward Gray II.
+#
+#   Copyright 2006 Gray Productions. All rights reserved.
+#
+# This is Free Software.  See LICENSE and COPYING for details.
+
+module ANSI
+
+  #
+  module Terminal
+
+    module_function
+
+    modes = %w{win32 termios curses stty}
+
+    #
+    # This section builds character reading and terminal size functions
+    # to suit the proper platform we're running on.  Be warned:  Here be
+    # dragons!
+    #
+    begin
+      require 'ansi/terminal/' + (mode = modes.pop)
+      CHARACTER_MODE = mode
+    rescue LoadError
+      retry
+    end
+
+    # Get the width of the terminal window.
+    def terminal_width
+      terminal_size[0]
+    end
+
+    # Get the height of the terminal window.
+    def terminal_height
+      terminal_size[1]
+    end
+
+  end
+
+end
+

data/lib/ansi/terminal/curses.rb

@@ -0,0 +1,27 @@
+module ANSI
+
+  module Terminal
+    require 'curses'
+
+    module_function
+
+    #CHARACTER_MODE = "curses"    # For Debugging purposes only.
+
+    #
+    # Curses savvy getc().
+    #
+    #
+    def get_character(input = STDIN)
+      Curses.getch()
+    end
+
+    def terminal_size
+      Curses.init_screen
+      w, r = Curses.cols, Curses.rows
+      Curses.close_screen
+      return r, w
+    end
+
+  end
+
+end

data/lib/ansi/terminal/stty.rb

@@ -0,0 +1,55 @@
+module ANSI
+
+  module Terminal
+
+    module_function
+
+    #CHARACTER_MODE = "stty"    # For Debugging purposes only.
+
+    #
+    # Unix savvy getc().  (Second choice.)
+    #
+    # *WARNING*:  This method requires the external "stty" program!
+    #
+    def get_character( input = STDIN )
+      raw_no_echo_mode
+
+      begin
+        input.getc
+      ensure
+        restore_mode
+      end
+    end
+
+    #
+    # Switched the input mode to raw and disables echo.
+    #
+    # *WARNING*:  This method requires the external "stty" program!
+    #
+    def raw_no_echo_mode
+      @state = `stty -g`
+      system "stty raw -echo cbreak isig"
+    end
+
+    #
+    # Restores a previously saved input mode.
+    #
+    # *WARNING*:  This method requires the external "stty" program!
+    #
+    def restore_mode
+      system "stty #{@state}"
+    end
+
+    # A Unix savvy method to fetch the console columns, and rows.
+    def terminal_size
+      if /solaris/ =~ RUBY_PLATFORM and
+          `stty` =~ /\brows = (\d+).*\bcolumns = (\d+)/
+        [$2, $1].map { |c| x.to_i }
+      else
+        `stty size`.split.map { |x| x.to_i }.reverse
+      end
+    end
+
+  end
+
+end

data/lib/ansi/terminal/termios.rb

@@ -0,0 +1,63 @@
+module ANSI
+
+  module Terminal
+    require "termios"             # Unix, first choice.
+
+    module_function
+
+    #CHARACTER_MODE = "termios"    # For Debugging purposes only.
+
+    #
+    # Unix savvy getc().  (First choice.)
+    #
+    # *WARNING*:  This method requires the "termios" library!
+    #
+    def get_character( input = STDIN )
+      old_settings = Termios.getattr(input)
+
+      new_settings                     =  old_settings.dup
+      new_settings.c_lflag             &= ~(Termios::ECHO | Termios::ICANON)
+      new_settings.c_cc[Termios::VMIN] =  1
+
+      begin
+        Termios.setattr(input, Termios::TCSANOW, new_settings)
+        input.getc
+      ensure
+        Termios.setattr(input, Termios::TCSANOW, old_settings)
+      end
+    end
+
+    # A Unix savvy method to fetch the console columns, and rows.
+    def terminal_size
+      if /solaris/ =~ RUBY_PLATFORM and
+          `stty` =~ /\brows = (\d+).*\bcolumns = (\d+)/
+        [$2, $1].map { |c| x.to_i }
+      else
+        `stty size`.split.map { |x| x.to_i }.reverse
+      end
+    end
+
+    # Console screen width (taken from progress bar)
+    #
+    # NOTE: Don't know how portable #screen_width is.
+    # TODO: How to fit in to system?
+    #
+    def screen_width(out=STDERR)
+      default_width = ENV['COLUMNS'] || 76
+      begin
+        tiocgwinsz = 0x5413
+        data = [0, 0, 0, 0].pack("SSSS")
+        if out.ioctl(tiocgwinsz, data) >= 0 then
+          rows, cols, xpixels, ypixels = data.unpack("SSSS")
+          if cols >= 0 then cols else default_width end
+        else
+          default_width
+        end
+      rescue Exception
+        default_width
+      end
+    end
+
+  end
+
+end

data/lib/ansi/terminal/win32.rb

@@ -0,0 +1,107 @@
+module ANSI
+
+  module Terminal
+    # Cygwin will look like Windows, but we want to treat it like a Posix OS:
+    raise LoadError, "Cygwin is a Posix OS." if RUBY_PLATFORM =~ /\bcygwin\b/i
+
+    require "Win32API"             # See if we're on Windows.
+
+    module_function
+
+    #CHARACTER_MODE = "Win32API"    # For Debugging purposes only.
+
+    #
+    # Windows savvy getc().
+    #
+    #
+    def get_character( input = STDIN )
+      @stdin_handle ||= GetStdHandle(STD_INPUT_HANDLE)
+
+      begin
+          SetConsoleEcho(@stdin_handle, false)
+          input.getc
+      ensure
+          SetConsoleEcho(@stdin_handle, true)
+      end
+    end
+
+    # A Windows savvy method to fetch the console columns, and rows.
+    def terminal_size
+      stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE)
+
+      bufx, bufy, curx, cury, wattr, left, top, right, bottom, maxx, maxy =
+        GetConsoleScreenBufferInfo(stdout_handle)
+      return right - left + 1, bottom - top + 1
+    end
+
+    # windows savvy console echo toggler
+    def SetConsoleEcho( console_handle, on )
+      mode = GetConsoleMode(console_handle)
+
+      # toggle the console echo bit
+      if on
+          mode |=  ENABLE_ECHO_INPUT
+      else
+          mode &= ~ENABLE_ECHO_INPUT
+      end
+
+      ok = SetConsoleMode(console_handle, mode)
+    end
+
+    # win32 console APIs
+
+    STD_INPUT_HANDLE  = -10
+    STD_OUTPUT_HANDLE = -11
+    STD_ERROR_HANDLE  = -12
+
+    ENABLE_PROCESSED_INPUT    = 0x0001
+    ENABLE_LINE_INPUT         = 0x0002
+    ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002
+    ENABLE_ECHO_INPUT         = 0x0004
+    ENABLE_WINDOW_INPUT       = 0x0008
+    ENABLE_MOUSE_INPUT        = 0x0010
+    ENABLE_INSERT_MODE        = 0x0020
+    ENABLE_QUICK_EDIT_MODE    = 0x0040
+
+    @@apiGetStdHandle               = nil
+    @@apiGetConsoleMode             = nil
+    @@apiSetConsoleMode             = nil
+    @@apiGetConsoleScreenBufferInfo = nil
+
+    def GetStdHandle( handle_type )
+      @@apiGetStdHandle ||= Win32API.new( "kernel32", "GetStdHandle",
+                                          ['L'], 'L' )
+
+      @@apiGetStdHandle.call( handle_type )
+    end
+
+    def GetConsoleMode( console_handle )
+      @@apiGetConsoleMode ||= Win32API.new( "kernel32", "GetConsoleMode",
+                                            ['L', 'P'], 'I' )
+
+      mode = ' ' * 4
+      @@apiGetConsoleMode.call(console_handle, mode)
+      mode.unpack('L')[0]
+    end
+
+    def SetConsoleMode( console_handle, mode )
+      @@apiSetConsoleMode ||= Win32API.new( "kernel32", "SetConsoleMode",
+                                            ['L', 'L'], 'I' )
+
+      @@apiSetConsoleMode.call(console_handle, mode) != 0
+    end
+
+    def GetConsoleScreenBufferInfo( console_handle )
+      @@apiGetConsoleScreenBufferInfo ||=
+        Win32API.new( "kernel32", "GetConsoleScreenBufferInfo",
+                      ['L', 'P'], 'L' )
+
+      format = 'SSSSSssssSS'
+      buf    = ([0] * format.size).pack(format)
+      @@apiGetConsoleScreenBufferInfo.call(console_handle, buf)
+      buf.unpack(format)
+    end
+
+  end
+
+end