riel 1.1.12 → 1.1.13

data/lib/riel/text.rb

@@ -1,415 +1,4 @@
 #!/usr/bin/ruby -w
 # -*- ruby -*-
 
-module Text
-
-  # Highlights text using either ANSI terminal codes, or HTML.
-
-  # Note that the foreground and background sections can have modifiers
-  # (attributes).
-  # 
-  # Examples:
-  #     black
-  #     blue on white
-  #     bold green on yellow
-  #     underscore bold magenta on cyan
-  #     underscore red on cyan
-  
-  class Highlighter
-
-    VERSION = "1.0.4"
-
-    ATTRIBUTES = %w{
-      none
-      reset
-      bold
-      underscore
-      underline
-      blink
-      negative
-      concealed
-      black
-      red
-      green
-      yellow
-      blue
-      magenta
-      cyan
-      white
-      on_black
-      on_red
-      on_green
-      on_yellow
-      on_blue
-      on_magenta
-      on_cyan
-      on_white
-    }
-    
-    NONE = Object.new
-    HTML = Object.new
-    ANSI = Object.new
-
-    COLORS      = %w{ black red green yellow blue magenta cyan white }
-    DECORATIONS = %w{ none reset bold underscore underline blink negative concealed }
-
-    BACKGROUND_COLORS = COLORS.collect { |color| "on_#{color}" }
-    FOREGROUND_COLORS = COLORS
-
-    COLORS_RE = Regexp.new('(?: ' + 
-                                # background will be in capture 0
-                                'on(?:\s+|_) ( ' + COLORS.join(' | ') + ' ) | ' +
-                                # foreground will be in capture 1
-                                '( ' + (COLORS + DECORATIONS).join(' | ') + ' ) ' +
-                            ')', Regexp::EXTENDED);
-
-    DEFAULT_COLORS = [
-      "black on yellow",
-      "black on green",
-      "black on magenta",
-      "yellow on black",
-      "magenta on black",
-      "green on black",
-      "cyan on black",
-      "blue on yellow",
-      "blue on magenta",
-      "blue on green",
-      "blue on cyan",
-      "yellow on blue",
-      "magenta on blue",
-      "green on blue",
-      "cyan on blue",
-    ]
-
-    attr_reader :colors
-    
-    def self.parse_colors str
-      str.scan(Regexp.new(COLORS_RE)).collect do |color|
-        color[0] ? "on_" + color[0] : color[1]
-      end
-    end
-
-    # returns a list of all color combinations.
-    def self.all_colors
-      all_colors = Array.new
-      ([ nil ] + DECORATIONS).each do |dec|
-        ([ nil ] + FOREGROUND_COLORS).each do |fg|
-          ([ nil ] + BACKGROUND_COLORS).each do |bg|
-            name = [ dec, fg, bg ].compact.join("_")
-            all_colors << name if name && name.length > 0
-          end
-        end
-      end
-      all_colors
-    end
-
-    # todo: change this to use method_missing:
-    if false
-      all_colors.each do |name|
-        meth = Array.new
-        meth << "def #{name}(&blk)"
-        meth << "  color(\"#{name}\", &blk)"
-        meth << "end"
-
-        self.class_eval meth.join("\n")
-      end
-    end
-    
-    def initialize colors
-      @colors = colors
-    end
-
-    def highlight str
-      # implemented by subclasses
-    end
-
-    def to_s
-      (@colors || '').join(' ')
-    end
-
-    def == other
-      return @colors.sort == other.colors.sort
-    end
-
-    # Colorizes the given object. If a block is passed, its return value is used
-    # and the stream is reset. If a String is provided as the object, it is
-    # colorized and the stream is reset. Otherwise, only the code for the given
-    # color name is returned.
-    
-    def color colorstr, obj = self, &blk
-      #                       ^^^^ this is the Module self
-
-      colornames = self.class.parse_colors colorstr
-      result     = names_to_code colornames
-      
-      if blk
-        result << blk.call
-        result << names_to_code("reset")
-      elsif obj.kind_of? String
-        result << obj
-        result << names_to_code("reset")
-      end
-      result
-    end
-
-    # returns the code for the given color string, which is in the format:
-    # foreground* [on background]?
-    # 
-    # Note that the foreground and background sections can have modifiers
-    # (attributes).
-    # 
-    # Examples:
-    #     black
-    #     blue on white
-    #     bold green on yellow
-    #     underscore bold magenta on cyan
-    #     underscore red on cyan
-
-    def code str
-      fg, bg = str.split(/\s*\bon_?\s*/)
-      (fg ? foreground(fg) : "") + (bg ? background(bg) : "")
-    end
-
-    # Returns the code for the given background color(s).
-    def background bgcolor
-      names_to_code "on_" + bgcolor
-    end
-
-    # Returns the code for the given foreground color(s).
-    def foreground fgcolor
-      fgcolor.split(/\s+/).collect { |fg| names_to_code fg }.join("")
-    end
-
-  end
-
-  # Highlights using ANSI escape sequences.
-  class ANSIHighlighter < Highlighter
-    ATTRIBUTES = Hash[
-      'none'       => '0', 
-      'reset'      => '0',
-      'bold'       => '1',
-      'underscore' => '4',
-      'underline'  => '4',
-      'blink'      => '5',
-      'negative'   => '7',
-      'concealed'  => '8',
-      'black'      => '30',
-      'red'        => '31',
-      'green'      => '32',
-      'yellow'     => '33',
-      'blue'       => '34',
-      'magenta'    => '35',
-      'cyan'       => '36',
-      'white'      => '37',
-      'on_black'   => '40',
-      'on_red'     => '41',
-      'on_green'   => '42',
-      'on_yellow'  => '43',
-      'on_blue'    => '44',
-      'on_magenta' => '45',
-      'on_cyan'    => '46',
-      'on_white'   => '47',
-    ]
-
-    RESET = "\e[0m"
-
-    def self.make str
-      colors = parse_colors str
-      ANSIHighlighter.new colors
-    end
-
-    def initialize colors = DEFAULT_COLORS
-      super
-      @code = nil
-    end
-
-    # Returns the escape sequence for the given names.
-    def names_to_code names
-      str = ""
-      names = [ names ] unless names.kind_of? Array
-      names.each do |name|
-        code = ATTRIBUTES[name]
-        if code
-          str << "\e[#{code}m"
-        end
-      end
-      str
-    end
-
-    def highlight str
-      @code ||= begin
-                  @code = @colors.collect do |color|
-                    names_to_code color
-                  end.join ""
-                end
-      
-      @code + str + RESET
-    end
-
-  end
-
-  # Highlights using HTML. Fonts are highlighted using <span> tags, not <font>.
-  # Also note that negative is translated to white on black.
-  # According to http://www.w3.org/TR/REC-CSS2/syndata.html#value-def-color,
-  # valid color keywords are: aqua, black, blue, fuchsia, gray, green, lime,
-  # maroon, navy, olive, purple, red, silver, teal, white, and yellow.
-  # Thus, no magenta or cyan.
-
-  class HTMLHighlighter < Highlighter
-    def initialize
-      # we need to know what we're resetting from (bold, font, underlined ...)
-      @stack = []
-    end
-
-    # Returns the start tag for the given name.
-    
-    def start_style name
-      case name
-      when "negative"
-        "<span style=\"color: white; background-color: black\">"
-      when /on_(\w+)/
-        colval = color_value $1
-        "<span style=\"background-color: #{colval}\">"
-      else
-        colval = color_value name
-        "<span style=\"color: #{colval}\">"
-      end
-    end
-
-    # Returns the end tag ("</span>").
-
-    def end_style
-      "</span>"
-    end
-
-    def color_value cname
-      case cname
-      when "cyan"
-        "#00FFFF"
-      when "magenta"
-        "#FF00FF"
-      else
-        cname
-      end
-    end
-
-    # Returns the code for the given name.
-    def names_to_code names
-      str = ""
-
-      names = [ names ] unless names.kind_of? Array
-
-      names.each do |name|
-        @stack << name
-
-        case name
-        when "none", "reset"
-          @stack.pop
-          if @stack.length > 0
-            begin
-              prev = @stack.pop
-              case prev
-              when "bold"
-                str << "</b>"
-              when "underscore", "underline"
-                str << "</u>"
-              when "blink"
-                str << "</blink>"
-              when "concealed"
-                str << " -->"
-              else
-                str << end_style
-              end
-            end while @stack.length > 0
-          end
-          str
-        when "bold"
-          str << "<b>"
-        when "underscore", "underline"
-          str << "<u>"
-        when "blink"
-          str << "<blink>"
-        when "concealed"
-          str << "<!-- "
-        else
-          str << start_style(name)
-        end
-      end
-
-      str
-    end
-  end
-
-  # Does no highlighting.
-
-  class NonHighlighter < Highlighter
-    def initialize
-      super nil
-    end
-
-    # Since the NonHighlighter does no highlighting, and thus its name, this
-    # returns an empty string.
-    def names_to_code colorname
-      ""
-    end
-  end
-
-  # An object that can be highlighted. This is used by the String class.
-
-  module Highlightable
-    # The highlighter for the class in which this module is included.
-    @@highlighter = ANSIHighlighter.new Text::Highlighter::DEFAULT_COLORS
-
-    if false
-      Text::Highlighter::ATTRIBUTES.each do |name|
-        meth = Array.new
-        meth << "def #{name}(&blk)"
-        meth << "  @@highlighter.color(\"#{name}\", self, &blk)"
-        meth << "end"
-
-        self.class_eval meth.join("\n")
-      end
-    end
-
-    # this dynamically adds methods for individual colors.
-    def method_missing(meth, *args, &blk)
-      if Text::Highlighter::all_colors.include? meth.to_s
-        methdecl = Array.new
-        methdecl << "def #{meth}(&blk)"
-        methdecl << "  @@highlighter.color(\"#{meth}\", self, &blk)"
-        methdecl << "end"
-        self.class.class_eval methdecl.join("\n")
-        send meth, *args, &blk
-      else
-        super
-      end
-    end
-
-    # Sets the highlighter for this class. This can be either by type or by
-    # String.
-    def highlighter= hl
-      $VERBOSE = false
-      @@highlighter = case hl
-                      when Text::Highlighter
-                        hl
-                      when Text::Highlighter::NONE, "NONE", nil
-                        Text::NonHighlighter.new #  unless @@highlighter.kind_of?(Text::NonHighlighter)
-                      when Text::Highlighter::HTML, "HTML"
-                        Text::HTMLHighlighter.new # unless @@highlighter.kind_of?(Text::HTMLHighlighter)
-                      when Text::Highlighter::ANSI, "ANSI"
-                        Text::ANSIHighlighter.new
-                      else
-                        Text::NonHighlighter.new
-                      end
-      
-    end
-  end
-  $HAVE_TEXT_HIGHLIGHT = true
-end
-
-# String is extended to support highlighting.
-
-class String
-  include Text::Highlightable
-  extend Text::Highlightable
-end
+require 'riel/text/string'

