seeing_is_believing 2.2.0 → 3.0.0.beta.1

data/spec/binary/comment_lines_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'seeing_is_believing/binary/comment_lines'
 
-describe SeeingIsBelieving::Binary::CommentLines, 'passes in the each commentable line and the line number, and adds the returned text (whitespace+comment) to the end' do
+RSpec.describe SeeingIsBelieving::Binary::CommentLines, 'passes in the each commentable line and the line number, and adds the returned text (whitespace+comment) to the end' do
   def call(code, &block)
     described_class.call code, &block
   end

data/spec/binary/interpret_flags_spec.rb

@@ -0,0 +1,307 @@
+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 '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 'shebang' do
+        it 'sets shebang to the value' do
+          expect(call(shebang: 'whatevz').shebang).to eq 'whatevz'
+        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 'evaluate_with is EvaluateWithEvalIn if safe is set' do
+          expect(call(safe: true)[:evaluate_with]).to eq EvaluateWithEvalIn
+        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 'ruby_executable is the shebang' do
+          expect(call(shebang: 'shebangprog')[:ruby_executable]).to eq 'shebangprog'
+        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

data/spec/binary/parse_args_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'seeing_is_believing/binary/parse_args'
 
-describe SeeingIsBelieving::Binary::ParseArgs do
+RSpec.describe SeeingIsBelieving::Binary::ParseArgs do
   RSpec::Matchers.define :have_error do |error_assertion|
     match do |options|
       options[:errors].find do |error|
@@ -23,8 +23,12 @@ describe SeeingIsBelieving::Binary::ParseArgs do
     end
   end
 
-  def parse(args, outstream=nil)
-    SeeingIsBelieving::Binary::ParseArgs.call args, outstream
+  def parse(args)
+    SeeingIsBelieving::Binary::ParseArgs.call args
+  end
+
+  def matrix_file
+    'seeing_is_believing/the_matrix'
   end
 
   shared_examples 'it requires a positive int argument' do |flags|
@@ -56,18 +60,33 @@ describe SeeingIsBelieving::Binary::ParseArgs do
     end
   end
 
+  it 'does not mutate the input array' do
+    ary = ['a']
+    parse(ary)
+    expect(ary).to eq ['a']
+  end
+
+  it 'can interpret conjoined short-flags' do
+    expect(parse(['-hjg'])).to eq parse(['-h', '-j', '-g'])
+  end
+
+  it 'can interpret conjoined short-flags where one of them is h+' do
+    expect(parse(['-h+jg'])).to eq parse(['-h+', '-j',  '-g'])
+    expect(parse(['-jh+g'])).to eq parse(['-j',  '-h+', '-g'])
+    expect(parse(['-jgh+'])).to eq parse(['-j',  '-g',  '-h+'])
+  end
+
   specify 'unknown options set an error' do
-    expect(parse(['--xyz'])).to have_error 'Unknown option: "--xyz"'
-    expect(parse(['-y'])).to have_error 'Unknown option: "-y"'
+    expect(parse(['--xyz'  ])).to have_error 'Unknown option: "--xyz"'
+    expect(parse(['-y'     ])).to have_error 'Unknown option: "-y"'
     expect(parse(['-y', 'b'])).to have_error 'Unknown option: "-y"'
+    expect(parse(['-+h'    ])).to have_error 'Unknown option: "-+"'
   end
 
   example 'example: multiple args' do
-    options = parse(%w[filename -l 12 -L 20 -h -r torequire])
+    options = parse(%w[filename -h -r torequire])
     expect(options[:filename]).to eq 'filename'
-    expect(options[:start_line]).to eq 12
-    expect(options[:end_line]).to eq 20
-    expect(options[:require]).to eq ['torequire']
+    expect(options[:require]).to include 'torequire'
     expect(options[:help]).to be_a_kind_of String
     expect(options[:errors]).to be_empty
   end
@@ -83,42 +102,11 @@ describe SeeingIsBelieving::Binary::ParseArgs do
       expect(parse(['a', '-x'])[:filename]).to eq 'a'
     end
 
-    it 'sets an error if given multiple filenames' do
-      expect(parse([])).to_not have_error /name/
-      expect(parse(['a'])).to_not have_error /Can only have one filename/
-      expect(parse(['a', 'b'])).to have_error 'Can only have one filename, but had: "a", "b"'
-    end
-  end
-
-  describe ':start_line' do
-    it 'defaults to 1' do
-      expect(parse([])[:start_line]).to equal 1
-    end
-
-    it 'is set with -l and --start-line' do
-      expect(parse(['-l', '1'])[:start_line]).to eq 1
-      expect(parse(['--start-line', '12'])[:start_line]).to eq 12
+    it 'records all filenames it sees' do
+      expect(parse([])[:filenames]).to eq []
+      expect(parse(['a'])[:filenames]).to eq ['a']
+      expect(parse(['a', 'b'])[:filenames]).to eq ['a', 'b']
     end
