andyw8-seeing_is_believing 4.2.0

data/lib/seeing_is_believing/binary/format_comment.rb

@@ -0,0 +1,79 @@
+# Polyfill String#scrub on Ruby 2.0.0
+require 'seeing_is_believing/compatibility'
+using SeeingIsBelieving::Compatibility
+
+class SeeingIsBelieving
+  module Binary
+    # not sure I like this name, it formats comments that show results
+    # e.g. "# => [1, 2, 3]"
+    #
+    # line_length is the length of the line this comment is being appended to
+    #
+    # For examples of what the options are, and how they all fit together, see
+    # spec/binary/format_comment.rb
+    class FormatComment
+      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
+        self.options     = options
+      end
+
+      def call
+        @formatted ||= begin
+          formatted = escape_non_printable result, chars_not_to_escape
+          formatted = truncate "#{separator}#{formatted}", 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.size }
+      end
+
+      def chars_not_to_escape
+        options.fetch :dont_escape, []
+      end
+
+      def escape_non_printable(str, omissions)
+        str.scrub { |c| c.inspect[1...-1] }
+           .gsub(/[\u0000-\u0020]/) { |char|
+              next char if omissions.include? char
+              char.inspect[1...-1]
+           }
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/interline_align.rb

@@ -0,0 +1,57 @@
+class SeeingIsBelieving
+  module Binary
+    class InterlineAlign
+      def initialize(results)
+        @results        = results
+        @format_strings = {}
+      end
+
+      def call(lineno, results)
+        format_string_for_line(lineno) % results
+      end
+
+      private
+
+      attr_accessor :results
+
+      def format_string_for_line(lineno)
+        group = groups_with_same_number_of_results(@results)[lineno]
+        format_string_for(results, group, lineno)
+      end
+
+      def groups_with_same_number_of_results(results)
+        @grouped_by_no_results ||= begin
+          length = 0
+          groups = 1.upto(results.num_lines)
+                    .slice_before { |num|
+                      new_length = results[num].length
+                      slice      = length != new_length
+                      length     = new_length
+                      slice
+                    }.to_a
+
+          groups.each_with_object Hash.new do |group, lineno_to_group|
+            group.each { |lineno| lineno_to_group[lineno] = group }
+          end
+        end
+      end
+
+      def format_string_for(results, group, lineno)
+        @format_strings[lineno] ||= begin
+          index = group.index lineno
+          group
+            .map { |lineno| results[lineno] }
+            .transpose
+            .map { |col|
+              lengths = col.map(&:length)
+              max     = lengths.max
+              crnt    = lengths[index]
+              "%-#{crnt}s,#{" "*(max-crnt)} "
+            }
+            .join
+            .sub(/, *$/, "")
+        end
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/remove_annotations.rb

@@ -0,0 +1,113 @@
+require 'seeing_is_believing/binary' # Defines the regexes to locate the markers
+require 'seeing_is_believing/code'   # We have to parse the file to find the comments
+
+class SeeingIsBelieving
+  module Binary
+    class RemoveAnnotations
+      def self.call(raw_code, remove_value_prefixes, markers)
+        new(raw_code, remove_value_prefixes, markers).call
+      end
+
+      def initialize(raw_code, remove_value_prefixes, markers)
+        self.remove_value_prefixes = remove_value_prefixes
+        self.raw_code              = raw_code
+        self.markers               = markers
+        self.code                  = Code.new(raw_code, 'strip_comments')
+      end
+
+      def call
+        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
+          }
+
+          case comment.text
+          when value_regex
+            if remove_value_prefixes
+              code.rewriter.remove comment.comment_range
+              remove_whitespace_before comment.comment_range.begin_pos, code.buffer, code.rewriter, false
+            else
+              prefix = comment.text[value_regex].rstrip
+              code.rewriter.replace comment.comment_range, prefix
+            end
+          when exception_regex
+            code.rewriter.remove comment.comment_range
+            remove_whitespace_before comment.comment_range.begin_pos, code.buffer, code.rewriter, true
+          when stdout_regex
+            code.rewriter.remove comment.comment_range
+            remove_whitespace_before comment.comment_range.begin_pos, code.buffer, code.rewriter, true
+          when stderr_regex
+            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
+
+        code.rewriter.process
+      end
+
+      private
+
+      attr_accessor :raw_code, :remove_value_prefixes, :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
+      # if there is a newline before all of that, and remove_preceding_newline is true, it will be removed as well
+      def remove_whitespace_before(index, buffer, rewriter, remove_preceding_newline)
+        end_pos   = index
+        begin_pos = end_pos - 1
+        begin_pos -= 1 while 0 <= begin_pos && raw_code[begin_pos] =~ /\s/ && raw_code[begin_pos] != "\n"
+        begin_pos -= 1 if 0 <= begin_pos && raw_code[begin_pos] == "\n"
+        begin_pos -= 1 if remove_preceding_newline && 0 <= begin_pos && raw_code[begin_pos] == "\n"
+        return if begin_pos.next == end_pos
+        rewriter.remove code.range_for(begin_pos.next, end_pos)
+      end
+
+      def annotation_chunks_in(code)
+        code
+          .inline_comments
+          .map { |comment| # associate each annotation to its comment
+            annotation = comment.text[value_regex]     ||
+                         comment.text[exception_regex] ||
+                         comment.text[stdout_regex]    ||
+                         comment.text[stderr_regex]
+            [annotation, comment]
+          }
+          .slice_before { |annotation, comment| annotation }    # annotations 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|
+              sequential                   = (prev.line_number.next == potential_nextline.line_number)
+              vertically_aligned           = start.text_col == potential_nextline.text_col
+              only_preceded_by_whitespace  = potential_nextline.whitespace_col.zero?
+              indention_matches_annotation = annotation.length <= potential_nextline.text[/#\s*/].length
+              break unless sequential && vertically_aligned && only_preceded_by_whitespace && indention_matches_annotation
+              nextline_comments << potential_nextline
+              prev = potential_nextline
+            }
+            [start, nextline_comments]
+          }
+      end
+
+      def value_regex
+        @value_regex ||= markers.fetch(:value).fetch(:regex)
+      end
+
+      def exception_regex
+        @exception_regex ||= markers.fetch(:exception).fetch(:regex)
+      end
+
+      def stdout_regex
+        @stdout_regex ||= markers.fetch(:stdout).fetch(:regex)
+      end
+
+      def stderr_regex
+        @stderr_regex ||= markers.fetch(:stderr).fetch(:regex)
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/rewrite_comments.rb

