wrong 0.3.3 → 0.4.0

data/lib/wrong/close_to.rb

@@ -1,13 +1,9 @@
-# TODO: make it a module, and optionally include it into Float and Fixnum if asked
-
-class Float
-  def close_to?(other, tolerance = 0.001)
-    (self - other.to_f).abs < tolerance
-  end
-end
-
-class Fixnum
-  def close_to?(*args)
-    self.to_f.close_to?(*args)
+module Wrong
+  module CloseTo
+    def close_to?(other, tolerance = 0.001)
+      (self.to_f - other.to_f).abs < tolerance
+    end
   end
+  Float.send :include, CloseTo
+  Fixnum.send :include, CloseTo
 end

data/lib/wrong/d.rb

@@ -0,0 +1,42 @@
+require "sexp"
+require "wrong/chunk"
+
+class ::Sexp < ::Array
+  def d?
+    is_a?(Sexp) &&
+            (self[0] == :iter) &&
+            (self[1][0] == :call) &&
+            (self[1][2] == :d)
+  end
+
+end
+
+module Wrong
+  module D
+    def d(*args, &block)
+      called_from = caller.first.split(':')
+      chunk = Chunk.from_block(block, 1)
+      sexp = chunk.sexp
+
+      # look for a "d" inside the block
+      sexp.each_subexp do |subexp|
+        if subexp.d?
+          sexp = subexp[3] # swap in the block part of the nested d call
+        end
+      end
+
+      code = sexp.to_ruby
+      value = eval(code, block.binding, called_from[0], called_from[1].to_i).inspect
+
+      if Wrong.config[:color]
+        require "wrong/rainbow"
+        code = code.color(:blue)
+        value = value.color(:magenta)
+      end
+
+      puts [code, "is", value].join(" ")
+    end
+
+    extend D # this allows you to call Wrong::D.d if you like
+  end
+end

data/lib/wrong/failure_message.rb

@@ -0,0 +1,43 @@
+module Wrong
+  class FailureMessage
+    @@formatters = []
+
+    def self.register_formatter(formatter)
+      @@formatters << formatter
+    end
+
+    def self.formatters
+      @@formatters
+    end
+
+    def self.formatter_for(predicate)
+      @@formatters.each do |formatter_class|
+        formatter = formatter_class.new(predicate)
+        if formatter.match?
+          return formatter
+        end
+      end
+      nil
+    end
+
+    class Formatter
+      def self.register
+        Wrong::FailureMessage.register_formatter(self)
+      end
+
+      attr_reader :predicate
+
+      def initialize(predicate)
+        @predicate = predicate
+      end
+
+      def describe(valence)
+
+      end
+
+      def match?
+        false
+      end
+    end
+  end
+end

data/lib/wrong/helpers.rb

@@ -0,0 +1,66 @@
+module Wrong
+  module Helpers
+
+    # Executes a block that is expected to raise an exception. Returns that exception, or nil if none was raised.
+    def rescuing
+      error = nil
+      begin
+        yield
+      rescue Exception, RuntimeError => e
+        error = e
+      end
+      error
+    end
+
+    # Usage:
+    # capturing { puts "hi" } => "hi\n"
+    # capturing(:stderr) { $stderr.puts "hi" } => "hi\n"
+    # out, err = capturing(:stdout, :stderr) { ... }
+    #
+    # see http://www.justskins.com/forums/closing-stderr-105096.html for more explanation
+    def capturing(*streams)
+      streams = [:stdout] if streams.empty?
+      original = {}
+      captured = {}
+
+      # reassign the $ variable (which is used by well-behaved code e.g. puts)
+      streams.each do |stream|
+        original[stream] = (stream == :stdout ? $stdout : $stderr)
+        captured[stream] = StringIO.new
+        case stream
+          when :stdout
+            $stdout = captured[stream]
+          when :stderr
+            $stderr = captured[stream]
+        end
+      end
+
+      yield
+
+      # return either one string, or an array of two strings
+      if streams.size == 1
+        captured[streams.first].string
+      else
+        [captured[streams[0]].string, captured[streams[1]].string]
+      end
+
+    ensure
+
+      streams.each do |stream|
+        # bail if stream was reassigned inside the block
+        if (stream == :stdout ? $stdout : $stderr) != captured[stream]
+          raise "#{stream} was reassigned while being captured"
+        end
+        # support nested calls to capturing
+        original[stream] << captured[stream].string if original[stream].is_a? StringIO
+        case stream
+          when :stdout
+            $stdout = original[stream]
+          when :stderr
+            $stderr = original[stream]
+        end
+      end
+    end
+  end
+
+end

data/lib/wrong/irb.rb

@@ -12,5 +12,5 @@ if defined? IRB
   end
 
   # include it in the top level too, since if you're using Wrong inside IRB that's probably what you want
-  include Wrong::Assert
+  include Wrong
 end

data/lib/wrong/message/array_diff.rb

@@ -1,87 +1,69 @@
 require "diff/lcs"
+require "wrong/failure_message"
 
 module Wrong
-  module Assert
-    
-    def failure_message(method_sym, block, predicate)
-      message = super
-      
-      if predicate.is_a?(Predicated::Equal) && 
-         predicate.left.is_a?(Enumerable) &&
-         predicate.right.is_a?(Enumerable)
-        
-        
-        
-        diffs = Diff::LCS.sdiff(predicate.left, predicate.right)
-        # left_offset = 0
-        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
-        
-        
-        left_str, right_str, diff_str = ArrayDiff.compute_and_format(predicate.left, predicate.right)
+  class ArrayDiff < FailureMessage::Formatter
+    register # tell FailureMessage::Formatter about us
 
-        message << "\n\narray diff:\n"
-        message << left_str + "\n"
-        message << right_str + "\n"
-        message << diff_str + "\n"
-      end
-      
+    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
-    
-    module ArrayDiff
-      def self.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
-        
 
-        [format(left_arr), 
-         format(right_arr),
-          " " + diff_arr.join("  ") + " "]
+    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
-      
-      def self.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
+
+
+      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
+        str << "]"
+      else
+        str << thing
       end
-      
+      str
     end
-      
-    
-    
+
   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

@@ -1,10 +1,12 @@
 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)

data/lib/{predicated/lib/predicated/sexp_patch.rb → wrong/ruby2ruby_patch.rb}

@@ -1,9 +1,7 @@
-
-
-#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
 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

data/lib/wrong/sexp_ext.rb

@@ -3,16 +3,24 @@ require 'ruby2ruby'
 require 'wrong/config'
 
 class Sexp < Array
-  def doop
-    Marshal.load(Marshal.dump(self))
-  end
 
   def to_ruby
-    d = self.doop
+    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