seeing_is_believing 2.0.0.beta1 → 2.0.0.beta2

data/lib/seeing_is_believing/binary/align_chunk.rb

@@ -1,38 +1,37 @@
+require 'seeing_is_believing/binary/commentable_lines'
+
 class SeeingIsBelieving
   class Binary
     class AlignChunk
-      attr_accessor :body, :start_line, :end_line
-
       def initialize(body, start_line, end_line)
         self.body, self.start_line, self.end_line = body, start_line, end_line
       end
 
       # max line length of the the chunk (newline separated sections of code exempting comments) + 2 spaces for padding
       def line_length_for(line_number)
-        line_lengths[line_number]
+        line_lengths.fetch line_number, 0
       end
 
-      def line_lengths
-        @line_lengths ||= Hash[
-          body.each_line
-              .map(&:chomp)
-              .map.with_index(1) { |line, index| [line, index] }
-              .take_while        { |line, index| not start_of_data_segment? line }
-              .select            { |line, index| not SyntaxAnalyzer.begins_multiline_comment?(line) .. SyntaxAnalyzer.ends_multiline_comment?(line ) }
-              .reject            { |line, index| SyntaxAnalyzer.ends_in_comment? line }
-              .slice_before      { |line, index| line == '' }
-              .map { |slice|
-                max_chunk_length = 2 + slice.select { |line, index| start_line <= index && index <= end_line }
-                                            .map { |line, index| line.length }
-                                            .max
-                slice.map { |line, index| [index, max_chunk_length] }
-              }
-              .flatten(1)
-        ]
-      end
+      private
+
+      attr_accessor :body, :start_line, :end_line
 
-      def start_of_data_segment?(line)
-        SyntaxAnalyzer.begins_data_segment?(line.chomp)
+      def line_lengths
+        @line_lengths ||= begin
+          line_num_to_indexes = CommentableLines.new(body).call # {line_number => [index_in_file, index_in_col]}
+          Hash[line_num_to_indexes
+                 .keys
+                 .sort
+                 .slice_before { |line_number| line_num_to_indexes[line_number].last.zero? }
+                 .map { |slice|
+                   max_chunk_length = 2 + slice.select { |line_num| start_line <= line_num && line_num <= end_line }
+                                               .map    { |line_num| line_num_to_indexes[line_num].last }
+                                               .max
+                   slice.map { |line_number| [line_number, max_chunk_length] }
+                 }
+                 .flatten(1)
+          ]
+        end
       end
     end
   end

data/lib/seeing_is_believing/binary/align_file.rb

@@ -1,3 +1,5 @@
+require 'seeing_is_believing/binary/commentable_lines'
+
 class SeeingIsBelieving
   class Binary
     class AlignFile
@@ -9,19 +11,14 @@ class SeeingIsBelieving
 
       # max line length of the lines to output (exempting comments) + 2 spaces for padding
       def line_length_for(line_number)
-        @max_source_line_length ||= 2 + body.each_line
-                                            .map(&:chomp)
-                                            .select.with_index(1) { |line, index| start_line <= index && index <= end_line }
-                                            .take_while { |line| not start_of_data_segment? line }
-                                            .select { |line| not SyntaxAnalyzer.begins_multiline_comment?(line) .. SyntaxAnalyzer.ends_multiline_comment?(line ) }
-                                            .reject { |line| SyntaxAnalyzer.ends_in_comment? line }
-                                            .map(&:length)
-                                            .concat([0])
-                                            .max
-      end
-
-      def start_of_data_segment?(line)
-        SyntaxAnalyzer.begins_data_segment?(line.chomp)
+        @max_source_line_length ||= 2 + begin
+          line_num_to_indexes = CommentableLines.new(body).call # {line_number => [index_in_file, index_in_col]}
+          max_value = line_num_to_indexes
+                           .select { |line_num, _| start_line <= line_num && line_num <= end_line }
+                           .values
+                           .map { |index, col| col }.max
+          max_value || 0
+        end
       end
     end
   end

