seeing_is_believing 3.0.0.beta.4 → 3.0.0.beta.5

data/lib/seeing_is_believing/event_stream/update_result.rb

@@ -1,24 +0,0 @@
-require 'seeing_is_believing/event_stream/events'
-class SeeingIsBelieving
-  module EventStream
-    # Adapter between EventStream and Result
-    module UpdateResult
-      def self.call(result, event)
-         case event
-         when EventStream::Events::LineResult       then result.record_result(event.type, event.line_number, event.inspected)
-         when EventStream::Events::UnrecordedResult then result.record_result(event.type, event.line_number, '...') # <-- is this really what I want?
-         when EventStream::Events::Exception        then result.record_exception event.line_number, event.class_name, event.message, event.backtrace
-         when EventStream::Events::Stdout           then result.stdout            << event.value
-         when EventStream::Events::Stderr           then result.stderr            << event.value
-         when EventStream::Events::MaxLineCaptures  then result.number_of_captures = event.value
-         when EventStream::Events::Exitstatus       then result.exitstatus         = event.value
-         when EventStream::Events::NumLines         then result.num_lines          = event.value
-         when EventStream::Events::SiBVersion       then result.sib_version        = event.value
-         when EventStream::Events::RubyVersion      then result.ruby_version       = event.value
-         when EventStream::Events::Filename         then result.filename           = event.value
-         else raise "Unknown event: #{event.inspect}"
-         end
-      end
-    end
-  end
-end

data/lib/seeing_is_believing/inspect_expressions.rb

@@ -1,21 +0,0 @@
-require 'seeing_is_believing/wrap_expressions'
-class SeeingIsBelieving
-  module InspectExpressions
-    def self.call(program, filename, number_of_captures, options={})
-      # TODO: much of this is duplicated in annotate_xmpfilter_stle
-      number_of_captures_as_str = number_of_captures.inspect
-      number_of_captures_as_str = 'Float::INFINITY' if number_of_captures == Float::INFINITY
-
-      wrap_expressions_callbacks = {}
-      wrap_expressions_callbacks[:before_all]  = options.fetch :before_all,  -> { "$SiB.record_ruby_version RUBY_VERSION;"\
-                                                                                  "$SiB.record_sib_version #{VERSION.inspect};"\
-                                                                                  "$SiB.record_filename #{filename.inspect};"\
-                                                                                  "$SiB.record_max_line_captures #{number_of_captures_as_str};"\
-                                                                                  "$SiB.num_lines = #{program.lines.count}; " }
-      wrap_expressions_callbacks[:after_all]   = options.fetch :after_all,   -> { "" }
-      wrap_expressions_callbacks[:before_each] = options.fetch :before_each, -> line_number { "(" }
-      wrap_expressions_callbacks[:after_each]  = options.fetch :after_each,  -> line_number { ").tap { |v| $SiB.record_result(:inspect, #{line_number}, v) }" }
-      WrapExpressions.call program, wrap_expressions_callbacks
-    end
-  end
-end

data/lib/seeing_is_believing/parser_helpers.rb

@@ -1,82 +0,0 @@
-module Parser
-  class << self
-    # With new versioning, there's lots of small versions
-    # we don't need it to complain that we're on 2.1.1 and its parsing 2.1.5
-    # https://github.com/whitequark/parser/blob/e2249d7051b1adb6979139928e14a81bc62f566e/lib/parser/current.rb#L3
-    def warn(*) end
-    require 'parser/current'
-    remove_method :warn
-  end
-end
-
-class SeeingIsBelieving
-  module ParserHelpers
-
-    # override #process so it does not raise an error on
-    # fatal parsings (we want to keep going if possible,
-    # this allows us to find comments in syntactically invalid files)
-    class NullDiagnostics < Parser::Diagnostic::Engine
-      def process(*)
-        # no op
-      end
-    end
-
-    extend self
-
-    def initialize_parser(code, name)
-      buffer                             = Parser::Source::Buffer.new(name)
-      buffer.source                      = code
-
-      builder                            = Parser::Builders::Default.new
-      builder.emit_file_line_as_literals = false
-
-      parser                             = Parser::CurrentRuby.new builder
-      rewriter                           = Parser::Source::Rewriter.new buffer
-
-      [buffer, parser, rewriter]
-    end
-
-    # useful b/c it can find comments even in syntactically invalid code
-    def comments_from(parser, buffer)
-      parser.instance_variable_set(:@diagnostics, NullDiagnostics.new) # seems really fucking risky
-      success, comments, tokens, * = parser.tokenize buffer            # experimentally, seems to be what these things return
-      comments
-    end
-
-    # this is the scardest fucking method I think I've ever written.
-    # *anything* can go wrong!
-    def heredoc?(ast)
-      # some strings are fucking weird.
-      # e.g. the "1" in `%w[1]` returns nil for ast.location.begin
-      # and `__FILE__` is a string whose location is a Parser::Source::Map instead of a Parser::Source::Map::Collection,
-      # so it has no #begin
-      ast.kind_of?(Parser::AST::Node)           &&
-        (ast.type == :dstr || ast.type == :str) &&
-        (location  = ast.location)              &&
-        (ast.location.kind_of? Parser::Source::Map::Heredoc)
-    end
-
-    def void_value?(ast)
-      case ast && ast.type
-      when :begin, :kwbegin, :resbody
-        void_value?(ast.children[-1])
-      when :rescue, :ensure
-        ast.children.any? { |child| void_value? child }
-      when :if
-        void_value?(ast.children[1]) || void_value?(ast.children[2])
-      when :return, :next, :redo, :retry, :break
-        true
-      else
-        false
-      end
-    end
-
-    def heredoc_hack(ast)
-      return ast
-      return ast unless heredoc? ast
-      Parser::AST::Node.new :str,
-                            [],
-                            location: Parser::Source::Map.new(ast.location.begin)
-    end
-  end
-end