-
-    it_behaves_like 'it requires a positive int argument', ['-l', '--start-line']
-  end
-
-  describe ':end_line' do
-    it 'defaults to infinity' do
-      expect(parse([])[:end_line]).to equal Float::INFINITY
-    end
-
-    it 'is set with -L and --end-line' do
-      expect(parse(['-L', '1'])[:end_line]).to eq 1
-      expect(parse(['--end-line', '12'])[:end_line]).to eq 12
-    end
-
-    it_behaves_like 'it requires a positive int argument', ['-L', '--end-line']
-  end
-
-  it 'swaps start and end line around if they are out of order' do
-    expect(parse(%w[-l 2 -L 1])[:start_line]).to eq 1
-    expect(parse(%w[-l 2 -L 1])[:end_line]).to eq 2
   end
 
   describe ':result_length' do
@@ -148,12 +136,12 @@ describe SeeingIsBelieving::Binary::ParseArgs do
   end
 
   describe :require do
-    it 'defaults to an empty array' do
-      expect(parse([])[:require]).to be_empty
+    it 'defaults to the matrix file array' do
+      expect(parse([])[:require]).to eq [matrix_file]
     end
 
     it '-r and --require sets each required file into the result array' do
-      expect(parse(%w[-r f1 --require f2])[:require]).to eq %w[f1 f2]
+      expect(parse(%w[-r f1 --require f2])[:require]).to eq [matrix_file, 'f1', 'f2']
     end
 
     it 'sets an error if not provided with a filename' do
@@ -168,31 +156,37 @@ describe SeeingIsBelieving::Binary::ParseArgs do
       expect(parse([])[:help]).to be_nil
     end
 
-    it 'is set to the flag only help screen with -h and --help and -help' do
-      expect(parse(['-h'])[:help]).to include 'Usage:'
-      expect(parse(['--help'])[:help]).to include 'Usage:'
-
-      expect(parse(['-h'])[:help]).to_not include 'Examples:'
-      expect(parse(['--help'])[:help]).to_not include 'Examples:'
+    it 'is set to "help" with -h and --help and -help' do
+      expect(parse(['-h'])[:help]).to eq 'help'
+      expect(parse(['--help'])[:help]).to eq 'help'
     end
 
-    it 'is set to the flag with examples help screen with --help+ and -h+' do
-      expect(parse(['-h+'])[:help]).to include 'Usage:'
-      expect(parse(['--help+'])[:help]).to include 'Usage:'
+    it 'is set to "help+" with examples help screen with --help+ and -h+' do
+      expect(parse(['-h+'])[:help]).to eq 'help+'
+      expect(parse(['--help+'])[:help]).to eq 'help+'
+    end
+  end
 
-      expect(parse(['-h+'])[:help]).to include 'Examples:'
-      expect(parse(['--help+'])[:help]).to include 'Examples:'
+  describe 'short and long help_screen' do
+    specify 'they are the short and long help screens' do
+      short = parse([])[:short_help_screen]
+      long  = parse([])[:long_help_screen]
+      expect(short.length).to be < long.length
+      expect(short).to     include 'Usage'
+      expect(long).to      include 'Usage'
+      expect(short).to_not include 'Examples'
+      expect(long).to      include 'Examples'
     end
   end
 
-  describe ':program' do
+  describe ':program_from_args' do
     it 'defaults to nil' do
-      expect(parse([])[:program]).to be_nil
+      expect(parse([])[:program_from_args]).to be_nil
     end
 
     it 'is set with -e or --program, and takes the next arg' do
-      expect(parse(['-e', '1'])[:program]).to eq '1'
-      expect(parse(['--program', '1'])[:program]).to eq '1'
+      expect(parse(['-e', '1'])[:program_from_args]).to eq '1'
+      expect(parse(['--program', '1'])[:program_from_args]).to eq '1'
     end
 
     it 'sets an error if not given a program' do
@@ -201,11 +195,6 @@ describe SeeingIsBelieving::Binary::ParseArgs do
       expect(parse(['-e'])).to have_error /-e/
       expect(parse(['--program'])).to have_error /--program/
     end
-
-    it 'sets an error if a filename is also give' do
-      expect(parse(['-e', '1'])).to_not have_error /-e/
-      expect(parse(['-e', '1', 'abc'])).to have_error /"abc"/
-    end
   end
 
   describe':load_path' do
