highline 1.6.2 → 1.6.5

data/lib/highline/color_scheme.rb

@@ -70,11 +70,29 @@ class HighLine
     def []( color_tag )
       @scheme[to_symbol(color_tag)]
     end
+    
+    # Retrieve the original form of the scheme
+    def definition( color_tag )
+      style = @scheme[to_symbol(color_tag)]
+      style && style.list
+    end
+    
+    # Retrieve the keys in the scheme
+    def keys
+      @scheme.keys
+    end
 
     # Allow the scheme to be set like a Hash.
     def []=( color_tag, constants )
-      @scheme[to_symbol(color_tag)] = constants.map { |c| to_constant(c) }
+      @scheme[to_symbol(color_tag)] = HighLine::Style.new(:name=>color_tag.to_s.downcase.to_sym, 
+                                                          :list=>constants, :no_index=>true)
+    end
+    
+    # Retrieve the color scheme hash (in original definition format)
+    def to_hash
+      @scheme.inject({}) { |hsh, pair| key, value = pair; hsh[key] = value.list; hsh }
     end
+      
 
     private
 
@@ -86,7 +104,7 @@ class HighLine
     # Return a normalized representation of a color setting.
     def to_constant( v )
       v = v.to_s if v.is_a?(Symbol)
-      if v.is_a?(String) then
+      if v.is_a?(::String) then
         HighLine.const_get(v.upcase)
       else
         v

data/lib/highline/menu.rb

@@ -178,7 +178,7 @@ class HighLine
       @index = style
       
       # Default settings.
-      if @index == :none or @index.is_a?(String)
+      if @index == :none or @index.is_a?(::String)
         @index_suffix = " "
         @select_by    = :name
       end

data/lib/highline/question.rb

@@ -289,6 +289,7 @@ class HighLine
     # Pathname::               Same as File, save that a Pathname object is
     #                          returned.
     # String::                 Answer is converted with Kernel.String().
+    # HighLine::String::       Answer is converted with HighLine::String()
     # Regexp::                 Answer is fed to Regexp.new().
     # Symbol::                 The method to_sym() is called on answer and
     #                          the result returned.
@@ -301,6 +302,8 @@ class HighLine
     def convert( answer_string )
       if @answer_type.nil?
         answer_string
+      elsif @answer_type == HighLine::String
+        HighLine::String(answer_string)
       elsif [Float, Integer, String].include?(@answer_type)
         Kernel.send(@answer_type.to_s.to_sym, answer_string)
       elsif @answer_type == Symbol

data/lib/highline/string_extensions.rb