data/lib/seeing_is_believing/binary/align_line.rb

@@ -20,10 +20,6 @@ class SeeingIsBelieving
                                     .map { |line, index| [index, line.length+2] }
                               ]
       end
-
-      def start_of_data_segment?(line)
-        SyntaxAnalyzer.begins_data_segment?(line.chomp)
-      end
     end
   end
 end

data/lib/seeing_is_believing/binary/arg_parser.rb

@@ -29,15 +29,15 @@ class SeeingIsBelieving
             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
-            when '-D', '--result-length'       then extract_positive_int_for :result_length, arg
-            when '-t', '--timeout'             then extract_non_negative_float_for :timeout, arg
-            when '-r', '--require'             then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:require]            << filename }
-            when '-I', '--load-path'           then next_arg("#{arg} expected a directory as the following argument but did not see one") { |dir|      options[:load_path]          << dir }
-            when '-e', '--program'             then next_arg("#{arg} expected a program as the following argument but did not see one")   { |program|  options[:program]            = program }
-            when '-a', '--as'                  then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:as]                 = filename }
+            when '-l', '--start-line'          then extract_positive_int_for :start_line,        arg
+            when '-L', '--end-line'            then extract_positive_int_for :end_line,          arg
+            when '-d', '--line-length'         then extract_positive_int_for :max_line_length,   arg
+            when '-D', '--result-length'       then extract_positive_int_for :max_result_length, arg
+            when '-t', '--timeout'             then extract_non_negative_float_for :timeout,     arg
+            when '-r', '--require'             then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:require]   << filename }
+            when '-I', '--load-path'           then next_arg("#{arg} expected a directory as the following argument but did not see one") { |dir|      options[:load_path] << dir }
+            when '-e', '--program'             then next_arg("#{arg} expected a program as the following argument but did not see one")   { |program|  options[:program]   =  program }
+            when '-a', '--as'                  then next_arg("#{arg} expected a filename as the following argument but did not see one")  { |filename| options[:as]        =  filename }
             when '-s', '--alignment-strategy'  then extract_alignment_strategy
             when /\A-K(.+)/                    then options[:encoding] = $1
             when '-K', '--encoding'            then next_arg("#{arg} expects an encoding, see `man ruby` for possibile values") { |encoding| options[:encoding] = encoding }
@@ -78,9 +78,9 @@ class SeeingIsBelieving
           program:             nil,
           filename:            nil,
           start_line:          1,
-          line_length:         Float::INFINITY,
           end_line:            Float::INFINITY,
-          result_length:       Float::INFINITY,
+          max_line_length:     Float::INFINITY,
+          max_result_length:   Float::INFINITY,
           timeout:             0, # timeout lib treats this as infinity
           errors:              [],
           require:             [],

data/lib/seeing_is_believing/binary/clean_body.rb

