andyw8-seeing_is_believing 4.2.0

data/spec/binary/engine_spec.rb

@@ -0,0 +1,114 @@
+require 'seeing_is_believing/binary/engine'
+require 'seeing_is_believing/binary/config'
+
+class SeeingIsBelieving
+  module Binary
+    RSpec.describe Engine do
+      def call(body, options={})
+        timeout  = options.fetch :timeout, 0
+        filename = options.fetch :filename, "program.rb"
+        toggle   = options.fetch :toggled_mark, nil
+        config   = Config.new body: body, timeout_seconds: timeout, toggle_mark: toggle
+        config.lib_options.timeout_seconds = timeout
+        config.lib_options.filename        = filename
+        Engine.new config
+      end
+
+      def assert_must_evaluate(message)
+        engine = call '1+1'
+        expect { engine.__send__ message }.to raise_error MustEvaluateFirst, /#{message}/
+        engine.evaluate!
+        engine.__send__ message
+      end
+
+      context 'syntax' do
+        let(:valid_engine)   { call "1+1", filename: "filename.rb" }
+        let(:invalid_engine) { call "1+",  filename: "filename.rb" }
+
+        specify 'syntax_error? is true when the body was syntactically invalid' do
+          expect(  valid_engine.syntax_error?).to eq false
+          expect(invalid_engine.syntax_error?).to eq true
+        end
+
+        specify 'syntax_error contains the syntax\'s error message with file and line information' do
+          expect(valid_engine.syntax_error).to eq nil
+
+          allow_any_instance_of(Code::Syntax).to receive(:error_message).and_return "ERR!!"
+          allow_any_instance_of(Code::Syntax).to receive(:line_number).and_return   123
+          expect(invalid_engine.syntax_error)
+            .to eq SyntaxErrorMessage.new(line_number: 123, filename: "filename.rb", explanation: "ERR!!")
+          expect(invalid_engine.syntax_error.to_s).to include "ERR!!"
+        end
+      end
+
+      context 'cleaned_body' do
+        it 'has the annotations removed' do
+          expect(call("1 # =>").cleaned_body).to eq "1"
+        end
+        it 'ends in a newline if the body ended in a newline' do
+          expect(call("1").cleaned_body).to eq "1"
+          expect(call("1\n").cleaned_body).to eq "1\n"
+        end
+      end
+
+      context 'toggled_mark' do
+        it 'has the mark toggled and doesn\'t change the newline' do
+          expect(call("1",        toggled_mark: 1).toggled_mark).to eq "1  # => "
+          expect(call("1 # => ",  toggled_mark: 1).toggled_mark).to eq "1"
+          expect(call("1\n",      toggled_mark: 1).toggled_mark).to eq "1  # => \n"
+          expect(call("1 # =>\n", toggled_mark: 1).toggled_mark).to eq "1\n"
+        end
+      end
+
+      context 'before evaluating it raises if asked for' do
+        specify('result')          { assert_must_evaluate :result }
+        specify('exitstatus')      { assert_must_evaluate :exitstatus }
+        specify('timed_out?')      { assert_must_evaluate :timed_out? }
+        specify('timeout_seconds') { assert_must_evaluate :timeout_seconds }
+        specify('annotated_body')  { assert_must_evaluate :annotated_body }
+      end
+
+      context 'after evaluating' do
+        specify 'result is the result of the evaluation' do
+          status = call('exit 55').evaluate!.result.exitstatus
+          expect(status).to eq 55
+        end
+
+        it 'has recorded the exitstatus' do
+          engine = call('exit 88')
+          engine.evaluate!
+          expect(engine.exitstatus).to eq 88
+        end
+
+        specify 'timed_out? is true if a Timeout event was emitted' do
+          expect(call('', timeout: 1).evaluate!.timed_out?).to eq false
+          expect(call('sleep 1', timeout: 0.01).evaluate!.timed_out?).to eq true
+        end
+
+        specify 'timeout_seconds is nil, or the timeout duration' do
+          expect(call('', timeout: 1).evaluate!.timeout_seconds).to eq nil
+          expect(call('sleep 1', timeout: 0.01).evaluate!.timeout_seconds).to eq 0.01
+        end
+
+        context 'annotated_body' do
+          it 'is the body after being run through the annotator' do
+            expect(call("1").evaluate!.annotated_body).to eq "1  # => 1"
+          end
+          it 'ends in a newline if the body ended in a newline' do
+            expect(call("1").evaluate!.annotated_body).to eq "1  # => 1"
+            expect(call("1\n").evaluate!.annotated_body).to eq "1  # => 1\n"
+          end
+        end
+
+        it 'evaluation errors are raised up, and it behaves as if it was not evaluated' do
+          evaluated   = call('1').evaluate!
+          unevaluated = call '1'
+          expect(SeeingIsBelieving).to receive(:call).exactly(2).times.and_raise(ArgumentError)
+          evaluated.evaluate!
+          expect { unevaluated.evaluate! }.to raise_error ArgumentError
+          expect { unevaluated.evaluate! }.to raise_error ArgumentError
+        end
+      end
+    end
+  end
+end