@@ -0,0 +1,98 @@
+# 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
+          def #{color.downcase}
+            color(:#{color.downcase})
+          end
+        END
+        base.class_eval <<-END
+          def on_#{color.downcase}
+            on(:#{color.downcase})
+          end
+        END
+        HighLine::STYLES.each do |style|
+          base.class_eval <<-END
+            def #{style.downcase}
+              color(:#{style.downcase})
+            end
+          END
+        end
+      end
+      
+      base.class_eval do
+        def color(*args)
+          self.class.new(HighLine.color(self, *args))
+        end
+        alias_method :foreground, :color
+        
+        def on(arg)
+          color(('on_' + arg.to_s).to_sym)
+        end
+
+        def uncolor
+          self.class.new(HighLine.uncolor(self))
+        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
+        
+        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
+        
+        # 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,184 @@
+#!/usr/local/bin/ruby -w
+
+# 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, :code, :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)
+        rgb = self.class.rgb_parts(hex)
+        @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
+      new_style = 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/test/string_methods.rb

@@ -0,0 +1,34 @@
+#!/usr/local/bin/ruby -w
+
+# string_methods.rb
+#
+#  Created by Richard LeBer 2011-06-27
+#
+#  This is Free Software.  See LICENSE and COPYING for details.
+#
+#  String class convenience methods
+
+module StringMethods  
+  def test_color
+    assert_equal("\e[34mstring\e[0m", @string.color(:blue))
+    assert_equal("\e[1m\e[47mstring\e[0m", @string.color(:bold,:on_white))
+    assert_equal("\e[45mstring\e[0m", @string.on(:magenta))
+    assert_equal("\e[36mstring\e[0m", @string.cyan)
+    assert_equal("\e[41m\e[5mstring\e[0m\e[0m", @string.blink.on_red)
+    assert_equal("\e[38;5;137mstring\e[0m", @string.color(:rgb_906030))
+    assert_equal("\e[38;5;101mstring\e[0m", @string.rgb('606030'))
+    assert_equal("\e[38;5;107mstring\e[0m", @string.rgb('60','90','30'))
+    assert_equal("\e[38;5;107mstring\e[0m", @string.rgb(96,144,48))
+    assert_equal("\e[38;5;173mstring\e[0m", @string.rgb_c06030)
+    assert_equal("\e[48;5;137mstring\e[0m", @string.color(:on_rgb_906030))
+    assert_equal("\e[48;5;101mstring\e[0m", @string.on_rgb('606030'))
+    assert_equal("\e[48;5;107mstring\e[0m", @string.on_rgb('60','90','30'))
+    assert_equal("\e[48;5;107mstring\e[0m", @string.on_rgb(96,144,48))
+    assert_equal("\e[48;5;173mstring\e[0m", @string.on_rgb_c06030)
+  end
+  
+  def test_uncolor
+    colored_string = HighLine::String("\e[38;5;137mstring\e[0m")
+    assert_equal "string", colored_string.uncolor
+  end
+end

data/test/tc_color_scheme.rb

@@ -46,6 +46,48 @@ class TestColorScheme < Test::Unit::TestCase
     @terminal.say("This should be <%= color('warning yellow', 'WarNing') %>.")
     assert_equal("This should be \e[1m\e[33mwarning yellow\e[0m.\n",@output.string)
     @output.rewind
+    
+    # Check that keys are available, and as expected
+    assert_equal ["critical", "error", "warning", "notice", "info", "debug", "row_even", "row_odd"].sort,
+                 HighLine.color_scheme.keys.sort
+    
+    # Color scheme doesn't care if we use symbols or strings, and is case-insensitive
+    warning1 = HighLine.color_scheme[:warning]
+    warning2 = HighLine.color_scheme["warning"]
+    warning3 = HighLine.color_scheme[:wArning]
+    warning4 = HighLine.color_scheme["warniNg"]
+    assert_instance_of HighLine::Style, warning1
+    assert_instance_of HighLine::Style, warning2
+    assert_instance_of HighLine::Style, warning3
+    assert_instance_of HighLine::Style, warning4
+    assert_equal warning1, warning2
+    assert_equal warning1, warning3
+    assert_equal warning1, warning4
+
+    # Nonexistent keys return nil
+    assert_nil HighLine.color_scheme[:nonexistent]
+    
+    # Same as above, for definitions
+    defn1 = HighLine.color_scheme.definition(:warning)
+    defn2 = HighLine.color_scheme.definition("warning")
+    defn3 = HighLine.color_scheme.definition(:wArning)
+    defn4 = HighLine.color_scheme.definition("warniNg")
+    assert_instance_of Array, defn1
+    assert_instance_of Array, defn2
+    assert_instance_of Array, defn3
+    assert_instance_of Array, defn4
+    assert_equal [:bold, :yellow], defn1
+    assert_equal [:bold, :yellow], defn2
+    assert_equal [:bold, :yellow], defn3
+    assert_equal [:bold, :yellow], defn4
+    assert_nil HighLine.color_scheme.definition(:nonexistent)
+    
+    color_scheme_hash = HighLine.color_scheme.to_hash
+    assert_instance_of Hash, color_scheme_hash
+    assert_equal ["critical", "error", "warning", "notice", "info", "debug", "row_even", "row_odd"].sort,
+                 color_scheme_hash.keys.sort
+    assert_instance_of Array, HighLine.color_scheme.definition(:warning)
+    assert_equal [:bold, :yellow], HighLine.color_scheme.definition(:warning)
 
     # turn it back off, should raise an exception
     HighLine.color_scheme = @old_color_scheme

data/test/tc_highline.rb

@@ -198,6 +198,28 @@ class TestHighLine < Test::Unit::TestCase
 
     @output.truncate(@output.rewind)
 
+    @terminal.say("This should be <%= NONE %>none<%= CLEAR %>!")
+    assert_equal("This should be \e[38mnone\e[0m!\n", @output.string)
+
+    @output.truncate(@output.rewind)
+
+    @terminal.say("This should be <%= RGB_906030 %>rgb_906030<%= CLEAR %>!")
+    assert_equal("This should be \e[38;5;137mrgb_906030\e[0m!\n", @output.string)
+
+    @output.truncate(@output.rewind)
+
+    @terminal.say("This should be <%= ON_RGB_C06030 %>on_rgb_c06030<%= CLEAR %>!")
+    assert_equal("This should be \e[48;5;173mon_rgb_c06030\e[0m!\n", @output.string)
+
+    @output.truncate(@output.rewind)
+    
+    # Does class method work, too?
+    @terminal.say("This should be <%= HighLine.color('reverse underlined magenta', :reverse, :underline, :magenta) %>!")
+    assert_equal( "This should be \e[7m\e[4m\e[35mreverse underlined magenta\e[0m!\n",
+                  @output.string )
+
+    @output.truncate(@output.rewind)
+
     # turn off color
     old_setting = HighLine.use_color?
     assert_nothing_raised(Exception) { HighLine.use_color = false }
@@ -205,6 +227,27 @@ class TestHighLine < Test::Unit::TestCase
     assert_equal("This should be cyan!\n", @output.string)
     HighLine.use_color = old_setting
   end
+
+  def test_uncolor
+    # instance method
+    assert_equal( "This should be reverse underlined magenta!\n",
+                  @terminal.uncolor("This should be \e[7m\e[4m\e[35mreverse underlined magenta\e[0m!\n") 
+                )
+
+    @output.truncate(@output.rewind)
+
+    # class method
+    assert_equal( "This should be reverse underlined magenta!\n",
+                  HighLine.uncolor("This should be \e[7m\e[4m\e[35mreverse underlined magenta\e[0m!\n") 
+                )
+
+    @output.truncate(@output.rewind)
+
+    # RGB color
+    assert_equal( "This should be rgb_906030!\n",
+                  @terminal.uncolor("This should be \e[38;5;137mrgb_906030\e[0m!\n") 
+                )
+  end
                                   
   def test_confirm
     @input << "junk.txt\nno\nsave.txt\ny\n"
@@ -284,6 +327,9 @@ class TestHighLine < Test::Unit::TestCase
   def test_files
     @input << "#{File.basename(__FILE__)[0, 5]}\n"
     @input.rewind
+    
+    assert_equal "tc_hi\n",@input.read
+    @input.rewind
 
     file = @terminal.ask("Select a file:  ", File) do |q|
       q.directory = File.expand_path(File.dirname(__FILE__))
@@ -342,8 +388,8 @@ class TestHighLine < Test::Unit::TestCase
                   answers )
     assert_equal("Age:  Father's Age:  Wife's Age:  ", @output.string)
   end
-  
-  def test_lists
+ 
+  def test_lists 
     digits     = %w{Zero One Two Three Four Five Six Seven Eight Nine}
     erb_digits = digits.dup
     erb_digits[erb_digits.index("Five")] = "<%= color('Five', :blue) %%>"
@@ -368,7 +414,7 @@ class TestHighLine < Test::Unit::TestCase
     @terminal.say("<%= list(#{digits.inspect}, :columns_down, 3) %>")
     assert_equal( "Zero   Four   Eight\n" +
                   "One    Five   Nine \n" +
-                  "Two    Six  \n" +
+                  "Two    Six  \n"        +
                   "Three  Seven\n",
                   @output.string )
 
@@ -387,7 +433,7 @@ class TestHighLine < Test::Unit::TestCase
 
     @terminal.say("<%= list(#{colums_of_twenty.inspect}, :columns_down) %>")
     assert_equal( "12345678901234567890  12345678901234567890  " +
-                  "12345678901234567890\n" +
+                  "12345678901234567890\n"                       +
                   "12345678901234567890  12345678901234567890\n",
                   @output.string )
 
@@ -409,6 +455,89 @@ class TestHighLine < Test::Unit::TestCase
                   "12345678901234567890\n" +
                   "12345678901234567890\n",
                   @output.string )
+
+    @output.truncate(@output.rewind)
+    
+    wide = %w[0123456789 a b c d e f g h i j k l m n o p q r s t u v w x y z]
+
+    @terminal.say("<%= list( #{wide.inspect}, :uneven_columns_across ) %>")
+    assert_equal( "0123456789  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  " +
+                  "p  q  r  s  t  u  v  w\n"                                  +
+                  "x           y  z\n",
+                  @output.string )
+
+    @output.truncate(@output.rewind)
+
+    @terminal.say("<%= list( #{wide.inspect}, :uneven_columns_across, 10 ) %>")
+    assert_equal( "0123456789  a  b  c  d  e  f  g  h  i\n" +
+                  "j           k  l  m  n  o  p  q  r  s\n" +
+                  "t           u  v  w  x  y  z\n",
+                  @output.string )
+
+    @output.truncate(@output.rewind)
+
+    @terminal.say("<%= list( #{wide.inspect}, :uneven_columns_down ) %>")
+    assert_equal( "0123456789  b  d  f  h  j  l  n  p  r  t  v  x  z\n" +
+                  "a           c  e  g  i  k  m  o  q  s  u  w  y\n",
+                  @output.string )
+
+    @output.truncate(@output.rewind)
+
+    @terminal.say("<%= list( #{wide.inspect}, :uneven_columns_down, 10 ) %>")
+    assert_equal( "0123456789  c  f  i  l  o  r  u  x\n" +
+                  "a           d  g  j  m  p  s  v  y\n" +
+                  "b           e  h  k  n  q  t  w  z\n",
+                  @output.string )
+  end
+  
+  def test_lists_with_zero_items
+    modes = [nil, :rows, :inline, :columns_across, :columns_down]
+    modes.each do |mode|
+      result = @terminal.list([], mode)
+      assert_equal("", result)
+    end
+  end
+  
+  def test_lists_with_one_item
+    items = ['Zero']
+    modes = { nil            => "Zero\n",
+             :rows           => "Zero\n",
+             :inline         => "Zero",
+             :columns_across => "Zero\n",
+             :columns_down   => "Zero\n" }
+             
+    modes.each do |mode, expected|
+      result = @terminal.list(items, mode)
+      assert_equal(expected, result)
+    end
+  end
+  
+  def test_lists_with_two_items
+    items = ['Zero', 'One']
+    modes = { nil            => "Zero\nOne\n",
+             :rows           => "Zero\nOne\n",
+             :inline         => "Zero or One",
+             :columns_across => "Zero  One \n",
+             :columns_down   => "Zero  One \n" }
+             
+    modes.each do |mode, expected|
+      result = @terminal.list(items, mode)
+      assert_equal(expected, result)
+    end
+  end
+  
+  def test_lists_with_three_items
+    items = ['Zero', 'One', 'Two']
+    modes = { nil            => "Zero\nOne\nTwo\n",
+             :rows           => "Zero\nOne\nTwo\n",
+             :inline         => "Zero, One or Two",
+             :columns_across => "Zero  One   Two \n",
+             :columns_down   => "Zero  One   Two \n" }
+
+    modes.each do |mode, expected|
+      result = @terminal.list(items, mode)
+      assert_equal(expected, result)
+    end
   end
   
   def test_mode