data/lib/riel.rb

@@ -4,7 +4,7 @@ $:.unshift(riellibdir) unless
   $:.include?(riellibdir) || $:.include?(File.expand_path(riellibdir))
 
 module RIEL
-  VERSION = '1.1.12'
+  VERSION = '1.1.13'
 end
 
 rbfiles = Dir[riellibdir + "/riel/**/*.rb"]

data/test/riel/command_test.rb

@@ -5,18 +5,19 @@ require 'test/unit'
 require 'riel/command'
 
 class CommandTestCase < Test::Unit::TestCase
-  def test_all
-    assert_equal [ "/bin/ls\n" ], Command.run("ls", "/bin/ls")
-    assert_equal [ "/bin/grep\n", "/bin/ls\n" ], Command.run("ls", "/bin/ls", "/bin/grep" )
+  def run_command_test expected, *args
+    assert_equal expected, Command.run(*args)
+  end
 
-    lnum = 0
-    expected = [ "/bin/grep\n", "/bin/ls\n" ]
-    lines = Command.run("ls", "/bin/ls", "/bin/grep" ) do |line|
-      assert_equal expected[lnum], line
-      lnum += 1
-    end
-    assert_equal expected, lines
+  def test_one_returned
+    run_command_test [ "/bin/ls\n" ], "ls", "/bin/ls"
+  end
+
+  def test_two_returned
+    run_command_test [ "/bin/grep\n", "/bin/ls\n" ], "ls", "/bin/ls", "/bin/grep"
+  end
 
