seeing_is_believing 2.0.0.beta1 → 2.0.0.beta2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a743322b1fb2c802a3c3e76876a799b4dcaaeae9
+  data.tar.gz: d6e24494bf3967f3958e73aa7df22a09c960c089
+SHA512:
+  metadata.gz: 49aa7ad618d82e0fad1902a7fe43489ea606df56ae932bb6e4802a70e70f4d1e28a871332d65bc42137954f4857eed385ee6621231633b5a51718e90e6d600bd
+  data.tar.gz: 11fdde4edaae47edf12ed0f2e19c8b3ec4c4e0a43125860dcb74b5a8193a8c497b5e5e3822425127cff5aadf7e0230632eeb8eb29f5db9da5caba443d80c4843

data/Readme.md

@@ -141,6 +141,7 @@ 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
+* `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.
 
 Todo
 ====
@@ -148,31 +149,18 @@ Todo
 * Add examples of invocations to the help screen
 * Add xmpfilter option to sublime text
 * Update TextMate examples to use same keys as sublime, add xmpfilter option on cmd+opt+N
-* Remove the SyntaxAnalyzer altogether!
 * How about if begin/rescue/end was able to record the result on the rescue section
 * Check how begin/rescue/end with multiple rescue blocks works
 * 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"
 * 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)
 * Add a flag to allow you to just get the results so that it can be easily used without a Ruby runtime
-
-Up Next
-=======
-
-rename ProgramRewriter -> WrapExpressions
-find that fucking regex bug
-add the inspected result --debug output
-Fix high-level shit:
-  remove all previous output except if -x flag is set, then leave `# =>`
-  `gsub(/\s*$/, '')`
-  run it through sib
-  if -x flag is set
-    for each comment
-      if it is `# =>`, update it
-  else
-    printable_list = get a list of each line that is an actual end and has no comments with sib (can ignore heredocs b/c they will have no value)
-                     this list is like line_number => [col_number, character_number] (e.g. where to insert on that line)
-    for each line, add it at that character location, adjusting from the col_number to pad it correctly
-
+* Go through each cuke and spec, implementing however many not-implemented ones that we can
+* Check %w and all the others
+* Add a --shebang flag
+* Make sure the examples in this readme all still make sense (mountain berry fields?)
+* uhm, can we wrap the parser setup code in one place? `ack Parser::Source::Buffer`
+* Make the fucking debugger not lazy
+* Go through Peter's email about how to make the use of Parser better
 
 License
 =======

data/features/examples.feature

@@ -34,7 +34,6 @@ Feature: Running the binary successfully
     /a
      b/x
 
-    # don't record heredocs b/c they're just too fucking different
     <<HERE
     is a doc
     HERE
@@ -88,8 +87,7 @@ Feature: Running the binary successfully
     /a
      b/x  # => /a\n b/x
 
-    # don't record heredocs b/c they're just too fucking different
-    <<HERE    # => "is a doc\n"
+    <<HERE  # => "is a doc\n"
     is a doc
     HERE
 

data/features/flags.feature

@@ -485,7 +485,7 @@ Feature: Using flags
     # => "omg2"
     """
 
-  # TODO: do we want to print the source without its comments?
+
   Scenario: --debug
     Given the file "simple_program.rb":
     """
@@ -496,19 +496,11 @@ Feature: Using flags
     When I run "seeing_is_believing --debug simple_program.rb"
     Then stderr is empty
     And the exit status is 0
-    # source without comments
-    # And stdout includes "SOURCE WITHOUT COMMENTS:"
-    # And stdout includes:
-    # """
-    # # encoding: utf-8
-    # 1
-    # 2
-    # """
-    # translated program
     And stdout includes "TRANSLATED PROGRAM:"
-    And stdout includes "$seeing_is_believing_current_result"
-    # result
+    And stdout includes "$SiB"
     And stdout includes "RESULT:"
+    And stdout includes "@results="
+    And stdout includes "OUTPUT:"
     And stdout includes:
     """
     # encoding: utf-8

data/features/regression.feature

@@ -164,7 +164,6 @@ Feature:
     'ç'  # => "ç"
     """
 
