andyw8-seeing_is_believing 4.2.0

data/lib/seeing_is_believing/binary/annotate_end_of_file.rb

@@ -0,0 +1,56 @@
+require 'seeing_is_believing/binary' # defines the markers
+require 'seeing_is_believing/binary/format_comment'
+
+class SeeingIsBelieving
+  module Binary
+    module AnnotateEndOfFile
+      extend self
+
+      def add_stdout_stderr_and_exceptions_to(new_body, results, options)
+        output = stdout_ouptut_for(results, options)    <<
+                 stderr_ouptut_for(results, options)    <<
+                 exception_output_for(results, options)
+
+        code = Code.new(new_body)
+        code.rewriter.insert_after code.body_range, output
+        new_body.replace code.rewriter.process
+      end
+
+      def stdout_ouptut_for(results, options)
+        return '' unless results.has_stdout?
+        output = "\n"
+        results.stdout.each_line do |line|
+          output << FormatComment.call(0, options[:markers][:stdout][:prefix], line.chomp, options) << "\n"
+        end
+        output
+      end
+
+      def stderr_ouptut_for(results, options)
+        return '' unless results.has_stderr?
+        output = "\n"
+        results.stderr.each_line do |line|
+          output << FormatComment.call(0, options[:markers][:stderr][:prefix], line.chomp, options) << "\n"
+        end
+        output
+      end
+
+      def exception_output_for(results, options)
+        return '' unless results.has_exception?
+        exception_marker = options[:markers][:exception][:prefix]
+        output = ""
+        results.exceptions.each do |exception|
+          output << "\n"
+          output << FormatComment.new(0, exception_marker, exception.class_name, options).call << "\n"
+          exception.message.each_line do |line|
+            output << FormatComment.new(0, exception_marker, line.chomp, options).call << "\n"
+          end
+          output << exception_marker.sub(/\s+$/, '') << "\n"
+          exception.backtrace.each do |line|
+            output << FormatComment.new(0, exception_marker, line.chomp, options).call << "\n"
+          end
+        end
+        output
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/annotate_every_line.rb

