wrong 0.4.0-java

data/lib/wrong/chunk.rb

@@ -0,0 +1,233 @@
+require 'ruby_parser'
+require 'ruby2ruby'
+
+begin
+  require "ParseTree"
+rescue LoadError => e
+  raise e unless e.message == "no such file to load -- ParseTree"
+end
+
+begin
+  require "sourcify"
+rescue LoadError => e
+  raise e unless e.message == "no such file to load -- sourcify"
+end
+
+require "wrong/config"
+require "wrong/sexp_ext"
+
+module Wrong
+  class Chunk
+    def self.from_block(block, depth = 0)
+
+      as_proc = block.to_proc
+      file, line =
+              if as_proc.respond_to? :source_location
+                # in Ruby 1.9, or with Sourcify, it reads the source location from the block
+                as_proc.source_location
+              else
+                # in Ruby 1.8, it reads the source location from the call stack
+                caller[depth].split(":")
+              end
+
+      new(file, line, block)
+    end
+
+    attr_reader :file, :line_number, :block
+
+    # line parameter is 1-based
+    def initialize(file, line_number, block = nil)
+      @file = file
+      @line_number = line_number.to_i
+      @block = block
+    end
+
+    def line_index
+      @line_number - 1
+    end
+
+    def location
+      "#{@file}:#{@line_number}"
+    end
+
+    def sexp
+      @sexp ||= build_sexp
+    end
+
+    def build_sexp
+      sexp = begin
+        unless @block.nil? or @block.is_a?(String) or !Object.const_defined?(:Sourcify)
+          # first try sourcify
+          @block.to_sexp[3] # the [3] is to strip out the "proc {" sourcify adds to everything
+        end
+      rescue ::Sourcify::MultipleMatchingProcsPerLineError, Racc::ParseError, Errno::ENOENT => e
+        # fall through
+      end
+
+      # next try glomming
+      sexp ||= glom(if @file == "(irb)"
+                      IRB.CurrentContext.all_lines
+                    else
+                      read_source_file(@file)
+                    end)
+    end
+
+    def read_source_file(file, dir = ".")
+      File.read "#{dir}/#{file}"
+
+    rescue Errno::ENOENT, Errno::EACCES => e
+      # we may be in a chdir underneath where the file is, so move up one level and try again
+      parent = "#{dir}/..".gsub(/^(\.\/)*/, '')
+      if File.expand_path(dir) == File.expand_path(parent)
+        raise Errno::ENOENT, "couldn't find #{file}"
+      end
+      read_source_file(file, parent)
+
+    end
+
+    # Algorithm:
+    # * try to parse the starting line
+    # * if it parses OK, then we're done!
+    # * if not, then glom the next line and try again
+    # * repeat until it parses or we're out of lines
+    def glom(source)
+      lines = source.split("\n")
+      @parser ||= RubyParser.new
+      @chunk = nil
+      c = 0
+      sexp = nil
+      while sexp.nil? && line_index + c < lines.size
+        begin
+          @chunk = lines[line_index..line_index+c].join("\n")
+          sexp = @parser.parse(@chunk)
+        rescue Racc::ParseError => e
+          # loop and try again
+          c += 1
+        end
+      end
+      sexp
+    end
+
+    # The claim is the part of the assertion inside the curly braces.
+    # E.g. for "assert { x == 5 }" the claim is "x == 5"
+    def claim
+      sexp()
+
+      if @sexp.nil?
+        raise "Could not parse #{location}"
+      else
+        assertion = @sexp.assertion
+        statement = assertion && assertion[3]
+        if statement.nil?
+          @sexp
+#          raise "Could not find assertion in #{location}\n\t#{@chunk.strip}\n\t#{@sexp}"
+        else
+          statement
+        end
+      end
+    end
+
+    def code
+      self.claim.to_ruby
+    rescue => e
+      # note: this is untested; it's to recover from when we can't locate the code
+      message = "Failed assertion at #{caller[depth + 2]} [couldn't retrieve source code due to #{e.inspect}]"
+      raise failure_class.new(message)
+    end
+
+    def parts(sexp = nil)
+      if sexp.nil?
+        parts(self.claim).compact.uniq
+      else
+        # todo: extract some of this into Sexp
+        parts_list = []
+        begin
+          unless sexp.first == :arglist
+            code = sexp.to_ruby.strip
+            parts_list << code unless code == "" || parts_list.include?(code)
+          end
+        rescue => e
+          puts "#{e.class}: #{e.message}"
+          puts e.backtrace.join("\n")
+        end
+
+        if sexp.first == :iter
+          sexp.delete_at(1) # remove the method-call-sans-block subnode
+        end
+
+        sexp.each do |sub|
+          if sub.is_a?(Sexp)
+            parts_list += parts(sub)
+          end
+        end
+
+        parts_list
+      end
+    end
+
+    def details
+      require "wrong/rainbow" if Wrong.config[:color]
+      s = ""
+      parts = self.parts
+      parts.shift # remove the first part, since it's the same as the code
+
+      details = []
+
+      if parts.size > 0
+        parts.each do |part|
+          begin
+            value = eval(part, block.binding)
+            unless part == value.inspect # this skips literals or tautologies
+              if part =~ /\n/m
+                part.gsub!(/\n/, newline(2))
+                part += newline(3)
+              end
+              value = indent_all(3, value.inspect)
+              if Wrong.config[:color]
+                part = part.color(:blue)
+                value = value.color(:magenta)
+              end
+              details << indent(2, part, " is ", value)
+            end
+          rescue Exception => e
+            raises = "raises #{e.class}"
+            if Wrong.config[:color]
+              part = part.color(:blue)
+              raises = raises.bold.color(:red)
+            end
+            formatted_exeption = if e.message and e.message != e.class.to_s
+              indent(2, part, " ", raises, ": ", indent_all(3, e.message))
+            else
+              indent(2, part, " ", raises)
+            end
+            details << formatted_exeption
+          end
+        end
+      end
+
+      details.uniq!
+      if details.empty?
+        ""
+      else
+        "\n" + details.join("\n") + "\n"
+      end
+
+    end
+
+    private
+
+    def indent(indent, *s)
+      "#{"  " * indent}#{s.join('')}"
+    end
+
+    def newline(indent)
+      "\n" + self.indent(indent)
+    end
+
+    def indent_all(amount, s)
+      s.gsub("\n", "\n#{indent(amount)}")
+    end
+
+  end
+
+end