-  @not-implemented
   Scenario: Some strings look like comments
     Given the file "strings_that_look_like_comments.rb":
     """
@@ -177,3 +176,98 @@ Feature:
     "1
      #{2}"  # => "1\n 2"
     """
+
+  Scenario: Kori's bug (Issue #11)
+    Given the file "koris_bug.rb":
+    """
+    class CreditCard
+
+    end
+
+    describe CreditCard do
+
+    end
+    """
+    When I run "seeing_is_believing koris_bug.rb"
+    Then stdout is:
+    """
+    class CreditCard
+
+    end
+
+    describe CreditCard do  # ~> NoMethodError: undefined method `describe' for main:Object
+
+    end
+
+    # ~> NoMethodError
+    # ~> undefined method `describe' for main:Object
+    # ~>
+    # ~> koris_bug.rb:5:in `<main>'
+    """
+
+  Scenario: lambda-style fibonacci generator
+    Given the file "lambda_style_fib_gen.rb":
+    """
+    class Proc
+      def inspect
+        "<PROC>"
+      end
+    end
+
+    generic_fib_gen = -> current, prev {
+      -> {
+        [(current+prev), generic_fib_gen.(current+prev, current)]
+      }
+    }
+
+    fib_gen    = generic_fib_gen.(1, -1)
+    n, fib_gen = fib_gen.()
+    n, fib_gen = fib_gen.()
+    n, fib_gen = fib_gen.()
+    """
+    When I run "seeing_is_believing lambda_style_fib_gen.rb"
+    Then stdout is:
+    """
+    class Proc
+      def inspect
+        "<PROC>"   # => "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>", "<PROC>"
+      end
+    end
+
+    generic_fib_gen = -> current, prev {
+      -> {
+        [(current+prev), generic_fib_gen.(current+prev, current)]  # => [0, <PROC>], [1, <PROC>], [1, <PROC>]
+      }                                                            # => <PROC>, <PROC>, <PROC>, <PROC>
+    }                                                              # => <PROC>
+
+    fib_gen    = generic_fib_gen.(1, -1)  # => <PROC>
+    n, fib_gen = fib_gen.()               # => [0, <PROC>]
+    n, fib_gen = fib_gen.()               # => [1, <PROC>]
+    n, fib_gen = fib_gen.()               # => [1, <PROC>]
+    """
+
+  Scenario: Repeated invocations
+    When I run "echo 'puts 1' | seeing_is_believing | seeing_is_believing"
+    Then stdout is:
+    """
+    puts 1  # => nil
+
+    # >> 1
+    """
+
+  Scenario: Heredoc at the end test
+    Given the file "heredoc_at_the_end.rb":
+    """
+    puts(<<A)
+    omg
+    A
+    """
+    When I run "seeing_is_believing heredoc_at_the_end.rb"
+    Then stdout is:
+    """
+    puts(<<A)  # => nil
+    omg
+    A
+
+    # >> omg
+    """

data/lib/seeing_is_believing.rb

@@ -2,18 +2,14 @@ require 'stringio'
 require 'tmpdir'
 require 'timeout'
 
-require 'seeing_is_believing/queue'
 require 'seeing_is_believing/result'
 require 'seeing_is_believing/version'
 require 'seeing_is_believing/debugger'
-require 'seeing_is_believing/remove_inline_comments'
 require 'seeing_is_believing/evaluate_by_moving_files'
-require 'seeing_is_believing/program_rewriter'
-require 'seeing_is_believing/syntax_analyzer' # can we get rid of this?
+require 'seeing_is_believing/wrap_expressions'
 
 # might not work on windows b/c of assumptions about line ends
 class SeeingIsBelieving
-  include TracksLineNumbersSeen
   BLANK_REGEX = /\A\s*\Z/
 
   def self.call(*args)
@@ -34,27 +30,14 @@ class SeeingIsBelieving
 
   def call
     @memoized_result ||= begin
