wrong 0.4.0-java

data/lib/wrong/message/array_diff.rb

@@ -0,0 +1,69 @@
+require "diff/lcs"
+require "wrong/failure_message"
+
+module Wrong
+  class ArrayDiff < FailureMessage::Formatter
+    register # tell FailureMessage::Formatter about us
+
+    def match?
+      predicate.is_a?(Predicated::Equal) &&
+              arrayish?(predicate.left) &&
+              arrayish?(predicate.right)
+    end
+
+    def arrayish?(object)
+      # in some Rubies, String is Enumerable
+      object.is_a?(Enumerable) && !object.is_a?(String)
+    end
+
+    def describe
+      left_str, right_str, diff_str = compute_and_format(predicate.left, predicate.right)
+
+      message = "\n"
+      message << left_str + "\n"
+      message << right_str + "\n"
+      message << diff_str + "\n"
+      message
+
+    end
+
+    def compute_and_format(left, right)
+      diffs = Diff::LCS.sdiff(left, right)
+
+      left_arr = []
+      right_arr = []
+      diff_arr = []
+
+      diffs.each do |diff|
+        left_elem = diff.old_element.nil? ? "nil" : diff.old_element.inspect
+        right_elem = diff.new_element.nil? ? "nil" : diff.new_element.inspect
+
+        max_length = [left_elem.length, right_elem.length].max
+        left_arr << left_elem.ljust(max_length) unless diff.action == "+"
+        right_arr << right_elem.ljust(max_length) unless diff.action == "-"
+        diff_arr << (diff.action == "=" ? " ".ljust(max_length) : "^".ljust(max_length))
+      end
+
+
+      diff_str = " " + diff_arr.join("  ") + " "
+
+      [format(left_arr), format(right_arr), diff_str]
+    end
+
+    def format(thing)
+      str = ""
+      if thing.is_a?(Array)
+        str << "["
+        thing.each_with_index do |item, i|
+          str << format(item)
+          str << ", " unless i == thing.length-1
+        end
+        str << "]"
+      else
+        str << thing
+      end
+      str
+    end
+
+  end
+end

data/lib/wrong/message/string_comparison.rb

@@ -0,0 +1,88 @@
+require "wrong/failure_message"
+
+module Wrong
+  class StringComparison
+    @@window = 64
+    @@prelude = 12
+
+    def self.window
+      @@window
+    end
+
+    def self.window=(val)
+      @@window = val
+    end
+
+    def self.prelude
+      @@prelude
+    end
+
+    def self.prelude=(val)
+      @@prelude = val
+    end
+
+    def initialize(first, second)
+      @first = first
+      @second = second
+    end
+
+    def same?
+      @first == @second
+    end
+
+    def different_at
+      if (@first.nil? || @second.nil?)
+        0
+      else
+        i = 0
+        while (i < @first.size && i < @second.size)
+          if @first[i] != @second[i]
+            break
+          end
+          i += 1
+        end
+        return i
+      end
+    end
+
+    def message
+      "Strings differ at position #{different_at}:\n" +
+              " first: #{chunk(@first)}\n" +
+              "second: #{chunk(@second)}"
+    end
+
+    def chunk(s)
+      prefix, middle, suffix = "...", "", "..."
+
+      start = different_at - @@prelude
+      if start < 0
+        prefix = ""
+        start = 0
+      end
+
+      stop = start + @@window
+      if stop >= s.size
+        suffix = ""
+        stop = s.size
+      end
+
+      [prefix, s[start...stop].inspect, suffix].join
+    end
+  end
+
+  class StringComparisonFormatter < FailureMessage::Formatter
+    register # tell FailureMessage::Formatter about us
+
+    def match?
+      predicate.is_a?(Predicated::Equal) &&
+              predicate.left.is_a?(String) &&
+              predicate.right.is_a?(String)
+    end
+
+    def describe
+      comparison = Wrong::StringComparison.new(predicate.left, predicate.right)
+      "\n" + comparison.message
+    end
+  end
+
+end

data/lib/wrong/message/test_context.rb

@@ -0,0 +1,28 @@
+module Wrong
+  module Assert
+    # todo: integrate with / use Chunk somehow?
+    #
+    def failure_message(method_sym, block, predicate)
+      upper_portion = super
+      
+      first_test_line = caller.find{|line|line =~ /(_test.rb|_spec.rb)/}
+      raise "Can't find test or spec in call chain: #{caller.join('|')}" if first_test_line.nil?
+      file, failure_line_number = first_test_line.split(":",2)
+    
+      lines = File.readlines(file)
+      line_number = failure_line_number.to_i - 1
+      to_show = []
+      begin
+        line = lines[line_number]
+        to_show.unshift(line)
+        line_number -= 1
+      end while !(line =~ /^\s+(test|it)[ ]+/ || line =~ /^\s+def test_\w+/)
+    
+      to_show[to_show.length-1] = to_show[to_show.length-1].chomp + 
+        "      ASSERTION FAILURE #{file}:#{failure_line_number.to_i}\n"
+      
+      upper_portion + "\n\n" + to_show.join
+    end
+    
+  end
+end

data/lib/wrong/rainbow.rb

@@ -0,0 +1,127 @@
+# Lifted from Rainbow gem, http://sickill.net/blog/2009/03/24/colorizing-console-output-with-rainbow-ruby-gem.html
+
+module Sickill
+  module Rainbow
+    class << self; attr_accessor :enabled; end
+    @enabled = STDOUT.tty? && ENV['TERM'] != 'dumb'
+
+    TERM_COLORS = {
+      :black => 0,
+      :red => 1,
+      :green => 2,
+      :yellow => 3,
+      :blue => 4,
+      :magenta => 5,
+      :cyan => 6,
+      :white => 7,
+      :default => 9,
+    }
+
+    TERM_EFFECTS = {
+      :reset => 0,
+      :bright => 1,
+      :italic => 3,
+      :underline => 4,
+      :blink => 5,
+      :inverse => 7,
+      :hide => 8,
+    }
+
+    # Sets foreground color of this text.
+    def foreground(*color)
+      color = color.first if color.size == 1
+      wrap_with_code(get_color_code(color, :foreground))
+    end
+    alias_method :color, :foreground
+    alias_method :colour, :foreground
+
+    # Sets background color of this text.
+    def background(*color)
+      color = color.first if color.size == 1
+      wrap_with_code(get_color_code(color, :background))
+    end
+
+    # Resets terminal to default colors/backgrounds.
+    #
+    # It shouldn't be needed to use this method because all methods append terminal reset code to end of string.
+    def reset
+      wrap_with_code(TERM_EFFECTS[:reset])
+    end
+
+    # Turns on bright/bold for this text.
+    def bright
+      wrap_with_code(TERM_EFFECTS[:bright])
+    end
+    alias_method :bold, :bright
+
+    # Turns on italic style for this text (not well supported by terminal emulators).
+    def italic
+      wrap_with_code(TERM_EFFECTS[:italic])
+    end
+
+    # Turns on underline decoration for this text.
+    def underline
+      wrap_with_code(TERM_EFFECTS[:underline])
+    end
+
+    # Turns on blinking attribute for this text (not well supported by terminal emulators).
+    def blink
+      wrap_with_code(TERM_EFFECTS[:blink])
+    end
+
+    # Inverses current foreground/background colors.
+    def inverse
+      wrap_with_code(TERM_EFFECTS[:inverse])
+    end
+
+    # Hides this text (set its color to the same as background).
+    def hide
+      wrap_with_code(TERM_EFFECTS[:hide])
+    end
+
+    protected
+    def wrap_with_code(code) #:nodoc:
+      return self unless Sickill::Rainbow.enabled
+
+      out = "#{self}"
+      match = out.match(/^(\e\[([\d;]+)m)*/)
+      out.insert(match.end(0), "\e[#{code}m")
+      out.concat("\e[0m") unless out =~ /\e\[0m$/
+      out
+    end
+
+    def get_color_code(color, type) #:nodoc:
+      case color
+      when Symbol
+        validate_color(color)
+        TERM_COLORS[color] + (type == :foreground ? 30 : 40)
+      when String
+        color = color.gsub("#", "")
+        r, g, b = color[0..1].to_i(16), color[2..3].to_i(16), color[4..5].to_i(16)
+        get_rgb_code(r, g, b, type)
+      when Array
+        raise ArgumentError.new("Bad number of arguments for RGB color definition, should be 3") unless color.size == 3
+        get_rgb_code(color[0], color[1], color[2], type)
+      end
+    end
+
+    def get_rgb_code(r, g, b, type) #:nodoc:
+      raise ArgumentError.new("RGB value outside 0-255 range") if [r, g, b].min < 0 || [r, g, b].max > 255
+      code = { :foreground => 38, :background => 48 }[type]
+      index = 16 + (6 * (r / 256.0)).to_i * 36 + (6 * (g / 256.0)).to_i * 6 + (6 * (b / 256.0)).to_i
+      "#{code};5;#{index}"
+    end
+
+    def validate_color(color) #:nodoc:
+      raise ArgumentError.new("Unknown color, valid colors: #{TERM_COLORS.keys.join(', ')}") unless TERM_COLORS.keys.include?(color)
+    end
+  end
+end
+
+String.send(:include, Sickill::Rainbow)
+
+begin
+  require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /win32/
+rescue LoadError
+  Sickill::Rainbow.enabled = false
+end

data/lib/wrong/ruby2ruby_patch.rb

@@ -0,0 +1,37 @@
+class ::Ruby2Ruby < ::SexpProcessor
+  # see http://gist.github.com/321038
+  # Monkey-patch to have Ruby2Ruby#translate with r2r >= 1.2.3, from
+  # http://seattlerb.rubyforge.org/svn/ruby2ruby/1.2.2/lib/ruby2ruby.rb
+  def self.translate(klass_or_str, method = nil)
+    sexp = ParseTree.translate(klass_or_str, method)
+    unifier = Unifier.new
+    unifier.processors.each do |p|
+      p.unsupported.delete :cfunc # HACK
+    end
+    sexp = unifier.process(sexp)
+    self.new.process(sexp)
+  end
+
+  #sconover - 7/2010 - monkey-patch
+  #{1=>2}=={1=>2}
+  #The right side was having its braces cut off because of
+  #special handling of hashes within arglists within the seattlerb code.
+  #I tried to fork r2r and add a test, but a lot of other tests
+  #broke, and I just dont understand the test in ruby2ruby.
+  #So I'm emailing the author...
+  def process_hash(exp)
+    result = []
+    until exp.empty?
+      lhs = process(exp.shift)
+      rhs = exp.shift
+      t = rhs.first
+      rhs = process rhs
+      rhs = "(#{rhs})" unless [:lit, :str].include? t # TODO: verify better!
+
+      result << "#{lhs} => #{rhs}"
+    end
+
+    return "{ #{result.join(', ')} }"
+  end
+
+end

data/lib/wrong/sexp_ext.rb

@@ -0,0 +1,49 @@
+require 'ruby_parser'
+require 'ruby2ruby'
+require 'wrong/config'
+
+class Sexp < Array
+
+  def to_ruby
+    d = self.deep_clone
+    ruby = Ruby2Ruby.new.process(d)
+    ruby
+  end
+
+  # visit every node in the tree, including the root, that is an Sexp
+  # todo: test
+  def each_subexp(&block)
+    yield self
+    each do |child|
+      if child.is_a?(Sexp)
+        child.each_subexp(&block)
+      end
+    end
+  end
+
+  def assertion?
+    self.is_a? Sexp and
+      self[0] == :iter and
+      self[1].is_a? Sexp and
+      self[1][0] == :call and
+      Wrong.config.assert_methods.include? self[1][2] # todo: allow aliases for assert (e.g. "is")
+  end
+
+  def assertion
+    sexp = self
+    assertion = if sexp.assertion?
+                  sexp
+                else
+                  nested_assertions.first
+                end
+    assertion
+  end
+
+  private
+  def nested_assertions
+    assertions = []
+    self.each_of_type(:iter) { |sexp| assertions << sexp if sexp.assertion? }
+    assertions
+  end
+
+end

data/lib/wrong/version.rb

@@ -0,0 +1,3 @@
+module Wrong
+  VERSION = "0.4.0" unless defined?(Wrong::VERSION)
+end

data/test/adapters/minitest_test.rb

@@ -0,0 +1,97 @@
+require "./test/test_helper"
+
+require "minitest/spec"
+require "minitest/unit"
+
+require "wrong/assert"
+require "wrong/adapters/minitest"
+
+describe "basic assert features" do
+
+  before do
+    @test_case_instance = Class.new(MiniTest::Unit::TestCase).new("x")
+  end
+
+  it "raises minitest assertion failures" do
+    test_case_instance = Class.new(MiniTest::Unit::TestCase).new("x")
+    assert {
+      rescuing {
+        test_case_instance.assert { 1==2 }
+      }.is_a?(MiniTest::Assertion)
+    }
+  end
+
+  it "passes asserts with no block up to the framework's assert method" do
+    e = rescuing { assert(1 == 2) }
+    assert { e.message == "Failed assertion, no message given." }
+
+    e = rescuing { assert(1 == 2, "black is white") }
+    assert { e.message == "black is white" }
+  end
+
+  it "passes denys with no block up to the framework's assert method" do
+    e = rescuing { deny(2 + 2 == 4) }
+    assert { e.message == "Failed assertion, no message given." }
+
+    e = rescuing { deny(2 + 2 == 4, "up is down") }
+    assert { e.message == "up is down" }
+  end
+
+  # TODO: optionally print a warning when calling the framework assert
+
+  it "makes Wrong's assert and deny available to minitest tests" do
+    class MyFailingAssertTest < MiniTest::Unit::TestCase
+      def initialize
+        super("assert test")
+      end
+
+      def test_fail
+        assert { 1==2 }
+      end
+    end
+
+    class MyFailingDenyTest < MiniTest::Unit::TestCase
+      def initialize
+        super("deny test")
+      end
+
+      def test_fail
+        deny { 1==1 }
+      end
+    end
+
+    msg = rescuing { MyFailingAssertTest.new.test_fail }.message
+
+    assert { msg.include?("1 is not equal to 2") }
+
+    msg = rescuing { MyFailingDenyTest.new.test_fail }.message
+    assert { msg.include?("1 is equal to 1") }
+  end
+end
+
+describe 'reports number of assertions' do
+  before do
+    @test = Class.new(MiniTest::Unit::TestCase).new("x")
+  end
+  
+  it 'assert{} should bump number of assertions' do
+    @test.assert {true}
+    assert {@test._assertions == 1}
+  end
+  
+  it 'assert() should not bump twice number of assertions' do
+    @test.assert(true)
+    assert {@test._assertions == 1}
+  end
+
+  it 'deny{} should bump number of assertions' do
+    @test.deny {false}
+    assert {@test._assertions == 1}
+  end 
+  
+  it 'deny() should bump once number of assertions' do
+    @test.deny(false)
+    assert {@test._assertions == 1}
+  end  
+end
+