@@ -0,0 +1,96 @@
+# CleanedBody
+#   takes a body
+#   removes annotations
+#   only removes "# =>" when should_clean_values is false
+
+require 'parser/current'
+
+class SeeingIsBelieving
+  class Binary
+    class CleanBody
+      def self.call(code, should_clean_values)
+        new(code, should_clean_values).call
+      end
+
+      def initialize(code, should_clean_values)
+        self.should_clean_values = should_clean_values
+        self.code                = code
+      end
+
+      def call
+        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)
+        removed_comments      = { result: [], exception: [], stdout: [], stderr: [] }
+
+        comments.each do |comment|
+          case comment.text
+          when /\A#\s*=>/
+            if should_clean_values
+              removed_comments[:result] << comment
+              rewriter.remove comment.location.expression
+            end
+          when /\A#\s*~>/
+            removed_comments[:exception] << comment
+            rewriter.remove comment.location.expression
+          when /\A#\s*>>/ then
+            removed_comments[:stdout] << comment
+            rewriter.remove comment.location.expression
+          when /\A#\s*!>/ then
+            removed_comments[:stderr] << comment
+            rewriter.remove comment.location.expression
+          end
+        end
+
+        remove_whitespace_preceeding_comments(buffer, rewriter, removed_comments)
+        rewriter.process
+      rescue Parser::SyntaxError => e
+        raise SyntaxError, e.message
+      end
+
+      private
+
+      attr_accessor :code, :should_clean_values, :buffer
+
+      def remove_whitespace_preceeding_comments(buffer, rewriter, removed_comments)
+        removed_comments[:result].each    { |comment| remove_whitespace_before comment.location.expression.begin_pos, buffer, rewriter, false }
+        removed_comments[:exception].each { |comment| remove_whitespace_before comment.location.expression.begin_pos, buffer, rewriter, true  }
+        removed_comments[:stdout].each    { |comment| remove_whitespace_before comment.location.expression.begin_pos, buffer, rewriter, true  }
+        removed_comments[:stderr].each    { |comment| remove_whitespace_before comment.location.expression.begin_pos, buffer, rewriter, true  }
+      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/binary/comment_formatter.rb

@@ -0,0 +1,55 @@
+class SeeingIsBelieving
+  class Binary
+    class CommentFormatter
+      def self.call(*args)
+        new(*args).call
+      end
+
+      def initialize(line_length, separator, result, options)
+       self.line_length = line_length
+       self.separator   = separator
+       self.result      = result.gsub "\n", '\n'
+       self.options     = options
+      end
+
+      def call
+        @formatted ||= begin
+          formatted = truncate "#{separator}#{result}", max_result_length
+          formatted = "#{' '*padding_length}#{formatted}"
+          formatted = truncate formatted, max_line_length
+          formatted = '' unless formatted.sub(/^ */, '').start_with? separator
+          formatted
+        end
+      end
+
+      private
+
+      attr_accessor :line_length, :separator, :result, :options
+
+      def max_line_length
+        length = options.fetch(:max_line_length, Float::INFINITY) - line_length
+        length = 0 if length < 0
+        length
+      end
+
+      def max_result_length
+        options.fetch :max_result_length, Float::INFINITY
+      end
+
+      def padding_length
+        padding_length = options.fetch(:pad_to, 0) - line_length
+        padding_length = 0 if padding_length < 0
+        padding_length
+      end
+
+      def truncate(string, length)
+        return string if string.size <= length
+        ellipsify string.slice(0, length)
+      end
+
+      def ellipsify(string)
+        string.sub(/.{0,3}$/) { |last_chars| last_chars.gsub /./, '.' }
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/comment_lines.rb

@@ -0,0 +1,37 @@
+require 'seeing_is_believing/binary/commentable_lines'
+
+class SeeingIsBelieving
+  class 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(code, &commenter)
+        new(code, &commenter).call
+      end
+
+      def initialize(code, &commenter)
+        self.code, self.commenter = code, commenter
+      end
+
+      def call
+        @call ||= begin
+          commentable_lines = CommentableLines.new 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 && code[first_index-1] != "\n"
+            comment_text = commenter.call 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 :code, :commenter
+    end
+  end
+end

data/lib/seeing_is_believing/binary/commentable_lines.rb