data/spec/binary/format_comment_spec.rb

@@ -0,0 +1,210 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'seeing_is_believing/binary/format_comment'
+
+RSpec.describe SeeingIsBelieving::Binary::FormatComment do
+  def result_for(line_length, separator, result, options={})
+    described_class.new(line_length, separator, result, options).call
+  end
+
+  specify 'it returns the consolidated result if there are no truncations' do
+    expect(result_for 1, '=>', '12345').to eq '=>12345'
+  end
+
+  specify 'max_result_length truncates a result to the specified length, using elipses up to that length if appropriate'  do
+    line_length = 1
+    separator   = '=>'
+    result      = '12345'
+    expect(result_for line_length,   separator, result, max_result_length: Float::INFINITY).to eq '=>12345'
+    expect(result_for line_length,   separator, result, max_result_length: 7              ).to eq '=>12345'
+    expect(result_for line_length,   separator, result, max_result_length: 6              ).to eq '=>1...'
+    expect(result_for line_length+1, separator, result, max_result_length: 6              ).to eq '=>1...'
+    expect(result_for line_length,   separator, result, max_result_length: 5              ).to eq '=>...'
+    expect(result_for line_length,   separator, result, max_result_length: 4              ).to eq ''
+    expect(result_for line_length,   separator, result, max_result_length: 0              ).to eq ''
+  end
+
+  specify 'max_line_length truncates a result to the specified length, minus the length of the line' do
+    line_length = 1
+    separator   = '=>'
+    result      = '12345'
+    expect(result_for line_length,   separator, result                                  ).to eq '=>12345'
+    expect(result_for line_length,   separator, result, max_line_length: Float::INFINITY).to eq '=>12345'
+    expect(result_for line_length,   separator, result, max_line_length: 8              ).to eq '=>12345'
+    expect(result_for line_length,   separator, result, max_line_length: 7              ).to eq '=>1...'
+    expect(result_for line_length+1, separator, result, max_line_length: 7              ).to eq '=>...'
+    expect(result_for line_length,   separator, result, max_line_length: 6              ).to eq '=>...'
+    expect(result_for line_length,   separator, result, max_line_length: 5              ).to eq ''
+    expect(result_for line_length,   separator, result, max_line_length: 0              ).to eq ''
+  end
+
+  specify 'pad_to will pad the length that the line is displayed in' do
+    expect(result_for 1, '=>', '2', pad_to: 0).to eq '=>2'
+    expect(result_for 1, '=>', '2', pad_to: 1).to eq '=>2'
+    expect(result_for 1, '=>', '2', pad_to: 2).to eq ' =>2'
+    expect(result_for 2, '=>', '2', pad_to: 2).to eq '=>2'
+  end
+
+  specify 'pad_to is ignored when separator/result will not be printed' do
+    expect(result_for 1, '=>', '12345', pad_to: 2,   max_line_length: 2).to eq ''
+    expect(result_for 1, '=>', '12345', pad_to: 2, max_result_length: 2).to eq ''
+  end
+
+  specify 'they can all work together' do
+    expect(result_for 1, '=>', '12345', max_line_length: 100, max_result_length: 100, pad_to: 2).to eq ' =>12345'
+    expect(result_for 1, '=>', '12345', max_line_length:   8, max_result_length: 100, pad_to: 2).to eq ' =>1...'
+    expect(result_for 1, '=>', '12345', max_line_length: 100, max_result_length:   6, pad_to: 2).to eq ' =>1...'
+    expect(result_for 1, '=>', '12345', max_line_length: 100, max_result_length:   6, pad_to: 2).to eq ' =>1...'
+  end
+
+  def assert_printed(c, printed)
+    c = c.force_encoding 'utf-8'
+    result = result_for 0, '', c
+    expect(result).to eq printed
+    expect(result.encoding).to eq Encoding::UTF_8
+    expect(result).to be_valid_encoding
+  end
+
+  it 'escapes any non-printable characters' do
+    assert_printed     '©' , '©'
+    assert_printed   0.chr , "\\u0000"
+    assert_printed   1.chr , "\\u0001"
+    assert_printed   2.chr , "\\u0002"
+    assert_printed   3.chr , "\\u0003"
+    assert_printed   4.chr , "\\u0004"
+    assert_printed   5.chr , "\\u0005"
+    assert_printed   6.chr , "\\u0006"
+    assert_printed   7.chr , "\\a"
+    assert_printed   8.chr , "\\b"
+    assert_printed   9.chr , "\\t"
+    assert_printed  10.chr , "\\n"
+    assert_printed  11.chr , "\\v"
+    assert_printed  12.chr , "\\f"
+    assert_printed  13.chr , "\\r"
+    assert_printed  14.chr , "\\u000E"
+    assert_printed  15.chr , "\\u000F"
+    assert_printed  16.chr , "\\u0010"
+    assert_printed  17.chr , "\\u0011"
+    assert_printed  18.chr , "\\u0012"
+    assert_printed  19.chr , "\\u0013"
+    assert_printed  20.chr , "\\u0014"
+    assert_printed  21.chr , "\\u0015"
+    assert_printed  22.chr , "\\u0016"
+    assert_printed  23.chr , "\\u0017"
+    assert_printed  24.chr , "\\u0018"
+    assert_printed  25.chr , "\\u0019"
+    assert_printed  26.chr , "\\u001A"
+    assert_printed  27.chr , "\\e"
+    assert_printed  28.chr , "\\u001C"
+    assert_printed  29.chr , "\\u001D"
+    assert_printed  30.chr , "\\u001E"
+    assert_printed  31.chr , "\\u001F"
+    assert_printed  32.chr , " "
+    assert_printed  33.chr , "!"
+    assert_printed  34.chr , '"' # printable, thus not escaped
+    assert_printed  35.chr , "#"
+    assert_printed  36.chr , "$"
+    assert_printed  37.chr , "%"
+    assert_printed  38.chr , "&"
+    assert_printed  39.chr , "'"
+    assert_printed  40.chr , "("
+    assert_printed  41.chr , ")"
+    assert_printed  42.chr , "*"
+    assert_printed  43.chr , "+"
+    assert_printed  44.chr , ","
+    assert_printed  45.chr , "-"
+    assert_printed  46.chr , "."
+    assert_printed  47.chr , "/"
+    assert_printed  48.chr , "0"
+    assert_printed  49.chr , "1"
+    assert_printed  50.chr , "2"
+    assert_printed  51.chr , "3"
+    assert_printed  52.chr , "4"
+    assert_printed  53.chr , "5"
+    assert_printed  54.chr , "6"
+    assert_printed  55.chr , "7"
+    assert_printed  56.chr , "8"
+    assert_printed  57.chr , "9"
+    assert_printed  58.chr , ":"
+    assert_printed  59.chr , ";"
+    assert_printed  60.chr , "<"
+    assert_printed  61.chr , "="
+    assert_printed  62.chr , ">"
+    assert_printed  63.chr , "?"
+    assert_printed  64.chr , "@"
+    assert_printed  65.chr , "A"
+    assert_printed  66.chr , "B"
+    assert_printed  67.chr , "C"
+    assert_printed  68.chr , "D"
+    assert_printed  69.chr , "E"
+    assert_printed  70.chr , "F"
+    assert_printed  71.chr , "G"
+    assert_printed  72.chr , "H"
+    assert_printed  73.chr , "I"
+    assert_printed  74.chr , "J"
+    assert_printed  75.chr , "K"
+    assert_printed  76.chr , "L"
+    assert_printed  77.chr , "M"
+    assert_printed  78.chr , "N"
+    assert_printed  79.chr , "O"
+    assert_printed  80.chr , "P"
+    assert_printed  81.chr , "Q"
+    assert_printed  82.chr , "R"
+    assert_printed  83.chr , "S"
+    assert_printed  84.chr , "T"
+    assert_printed  85.chr , "U"
+    assert_printed  86.chr , "V"
+    assert_printed  87.chr , "W"
+    assert_printed  88.chr , "X"
+    assert_printed  89.chr , "Y"
+    assert_printed  90.chr , "Z"
+    assert_printed  91.chr , "["
+    assert_printed  92.chr , "\\" # printable, thus not escaped
+    assert_printed  93.chr , "]"
+    assert_printed  94.chr , "^"
+    assert_printed  95.chr , "_"
+    assert_printed  96.chr , "`"
+    assert_printed  97.chr , "a"
+    assert_printed  98.chr , "b"
+    assert_printed  99.chr , "c"
+    assert_printed 100.chr , "d"
+    assert_printed 101.chr , "e"
+    assert_printed 102.chr , "f"
+    assert_printed 103.chr , "g"
+    assert_printed 104.chr , "h"
+    assert_printed 105.chr , "i"
+    assert_printed 106.chr , "j"
+    assert_printed 107.chr , "k"
+    assert_printed 108.chr , "l"
+    assert_printed 109.chr , "m"
+    assert_printed 110.chr , "n"
+    assert_printed 111.chr , "o"
+    assert_printed 112.chr , "p"
+    assert_printed 113.chr , "q"
+    assert_printed 114.chr , "r"
+    assert_printed 115.chr , "s"
+    assert_printed 116.chr , "t"
+    assert_printed 117.chr , "u"
+    assert_printed 118.chr , "v"
+    assert_printed 119.chr , "w"
+    assert_printed 120.chr , "x"
+    assert_printed 121.chr , "y"
+    assert_printed 122.chr , "z"
+    assert_printed 123.chr , "{"
+    assert_printed 124.chr , "|"
+    assert_printed 125.chr , "}"
+    assert_printed 126.chr , "~"
+    assert_printed 127.chr, "\u007F"
+  end
+
+  it 'can be given a list of characters to not escape' do
+    expect(result_for 0, '', "\r\n", dont_escape: ["\n"]).to eq "\\r\n"
+    expect(result_for 0, '', "\r\n", dont_escape: ["\r"]).to eq "\r\\n"
+  end
+
+  it 'escapes them before running through the other calculations' do
+    expect(result_for 1, '=>', "\r\n", max_line_length: 7).to eq '=>\r\n'
+    expect(result_for 1, '=>', "\r\n", max_line_length: 6).to eq '=>...'
+  end
+end

