riel 1.0.0

data/test/riel/dir_test.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'pathname'
+require 'riel/dir'
+require 'riel/file'
+
+class DirTestCase < RUNIT::TestCase
+
+  def test_home
+    assert_equal ENV["HOME"], Dir.home
+  end
+
+  def test_remove_if_empty
+    # set up a mess of files in /tmp ...
+
+    tmpdir = Pathname.new('/tmp')
+
+    # maybe this isn't Linux (poor devils!):
+    return unless tmpdir.exist?
+
+    testdir = tmpdir + 'riel_dir_test'
+    if testdir.exist?
+      testdir.delete
+    end
+
+    testdir.mkdir
+    assert testdir.exist?
+
+    # create a structure like this:
+    layout = [
+      :a => [ 
+        :a0 => %w{ a00 a01 a02 }
+      ],
+      :b => [ 
+        :b0 => %w{  },
+        :b1 => %w{ b10 b11 }
+      ]
+    ]
+
+    a = testdir + 'a'
+    a.mkdir
+    (0 .. 5).each do |ai|
+      adir = a + "a#{ai}"
+      adir.mkdir
+    end
+
+    Dir.remove_if_empty(a, :verbose => false)
+
+    assert !a.exist?
+
+    a = testdir + 'a'
+    a.mkdir
+    (0 .. 5).each do |ai|
+      adir = a + "a#{ai}"
+      adir.mkdir
+      (0 .. 4).each do |aai|
+        aafile = adir + "aa#{aai}"
+        File.write_file(aafile) do
+          (4 .. rand(50)).collect do |li|
+            "line #{li}"
+          end
+        end
+      end
+    end
+
+    Dir.remove_if_empty(a)
+    assert a.exist?
+
+    Dir.remove_if_empty(a, :deletable => [ %r{aa\d+} ])
+
+    assert !a.exist?
+
+    a = testdir + 'a'
+    a.mkdir
+    (0 .. 5).each do |ai|
+      adir = a + "a#{ai}"
+      adir.mkdir
+      (0 .. 4).each do |aai|
+        aafile = adir + "foo.bar"
+        File.write_file(aafile) do
+          (4 .. rand(50)).collect do |li|
+            "line #{li}"
+          end
+        end
+      end
+    end
+
+    Dir.remove_if_empty(a)
+    assert a.exist?
+
+    Dir.remove_if_empty(a, :deletable => %w{ foo.bar })
+    assert !a.exist?
+
+    testdir.delete
+  end
+end

data/test/riel/enumerable_test.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pathname'
+require 'rubyunit'
+require 'riel/enumerable'
+
+class EnumerableTestCase < RUNIT::TestCase
+
+  def test_collect_with_index
+    assert_equals([ 0, 5, 12, 21, 32 ],     (4   ..   8).collect_with_index { |val, idx| val * idx })
+    assert_equals([ "", "b", "cc", "ddd" ], ('a' .. 'd').collect_with_index { |str, idx| str * idx })
+  end
+  
+  def test_select_with_index
+    assert_equals([ 5, 6, 7, 8 ], (4 .. 8).select_with_index { |val, idx| val >= 5 })
+    assert_equals([ 6 ],          (4 .. 8).select_with_index { |val, idx| val * idx == 12 })
+    assert_equals([],             (4 .. 8).select_with_index { |val, idx| idx - val > 0  })
+  end
+
+  def test_detect_with_index
+    assert_equals(5,   (4 .. 8).detect_with_index { |val, idx| val >= 5 })
+    assert_equals(6,   (4 .. 8).detect_with_index { |val, idx| val * idx == 12 })
+    assert_equals(nil, (4 .. 8).detect_with_index { |val, idx| idx - val > 0  })
+  end
+
+end

