seeing_is_believing 0.0.26 → 1.0.0

data/lib/seeing_is_believing/binary.rb

@@ -1,6 +1,7 @@
 require 'seeing_is_believing'
 require 'seeing_is_believing/binary/arg_parser'
-require 'seeing_is_believing/binary/print_results_next_to_lines'
+require 'seeing_is_believing/binary/add_annotations'
+require 'seeing_is_believing/binary/remove_previous_annotations'
 require 'timeout'
 
 
@@ -85,11 +86,11 @@ class SeeingIsBelieving
     end
 
     def print_unexpected_error
-      stderr.puts unexpected_exception.class, unexpected_exception.message
+      stderr.puts unexpected_exception.class, unexpected_exception.message, "", unexpected_exception.backtrace
     end
 
     def printer
-      @printer ||= PrintResultsNextToLines.new body, flags.merge(stdin: (file_is_on_stdin? ? '' : stdin))
+      @printer ||= AddAnnotations.new body, flags.merge(stdin: (file_is_on_stdin? ? '' : stdin))
     end
 
     def results
@@ -154,7 +155,7 @@ class SeeingIsBelieving
     end
 
     def print_cleaned_program
-      stdout.print PrintResultsNextToLines.remove_previous_output_from body
+      stdout.print RemovePreviousAnnotations.call body
     end
   end
 end

data/lib/seeing_is_believing/binary/{print_results_next_to_lines.rb → add_annotations.rb}

@@ -1,6 +1,8 @@
+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'
 
 # I think there is a bug where with xmpfilter_style set,
 # the exceptions won't be shown. But it's not totally clear
@@ -16,20 +18,13 @@ require 'seeing_is_believing/binary/line_formatter'
 
 class SeeingIsBelieving
   class Binary
-    class PrintResultsNextToLines
+    class AddAnnotations
       include HasException
 
+         RESULT_PREFIX = '# =>'
+      EXCEPTION_PREFIX = '# ~>'
          STDOUT_PREFIX = '# >>'
          STDERR_PREFIX = '# !>'