@@ -0,0 +1,62 @@
+require 'seeing_is_believing/code'
+require 'seeing_is_believing/binary/commentable_lines'
+
+class SeeingIsBelieving
+  module Binary
+    # can this be joined into CommentLines?
+    # that one yields every commentable line, this one just lines which have comments
+    # what they yield is a little different, too, but their algorithms and domain are very similar
+    module RewriteComments
+      Options = HashStruct.anon do
+        attribute(:include_lines) { [] }
+      end
+
+      def self.call(raw_code, options={}, &mapping)
+        code        = Code.new(raw_code)
+        comments    = code.inline_comments
+        extra_lines = Options.new(options).include_lines
+
+        # update existing comments
+        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
+
+        # remove extra lines that are handled / uncommentable
+        comments.each { |c| extra_lines.delete c.line_number }
+        commentable_linenums = CommentableLines.call(code.raw).map { |linenum, *| linenum }
+        extra_lines.select! { |linenum| commentable_linenums.include? linenum }
+
+        # add additional comments
+        extra_lines.each do |line_number|
+          line_begin_col     = code.linenum_to_index(line_number)
+          nextline_begin_col = code.linenum_to_index(line_number.next)
+          nextline_begin_col -= 1 if code.raw[nextline_begin_col-1] == "\n"
+          whitespace_col     = nextline_begin_col-1
+          whitespace_col     -= 1 while line_begin_col < whitespace_col &&
+                                        code.raw[whitespace_col] =~ /\s/
+          whitespace_col += 1
+          whitespace_range = code.range_for(whitespace_col, nextline_begin_col)
+          comment_range = code.range_for(nextline_begin_col, nextline_begin_col)
+
+          comment = Code::InlineComment.new \
+            line_number:      line_number,
+            whitespace_col:   whitespace_col-line_begin_col,
+            whitespace:       code.raw[whitespace_col...nextline_begin_col]||"",
+            text_col:         nextline_begin_col-line_begin_col,
+            text:             "",
+            full_range:       whitespace_range,
+            whitespace_range: whitespace_range,
+            comment_range:    comment_range
+
+          whitespace, body = mapping.call comment
+          code.rewriter.replace whitespace_range, "#{whitespace}#{body}"
+        end
+
+        # perform the rewrite
+        code.rewriter.process
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary.rb

