seeing_is_believing 0.0.16 → 0.0.17

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    seeing_is_believing (0.0.16)
+    seeing_is_believing (0.0.17)
 
 GEM
   remote: http://rubygems.org/

data/Readme.md

@@ -130,9 +130,10 @@ Known Issues
 
 * `BEGIN/END` breaks things and I probably won't take the time to fix it, becuase it's nontrivial and its really meant for command-line scripts, but there is currently a cuke for it
 * Heredocs aren't recorded. It might actually be possible if the ExpressionList were to get smarter
-* Return statements are dealt with poorly, causing some situations where you could capture and display a value to not capture
+* Return statements and other control-flow changing keywords (next/break/redo/retry) are dealt with poorly, causing some situations where you could capture and display a value to not capture
 * errors come out really shitty if you're calling them from another program like TextMate, would be better to put a line in that shows where the error is.
 * Add a time limit to auto-kill it if it gets stuck or something (e.g. stack overflow is painful to wait for)
+* Doesn't handle # ~> -:5: stack level too deep (SystemStackError) gracefully
 
 License
 =======

data/features/errors.feature

@@ -39,3 +39,17 @@ Feature: Running the binary unsuccessfully
     Then stderr is "this_file_does_not_exist.rb does not exist!"
     And the exit status is 1
     And stdout is empty
+
+  Scenario: Passing unknown options
+    Given the file "some_file" "1"
+    When I run "seeing_is_believing --unknown-option"
+    Then stderr is 'Unknown option: "--unknown-option"'
+    And the exit status is 1
+    And stdout is empty
+
+  Scenario: Passing an unknown option with a value but forgetting the filename
+    When I run "seeing_is_believing --unknown-option some-value"
+    Then stderr is 'Unknown option: "--unknown-option"'
+    And the exit status is 1
+    And stdout is empty
+

data/features/flags.feature

@@ -242,3 +242,114 @@ Feature: Using flags
     Then stderr is empty
     And the exit status is 0
     And stdout includes "Usage"