+  def test_with_line_numbers
     expected = [ "/bin/grep\n", "/bin/ls\n" ]
     lines = Command.run("ls", "/bin/ls", "/bin/grep" ) do |line, ln|
       assert_equal expected[ln], line

data/test/riel/date_test.rb

@@ -5,11 +5,28 @@ require 'test/unit'
 require 'riel/date'
 
 class DateTestCase < Test::Unit::TestCase
-  def test_simple
-    assert_equal 28, Date.days_in_month(2010, 2)
-    assert_equal 31, Date.days_in_month(2010, 1)
-    assert_equal 29, Date.days_in_month(2008, 2)
-    assert_equal 30, Date.days_in_month(2007, 6)
-    assert_equal 31, Date.days_in_month(2010, 12)
+  def run_date_test expected, year, month
+    dim = Date.days_in_month(year, month)
+    assert_equal expected, dim, "year: #{year}; month: #{month}"
+  end
+
+  def test_january
+    run_date_test 31, 2010, 1
+  end
+
+  def test_june
+    run_date_test 30, 1997, 6
+  end
+
+  def test_december
+    run_date_test 31, 1967, 12
+  end
+
+  def test_february_non_leap_year
+    run_date_test 28, 2010, 2
+  end
+
+  def test_february_leap_year
+    run_date_test 29, 2008, 2
   end
 end