data/test/riel/env_test.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/env'
+
+class EnvTestCase < RUNIT::TestCase
+
+  def test_home_directory
+    # Unix
+    
+    ENV["HOME"] = "/home/me"
+    
+    assert_equals "/home/me", Env.home_directory
+
+    # Windows
+    
+    ENV["HOME"] = nil
+    ENV["HOMEDRIVE"] = "c:"
+    
+    assert_equals "c:\\", Env.home_directory
+
+    ENV["HOME"] = nil
+    ENV["HOMEDRIVE"] = nil
+    ENV["HOMEPATH"] = "\\Program Files\\User"
+    
+    assert_equals "\\Program Files\\User", Env.home_directory
+    
+    ENV["HOME"] = nil
+    ENV["HOMEDRIVE"] = "c:"
+    ENV["HOMEPATH"] = "\\Program Files\\User"
+    
+    # assert_equals "c:\\Program Files\\User", Env.home_directory
+  end
+
+  def do_split_test(expected, input)
+    ENV["FOO"] = input
+    
+    result = Env.split("FOO")
+
+    assert_equals expected, result
+  end
+  
+  def test_split
+    do_split_test(%w{ testing }, "testing")
+    do_split_test(%w{ this is }, "this is")
+    do_split_test(%w{ this is }, '"this" "is"')
+    do_split_test(%w{ this is a test }, '"this" "is" \'a\' "test"')
+    do_split_test(%w{ this is a tes't }, '"this" "is" \'a\' "tes\'t"')
+  end
+
+end

data/test/riel/file_test.rb

@@ -0,0 +1,242 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/file'
+require 'riel/tempfile'
+require 'pathname'
+
+
+class FileTestCase < RUNIT::TestCase
+
+  def get_file_rootname
+    Pathname.new(__FILE__).rootname
+  end
+
+  def create_text_file
+    rootname = Pathname.new(__FILE__).rootname
+    Tempfile.open(rootname) do |tf|
+      tf.puts "this is some text"
+      tf.puts "this is more text"
+      tf.puts "even more text"
+      tf.puts "and some final text"
+    end
+  end
+
+  def create_binary_file
+    stringio_so = "/usr/lib/ruby/1.8/i386-linux/stringio.so"
+
+    tempname = nil
+
+    if File.exist?(stringio_so)
+      rootname = Pathname.new(__FILE__).rootname
+      tempname = Tempfile.open(rootname) do |tf|
+        tf.write IO.read(stringio_so)
+      end
+    else
+      $stderr.puts "not testing binary file: #{stringio_so} does not exist"
+    end
+
+    tempname
+  end
+
+  def test_file_types
+    text_file = create_text_file
+    assert(File.text?(text_file))
+    assert(!File.binary?(text_file))
+    
+    if binary_file = create_binary_file
+      assert(!File.text?(binary_file))
+      assert(File.binary?(binary_file))
+    end
+  end
+
+  def test_is_file_is_directory
+    file = create_text_file
+
+    dir = Pathname.new(file).dirname
+
+    assert(File.is_file?(file))
+    assert(!File.is_file?(dir))
+
+    assert(!File.is_directory?(file))
+    assert(File.is_directory?(dir))
+
+    # this should have access only by root:
+
+    file = "/var/log/httpd/error_log"
+    assert(!File.is_file?(file))
+    assert(!File.is_directory?(file))
+    
+  end
+
+  def test_read_write_file
+    filename = Tempfile.new(Pathname.new(__FILE__).rootname).path
+
+    File.write_file(filename) do
+      "hello, world"
+    end
+
+    line = nil
+    File.read_file(filename) do |ln|
+      line = ln
+    end
+
+    assert_equal("hello, world", line)
+  end
+
+  def test_read_put_file
+    filename = Tempfile.new(Pathname.new(__FILE__).rootname).path
+
+    File.put_file(filename) do
+      "hello, world"
+    end
+
+    line = nil
+    File.read_file(filename) do |ln|
+      line = ln
+    end
+
+    assert_equal("hello, world\n", line)
+
+    File.put_file(filename) do
+      [
+        "hello, world",
+        "this is a test"
+      ]
+    end
+
+    lines = Array.new
+    File.read_file_lines(filename) do |ln|
+      lines << ln
+    end
+
+    assert_equal([ "hello, world\n", "this is a test\n" ] , lines)
+  end
+
+  def test_open_via_temp_file
+    fname = "/tmp/test_open_via_temp_file.#{$$}"
+
+    pn = Pathname.new(fname)
+
+    assert !pn.exist?
+    
+    File.open_via_temp_file(fname) do |io|
+      assert !pn.exist?
+      io.puts "this is a test"
+    end
+
+    assert pn.exist?
+
+    pn.delete
+  end
+
+  def assert_files_existence(expected, files)
+    files.each do |file|
+      assert_equal expected, file.exist?
+    end
+  end
+
+  def test_move_files
+    tmp = Pathname.new("/tmp")
+    
+    assert tmp.exist?
+
+    tgt = tmp + "movetest"
+
+    fnums = 0 .. 3
+    
+    srcfiles = fnums.collect { |num| Pathname.new(tmp + "movefile#{num}") }
+
+    # if the user has something there, we shouldn't delete it at the end of
+    # these tests.
+
+    assert !tgt.exist?
+    
+    begin
+      tgt.mkdir
+      
+      srcfiles.each do |file|
+        assert !file.exist?
+        
+        File.write_file(file) do
+          "contents of file"
+        end
+        
+        assert file.exist?
+      end
+
+      File.move_files(tgt, srcfiles)
+
+      assert_files_existence(false, srcfiles)
+
+      tgtfiles = fnums.collect { |num| tgt + "movefile#{num}" }
+
+      assert_files_existence(true, tgtfiles)
+    ensure
+      if tgt && tgt.exist?
+        tgt.children.each do |child|
+          child.delete
+        end
+
+        tgt.delete if tgt && tgt.exist?
+      end
+      
+      srcfiles.each do |file|
+        file.delete if file && file.exist?
+      end
+    end
+  end
+
+  def test_copy_files
+    tmp = Pathname.new("/tmp")
+    
+    assert tmp.exist?
+
+    tgt = tmp + "copytest"
+
+    fnums = 0 .. 3
+    
+    srcfiles = fnums.collect { |num| Pathname.new(tmp + "copyfile#{num}") }
+
+    # if the user has something there, we shouldn't delete it at the end of
+    # these tests.
+
+    assert !tgt.exist?
+    
+    begin
+      tgt.mkdir
+      
+      srcfiles.each do |file|
+        assert !file.exist?
+        
+        File.write_file(file) do
+          "contents of file"
+        end
+        
+        assert file.exist?
+      end
+
+      File.copy_files(tgt, srcfiles)
+
+      assert_files_existence(true, srcfiles)
+
+      tgtfiles = fnums.collect { |num| tgt + "copyfile#{num}" }
+
+      assert_files_existence(true, tgtfiles)
+    ensure
+      if tgt && tgt.exist?
+        tgt.children.each do |child|
+          child.delete
+        end
+
+        tgt.delete if tgt && tgt.exist?
+      end
+      
+      srcfiles.each do |file|
+        file.delete if file && file.exist?
+      end
+    end
+  end
+
+end

data/test/riel/filetype_test.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/filetype'
+
+
+class FileTypeTestCase < RUNIT::TestCase
+
+  def test_default_extensions
+    ft = FileType.instance
+
+    assert(ft.text_extensions.include?("rb"))
+
+    assert(!ft.text_extensions.include?("rbx"))
+    assert(!ft.text_extensions.include?("tar"))
+    assert(!ft.text_extensions.include?("jar"))
+    assert(!ft.text_extensions.include?("gz"))
+
+    assert(ft.nontext_extensions.include?("tar"))
+    assert(ft.nontext_extensions.include?("jar"))
+    assert(ft.nontext_extensions.include?("gz"))
+
+    ft.set_extensions(true, "rbx")
+    assert(ft.text_extensions.include?("rbx"))
+
+    ft.set_extensions(true, "foo", "bar")
+    assert(ft.text_extensions.include?("foo"))
+    assert(ft.text_extensions.include?("bar"))
+  end
+
+end

data/test/riel/hash_test.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/hash'
+
+class HashTestCase < RUNIT::TestCase
+
+  def test
+  end
+
+end

data/test/riel/io_test.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/env'
+
+class IOTestCase < RUNIT::TestCase
+
+  def test_readlines
+    orig = $/
+
+    $/ = nil
+
+    contents = IO.readlines(__FILE__)
+    
+    assert_not_nil contents
+    assert contents.size > 0
+
+    $/ = orig
+  end
+
+end

data/test/riel/log_test.rb

@@ -0,0 +1,184 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pathname'
+require 'rubyunit'
+require 'stringio'
+require 'riel/log'
+
+class LogTestCase < RUNIT::TestCase
+  include Loggable
+
+  def test_no_output
+    # I could make this an instance variable, but I want to check the method
+    # names in the output string.
+
+    log = Proc.new { 
+      Log.log   "hello, world?"
+      Log.debug "hello, world?"
+      Log.info  "hello, world?"
+      Log.warn  "EXPECTED OUTPUT TO STDERR: hello, world." # will go to stderr
+      Log.error "EXPECTED OUTPUT TO STDERR: hello, world." # will go to stderr
+      Log.stack "hello, world?"
+    }
+    
+    run_test(@nonverbose_setup, log)
+  end
+
+  def test_output_arg
+    log = Proc.new { 
+      Log.log   "hello, world?"
+      Log.debug "hello, world?"
+      Log.info  "hello, world?"
+      Log.warn  "hello, world?"
+      Log.error "hello, world?"
+      Log.stack "hello, world?"
+    }
+
+    expected_output = [
+      "[log_test.rb    :  33] {test_output_arg     } hello, world?",
+      "[log_test.rb    :  34] {test_output_arg     } hello, world?",
+      "[log_test.rb    :  35] {test_output_arg     } hello, world?",
+      "[log_test.rb    :  36] {test_output_arg     } hello, world?",
+      "[log_test.rb    :  37] {test_output_arg     } hello, world?",
+      "[log_test.rb    :  38] {test_output_arg     } hello, world?",
+      "[log_test.rb    : 165] {call                } ",
+      "[log_test.rb    : 165] {run_test            } ",
+      "[log_test.rb    :  71] {test_output_arg     } ",
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+    ]
+
+    run_test(@verbose_setup, log, *expected_output)
+  end
+
+  def test_output_block
+    log = Proc.new { 
+      Log.log { "hello, world?" }
+    }
+    
+    run_test(@verbose_setup, log, "[log_test.rb    :  76] {test_output_block   } hello, world?")
+
+    info_setup = Proc.new {
+      Log.level = Log::INFO
+      Log.output  = StringIO.new
+    }
+
+    evaluated = false
+    log = Proc.new { 
+      Log.debug { evaluated = true; "hello, world?" }
+    }
+    
+    run_test(info_setup, log)
+    
+    assert_equals false, evaluated
+  end
+
+  def test_instance_log
+    log = Proc.new { 
+      log "hello, world?"
+    }
+    
+    Log.set_widths(-15, 4, -40)
+    run_test(@verbose_setup, log, "[log_test.rb    :  98] {LogTestCase#test_instance_log           } hello, world?")
+
+    Log.set_default_widths
+  end
+
+  def test_colors
+    log = Proc.new { 
+      white "white wedding"
+      blue "blue iris"
+      on_cyan "red"
+    }
+    
+    run_test(@verbose_setup, log,
+             "[log_test.rb    : 109] {LogTestCase#test_col} \e[37mwhite wedding\e[0m",
+             "[log_test.rb    : 110] {LogTestCase#test_col} \e[34mblue iris\e[0m",
+             "[log_test.rb    : 111] {LogTestCase#test_col} \e[46mred\e[0m")
+
+    Log.set_default_widths
+  end
+
+  def test_format
+    log = Proc.new { 
+      Log.log "hello, world?"
+    }
+    
+    Log.set_default_widths
+    run_test(@verbose_setup, log, "[log_test.rb    : 124] {test_format         } hello, world?")
+
+    # Log.set_widths(file_width, line_width, func_width)
+    
+    run_format_test(log, -25,    8, 30, "[log_test.rb              :     124] {                   test_format} hello, world?")
+    run_format_test(log,  25,    8, 30, "[              log_test.rb:     124] {                   test_format} hello, world?")
+    run_format_test(log,  25, "08", 30, "[              log_test.rb:00000124] {                   test_format} hello, world?")
+    
+    # useless feature of truncating line numbers, but so it goes ...
+    run_format_test(log,   4,   2, -10, "[log_:12] {test_forma} hello, world?")
+    
+    Log.set_default_widths
+  end
+
+  def run_format_test(log, file_width, line_width, func_width, expected)
+    Log.set_widths(file_width, line_width, func_width)
+    run_test(@verbose_setup, log, expected)
+  end    
+
+  # the ctor is down here so the lines above are less likely to change.
+  def initialize(test, name)
+    @nonverbose_setup = Proc.new {
+      Log.verbose = false
+      Log.output  = StringIO.new
+    }
+    
+    @verbose_setup = Proc.new {
+      Log.verbose = true
+      Log.output  = StringIO.new
+    }
+
+    super
+  end
+
+  def run_test(setup, log, *expected)
+    io = setup.call
+
+    log.call
+
+    assert_not_nil(io)
+    str = io.string
+    assert_not_nil str
+
+    lines = str.split("\n")
+
+    assert_equals expected.size, lines.size, "number of lines of output"
+
+    (0 ... expected.size).each do |idx|
+      if expected[idx]
+        assert_equals expected[idx], lines[idx], "index: #{idx}"
+      end
+    end
+
+    Log.output = io
+  end
+
+end

data/test/riel/matchdata_test.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/matchdata'
+
+
+class MatchDataTestCase < RUNIT::TestCase
+
+  def test_inspect
+    md = %r{(foo)(.*)(bar)}.match("footloose sidebar")
+    assert_equals "[\"footloose sidebar\", \"foo\", \"tloose side\", \"bar\"]", md.inspect
+  end
+
+end