seeing_is_believing 3.0.0.beta.1 → 3.0.0.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4baad8edd542826d976fb5439fe4523724e25c2
-  data.tar.gz: 806d6b1cb7b43dc168c7653ff9995b3dd1b37220
+  metadata.gz: 981bfb703701767923dee2010cd2073ec901e20f
+  data.tar.gz: 0eaa0290fac0e7b0b312196371507f717b2ad1d7
 SHA512:
-  metadata.gz: 74cde1ec9bd35565d7e49110210fadc6e8b9eb01538e78411138babf50abf5bc299a6cb592e3e7cc0d873c97c5549d8ddb5aa0a6a3e2eb07dc76130f433f077c
-  data.tar.gz: 57811be453dd99be97df3c4ed6a17b7a0329178776c2bce14a4247f13d51acac04f1d9ccfc9930a7ae55983b2f285e0ad6c351c703041cab3dafa071e09f8941
+  metadata.gz: 019b0ac6587cb94c98bc9e916daa49f8b21e6eba166a3a6c5e930de573ecce274004f11de8cd47e366af46c4da881376b05c4ef4d3a8a43a5e0c614517a53d75
+  data.tar.gz: d515e9959c12741755f0ff298a5f571d8860290a15f3548e3386ae7ef8b4b9c0364ccac1c7a7816a771fc9a100746f813e259dce2cac943d01c6f8d70510dc1d

data/features/xmpfilter-style.feature

@@ -3,6 +3,12 @@ Feature: Xmpfilter style
   Support the same (or highly similar) interface as xmpfilter,
   so that people who use that lib can easily transition to SiB.
 
+  TODO:
+  * multiple values on pp lines
+  * show that exceptions respect line-length restriction flags
+  * Scenario: pp output on line with exception
+  * when input has previously identified exception
+
 
   Scenario: --xmpfilter-style Generic updating of marked lines
     Given the file "magic_comments.rb":
@@ -18,6 +24,7 @@ Feature: Xmpfilter style
     # =>
     "omg2"
     # => "not omg2"
+    3+3#=>
     """
     When I run "seeing_is_believing --xmpfilter-style magic_comments.rb"
     Then stderr is empty
@@ -35,6 +42,7 @@ Feature: Xmpfilter style
     # => "omg"
     "omg2"
     # => "omg2"
+    3+3# => 6
     """
 
 
@@ -101,42 +109,44 @@ Feature: Xmpfilter style
     """
 
 
-    @josh1
   Scenario: Errors on annotated lines
     Given the file "xmpfilter_error_on_annotated_line.rb":
     """
-    raise "omg" # =>
+    raise "ZOMG\n!!!!" # =>
     """
     When I run "seeing_is_believing --xmpfilter-style xmpfilter_error_on_annotated_line.rb"
     Then stderr is empty
     And the exit status is 1
     Then stdout is:
     """
-    raise "omg" # => # ~> RuntimeError: ZOMG\n!!!!
+    raise "ZOMG\n!!!!" # => RuntimeError: ZOMG\n!!!!
 
     # ~> RuntimeError
-    # ~> omg
+    # ~> ZOMG
+    # ~> !!!!
     # ~>
     # ~> xmpfilter_error_on_annotated_line.rb:1:in `<main>'
     """
 
 
-    @josh2
   Scenario: Errors on unannotated lines
-    Given the file "xmpfilter_error_on_annotated_line.rb":
+    Given the file "xmpfilter_error_on_unannotated_line.rb":
     """
-    raise "omg"
+    raise "ZOMG\n!!!!"
     """
-    When I run "seeing_is_believing --xmpfilter-style xmpfilter_error_on_annotated_line.rb"
+    When I run "seeing_is_believing --xmpfilter-style xmpfilter_error_on_unannotated_line.rb"
     Then stderr is empty
     And the exit status is 1
     Then stdout is:
     """
-    raise "omg" # =>
-    """
+    raise "ZOMG\n!!!!" # ~> RuntimeError: ZOMG\n!!!!
 
-
-  Scenario: pp output on line with exception
+    # ~> RuntimeError
+    # ~> ZOMG
+    # ~> !!!!
+    # ~>
+    # ~> xmpfilter_error_on_unannotated_line.rb:1:in `<main>'
+    """
 
 
   Scenario: Cleaning previous output

data/lib/seeing_is_believing/binary.rb

@@ -34,7 +34,7 @@ class SeeingIsBelieving
       end
 
       if options.print_cleaned?
-        stdout.print RemoveAnnotations.call(options.prepared_body, true, options.markers)
+        stdout.print RemoveAnnotations.call(options.prepared_body, true, options.marker_regexes)
         return SUCCESS_STATUS
       end
 

data/lib/seeing_is_believing/binary/annotate_every_line.rb

@@ -1,12 +1,12 @@
 class SeeingIsBelieving
   module Binary
     class AnnotateEveryLine
-      def self.prepare_body(uncleaned_body, markers)
+      def self.prepare_body(uncleaned_body, marker_regexes)
         require 'seeing_is_believing/binary/remove_annotations'
-        RemoveAnnotations.call uncleaned_body, true, markers
+        RemoveAnnotations.call uncleaned_body, true, marker_regexes
       end
 
-      def self.expression_wrapper(markers)
+      def self.expression_wrapper(markers, marker_regexes)
         require 'seeing_is_believing/inspect_expressions'
         InspectExpressions
       end
