seeing_is_believing 2.2.0 → 3.0.0.beta.1

data/lib/seeing_is_believing/has_exception.rb

@@ -1,27 +0,0 @@
-class SeeingIsBelieving
-
-  # We cannot serialize the actual exception because we do not have any guarantee that its class is defined on the SIB side,
-  # so we must use simpler data structures (Strings and arrays)
-  RecordedException = Struct.new :class_name, :message, :backtrace do
-    def self.from_primitive(primitive)
-      return nil unless primitive
-      exception = new
-      exception.class_name = primitive['class_name']
-      exception.message    = primitive['message']
-      exception.backtrace  = primitive['backtrace']
-      exception
-    end
-
-    def to_primitive
-      { 'class_name' => class_name,
-        'message'    => message,
-        'backtrace'  => backtrace,
-      }
-    end
-  end
-
-  module HasException
-    attr_accessor :exception
-    alias has_exception? exception
-  end
-end

data/lib/seeing_is_believing/line.rb

@@ -1,90 +0,0 @@
-require 'seeing_is_believing/has_exception'
-
-class SeeingIsBelieving
-  # thin wrapper over an array, used by the result
-  class Line
-    include HasException
-    include Enumerable
-
-    # delegate all methods to the array, but return self where the array would be returned
-    Array.instance_methods(false).sort.each do |method_name|
-      define_method method_name do |*args, &block|
-        result = @array.__send__ method_name, *args, &block
-        result.equal?(@array) ? self : result
-      end
-    end
-
-    def to_float(n)
-      return n unless n == Float::INFINITY
-      'FUCKING_INFINITY_AND_JESUS_FUCKING_CHRIST_JSON_AND_MARSHAL_AND_YAML_WHAT_THE_FUCK?'
-    end
-
-    def from_float(n)
-      return n if n.kind_of? Float
-      Float::INFINITY
-    end
-
-    def to_primitive
-      { 'array'                  => @array,
-        'max_number_of_captures' => to_float(@max_number_of_captures),
-        'num_results'            => @num_results,
-        'total_size'             => @total_size,
-        'exception'              => (exception && exception.to_primitive)
-      }
-    end
-
-    def from_primitive(primitive)
-      @array                  = primitive['array']
-      @max_number_of_captures = from_float primitive['max_number_of_captures']
-      @num_results            = primitive['num_results']
-      @total_size             = primitive['total_size']
-      @exception              = RecordedException.from_primitive primitive['exception']
-    end
-
-    def to_a
-      @array.dup
-    end
-    alias to_ary to_a
-
-    def initialize(array = [], max_number_of_captures=Float::INFINITY)
-      @array                  = []
-      @max_number_of_captures = max_number_of_captures
-      @num_results            = 0
-      @total_size             = 0
-      array.each { |element| record_result element }
-    end
-
-    StackErrors = [SystemStackError]
-    StackErrors << Java::JavaLang::StackOverflowError if defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java'
-    def record_result(value)
-      begin
-        inspected = value.inspect.to_str # only invoke inspect once, b/c the inspection may be recorded
-      rescue NoMethodError
-        inspected = "#<no inspect available>"
-      rescue *StackErrors
-        # this is necessary because SystemStackError won't show the backtrace of the method we tried to call
-        # which means there won't be anything showing the user where this came from
-        # so we need to re-raise the error to get a backtrace that shows where we came from
-        # otherwise it looks like the bug is in SiB and not the user's program, see https://github.com/JoshCheek/seeing_is_believing/issues/37
-        raise SystemStackError, "Calling inspect blew the stack (is it recursive w/o a base case?)"
-      end
-
-      if    size <  @max_number_of_captures then @array << inspected
-      elsif size == @max_number_of_captures then @array << '...'
-      end
-      @num_results += 1
-      @total_size  += inspected.size
-      self
-    end
-
-    def ==(ary_or_line)
-      return @array == ary_or_line if Array === ary_or_line
-      ary_or_line == @array && exception == ary_or_line.exception
-    end
-
-    def inspect
-      inspected_exception = has_exception? ? "#{exception.class}:#{exception.message.inspect}" : "no exception"
-      "#<SIB:Line#{@array.inspect} (#@num_results, #@total_size) #{inspected_exception}>"
-    end
-  end
-end

data/spec/line_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-require 'seeing_is_believing/result'
-
-describe SeeingIsBelieving::Line do
-  Line = described_class
-
-  def line_for(*args)
-    line = Line.new
-    args.each { |a| line.record_result a }
-    line
-  end
-
-  it 'inspects prettily' do
-    expect(line_for(       ).inspect).to eq '#<SIB:Line[] (0, 0) no exception>'
-    expect(line_for("a"    ).inspect).to eq '#<SIB:Line["\"a\""] (1, 3) no exception>'
-    expect(line_for("a", 12).inspect).to eq '#<SIB:Line["\"a\"", "12"] (2, 5) no exception>'
-
-    line = Line.new
-    line.exception = RuntimeError.new("omg")
-    expect(line.inspect).to eq '#<SIB:Line[] (0, 0) RuntimeError:"omg">'
-  end
-
-  it "doesn't blow up when there is no #inspect available e.g. BasicObject" do
-    obj = BasicObject.new
-    expect(line_for(obj).inspect).to eq '#<SIB:Line["#<no inspect available>"] (1, 23) no exception>'
-  end
-
-  it "doesn't blow up when #inspect returns a not-String (e.g. pathalogical libraries like FactoryGirl)" do
-    obj = BasicObject.new
-    def obj.inspect
-      nil
-    end
-    expect(line_for(obj).inspect).to eq '#<SIB:Line["#<no inspect available>"] (1, 23) no exception>'
-  end
-
-  it 'knows when it has an exception' do
-    exception = RuntimeError.new 'omg'
-    line = Line.new
-    expect(line).to_not have_exception
-    line.exception = exception
-    expect(line).to have_exception
-    expect(line.exception).to equal exception
-  end
-
-  it 'delegates its other methods to array, but returns itself where the array would be returned' do
-    line = Line.new
-    expect(line).to be_empty
-    expect((line << 1)).to equal line
-    expect(line).to_not be_empty
-    expect(line.map { |i| i * 2 }).to eq [2]
-    line << 10 << 100
-    expect(line.take(2)).to eq [1, 10]
-  end
-
-  it 'returns its array for #to_a and #to_ary' do
-    line = line_for 1, 2
-    expect(line.to_a).to be_a_kind_of Array
-    expect(line.to_a).to eq %w[1 2]
-    expect(line.to_ary).to be_a_kind_of Array
-    expect(line.to_ary).to eq %w[1 2]
-  end
-
-  it 'is equal to arrays with the same elements as its array' do
-    expect(line_for(1, 2)).to eq %w[1 2]
-    expect(line_for(1, 2)).to_not eq %w[2 1]
-  end
-
-  # Exception equality seems to be based off of the message, and be indifferent to the class, I don't think it's that important to fix it
-  it "is equal to lines with the same elements and the same exception" do
-    exception = RuntimeError.new 'omg'
-
-    expect(line_for(1, 2)).to eq line_for(1, 2)
-    expect(line_for(1, 2)).to_not eq line_for(2, 1)
-
-    line1 = line_for(1, 2)
-    line1.exception = exception
-    expect(line1).to_not eq line_for(1, 2)
-
-    line2 = line_for(1, 2)
-    line2.exception = exception
-    expect(line1).to eq line2
-
-    line2.exception = RuntimeError.new 'wrong message'
-    expect(line1).to_not eq line2
-  end
-end