@@ -0,0 +1,52 @@
+require 'seeing_is_believing/binary/interline_align'
+
+class SeeingIsBelieving
+  module Binary
+    class AnnotateEveryLine
+      def self.call(body, results, options)
+        new(body, results, options).call
+      end
+
+      def initialize(body, results, options={})
+        @options         = options
+        @body            = body
+        @results         = results
+        @interline_align = InterlineAlign.new(results)
+      end
+
+      def call
+        @new_body ||= begin
+          require 'seeing_is_believing/binary/comment_lines'
+          require 'seeing_is_believing/binary/format_comment'
+          exception_prefix = @options[:markers][:exception][:prefix]
+          value_prefix     = @options[:markers][:value][:prefix]
+          exceptions       = Hash.[] @results.exceptions.map { |e| [e.line_number, e] }
+
+          alignment_strategy = @options[:alignment_strategy].new(@body)
+          new_body = CommentLines.call @body do |line, line_number|
+            exception = exceptions[line_number]
+            options   = @options.merge pad_to: alignment_strategy.line_length_for(line_number)
+            if exception
+              result = sprintf "%s: %s", exception.class_name, exception.message.gsub("\n", '\n')
+              FormatComment.call(line.size, exception_prefix, result, options)
+            elsif @results[line_number].any?
+              if @options[:interline_align]
+                result = @interline_align.call line_number, @results[line_number].map { |result| result.gsub "\n", '\n' }
+              else
+                result = @results[line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
+              end
+              FormatComment.call(line.size, value_prefix, result, options)
+            else
+              ''
+            end
+          end
+
+          require 'seeing_is_believing/binary/annotate_end_of_file'
+          AnnotateEndOfFile.add_stdout_stderr_and_exceptions_to new_body, @results, @options
+
+          new_body
+        end
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/annotate_marked_lines.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+require 'seeing_is_believing/code'
+
+# *sigh* need to find a way to join the annotators.
+# They are sinful ugly, kinda hard to work with,
+# and absurdly duplicated.
+
+class SeeingIsBelieving
+  module Binary
+    # Based on the behaviour of xmpfilter (a binary in the rcodetools gem)
+    # See https://github.com/JoshCheek/seeing_is_believing/issues/44 for more details
+    class AnnotateMarkedLines
+      def self.map_markers_to_linenos(program, markers)
+        value_regex      = markers[:value][:regex]
+        recordable_lines = []
+        inspect_linenos  = []
+        pp_map           = {}
+        WrapExpressions.call program, before_each: -> line_number {
+          recordable_lines << line_number
+          ''
+        }
+
+        Code.new(program).inline_comments.each do |c|
+          next unless c.text[value_regex]
+          if c.whitespace_col == 0
+            lineno = c.line_number
+            loop do
+              lineno -= 1
+              break if recordable_lines.include?(lineno) || lineno.zero?
+            end
+            pp_map[c.line_number] = lineno
+          else
+            inspect_linenos << c.line_number
+          end
+        end
+
+        return inspect_linenos, pp_map
+      end
+
+      def self.code_rewriter(markers)
+        lambda do |program|
+          inspect_linenos, pp_map = map_markers_to_linenos(program, markers)
+          pp_linenos = pp_map.values
+
+          should_inspect = false
+          should_pp      = false
+          WrapExpressions.call \
+            program,
+            before_all: -> { "BEGIN { $SiB.file_loaded };" },
+            before_each: -> line_number {
+              inspect        = "$SiB.record_result(:inspect, #{line_number}, ("
+              pp             = "$SiB.record_result(:pp, #{line_number}, ("
+
+              should_inspect = inspect_linenos.include? line_number
+              should_pp      = pp_linenos.include?      line_number
+
+              if    should_inspect && should_pp then "#{pp}#{inspect}"
+              elsif should_inspect              then inspect
+              elsif should_pp                   then pp
+              else                                   ""
+              end
+            },
+            after_each:  -> line_number {
+              # 74 b/c pretty print_defaults to 79 (guessing 80 chars with 1 reserved for newline), and
+              # 79 - "# => ".length # => 4
+              # ALSO: This should be configurable, b/c otherwise you have to go into the guts of `pp`
+              #       https://gist.github.com/JoshCheek/6472c8f334ae493f4ab1f7865e2470e5
+              inspect = ")) { |v| v.inspect }"
+              pp      = ")) { |v| PP.pp v, '', 74 }"
+
+              should_inspect = inspect_linenos.include? line_number
+              should_pp      = pp_linenos.include?      line_number
+
+              if    should_inspect && should_pp then "#{inspect}#{pp}"
+              elsif should_inspect              then inspect
+              elsif should_pp                   then pp
+              else                                   ""
+              end
+            }
+        end
+      end
+
+      def self.call(body, results, options)
+        new(body, results, options).call
+      end
+
+      def initialize(body, results, options={})
+        @options         = options
+        @body            = body
+        @results         = results
+        @interline_align = InterlineAlign.new(results)
+      end
+
+      # seems like maybe this should respect the alignment strategy (not what xmpfilter does, but there are other ways I'd like to deviate anyway)
+      # and we should just add a new alignment strategy for default xmpfilter style
+      def call
+        @new_body ||= begin
+          require 'seeing_is_believing/binary/rewrite_comments'
+          require 'seeing_is_believing/binary/format_comment'
+          include_lines     = []
+          exception_results = {}
+
+          @results.exceptions.each do |exception|
+            exception_results[exception.line_number] =
+              sprintf "%s: %s", exception.class_name, exception.message.gsub("\n", '\n')
+            include_lines << exception.line_number
+          end
+
+          _, pp_map = self.class.map_markers_to_linenos(@body, @options[:markers])
+          new_body = RewriteComments.call @body, include_lines: include_lines do |comment|
+            exception_result   = exception_results[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_result && annotate_this_line
+              [comment.whitespace, FormatComment.call(comment.text_col, value_prefix, exception_result, @options)]
+            elsif exception_result && comment.text.empty?
+              whitespace = comment.whitespace
+              whitespace = " " if whitespace.empty?
+              [whitespace, FormatComment.call(0, exception_prefix, exception_result, @options)]
+            elsif normal_annotation
+              if @options[:interline_align]
+                annotation = @interline_align.call comment.line_number, @results[comment.line_number].map { |result| result.gsub "\n", '\n' }
+                [comment.whitespace, FormatComment.call(comment.text_col, value_prefix, annotation, @options)]
+              else
+                annotation = @results[comment.line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
+                [comment.whitespace, FormatComment.call(comment.text_col, value_prefix, annotation, @options)]
+              end
+            elsif pp_annotation
+              result     = @results[pp_map[comment.line_number], :pp]
+              annotation = result.map { |result| result.chomp }.join("\n,") # ["1\n2", "1\n2", ...
+              swap_leading_whitespace_in_multiline_comment(annotation)
+              comment_lines = annotation.each_line.map.with_index do |comment_line, result_offest|
+                if result_offest == 0
+                  FormatComment.call(comment.whitespace_col, value_prefix, comment_line.chomp, @options)
+                else
+                  leading_whitespace = " " * comment.text_col
+                  leading_whitespace << FormatComment.call(comment.whitespace_col, nextline_prefix, comment_line.chomp, @options)
+                end
+              end
+              comment_lines = [value_prefix.rstrip] if comment_lines.empty?
+              [comment.whitespace, comment_lines.join("\n")]
+            else
+              [comment.whitespace, comment.text]
+            end
+          end
+
+          require 'seeing_is_believing/binary/annotate_end_of_file'
+          AnnotateEndOfFile.add_stdout_stderr_and_exceptions_to new_body, @results, @options
+
+          new_body
+        end
+      end
+
+      def value_prefix
+        @value_prefix ||= @options[:markers][:value][:prefix]
+      end
+
+      def nextline_prefix
+        @nextline_prefix ||= ('#' + ' '*value_prefix.length.pred)
+      end
+
+      def exception_prefix
+        @exception_prefix ||= @options[:markers][:exception][:prefix]
+      end
+
+      def value_regex
+        @value_regex ||= @options[:markers][:value][:regex]
+      end
+
+      def swap_leading_whitespace_in_multiline_comment(comment)
+        return if comment.scan("\n").size < 2
+        return if comment[0] =~ /\S/
+        nonbreaking_space = " "
+        comment[0] = nonbreaking_space
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/comment_lines.rb

@@ -0,0 +1,36 @@
+require 'seeing_is_believing/binary/commentable_lines'
+
+class SeeingIsBelieving
+  module Binary
+    # takes a body and a block
+    # passes the block the line
+    # the block returns the comment to add at the end of it
+    class CommentLines
+      def self.call(raw_code, &commenter)
+        new(raw_code, &commenter).call
+      end
+
+      def initialize(raw_code, &commenter)
+        self.raw_code, self.commenter = raw_code, commenter
+      end
+
+      def call
+        @call ||= begin
+          commentable_lines = CommentableLines.new raw_code
+          commentable_lines.call.each do |line_number, (index_of_newline, _col)|
+            first_index  = last_index = index_of_newline
+            first_index -= 1 while first_index > 0 && raw_code[first_index-1] != "\n"
+            comment_text = commenter.call raw_code[first_index...last_index], line_number
+            range        = Parser::Source::Range.new(commentable_lines.buffer, first_index, last_index)
+            commentable_lines.rewriter.insert_after range, comment_text
+          end
+          commentable_lines.rewriter.process
+        end
+      end
+
+      private
+
+      attr_accessor :raw_code, :commenter
+    end
+  end
+end

data/lib/seeing_is_believing/binary/commentable_lines.rb

@@ -0,0 +1,126 @@
+require 'seeing_is_believing/code'
+
+class SeeingIsBelieving
+  module Binary
+
+    class CommentableLines
+      def self.call(code)
+        new(code).call
+      end
+
+      def initialize(code)
+        self.code = code
+        self.code_obj = Code.new(code, 'finding_commentable_lines')
+      end
+
+      def call
+        @call ||= begin
+          line_num_to_location = line_nums_to_last_index_and_col(buffer)
+          remove_lines_after_data_segment           line_num_to_location
+          remove_lines_whose_newline_is_escaped     line_num_to_location
+          remove_lines_ending_in_comments           line_num_to_location, code_obj.raw_comments
+          remove_lines_inside_of_strings_and_things line_num_to_location, root
+          line_num_to_location
+        end
+      end
+
+      def buffer
+        code_obj.buffer
+      end
+
+      def rewriter
+        code_obj.rewriter
+      end
+
+      private
+
+      attr_writer :buffer, :rewriter
+      attr_accessor :code, :code_obj
+
+      def root
+        code_obj.root
+      end
+
+      def line_nums_to_last_index_and_col(buffer)
+        code.each_char
+            .with_index
+            .select { |char, index| char == "\n" }
+            .each_with_object(Hash.new) do |(_, index), hash|
+              line, col = buffer.decompose_position index
+              hash[line] = [index, col]
+            end
+      end
+
+      def remove_lines_whose_newline_is_escaped(line_num_to_location)
+        ors_indexes = code_obj.indexes_of_ors_at_eol
+        line_num_to_location
+          .select { |line_number, (index_of_newline, _col)|
+            code[index_of_newline-1] == '\\'
+          }
+          .reject { |line_number, (index_of_newline, _col)|
+            ors_indexes.include? index_of_newline
+          }
+          .each { |line_number, (_index_of_newline, _col)|
+            line_num_to_location.delete line_number
+          }
+      end
+
+      def remove_lines_ending_in_comments(line_num_to_location, comments)
+        comments.each do |comment|
+          if comment.type == :inline
+            line_num_to_location.delete comment.location.line
+          else
+            begin_pos = comment.location.expression.begin_pos
+            end_pos   = comment.location.expression.end_pos
+            range     = begin_pos...end_pos
+            line_num_to_location.select { |line_number, (index_of_newline, _col)| range.include? index_of_newline }
+                                .each   { |line_number, (_index_of_newline, _col)| line_num_to_location.delete line_number }
+          end
+        end
+      end
+
+      def remove_lines_inside_of_strings_and_things(line_num_to_location, ast)
+        invalid_boundaries = ranges_of_atomic_expressions ast, []
+        invalid_boundaries.each do |invalid_boundary|
+          line_num_to_location.select { |line_number, (index_of_newline, _col)| invalid_boundary.include? index_of_newline }
+                              .each   { |line_number, (_index_of_newline, _col)| line_num_to_location.delete line_number }
+        end
+      end
+
+      def ranges_of_atomic_expressions(ast, found_ranges)
+        return found_ranges unless ast.kind_of? ::AST::Node
+        if no_comment_zone?(ast) && code_obj.heredoc?(ast)
+          begin_pos = ast.location.heredoc_body.begin_pos
+          end_pos   = ast.location.heredoc_end.end_pos.next
+          found_ranges << (begin_pos...end_pos)
+        elsif no_comment_zone? ast
+          begin_pos = ast.location.expression.begin.begin_pos
+          end_pos   = ast.location.expression.end.end_pos
+          found_ranges << (begin_pos...end_pos)
+        else
+          ast.children.each { |child| ranges_of_atomic_expressions child, found_ranges }
+        end
+        found_ranges
+      end
+
+      def no_comment_zone?(ast)
+        case ast.type
+        when :dstr, :str, :xstr, :regexp
+          true
+        when :array
+          the_begin = ast.location.begin
+          the_begin && the_begin.source =~ /\A%/
+        else
+          false
+        end
+      end
+
+      def remove_lines_after_data_segment(line_num_to_location)
+        end_index = code_obj.body_range.end_pos
+        body_end  = code_obj.index_to_linenum end_index
+        file_end  = line_num_to_location.keys.max
+        body_end.upto(file_end) { |line_number| line_num_to_location.delete line_number }
+      end
+    end
+  end
+end