jleo-leftright 0.9.1

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009, 2010 Jordi Bunster <jordi@bunster.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,46 @@
+= leftright
+
+leftright is kind of like the redgreen gem. It makes passing tests look
+green, exceptions yellow, and failures red. But then there's more:
+
+  * It lets you know which TestCase class is being tested
+  * It shows you the full text of failures and exceptions as they happen
+  * It skips all remaining tests for a TestCase class if one fails
+
+This release was tested under:
+
+  * Rubinius 1.0.1
+  * REE 1.8.7
+  * MRI 1.8.6 and 1.8.7
+  * JRuby 1.4.0 and 1.5.2 (both in 1.8.7 mode)
+
+== Dependencies
+
+Right now this is pretty heavily dependent on Test::Unit, so it won't work
+in Ruby 1.9+ using MiniTest. Support is planned as soon as I find myself
+using the Ruby 1.9 + Rails 3 combo day to day.
+
+== Installation instructions
+
+  gem install leftright
+
+If you're on JRuby, you'll need to install ffi-ncurses to format properly:
+
+  jruby -S gem install ffi-ncurses
+
+== Example usage
+
+  require 'leftright'
+
+  class SomeTest < Test::Unit::TestCase
+    def test_that_true_is_indeed_true
+      assert_equal true, true
+    end
+  end
+
+Then run the file with ruby. Mind you, it gets a lot more exciting with
+your own tests, specially if they fail. :)
+
+== Legal
+
+Copyright (c) 2009, 2010 Jordi Bunster, released under the MIT license

data/WHATSNEW

@@ -0,0 +1,29 @@
+* 0.9.0 (2010-08-27):
+  - Fixed "leftright.rb:113: warning: parenthesize argument(s) for future 
+    version" in 1.8.6 (2007-03-13 patchlevel 0) and possibly other
+    versions (Mike Naberezny).
+  - Fixed a bug when running under non-ttys (Erik Peterson).
+
+* 0.0.6 (2010-08-02):
+  - Added the 'lr' binary to run foreign test suites using leftright.
+
+* 0.0.5 (2010-07-31):
+  - Fixed a ginormous bug when running under non-REE CRUBY. Yipes.
+
+* 0.0.4 (2010-07-31):
+  - Ignoring certain testcases (like ActionController::IntegrationTest) when
+    calculating the left margin. Does not break if Rails is not present.
+  - Added support for JRuby (using ffi-ncurses instead of stty (Zach Holman))
+  - Added (very basic) tests
+
+* 0.0.3 (2009-11-03):
+  - Removed 'XMLOBJECT_GEMSPEC' from gemspec (copy & paste gone wrong) :(
+  - Changed the TestCase collector to work like Test::Unit's.
+
+* 0.0.2 (2009-10-28):
+  - Added this file. :)
+  - Fixed http://github.com/jordi/leftright/issues/#issue/1 which prevented
+    this from working in 1.8.6 (thanks technoweenie).
+
+* 0.0.1 (2009-10-28):
+  - First release.

data/bin/lr

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'leftright'
+require $0 = ARGV.first

data/leftright.gemspec

@@ -0,0 +1,37 @@
+require 'lib/leftright/version'
+
+Gem::Specification.new do |gem|
+  gem.name    = 'jleo-leftright'
+  gem.version = LeftRight::VERSION
+
+  gem.author, gem.email = 'Joe Leo', 'jleo3@cyrusinnovation.com'
+
+  gem.summary     = "Jordi Bunster's leftright gem with a couple of tweaks."
+  gem.description = %{ leftright is kind of like the redgreen gem. It makes
+    passing tests look green, exceptions yellow, and failures red. It also
+    has a few features that make your workflow a bit faster (see README).
+  }.strip!.gsub! /\s+/, ' '
+
+  gem.has_rdoc = false
+
+  gem.date  = Date.today
+  gem.files = %w[
+    MIT-LICENSE
+    README.rdoc
+    WHATSNEW
+    bin
+    bin/lr
+    leftright.gemspec
+    lib
+    lib/leftright.rb
+    lib/leftright
+    lib/leftright/autorun.rb
+    lib/leftright/color.rb
+    lib/leftright/runner.rb
+    lib/leftright/tty.rb
+    lib/leftright/version.rb
+    lib/leftright/force_tty.rb
+  ]
+
+  gem.executables = 'lr'
+end

data/lib/leftright.rb

