seeing_is_believing 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae86d44e9afffb2928ac761a5bf8f6810ec1c996
-  data.tar.gz: 4c37f23d51da74cde81e85f2c48b1928daeedce9
+  metadata.gz: 5d761a62840425753a50b764d74caad42f1ff790
+  data.tar.gz: eb674e4076644502c643453699d1744de4161315
 SHA512:
-  metadata.gz: 08e8e66324e9360ee680327765f7d633a0862ab22237148ddd49d0bfc78ebfaa89f9466a4390dc5404126aa791256cbb437aa346ebbfc22c904a231fab042c35
-  data.tar.gz: bd56f998a57e28b06bcfc04782feb64ccb1e7466503cec372b08f9f77102a70df4c05dd7e9079f45b441ed2c72ded198d02aedc653c8be2c43d69448e48a286f
+  metadata.gz: 4e51b01ba8efe1a01b3602132ebb81a7ef935af700dfe05dbf4671cec579729dd3bb86cb83bba124c595bd7623e4612752e7266724fc7f9d3a6ba61b3cee5bba
+  data.tar.gz: 70bd344383af51e11e3edf04dcadfdee0c37535dbda6fbe6c1fe4ff582c9c5603a106db38e6b752e0cac47bc710bac803cdd82d7c37c932fe377cc2e605a5407

data/Readme.md

@@ -93,18 +93,11 @@ Known Issues
 * `exit!` ignores callbacks that `SeeingIsBelieving` uses to communicate the results back to the main app. If you call it, `SeeingIsBelieving` will blow up. We could "fix" this by overriding it, but I feel like that would violate the meaning of `exit!`, so basically, just don't call that method.
 * The code to find the data segment is naive, and could wind up interpolating results into a string or something
 