@@ -0,0 +1,73 @@
+require 'seeing_is_believing'
+require 'seeing_is_believing/binary/config'
+require 'seeing_is_believing/binary/engine'
+
+class SeeingIsBelieving
+  module Binary
+    SUCCESS_STATUS              = 0
+    DISPLAYABLE_ERROR_STATUS    = 1 # e.g. user code raises an exception (we can display this in the output)
+    NONDISPLAYABLE_ERROR_STATUS = 2 # e.g. SiB was invoked incorrectly
+
+    def self.call(argv, stdin, stdout, stderr)
+      config = Config.new.parse_args(argv).finalize(stdin, stdout, stderr, File)
+      engine = Engine.new config
+
+      if config.print_help?
+        stdout.puts config.help_screen
+        return SUCCESS_STATUS
+      end
+
+      if config.print_version?
+        stdout.puts SeeingIsBelieving::VERSION
+        return SUCCESS_STATUS
+      end
+
+      if config.errors.any?
+        stderr.puts(*config.errors, *config.deprecations)
+        return NONDISPLAYABLE_ERROR_STATUS
+      end
+
+      if config.print_cleaned?
+        stdout.print engine.cleaned_body
+        return SUCCESS_STATUS
+      end
+
+      if config.toggle_mark?
+        stdout.print engine.toggled_mark
+        return SUCCESS_STATUS
+      end
+
+      if engine.syntax_error?
+        stderr.puts engine.syntax_error
+        return NONDISPLAYABLE_ERROR_STATUS
+      end
+
+      engine.evaluate!
+
+      if engine.timed_out?
+        stderr.puts "Timeout Error after #{engine.timeout_seconds} seconds!"
+        return NONDISPLAYABLE_ERROR_STATUS
+      end
+
+      if config.result_as_json?
+        require 'json'
+        stdout.puts JSON.dump(engine.result.as_json)
+        return SUCCESS_STATUS
+      elsif config.print_event_stream?
+        # no op, the event stream handler has been printing it all along
+      elsif config.debug?
+        config.debugger.context("OUTPUT") { engine.annotated_body }
+      else
+        stdout.print engine.annotated_body
+      end
+
+      if config.inherit_exitstatus?
+        engine.exitstatus
+      elsif engine.exitstatus.zero?
+        SUCCESS_STATUS
+      else
+        DISPLAYABLE_ERROR_STATUS
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/code.rb

@@ -0,0 +1,139 @@
+# With new versioning, there's lots of small versions
+# we don't need Parser to complain that we're on 2.1.1 and its parsing 2.1.5
+# https://github.com/whitequark/parser/blob/e2249d7051b1adb6979139928e14a81bc62f566e/lib/parser/current.rb#L3
+class << (Parser ||= Module.new)
+  def warn(*) end
+  require 'parser/current'
+  remove_method :warn
+end
+
+require 'set'
+require 'seeing_is_believing/hash_struct'
+
+class SeeingIsBelieving
+  class Code
+    InlineComment = HashStruct.for :line_number, :whitespace_col, :whitespace, :text_col, :text, :full_range, :whitespace_range, :comment_range
+    Syntax = HashStruct.for error_message: nil, line_number: nil do
+      def valid?()   !error_message end
+      def invalid?() !valid?        end
+    end
+
+    attr_reader :raw, :buffer, :parser, :rewriter, :inline_comments, :root, :raw_comments, :syntax, :body_range
+
+    def initialize(raw_code, name=nil)
+      raw_code[-1] == "\n" || raise(SyntaxError, "Code must end in a newline for the sake of consistency (sanity)")
+      @raw             = raw_code
+      @buffer          = Parser::Source::Buffer.new(name||"SeeingIsBelieving")
+      @buffer.source   = raw
+      @rewriter        = Parser::Source::TreeRewriter.new buffer
+      builder          = Parser::Builders::Default.new.tap { |b| b.emit_file_line_as_literals = false }
+      @parser          = Parser::CurrentRuby.new builder
+      @syntax          = Syntax.new
+      parser.diagnostics.consumer = lambda do |diagnostic|
+        if :fatal == diagnostic.level || :error == diagnostic.level
+          @syntax = Syntax.new error_message: diagnostic.message, line_number: index_to_linenum(diagnostic.location.begin_pos)
+        end
+      end
+      @root, @raw_comments, @tokens = parser.tokenize(@buffer, true)
+      @body_range                   = body_range_from_tokens(@tokens)
+      @inline_comments              = raw_comments.select(&:inline?).map { |c| wrap_comment c }
+      @root                       ||= null_node
+    end
+
+    def range_for(start_index, end_index)
+      Parser::Source::Range.new buffer, start_index, end_index
+    end
+
+    def index_to_linenum(char_index)
+      line_indexes.index { |line_index| char_index < line_index } || line_indexes.size
+    end
+
+    def linenum_to_index(line_num)
+      return raw.size if line_indexes.size < line_num
+      line_indexes[line_num - 1]
+    end
+
+    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.kind_of? Parser::Source::Map::Heredoc)
+    end
+
+    def void_value?(ast)
+      case ast && ast.type
+      when :begin, :kwbegin, :resbody
+        void_value?(ast.children.last)
+      when :rescue, :ensure
+        ast.children.any? { |child| void_value? child }
+      when :if
+        void_value?(ast.children[1]) || void_value?(ast.children[2])
+      when :return, :next, :redo, :retry, :break
+        true
+      else
+        false
+      end
+    end
+
+    def line_indexes
+      @line_indexes ||= [ 0,
+                          *raw.each_char
+                              .with_index(1)
+                              .select { |char, index| char == "\n" }
+                              .map    { |char, index| index },
+                        ].freeze
+    end
+
+    def indexes_of_ors_at_eol
+      Set.new(
+        @tokens.select { |type, *| type == :tGVAR }
+               .select { |_, (var, _range)| var == '$\\'.freeze }
+               .map    { |_, (_var, range)| range.end_pos }
+      )
+    end
+
+    private
+
+    def comments_and_tokens(builder, buffer)
+      parser = Parser::CurrentRuby.new builder
+      _, all_comments, tokens = parser.tokenize(@buffer, true)
+      [all_comments, tokens]
+    end
+
+    def body_range_from_tokens(tokens)
+      return range_for(0, 0) if raw.start_with? "__END__\n"
+      (name, (_, range)) = tokens.max_by { |name, (_data, range)| range.end_pos } ||
+                            [nil, [nil, range_for(0, 1)]]
+      end_pos = range.end_pos
+      end_pos += 1 if name == :tCOMMENT || name == :tSTRING_END || name == :tSEMI
+      range_for 0, end_pos
+    end
+
+    def wrap_comment(comment)
+      last_char  = comment.location.expression.begin_pos
+      first_char = last_char
+      first_char -= 1 while first_char > 0 && raw[first_char-1] =~ /[ \t]/
+      preceding_whitespace        = buffer.source[first_char...last_char]
+      preceding_whitespace_range  = range_for first_char, last_char
+
+      InlineComment.new line_number:      comment.location.line,
+                        whitespace_col:   preceding_whitespace_range.column,
+                        whitespace:       preceding_whitespace,
+                        text_col:         comment.location.column,
+                        text:             comment.text,
+                        full_range:       range_for(first_char, comment.location.expression.end_pos),
+                        whitespace_range: preceding_whitespace_range,
+                        comment_range:    comment.location.expression
+    end
+
+    def null_node
+      location = Parser::Source::Map::Collection.new nil, nil, range_for(0, 0)
+      Parser::AST::Node.new :null_node, [], location: location
+    end
+
+  end
+end