+
+  Scenario: --timeout
+    Given the file "example.rb" "sleep 1"
+    When I run "seeing_is_believing --timeout 0.1 example.rb"
+    Then stdout is empty
+    And the exit status is 1
+    And stderr is "Timeout Error after 0.1 seconds!"
+
+  Scenario: --timeout
+    Given the file "example.rb" "1 + 1"
+    When I run "seeing_is_believing --timeout 1.0 example.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is "1 + 1  # => 2"
+
+  Scenario: --alignment-strategy file
+    Given the file "file_alignments.rb":
+    """
+    # comment
+    1
+
+    =begin
+    multiline comment
+    =end
+    1 + 1
+    1 + 1 + 1
+    """
+    When I run "seeing_is_believing --alignment-strategy file file_alignments.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    # comment
+    1          # => 1
+
+    =begin
+    multiline comment
+    =end
+    1 + 1      # => 2
+    1 + 1 + 1  # => 3
+    """
+
+  Scenario: --alignment-strategy chunk
+    Given the file "chunk_alignments.rb":
+    """
+    # comment
+    1
+
+    =begin
+    multiline comment
+    =end
+    1 + 1
+    1 + 1 + 1
+
+    1+1+1
+    1+1
+
+    1 + 1
+    # comment in the middle!
+    1 + 1 + 1 + 1
+    1 + 1
+    """
+    When I run "seeing_is_believing --alignment-strategy chunk chunk_alignments.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    # comment
+    1  # => 1
+
+    =begin
+    multiline comment
+    =end
+    1 + 1      # => 2
+    1 + 1 + 1  # => 3
+
+    1+1+1  # => 3
+    1+1    # => 2
+
+    1 + 1          # => 2
+    # comment in the middle!
+    1 + 1 + 1 + 1  # => 4
+    1 + 1          # => 2
+    """
+
+  Scenario: --alignment-strategy line
+    Given the file "line_alignments.rb":
+    """
+    # comment
+    1
+
+    =begin
+    multiline comment
+    =end
+    1 + 1
+    1 + 1 + 1
+    """
+    When I run "seeing_is_believing --alignment-strategy line line_alignments.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    # comment
+    1  # => 1
+
+    =begin
+    multiline comment
+    =end
+    1 + 1  # => 2
+    1 + 1 + 1  # => 3
+    """

data/features/step_definitions/steps.rb

@@ -6,6 +6,11 @@ When('I run "$command"')                     { |command|              @last_exec
 When("I run '$command'")                     { |command|              @last_executed = CommandLineHelpers.execute command, @stdin_data }
 Then(/^(stderr|stdout) is:$/)                { |stream_name, output|  @last_executed.send(stream_name).chomp.should == eval_curlies(output) }
 Then(/^(stderr|stdout) is ["'](.*?)["']$/)   { |stream_name, output|  @last_executed.send(stream_name).chomp.should == eval_curlies(output) }
-Then(/^(stderr|stdout) is empty$/)           { |stream_name|          @last_executed.send(stream_name).should == '' }
+Then(/^(stderr|stdout) is empty$/)           { |stream_name|
+  stream = @last_executed.send(stream_name)
+  if stream != ''
+    raise "EXPECTED NOTHING, GOT #{stream}"
+  end
+  }
 Then(/^(stderr|stdout) includes "([^"]*)"$/) { |stream_name, content| @last_executed.send(stream_name).should include eval_curlies(content) }
 Then('the exit status is $status')           { |status|               @last_executed.exitstatus.to_s.should == status }

data/lib/seeing_is_believing.rb

@@ -1,5 +1,6 @@
 require 'stringio'
 require 'tmpdir'
+require 'timeout'
 
 require 'seeing_is_believing/queue'
 require 'seeing_is_believing/result'
@@ -26,9 +27,10 @@ class SeeingIsBelieving
     @load_path       = options.fetch :load_path, []
     @encoding        = options.fetch :encoding, nil
     @line_number     = 1
+    @timeout         = options[:timeout]
   end
 
-  # I'd lik to refactor this, but I was unsatisfied with the three different things I tried.
+  # I'd like to refactor this, but I was unsatisfied with the three different things I tried.
   # In the end, I prefer keeping all manipulation of the line number here in the main function
   # And I like that the higher-level construct of how the program gets built can be found here.
   def call
@@ -118,7 +120,8 @@ class SeeingIsBelieving
                                 matrix_filename: matrix_filename,
                                 require:         @require,
                                 load_path:       @load_path,
-                                encoding:        @encoding)
+                                encoding:        @encoding,
+                                timeout:         @timeout)
                            .call
                            .track_line_number(max_line_number)
     end

data/lib/seeing_is_believing/binary.rb

@@ -1,11 +1,12 @@
 require 'seeing_is_believing'
 require 'seeing_is_believing/binary/arg_parser'
 require 'seeing_is_believing/binary/print_results_next_to_lines'
+require 'timeout'
 
 
 class SeeingIsBelieving
   class Binary
-    attr_accessor :argv, :stdin, :stdout, :stderr
+    attr_accessor :argv, :stdin, :stdout, :stderr, :timeout_error
 
     def initialize(argv, stdin, stdout, stderr)
       self.argv   = argv
@@ -21,6 +22,7 @@ class SeeingIsBelieving
                       elsif has_filename? && file_dne?  then print_file_dne        ; 1
                       elsif should_clean?               then print_cleaned_program ; 0
                       elsif invalid_syntax?             then print_syntax_error    ; 1
+                      elsif program_timedout?           then print_timeout_error   ; 1
                       else                                   print_program         ; (results.has_exception? ? 1 : 0)
                       end
     end
@@ -33,6 +35,15 @@ class SeeingIsBelieving
       flags[:filename]
     end
 
+    def program_timedout?
+      results
+      timeout_error
+    end
+
+    def print_timeout_error
+      stderr.puts "Timeout Error after #{@flags[:timeout]} seconds!"
+    end
+
     def cleaned_body
       @body ||= PrintResultsNextToLines.remove_previous_output_from \
         flags[:program] || (file_is_on_stdin? && stdin.read) || File.read(flags[:filename])
@@ -44,7 +55,10 @@ class SeeingIsBelieving
                                           require:   flags[:require],
                                           load_path: flags[:load_path],
                                           encoding:  flags[:encoding],
-                                          stdin:     (file_is_on_stdin? ? '' : stdin)
+                                          stdin:     (file_is_on_stdin? ? '' : stdin),
+                                          timeout:   flags[:timeout]
+    rescue Timeout::Error
+      self.timeout_error = true
     end
 
     def printer

data/lib/seeing_is_believing/binary/align_all.rb

@@ -0,0 +1,28 @@
+class SeeingIsBelieving
+  class Binary
+    class AlignAll
+      attr_accessor :body, :start_line, :end_line
+
+      def initialize(body, start_line, end_line)
+        self.body, self.start_line, self.end_line = body, start_line, end_line
+      end
+
+      # max line length of the lines to output (exempting comments) + 2 spaces for padding
+      def line_length_for(line_number)
+        @max_source_line_length ||= 2 + body.each_line
+                                            .map(&:chomp)
+                                            .select.with_index(1) { |line, index| start_line <= index && index <= end_line }
+                                            .take_while { |line| not start_of_data_segment? line }
+                                            .select { |line| not SyntaxAnalyzer.begins_multiline_comment?(line) .. SyntaxAnalyzer.ends_multiline_comment?(line ) }
+                                            .reject { |line| SyntaxAnalyzer.ends_in_comment? line }
+                                            .map(&:length)
+                                            .concat([0])
+                                            .max
+      end
+
+      def start_of_data_segment?(line)
+        SyntaxAnalyzer.begins_data_segment?(line.chomp)
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/align_chunk.rb

@@ -0,0 +1,37 @@
+class SeeingIsBelieving
+  class Binary
+    class AlignChunk
+      attr_accessor :body, :start_line, :end_line
+
+      def initialize(body, start_line, end_line)
+        self.body, self.start_line, self.end_line = body, start_line, end_line
+      end
+
+      # max line length of the the chunk (newline separated sections of code exempting comments) + 2 spaces for padding
+      def line_length_for(line_number)
+        line_lengths[line_number]
+      end
+
+      def line_lengths
+        @line_lengths ||= Hash[
+          body.each_line
+              .map(&:chomp)
+              .map.with_index(1) { |line, index| [line, index] }
+              .take_while        { |line, index| not start_of_data_segment? line }
+              .select            { |line, index| not SyntaxAnalyzer.begins_multiline_comment?(line) .. SyntaxAnalyzer.ends_multiline_comment?(line ) }
+              .reject            { |line, index| SyntaxAnalyzer.ends_in_comment? line }
+              .slice_before      { |line, index| line == '' }
+              .map { |slice|
+                max_chunk_length = 2 + slice.map { |line, index| line.length }.max
+                slice.map { |line, index| [index, max_chunk_length] }
+              }
+              .flatten(1)
+        ]
+      end
+
+      def start_of_data_segment?(line)
+        SyntaxAnalyzer.begins_data_segment?(line.chomp)
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/align_line.rb

@@ -0,0 +1,29 @@
+class SeeingIsBelieving
+  class Binary
+    class AlignLine
+      attr_accessor :body, :start_line, :end_line
+
+      def initialize(body, start_line, end_line)
+        self.body, self.start_line, self.end_line = body, start_line, end_line
+      end
+
+      # length of the line + 2 spaces for padding
+      def line_length_for(line_number)
+        line_lengths[line_number]
+      end
+
+      def line_lengths
+        @line_lengths ||= Hash[ body.each_line
+                                    .map(&:chomp)
+                                    .each
+                                    .with_index(1)
+                                    .map { |line, index| [index, line.length+2] }
+                              ]
+      end
+
+      def start_of_data_segment?(line)
+        SyntaxAnalyzer.begins_data_segment?(line.chomp)
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/arg_parser.rb

@@ -1,3 +1,8 @@
+require 'seeing_is_believing/version'
+require 'seeing_is_believing/binary/align_all'
+require 'seeing_is_believing/binary/align_line'
+require 'seeing_is_believing/binary/align_chunk'
+
 class SeeingIsBelieving
   class Binary
     class ArgParser
@@ -16,20 +21,22 @@ class SeeingIsBelieving
         @result ||= begin
           until args.empty?
             case (arg = args.shift)
-            when '-h', '--help'          then options[:help]    = self.class.help_screen
-            when '-v', '--version'       then options[:version] = true
-            when '-c', '--clean'         then options[:clean]   = true
-            when '-l', '--start-line'    then extract_positive_int_for :start_line,    arg
-            when '-L', '--end-line'      then extract_positive_int_for :end_line,      arg
-            when '-d', '--line-length'   then extract_positive_int_for :line_length,   arg
-            when '-D', '--result-length' then extract_positive_int_for :result_length, arg
-            when '-r', '--require'       then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:require]   << filename }
-            when '-I', '--load-path'     then next_arg("#{arg} expected a directory as the following argument but did not see one") { |dir|      options[:load_path] << dir }
-            when '-e', '--program'       then next_arg("#{arg} expected a program as the following argument but did not see one")   { |program|  options[:program]   = program }
-            when '-a', '--as'            then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:as]        = filename }
-            when /\A-K(.+)/              then options[:encoding] = $1
-            when '-K', '--encoding'      then next_arg("#{arg} expects an encoding, see `man ruby` for possibile values") { |encoding| options[:encoding] = encoding }
-            when /^-/                    then options[:errors] << "Unknown option: #{arg.inspect}" # unknown flags
+            when '-h', '--help'               then options[:help]    = self.class.help_screen
+            when '-v', '--version'            then options[:version] = true
+            when '-c', '--clean'              then options[:clean]   = true
+            when '-l', '--start-line'         then extract_positive_int_for :start_line,    arg
+            when '-L', '--end-line'           then extract_positive_int_for :end_line,      arg
+            when '-d', '--line-length'        then extract_positive_int_for :line_length,   arg
+            when '-D', '--result-length'      then extract_positive_int_for :result_length, arg
+            when '-t', '--timeout'            then extract_non_negative_float_for :timeout, arg
+            when '-r', '--require'            then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:require]            << filename }
+            when '-I', '--load-path'          then next_arg("#{arg} expected a directory as the following argument but did not see one") { |dir|      options[:load_path]          << dir }
+            when '-e', '--program'            then next_arg("#{arg} expected a program as the following argument but did not see one")   { |program|  options[:program]            = program }
+            when '-a', '--as'                 then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:as]                 = filename }
+            when '-s', '--alignment-strategy' then extract_alignment_strategy
+            when /\A-K(.+)/                   then options[:encoding] = $1
+            when '-K', '--encoding'           then next_arg("#{arg} expects an encoding, see `man ruby` for possibile values") { |encoding| options[:encoding] = encoding }
+            when /^-/                         then options[:errors] << "Unknown option: #{arg.inspect}" # unknown flags
             else
               filenames << arg
               options[:filename] = arg
@@ -58,18 +65,36 @@ class SeeingIsBelieving
 
       def options
         @options ||= {
-          version:       false,
-          clean:         false,
-          program:       nil,
-          filename:      nil,
-          start_line:    1,
-          line_length:   Float::INFINITY,
-          end_line:      Float::INFINITY,
-          result_length: Float::INFINITY,
-          errors:        [],
-          require:       [],
-          load_path:     [],
+          version:            false,
+          clean:              false,
+          program:            nil,
+          filename:           nil,
+          start_line:         1,
+          line_length:        Float::INFINITY,
+          end_line:           Float::INFINITY,
+          result_length:      Float::INFINITY,
+          timeout:            0, # timeout lib treats this as infinity
+          errors:             [],
+          require:            [],
+          load_path:          [],
+          alignment_strategy: AlignAll,
+        }
+      end
+
+
+      def extract_alignment_strategy
+        strategies = {
+          'file'  => AlignAll,
+          'chunk' => AlignChunk,
+          'line'  => AlignLine,
         }
+        next_arg "alignment-strategy expected an alignment strategy as the following argument but did not see one" do |strategy_name|
+          if strategies[strategy_name]
+            options[:alignment_strategy] = strategies[strategy_name]
+          else
+            options[:errors] << "alignment-strategy does not know #{strategy_name}, only knows: #{strategies.keys.join(', ')}"
+          end
+        end
       end
 
       def next_arg(error_message, &success_block)
@@ -86,6 +111,15 @@ class SeeingIsBelieving
           options[:errors] << "#{flag} expects a positive integer argument"
         end
       end
+
+      def extract_non_negative_float_for(key, flag)
+        float = Float args.shift
+        raise if float < 0
+        options[key] = float
+      rescue
+        options[:errors] << "#{flag} expects a positive float or integer argument"
+      end
+
     end
 
     def ArgParser.help_screen
@@ -96,18 +130,23 @@ Usage: #{$0} [options] [filename]
 
   If no filename is provided, the binary will read the program from standard input.
 
-  -l, --start-line n      # line number to begin showing results on
-  -L, --end-line n        # line number to stop showing results on
-  -d, --line-length n     # max length of the entire line (only truncates results, not source lines)
-  -D, --result-length n   # max length of the portion after the "# => "
-  -I, --load-path dir     # a dir that should be added to the $LOAD_PATH
-  -r, --require file      # additional files to be required before running the program
-  -e, --program program   # Pass the program to execute as an argument
-  -K, --encoding encoding # sets file encoding, equivalent to Ruby's -Kx (see `man ruby` for valid values)
-  -a, --as filename       # run the program as if it was the specified filename
-  -c, --clean             # remove annotations from previous runs of seeing_is_believing
-  -v, --version           # print the version (#{VERSION})
-  -h, --help              # this help screen
+  -l, --start-line n        # line number to begin showing results on
+  -L, --end-line n          # line number to stop showing results on
+  -d, --line-length n       # max length of the entire line (only truncates results, not source lines)
+  -D, --result-length n     # max length of the portion after the "# => "
+  -s, --alignment-strategy  # select the alignment strategy:
+                              file  (DEFAULT) =>  the entire file is at the same alignment
+                              chunk           =>  each chunk of code is at the same alignment
+                              line            =>  each line is at its own alignment
+  -t, --timeout n           # timeout limit in seconds when evaluating source file (ex. -t 0.3 or -t 3)
+  -I, --load-path dir       # a dir that should be added to the $LOAD_PATH
+  -r, --require file        # additional files to be required before running the program
+  -e, --program program     # Pass the program to execute as an argument
+  -K, --encoding encoding   # sets file encoding, equivalent to Ruby's -Kx (see `man ruby` for valid values)
+  -a, --as filename         # run the program as if it was the specified filename
+  -c, --clean               # remove annotations from previous runs of seeing_is_believing
+  -v, --version             # print the version (#{VERSION})
+  -h, --help                # this help screen
 HELP_SCREEN
     end
   end

data/lib/seeing_is_believing/binary/print_results_next_to_lines.rb

@@ -2,6 +2,7 @@ require 'seeing_is_believing/queue'
 require 'seeing_is_believing/has_exception'
 require 'seeing_is_believing/binary/line_formatter'
 
+
 class SeeingIsBelieving
   class Binary
     class PrintResultsNextToLines
@@ -29,11 +30,11 @@ class SeeingIsBelieving
       method_from_options :line_length,   Float::INFINITY
       method_from_options :result_length, Float::INFINITY
 
-
       def initialize(body, file_result, options={})
-        self.body        = body
-        self.options     = options
-        self.file_result = file_result
+        self.body               = body
+        self.options            = options
+        self.file_result        = file_result
+        self.alignment_strategy = options[:alignment_strategy].new body, start_line, end_line
       end
 
       def new_body
@@ -52,7 +53,7 @@ class SeeingIsBelieving
 
       private
 
-      attr_accessor :body, :file_result, :options
+      attr_accessor :body, :file_result, :options, :alignment_strategy
 
       def add_each_line_until_start_or_data_segment
         line_queue.until { |line, line_number| line_number == start_line || start_of_data_segment?(line) }
@@ -61,7 +62,7 @@ class SeeingIsBelieving
 
       def add_lines_with_results_until_end_or_data_segment
         line_queue.until { |line, line_number| end_line < line_number || start_of_data_segment?(line) }
-                  .each  { |line, line_number| new_body << format_line(line.chomp, file_result[line_number]) }
+                  .each  { |line, line_number| new_body << format_line(line.chomp, line_number, file_result[line_number]) }
       end
 
       def add_lines_until_data_segment
@@ -81,19 +82,6 @@ class SeeingIsBelieving
         SyntaxAnalyzer.begins_data_segment?(line.chomp)
       end
 
-      # max line length of the lines to output (exempting comments) + 2 spaces for padding
-      def max_source_line_length
-        @max_source_line_length ||= 2 + body.each_line
-                                            .map(&:chomp)
-                                            .select.with_index(1) { |line, index| start_line <= index && index <= end_line }
-                                            .take_while { |line| not start_of_data_segment? line }
-                                            .select { |line| not SyntaxAnalyzer.begins_multiline_comment?(line) .. SyntaxAnalyzer.ends_multiline_comment?(line ) }
-                                            .reject { |line| SyntaxAnalyzer.ends_in_comment? line }
-                                            .map(&:length)
-                                            .concat([0])
-                                            .max
-      end
-
       def add_stdout
         return unless file_result.has_stdout?
         new_body << "\n"
@@ -110,8 +98,8 @@ class SeeingIsBelieving
         end
       end
 
-      def format_line(line, line_results)
-        options = options().merge source_length: max_source_line_length
+      def format_line(line, line_number, line_results)
+        options = options().merge source_length: alignment_strategy.line_length_for(line_number)
         formatted_line = if line_results.has_exception?
                            result = sprintf "%s: %s", line_results.exception.class, line_results.exception.message
                            LineFormatter.new(line, "#{EXCEPTION_PREFIX} ", result, options).call

data/lib/seeing_is_believing/evaluate_by_moving_files.rb

@@ -11,6 +11,7 @@
 # I did look at Ripper, and it will invoke on_kw("__FILE__")
 # when it sees this.
 
+require 'yaml'
 require 'open3'
 require 'stringio'
 require 'fileutils'
@@ -20,7 +21,7 @@ require 'seeing_is_believing/hard_core_ensure'
 
 class SeeingIsBelieving
   class EvaluateByMovingFiles
-    attr_accessor :program, :filename, :error_stream, :input_stream, :matrix_filename, :require_flags, :load_path_flags, :encoding
+    attr_accessor :program, :filename, :error_stream, :input_stream, :matrix_filename, :require_flags, :load_path_flags, :encoding, :timeout
 
     def initialize(program, filename, options={})
       self.program         = program
@@ -31,6 +32,7 @@ class SeeingIsBelieving
       self.require_flags   = options.fetch(:require, []).map { |filename| ['-r', filename] }.flatten
       self.load_path_flags = options.fetch(:load_path, []).map { |dir| ['-I', dir] }.flatten
       self.encoding        = options.fetch :encoding, nil
+      self.timeout         = options[:timeout]
     end
 
     def call
@@ -44,7 +46,7 @@ class SeeingIsBelieving
             fail unless exitstatus.success?
             deserialize_result
           rescue Exception
-            record_error
+            notify_user_of_error if error_implies_bug_in_sib? $!
             raise $!
           end
         },
@@ -53,6 +55,10 @@ class SeeingIsBelieving
         }
     end
 
+    def error_implies_bug_in_sib?(error)
+      not error.kind_of? Timeout::Error
+    end
+
     def file_directory
       File.dirname filename
     end
@@ -95,9 +101,16 @@ class SeeingIsBelieving
           input_stream.each_char { |char| process_stdin.write char }
           process_stdin.close
         end
-        self.stdout     = out_reader.value
-        self.stderr     = err_reader.value
-        self.exitstatus = thread.value
+        begin
+          Timeout::timeout timeout do
+            self.stdout     = out_reader.value
+            self.stderr     = err_reader.value
+            self.exitstatus = thread.value
+          end
+        rescue Timeout::Error
+          Process.kill "TERM", thread.pid
+          raise $!
+        end
       end
     end
 
@@ -117,10 +130,12 @@ class SeeingIsBelieving
     end
 
     def deserialize_result
-      Marshal.load stdout
+      result = YAML.load stdout.force_encoding("utf-8")
+      result.fix_exception_backtraces_after_yaml_serialization
+      result
     end
 
-    def record_error
+    def notify_user_of_error
       error_stream.puts "It blew up. Not too surprising given that seeing_is_believing is pretty rough around the edges, but still this shouldn't happen."
       error_stream.puts "Please log an issue at: https://github.com/JoshCheek/seeing_is_believing/issues"
       error_stream.puts

data/lib/seeing_is_believing/has_exception.rb

@@ -2,5 +2,27 @@ class SeeingIsBelieving
   module HasException
     attr_accessor :exception
     alias has_exception? exception
+
+    # NOTE:
+    #   zomg, so YAML doesn't serialize an exception's backtrace
+    #   and Marshal gets all horked on windows (something like Marshal data too short)
+    #   so I'm going back to YAML, but independently storing the backtrace
+    #   It will need to get manually set back onto the exception
+    #
+    #   However, there is no Exception#backtrace=, so I have to redefine the method
+    #   which sucks b/c of cache busting and so forth
+    #   but that probably doesn't actually matter for any real-world use case of SeeingIsBelieving
+
+    def exception=(exception)
+      @exception = exception
+      @exception_backtrace = exception.backtrace
+    end
+
+    def fix_exception_backtraces_after_yaml_serialization
+      return unless exception
+      exception_backtrace = @exception_backtrace
+      exception.define_singleton_method(:backtrace) { exception_backtrace }
+      self
+    end
   end
 end

data/lib/seeing_is_believing/the_matrix.rb

@@ -1,6 +1,7 @@
 # WARNING: DO NOT REQUIRE THIS FILE, IT WILL FUCK YOU UP!!!!!!
 
 
+require 'yaml'
 require 'stringio'
 real_stdout = STDOUT
 real_stderr = STDERR
@@ -14,5 +15,5 @@ at_exit do
   $seeing_is_believing_current_result.stdout = fake_stdout.string
   $seeing_is_believing_current_result.stderr = fake_stderr.string
 
-  real_stdout.write Marshal.dump $seeing_is_believing_current_result
+  real_stdout.write YAML.dump($seeing_is_believing_current_result).force_encoding("utf-8")
 end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '0.0.16'
+  VERSION = '0.0.17'
 end

data/spec/arg_parser_spec.rb

@@ -40,9 +40,25 @@ describe SeeingIsBelieving::Binary::ArgParser do
     end
   end
 
+  shared_examples 'it requires a non-negative float or int' do |flags|
+    it 'expects a non-negative float or int argument' do
+      flags.each do |flag|
+        parse([flag,   '1']).should_not have_error /#{flag}/
+        parse([flag,   '0']).should_not have_error /#{flag}/
+        parse([flag,  '-1']).should     have_error /#{flag}/
+        parse([flag,'-1.0']).should     have_error /#{flag}/
+        parse([flag, '1.0']).should_not have_error /#{flag}/
+        parse([flag,   'a']).should     have_error /#{flag}/
+        parse([flag,   '' ]).should     have_error /#{flag}/
+        parse([flag       ]).should     have_error /#{flag}/
+      end
+    end
+  end
+
   specify 'unknown options set an error' do
     parse(['--xyz']).should have_error 'Unknown option: "--xyz"'
     parse(['-x']).should have_error 'Unknown option: "-x"'
+    parse(['-x', 'b']).should have_error 'Unknown option: "-x"'
   end
 
   example 'example: multiple args' do
@@ -259,5 +275,41 @@ describe SeeingIsBelieving::Binary::ArgParser do
       parse(%w[--version])[:version].should == true
     end
   end
+
+  describe ':timeout' do
+    it 'defaults to 0' do
+      parse([])[:timeout].should == 0
+    end
+
+    it_behaves_like 'it requires a non-negative float or int', ['-t', '--timeout']
+  end
+
+  describe ':alignment_strategy' do
+    AlignAll   = SeeingIsBelieving::Binary::AlignAll
+    AlignLine  = SeeingIsBelieving::Binary::AlignLine
+    AlignChunk = SeeingIsBelieving::Binary::AlignChunk
+
+    # maybe change the default?
+    it 'defaults to AlignAll' do
+      parse([])[:alignment_strategy].should == AlignAll
+    end
+
+    specify '-s and --alignment-strategy sets the alignment strategy' do
+      parse(['-s',                   'chunk'])[:alignment_strategy].should == AlignChunk
+      parse(['--alignment-strategy', 'chunk'])[:alignment_strategy].should == AlignChunk
+    end
+
+    it 'accepts values: file, line, chunk' do
+      parse(['-s',  'file'])[:alignment_strategy].should == AlignAll
+      parse(['-s',  'line'])[:alignment_strategy].should == AlignLine
+      parse(['-s', 'chunk'])[:alignment_strategy].should == AlignChunk
+    end
+
+    it 'sets an error if not provided with a strategy, or if provided with an unknown strategy' do
+      parse(['-s', 'file']).should_not have_error /alignment-strategy/
+      parse(['-s',  'abc']).should     have_error /alignment-strategy/
+      parse(['-s'        ]).should     have_error /alignment-strategy/
+    end
+  end
 end
 

data/spec/seeing_is_believing_spec.rb

@@ -279,4 +279,9 @@ describe SeeingIsBelieving do
                                                                      [], [],
                                                                      ['6']]
   end
+
+  it 'times out if the timeout limit is exceeded' do
+    expect { invoke "sleep 0.2", timeout: 0.1 }.to raise_error Timeout::Error
+  end
+
 end

metadata

@@ -2,14 +2,14 @@
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.0.16
+  version: 0.0.17
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-19 00:00:00.000000000 Z
+date: 2013-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
@@ -99,6 +99,9 @@ files:
 - features/support/env.rb
 - lib/seeing_is_believing.rb
 - lib/seeing_is_believing/binary.rb
+- lib/seeing_is_believing/binary/align_all.rb
+- lib/seeing_is_believing/binary/align_chunk.rb
+- lib/seeing_is_believing/binary/align_line.rb
 - lib/seeing_is_believing/binary/arg_parser.rb
 - lib/seeing_is_believing/binary/line_formatter.rb
 - lib/seeing_is_believing/binary/print_results_next_to_lines.rb