-      # must use newline after code, or comments will comment out rescue section
-      # FIXME: IS THIS STILL TRUE?
-      wrapped = ProgramReWriter.call "#@program\n",
-                                     before_all:  "begin;",
-                                     after_all:   "\n"\
-                                                  "rescue Exception;"\
-                                                    "line_number = $!.backtrace.grep(/\#{__FILE__}/).first[/:\\d+/][1..-1].to_i;"\
-                                                    "$seeing_is_believing_current_result.record_exception line_number, $!;"\
-                                                    "$seeing_is_believing_current_result.exitstatus = 1;"\
-                                                    "$seeing_is_believing_current_result.exitstatus = $!.status if $!.kind_of? SystemExit;"\
-                                                  "end",
-                                     before_each: -> line_number { "($seeing_is_believing_current_result.record_result(#{line_number}, (" },
-                                     after_each:  -> line_number { ")))" }
-      debugger.context("TRANSLATED PROGRAM") { wrapped }
-      result = result_for wrapped
+      new_program = program_that_will_record_expressions
+      debugger.context("TRANSLATED PROGRAM") { new_program }
+      result = result_for new_program
       debugger.context("RESULT") { result.inspect }
       result
     end
   end
 
-
   private
 
   attr_reader :matrix_filename, :debugger
@@ -64,6 +47,19 @@ class SeeingIsBelieving
     StringIO.new string_or_stream
   end
 
+  def program_that_will_record_expressions
+    WrapExpressions.call "#@program\n",
+                         before_all:  "begin;",
+                         after_all:   ";rescue Exception;"\
+                                        "line_number = $!.backtrace.grep(/\#{__FILE__}/).first[/:\\d+/][1..-1].to_i;"\
+                                        "$SiB.record_exception line_number, $!;"\
+                                        "$SiB.exitstatus = 1;"\
+                                        "$SiB.exitstatus = $!.status if $!.kind_of? SystemExit;"\
+                                      "end",
+                         before_each: -> line_number { "$SiB.record_result(#{line_number}, (" },
+                         after_each:  -> line_number { "))" }
+  end
+
   def result_for(program)
     Dir.mktmpdir "seeing_is_believing_temp_dir" do |dir|
       filename = @filename || File.join(dir, 'program.rb')

data/lib/seeing_is_believing/binary.rb

@@ -1,7 +1,7 @@
 require 'seeing_is_believing'
 require 'seeing_is_believing/binary/arg_parser'
 require 'seeing_is_believing/binary/add_annotations'
-require 'seeing_is_believing/binary/remove_previous_annotations'
+require 'seeing_is_believing/binary/clean_body'
 require 'timeout'
 
 
@@ -94,7 +94,7 @@ class SeeingIsBelieving
     end
 
     def results
-      printer.file_result
+      printer.results
     end
 
     def flags_have_errors?
@@ -155,7 +155,7 @@ class SeeingIsBelieving
     end
 
     def print_cleaned_program
-      stdout.print RemovePreviousAnnotations.call body
+      stdout.print CleanBody.call(body, true)
     end
   end
 end

data/lib/seeing_is_believing/binary/add_annotations.rb

@@ -1,161 +1,129 @@
 require 'stringio'
-require 'seeing_is_believing/queue'
 require 'seeing_is_believing/has_exception'
-require 'seeing_is_believing/binary/line_formatter'
-require 'seeing_is_believing/binary/remove_previous_annotations'
+require 'seeing_is_believing/binary/comment_formatter'
 
-# I think there is a bug where with xmpfilter_style set,
-# the exceptions won't be shown. But it's not totally clear
-# how to show them with this option set, anyway.
-# probably do what xmpfilter does and print them at the bottom
-# of the file (probably do this regardless of whether xmpfilter_style
-# is set)
-#
-# Would also be nice to support
-#     1 + 1
-#     # => 2
-# style updates like xmpfilter does
+require 'seeing_is_believing/binary/clean_body'
+require 'seeing_is_believing/binary/rewrite_comments'
+require 'seeing_is_believing/binary/comment_lines'
 
 class SeeingIsBelieving
   class Binary
     class AddAnnotations
       include HasException
 