data/spec/binary/marker_spec.rb

@@ -0,0 +1,71 @@
+require 'seeing_is_believing/binary/data_structures'
+
+RSpec.describe SeeingIsBelieving::Binary::Marker do
+
+  describe 'to_regex' do
+    def assert_parses(input, regex)
+      expect(described_class.to_regex input).to eq regex
+    end
+
+    it 'doesn\'t change existing regexes' do
+      assert_parses /^.$/ix, /^.$/ix
+    end
+
+    it 'converts strings into regexes' do
+      assert_parses '',    %r()
+      assert_parses 'a',   %r(a)
+    end
+
+    it 'ignores surrounding slashes' do
+      assert_parses '//',  %r()
+      assert_parses '/a/', %r(a)
+    end
+
+    it 'respects flags after the trailing slash in surrounding slashes' do
+      assert_parses '/a/',     %r(a)
+      assert_parses '/a//',    %r(a/)
+      assert_parses '//a/',    %r(/a)
+      assert_parses '/a/i',    %r(a)i
+      assert_parses '/a/im',   %r(a)im
+      assert_parses '/a/xim',  %r(a)xim
+      assert_parses '/a/mix',  %r(a)mix
+      assert_parses '/a/mixi', %r(a)mixi
+    end
+
+    it 'isn\'t fooled by strings that kinda look regexy' do
+      assert_parses '/a',  %r(/a)
+      assert_parses 'a/',  %r(a/)
+      assert_parses '/',   %r(/)
+      assert_parses '/i',  %r(/i)
+    end
+
+    it 'does not escape the content' do
+      assert_parses 'a\\s+',   %r(a\s+)
+      assert_parses '/a\\s+/', %r(a\s+)
+    end
+  end
+
+  it 'requires prefix and a regex' do
+    described_class.new prefix: '', regex: //
+    expect { described_class.new }.to raise_error ArgumentError
+    expect { described_class.new prefix: ''  }.to raise_error ArgumentError
+    expect { described_class.new regex:  // }.to raise_error ArgumentError
+  end
+
+  it 'stores the prefix and a regex' do
+    marker = described_class.new(prefix: 't', regex: /r/)
+    expect(marker.prefix).to eq 't'
+    expect(marker.regex).to eq /r/
+  end
+
+  it 'converts strings to rgexes when they are set' do
+    marker = described_class.new prefix: 't', regex: 'r1'
+    expect(marker[:regex]).to eq /r1/
+
+    marker.regex = '/r2/i'
+    expect(marker.regex).to eq /r2/i
+
+    marker[:regex] = 'r3'
+    expect(marker.regex).to eq /r3/
+  end
+end