data/test/riel/file_test.rb

@@ -23,7 +23,7 @@ class FileTestCase < Test::Unit::TestCase
   end
 
   def create_binary_file
-    stringio_so = "/usr/lib/ruby/1.8/i386-linux/stringio.so"
+    stringio_so = '/usr/lib/ruby/1.9.1/x86_64-linux/socket.so'
 
     tempname = nil
 
@@ -39,17 +39,28 @@ class FileTestCase < Test::Unit::TestCase
     tempname
   end
 
-  def test_file_types
+  def test_text_is_text
     text_file = create_text_file
     assert File.text?(text_file)
+  end
+
+  def test_text_is_not_binary
+    text_file = create_text_file
     assert !File.binary?(text_file)
-    
+  end
+
+  def test_binary_is_binary
     if binary_file = create_binary_file
-      assert !File.text?(binary_file)
       assert File.binary?(binary_file)
     end
   end
 
+  def test_binary_is_not_binary
+    if binary_file = create_binary_file
+      assert !File.text?(binary_file)
+    end
+  end
+
   def test_is_file_is_directory
     file = create_text_file
 

data/test/riel/io_test.rb

@@ -24,11 +24,11 @@ class IOTestCase < Test::Unit::TestCase
     writelines << "this is line one"
     writelines << "line two is this"
 
-    puts "writelines: <<<#{writelines}>>>"
-    
     IO.writelines name, writelines
 
     readlines = IO::readlines name
     assert_equal writelines.collect { |line| line + "\n" }, readlines
+
+    File.delete name
   end
 end

data/test/riel/setdiff_test.rb

@@ -5,19 +5,40 @@ require 'test/unit'
 require 'riel/setdiff'
 
 class SetDiffTestCase < Test::Unit::TestCase
-  def run_test a, b, expected
+  def assert_diff_type a, b, expected
     sd = SetDiff.new a, b
     assert_equal expected, sd.diff_type
   end
 
-  def test_all
-    run_test %w{ one two three }, %w{ two one three },  :identical
-    run_test %w{ one two },       %w{ two one three },  :b_contains_a
-    run_test %w{ one two three }, %w{ two },            :a_contains_b
-    run_test %w{ one two three }, %w{ four five six },  :no_common
-    run_test %w{ one two three }, %w{ },                :no_common
-    run_test %w{ },               %w{ one two three },  :no_common
-    run_test %w{ },               %w{ },                :no_common
-    run_test %w{ one two three},  %w{ two three four }, :common
+  def test_identical_same_order
+    assert_diff_type %w{ one two three }, %w{ one two three },  :identical
+  end
+
+  def test_identical_different_order
+    assert_diff_type %w{ one two three }, %w{ two one three },  :identical
+  end
+
+  def test_common
+    assert_diff_type %w{ one two three }, %w{ one dos three },  :common
+  end
+
+  def test_b_contains_a
+    assert_diff_type %w{ one two }, %w{ two one three },  :b_contains_a
+  end
+
+  def test_a_contains_b
+    assert_diff_type %w{ one two three }, %w{ one two },  :a_contains_b
+  end
+
+  def test_no_common_nonempty
+    assert_diff_type %w{ one two three }, %w{ four five six },  :no_common
+  end
+
+  def test_no_common_empty
+    assert_diff_type %w{ one two three }, %w{ },  :no_common
+  end
+
+  def test_no_common_both_empty
+    assert_diff_type %w{ }, %w{ }, :no_common
   end
 end

data/test/riel/string_test.rb

@@ -52,9 +52,4 @@ class StringToRangeTestCase < Test::Unit::TestCase
     assert_equal "foo", "food" - "d"
     assert_equal "fd",  "food" - %r{o+}
   end
-
-  def test_highlight
-    assert_equal "...\e[34mthis\e[0m... is blue", "...this... is blue".highlight(%r{this}, "blue")
-    assert_equal "...\e[34m\e[42mthis\e[0m... is blue", "...this... is blue".highlight(%r{this}, "blue on green")
-  end
 end