minispec 0.0.1

data/lib/minispec/reporter.rb

@@ -0,0 +1,185 @@
+module MiniSpec
+  class Reporter
+    @@indent = " ".freeze
+
+    attr_reader :failed_specs, :failed_tests, :skipped_tests
+
+    def initialize stdout = STDOUT
+      @stdout = stdout
+      @failed_specs, @failed_tests, @skipped_tests = [], {}, {}
+    end
+
+    def summary
+      summary__failed_specs
+      summary__failed_tests
+      summary__skipped_tests
+      totals
+    end
+
+    def summary__failed_specs
+      return if @failed_specs.empty?
+      puts
+      puts(error('--- Failed Specs ---'))
+      last_ex = nil
+      @failed_specs.each do |(spec,proc,ex)|
+        puts(info(spec))
+        puts(info('defined at ' + proc.source_location.join(':')), indent: 2) if proc.is_a?(Proc)
+        if last_ex && ex.backtrace == last_ex.backtrace
+          puts('see exception above', indent: 2)
+          next
+        end
+        last_ex = ex
+        puts(error(ex.message), indent: 2)
+        ex.backtrace.each {|l| puts(l, indent: 2)}
+        puts
+      end
+    end
+
+    def summary__skipped_tests
+      return if @skipped_tests.empty?
+      puts
+      puts(warn('--- Skipped Tests ---'))
+      @skipped_tests.each_pair do |spec,tests|
+        puts(info(spec))
+        tests.each do |(test,source_location)|
+          puts(warn(test), indent: 2)
+          puts(info(MiniSpec::Utils.shorten_source(source_location)), indent: 2)
+          puts
+        end
+        puts
+      end
+    end
+
+    def summary__failed_tests
+      return if @failed_tests.empty?
+      puts
+      puts(error('--- Failed Tests ---'), '')
+      @failed_tests.each_pair do |spec, failures|
+        @failed_specs.push(spec) # to be used on #totals__specs
+        failures.each do |(test,verb,proc,errors)|
+          errors.each do |error|
+            error.is_a?(Exception) ?
+              exception_details(spec, test, error) :
+              failure_details(spec, test, error)
+          end
+        end
+      end
+    end
+
+    def totals
+      puts
+      puts('---')
+      totals__specs
+      totals__tests
+      totals__assertions
+    end
+
+    def totals__specs
+      print(info('       Specs: '))
+      return puts(success(Minispec.specs.size)) if @failed_specs.empty?
+      print(info(Minispec.specs.size))
+      puts(error('  (%s failed)' % @failed_specs.size))
+    end
+
+    def totals__tests
+      print(info('       Tests: '))
+      print(send(@failed_tests.any? ? :info : :success, Minispec.tests))
+      failed  = error('%s failed' % @failed_tests.values.map(&:size).reduce(:+)) if @failed_tests.any?
+      skipped = warn('%s skipped' % @skipped_tests.size) if @skipped_tests.any?
+      report  = [failed, skipped].compact.join(', ')
+      puts(report.empty? ? report : ' (%s)' %  report)
+    end
+
+    def totals__assertions
+      print(info('  Assertions: '))
+      return puts(success(Minispec.assertions)) if @failed_tests.empty?
+      print(info(Minispec.assertions))
+      puts(error('  (%s failed)' % @failed_tests.values.map(&:size).reduce(:+)))
+    end
+
+    def exception_details spec, test, exception
+      puts(info([spec, test]*' / '))
+      puts(error(exception.message), indent: 2)
+      exception.backtrace.each {|l| puts(info(MiniSpec::Utils.shorten_source(l)), indent: 2)}
+      puts('---', '')
+    end
+
+    def failure_details spec, test, failure
+      puts(info([spec, test]*' / '))
+      puts(error(callerline(failure[:callers][0])), indent: 2)
+      callers(failure[:callers]).each {|l| puts(info(l), indent: 2)}
+      puts
+      return puts(*failure[:message].split("\n"), '', indent: 2) if failure[:message]
+      return if failure[:right_object] == :__ms__right_object
+
+      expected, actual = [:right_object, :left_object].map do |obj|
+        str = stringify_object(failure[obj])
+        [str =~ /\n/ ? :puts : :print, str]
+      end
+
+      send(expected.first, info('           Expected: '))
+      print('NOT ') if failure[:negation]
+      puts(expected.last)
+
+      send(actual.first, info('             Actual: '))
+      puts(actual.last)
+
+      print(info('     Compared using: '))
+      puts(failure[:right_method])
+
+      diff = diff(actual.last, expected.last)
+      puts(info('               Diff: '), diff) unless diff.empty?
+      puts('---', '')
+    end
+
+    def mark_as_passed spec, test
+      puts(success("OK"))
+    end
+
+    def mark_as_skipped spec, test, source_location
+      puts(warn("Skipped"))
+      (@skipped_tests[spec] ||= []).push([test, source_location])
+    end
+
+    def mark_as_failed spec, test, verb, proc, failures
+      puts(error("FAILED"))
+      (@failed_tests[spec] ||= []).push([test, verb, proc, failures])
+    end
+
+    def print(*args); @stdout.print(*indent_lines(*args)) end
+    def puts(*args);  @stdout.puts(*indent_lines(*args))  end
+
+    {success: 32, info: 34, warn: 35, error: 31}.each_pair do |m,c|
+      define_method(m) {|s| "\e[%im%s\e[0m" % [c, s]}
+    end
+
+    def failures?
+      @failed_specs.any? || @failed_tests.any?
+    end
+
+    private
+    def indent_lines *args
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      (i = opts[:indent]) && (i = @@indent*i) && args.map {|l| i + l} || args
+    end
+
+    def callers *callers
+      callers.flatten.uniq.reverse.map {|l| MiniSpec::Utils.shorten_source(l)}
+    end
+
+    def callerline caller
+      file, line = caller.match(/^(.+?):(\d+)(?::in `(.*)')?/) {|m| m[1..2]}
+      return unless lines = MiniSpec.source_location_cache(file)
+      (line = lines[line.to_i - 1]) && line.strip
+    end
+
+    def stringify_object obj
+      obj.is_a?(String) ? obj : MiniSpec::Utils.pp(obj)
+    end
+
+    def diff actual, expected
+      @differ ||= MiniSpec::Differ.new(color: true)
+      @differ.diff(actual, expected).strip
+    end
+  end
+end

data/lib/minispec/utils.rb

@@ -0,0 +1,139 @@
+module MiniSpec
+  module Utils
+    extend self
+
+    def undefine_method object, method
+      return unless method_defined?(object, method)
+      object.instance_eval('undef :%s' % method)
+    end
+
+    def method_defined? object, method
+      object.respond_to?(method) ||
+        object.protected_methods.include?(method) ||
+        object.private_methods.include?(method)
+    end
+
+    # @api private
+    # checking whether correct arguments passed to proxy methods.
+    #
+    # @raise [ArgumentError] if more than two arguments given
+    # @raise [ArgumentError] if both argument and block given
+    #
+    def valid_proxy_arguments? left_method, *args, &proc
+      args.size > 2 && raise(ArgumentError, '#%s - wrong number of arguments, %i for 0..2' % [left_method, args.size])
+      args.size > 0 && proc && raise(ArgumentError, '#%s accepts either arguments or a block, not both' % left_method)
+    end
+
+    # @example
+    #   received = [:a, :b, :c]
+    #   expected = [1]
+    #   => {:a=>1, :b=>1, :c=>1}
+    #
+    # @example
+    #   received = [:a, :b, :c]
+    #   expected = []
+    #   => {:a=>nil, :b=>nil, :c=>nil}
+    #
+    # @example
+    #   received = [:a, :b, :c]
+    #   expected = [1, 2]
+    #   => {:a=>1, :b=>2, :c=>2}
+    #
+    # @example
+    #   received = [:a, :b, :c]
+    #   expected = [1, 2, 3, 4]
+    #   => {:a=>1, :b=>2, :c=>3}
+    #
+    # @param received [Array]
+    # @param expected [Array]
+    # @return [Hash]
+    #
+    def zipper received, expected
+      result = {}
+      received.uniq.each_with_index do |m,i|
+        result[m] = expected[i] || expected[i-1] || expected[0]
+      end
+      result
+    end
+
+    # determines method's visibility
+    #
+    # @param object
+    # @param method
+    # @return [Symbol] or nil
+    #
+    def method_visibility object, method
+      {
+           public: :public_methods,
+        protected: :protected_methods,
+          private: :private_methods
+      }.each_pair do |v,m|
+        return v if object.send(m).include?(method)
+      end
+      nil
+    end
+
+    def array_elements_map array
+      # borrowed from thoughtbot/shoulda
+      array.inject({}) {|h,e| h[e] ||= array.select { |i| i == e }.size; h}
+    end
+
+    def source proc
+      shorten_source(proc.source_location*':')
+    end
+
+    # get rid of Dir.pwd from given path
+    def shorten_source source
+      source.to_s.sub(/\A#{Dir.pwd}\/?/, '')
+    end
+
+    # checks whether given label matches any matcher.
+    # even if label matched, it will return `false` if label matches some rejector.
+    #
+    # @param label
+    # @param matchers  an `Array` of matchers and rejectors.
+    #   matchers contained as hashes, rejectors as arrays.
+    # @return `true` or `false`
+    #
+    def any_match? label, matchers
+      reject, select = matchers.partition {|m| m.is_a?(Hash)}
+
+      rejected = rejected?(label, reject)
+      if select.any?
+        return select.find {|x| (x == :*) || match?(label, x)} && !rejected
+      end
+      !rejected
+    end
+
+    # checks whether given label matches any rejector.
+    #
+    # @param label
+    # @param reject  an `Array` of rejectors, each being a `Hash` containing `:except` key
+    # @return `true` or `false`
+    #
+    def rejected? label, reject
+      if reject.any? && (x = reject.first[:except])
+        if x.is_a?(Array)
+          return true if x.find {|m| match?(label, m)}
+        else
+          return true if match?(label, x)
+        end
+      end
+      false
+    end
+
+    # compare given label to given expression.
+    # if expression is a `Regexp` comparing using `=~`.
+    # otherwise `==` are used
+    #
+    # @param label
+    # @param x
+    # @return `true` or `false`
+    #
+    def match? label, x
+      x.is_a?(Regexp) ? label.to_s =~ x : label == x
+    end
+  end
+end
+
+Dir[File.expand_path('../utils/**/*.rb', __FILE__)].each {|f| require(f)}

data/lib/minispec/utils/differ.rb

@@ -0,0 +1,325 @@
+# borrowed from RSpec - https://github.com/rspec/rspec-support
+
+# Copyright (c) 2013 David Chelimsky, Myron Marston, Jon Rowe, Sam Phippen, Xavier Shay, Bradley Schaefer
+#
+# MIT License
+#
+# 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.
+
+module MiniSpec
+  class Differ
+    class EncodedString
+
+      MRI_UNICODE_UNKNOWN_CHARACTER = "\xEF\xBF\xBD".freeze
+
+      def initialize(string, encoding = nil)
+        @encoding = encoding
+        @source_encoding = detect_source_encoding(string)
+        @string = matching_encoding(string)
+      end
+      attr_reader :source_encoding
+
+      delegated_methods = String.instance_methods.map(&:to_s) & %w[eql? lines == encoding empty?]
+      delegated_methods.each do |name|
+        define_method(name) { |*args, &block| @string.__send__(name, *args, &block) }
+      end
+
+      def <<(string)
+        @string << matching_encoding(string)
+      end
+
+      def split(regex_or_string)
+        @string.split(matching_encoding(regex_or_string))
+      end
+
+      def to_s
+        @string
+      end
+      alias :to_str :to_s
+
+      private
+
+      if String.method_defined?(:encoding)
+        def matching_encoding(string)
+          string.encode(@encoding)
+        rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
+          normalize_missing(string.encode(@encoding, :invalid => :replace, :undef => :replace))
+        rescue Encoding::ConverterNotFoundError
+          normalize_missing(string.force_encoding(@encoding).encode(:invalid => :replace))
+        end
+
+        def normalize_missing(string)
+          if @encoding.to_s == "UTF-8"
+            string.gsub(MRI_UNICODE_UNKNOWN_CHARACTER.force_encoding(@encoding), "?")
+          else
+            string
+          end
+        end
+
+        def detect_source_encoding(string)
+          string.encoding
+        end
+      else
+        def matching_encoding(string)
+          string
+        end
+
+        def detect_source_encoding(string)
+          'US-ASCII'
+        end
+      end
+    end
+
+    class HunkGenerator
+      def initialize(actual, expected)
+        @actual = actual
+        @expected = expected
+      end
+
+      def hunks
+        @file_length_difference = 0
+        @hunks ||= diffs.map do |piece|
+          build_hunk(piece)
+        end
+      end
+
+      private
+
+      def diffs
+        Diff::LCS.diff(expected_lines, actual_lines)
+      end
+
+      def expected_lines
+        @expected.split("\n").map! { |e| e.chomp }
+      end
+
+      def actual_lines
+        @actual.split("\n").map! { |e| e.chomp }
+      end
+
+      def build_hunk(piece)
+        Diff::LCS::Hunk.new(
+          expected_lines, actual_lines, piece, context_lines, @file_length_difference
+        ).tap do |h|
+          @file_length_difference = h.file_length_difference
+        end
+      end
+
+      def context_lines
+        3
+      end
+    end
+
+    def diff(actual, expected)
+      diff = ""
+
+      if actual && expected
+        if all_strings?(actual, expected)
+          if any_multiline_strings?(actual, expected)
+            diff = diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
+          end
+        elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
+          diff = diff_as_object(actual, expected)
+        end
+      end
+
+      diff.to_s
+    end
+
+    def diff_as_string(actual, expected)
+      @encoding = pick_encoding actual, expected
+
+      @actual   = EncodedString.new(actual, @encoding)
+      @expected = EncodedString.new(expected, @encoding)
+
+      output = EncodedString.new("\n", @encoding)
+
+      hunks.each_cons(2) do |prev_hunk, current_hunk|
+        begin
+          if current_hunk.overlaps?(prev_hunk)
+            add_old_hunk_to_hunk(current_hunk, prev_hunk)
+          else
+            add_to_output(output, prev_hunk.diff(format).to_s)
+          end
+        ensure
+          add_to_output(output, "\n")
+        end
+      end
+
+      if hunks.last
+        finalize_output(output, hunks.last.diff(format).to_s)
+      end
+
+      color_diff output
+    rescue Encoding::CompatibilityError
+      handle_encoding_errors
+    end
+
+    def diff_as_object(actual, expected)
+      actual_as_string = object_to_string(actual)
+      expected_as_string = object_to_string(expected)
+      diff_as_string(actual_as_string, expected_as_string)
+    end
+
+    attr_reader :color
+    alias_method :color?, :color
+
+    def initialize(opts={})
+      @color = opts.fetch(:color, false)
+      @object_preparer = opts.fetch(:object_preparer, lambda { |string| string })
+    end
+
+    private
+
+    def no_procs?(*args)
+      args.flatten.none? { |a| Proc === a}
+    end
+
+    def all_strings?(*args)
+      args.flatten.all? { |a| String === a}
+    end
+
+    def any_multiline_strings?(*args)
+      all_strings?(*args) && args.flatten.any? { |a| multiline?(a) }
+    end
+
+    def no_numbers?(*args)
+      args.flatten.none? { |a| Numeric === a}
+    end
+
+    def coerce_to_string(string_or_array)
+      return string_or_array unless Array === string_or_array
+      diffably_stringify(string_or_array).join("\n")
+    end
+
+    def diffably_stringify(array)
+      array.map do |entry|
+        if Array === entry
+          entry.inspect
+        else
+          entry.to_s.gsub("\n", "\\n")
+        end
+      end
+    end
+
+    if String.method_defined?(:encoding)
+      def multiline?(string)
+        string.include?("\n".encode(string.encoding))
+      end
+    else
+      def multiline?(string)
+        string.include?("\n")
+      end
+    end
+
+    def hunks
+      @hunks ||= HunkGenerator.new(@actual, @expected).hunks
+    end
+
+    def finalize_output(output, final_line)
+      add_to_output(output, final_line)
+      add_to_output(output, "\n")
+    end
+
+    def add_to_output(output, string)
+      output << string
+    end
+
+    def add_old_hunk_to_hunk(hunk, oldhunk)
+      hunk.merge(oldhunk)
+    end
+
+    def format
+      :unified
+    end
+
+    def color(text, color_code)
+      "\e[#{color_code}m#{text}\e[0m"
+    end
+
+    def red(text)
+      color(text, 31)
+    end
+
+    def green(text)
+      color(text, 32)
+    end
+
+    def blue(text)
+      color(text, 34)
+    end
+
+    def normal(text)
+      color(text, 0)
+    end
+
+    def color_diff(diff)
+      return diff unless color?
+
+      diff.lines.map { |line|
+        case line[0].chr
+        when "+"
+          green line
+        when "-"
+          red line
+        when "@"
+          line[1].chr == "@" ? blue(line) : normal(line)
+        else
+          normal(line)
+        end
+      }.join
+    end
+
+    def object_to_string(object)
+      object = @object_preparer.call(object)
+      case object
+      when Hash
+        object.keys.sort_by { |k| k.to_s }.map do |key|
+          pp_key   = PP.singleline_pp(key, "")
+          pp_value = PP.singleline_pp(object[key], "")
+
+          "#{pp_key} => #{pp_value},"
+        end.join("\n")
+      when String
+        object =~ /\n/ ? object : object.inspect
+      else
+        PP.pp(object,"")
+      end
+    end
+
+    if String.method_defined?(:encoding)
+      def pick_encoding(source_a, source_b)
+        Encoding.compatible?(source_a, source_b) || Encoding.default_external
+      end
+    else
+      def pick_encoding(source_a, source_b)
+      end
+    end
+
+    def handle_encoding_errors
+      if @actual.source_encoding != @expected.source_encoding
+        "Could not produce a diff because the encoding of the actual string (#{@actual.source_encoding}) "+
+          "differs from the encoding of the expected string (#{@expected.source_encoding})"
+      else
+        "Could not produce a diff because of the encoding of the string (#{@expected.source_encoding})"
+      end
+    end
+  end
+end