@@ -45,7 +45,7 @@ class SeeingIsBelieving
           AnnotateEndOfFile.add_stdout_stderr_and_exceptions_to new_body, @results, @options
 
           # What's w/ this debugger? maybe this should move higher?
-          @options[:debugger].context "OUTPUT"
+          @options.fetch(:debugger).context "OUTPUT"
           new_body
         end
       end
@@ -53,11 +53,11 @@ class SeeingIsBelieving
       private
 
       def value_marker
-        @value_marker ||= @options[:markers][:value]
+        @value_marker ||= @options.fetch(:markers).fetch(:value)
       end
 
       def exception_marker
-        @exception_marker ||= @options[:markers][:exception]
+        @xnextline_marker ||= @options.fetch(:markers).fetch(:exception)
       end
     end
   end

data/lib/seeing_is_believing/binary/annotate_xmpfilter_style.rb

@@ -3,34 +3,17 @@ require 'seeing_is_believing/code'
 class SeeingIsBelieving
   module Binary
     class AnnotateXmpfilterStyle
-      def self.prepare_body(uncleaned_body, markers)
-        # TODO: There's definitely a lot of overlap in responsibilities with invoking of parser
-        # and this is a conspicuous hack, since this functionality should really be provided by RemoveAnnotations
-        code = Code.new(uncleaned_body)
-        code.inline_comments
-            .select       { |c|  c.whitespace_col == 0 } # TODO: Would be nice to support indentation here
-            .slice_before { |c|  c.text.start_with? markers[:value]  }
-            .flat_map     { |cs|
-              consecutives = cs.each_cons(2).take_while { |c1, c2| c1.line_number.next == c2.line_number }
-              cs[1, consecutives.size]
-            }
-            .select { |c| c.text.start_with? markers[:nextline] }
-            .each { |c|
-              range_with_preceding_newline = code.range_for(c.comment_range.begin_pos.pred, c.comment_range.end_pos)
-              code.rewriter.remove range_with_preceding_newline
-            }
-        partially_cleaned_body = code.rewriter.process
-
+      def self.prepare_body(uncleaned_body, marker_regexes)
         require 'seeing_is_believing/binary/remove_annotations'
-        RemoveAnnotations.call partially_cleaned_body, false, markers
+        RemoveAnnotations.call uncleaned_body, false, marker_regexes
       end
 