data/lib/wrong/close_to.rb

@@ -0,0 +1,9 @@
+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/config.rb

@@ -0,0 +1,29 @@
+module Wrong
+  def self.config
+    @config ||= Config.new
+  end
+
+  class Config < Hash
+    def alias_assert(method_name)
+      Wrong::Assert.send(:alias_method, method_name, :assert)
+      self.assert_method_names << method_name.to_sym unless self.assert_method_names.include?(method_name)
+    end
+
+    def alias_deny(method_name)
+      Wrong::Assert.send(:alias_method, method_name, :deny)
+      self.deny_method_names << method_name.to_sym unless self.deny_method_names.include?(method_name)
+    end
+
+    def assert_method_names
+      (self[:assert_method] ||= [:assert])
+    end
+
+    def deny_method_names
+      (self[:deny_method] ||= [:deny])
+    end
+
+    def assert_methods
+      assert_method_names + deny_method_names
+    end
+  end
+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

@@ -0,0 +1,16 @@
+if defined? IRB
+  module IRB
+    class Context
+      alias :original_evaluate :evaluate
+      attr_reader :all_lines
+
+      def evaluate(line, line_no)
+        (@all_lines ||= "") <<line
+        original_evaluate line, line_no
+      end
+    end
+  end
+
+  # include it in the top level too, since if you're using Wrong inside IRB that's probably what you want
+  include Wrong
+end