-         RESULT_PREFIX = '# =>'
-      EXCEPTION_PREFIX = '# ~>'
-         STDOUT_PREFIX = '# >>'
-         STDERR_PREFIX = '# !>'
-
       def self.method_from_options(*args)
         define_method(args.first) { options.fetch *args }
       end
 
       method_from_options :filename, nil
-      method_from_options :start_line
-      method_from_options :end_line
-      method_from_options :line_length,    Float::INFINITY
-      method_from_options :result_length,  Float::INFINITY
+      method_from_options :start_line # rename: line_to_begin_recording
+      method_from_options :end_line   # rename: line_to_end_recording
       method_from_options :xmpfilter_style
       method_from_options :debugger
 
-      attr_accessor :file_result
-      def initialize(body, options={})
-        cleaned_body            = RemovePreviousAnnotations.call body
-        self.options            = options
-        self.body               = (xmpfilter_style ? body : cleaned_body)
-        self.file_result        = 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
-        self.alignment_strategy = options[:alignment_strategy].new cleaned_body, start_line, end_line
-      end
-
-      def new_body
-        @new_body ||= ''
+      attr_accessor :results, :body
+      def initialize(uncleaned_body, options={})
+        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
       end
 
       def call
-        @printed_program ||= begin
-          # can we put the call to chomp into the line_queue initialization code?
-          line_queue.until { |line, line_number| SyntaxAnalyzer.begins_data_segment?(line.chomp) }
-                    .each  { |line, line_number| add_line line, line_number }
-          add_stdout
-          add_stderr
-          add_exception
-          add_remaining_lines
-          if debugger.enabled?
-            debugger.context("RESULT") { new_body }.to_s
+        @new_body ||= begin
+          # uhm, these basically look like strategies for commenting.
+          new_body = if xmpfilter_style
+            RewriteComments.call body do |line_number, line, whitespace, comment|
+              # FIXME: can we centralize these regexes?
+              if !comment[/\A#\s*=>/]
+                [whitespace, comment]
+              elsif line.empty?
+                # should go through comment formatter
+                [whitespace, "# => #{results[line_number-1].map { |result| result.gsub "\n", '\n' }.join(', ')}"] # FIXME: NEED TO CONSIDER THE LINE LENGTH
+              else
+                # should go through comment formatter
+                [whitespace, "# => #{results[line_number].map { |result| result.gsub "\n", '\n' }.join(', ')}"] # FIXME: NEED TO CONSIDER THE LINE LENGTH
+              end
+            end
           else
-            new_body
+            alignment_strategy = options[:alignment_strategy].new body, start_line, end_line
+            CommentLines.call body do |line, line_number|
+              options = options().merge pad_to: alignment_strategy.line_length_for(line_number)
+              if line_number < start_line || end_line < line_number
+                ''
+              elsif results[line_number].has_exception?
+                exception = results[line_number].exception
+                result    = sprintf "%s: %s", exception.class_name, exception.message.gsub("\n", '\n')
+                CommentFormatter.new(line.size, "# ~> ", result, options).call
+              elsif results[line_number].any?
+                result  = results[line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
+                CommentFormatter.call(line.size, "# => ", result, options)
+              else
+                ''
+              end
+            end
           end
-        end
-      end
 
-      private
-
-      attr_accessor :body, :options, :alignment_strategy
+          output = stdout_ouptut_for(results)    <<
+                   stderr_ouptut_for(results)    <<
+                   exception_output_for(results)
 
-      def line_queue
-        @line_queue ||= Queue.new &body.each_line.with_index(1).to_a.method(:shift)
-      end
+          if new_body["\n__END__\n"]
+            new_body.sub! "\n__END__\n", "\n#{output}__END__\n"
+          else
+            new_body << "\n" unless new_body.end_with? "\n"
+            new_body << output
+          end
 
-      # if we want to pull this into a strategy
-      # we need to make available:
-      #   file_result, start_line, end_line, alignment_strategy, line_length, result_length
-      def add_line(line, line_number)
-        should_record = should_record? line, line_number
-        if should_record && xmpfilter_style && line.strip =~ /^# =>/
-          new_body << xmpfilter_update(line, file_result[line_number - 1]) # There is probably a bug in this since it doesn't go through the LineFormatter it can probably be to long
-        elsif should_record && xmpfilter_style
-          new_body << xmpfilter_update(line, file_result[line_number]) # There is probably a bug in this since it doesn't go through the LineFormatter it can probably be to long
-        elsif should_record
-          new_body << format_line(line.chomp, line_number, file_result[line_number])
-        else
-          new_body << line
+          new_body = if debugger.enabled?
+            debugger.context("OUTPUT") { new_body }.to_s
+          else
+            new_body
+          end
         end
       end
 
-      def should_record?(line, line_number)
-        (start_line <= line_number) &&
-          (line_number <= end_line) &&
-          (xmpfilter_style ? line =~ /# =>/ : # technically you could fuck this up with a line like "# =>", should later delegate to syntax analyzer
-                             !SyntaxAnalyzer.ends_in_comment?(line))
-      end
+      private
 
-      # again, this is too naive, should actually parse the comments and update them
-      def xmpfilter_update(line, line_results)
-        line.gsub /# =>.*?$/, "# => #{line_results.join(', ').gsub("\n", '\n')}"
-      end
+      attr_accessor :body, :options, :alignment_strategy
 
-      def add_stdout
-        return unless file_result.has_stdout?
-        new_body << "\n"
-        file_result.stdout.each_line do |line|
-          new_body << LineFormatter.new('', "#{STDOUT_PREFIX} ", line.chomp, options).call << "\n"
+      def stdout_ouptut_for(results)
+        return '' unless results.has_stdout?
+        output = "\n"
+        results.stdout.each_line do |line|
+          output << CommentFormatter.call(0, "# >> ", line.chomp, options()) << "\n"
         end
+        output
       end
 
-      def add_stderr
-        return unless file_result.has_stderr?
-        new_body << "\n"
-        file_result.stderr.each_line do |line|
-          new_body << LineFormatter.new('', "#{STDERR_PREFIX} ", line.chomp, options).call << "\n"
+      def stderr_ouptut_for(results)
+        return '' unless results.has_stderr?
+        output = "\n"
+        results.stderr.each_line do |line|
+          output << CommentFormatter.call(0, "# !> ", line.chomp, options()) << "\n"
         end
+        output
       end
 
-      def add_exception
-        return unless file_result.has_exception?
-        exception = file_result.exception
-        new_body << "\n"
-        new_body << LineFormatter.new('', "#{EXCEPTION_PREFIX} ", exception.class_name, options).call << "\n"
+      def exception_output_for(results)
+        return '' unless results.has_exception?
+        exception = results.exception
+        output = "\n"
+        output << CommentFormatter.new(0, "# ~> ", exception.class_name, options).call << "\n"
         exception.message.each_line do |line|
-          new_body << LineFormatter.new('', "#{EXCEPTION_PREFIX} ", line.chomp, options).call << "\n"
+          output << CommentFormatter.new(0, "# ~> ", line.chomp, options).call << "\n"
         end
-        new_body << "#{EXCEPTION_PREFIX}\n"
+        output << "# ~>\n"
         exception.backtrace.each do |line|
-          new_body << LineFormatter.new('', "#{EXCEPTION_PREFIX} ", line.chomp, options).call << "\n"
+          output << CommentFormatter.new(0, "# ~> ", line.chomp, options).call << "\n"
         end
-      end
-
-      def add_remaining_lines
-        line_queue.each { |line, line_number| new_body << line }
-      end
-
-      def format_line(line, line_number, line_results)
-        options = options().merge pad_to: alignment_strategy.line_length_for(line_number)
-        formatted_line = if line_results.has_exception?
-                           result = sprintf "%s: %s", line_results.exception.class_name, line_results.exception.message.gsub("\n", '\n')
-                           LineFormatter.new(line, "#{EXCEPTION_PREFIX} ", result, options).call
-                         elsif line_results.any?
-                           LineFormatter.new(line, "#{RESULT_PREFIX} ", line_results.join(', '), options).call
-                         else
-                           line
-                         end
-        formatted_line + "\n"
+        output
       end
 
     end