data/lib/seeing_is_believing/compatibility.rb

@@ -0,0 +1,28 @@
+class SeeingIsBelieving
+  module Compatibility
+  end
+end
+
+# Ruby 2.0.0 is soooooo painful >.<
+# want to stop supporting this so bad!!
+is_v2_0 = !String.instance_methods.include?(:scrub)
+
+is_v2_0 && begin
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  module SeeingIsBelieving::Compatibility
+    refine String do
+      def scrub(char=nil, &block)
+        char && block = lambda { |c| char }
+        each_char.inject("") do |new_str, char|
+          if char.valid_encoding?
+            new_str << char
+          else
+            new_str << block.call(char)
+          end
+        end
+      end
+    end
+  end
+ensure
+  $VERBOSE = old_verbose
+end

data/lib/seeing_is_believing/debugger.rb

@@ -0,0 +1,32 @@
+class SeeingIsBelieving
+  class Debugger
+    CONTEXT_COLOUR = "\e[37;44m" # background blue
+    RESET_COLOUR   = "\e[0m"
+
+    def initialize(options={})
+      @coloured = options[:colour]
+      @stream   = options[:stream]
+    end
+
+    Null = new stream: nil
+
+    def coloured?
+      @coloured
+    end
+
+    attr_reader :stream
+    alias enabled? stream
+
+    def context(name, &block)
+      if enabled?
+        stream << CONTEXT_COLOUR if coloured?
+        stream << "#{name}:"
+        stream << RESET_COLOUR   if coloured?
+        stream << "\n"
+        stream << block.call.to_s << "\n" if block
+      end
+      self
+    end
+  end
+
+end

data/lib/seeing_is_believing/error.rb

@@ -0,0 +1,17 @@
+class SeeingIsBelieving
+  # All our errors will inherit from this so that a user can catch any error generated by this lib
+  SeeingIsBelievingError = Class.new StandardError
+
+  class TempFileAlreadyExists < SeeingIsBelievingError
+    def initialize(from_filename, backup_filename)
+      super "Trying to back up #{from_filename.inspect} (FILE) to"\
+            " #{backup_filename.inspect} (TEMPFILE) but TEMPFILE already exists."\
+            " You should check the contents of these files. If FILE is correct,"\
+            " then delete TEMPFILE. Otherwise rename TEMPFILE to FILE."
+    end
+  end
+
+  # EventStream
+  NoMoreEvents       = Class.new SeeingIsBelievingError
+  UnknownEvent       = Class.new SeeingIsBelievingError
+end