-Todo
-====
-
-* Sublime: Merge xmpfilter option into main after 2.0 release
-* Make a new video
-
 Shit that will probably never get done (or if it does, won't be until after 2.0)
 ================================================================================
 
 * How about if begin/rescue/end was able to record the result on the rescue section
 * What about recording the result of a line inside of a string interpolation, e.g. "a#{\n1\n}b" could record line 2 is 1 and line 3 is "a\n1\nb"
-* Add a flag to allow you to just get the results so that it can be easily used without a Ruby runtime (difficult in that its unclear how to separate line output from stdout, stderr, exit status, exceptions, etc. Maybe just serialize the result as JSON?)
 * Be able to clean an invalid file (used to be able to do this, but parser can't identify comments in an invalid file the way that I'm currently using it, cuke is still there, marked as @not-implemented)
 * If given a file with a unicode character, but not set unicode, inform the user
 

data/features/flags.feature

@@ -184,6 +184,28 @@ Feature: Using flags
     When I run "seeing_is_believing --line-length 14 line_lengths2.rb"
     Then stdout is "12345"
 
+  Scenario: --number-of-captures determines how many times a line will be recorded
+    Given the file "number_of_captures.rb":
+    """
+    5.times do |i|
+      i
+    end
+    """
+    When I run "seeing_is_believing --number-of-captures 4 number_of_captures.rb"
+    Then stdout is:
+    """
+    5.times do |i|  # => 5
+      i             # => 0, 1, 2, 3, ...
+    end             # => 5
+    """
+    When I run "seeing_is_believing --number-of-captures 5 number_of_captures.rb"
+    Then stdout is:
+    """
+    5.times do |i|  # => 5
+      i             # => 0, 1, 2, 3, 4
+    end             # => 5
+    """
+
   Scenario: --xmpfilter-style respects the line formatting (but not currently alignment strategies, it just preserves submitted alignment)
     Given the file "line_lengths3.rb":
     """
@@ -537,3 +559,44 @@ Feature: Using flags
     When I run "chmod +x fake_ruby"
     When I run "seeing_is_believing -e 123 --shebang ./fake_ruby"
     Then stdout is "123  # => /omg/"
+
+  Scenario: --json
+    Given the file "all_kinds_of_output.rb":
+    """
+    3.times do |i|
+      i.to_s
+    end
+    $stdout.puts "b"
+    $stderr.puts "c"
+    raise "omg"
+    """
+    When I run "seeing_is_believing --json all_kinds_of_output.rb"
+    Then the exit status is 0
+    And stdout is the JSON:
+    """
+      {
+        "lines": {
+          "1": { "exception": null, "results": ["3"] },
+          "2": { "exception": null, "results": ["\"0\"", "\"1\"", "\"2\""] },
+          "3": { "exception": null, "results": ["3"] },
+          "4": { "exception": null, "results": ["nil"] },
+          "5": { "exception": null, "results": ["nil"] },
+          "6": { "exception": { "class_name": "RuntimeError",
+                                "message":    "omg",
+                                "backtrace":  ["all_kinds_of_output.rb:6:in `<main>'"]
+                              },
+                 "results": []
+               }
+        },
+        "exception": {
+          "line_number_in_this_file": 6,
+          "class_name":               "RuntimeError",
+          "message":                  "omg",
+          "backtrace":                ["all_kinds_of_output.rb:6:in `<main>'"]
+        },
+        "stdout": "b\n",
+        "stderr": "c\n",
+        "exit_status": 1
+      }
+    """
+

data/features/support/env.rb

@@ -10,3 +10,9 @@ end
 Then 'stdout is exactly:' do |code|
   @last_executed.stdout.should == eval_curlies(code)
 end
+
+Then 'stdout is the JSON:' do |json|
+  expected = JSON.parse(json)
+  actual   = JSON.parse(@last_executed.stdout)
+  actual.should == expected
+end

data/for-presentations

@@ -0,0 +1,33 @@
+# intro
+  # show the website!
+  # omg, what's it do?
+  # integrates with the editors
+
+# walk through example of how to use it
+  # make a user class or something
+  # show the -n flag
+
+# features
+  # iteration
+  # method and invocations
+  # multilinezzz
+  # mutliple levels of nesting (e.g. class definition)
+  # printing to stdout/stderr, respecting DATA segment
+  # respecting macros
+  # exceptions displayed where they occur
+  # records hash results
+  # syntax errors
+  # total fucking failure
+
+# show the snippets
+  # s_arb
+  # s_sinatra
+  # s_nokogiri
+  # s_reflection
+
+# Show how to customize
+  # --line-length n
+  # --result-length n
+  # --alignment-strategy name
+  # --timeout n
+  # --debug

data/lib/seeing_is_believing.rb

@@ -17,16 +17,17 @@ class SeeingIsBelieving
   end
 
   def initialize(program, options={})
-    @program         = program
-    @matrix_filename = options[:matrix_filename]
-    @filename        = options[:filename]
-    @stdin           = to_stream options.fetch(:stdin, '')
-    @require         = options.fetch :require, []
-    @load_path       = options.fetch :load_path, []
-    @encoding        = options.fetch :encoding, nil
-    @timeout         = options[:timeout]
-    @debugger        = options.fetch :debugger, Debugger.new(stream: nil)
-    @ruby_executable = options.fetch :ruby_executable, 'ruby'
+    @program            = program
+    @matrix_filename    = options[:matrix_filename]
+    @filename           = options[:filename]
+    @stdin              = to_stream options.fetch(:stdin, '')
+    @require            = options.fetch :require, []
+    @load_path          = options.fetch :load_path, []
+    @encoding           = options.fetch :encoding, nil
+    @timeout            = options[:timeout]
+    @debugger           = options.fetch :debugger, Debugger.new(stream: nil)
+    @ruby_executable    = options.fetch :ruby_executable, 'ruby'
+    @number_of_captures = options.fetch :number_of_captures, Float::INFINITY
   end
 
   def call
@@ -50,7 +51,7 @@ class SeeingIsBelieving
 
   def program_that_will_record_expressions
     WrapExpressions.call "#@program\n",
-                         before_all:  "begin;",
+                         before_all:  "begin; $SiB.number_of_captures = #{number_of_captures_as_str}; ",
                          after_all:   ";rescue Exception;"\
                                         "line_number = $!.backtrace.grep(/\#{__FILE__}/).first[/:\\d+/][1..-1].to_i;"\
                                         "$SiB.record_exception line_number, $!;"\
@@ -66,15 +67,21 @@ class SeeingIsBelieving
       filename = @filename || File.join(dir, 'program.rb')
       EvaluateByMovingFiles.new(program,
                                 filename,
-                                input_stream:    @stdin,
-                                matrix_filename: matrix_filename,
-                                require:         @require,
-                                load_path:       @load_path,
-                                encoding:        @encoding,
-                                timeout:         @timeout,
-                                ruby_executable: @ruby_executable,
-                                debugger:        @debugger)
+                                input_stream:       @stdin,
+                                matrix_filename:    matrix_filename,
+                                require:            @require,
+                                load_path:          @load_path,
+                                encoding:           @encoding,
+                                timeout:            @timeout,
+                                ruby_executable:    @ruby_executable,
+                                debugger:           @debugger,
+                                number_of_captures: @number_of_captures)
                            .call
     end
   end
+
+  def number_of_captures_as_str
+    return 'Float::INFINITY' if @number_of_captures == Float::INFINITY
+    @number_of_captures.inspect
+  end
 end

data/lib/seeing_is_believing/binary.rb

@@ -44,6 +44,7 @@ class SeeingIsBelieving
         elsif invalid_syntax?                       then print_syntax_error     ; NONDISPLAYABLE_ERROR_STATUS
         elsif (evaluate_program; program_timedout?) then print_timeout_error    ; NONDISPLAYABLE_ERROR_STATUS
         elsif something_blew_up?                    then print_unexpected_error ; NONDISPLAYABLE_ERROR_STATUS
+        elsif output_as_json?                       then print_result_as_json   ; SUCCESS_STATUS
         else                                             print_program          ; program_exit_status
         end
       end
@@ -173,5 +174,40 @@ class SeeingIsBelieving
     def print_cleaned_program
       stdout.print CleanBody.call(body, true)
     end
+
+    def output_as_json?
+      flags[:result_as_json]
+    end
+
+    def print_result_as_json
+      require 'json'
+      stdout.puts JSON.dump result_as_data_structure
+    end
+
+    def result_as_data_structure
+      results = printer.results
+      { stdout:      results.stdout,
+        stderr:      results.stderr,
+        exit_status: results.exitstatus,
+        exception:   if results.has_exception?
+                       { line_number_in_this_file: results.each_with_line_number.find { |line_number, result| result.has_exception? }.first,
+                         class_name:               results.exception.class_name,
+                         message:                  results.exception.message,
+                         backtrace:                results.exception.backtrace,
+                       }
+                     end,
+        lines:       results.each_with_line_number.each_with_object(Hash.new) { |(line_number, result), hash|
+                       hash[line_number] = { results:   result.to_a,
+                                             exception: if result.has_exception?
+                                                          { class_name:               results.exception.class_name,
+                                                            message:                  results.exception.message,
+                                                            backtrace:                results.exception.backtrace,
+                                                          }
+                                                        end
+                       }
+                     },
+      }
+    end
+
   end
 end

data/lib/seeing_is_believing/binary/add_annotations.rb

@@ -27,14 +27,15 @@ class SeeingIsBelieving
         self.options = options
         self.body    = CleanBody.call uncleaned_body, !xmpfilter_style
         self.results = SeeingIsBelieving.call body,
-                                              filename:        (options[:as] || options[:filename]),
-                                              require:         options[:require],
-                                              load_path:       options[:load_path],
-                                              encoding:        options[:encoding],
-                                              stdin:           options[:stdin],
-                                              timeout:         options[:timeout],
-                                              debugger:        debugger,
-                                              ruby_executable: options[:shebang]
+                                              filename:           (options[:as] || options[:filename]),
+                                              require:            options[:require],
+                                              load_path:          options[:load_path],
+                                              encoding:           options[:encoding],
+                                              stdin:              options[:stdin],
+                                              timeout:            options[:timeout],
+                                              debugger:           debugger,
+                                              ruby_executable:    options[:shebang],
+                                              number_of_captures: options[:number_of_captures]
       end
 
       def call

data/lib/seeing_is_believing/binary/parse_args.rb

@@ -30,12 +30,14 @@ class SeeingIsBelieving
             when '-v', '--version'             then options[:version]             = true
             when '-x', '--xmpfilter-style'     then options[:xmpfilter_style]     = true
             when '-i', '--inherit-exit-status' then options[:inherit_exit_status] = true
+            when '-j', '--json'                then options[:result_as_json]      = true
             when '-g', '--debug'               then options[:debugger]            = Debugger.new(stream: outstream, colour: 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 :max_line_length,   arg
-            when '-D', '--result-length'       then extract_positive_int_for :max_result_length, arg
-            when '-t', '--timeout'             then extract_non_negative_float_for :timeout,     arg
+            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 :max_line_length,    arg
+            when '-D', '--result-length'       then extract_positive_int_for :max_result_length,  arg
+            when '-n', '--number-of-captures'  then extract_positive_int_for :number_of_captures, 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 }
@@ -85,12 +87,14 @@ class SeeingIsBelieving
           end_line:            Float::INFINITY,
           max_line_length:     Float::INFINITY,
           max_result_length:   Float::INFINITY,
+          number_of_captures:  Float::INFINITY,
           timeout:             0, # timeout lib treats this as infinity
           errors:              [],
           require:             [],
           load_path:           [],
           alignment_strategy:  AlignChunk,
           shebang:             'ruby',
+          result_as_json:      false,
         }
       end
 
@@ -147,6 +151,9 @@ Usage: seeing_is_believing [options] [filename]
   -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 "#{VALUE_MARKER}"
+  -n, --number-of-captures n    # how many results to capture for a given line
+                                  if you had 1 million results on a line, it could take a long time to record
+                                  and serialize them, you might limit it to 1000 results as an optimization
   -s, --alignment-strategy name # select the alignment strategy:
                                   chunk (DEFAULT) =>  each chunk of code is at the same alignment
                                   file            =>  the entire file is at the same alignment
@@ -160,6 +167,7 @@ Usage: seeing_is_believing [options] [filename]
   -c, --clean                   # remove annotations from previous runs of seeing_is_believing
   -g, --debug                   # print debugging information (useful if program is fucking up, or if you want to brag)
   -x, --xmpfilter-style         # annotate marked lines instead of every line
+  -j, --json                    # print results in json format (i.e. so another program can consume them)
   -i, --inherit-exit-status     # exit with the exit status of the program being eval
       --shebang ruby-executable # if you want SiB to use some ruby other than the one in the path
   -v, --version                 # print the version (#{VERSION})

data/lib/seeing_is_believing/line.rb

@@ -1,11 +1,8 @@
 require 'seeing_is_believing/has_exception'
+
 class SeeingIsBelieving
   # thin wrapper over an array, used by the result
   class Line
-    def self.[](*elements)
-      new(elements)
-    end
-
     include HasException
     include Enumerable
 
@@ -22,8 +19,22 @@ class SeeingIsBelieving
     end
     alias to_ary to_a
 
-    def initialize(array = [])
-      @array = array.dup
+    def initialize(array = [], max_number_of_captures=Float::INFINITY)
+      @array                  = []
+      @max_number_of_captures = max_number_of_captures
+      @num_results            = 0
+      @total_size             = 0
+      array.each { |element| record_result element }
+    end
+
+    def record_result(value)
+      inspected = value.inspect # only invoke inspect once, b/c the inspection may be recorded
+      if    size <  @max_number_of_captures then @array << inspected
+      elsif size == @max_number_of_captures then @array << '...'
+      end
+      @num_results += 1
+      @total_size  += inspected.size
+      self
     end
 
     def ==(ary_or_line)
@@ -33,7 +44,7 @@ class SeeingIsBelieving
 
     def inspect
       inspected_exception = has_exception? ? "#{exception.class}:#{exception.message.inspect}" : "no exception"
-      "#<SIB:Line#{@array.inspect} #{inspected_exception}>"
+      "#<SIB:Line#{@array.inspect} (#@num_results, #@total_size) #{inspected_exception}>"
     end
   end
 end

data/lib/seeing_is_believing/result.rb

@@ -6,7 +6,7 @@ class SeeingIsBelieving
     include HasException
     include Enumerable
 
-    attr_accessor :stdout, :stderr, :exitstatus, :bug_in_sib
+    attr_accessor :stdout, :stderr, :exitstatus, :bug_in_sib, :number_of_captures
 
     alias bug_in_sib? bug_in_sib
 
@@ -19,7 +19,7 @@ class SeeingIsBelieving
     end
 
     def record_result(line_number, value)
-      results_for(line_number) << value.inspect
+      results_for(line_number).record_result(value)
       value
     end
 
@@ -40,17 +40,34 @@ class SeeingIsBelieving
       (1..max).each { |line_number| block.call self[line_number] }
     end
 
+    def each_with_line_number(&block)
+      return to_enum :each_with_line_number unless block
+      max = results.keys.max || 1
+      (1..max).each { |line_number| block.call line_number, results_for(line_number) }
+    end
+
     def inspect
       results
-      "#<SIB::Result #{
-        instance_variables.map { |name| "#{name}=#{instance_variable_get(name).inspect}" }.join("\n  ")
-      }>"
+      variables = instance_variables.map do |name|
+        value = instance_variable_get(name)
+        inspected = if name.to_s == '@results'
+          "{#{value.sort_by(&:first).map { |k, v| "#{k.inspect}=>#{v.inspect}"}.join(",\n            ")}}"
+        else
+          value.inspect
+        end
+        "#{name}=#{inspected}"
+      end
+      "#<SIB::Result #{variables.join "\n  "}>"
+    end
+
+    def number_of_captures
+      @number_of_captures || Float::INFINITY
     end
 
     private
 
     def results_for(line_number)
-      results[line_number] ||= Line.new
+      results[line_number] ||= Line.new([], number_of_captures)
     end
 
     def results

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '2.0.0'
+  VERSION = '2.0.1'
 end

data/spec/binary/{arg_parser_spec.rb → parse_args_spec.rb}

@@ -363,5 +363,29 @@ describe SeeingIsBelieving::Binary::ParseArgs do
       parse(['--shebang']).should have_error /--shebang/
     end
   end
+
+  describe ':number_of_captures' do
+    it 'defaults to infinity' do
+      parse([])[:number_of_captures].should == Float::INFINITY
+    end
+
+    it 'can be set with --number-of-captures or -n' do
+      parse(['-n', '10'])[:number_of_captures].should == 10
+      parse(['--number-of-captures', '10'])[:number_of_captures].should == 10
+    end
+
+    it_behaves_like 'it requires a positive int argument', ['-n', '--number-of-captures']
+  end
+
+  describe ':result_as_json' do
+    it 'defaults to false' do
+      parse([])[:result_as_json].should == false
+    end
+
+    it 'can be enabled with --json or -j' do
+      parse(['--json'])[:result_as_json].should == true
+      parse(['-j'])[:result_as_json].should == true
+    end
+  end
 end
 

data/spec/evaluate_by_moving_files_spec.rb

@@ -100,7 +100,7 @@ describe SeeingIsBelieving::EvaluateByMovingFiles do
     invoke('print "ç"', encoding: 'u').stdout.should == "ç"
   end
 
-  it 'if it fails, it prints some debugging information and raises an error', t:true do
+  it 'if it fails, it prints some debugging information and raises an error' do
     error_stream = StringIO.new
     evaluator = described_class.new 'raise "omg"', filename, debugger: SeeingIsBelieving::Debugger.new(stream: error_stream)
     FileUtils.rm_f evaluator.temp_filename

data/spec/line_spec.rb

@@ -1,15 +1,22 @@
 require 'seeing_is_believing/result'
 
-describe SeeingIsBelieving::Line do
+describe SeeingIsBelieving::Line, t:true do
   Line = described_class
 
+  def line_for(*args)
+    line = Line.new
+    args.each { |a| line.record_result a }
+    line
+  end
+
   it 'inspects prettily' do
-    Line[].inspect.should == '#<SIB:Line[] no exception>'
-    Line["a"].inspect.should == '#<SIB:Line["a"] no exception>'
-    Line["a", 1].inspect.should == '#<SIB:Line["a", 1] no exception>'
-    line = Line[]
+    line_for(       ).inspect.should == '#<SIB:Line[] (0, 0) no exception>'
+    line_for("a"    ).inspect.should == '#<SIB:Line["\"a\""] (1, 3) no exception>'
+    line_for("a", 12).inspect.should == '#<SIB:Line["\"a\"", "12"] (2, 5) no exception>'
+
+    line = Line.new
     line.exception = RuntimeError.new("omg")
-    line.inspect.should == '#<SIB:Line[] RuntimeError:"omg">'
+    line.inspect.should == '#<SIB:Line[] (0, 0) RuntimeError:"omg">'
   end
 
   it 'knows when it has an exception' do
@@ -32,30 +39,30 @@ describe SeeingIsBelieving::Line do
   end
 
   it 'returns its array for #to_a and #to_ary' do
-    line = Line[1,2]
+    line = line_for 1, 2
     line.to_a.should be_a_kind_of Array
-    line.to_a.should == [1, 2]
+    line.to_a.should == %w[1 2]
     line.to_ary.should be_a_kind_of Array
-    line.to_ary.should == [1, 2]
+    line.to_ary.should == %w[1 2]
   end
 
   it 'is equal to arrays with the same elements as its array' do
-    Line[1, 2].should == [1, 2]
-    Line[1, 2].should_not == [2, 1]
+    line_for(1, 2).should == %w[1 2]
+    line_for(1, 2).should_not == %w[2 1]
   end
 
   # Exception equality seems to be based off of the message, and be indifferent to the class, I don't think it's that important to fix it
   it "is equal to lines with the same elements and the same exception" do
     exception = RuntimeError.new 'omg'
 
-    Line[1, 2].should == Line[1, 2]
-    Line[1, 2].should_not == Line[2, 1]
+    line_for(1, 2).should == line_for(1, 2)
+    line_for(1, 2).should_not == line_for(2, 1)
 
-    line1 = Line[1, 2]
+    line1 = line_for(1, 2)
     line1.exception = exception
-    line1.should_not == Line[1, 2]
+    line1.should_not == line_for(1, 2)
 
-    line2 = Line[1, 2]
+    line2 = line_for(1, 2)
     line2.exception = exception
     line1.should == line2
 

data/spec/seeing_is_believing_spec.rb

@@ -19,6 +19,11 @@ describe SeeingIsBelieving do
     invoke(input)[2].should == ['"22"']
   end
 
+  it 'only invokes inspect once' do
+    input = "class Fixnum; def inspect; 'NUM'\nend\nend\n1"
+    invoke(input)[1].should == ['"NUM"']
+  end
+
   it 'remembers context of previous lines' do
     values_for("a=12\na*2").should == [['12'], ['24']]
   end
@@ -299,6 +304,13 @@ describe SeeingIsBelieving do
                                                   ['[6, 12]']]
   end
 
+  it 'can be limited to a specific number of captures', t:true do
+    values_for("2.times do\n1\nend", number_of_captures: 1)
+      .should == [['2'],
+                  ['1', '...'],
+                  ['2']]
+  end
+
   it 'can evaluate under a different ruby executable' do
     Dir.chdir proving_grounds_dir do
       File.write 'omg-ruby', "#!/usr/bin/env ruby
@@ -355,7 +367,7 @@ describe SeeingIsBelieving do
     it 'prints the result' do
       call
       stream.string.should include "RESULT:"
-      stream.string.should include '1=>#<SIB:Line["1"] no exception>'
+      stream.string.should include '1=>#<SIB:Line["1"] (1, 1) no exception>'
     end
     # should ProgramRewriter have some debug options?
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-19 00:00:00.000000000 Z
+date: 2013-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -115,6 +115,7 @@ files:
 - features/flags.feature
 - features/regression.feature
 - features/support/env.rb
+- for-presentations
 - lib/seeing_is_believing.rb
 - lib/seeing_is_believing/binary.rb
 - lib/seeing_is_believing/binary/add_annotations.rb
@@ -139,10 +140,10 @@ files:
 - lib/seeing_is_believing/version.rb
 - lib/seeing_is_believing/wrap_expressions.rb
 - seeing_is_believing.gemspec
-- spec/binary/arg_parser_spec.rb
 - spec/binary/clean_body_spec.rb
 - spec/binary/comment_formatter_spec.rb
 - spec/binary/comment_lines_spec.rb
+- spec/binary/parse_args_spec.rb
 - spec/binary/rewrite_comments_spec.rb
 - spec/debugger_spec.rb
 - spec/evaluate_by_moving_files_spec.rb
@@ -171,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: seeing_is_believing
-rubygems_version: 2.0.5
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Records results of every line of code in your file
@@ -181,10 +182,10 @@ test_files:
 - features/flags.feature
 - features/regression.feature
 - features/support/env.rb
-- spec/binary/arg_parser_spec.rb
 - spec/binary/clean_body_spec.rb
 - spec/binary/comment_formatter_spec.rb
 - spec/binary/comment_lines_spec.rb
+- spec/binary/parse_args_spec.rb
 - spec/binary/rewrite_comments_spec.rb
 - spec/debugger_spec.rb
 - spec/evaluate_by_moving_files_spec.rb