data/spec/binary/interpret_flags_spec.rb

@@ -1,332 +0,0 @@
-require 'seeing_is_believing/binary/parse_args'
-require 'seeing_is_believing/binary/interpret_flags'
-
-class SeeingIsBelieving
-  module Binary
-    RSpec.describe 'SeeingIsBelieving::Binary::InterpretFlags' do
-      let(:stdin_data)  { 'stdin data' }
-      let(:stdin)       { double 'stdin', read: stdin_data }
-      let(:stdout)      { double 'stdout' }
-
-      let(:file_body)            { 'good file body' }
-      let(:nonexisting_filename) { 'badfilename'    }
-      let(:existing_filename)    { 'goodfilename'   }
-
-      before do
-        allow(File).to receive(:exist?).and_return(false)
-        allow(File).to receive(:exist?).with(existing_filename).and_return(true)
-        allow(File).to receive(:exist?).with(nonexisting_filename).and_return(false)
-        allow(File).to receive(:read).with(existing_filename).and_return(file_body)
-      end
-
-      def call(overrides={})
-        flags = ParseArgs.call []
-        InterpretFlags.new(flags.merge(overrides), stdin, stdout)
-      end
-
-      describe '.to_regex' do
-        def call(input, regex)
-          expect(InterpretFlags.to_regex input).to eq regex
-        end
-
-        it 'converts strings into regexes' do
-          call '',    %r()
-          call 'a',   %r(a)
-        end
-
-        it 'ignores surrounding slashes' do
-          call '//',  %r()
-          call '/a/', %r(a)
-        end
-
-        it 'respects flags after the trailing slash in surrounding slashes' do
-          call '/a/',     %r(a)
-          call '/a//',    %r(a/)
-          call '//a/',    %r(/a)
-          call '/a/i',    %r(a)i
-          call '/a/im',   %r(a)im
-          call '/a/xim',  %r(a)xim
-          call '/a/mix',  %r(a)mix
-          call '/a/mixi', %r(a)mixi
-        end
-
-        it 'isn\'t fooled by strings that kinda look regexy' do
-          call '/a',  %r(/a)
-          call 'a/',  %r(a/)
-          call '/',   %r(/)
-          call '/i',  %r(/i)
-        end
-
-        it 'does not escape the content' do
-          call 'a\\s+',   %r(a\s+)
-          call '/a\\s+/', %r(a\s+)
-        end
-      end
-
-      describe 'annotator' do
-        it 'annotates every line by default' do
-          expect(call.annotator).to eq AnnotateEveryLine
-        end
-
-        it 'annotates xmpfilter-style if xmpfilter_style was set' do
-          expect(call.annotator).to eq AnnotateEveryLine
-        end
-      end
-
-      describe 'help' do
-        let(:overrides) { {short_help_screen: 'short help screen',
-                           long_help_screen:  'long help screen'} }
-
-        context 'when the value is not set' do
-          before { overrides[:help] = nil }
-
-          it 'does not set print_help?' do
-            expect(call(overrides).print_help?).to eq false
-          end
-        end
-
-        context 'when the value is "help"' do
-          before { overrides[:help] = 'help' }
-
-          it 'sets print_help?' do
-            expect(call(overrides).print_help?).to eq true
-          end
-
-          it 'sets the help_screen to the short one' do
-            expect(call(overrides).help_screen).to eq 'short help screen'
-          end
-        end
-
-        context 'when the value is "help+"' do
-          before { overrides[:help] = 'help+' }
-
-          it 'sets print_help?' do
-            expect(call(overrides).print_help?).to eq true
-          end
-
-          it 'sets the help screen to the long one' do
-            expect(call(overrides).help_screen).to eq 'long help screen'
-          end
-        end
-      end
-
-      context 'debug' do
-        it 'sts a null debugger when false' do
-          expect(call(debug: false).debugger).to_not be_enabled
-        end
-
-        it 'sets a debugger to the output stream when true' do
-          expect(call(debug: true).debugger).to be_enabled
-        end
-      end
-
-      context 'markers' do
-        # TODO: fix this later to use objs
-      end
-
-      context 'timeout' do
-        it 'sets timeout to the value' do
-          expect(call(timeout: 0).timeout).to eq 0 # TODO: Should the interpretation of 0 move up from flags to here?
-          expect(call(timeout: 1).timeout).to eq 1
-        end
-      end
-
-      context 'filename' do
-        it 'sets this as the filename' do
-          expect(call(filename: 'somefilename').filename).to eq 'somefilename'
-        end
-      end
-
-      context 'filenames' do
-        it 'sets an error if more than one filename was provided' do
-          expect(call(filenames: []).errors.join).to_not match /filename/
-          expect(call(filenames: ['a']).errors.join).to_not match /filename/
-          expect(call(filenames: ['a', 'b']).errors.join).to match /filename/
-        end
-
-        it 'sets an error if there is a filename and the program was also passed on stdin' do
-          matcher = /also specified the filename/
-          expect(call(filename: 'f', program_from_args: 'prog').errors.join).to match matcher
-          expect(call(filename: nil, program_from_args: 'prog').errors.join).to_not match matcher
-          expect(call(filename: 'f', program_from_args: nil   ).errors.join).to_not match matcher
-        end
-      end
-
-      context 'predicates' do
-        it 'sets print_version? when version is true' do
-          expect(call(version: false).print_version?).to eq false
-          expect(call(version: true).print_version?).to eq true
-        end
-
-        it 'sets inherit_exit_status when inherit_exit_status is true' do
-          expect(call(inherit_exit_status: false).inherit_exit_status?).to eq false
-          expect(call(inherit_exit_status: true).inherit_exit_status?).to eq true
-        end
-
-        it 'sets result_as_json when result_as_json is true' do
-          expect(call(result_as_json: false).result_as_json?).to eq false
-          expect(call(result_as_json: true).result_as_json?).to eq true
-        end
-
-        it 'sets print_help when help has a value' do
-          expect(call(help: nil).print_help?).to eq false
-          expect(call(help: 'help').print_help?).to eq true
-        end
-
-        it 'sets print_cleaned when clean is set' do
-          expect(call(clean: false).print_cleaned?).to eq false
-          expect(call(clean: true).print_cleaned?).to eq true
-        end
-
-        it 'sets provided_filename_dne when there is a filename and that file does not exist' do
-          expect(call(filename: nonexisting_filename).provided_filename_dne?).to eq true
-          expect(call(filename: existing_filename).provided_filename_dne?).to eq false
-          expect(call(filename: nil).provided_filename_dne?).to eq false
-        end
-
-        it 'sets file_is_on_stdin when there is no filename and the program is not provided in the args' do
-          expect(call(filename: nil, program_from_args: nil).file_is_on_stdin?).to eq true
-          expect(call(filename: 'f', program_from_args: nil).file_is_on_stdin?).to eq false
-          expect(call(filename: nil, program_from_args: 'p').file_is_on_stdin?).to eq false
-        end
-      end
-
-      context 'body' do
-        it 'is an empty string if we\'re going to print the version or help instead of the program' do
-          expect(call(version: true).body).to eq ''
-          expect(call(help:    true).body).to eq ''
-        end
-
-        it 'is the program_from_args if this is provided' do
-          expect(call(program_from_args: 'prog').body).to eq 'prog'
-        end
-
-        it 'is stdin if there is no file and no program_from_args' do
-          expect(call(filename: nil, program_from_args: nil).body).to eq stdin_data
-        end
-
-        it 'is the file body if the filename is provded and exists' do
-          expect(call(filename: existing_filename).body).to eq file_body
-        end
-
-        it 'is an empty string if the provided filename dne' do
-          expect(call(filename: nonexisting_filename).body).to eq ""
-        end
-      end
-
-      context 'prepared_body' do
-        it 'is the body after being run throught he annotator\'s prepare method' do
-          expect(call(program_from_args: '1+1 # => ').prepared_body).to eq '1+1'
-        end
-      end
-
-      context 'lib_options' do
-        def call(overrides={})
-          super(overrides).lib_options
-        end
-
-        it 'returns a hash to be passed to the evaluator' do
-          expect(call).to be_a_kind_of Hash
-        end
-
-        specify 'evaluate_with is EvaluateByMovingFiles by default' do
-          expect(call[:evaluate_with]).to eq EvaluateByMovingFiles
-        end
-
-        specify 'filename is the as option or the provided filename' do
-          expect(call(filename: 'from_fn')[:filename]).to eq 'from_fn'
-          expect(call(as: 'from_as')[:filename]).to eq 'from_as'
-          expect(call(as: 'from_as', filename: 'from_fn')[:filename]).to eq 'from_as'
-        end
-
-        specify 'stdin is empty when the program is on stdin, and is stdin otherwise' do
-          # NOTE: the lib will normalize this into a stream
-          expect(call(filename: nil, program_from_args: nil)[:stdin]).to eq ''
-          expect(call(filename: nil, program_from_args: '1')[:stdin]).to eq stdin
-        end
-
-        # TODO: Add cuke where required file prints
-        specify 'require includes the matrix first, plus any other required files' do
-          expect(call(require: ['somefile'])[:require]).to eq ['seeing_is_believing/the_matrix', 'somefile']
-        end
-
-        # TODO: This is prob not ture for eval_in... maybe let the evaluators provide defaults?
-        specify 'load_path is the load_path, with the full path to sib\'s lib added' do
-          path_to_lib = File.expand_path('../../../lib', __FILE__)
-          expect(call(load_path: ['somepath'])[:load_path]).to eq [path_to_lib, 'somepath']
-        end
-
-        # TODO: Default this to utf-8
-        specify 'encoding is set to the encoding' do
-          expect(call(encoding: 'someencoding')[:encoding]).to eq 'someencoding'
-        end
-
-        specify 'timeout is set to timeout' do
-          expect(call(timeout: 1.2)[:timeout]).to eq 1.2
-        end
-
-        specify 'debugger is the same as the toplevel debugger' do
-          options = InterpretFlags.new(ParseArgs.call([]), stdin, stdout)
-          expect(options.lib_options[:debugger]).to equal options.debugger
-        end
-
-        specify 'number_of_captures is number_of_captures' do
-          expect(call(number_of_captures: 12345)[:number_of_captures]).to eq 12345
-        end
-
-        specify 'record_expressions is the annotator\'s expression wrapper' do
-          expect(call[:record_expressions]).to eq InspectExpressions
-          expect(call(xmpfilter_style: true)[:record_expressions]).to be_a_kind_of Proc
-        end
-      end
-
-      context 'annotator_options' do
-        def call(overrides={})
-          super(overrides).annotator_options
-        end
-
-        it 'sets alignment_strategy to the provided alignment strategy' do
-          expect(call(alignment_strategy: 'chunk')[:alignment_strategy]).to eq AlignChunk
-          expect(call(alignment_strategy: 'file' )[:alignment_strategy]).to eq AlignFile
-          expect(call(alignment_strategy: 'line' )[:alignment_strategy]).to eq AlignLine
-        end
-
-        it 'sets an error if the requested alignment strategy is not known, or not provided' do
-          flags   = ParseArgs.call([])
-          options = InterpretFlags.new(flags.merge(alignment_strategy: 'chunk'), stdin, stdout)
-          expect(options.errors.join).to_not include 'alignment-strategy'
-
-          options = InterpretFlags.new(flags.merge(alignment_strategy: 'nonsense'), stdin, stdout)
-          expect(options.errors.join).to include 'alignment-strategy does not know'
-
-          options = InterpretFlags.new(flags.merge(alignment_strategy: nil), stdin, stdout)
-          expect(options.errors.join).to include 'alignment-strategy expected an alignment strategy'
-        end
-
-        it 'sets the debugger to the toplevel debugger' do
-          options = InterpretFlags.new(ParseArgs.call([]), stdin, stdout)
-          expect(options.annotator_options[:debugger]).to equal options.debugger
-        end
-
-        # TODO: markers
-        it 'sets max_line_length to the max_line_length' do
-          expect(call(max_line_length: 123321)[:max_line_length]).to eq 123321
-        end
-
-        it 'sets max_result_length to the max_result_length' do
-          expect(call(max_result_length: 99889)[:max_result_length]).to eq 99889
-        end
-      end
-
-      it 'has a fancy inspect that shows predicates and attributes on multiple lines' do
-        inspected = call.inspect
-        expect(inspected).to include "PREDICATES"
-        expect(inspected).to include "ATTRIBUTES"
-        expect(inspected.lines.to_a.length).to be > 1
-        inspected.lines.each do |line|
-          expect(line.length).to be < 80 # truncate output so it doesn't get spammy
-        end
-      end
-    end
-  end
-end