@@ -297,30 +286,24 @@ describe SeeingIsBelieving::Binary::ParseArgs do
   end
 
   describe ':alignment_strategy' do
-    AlignFile  = SeeingIsBelieving::Binary::AlignFile
-    AlignLine  = SeeingIsBelieving::Binary::AlignLine
-    AlignChunk = SeeingIsBelieving::Binary::AlignChunk
-
-    # maybe change the default?
-    it 'defaults to AlignChunk' do
-      expect(parse([])[:alignment_strategy]).to eq AlignChunk
+    # TODO: maybe change the default?
+    it 'defaults to "chunk"' do
+      expect(parse([])[:alignment_strategy]).to eq 'chunk'
     end
 
     specify '-s and --alignment-strategy sets the alignment strategy' do
-      expect(parse(['-s',                   'chunk'])[:alignment_strategy]).to eq AlignChunk
-      expect(parse(['--alignment-strategy', 'chunk'])[:alignment_strategy]).to eq AlignChunk
+      expect(parse(['-s',                   'chunk'])[:alignment_strategy]).to eq 'chunk'
+      expect(parse(['--alignment-strategy', 'chunk'])[:alignment_strategy]).to eq 'chunk'
     end
 
     it 'accepts values: file, line, chunk' do
-      expect(parse(['-s',  'file'])[:alignment_strategy]).to eq AlignFile
-      expect(parse(['-s',  'line'])[:alignment_strategy]).to eq AlignLine
-      expect(parse(['-s', 'chunk'])[:alignment_strategy]).to eq AlignChunk
+      expect(parse(['-s',  'file'])[:alignment_strategy]).to eq 'file'
+      expect(parse(['-s',  'line'])[:alignment_strategy]).to eq 'line'
+      expect(parse(['-s', 'chunk'])[:alignment_strategy]).to eq 'chunk'
     end
 
-    it 'sets an error if not provided with a strategy, or if provided with an unknown strategy' do
+    it 'sets an error if not provided with a strategy' do
       expect(parse(['-s', 'file'])).to_not have_error /alignment-strategy/
-      expect(parse(['-s',  'abc'])).to     have_error /alignment-strategy/
-      expect(parse(['-s'        ])).to     have_error /alignment-strategy/
     end
   end
 
@@ -346,18 +329,14 @@ describe SeeingIsBelieving::Binary::ParseArgs do
     end
   end
 
-  describe ':debugger' do
-    it 'defaults to a debugger that is disabled' do
-      expect(parse([], :fake_stream)[:debugger]).to_not be_enabled
+  describe ':debug' do
+    it 'defaults to a false' do
+      expect(parse([])[:debug]).to eq false
     end
 
     it 'can be enabled with --debug or -g' do
-      expect(parse(['--debug'], :fake_stream)[:debugger]).to be_enabled
-      expect(parse(['-g'], :fake_stream)[:debugger]).to be_enabled
-    end
-
-    it 'sets the stream to the one passed in' do
-      expect(parse(['-g'], :fake_stream)[:debugger].stream).to eq :fake_stream
+      expect(parse(['--debug'])[:debug]).to eq true
+      expect(parse(['-g'])[:debug]).to eq true
     end
   end
 
@@ -399,5 +378,28 @@ describe SeeingIsBelieving::Binary::ParseArgs do
       expect(parse(['-j'])[:result_as_json]).to eq true
     end
   end
+
+  describe ':markers' do
+    it 'defaults to a hash with :value, :exception, :stdout, :stderr, and :nextline' do
+      expect(parse([])[:markers].keys).to eq [:value, :exception, :stdout, :stderr, :nextline]
+    end
+
+    def assert_default(marker_name, value)
+      expect(parse([])[:markers][marker_name]).to eq value
+    end
+
+    it('defaults :value     to "# => "') { assert_default :value     , "# => " }
+    it('defaults :exception to "# ~> "') { assert_default :exception , "# ~> " }
+    it('defaults :stdout    to "# >> "') { assert_default :stdout    , "# >> " }
+    it('defaults :stderr    to "# !> "') { assert_default :stderr    , "# !> " }
+    it('defaults :nextline  to "#    "') { assert_default :nextline  , "#    " }
+
+    # TODO: When things get a little more stable, don't feel like adding all the cukes to play with this right now
+    it 'overrides :value     with --value-marker'
+    it 'overrides :exception with --exception-marker'
+    it 'overrides :stdout    with --stdout-marker'
+    it 'overrides :stderr    with --stderr-marker'
+    it 'overrides :nextline  with --xmpfilter-nextline-marker'
+  end
 end