logue 1.0.8 → 1.0.9

data/test/logue/colors_test.rb

@@ -1,12 +0,0 @@
-#!/usr/bin/ruby -w
-# -*- ruby -*-
-
-require 'logue/colors'
-require 'test/unit'
-
-class ColorsTest < Test::Unit::TestCase
-  def test_valid_colors
-    result = Colors.valid_colors
-    assert_equal [ :black, :red, :green, :yellow, :blue, :magenta, :cyan, :white, :default ], result.keys
-  end
-end

data/test/logue/format_test.rb

@@ -1,59 +0,0 @@
-#!/usr/bin/ruby -w
-# -*- ruby -*-
-
-require 'test/unit'
-require 'logue/format'
-
-class Logue::FormatTestCase < Test::Unit::TestCase
-  # use as:
-  # msg "path", path, "lineno", lineno, "cls", cls, "func", func
-  def message(*fields)
-    fields.each_slice(2).collect do |field, value|
-      "#{field}: #{value}"
-    end.join "; "
-  end
-
-  def assert_instance_variable expected, obj, name
-    val = obj.instance_eval name
-    assert_equal expected, val, "name: #{name}; expected: #{expected}; result: #{val}"
-    val
-  end
-
-  def test_default_values
-    fmt = Logue::Format.new
-    assert_instance_variable Logue::FormatWidths::DEFAULT_FILENAME, fmt, "@file_width"
-    assert_instance_variable Logue::FormatWidths::DEFAULT_LINENUM, fmt, "@line_width"
-    assert_instance_variable Logue::FormatWidths::DEFAULT_FUNCTION, fmt, "@method_width"
-    assert_instance_variable true, fmt, "@trim"
-  end
-
-  def assert_format expected, path, lineno, cls, func
-    msg = message "path", path, "lineno", lineno, "cls", cls, "func", func
-    fmt = Logue::Format.new
-    fmt.format path, lineno, cls, func
-    result = fmt.format path, lineno, cls, func
-    assert_equal expected, result, msg
-  end
-
-  def test_write
-    path = "/a/long/path/to/the/directory/abc.t"
-    lineno = 1    
-    func = "block (2 levels) in one"
-    cls = nil
-    expected = "[.../the/directory/abc.t  :   1] {block (2 levels) in }"
-    assert_format expected, path, lineno, cls, func
-  end
-
-  def test_copy
-    fmt = Logue::Format.new line_width: 77
-    val = fmt.instance_eval "@line_width"
-    assert_equal 77, val
-    
-    copy = fmt.copy method_width: 123
-    val = copy.instance_eval "@line_width"
-    assert_equal 77, val
-    
-    val = copy.instance_eval "@method_width"
-    assert_equal 123, val
-  end
-end

data/test/logue/log_test.rb

@@ -1,88 +0,0 @@
-#!/usr/bin/ruby -w
-# -*- ruby -*-
-
-require 'test/unit'
-require 'logue/log'
-
-class Logue::LogTest < Test::Unit::TestCase
-  def assert_accessor_methods rdmeth, *values
-    wrmeth = (rdmeth.to_s + "=").to_sym
-    logger = Logue::Log.logger
-    values.each do |value|
-      Logue::Log.send wrmeth, value
-      
-      assert_equal value, logger.send(rdmeth)
-      assert_equal value, Logue::Log.send(rdmeth)
-    end
-  end
-  
-  def assert_read_method rdmeth, *values
-    values.each do |value|
-      Logue::Log.send rdmeth, *value
-    end
-  end
-  
-  def test_delegator_verbose
-    assert_accessor_methods :verbose, false, true
-  end
-
-  def test_delegator_level
-    assert_accessor_methods :level, Logue::Log::Severity::FATAL, Logue::Log::Severity::INFO
-  end
-  
-  def test_delegator_quiet
-    assert_accessor_methods :quiet, true, false
-  end
-
-  def test_delegator_format
-    # no logger.format method yet:
-    return if true
-    assert_accessor_methods :format, "abc", "def"
-  end
-  
-  def test_delegator_output
-    assert_accessor_methods :output, "abc", "def"
-  end
-  
-  def test_delegator_colorize_line
-    assert_accessor_methods :colorize_line, false, true
-  end
-
-  def assert_outfile_equals value
-    # is called, but converted from value to File.new(value)
-    Logue::Log.outfile = value
-  end
-  
-  def test_delegator_outfile
-    assert_outfile_equals "/tmp/logue_test_abc"
-  end
-
-  def test_ignore_file
-    assert_read_method :ignore_file, true, false
-  end
-    
-  def test_ignore_method
-    assert_read_method :ignore_method, true, false
-  end
-    
-  def test_ignore_class
-    assert_read_method :ignore_class, true, false
-  end
-
-  def test_log_file
-    assert_read_method :log_file, true, false
-  end
-    
-  def test_log_method
-    assert_read_method :log_method, true, false
-  end
-    
-  def test_log_class
-    assert_read_method :log_class, true, false
-  end
-    
-  def test_set_color
-    lvl = Logue::Log::Severity::FATAL
-    assert_read_method :set_color, [ lvl, :red ], [ lvl, :none ]
-  end
-end

data/test/logue/loggable_test.rb

@@ -1,72 +0,0 @@
-#!/usr/bin/ruby -w
-# -*- ruby -*-
-
-require 'test/unit'
-require 'logue/loggable'
-
-class LoggableTest < Test::Unit::TestCase
-  def test_respond_to_colors
-    obj = Object.new
-    obj.extend Logue::Loggable
-
-    # from rainbow/color:
-    
-    colors = [
-      :black,
-      :red,
-      :green,
-      :yellow,
-      :blue,
-      :magenta,
-      :cyan,
-      :white,
-      :default
-    ]
-    
-    colors.each do |color|
-      assert_respond_to obj, color, "color: #{color}"
-    end
-  end
-
-  # poor man's mock
-  class TestLogDelegate
-    class << self
-      attr_accessor :invoked
-      
-      def method_missing meth, *args, &blk
-        @invoked = { name: meth, args: args }
-      end
-
-      def respond_to? meth, include_all = false
-        true
-      end
-    end
-  end
-  
-  def test_delegation
-    obj = Object.new
-    obj.extend Logue::Loggable
-
-    def obj.delegate_log_class
-      TestLogDelegate
-    end
-
-    delegate_methods = Array.new.tap do |ary|
-      ary << :log
-      ary << :debug
-      ary << :info
-      ary << :warn
-      ary << :error
-      ary << :fatal
-      ary << :stack
-      ary << :write
-    end
-
-    delegate_methods.each do |dmeth|
-      TestLogDelegate.invoked = nil
-      obj.send dmeth, "abc"
-      invoked = TestLogDelegate.invoked      
-      assert_equal dmeth, invoked[:name], "method: #{dmeth}"
-    end
-  end
-end

data/test/logue/logger_test.rb

@@ -1,30 +0,0 @@
-#!/usr/bin/ruby -w
-# -*- ruby -*-
-
-require 'test/unit'
-require 'logue/logger'
-
-class LoggerTest < Test::Unit::TestCase
-  def test_default
-    logger = Logue::Logger.new
-
-    assert_equal Logue::Log::Severity::FATAL, $LOGGING_LEVEL
-    assert_equal Logue::Log::Severity::FATAL, logger.level
-
-    assert_equal false, logger.quiet
-    assert_equal $stdout, logger.output
-    assert_equal false, logger.colorize_line
-
-    assert_equal Hash.new, logger.ignored_files
-    assert_equal Hash.new, logger.ignored_methods
-    assert_equal Hash.new, logger.ignored_classes
-    assert_equal true, logger.trim
-
-    assert_equal false, logger.verbose
-  end
-
-  def test_respond_to
-    logger = Logue::Logger.new
-    assert_equal true, logger.respond_to?(:blue)
-  end 
-end

data/test/logue/pathutil_test.rb

@@ -1,73 +0,0 @@
-#!/usr/bin/ruby -w
-# -*- ruby -*-
-
-require 'test/unit'
-require 'logue/pathutil'
-
-class Logue::PathUtilTestCase < Test::Unit::TestCase
-  # trim_left
-
-  def run_trim_left_test expected, length, str = "something"
-    trimmed = Logue::PathUtil.trim_left str, length
-    assert_equal expected, trimmed
-  end
-
-  def test_trim_left_short_positive_number
-    run_trim_left_test "some", 4
-  end
-
-  def test_trim_left_long
-    run_trim_left_test "something", 10
-  end
-
-  def test_trim_left_short_negative_number
-    run_trim_left_test "some", -4
-  end
-
-  # trim_right
-
-  def assert_trim_right expected, length, str
-    trimmed = Logue::PathUtil.trim_right str, length
-    assert_equal expected, trimmed, "length: #{length}"
-  end
-
-  def test_trim_right_path_excess
-    assert_trim_right "ab/cd/ef.t", 11, "ab/cd/ef.t"
-  end
-
-  def test_trim_right_path_at_length
-    assert_trim_right "ab/cd/ef.t", 10, "ab/cd/ef.t"
-  end
-
-  def test_trim_right_path_one_less
-    assert_trim_right ".../ef.t", 9, "ab/cd/ef.t"
-  end
-
-  def test_trim_right_path_two_less
-    assert_trim_right ".../ef.t", 8, "ab/cd/ef.t"
-  end
-
-  def test_trim_right_path_three_less
-    assert_trim_right "ef.t", 7, "ab/cd/ef.t"
-  end
-
-  def test_trim_right_path_four_less
-    assert_trim_right "ef.t", 6, "ab/cd/ef.t"
-  end
-
-  def test_trim_right_path_five_less
-    assert_trim_right "ef.t", 5, "ab/cd/ef.t"
-  end
-
-  def test_trim_right_path_six_less
-    assert_trim_right "ef.t", 4, "ab/cd/ef.t"
-  end
-
-  def test_trim_right_path_seven_less
-    assert_trim_right "ef.t", 3, "ab/cd/ef.t"
-  end
-
-  def test_trim_right_path_eight_less
-    assert_trim_right "ef.t", 2, "ab/cd/ef.t"
-  end
-end

data/test/logue/testlog/log_stack_test.rb

@@ -1,97 +0,0 @@
-#!/usr/bin/ruby -w
-# -*- ruby -*-
-
-require 'pathname'
-require 'test/unit'
-require 'stringio'
-require 'logue'
-
-include Logue
-
-class LogAbyss
-  include Loggable
-
-  def squeal
-    log "hello from the abyss"
-    stack "turtles all the way down"
-  end
-end
-
-class LogDepths
-  include Loggable
-
-  def speak
-    log "hello from the depths"
-    la = LogAbyss.new
-    la.squeal
-  end
-end
-
-class LogInner
-  include Loggable
-
-  def screech
-    ldi = LogDepths.new
-    log "hello from the innerds"
-    ldi.speak
-  end
-end
-
-class LogStackTestCase < Test::Unit::TestCase
-  include Loggable
-
-  def test_stack
-    Log.set_widths(-15, 4, -40)
-    
-    log = Proc.new { 
-      li = LogInner.new
-      li.screech
-    }
-
-    expected_output = [
-                       "[log_stack_test.rb:  35] {LogInner#screech                        } hello from the innerds",
-                       "[log_stack_test.rb:  24] {LogDepths#speak                         } hello from the depths",
-                       "[log_stack_test.rb:  15] {LogAbyss#squeal                         } hello from the abyss",
-                       "[log_stack_test.rb:  16] {LogAbyss#squeal                         } turtles all the way down",
-                       "[log_stack_test.rb:  26] {speak                                   } ",
-                       "[log_stack_test.rb:  36] {screech                                 } ",
-                      ]
-
-    do_run_test @verbose_setup, log, *expected_output
-  end
-
-  # the ctor is down here so the lines above are less likely to change.
-  def initialize test, name = nil
-    @nonverbose_setup = Proc.new {
-      Log.verbose = false
-      Log.output  = StringIO.new
-    }
-    
-    @verbose_setup = Proc.new {
-      Log.verbose = true
-      Log.output  = StringIO.new
-    }
-
-    super test
-  end
-
-  def do_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"
-
-    (0 ... expected.size).each do |idx|
-      if expected[idx]
-        assert_equal expected[idx], lines[idx], "index: #{idx}"
-      end
-    end
-
-    Log.output = io
-  end
-end

data/test/logue/testlog/log_test.rb

@@ -1,167 +0,0 @@
-#!/usr/bin/ruby -w
-# -*- ruby -*-
-
-require 'pathname'
-require 'test/unit'
-require 'stringio'
-require 'logue/loggable'
-require 'logue/testlog/logtestee'
-require 'logue/format'
-
-include Logue
-
-class LogTestCase < Test::Unit::TestCase
-  include Loggable
-
-  def run_log_testee_test(methname, expected, &blk)
-    Log.verbose = true
-    io = StringIO.new
-    Log.output = io
-    Log.set_default_widths
-
-    blk.call if blk
-
-    lt = LogTestee.new
-    lt.send methname
-
-    str = io.string
-
-    lines = str.split "\n"
-
-    (0 ... expected.size).each do |idx|
-      if expected[idx]
-        assert_equal expected[idx], lines[idx], "index: #{idx}"
-      end
-    end
-    
-    Log.set_default_widths
-  end
-
-  def run_format_test(expected, &blk)
-    Log.verbose = true
-    io = StringIO.new
-    Log.output = io
-    Log.set_default_widths
-
-    blk.call
-
-    lt = LogTestee.new
-    lt.format_test
-
-    assert_equal expected.join(''), io.string
-    
-    Log.set_default_widths
-  end
-
-  def test_no_output
-    run_log_testee_test(:log_all, Array.new) do
-      Log.verbose = false
-    end
-  end
-
-  def msg lnum, methname, msg
-    sprintf("[ .../testlog/logtestee.rb :  %2d] {%-20s} %s", 16 + lnum, methname[0 .. 19], msg)
-  end
-
-  def test_output_arg
-    methname = "log_all"
-
-    expected = Array.new
-    (1 .. 6).each do |lnum|
-      msg = "hello, world?"
-      if lnum == 4 || lnum == 5
-        msg = "EXPECTED OUTPUT TO STDERR: hello, world."
-      end
-      expected << sprintf("[.../testlog/logtestee.rb :  %2d] {%-20s} %s", 16 + lnum, methname[0 .. 19], msg)
-    end
-
-    run_log_testee_test(:log_all, expected)
-  end
-
-  def test_output_block_at_level
-    Log.level = Log::DEBUG
-    
-    methname = "log_block"
-
-    msg = "block party"
-
-    expected = Array.new
-    expected << sprintf("[.../testlog/logtestee.rb :  %2d] {%-20s} %s", 26, methname[0 .. 19], msg)
-
-    run_log_testee_test(:log_block, expected)
-  end
-
-  def test_output_block_below_level
-    expected = Array.new
-
-    run_log_testee_test(:log_block, expected) do
-      Log.level = Log::INFO
-    end
-  end
-
-  def test_colors_foreground
-    methname = "log_foregrounds"
-    expected = Array.new
-    expected << sprintf("[.../testlog/logtestee.rb :  %2d] {%-20s} %s", 30, methname[0 .. 19], "\e[37mwhite wedding\e[0m")
-    expected << sprintf("[.../testlog/logtestee.rb :  %2d] {%-20s} %s", 31, methname[0 .. 19], "\e[34mblue iris\e[0m")
-    
-    run_log_testee_test(:log_foregrounds, expected)
-  end
-
-  def xxxtest_colors_background
-    expected = Array.new
-    expected << "[.../test/logue/log_test.rb: 109] {LogTestCase#test_col} \e[46mred\e[0m"
-
-    run_log_testee_test(:log_foregrounds, expected) do
-    end
-  end
-
-  def test_format_default
-    expected = Array.new
-    expected << "[.../testlog/logtestee.rb :  10] {format_test         } tamrof\n"
-
-    run_format_test expected do
-      Log.set_default_widths
-    end
-  end
-
-  def test_format_flush_filename_left
-    expected = Array.new
-    expected << "[.../test/logue/testlog/logtestee.rb:  10] {format_test         } tamrof\n"
-
-    run_format_test expected do
-      Log.set_widths(-35, Logue::FormatWidths::DEFAULT_LINENUM, Logue::FormatWidths::DEFAULT_FUNCTION)
-    end
-  end
-
-  def test_format_flush_linenum_left
-    expected = Array.new
-    expected << "[.../testlog/logtestee.rb :10        ] {format_test         } tamrof\n"
-
-    run_format_test expected do
-      Log.set_widths(Logue::FormatWidths::DEFAULT_FILENAME, -10, Logue::FormatWidths::DEFAULT_FUNCTION)
-    end
-  end
-
-  def test_format_flush_function_right
-    expected = Array.new
-    expected << "[.../testlog/logtestee.rb :  10] {                        format_test} tamrof\n"
-
-    run_format_test expected do
-      Log.set_widths(Logue::FormatWidths::DEFAULT_FILENAME, Logue::FormatWidths::DEFAULT_LINENUM, 35)
-    end
-  end
-
-  def test_format_pad_linenum_zeros
-    expected = Array.new
-    expected << "[.../testlog/logtestee.rb :00000010] {format_test         } tamrof\n"
-
-    run_format_test expected do
-      Log.set_widths(Logue::FormatWidths::DEFAULT_FILENAME, "08", Logue::FormatWidths::DEFAULT_FUNCTION)
-    end
-  end
-
-  def test_respond_to_color
-    assert Log.respond_to? :blue
-  end
-end

data/test/logue/testlog/loggable_test.rb

@@ -1,30 +0,0 @@
-#!/usr/bin/ruby -w
-# -*- ruby -*-
-
-require 'test/unit'
-require 'stringio'
-require 'logue/log'
-require 'logue/loggable'
-require 'logue/testlog/lgbl_testee'
-
-class LoggableTestCase < Test::Unit::TestCase
-  include Logue::Loggable
-
-  def test_instance_colors
-    Logue::Log.verbose = true
-    io = StringIO.new
-    Logue::Log.output = io
-
-    expected = Array.new
-    expected << "[.../lgbl_testee.rb       :  10] {LgblTestee#crystal  } hello!\n"
-    expected << "[.../lgbl_testee.rb       :  11] {LgblTestee#crystal  } azul ... \n"
-    expected << "[.../lgbl_testee.rb       :  12] {LgblTestee#crystal  } rojo?\n"
-    
-    te = LgblTestee.new
-    te.crystal
-
-    # puts io.string
-
-    assert_equal expected.join(''), io.string
-  end
-end

data/test/logue/writer_test.rb

@@ -1,57 +0,0 @@
-#!/usr/bin/ruby -w
-# -*- ruby -*-
-
-require 'test/unit'
-require 'logue/writer'
-require 'logue/format'
-require 'stringio'
-
-class FakeLocation
-  attr_reader :absolute_path
-  attr_reader :lineno
-  attr_reader :label
-  # attr_reader :base_label
-
-  def initialize args
-    @absolute_path = args[:absolute_path]
-    @lineno = args[:lineno]
-    @label = args[:label]
-  end
-end
-
-class WriterTest < Test::Unit::TestCase
-  def test_write_one
-    fake_stack = Array.new.tap do |ary|
-      ary << FakeLocation.new(absolute_path: "/a/long/path/to/the/directory/abc.t", label: "block (2 levels) in one", lineno: 1)
-      ary << FakeLocation.new(absolute_path: "/another/path/def.t", label: "two", lineno: 11)
-      ary << FakeLocation.new(absolute_path: "/a/whole/nother/path/ghi.t", label: "three", lineno: 101)
-    end
-
-    fmt = Logue::Format.new
-
-    # content is matched in format_test
-    
-    out, err = capture_io do
-      wr = Logue::Writer.new
-      wr.write fmt, fake_stack, 1
-    end
-    refute_empty out
-    assert_empty err
-  end
-
-  def capture_io
-    begin
-      captured_stdout, captured_stderr = StringIO.new, StringIO.new
-
-      orig_stdout, orig_stderr = $stdout, $stderr
-      $stdout, $stderr         = captured_stdout, captured_stderr
-
-      yield
-
-      return captured_stdout.string, captured_stderr.string
-    ensure
-      $stdout = orig_stdout
-      $stderr = orig_stderr
-    end
-  end
-end