-      EXCEPTION_PREFIX = '# ~>'
-         RESULT_PREFIX = '# =>'
-
-      def self.remove_previous_output_from(string)
-        string.gsub(/\s+(#{EXCEPTION_PREFIX}|#{RESULT_PREFIX}).*?$/, '')
-              .gsub(/(^\n)?(^#{STDOUT_PREFIX}[^\n]*\r?\n?)+/m,       '')
-              .gsub(/(^\n)?(^#{STDERR_PREFIX}[^\n]*\r?\n?)+/m,       '')
-      end
-
 
       def self.method_from_options(*args)
         define_method(args.first) { options.fetch *args }
@@ -41,19 +36,21 @@ class SeeingIsBelieving
       method_from_options :line_length,    Float::INFINITY
       method_from_options :result_length,  Float::INFINITY
       method_from_options :xmpfilter_style
+      method_from_options :debugger
 
       attr_accessor :file_result
       def initialize(body, options={})
-        cleaned_body            = self.class.remove_previous_output_from body
+        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]
+                                                         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
 
@@ -68,8 +65,13 @@ class SeeingIsBelieving
                     .each  { |line, line_number| add_line line, line_number }
           add_stdout
           add_stderr
+          add_exception
           add_remaining_lines
-          new_body
+          if debugger.enabled?
+            debugger.context("RESULT") { new_body }.to_s
+          else
+            new_body
+          end
         end
       end
 
@@ -125,6 +127,20 @@ class SeeingIsBelieving
         end
       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"
+        exception.message.each_line do |line|
+          new_body << LineFormatter.new('', "#{EXCEPTION_PREFIX} ", line.chomp, options).call << "\n"
+        end
+        new_body << "#{EXCEPTION_PREFIX}\n"
+        exception.backtrace.each do |line|
+          new_body << LineFormatter.new('', "#{EXCEPTION_PREFIX} ", line.chomp, options).call << "\n"
+        end
+      end
+
       def add_remaining_lines
         line_queue.each { |line, line_number| new_body << line }
       end
@@ -132,7 +148,7 @@ class SeeingIsBelieving
       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
+                           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

data/lib/seeing_is_believing/binary/arg_parser.rb

@@ -1,4 +1,6 @@
+require 'stringio'
 require 'seeing_is_believing/version'
+require 'seeing_is_believing/debugger'
 require 'seeing_is_believing/binary/align_file'
 require 'seeing_is_believing/binary/align_line'
 require 'seeing_is_believing/binary/align_chunk'
@@ -22,10 +24,11 @@ class SeeingIsBelieving
           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 '-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 '-g', '--debug'               then options[:debugger]            = Debugger.new(enabled: true, 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 :line_length,   arg
@@ -67,6 +70,7 @@ class SeeingIsBelieving
 
       def options
         @options ||= {
+          debugger:            Debugger.new(enabled: false, colour: true),
           version:             false,
           clean:               false,
           xmpfilter_style:     false,
@@ -149,6 +153,7 @@ Usage: seeing_is_believing [options] [filename]
   -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
+  -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
   -i, --inherit-exit-status     # exit with the exit status of the program being eval
   -v, --version                 # print the version (#{VERSION})

data/lib/seeing_is_believing/binary/remove_previous_annotations.rb

@@ -0,0 +1,75 @@
+require 'seeing_is_believing/remove_inline_comments'
+
+class SeeingIsBelieving
+  class Binary
+    class RemovePreviousAnnotations
+      def self.call(code)
+        new(code).call
+      end
+
+      def initialize(code)
+        self.code     = code
+        self.comments = { result:    [],
+                          exception: [],
+                          stdout:    [],
+                          stderr:    [],
+                        }
+      end
+
+      def call
+        RemoveInlineComments.call code, additional_rewrites: remove_whitespace_preceeding_comments do |comment|
+          if    comment.text[/\A#\s*=>/] then comments[:result]    << comment; true
+          elsif comment.text[/\A#\s*~>/] then comments[:exception] << comment; true
+          elsif comment.text[/\A#\s*>>/] then comments[:stdout]    << comment; true
+          elsif comment.text[/\A#\s*!>/] then comments[:stderr]    << comment; true
+          else                                                                 false
+          end
+        end
+      end
+
+      private
+
+      attr_accessor :code, :comments
+
+      def remove_whitespace_preceeding_comments
+        lambda do |buffer, rewriter|
+          comments[:result].each    { |comment| remove_whitespace_before comment.location.begin_pos, buffer, rewriter, false }
+          comments[:exception].each { |comment| remove_whitespace_before comment.location.begin_pos, buffer, rewriter, true  }
+          comments[:stdout].each    { |comment| remove_whitespace_before comment.location.begin_pos, buffer, rewriter, true  }
+          comments[:stderr].each    { |comment| remove_whitespace_before comment.location.begin_pos, buffer, rewriter, true  }
+        end
+      end
+
+      # any whitespace before the index (on the same line) will be removed
+      # if the preceeding whitespace is at the beginning of the line, the newline will be removed
+      # if there is a newline before all of that, and remove_preceeding_newline is true, it will be removed as well
+      def remove_whitespace_before(index, buffer, rewriter, remove_preceeding_newline)
+        end_pos   = index
+        begin_pos = end_pos - 1
+        begin_pos -= 1 while code[begin_pos] =~ /\s/ && code[begin_pos] != "\n"
+        begin_pos -= 1 if code[begin_pos] == "\n"
+        begin_pos -= 1 if code[begin_pos] == "\n" && remove_preceeding_newline
+        return if begin_pos.next == end_pos
+        rewriter.remove Parser::Source::Range.new(buffer, begin_pos.next, end_pos)
+      end
+
+      # returns comments in groups that are on consecutive lines
+      def adjacent_comments(comments, buffer)
+        comments          = comments.sort_by { |comment| comment.location.begin_pos }
+        current_chunk     = 0
+        last_line_seen    = -100
+        chunks_to_comment = comments.chunk do |comment|
+          line, col = buffer.decompose_position comment.location.begin_pos
+          if last_line_seen.next == line
+            last_line_seen = line
+            current_chunk
+          else
+            last_line_seen = line
+            current_chunk += 1
+          end
+        end
+        chunks_to_comment.map &:last
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/debugger.rb

@@ -0,0 +1,36 @@
+class SeeingIsBelieving
+  class Debugger
+
+    CONTEXT_COLOUR = "\e[37;44m"
+    RESET_COLOUR   = "\e[0m"
+
+    def initialize(options={})
+      @contexts = Hash.new { |h, k| h[k] = [] }
+      @enabled  = options.fetch :enabled, true
+      @coloured = options.fetch :colour,  false
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def coloured?
+      @coloured
+    end
+
+    def context(name, &block)
+      @contexts[name] << block.call if enabled?
+      self
+    end
+
+    def to_s
+      @contexts.map { |name, values|
+        string = ""
+        string << CONTEXT_COLOUR if coloured?
+        string << "#{name}:"
+        string << RESET_COLOUR if coloured?
+        string << "\n#{values.join "\n"}\n"
+      }.join("\n")
+    end
+  end
+end

data/lib/seeing_is_believing/expression_list.rb

@@ -1,8 +1,8 @@
 require 'open3'
+require 'seeing_is_believing/debugger'
 require 'seeing_is_believing/syntax_analyzer'
 
-# A lot of colouring going on in this file, maybe should extract a debugging object to contain it
-
+# can we get better debugging support so that we don't need to drop ANSI escape sequences in the middle of strings?
 class SeeingIsBelieving
   class ExpressionList
     PendingExpression = Struct.new :expression, :children do
@@ -16,8 +16,7 @@ class SeeingIsBelieving
     end
 
     def initialize(options)
-      self.debug_stream   = options.fetch :debug_stream, $stdout
-      self.should_debug   = options.fetch :debug, false
+      self.debugger       = options.fetch :debugger, Debugger.new(enabled: false)
       self.get_next_line  = options.fetch :get_next_line
       self.peek_next_line = options.fetch :peek_next_line
       self.on_complete    = options.fetch :on_complete
@@ -27,7 +26,10 @@ class SeeingIsBelieving
       offset, expressions, expression = 0, [], nil
       begin
         pending_expression = generate(expressions)
-        debug { "GENERATED: #{pending_expression.expression.inspect}, ADDING IT TO #{inspected_expressions expressions}" }
+
+        debugger.context debugger_context do
+          "GENERATED: #{pending_expression.expression.inspect}, ADDING IT TO #{inspected_expressions expressions}"
+        end
 
         expression = reduce expressions, offset unless next_line_modifies_current?
 
@@ -38,7 +40,11 @@ class SeeingIsBelieving
 
     private
 
-    attr_accessor :debug_stream, :should_debug, :get_next_line, :peek_next_line, :on_complete, :expressions
+    attr_accessor :debugger, :get_next_line, :peek_next_line, :on_complete, :expressions
+
+    def debugger_context
+      "EXPRESSION EVALUATION"
+    end
 
     def generate(expressions)
       expression = get_next_line.call
@@ -59,15 +65,7 @@ class SeeingIsBelieving
     end
 
     def inspected_expressions(expressions)
-      "[#{expressions.map { |pe| pe.inspect debug? }.join(', ')}]"
-    end
-
-    def debug?
-      @should_debug
-    end
-
-    def debug
-      @debug_stream.puts yield if debug?
+      "[#{expressions.map { |pe| pe.inspect debugger.enabled? }.join(', ')}]"
     end
 
     def reduce(expressions, offset)
@@ -83,14 +81,14 @@ class SeeingIsBelieving
                                   offset)
         expressions.replace expressions[0, i]
         expressions[i-1].children << result unless expressions.empty?
-        debug { "REDUCED: #{result.inspect}, LIST: #{inspected_expressions expressions}" }
+        debugger.context(debugger_context) { "REDUCED: #{result.inspect}, LIST: #{inspected_expressions expressions}" }
         return result
       end
     end
 
     def valid_ruby?(expression)
       valid = SyntaxAnalyzer.valid_ruby? expression
-      debug { "#{valid ? "\e[32mIS VALID:" : "\e[31mIS NOT VALID:"}: #{expression.inspect}\e[0m" }
+      debugger.context(debugger_context) { "#{valid ? "\e[32mIS VALID:" : "\e[31mIS NOT VALID:"}: #{expression.inspect}\e[0m" }
       valid
     end
 

data/lib/seeing_is_believing/remove_inline_comments.rb

@@ -2,21 +2,45 @@ require 'parser/current'
 
 class SeeingIsBelieving
   module RemoveInlineComments
-    extend self
+    module NonLeading
+      def self.call(code)
+        ranges = []
+
+        nonleading_comments = lambda do |buffer, rewriter|
+          ranges.sort_by(&:begin_pos)
+                .drop_while.with_index(1) { |range, index|
+                  line, col = buffer.decompose_position range.begin_pos
+                  index == line && col.zero?
+                }
+                .each { |range| rewriter.remove range }
+        end
 
-    def self.call(code)
-      remove_inline_comments code
+        RemoveInlineComments.call code, additional_rewrites: nonleading_comments do |comment|
+          ranges << comment.location
+          false
+        end
+      end
     end
 
-    def remove_inline_comments(code)
-      buffer        = Parser::Source::Buffer.new "strip_comments"
-      buffer.source = code
-      parser        = Parser::CurrentRuby.new
-      rewriter      = Parser::Source::Rewriter.new(buffer)
-      ast, comments = parser.parse_with_comments(buffer)
+    extend self
+
+    # selector is a block that will receive the comment object
+    # if it returns true, the comment will be removed
+    def self.call(code, options={}, &selector)
+      selector            ||= Proc.new { true }
+      additional_rewrites   = options.fetch :additional_rewrites, Proc.new {}
+      buffer                = Parser::Source::Buffer.new "strip_comments"
+      buffer.source         = code
+      parser                = Parser::CurrentRuby.new
+      rewriter              = Parser::Source::Rewriter.new(buffer)
+      ast, comments         = parser.parse_with_comments(buffer)
       comments.select { |comment| comment.type == :inline }
+              .select { |comment| selector.call comment }
               .each   { |comment| rewriter.remove comment.location }
+      additional_rewrites.call buffer, rewriter
       rewriter.process
+    rescue Parser::SyntaxError => e
+      raise SyntaxError, e.message
     end
   end
 end

data/lib/seeing_is_believing/syntax_analyzer.rb

@@ -139,7 +139,8 @@ class SeeingIsBelieving
     end
 
     def self.ends_in_comment?(code)
-      code =~ /^=end\Z/ || parsed(code.lines.to_a.last.to_s).has_comment?
+      # must do the newline hack or it totally fucks up on comments like "# Transfer-Encoding: chunked"
+      code =~ /^=end\Z/ || parsed("\n#{code.lines.to_a.last.to_s}").has_comment?
     end
 
     def self.unclosed_comment?(code)

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '0.0.26'
+  VERSION = '1.0.0'
 end

data/seeing_is_believing.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency             "parser",   "~> 2.0.0.beta9"
+  s.add_dependency             "parser",   "~> 2.0.0.pre1"
 
   s.add_development_dependency "haiti",    "~> 0.0.3"
   s.add_development_dependency "rake",     "~> 10.0.3"

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

@@ -333,5 +333,16 @@ describe SeeingIsBelieving::Binary::ArgParser do
       parse(['-x'])[:xmpfilter_style].should be_true
     end
   end
+
+  describe ':debugger' do
+    it 'defaults to a debugger that is disabled' do
+      parse([])[:debugger].should_not be_enabled
+    end
+
+    it 'can be enabled with --debug or -g' do
+      parse(['--debug'])[:debugger].should be_enabled
+      parse(['-g'])[:debugger].should be_enabled
+    end
+  end
 end