@@ -0,0 +1,158 @@
+require 'parser/current'
+
+class SeeingIsBelieving
+  class Binary
+
+    class CommentableLines
+      def self.call(code)
+        new(code).call
+      end
+
+      def initialize(code)
+        self.code = code
+      end
+
+      def call
+        @call ||= begin
+          line_num_to_indexes = line_nums_to_last_index_and_col(buffer)
+          remove_lines_after_data_segment           line_num_to_indexes
+          remove_lines_whose_newline_is_escaped     line_num_to_indexes
+          remove_lines_ending_in_comments           line_num_to_indexes, comments
+          remove_lines_inside_of_strings_and_things line_num_to_indexes, root
+          line_num_to_indexes
+        end
+      end
+
+      def buffer
+        @buffer ||= Parser::Source::Buffer.new("strip_comments").tap { |b| b.source = code }
+      end
+
+      def rewriter
+        @rewriter ||= Parser::Source::Rewriter.new(buffer)
+      end
+
+      private
+
+      attr_accessor :code
+
+      def parser
+        @parser ||= Parser::CurrentRuby.new
+      end
+
+      def root
+        parse!
+        @root
+      end
+
+      def comments
+        parse!
+        @comments
+      end
+
+
+      def parse!
+        return if @root
+        @root, @comments = parser.parse_with_comments(buffer)
+      end
+
+      def line_nums_to_last_index_and_col(buffer)
+        line_num_to_indexes = code.each_char
+                                  .with_index
+                                  .select { |char, index| char == "\n" } # <-- is this okay? what about other OSes?
+                                  .each_with_object(Hash.new) do |(_, index), hash|
+                                    line, col = buffer.decompose_position index
+                                    hash[line] = [index, col]
+                                  end
+        if code[code.size-1] != "\n" # account for the fact that the last line wouldn't have been found above if it doesn't end in a newline
+          line, col = buffer.decompose_position code.size
+          line_num_to_indexes[line] = [code.size, col]
+        end
+        line_num_to_indexes
+      end
+
+      def remove_lines_whose_newline_is_escaped(line_num_to_indexes)
+        line_num_to_indexes.select { |line_number, (index_of_newline, col)| code[index_of_newline-1] == '\\' }
+                           .each   { |line_number, (index_of_newline, col)| line_num_to_indexes.delete line_number }
+      end
+
+      def remove_lines_ending_in_comments(line_num_to_indexes, comments)
+        comments.each do |comment|
+          if comment.type == :inline
+            line_num_to_indexes.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_indexes.select { |line_number, (index_of_newline, col)| range.include? index_of_newline }
+                               .each   { |line_number, (index_of_newline, col)| line_num_to_indexes.delete line_number }
+          end
+        end
+      end
+
+      def remove_lines_inside_of_strings_and_things(line_num_to_indexes, ast)
+        invalid_boundaries = ranges_of_atomic_expressions ast, []
+        invalid_boundaries.each do |invalid_boundary|
+          line_num_to_indexes.select { |line_number, (index_of_newline, col)| invalid_boundary.include? index_of_newline }
+                             .each   { |line_number, (index_of_newline, col)| line_num_to_indexes.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) && heredoc?(ast)
+          begin_pos  = ast.location.expression.begin.begin_pos
+          begin_pos += (ast.location.expression.source =~ /\n/).next
+          end_pos    = ast.location.expression.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
+
+      # copy/pasted from wrap_expressions
+      def heredoc?(ast)
+        # some strings are fucking weird.
+        # e.g. the "1" in `%w[1]` returns nil for ast.location.begin
+        # and `__FILE__` is a string whose location is a Parser::Source::Map instead of a Parser::Source::Map::Collection, so it has no #begin
+        ast.kind_of?(Parser::AST::Node)           &&
+          (ast.type == :dstr || ast.type == :str) &&
+          (location  = ast.location)              &&
+          (location.respond_to?(:begin))          &&
+          (the_begin = location.begin)            &&
+          (the_begin.source =~ /^\<\<-?/)
+      end
+
+      def remove_lines_after_data_segment(line_num_to_indexes)
+        data_segment_line, _ = line_num_to_indexes.find do |line_number, (end_index, col)|
+          if end_index == 7
+            code.start_with? '__END__'
+          elsif end_index < 7
+            false
+          else
+            code[(end_index-8)...end_index] == "\n__END__"
+          end
+        end
+        return unless data_segment_line
+        max_line = line_num_to_indexes.keys.max
+        data_segment_line.upto(max_line) { |line_number| line_num_to_indexes.delete line_number }
+      end
+    end
+  end
+end