@@ -0,0 +1,214 @@
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+
+require 'leftright/version' # to open the module
+
+require 'leftright/tty'
+require 'leftright/color'
+require 'leftright/runner'
+require 'leftright/autorun'
+
+module LeftRight
+  # In counts of ' ':
+  MID_SEPARATOR = 1
+  RIGHT_MARGIN  = 1
+  LEFT_MARGIN   = 1
+
+  # This whole thing is fairly gnarly, needing to keep state across multiple
+  # parts of the crazyness that is Test::Unit, so we keep it all here.
+  #
+  def self.state
+    @state ||= begin
+      fields = [
+        :dots,               # the number of dots ('.') printed on this line
+        :class,              # the TestCase-extending class being tested
+        :fault,              # the current Test::Unit Failure/Error object
+        :last_class_printed, # last class printed on the left side
+        :previous_failed,    # true if the previous test failed/exceptioned
+        :skip,               # true if the current test was a skip
+        :skipped_count       # total number of skipped tests so far
+      ]
+
+      state = Struct.new(*fields).new
+      state.skipped_count = 0
+      state.dots          = 0
+      state
+    end
+  end
+
+  # Gets all descendants of Class that also descend from Test::Unit::TestCase
+  #
+  def self.testcase_classes
+    @testcase_classes ||= begin
+      found = []
+
+      ObjectSpace.each_object(Class) do |klass|
+        found << klass if Test::Unit::TestCase > klass
+      end
+
+      # Rails 2.3.5 defines these, and they cramp up my style.
+      found.reject! { |k| k.to_s == 'ActiveRecord::TestCase'            }
+      found.reject! { |k| k.to_s == 'ActionMailer::TestCase'            }
+      found.reject! { |k| k.to_s == 'ActionView::TestCase'              }
+      found.reject! { |k| k.to_s == 'ActionController::TestCase'        }
+      found.reject! { |k| k.to_s == 'ActionController::IntegrationTest' }
+      found.reject! { |k| k.to_s == 'ActiveSupport::TestCase'           }
+
+      found
+    end
+  end
+
+  # Replaces all instance methods beginning with 'test' in the given class
+  # with stubs that skip testing.
+  #
+  def self.skip_testing_class(klass)
+    klass.instance_methods.each do |m|
+      if 'test' == m.to_s[0,4]
+        klass.send :define_method, m.to_sym do
+          ::LeftRight.state.skip = true
+          ::LeftRight.state.skipped_count += 1
+        end
+      end
+    end
+  end
+
+  # Formats a class name to display on the left side.
+  #
+  def self.format_class_name(class_name)
+    class_name.chomp 'Test'
+  end
+
+  # Tries to get the terminal width in columns.
+  #
+  def self.terminal_width
+    @terminal_width ||= if defined?(RUBY_ENGINE) && RUBY_ENGINE.match('jruby')
+      ncurses_terminal_width
+    else
+      stty_terminal_width
+    end
+  end
+
+  # Uses stty to determine terminal width
+  def self.stty_terminal_width
+    `stty size`.split[-1].to_i
+  rescue
+    0
+  end
+
+  # Uses ffi-ncurses to determine terminal width
+  #
+  def self.ncurses_terminal_width
+    require 'ffi-ncurses'
+
+    begin
+      FFI::NCurses.initscr
+      FFI::NCurses.getmaxyx(FFI::NCurses._initscr).reverse.first.to_i
+    rescue
+      0
+    ensure
+      FFI::NCurses.endwin
+    end
+  rescue LoadError
+    puts %{ Under JRuby, you need to install the 'ffi-ncurses' gem,
+            since `stty` is not available. }.strip.gsub(/\s+/, ' ')
+    exit 1
+  end
+
+  # Tries to get the left side width in columns.
+  #
+  def self.left_side_width
+    @left_side_width ||= begin
+      testcase_classes.map do |c|
+        format_class_name(c.name).size + LEFT_MARGIN
+      end.max
+    end
+  end
+
+  # Tries to get the right side width in columns.
+  #
+  def self.right_side_width
+    terminal_width - left_side_width
+  end
+
+  # Returns the given string, right-justified onto the left side.
+  #
+  def self.justify_left_side(str = '')
+    str.to_s.rjust(left_side_width) + (' ' * MID_SEPARATOR)
+  end
+
+  # This gets the class name from the 'test_name' method on a
+  # Test::Unit Failure or Error. They look like test_method_name(TestCase),
+  #
+  def self.extract_class_name(test_name)
+    test_name.scan(/\(([^(|)]+)\)/x).flatten.last
+  end
+
+  # Wraps the given lines at word boundaries. Ripped right out of
+  # http://blog.macromates.com/2006/wrapping-text-with-regular-expressions/
+  #
+  def self.wrap(line)
+    return line unless tty?
+    width = right_side_width - MID_SEPARATOR - RIGHT_MARGIN
+    line.gsub /(.{1,#{width}})( +|$)\n?|(.{#{width}})/, "\\1\\3\n"
+  end
+
+  # Returns the current fault as a formatted failure message.
+  #
+  def self.F(color = C.red)
+    # First, we wrap each line individually, to keep existing line breaks:
+    lines = state.fault.long_display.split("\n")
+
+    # Drop the redundant "Failure: ", "test: " (shoulda), "test_", etc
+    lines.shift if lines.first.match /Failure:|Error:/
+    lines.first.sub! /^test[\ |:|_]?/i,    ''
+
+    # Drop the class name in () from the test method name
+    lines.first.sub! /\(#{state.class}\)/, ''
+
+    # shoulda puts '. :' at the end of method names
+    lines.first.sub! /\.\ :\s?/, ':'
+
+    # Wrap lines before coloring, since the wrapping would get confused
+    # by non-printables.
+    buffer = lines.map { |line| wrap line.strip }.join.strip
+
+    # We make interesting parts of the failure message bold:
+    [ /(`[^']+')/m,          # Stuff in `quotes'
+      /("[^"]+")/m,          # Stuff in "quotes"
+      /([^\/|\[]+\.rb:\d+)/, # Filenames with line numbers (without [box])
+      /(\s+undefined\s+)/ ].each do |interesting|
+      buffer.gsub! interesting, ( C.bold + '\0' + C.reset + color )
+    end
+
+    # These are great for assert_equal and similar:
+    buffer.sub! /(<)(.*)(>\s+expected)/,
+      '\1' + C.bold + '\2' + C.reset + color + '\3'
+    buffer.sub! /(but\s+was\s+<)(.*)(>\.)/,
+      '\1' + C.bold + '\2' + C.reset + color + '\3'
+
+    color + buffer + C.reset + "\n"
+  end
+
+  # Returns the current fault as a formatted error message.
+  #
+  def self.E
+    F C.red
+  end
+
+  # Returns a passing dot, aware of how many to print per-line.
+  #
+  def self.P
+    return '.' unless tty?
+
+    state.dots += 1
+
+    max_dots = right_side_width - RIGHT_MARGIN - MID_SEPARATOR
+
+    if state.dots >= max_dots
+      state.dots = 1
+      "\n" + C.green('.')
+    else
+      C.green '.'
+    end
+  end
+end

data/lib/leftright/autorun.rb

@@ -0,0 +1,12 @@
+# This is the only monkeypatching we do in LeftRight, since
+# Test::Unit::AutoRunner has no API for changing which runner to use. In
+# fact, it has a hardcoded list of runners.
+
+class Test::Unit::AutoRunner
+  alias :initialize_without_leftright :initialize
+
+  def initialize(*args)
+    initialize_without_leftright *args
+    @runner = lambda { |r| LeftRight::Runner }
+  end
+end

data/lib/leftright/color.rb

@@ -0,0 +1,39 @@
+# This is just here to avoid depending on Term::ANSIColor and such, since
+# we need so little, and need it to transparently do nothing when
+# STDOUT is not a terminal.
+
+module LeftRight
+  module C
+    def self.color(string = nil, code = nil)
+      if ::LeftRight::tty?
+        string.nil? ? "\e[#{code}m" : "\e[#{code}m" + string + "\e[0m"
+      else
+        string || ''
+      end
+    end
+
+    def self.reset(string = nil)
+      color string, 0
+    end
+
+    def self.bold(string = nil)
+      color string, 1
+    end
+
+    def self.red(string = nil)
+      color string, 31
+    end
+
+    def self.green(string = nil)
+      color string, 32
+    end
+
+    def self.yellow(string = nil)
+      color string, 33
+    end
+
+    def self.cyan(string = nil)
+      color string, 36
+    end
+  end
+end

data/lib/leftright/force_tty.rb

@@ -0,0 +1,6 @@
+module LeftRight
+  # Are we running under a terminal? YES.
+  def self.tty?
+    true
+  end
+end

data/lib/leftright/runner.rb

@@ -0,0 +1,108 @@
+# This is the replacement for Test::Unit::UI::Console::TestRunner
+
+module LeftRight
+  class Runner < Test::Unit::UI::Console::TestRunner
+    # Access to the LeftRight module from the Runner instance. Hopefully to
+    # reduce the likelyhood of future name clashes.
+    #
+    def lr
+      LeftRight
+    end
+
+    # We intercept this to be able to set some pertinent state.
+    #
+    def test_started(test_name)
+      name           = lr.extract_class_name test_name
+      lr.state.class = lr.testcase_classes.detect { |c| c.name == name }
+
+      super
+    end
+
+    # We intercept this to be able to set some pertinent state
+    def add_fault(fault)
+      lr.state.fault = fault
+      super
+    end
+
+    # Test::Unit uses this method to print '.', 'F', 'E', and possibly
+    # others. We do most of the work here, using the state saved in
+    # 'add_fault' and 'test_finished'.
+    #
+    def output_single(captured, *etc)
+      # Make sure we are printing a test result
+      return super unless %w[ . F E ].include? captured
+
+      # Do nothing if the method was a skipper
+      return if lr.state.skip && '.' == captured
+
+      output = case captured
+        when '.' then lr.P
+        when 'F' then lr.F
+        when 'E' then lr.E
+      end
+
+      if lr.state.last_class_printed != lr.state.class
+        # If we're here, we need to print a new class name on the left side
+        lr.state.last_class_printed = lr.state.class
+        lr.state.dots = 0
+        @io.write "\n"
+        @io.write lr.justify_left_side(
+                    lr.format_class_name(lr.state.class.name))
+      elsif captured != '.'
+        # This handles the edge case when the first test for a class fails
+        @io.write "\n"
+        @io.write lr.justify_left_side
+      end
+
+      # Justify all lines but first:
+      output.gsub! "\n", "\n" + lr.justify_left_side
+
+      @io.write output
+    ensure # reset all of the nasty state stuff
+      @io.flush
+      lr.state.previous_failed = captured != '.'
+      lr.state.skip            = false
+    end
+
+    # This prints the final summary at the end of all tests.
+    #
+    def finished(elapsed_time)
+      passed_count = @result.run_count     -
+                     @result.failure_count -
+                     @result.error_count   - lr.state.skipped_count
+
+      total = { :passed  => passed_count,
+                :failed  => @result.failure_count,
+                :errors  => @result.error_count,
+                :tests   => @result.run_count,
+                :skipped => lr.state.skipped_count }
+
+      results = []
+
+      unless passed_count.zero?
+        total[:passed] = 'all' if passed_count == @result.run_count
+        results << lr::C.green("#{total[:passed]} passed")
+      end
+
+      unless lr.state.skipped_count.zero?
+        results << lr::C.cyan("#{total[:skipped]} skipped")
+      end
+
+      unless @result.failure_count.zero?
+        results << lr::C.red("#{total[:failed]} failed")
+      end
+
+      unless @result.error_count.zero?
+        plural = @result.error_count > 1 ? 'errors' : 'error'
+        results << lr::C.yellow("#{total[:errors]} #{plural}")
+      end
+
+      @io.write "\n"
+      @io.write "\n" unless lr.state.previous_failed
+      @io.write "#{total[:tests]} test#{'s' if @result.run_count > 1}: "
+      @io.write results.join(', ').reverse.sub(',', 'dna ').reverse # :(
+      @io.write "\n" + "\n"
+      @io.puts "(#{elapsed_time} seconds)"
+    end
+  end
+end

data/lib/leftright/tty.rb

@@ -0,0 +1,6 @@
+module LeftRight
+  # Are we running under a terminal?
+  def self.tty?
+    STDOUT.tty?
+  end
+end

data/lib/leftright/version.rb

@@ -0,0 +1,3 @@
+module LeftRight
+  VERSION = '0.9.1'
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: jleo-leftright
+version: !ruby/object:Gem::Version 
+  hash: 57
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 1
+  version: 0.9.1
+platform: ruby
+authors: 
+- Joe Leo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-13 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: leftright is kind of like the redgreen gem. It makes passing tests look green, exceptions yellow, and failures red. It also has a few features that make your workflow a bit faster (see README).
+email: jleo3@cyrusinnovation.com
+executables: 
+- lr
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- MIT-LICENSE
+- README.rdoc
+- WHATSNEW
+- bin/lr
+- leftright.gemspec
+- lib/leftright.rb
+- lib/leftright/autorun.rb
+- lib/leftright/color.rb
+- lib/leftright/runner.rb
+- lib/leftright/tty.rb
+- lib/leftright/version.rb
+- lib/leftright/force_tty.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Jordi Bunster's leftright gem with a couple of tweaks.
+test_files: []
+