-      def self.expression_wrapper(markers)
+      def self.expression_wrapper(markers, marker_regexes)
         -> program, number_of_captures {
           inspect_linenos = []
           pp_linenos      = []
           Code.new(program).inline_comments.each do |c|
-            next unless c.text.start_with? markers[:value].sub(/\s+$/, '')
+            next unless c.text[marker_regexes[:value]]
             c.whitespace_col == 0 ? pp_linenos      << c.line_number - 1
                                   : inspect_linenos << c.line_number
           end
@@ -73,14 +56,33 @@ class SeeingIsBelieving
       def call
         @new_body ||= begin
           # TODO: doesn't currently realign output markers, do we want to do that?
-          require 'seeing_is_believing/binary' # defines the markers
           require 'seeing_is_believing/binary/rewrite_comments'
           require 'seeing_is_believing/binary/comment_formatter'
-          exception_lineno  = @results.has_exception? ? @results.exception.line_number : -1
-          new_body = RewriteComments.call @body do |comment|
-            if !comment.text[value_regex]
-              [comment.whitespace, comment.text]
-            elsif comment.whitespace_col == 0
+          always_rewrite = []
+
+          if @results.has_exception?
+            exception_result  = sprintf "%s: %s", @results.exception.class_name, @results.exception.message.gsub("\n", '\n')
+            exception_lineno  = @results.exception.line_number
+            always_rewrite << exception_lineno
+          end
+
+          new_body = RewriteComments.call @body, always_rewrite: always_rewrite do |comment|
+            exception_on_line  = exception_lineno == comment.line_number
+            annotate_this_line = comment.text[value_regex]
+            pp_annotation      = annotate_this_line && comment.whitespace_col.zero?
+            normal_annotation  = annotate_this_line && !pp_annotation
+            if exception_on_line && annotate_this_line
+              [comment.whitespace, CommentFormatter.call(comment.text_col, value_marker, exception_result, @options)]
+            elsif exception_on_line
+              whitespace = comment.whitespace
+              whitespace = " " if whitespace.empty?
+              [whitespace, CommentFormatter.call(comment.line_number, exception_marker, exception_result, @options)]
+            elsif normal_annotation
+              result = @results[comment.line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
+              [comment.whitespace, CommentFormatter.call(comment.text_col, value_marker, result, @options)]
+            elsif pp_annotation
+              # result = sprintf "%s: %s", @results.exception.class_name, @results.exception.message.gsub("\n", '\n')
+              # CommentFormatter.call(line.size, exception_marker, result, options)
               # TODO: check that having multiple mult-line output values here looks good (e.g. avdi's example in a loop)
               result          = @results[comment.line_number-1, :pp].map { |result| result.chomp }.join(', ')
               comment_lines   = result.each_line.map.with_index do |comment_line, result_offest|
@@ -92,41 +94,33 @@ class SeeingIsBelieving
               end
               [comment.whitespace, comment_lines.join("\n")]
             else
-              result = @results[comment.line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
-              [comment.whitespace, CommentFormatter.call(comment.text_col, value_marker, result, @options)]
+              [comment.whitespace, comment.text]
             end
           end
 
-          # if exception_lineno == line_number
-          #   if comment.text[value_regex] # has exception and comment
-          #     # '# => # ~> exception...'
-          #     [comment.whitespace, comment.text]
-          #   else # exception, no comment
-          #     # NORMAL EXCEPTION
-          #     # result  = @results[line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
-          #     # CommentFormatter.call(line.size, value_marker, result, options)
-          #     # [comment.whitespace, comment.text]
-          #   end
-
           require 'seeing_is_believing/binary/annotate_end_of_file'
           AnnotateEndOfFile.add_stdout_stderr_and_exceptions_to new_body, @results, @options
 
           # What's w/ this debugger? maybe this should move higher?
-          @options[:debugger].context "OUTPUT"
+          @options.fetch(:debugger).context "OUTPUT"
           new_body
         end
       end
 
       def value_marker
-        @value_marker ||= @options[:markers][:value]
+        @value_marker ||= @options.fetch(:markers).fetch(:value)
       end
 
       def nextline_marker
-        @xnextline_marker ||= @options[:markers][:nextline]
+        @xnextline_marker ||= ('#' + ' '*value_marker.size.pred)
+      end
+
+      def exception_marker
+        @exception_marker ||= @options.fetch(:markers).fetch(:exception)
       end
 
       def value_regex
-        @value_regex ||= /\A#{value_marker.sub(/\s+$/, '')}/
+        @value_regex ||= @options.fetch(:marker_regexes).fetch(:value)
       end
     end
   end

data/lib/seeing_is_believing/binary/interpret_flags.rb

@@ -17,6 +17,14 @@ require 'seeing_is_believing/binary/annotate_xmpfilter_style'
 class SeeingIsBelieving
   module Binary
     class InterpretFlags
+      def self.to_regex(string)
+        flag_to_bit = {'i' => 0b001, 'x' => 0b010, 'm' => 0b100}
+        string =~ %r{\A/(.*)/([mxi]*)\Z}
+        Regexp.new ($1||string),
+                   ($2||"").each_char.inject(0) { |bits, flag| bits|flag_to_bit[flag] }
+      end
+
+
       def self.attr_predicate(name)
         define_method("#{name}?") { predicates.fetch name }
       end
@@ -35,6 +43,7 @@ class SeeingIsBelieving
       attr_attribute :help_screen
       attr_attribute :debugger
       attr_attribute :markers
+      attr_attribute :marker_regexes
       attr_attribute :timeout
       attr_attribute :shebang
       attr_attribute :filename
@@ -47,11 +56,12 @@ class SeeingIsBelieving
       def initialize(flags, stdin, stdout)
         # Some simple attributes
         self.attributes = {}
-        attributes[:errors]   = flags.fetch(:errors)
-        attributes[:markers]  = flags.fetch(:markers) # TODO: Should probably object-ify these
-        attributes[:timeout]  = flags.fetch(:timeout) # b/c binary prints this out in the error message  TODO: rename seconds_until_timeout
-        attributes[:shebang]  = flags.fetch(:shebang) # b/c binary uses this to validate syntax atm
-        attributes[:filename] = flags.fetch(:filename)
+        attributes[:errors]         = flags.fetch(:errors)
+        attributes[:markers]        = flags.fetch(:markers) # TODO: Should probably object-ify these
+        attributes[:marker_regexes] = flags.fetch(:marker_regexes).each_with_object({}) { |(k, v), rs| rs[k] = self.class.to_regex v }
+        attributes[:timeout]        = flags.fetch(:timeout) # b/c binary prints this out in the error message  TODO: rename seconds_until_timeout
+        attributes[:shebang]        = flags.fetch(:shebang) # b/c binary uses this to validate syntax atm
+        attributes[:filename]       = flags.fetch(:filename)
 
         # All predicates
         self.predicates = {}
@@ -74,7 +84,7 @@ class SeeingIsBelieving
                                    String.new
 
         # Attributes that depend on predicates
-        attributes[:prepared_body] = body && annotator.prepare_body(body, markers)
+        attributes[:prepared_body] = body && annotator.prepare_body(body, marker_regexes)
 
         # The lib's options (passed to SeeingIsBelieving.new)
         attributes[:lib_options] = {
@@ -88,7 +98,7 @@ class SeeingIsBelieving
           timeout:            timeout,
           debugger:           debugger,
           number_of_captures: flags.fetch(:number_of_captures), # TODO: Rename to max_number_of_captures
-          record_expressions: annotator.expression_wrapper(markers), # TODO: rename to wrap_expressions
+          record_expressions: annotator.expression_wrapper(markers, marker_regexes), # TODO: rename to wrap_expressions
         }
 
         # The annotator's options (passed to annotator.call)
@@ -96,6 +106,7 @@ class SeeingIsBelieving
           alignment_strategy: extract_alignment_strategy(flags.fetch(:alignment_strategy), errors),
           debugger:           debugger,
           markers:            markers,
+          marker_regexes:     marker_regexes,
           max_line_length:    flags.fetch(:max_line_length),
           max_result_length:  flags.fetch(:max_result_length),
         }

data/lib/seeing_is_believing/binary/parse_args.rb

@@ -10,7 +10,15 @@ class SeeingIsBelieving
           exception: '# ~> ',
           stdout:    '# >> ',
           stderr:    '# !> ',
-          nextline:  '#    ',
+        }
+      end
+
+      # TODO: rename to default_marker_regexes ...or turn into fkn objects
+      def self.marker_regexes
+        { value:     '#\s*=>\s*',
+          exception: '#\s*~>\s*',
+          stdout:    '#\s*>>\s*',
+          stderr:    '#\s*!>\s*',
         }
       end
 
@@ -88,6 +96,7 @@ class SeeingIsBelieving
           shebang:             'ruby',
           result_as_json:      false,
           markers:             self.class.default_markers,
+          marker_regexes:      self.class.marker_regexes,
           short_help_screen:   self.class.help_screen(false),
           long_help_screen:    self.class.help_screen(true),
           safe:                false,
@@ -133,7 +142,6 @@ class SeeingIsBelieving
       exception_marker = markers.fetch(:exception)
       stdout_marker    = markers.fetch(:stdout)
       stderr_marker    = markers.fetch(:stderr)
-      nextline_marker  = markers.fetch(:nextline)
 
 <<FLAGS + if include_examples then <<EXAMPLES else '' end
 Usage: seeing_is_believing [options] [filename]

data/lib/seeing_is_believing/binary/remove_annotations.rb

@@ -3,60 +3,53 @@ require 'seeing_is_believing/parser_helpers' # We have to parse the file to find
 
 class SeeingIsBelieving
   module Binary
+    # TODO: might be here that we hit the issue where
+    # you sometimes have to run it 2x to get it to correctly reset whitespace
+    # should wipe out the full_range rather than just the comment_range
     class RemoveAnnotations
-      def self.call(code, should_clean_values, markers)
-        new(code, should_clean_values, markers).call
+      def self.call(raw_code, should_clean_values, markers)
+        new(raw_code, should_clean_values, markers).call
       end
 
-      def initialize(code, should_clean_values, markers)
+      def initialize(raw_code, should_clean_values, markers)
         self.should_clean_values = should_clean_values
-        self.code                = code
-        self.markers             = markers
+        self.raw_code            = raw_code
+        self.markers             = markers # TECHNICALLY THESE ARE REGEXES RIGHT NOW
+        self.code                = Code.new(raw_code, 'strip_comments')
       end
 
       def call
-        code_obj         = Code.new(code, 'strip_comments')
-        removed_comments = { result: [], exception: [], stdout: [], stderr: [] }
+        annotation_chunks_in(code).each do |comment, rest|
+          rest.each { |comment|
+            code.rewriter.remove comment.comment_range
+            remove_whitespace_before comment.comment_range.begin_pos, code.buffer, code.rewriter, false
+          }
 
-        # TODO: This is why you sometimes have to run it 2x to get it to correctly reset whitespace
-        # should wipe out the full_range rather than just the comment_range
-        code_obj.inline_comments.each do |comment|
           case comment.text
           when value_regex
-            if should_clean_values
-              # puts "REMOVING VALUE: #{comment.text}"
-              removed_comments[:result] << comment
-              code_obj.rewriter.remove comment.comment_range
-            end
+            next unless should_clean_values
+            code.rewriter.remove comment.comment_range
+            remove_whitespace_before comment.comment_range.begin_pos, code.buffer, code.rewriter, false
           when exception_regex
-              # puts "REMOVING EXCEPTION: #{comment.text}"
-            removed_comments[:exception] << comment
-            code_obj.rewriter.remove comment.comment_range
+            code.rewriter.remove comment.comment_range
+            remove_whitespace_before comment.comment_range.begin_pos, code.buffer, code.rewriter, true
           when stdout_regex
-              # puts "REMOVING STDOUT: #{comment.text}"
-            removed_comments[:stdout] << comment
-            code_obj.rewriter.remove comment.comment_range
+            code.rewriter.remove comment.comment_range
+            remove_whitespace_before comment.comment_range.begin_pos, code.buffer, code.rewriter, true
           when stderr_regex
-              # puts "REMOVING STDERR: #{comment.text}"
-            removed_comments[:stderr] << comment
-            code_obj.rewriter.remove comment.comment_range
+            code.rewriter.remove comment.comment_range
+            remove_whitespace_before comment.comment_range.begin_pos, code.buffer, code.rewriter, true
+          else
+            raise "This should be impossible! Something must be broken in the comment section above"
           end
         end
 
-        remove_whitespace_preceding_comments(code_obj.buffer, code_obj.rewriter, removed_comments)
-        code_obj.rewriter.process
+        code.rewriter.process
       end
 
       private
 
-      attr_accessor :code, :should_clean_values, :buffer, :markers
-
-      def remove_whitespace_preceding_comments(buffer, rewriter, removed_comments)
-        removed_comments[:result].each    { |comment| remove_whitespace_before comment.comment_range.begin_pos, buffer, rewriter, false }
-        removed_comments[:exception].each { |comment| remove_whitespace_before comment.comment_range.begin_pos, buffer, rewriter, true  }
-        removed_comments[:stdout].each    { |comment| remove_whitespace_before comment.comment_range.begin_pos, buffer, rewriter, true  }
-        removed_comments[:stderr].each    { |comment| remove_whitespace_before comment.comment_range.begin_pos, buffer, rewriter, true  }
-      end
+      attr_accessor :raw_code, :should_clean_values, :markers, :code
 
       # any whitespace before the index (on the same line) will be removed
       # if the preceding whitespace is at the beginning of the line, the newline will be removed
@@ -64,31 +57,57 @@ class SeeingIsBelieving
       def remove_whitespace_before(index, buffer, rewriter, remove_preceding_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_preceding_newline
+        begin_pos -= 1 while raw_code[begin_pos] =~ /\s/ && raw_code[begin_pos] != "\n"
+        begin_pos -= 1 if raw_code[begin_pos] == "\n"
+        begin_pos -= 1 if raw_code[begin_pos] == "\n" && remove_preceding_newline
         return if begin_pos.next == end_pos
         rewriter.remove Parser::Source::Range.new(buffer, begin_pos.next, end_pos)
       end
 
+      def annotation_chunks_in(code)
+        code
+          .inline_comments
+          .map { |comment| [ (comment.text[value_regex]     ||     # associates each comment to its annotation
+                              comment.text[exception_regex] ||
+                              comment.text[stdout_regex]    ||
+                              comment.text[stderr_regex]
+                             ),
+                             comment]}
+          .slice_before { |annotation, comment| annotation }       # annotatios begin chunks
+          .select       { |(annotation, start), *| annotation }    # discard chunks not beginning with an annotation (probably can only happens on first comment)
+          .map { |(annotation, start), *rest|                      # end the chunk if the comment doesn't meet nextline criteria
+            nextline_comments = []
+            prev = start
+            rest.each { |_, potential_nextline|
+              break unless prev.line_number.next == potential_nextline.line_number &&
+                             start.text_col == potential_nextline.text_col         &&
+                             potential_nextline.whitespace_col.zero?               &&
+                             annotation.length <= potential_nextline.text[/#\s*/].length
+              prev = potential_nextline
+              nextline_comments << potential_nextline
+            }
+            [start, nextline_comments]
+          }
+      end
+
       def value_regex
-        @value_regex ||= marker_to_regex markers[:value]
+        markers.fetch(:value)
       end
 
       def exception_regex
-        @exception_regex ||= marker_to_regex markers[:exception]
+        markers.fetch(:exception)
       end
 
       def stdout_regex
-        @stdout_regex ||= marker_to_regex markers[:stdout]
+        markers.fetch(:stdout)
       end
 
       def stderr_regex
-        @stderr_regex ||= marker_to_regex markers[:stderr]
+        markers.fetch(:stderr)
       end
 
-      def marker_to_regex(marker)
-        /\A#{Regexp.escape marker.sub(/\s+$/, '')}/
+      def nextline_regex
+        markers.fetch(:nextline)
       end
     end
   end

data/lib/seeing_is_believing/binary/rewrite_comments.rb

@@ -3,15 +3,61 @@ require 'seeing_is_believing/code'
 class SeeingIsBelieving
   module Binary
     module RewriteComments
-      def self.call(code, &mapping)
-        code = Code.new(code)
-        code.inline_comments.each do |comment|
+      def self.call(code, options={}, &mapping)
+        code     = Code.new(code)
+        comments = code.inline_comments
+        buffer   = code.buffer
+
+        comments.each do |comment|
           new_whitespace, new_comment = mapping.call comment
           code.rewriter.replace comment.whitespace_range, new_whitespace
           code.rewriter.replace comment.comment_range,    new_comment
         end
+
+        line_begins = line_begins_for(buffer.source)
+        options.fetch(:always_rewrite, []).each { |line_number|
+          next if comments.any? { |c| c.line_number == line_number }
+
+          # TODO: can this move down into Code?
+          _, next_line_index = (line_begins.find { |ln, index| ln == line_number } || [nil, buffer.source.size.next])
+          col  = 0
+          col += 1 until col == next_line_index || buffer.source[next_line_index-2-col] == "\n"
+
+          index   = next_line_index - 1
+          range   = Parser::Source::Range.new buffer, index, index
+
+          comment = Code::InlineComment.new line_number, # line_number,
+                                            col,         # preceding_whitespace_range.column,
+                                            "",          # preceding_whitespace,
+                                            col,         # comment.location.column,
+                                            "",          # comment.text,
+                                            range,       # range_for(first_char, comment.location.expression.end_pos),
+                                            range,       # preceding_whitespace_range,
+                                            range        # comment.location.expression
+
+          whitespace, body = mapping.call comment
+          code.rewriter.insert_before range, "#{whitespace}#{body}"
+        }
+
         code.rewriter.process
       end
+
+      # TODO: Move down into the Code obj?
+      # returns: [[lineno, index], ...]
+      def self.line_begins_for(raw_code)
+        # Copied from here https://github.com/whitequark/parser/blob/34c40479293bb9b5ba217039cf349111466d1f9a/lib/parser/source/buffer.rb#L213-227
+        # I figured it's better to copy it than to violate encapsulation since this is private
+        line_begins, index = [ [ 0, 0 ] ], 1
+
+        raw_code.each_char do |char|
+          if char == "\n"
+            line_begins.unshift [ line_begins.length, index ]
+          end
+
+          index += 1
+        end
+        line_begins
+      end
     end
   end
 end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '3.0.0.beta.1'
+  VERSION = '3.0.0.beta.2'
 end

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -27,7 +27,7 @@ class SeeingIsBelieving
 
     def call
       @called ||= begin
-        find_wrappings
+        wrap_recursive
 
         rewriter.insert_before root_range, before_all.call
 
@@ -81,19 +81,19 @@ class SeeingIsBelieving
 
     def add_children(ast, omit_first = false)
       (omit_first ? ast.children.drop(1) : ast.children)
-        .each { |child| find_wrappings child }
+        .each { |child| wrap_recursive child }
     end
 
-    def find_wrappings(ast=root)
+    # todo: is this actually add_wrappings
+    #       and add_wrappings is actually add_wrapping?
+    def wrap_recursive(ast=root)
       return wrappings unless ast.kind_of? ::AST::Node
-
       case ast.type
       when :args, :redo, :retry, :alias, :undef, :splat, :match_current_line
         # no op
       when :defs
         add_to_wrappings ast
-        child = ast.children.last
-        add_to_wrappings child if child
+        add_children ast, true
       when :rescue, :ensure, :return, :break, :next
         add_children ast
       when :if
@@ -108,10 +108,10 @@ class SeeingIsBelieving
           add_children ast
         end
       when :when, :pair, :class, :module, :sclass
-        find_wrappings ast.children.last
+        wrap_recursive ast.children.last
       when :resbody
         exception_type, variable_name, body = ast.children
-        find_wrappings body
+        wrap_recursive body
       when :array
         add_to_wrappings ast
         the_begin = ast.location.begin
@@ -136,7 +136,7 @@ class SeeingIsBelieving
         # I can't think of anything other than a :send that could be the first child
         # but I'll check for it anyway.
         the_send = ast.children[0]
-        find_wrappings the_send.children.first if the_send.type == :send
+        wrap_recursive the_send.children.first if the_send.type == :send
         add_children ast, true
       when :masgn
         # we must look at RHS because [1,<<A] and 1,<<A are both allowed

data/spec/binary/interpret_flags_spec.rb

@@ -24,6 +24,45 @@ class SeeingIsBelieving
         InterpretFlags.new(flags.merge(overrides), stdin, stdout)
       end
 
+      describe '.to_regex' do
+        def call(input, regex)
+          expect(InterpretFlags.to_regex input).to eq regex
+        end
+
+        it 'converts strings into regexes' do
+          call '',    %r()
+          call 'a',   %r(a)
+        end
+
+        it 'ignores surrounding slashes' do
+          call '//',  %r()
+          call '/a/', %r(a)
+        end
+
+        it 'respects flags after the trailing slash in surrounding slashes' do
+          call '/a/',     %r(a)
+          call '/a//',    %r(a/)
+          call '//a/',    %r(/a)
+          call '/a/i',    %r(a)i
+          call '/a/im',   %r(a)im
+          call '/a/xim',  %r(a)xim
+          call '/a/mix',  %r(a)mix
+          call '/a/mixi', %r(a)mixi
+        end
+
+        it 'isn\'t fooled by strings that kinda look regexy' do
+          call '/a',  %r(/a)
+          call 'a/',  %r(a/)
+          call '/',   %r(/)
+          call '/i',  %r(/i)
+        end
+
+        it 'does not escape the content' do
+          call 'a\\s+',   %r(a\s+)
+          call '/a\\s+/', %r(a\s+)
+        end
+      end
+
       describe 'annotator' do
         it 'annotates every line by default' do
           expect(call.annotator).to eq AnnotateEveryLine

data/spec/binary/parse_args_spec.rb

@@ -380,8 +380,8 @@ RSpec.describe SeeingIsBelieving::Binary::ParseArgs do
   end
 
   describe ':markers' do
-    it 'defaults to a hash with :value, :exception, :stdout, :stderr, and :nextline' do
-      expect(parse([])[:markers].keys).to eq [:value, :exception, :stdout, :stderr, :nextline]
+    it 'defaults to a hash with :value, :exception, :stdout, and :stderr' do
+      expect(parse([])[:markers].keys).to eq [:value, :exception, :stdout, :stderr]
     end
 
     def assert_default(marker_name, value)
@@ -392,14 +392,25 @@ RSpec.describe SeeingIsBelieving::Binary::ParseArgs do
     it('defaults :exception to "# ~> "') { assert_default :exception , "# ~> " }
     it('defaults :stdout    to "# >> "') { assert_default :stdout    , "# >> " }
     it('defaults :stderr    to "# !> "') { assert_default :stderr    , "# !> " }
-    it('defaults :nextline  to "#    "') { assert_default :nextline  , "#    " }
 
     # TODO: When things get a little more stable, don't feel like adding all the cukes to play with this right now
     it 'overrides :value     with --value-marker'
     it 'overrides :exception with --exception-marker'
     it 'overrides :stdout    with --stdout-marker'
     it 'overrides :stderr    with --stderr-marker'
-    it 'overrides :nextline  with --xmpfilter-nextline-marker'
+  end
+
+  describe ':marker_regexes' do
+    it 'is a hash with the same keys as the markers' do
+      marker_keys = parse([])[:markers].keys
+      marker_regexes_keys = parse([])[:marker_regexes].keys
+      expect(marker_regexes_keys).to eq marker_keys
+    end
+
+    it 'overrides :value     with --value-regex'
+    it 'overrides :exception with --exception-regex'
+    it 'overrides :stdout    with --stdout-regex'
+    it 'overrides :stderr    with --stderr-regex'
   end
 end
 

data/spec/binary/remove_annotations_spec.rb

@@ -1,51 +1,155 @@
 require 'spec_helper'
 require 'seeing_is_believing/binary/remove_annotations'
+require 'seeing_is_believing/binary/parse_args'  # for marker info
 
 RSpec.describe SeeingIsBelieving::Binary::RemoveAnnotations do
   def call(code, should_clean_values=true)
     indentation = code[/\A */]
     code        = code.gsub /^#{indentation}/, ''
-    described_class.call(code,
-                         should_clean_values,
-                         value:     '# => ',
-                         exception: '# ~> ',
-                         stdout:    '# >> ',
-                         stderr:    '# !> ',
-                         nextline:  '#    ',
-                        ).chomp
+    described_class.call(code, should_clean_values, regexes).chomp
+  end
+
+  def regexes
+    SeeingIsBelieving::Binary::ParseArgs
+      .marker_regexes
+      .each_with_object({}) { |(name, str), rs| rs[name] = Regexp.new str }
+  end
+
+  context 'when there are lines that are just normal comments' do
+    example { expect(call "1 # hello").to eq "1 # hello" }
+    example { expect(call "1 # hello\n"\
+                          "# world").to eq "1 # hello\n"\
+                                           "# world" }
+    example { expect(call "1 # not special\n"\
+                          "2 # => 3").to eq "1 # not special\n2" }
   end
 
   context 'when told to clean out value annotations' do
-    example { expect(call "1# => 1",      true).to eq "1" }
-    example { expect(call "1 # => 1",     true).to eq "1" }
-    example { expect(call "1  # => 1",    true).to eq "1" }
-    example { expect(call "1  # => 1",   true).to eq "1" }
-    example { expect(call "1   # => 1",  true).to eq "1" }
-    example { expect(call "1  # =>  1",  true).to eq "1" }
+    example { expect(call "1# => 1",    true).to eq "1"   }
+    example { expect(call "1 # => 1",   true).to eq "1"   }
+    example { expect(call "1  # => 1",  true).to eq "1"   }
+    example { expect(call "1  # => 1",  true).to eq "1"   }
+    example { expect(call "1   # => 1", true).to eq "1"   }
+    example { expect(call "1  # =>  1", true).to eq "1"   }
     example { expect(call "\n1 # => 1", true).to eq "\n1" }
   end
 
   context 'when told not to clean out value annotations' do
-    example { expect(call "1# => 1",      false).to eq "1# => 1" }
-    example { expect(call "1 # => 1",     false).to eq "1 # => 1" }
-    example { expect(call "1  # => 1",    false).to eq "1  # => 1" }
-    example { expect(call "1  # => 1",   false).to eq "1  # => 1" }
-    example { expect(call "1   # => 1",  false).to eq "1   # => 1" }
-    example { expect(call "1  # =>  1",  false).to eq "1  # =>  1" }
+    example { expect(call "1# => 1",    false).to eq "1# => 1"    }
+    example { expect(call "1 # => 1",   false).to eq "1 # => 1"   }
+    example { expect(call "1  # => 1",  false).to eq "1  # => 1"  }
+    example { expect(call "1  # => 1",  false).to eq "1  # => 1"  }
+    example { expect(call "1   # => 1", false).to eq "1   # => 1" }
+    example { expect(call "1  # =>  1", false).to eq "1  # =>  1" }
     example { expect(call "\n1 # => 1", false).to eq "\n1 # => 1" }
   end
 
   context 'cleaning inline exception annotations' do
-    example { expect(call "1# ~> 1"     ).to eq "1" }
-    example { expect(call "1 # ~> 1"    ).to eq "1" }
-    example { expect(call "1  # ~> 1"   ).to eq "1" }
-    example { expect(call "1  # ~> 1"  ).to eq "1" }
-    example { expect(call "1   # ~> 1" ).to eq "1" }
-    example { expect(call "1  # ~>  1" ).to eq "1" }
+    example { expect(call "1# ~> 1"   ).to eq "1"   }
+    example { expect(call "1 # ~> 1"  ).to eq "1"   }
+    example { expect(call "1  # ~> 1" ).to eq "1"   }
+    example { expect(call "1  # ~> 1" ).to eq "1"   }
+    example { expect(call "1   # ~> 1").to eq "1"   }
+    example { expect(call "1  # ~>  1").to eq "1"   }
     example { expect(call "\n1 # ~> 1").to eq "\n1" }
 
-    example { expect(call "# >> 1").to eq "" }
-    example { expect(call "# !> 1").to eq "" }
+    example { expect(call "# >> 1").to eq ""        }
+    example { expect(call "# !> 1").to eq ""        }
+  end
+
+  context 'cleaning multiline results' do
+    it 'cleans values whose hash and value locations exactly match the annotation on the line prior' do
+      expect(call "1# => 2\n"\
+                  " #    3").to eq "1"
+    end
+
+    it 'does not clean values where the comment appears at a different position' do
+      expect(call "1# => 2\n"\
+                  "#    3").to eq "1\n"\
+                                  "#    3"
+
+      expect(call "1# => 2\n"\
+                  "  #    3").to eq "1\n"\
+                                    "  #    3"
+
+      expect(call "1# => 2\n"\
+                  "#     3").to eq "1\n"\
+                                   "#     3"
+      expect(call "1# => 2\n"\
+                  "  #   3").to eq "1\n"\
+                                   "  #   3"
+
+    end
+
+    it 'does not clean values where the nextline value appears before the initial annotation value' do
+      # does clean
+      expect(call "1# => 2\n"\
+                  " #    3").to eq "1"
+      expect(call "1# => 2\n"\
+                  " #     3").to eq "1"
+
+      # does not clean
+      expect(call "1# => 2\n"\
+                  " #  3 4").to eq "1\n"\
+                                   " #  3 4"
+      expect(call "1# => 2\n"\
+                  " #   3").to eq "1\n"\
+                                  " #   3"
+      expect(call "1# => 2\n"\
+                  " #  3").to eq "1\n"\
+                                 " #  3"
+    end
+
+    it 'does not clean values where there is content before the comment' do
+      expect(call "1# => 2\n"\
+                  "3#    4").to eq "1\n"\
+                                   "3#    4"
+    end
+
+    it 'cleans successive rows of these' do
+      expect(call "1# => 2\n"\
+                  " #    3\n"\
+                  " #    4" ).to eq "1"
+      expect(call "1# => 2\n"\
+                  " #    3\n"\
+                  " #    4\n"\
+                  "5# => 6\n"\
+                  " #    7\n"\
+                  " #    8" ).to eq "1\n5"
+    end
+
+    it 'does not clean values where there is non-annotation inbetween' do
+      expect(call "1# => 2\n"\
+                  "#    3\n"\
+                  " #    4").to eq "1\n"\
+                                   "#    3\n"\
+                                   " #    4"
+
+      expect(call "1# => 2\n"\
+                  "3      \n"\
+                  " #    4").to eq "1\n"\
+                                   "3      \n"\
+                                   " #    4"
+      expect(call "1# => 2\n"\
+                  "#    3\n"\
+                  " #    4").to eq "1\n"\
+                                   "#    3\n"\
+                                   " #    4"
+    end
+
+    it 'cleans multiline portion, regardless of whether cleaning values (this is soooooo xmpfilter specific)' do
+      expect(call "1# => 2\n"\
+                  " #    3").to eq "1"
+
+      expect(call "1# => 2\n"\
+                  " #    3",
+                  false).to eq "1# => 2"
+    end
+
+    it 'works on inline exceptions' do
+      expect(call "1# ~> 2\n"\
+                  " #    3").to eq "1"
+    end
   end
 
   context 'cleaning stdout annotations' do

data/spec/binary/rewrite_comments_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 require 'seeing_is_believing/binary/rewrite_comments'
 
 RSpec.describe SeeingIsBelieving::Binary::RewriteComments do
-  def call(code, &block)
-    described_class.call code, &block
+  def call(code, options={}, &block)
+    described_class.call code, options, &block
   end
 
   it 'ignores multiline comments' do
@@ -52,4 +52,40 @@ RSpec.describe SeeingIsBelieving::Binary::RewriteComments do
                             "%Q{\n"\
                             " 1}NEW_WHITESPACE6--COMMENT-6--"
   end
+
+  it 'can be given additional lines to make sure are provided, whether they have comments on them or not' do
+    rewritten = call("'a'\n"\
+                     "'b'\n"\
+                     "'c' # c\n"\
+                     "'d'",
+                     always_rewrite: [2, 3]) do |c|
+                       value = sprintf "%d|%d|%p|%d|%p|%d..%d|%d..%d|%d..%d",
+                                       c.line_number,
+                                       c.whitespace_col,
+                                       c.whitespace,
+                                       c.text_col,
+                                       c.text,
+                                       c.full_range.begin_pos,
+                                       c.full_range.end_pos,
+                                       c.whitespace_range.begin_pos,
+                                       c.whitespace_range.end_pos,
+                                       c.comment_range.begin_pos,
+                                       c.comment_range.end_pos
+                       ['pre', value]
+                     end
+    expect(rewritten).to eq \
+      "'a'\n"\
+      "'b'pre2|3|\"\"|3|\"\"|7..7|7..7|7..7\n"\
+      "'c'pre3|3|\" \"|4|\"# c\"|11..15|11..12|12..15\n"\
+      "'d'"
+
+    rewritten = call("", always_rewrite: [1]) { |c| ['a', 'b'] }
+    expect(rewritten).to eq "ab"
+
+    rewritten = call("a", always_rewrite: [1]) { |c| ['b', 'c'] }
+    expect(rewritten).to eq "abc"
+
+    rewritten = call("a\n", always_rewrite: [1]) { |c| ['b', 'c'] }
+    expect(rewritten).to eq "abc\n"
+  end
 end

data/spec/wrap_expressions_spec.rb

@@ -17,8 +17,8 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
   end
 
   describe 'wrapping the body' do
-    let(:options) { { before_all: -> { "[".freeze },
-                      after_all:  -> { "]".freeze },
+    let(:options) { { before_all:  ->   { "[".freeze },
+                      after_all:   ->   { "]".freeze },
                       before_each: -> * { '<'.freeze },
                       after_each:  -> * { '>'.freeze } } }
 
@@ -798,14 +798,16 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("def a(b,c=1,*d,&e)\nend")).to eq "<def a(b,c=1,*d,&e)\nend>"
     end
 
-    it 'wraps the body' do
+    it 'wraps the the body' do
       expect(wrap("def a\n1\nend")).to eq "<def a\n<1>\nend>"
       expect(wrap("def a()\n1\nend")).to eq "<def a()\n<1>\nend>"
+      expect(wrap("def a\n1\n2\nend")).to eq "<def a\n<1>\n<2>\nend>"
     end
 
-    it 'wrap singleton method definitions' do
+    it 'wraps singleton method definitions' do
       expect(wrap("def a.b\n1\nend")).to eq "<def a.b\n<1>\nend>"
-      # expect(wrap("def a.b()\n1\nend")).to eq "<def a.b()\n<1>\nend>"
+      expect(wrap("def a.b()\n1\nend")).to eq "<def a.b()\n<1>\nend>"
+      expect(wrap("def a.b\n1\n2\nend")).to eq "<def a.b\n<1>\n<2>\nend>" # <-- seems redundant, but this was a regression
     end
 
     it 'wraps calls to yield' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  version: 3.0.0.beta.1
+  version: 3.0.0.beta.2
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-23 00:00:00.000000000 Z
+date: 2014-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eval_in
@@ -267,7 +267,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: seeing_is_believing
-rubygems_version: 2.4.1
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Records results of every line of code in your file
@@ -293,4 +293,3 @@ test_files:
 - spec/seeing_is_believing_spec.rb
 - spec/spec_helper.rb
 - spec/wrap_expressions_spec.rb
-has_rdoc: