highline-sgonyea 1.6.12

data/lib/highline/simulate.rb

@@ -0,0 +1,48 @@
+# simulate.rb
+#
+#  Created by Andy Rossmeissl on 2012-04-29.
+#  Copyright 2005 Gray Productions. All rights reserved.
+#
+#  This is Free Software.  See LICENSE and COPYING for details.
+#
+# adapted from https://gist.github.com/194554
+class HighLine
+
+  # Simulates Highline input for use in tests.
+  class Simulate
+
+    # Creates a simulator with an array of Strings as a script
+    def initialize(strings)
+      @strings = strings
+    end
+    
+    # Simulate StringIO#gets by shifting a string off of the script
+    def gets
+      @strings.shift
+    end
+
+    # Simulate StringIO#getbyte by shifting a single character off of the next line of the script
+    def getbyte
+      line = gets
+      if line.length > 0
+        char = line.slice! 0
+        @strings.unshift line
+        char
+      end
+    end
+
+    # The simulator handles its own EOF
+    def eof?
+      false
+    end
+
+    # A wrapper method that temporarily replaces the Highline instance in $terminal with an instance of this object for the duration of the block
+    def self.with(*strings)
+      @input = $terminal.instance_variable_get :@input
+      $terminal.instance_variable_set :@input, new(strings)
+      yield
+    ensure
+      $terminal.instance_variable_set :@input, @input
+    end
+  end
+end

data/lib/highline/string_extensions.rb

@@ -0,0 +1,131 @@
+# Extensions for class String
+#
+# HighLine::String is a subclass of String with convenience methods added for colorization.
+#
+# Available convenience methods include:
+#   * 'color' method         e.g.  highline_string.color(:bright_blue, :underline)
+#   * colors                 e.g.  highline_string.magenta
+#   * RGB colors             e.g.  highline_string.rgb_ff6000
+#                             or   highline_string.rgb(255,96,0)
+#   * background colors      e.g.  highline_string.on_magenta
+#   * RGB background colors  e.g.  highline_string.on_rgb_ff6000
+#                             or   highline_string.on_rgb(255,96,0)
+#   * styles                 e.g.  highline_string.underline
+#
+# Additionally, convenience methods can be chained, for instance the following are equivalent:
+#   highline_string.bright_blue.blink.underline
+#   highline_string.color(:bright_blue, :blink, :underline)
+#   HighLine.color(highline_string, :bright_blue, :blink, :underline)
+#
+# For those less squeamish about possible conflicts, the same convenience methods can be 
+# added to the builtin String class, as follows:
+#
+#  require 'highline'
+#  Highline.colorize_strings
+
+class HighLine
+  def self.String(s)
+    HighLine::String.new(s)
+  end
+  
+  module StringExtensions
+    def self.included(base)
+      HighLine::COLORS.each do |color|
+        base.class_eval <<-END
+          if public_instance_methods.map { |m| m.to_s }.
+                                     include? "#{color.downcase}"
+            undef :#{color.downcase}
+          end
+          def #{color.downcase}
+            color(:#{color.downcase})
+          end
+        END
+        base.class_eval <<-END
+          if public_instance_methods.map { |m| m.to_s }.
+                                     include? "on_#{color.downcase}"
+            undef :on_#{color.downcase}
+          end
+          def on_#{color.downcase}
+            on(:#{color.downcase})
+          end
+        END
+        HighLine::STYLES.each do |style|
+          base.class_eval <<-END
+            if public_instance_methods.map { |m| m.to_s }.
+                                       include? "#{style.downcase}"
+              undef :#{style.downcase}
+            end
+            def #{style.downcase}
+              color(:#{style.downcase})
+            end
+          END
+        end
+      end
+      
+      base.class_eval do
+        if public_instance_methods.map { |m| m.to_s }.include? "color"
+          undef :color
+        end
+        if public_instance_methods.map { |m| m.to_s }.include? "foreground"
+          undef :foreground
+        end
+        def color(*args)
+          self.class.new(HighLine.color(self, *args))
+        end
+        alias_method :foreground, :color
+        
+        if public_instance_methods.map { |m| m.to_s }.include? "on"
+          undef :on
+        end
+        def on(arg)
+          color(('on_' + arg.to_s).to_sym)
+        end
+
+        if public_instance_methods.map { |m| m.to_s }.include? "uncolor"
+          undef :uncolor
+        end
+        def uncolor
+          self.class.new(HighLine.uncolor(self))
+        end
+        
+        if public_instance_methods.map { |m| m.to_s }.include? "rgb"
+          undef :rgb
+        end
+        def rgb(*colors)
+          color_code = colors.map{|color| color.is_a?(Numeric) ? '%02x'%color : color.to_s}.join
+          raise "Bad RGB color #{colors.inspect}" unless color_code =~ /^[a-fA-F0-9]{6}/
+          color("rgb_#{color_code}".to_sym)
+        end
+        
+        if public_instance_methods.map { |m| m.to_s }.include? "on_rgb"
+          undef :on_rgb
+        end
+        def on_rgb(*colors)
+          color_code = colors.map{|color| color.is_a?(Numeric) ? '%02x'%color : color.to_s}.join
+          raise "Bad RGB color #{colors.inspect}" unless color_code =~ /^[a-fA-F0-9]{6}/
+          color("on_rgb_#{color_code}".to_sym)
+        end
+        
+        if public_instance_methods.map { |m| m.to_s }.include? "method_missing"
+          undef :method_missing
+        end
+        # TODO Chain existing method_missing
+        def method_missing(method, *args, &blk)
+          if method.to_s =~ /^(on_)?rgb_([0-9a-fA-F]{6})$/
+            color(method)
+          else
+            raise NoMethodError, "undefined method `#{method}' for #<#{self.class}:#{'%#x'%self.object_id}>"
+          end
+        end
+      end
+    end
+  end
+  
+  class HighLine::String < ::String
+    include StringExtensions
+  end
+  
+  def self.colorize_strings
+    ::String.send(:include, StringExtensions)
+  end
+end

data/lib/highline/style.rb

@@ -0,0 +1,181 @@
+# color_scheme.rb
+#
+# Created by Richard LeBer on 2011-06-27.
+# Copyright 2011.  All rights reserved
+#
+# This is Free Software.  See LICENSE and COPYING for details
+
+class HighLine
+  
+  def self.Style(*args)
+    args = args.compact.flatten
+    if args.size==1
+      arg = args.first
+      if arg.is_a?(Style)
+        Style.list[arg.name] || Style.index(arg)
+      elsif arg.is_a?(::String) && arg =~ /^\e\[/ # arg is a code
+        if styles = Style.code_index[arg]
+          styles.first
+        else
+          Style.new(:code=>arg)
+        end
+      elsif style = Style.list[arg]
+        style
+      elsif HighLine.color_scheme && HighLine.color_scheme[arg]
+        HighLine.color_scheme[arg]
+      elsif arg.is_a?(Hash)
+        Style.new(arg)
+      elsif arg.to_s.downcase =~ /^rgb_([a-f0-9]{6})$/
+        Style.rgb($1)
+      elsif arg.to_s.downcase =~ /^on_rgb_([a-f0-9]{6})$/
+        Style.rgb($1).on
+      else
+        raise NameError, "#{arg.inspect} is not a defined Style"
+      end
+    else
+      name = args
+      Style.list[name] || Style.new(:list=>args)
+    end
+  end
+  
+  class Style
+    
+    def self.index(style)
+      if style.name
+        @@styles ||= {}
+        @@styles[style.name] = style
+      end
+      if !style.list
+        @@code_index ||= {}
+        @@code_index[style.code] ||= []
+        @@code_index[style.code].reject!{|indexed_style| indexed_style.name == style.name}
+        @@code_index[style.code] << style
+      end
+      style
+    end
+    
+    def self.rgb_hex(*colors)
+      colors.map do |color|
+        color.is_a?(Numeric) ? '%02x'%color : color.to_s
+      end.join
+    end
+    
+    def self.rgb_parts(hex)
+      hex.scan(/../).map{|part| part.to_i(16)}
+    end
+    
+    def self.rgb(*colors)
+      hex = rgb_hex(*colors)
+      name = ('rgb_' + hex).to_sym
+      if style = list[name]
+        style
+      else
+        parts = rgb_parts(hex)
+        new(:name=>name, :code=>"\e[38;5;#{rgb_number(parts)}m", :rgb=>parts)
+      end
+    end
+    
+    def self.rgb_number(*parts)
+      parts = parts.flatten
+      16 + parts.inject(0) {|kode, part| kode*6 + (part/256.0*6.0).floor}
+    end
+    
+    def self.ansi_rgb_to_hex(ansi_number)
+      raise "Invalid ANSI rgb code #{ansi_number}" unless (16..231).include?(ansi_number)
+      parts = (ansi_number-16).to_s(6).rjust(3,'0').scan(/./).map{|d| (d.to_i*255.0/6.0).ceil}
+      rgb_hex(*parts)
+    end
+    
+    def self.list
+      @@styles ||= {}
+    end
+    
+    def self.code_index
+      @@code_index ||= {}
+    end
+    
+    def self.uncolor(string)
+      string.gsub(/\e\[\d+(;\d+)*m/, '')
+    end
+    
+    attr_reader :name, :list
+    attr_accessor :rgb, :builtin
+    
+    # Single color/styles have :name, :code, :rgb (possibly), :builtin
+    # Compound styles have :name, :list, :builtin
+    def initialize(defn = {})
+      @definition = defn
+      @name    = defn[:name]
+      @code    = defn[:code]
+      @rgb     = defn[:rgb]
+      @list    = defn[:list]
+      @builtin = defn[:builtin]
+      if @rgb
+        hex = self.class.rgb_hex(@rgb)
+        @name ||= 'rgb_' + hex
+      elsif @list
+        @name ||= @list
+      end
+      self.class.index self unless defn[:no_index]
+    end
+    
+    def dup
+      self.class.new(@definition)
+    end
+    
+    def to_hash
+      @definition
+    end
+    
+    def color(string)
+      code + string + HighLine::CLEAR
+    end
+    
+    def code
+      if @list
+        @list.map{|element| HighLine.Style(element).code}.join
+      else
+        @code
+      end
+    end
+      
+    def red
+      @rgb && @rgb[0]
+    end
+
+    def green
+      @rgb && @rgb[1]
+    end
+
+    def blue
+      @rgb && @rgb[2]
+    end
+    
+    def variant(new_name, options={})
+      raise "Cannot create a variant of a style list (#{inspect})" if @list
+      new_code = options[:code] || code
+      if options[:increment]
+        raise "Unexpected code in #{inspect}" unless new_code =~ /^(.*?)(\d+)(.*)/
+        new_code = $1 + ($2.to_i + options[:increment]).to_s + $3
+      end
+      new_rgb = options[:rgb] || @rgb
+      self.class.new(self.to_hash.merge(:name=>new_name, :code=>new_code, :rgb=>new_rgb))
+    end
+    
+    def on
+      new_name = ('on_'+@name.to_s).to_sym
+      self.class.list[new_name] ||= variant(new_name, :increment=>10)
+    end
+    
+    def bright
+      raise "Cannot create a bright variant of a style list (#{inspect})" if @list
+      new_name = ('bright_'+@name.to_s).to_sym
+      if style = self.class.list[new_name]
+        style
+      else
+        new_rgb = @rgb == [0,0,0] ? [128, 128, 128] : @rgb.map {|color|  color==0 ? 0 : [color+128,255].min }
+        variant(new_name, :increment=>60, :rgb=>new_rgb)
+      end
+    end
+  end
+end

data/lib/highline/system_extensions.rb

@@ -0,0 +1,186 @@
+# system_extensions.rb
+#
+#  Created by James Edward Gray II on 2006-06-14.
+#  Copyright 2006 Gray Productions. All rights reserved.
+#
+#  This is Free Software.  See LICENSE and COPYING for details.
+
+require "highline/compatibility"
+
+class HighLine
+  module SystemExtensions
+    module_function
+
+    JRUBY = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+    #
+    # This section builds character reading and terminal size functions
+    # to suit the proper platform we're running on.  Be warned:  Here be
+    # dragons!
+    #
+    begin
+      # 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.
+
+      CHARACTER_MODE = "Win32API"    # For Debugging purposes only.
+
+      #
+      # Windows savvy getc().
+      #
+      # *WARNING*:  This method ignores <tt>input</tt> and reads one
+      # character from +STDIN+!
+      #
+      def get_character( input = STDIN )
+        Win32API.new("msvcrt", "_getch", [ ], "L").Call
+      rescue Exception
+        Win32API.new("crtdll", "_getch", [ ], "L").Call
+      end
+
+      # A Windows savvy method to fetch the console columns, and rows.
+      def terminal_size
+        m_GetStdHandle               = Win32API.new( 'kernel32',
+                                                     'GetStdHandle',
+                                                     ['L'],
+                                                     'L' )
+        m_GetConsoleScreenBufferInfo = Win32API.new(
+          'kernel32', 'GetConsoleScreenBufferInfo', ['L', 'P'], 'L'
+        )
+
+        format        = 'SSSSSssssSS'
+        buf           = ([0] * format.size).pack(format)
+        stdout_handle = m_GetStdHandle.call(0xFFFFFFF5)
+
+        m_GetConsoleScreenBufferInfo.call(stdout_handle, buf)
+        _, _, _, _, _,
+        left, top, right, bottom, _, _ = buf.unpack(format)
+        return right - left + 1, bottom - top + 1
+      end
+    rescue LoadError                  # If we're not on Windows try...
+      begin
+        require "termios"             # Unix, first choice termios.
+
+        CHARACTER_MODE = "termios"    # For Debugging purposes only.
+
+        #
+        # Unix savvy getc().  (First choice.)
+        #
+        # *WARNING*:  This method requires the "termios" library!
+        #
+        def get_character( input = STDIN )
+          return input.getbyte if input.is_a? StringIO
+
+          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.getbyte
+          ensure
+            Termios.setattr(input, Termios::TCSANOW, old_settings)
+          end
+        end
+      rescue LoadError            # If our first choice fails, try using ffi-ncurses.
+        begin
+          require 'ffi-ncurses'   # The ffi gem is builtin to JRUBY and because stty does not
+                                  # work correctly in JRuby manually installing the ffi-ncurses
+                                  # gem is the only way to get highline to operate correctly in
+                                  # JRuby. The ncurses library is only present on unix platforms
+                                  # so this is not a solution for using highline in JRuby on
+                                  # windows.
+
+          CHARACTER_MODE = "ncurses"    # For Debugging purposes only.
+
+          #
+          # ncurses savvy getc().
+          #
+          def get_character( input = STDIN )
+            FFI::NCurses.initscr
+            FFI::NCurses.cbreak
+            begin
+              FFI::NCurses.curs_set 0
+              input.getbyte
+            ensure
+              FFI::NCurses.endwin
+            end
+          end
+
+        rescue LoadError                # If the ffi-ncurses choice fails, try using stty
+          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.getbyte
+            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 -icanon isig"
+          end
+
+          #
+          # Restores a previously saved input mode.
+          #
+          # *WARNING*:  This method requires the external "stty" program!
+          #
+          def restore_mode
+            system "stty #{@state}"
+          end
+        end
+      end
+      if CHARACTER_MODE == 'ncurses'
+        #
+        # A ncurses savvy method to fetch the console columns, and rows.
+        #
+        def terminal_size
+          size = [80, 40]
+          FFI::NCurses.initscr
+          begin
+            size = FFI::NCurses.getmaxyx(stdscr).reverse
+          ensure
+            FFI::NCurses.endwin
+          end
+          size
+        end
+      elsif JRUBY
+        # JRuby running on Unix can fetch the number of columns and rows from the builtin Jline library
+        require 'java'
+        java_import 'jline.Terminal'
+        def terminal_size
+          java_terminal = @java_terminal || Terminal.getTerminal
+          [ java_terminal.getTerminalWidth, java_terminal.getTerminalHeight ]
+        end
+      else
+        # A Unix savvy method using stty that to fetch the console columns, and rows.
+        # ... stty does not work in JRuby
+        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
+  end
+end