seeing_is_believing 2.2.0 → 3.0.0.beta.1

data/lib/seeing_is_believing/binary/parse_args.rb

@@ -1,146 +1,140 @@
 # encoding: utf-8
 
-require 'stringio'
-require 'seeing_is_believing/version'
-require 'seeing_is_believing/binary'
-require 'seeing_is_believing/debugger'
-require 'seeing_is_believing/binary/align_file'
-require 'seeing_is_believing/binary/align_line'
-require 'seeing_is_believing/binary/align_chunk'
+require 'seeing_is_believing/version' # We print the version in the output
 
 class SeeingIsBelieving
-  class Binary
+  module Binary
     class ParseArgs
-      def self.call(args, outstream)
-        new(args, outstream).call
+      def self.default_markers
+        { value:     '# => ',
+          exception: '# ~> ',
+          stdout:    '# >> ',
+          stderr:    '# !> ',
+          nextline:  '#    ',
+        }
+      end
+
+      def self.call(args)
+        new(args).call
       end
 
-      def initialize(args, outstream)
-        self.args      = args
-        self.filenames = []
-        self.outstream = outstream
+      def initialize(args)
+        self.args = args.dup
       end
 
       def call
         @result ||= begin
           until args.empty?
             case (arg = args.shift)
-            when '-h',  '--help'                then options[:help]                = self.class.help_screen(false)
-            when '-h+', '--help+'               then options[:help]                = self.class.help_screen(true)
-            when '-c',  '--clean'               then options[:clean]               = true
-            when '-v',  '--version'             then options[:version]             = true
-            when '-x',  '--xmpfilter-style'     then options[:xmpfilter_style]     = true
-            when '-i',  '--inherit-exit-status' then options[:inherit_exit_status] = true
-            when '-j',  '--json'                then options[:result_as_json]      = true
-            when '-g',  '--debug'               then options[:debugger]            = Debugger.new(stream: outstream, 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 '-h',  '--help'                then flags[:help]                = 'help'
+            when '-h+', '--help+'               then flags[:help]                = 'help+'
+            when '-c',  '--clean'               then flags[:clean]               = true
+            when '-v',  '--version'             then flags[:version]             = true
+            when '-x',  '--xmpfilter-style'     then flags[:xmpfilter_style]     = true
+            when '-i',  '--inherit-exit-status' then flags[:inherit_exit_status] = true
+            when '-j',  '--json'                then flags[:result_as_json]      = true
+            when '-g',  '--debug'               then flags[:debug]               = true
+            when        '--safe'                then flags[:safe]                = true
             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 '-n',  '--number-of-captures'  then extract_positive_int_for :number_of_captures, 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        '--shebang'             then next_arg("#{arg} expects a ruby executable as the following argument but did not see one") { |executable| options[:shebang]   =  executable }
-            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 }
-            when /^-/                          then options[:errors] << "Unknown option: #{arg.inspect}" # unknown flags
+            when '-r',  '--require'             then next_arg("#{arg} expected a filename as the following argument but did not see one")       { |filename|   flags[:require]           << filename }
+            when '-I',  '--load-path'           then next_arg("#{arg} expected a directory as the following argument but did not see one")      { |dir|        flags[:load_path]         << dir }
+            when '-e',  '--program'             then next_arg("#{arg} expected a program as the following argument but did not see one")        { |program|    flags[:program_from_args] =  program }
+            when '-a',  '--as'                  then next_arg("#{arg} expected a filename as the following argument but did not see one")       { |filename|   flags[:as]                =  filename }
+            when        '--shebang'             then next_arg("#{arg} expects a ruby executable as the following argument but did not see one") { |executable| flags[:shebang]           =  executable }
+            when '-s',  '--alignment-strategy'  then flags[:alignment_strategy] = args.shift
+            when /\A-K(.+)/                     then flags[:encoding] = $1
+            when '-K', '--encoding'             then next_arg("#{arg} expects an encoding, see `man ruby` for possibile values") { |encoding| flags[:encoding] = encoding }
+            when /^(-.|--.*)$/                  then flags[:errors] << "Unknown option: #{arg.inspect}" # unknown flags
+            when /^-[^-]/                       then args.unshift *normalize_shortflags(arg)
             else
-              filenames << arg
-              options[:filename] = arg
+              flags[:filenames] << arg
+              flags[:filename] = arg
             end
           end
-          normalize_and_validate
-          options
+          flags
         end
       end
 
-      private
 
-      attr_accessor :filenames, :args, :outstream
 
+      private
 
-      def normalize_and_validate
-        if 1 < filenames.size
-          options[:errors] << "Can only have one filename, but had: #{filenames.map(&:inspect).join ', '}"
-        elsif filenames.any? && options[:program]
-          options[:errors] << "You passed the program in an argument, but have also specified the filename #{filenames.first.inspect}"
-        end
-
-        if options[:end_line] < options[:start_line]
-          options[:start_line], options[:end_line] = options[:end_line], options[:start_line]
-        end
-      end
+      attr_accessor :args
 
-      def options
-        @options ||= {
-          debugger:            Debugger.new(stream: nil),
+      def flags
+        @flags ||= {
+          as:                  nil,
+          filenames:           [],
+          help:                nil,
+          encoding:            nil,
+          debug:               false,
           version:             false,
           clean:               false,
           xmpfilter_style:     false,
           inherit_exit_status: false,
-          program:             nil,
+          program_from_args:   nil,
           filename:            nil,
-          start_line:          1,
-          end_line:            Float::INFINITY,
           max_line_length:     Float::INFINITY,
           max_result_length:   Float::INFINITY,
           number_of_captures:  Float::INFINITY,
           timeout:             0, # timeout lib treats this as infinity
           errors:              [],
-          require:             [],
+          require:             ['seeing_is_believing/the_matrix'],
           load_path:           [],
-          alignment_strategy:  AlignChunk,
+          alignment_strategy:  'chunk',
           shebang:             'ruby',
           result_as_json:      false,
+          markers:             self.class.default_markers,
+          short_help_screen:   self.class.help_screen(false),
+          long_help_screen:    self.class.help_screen(true),
+          safe:                false,
         }
       end
 
-
-      def extract_alignment_strategy
-        strategies = {
-          'file'  => AlignFile,
-          'chunk' => AlignChunk,
-          'line'  => AlignLine,
-        }
-        next_arg "alignment-strategy expected an alignment strategy as the following argument but did not see one" do |strategy_name|
-          if strategies[strategy_name]
-            options[:alignment_strategy] = strategies[strategy_name]
-          else
-            options[:errors] << "alignment-strategy does not know #{strategy_name}, only knows: #{strategies.keys.join(', ')}"
-          end
+      def normalize_shortflags(consolidated_shortflag)
+        shortflags = consolidated_shortflag[1..-1].chars.to_a # to_a for 1.9.3 -.-
+        plusidx    = shortflags.index('+') || 0
+        if 0 < plusidx
+          shortflags[plusidx-1] << '+'
+          shortflags.delete_at plusidx
         end
+        shortflags.map { |flag| "-#{flag}" }
       end
 
       def next_arg(error_message, &success_block)
         arg = args.shift
-        arg ? success_block.call(arg) : (options[:errors] << error_message)
+        arg ? success_block.call(arg) : (flags[:errors] << error_message)
       end
 
       def extract_positive_int_for(key, flag)
         string = args.shift
         int    = string.to_i
         if int.to_s == string && 0 < int
-          options[key] = int
+          flags[key] = int
         else
-          options[:errors] << "#{flag} expects a positive integer argument"
+          flags[:errors] << "#{flag} expects a positive integer argument"
         end
       end
 
       def extract_non_negative_float_for(key, flag)
         float = Float args.shift
         raise if float < 0
-        options[key] = float
+        flags[key] = float
       rescue
-        options[:errors] << "#{flag} expects a positive float or integer argument"
+        flags[:errors] << "#{flag} expects a positive float or integer argument"
       end
-
     end
 
-    def ParseArgs.help_screen(include_examples)
+    def ParseArgs.help_screen(include_examples, markers=default_markers)
+      value_marker     = markers.fetch(:value)
+      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]
 
@@ -148,10 +142,8 @@ Usage: seeing_is_believing [options] [filename]
 
   If no filename is provided, the binary will read the program from standard input.
 
-  -l,  --start-line n            # line number to begin showing results on
-  -L,  --end-line n              # line number to stop showing results on
   -d,  --line-length n           # max length of the entire line (only truncates results, not source lines)
-  -D,  --result-length n         # max length of the portion after the "#{VALUE_MARKER}"
+  -D,  --result-length n         # max length of the portion after the "#{value_marker}"
   -n,  --number-of-captures n    # how many results to capture for a given line
                                    if you had 1 million results on a line, it could take a long time to record
                                    and serialize them, you might limit it to 1000 results as an optimization
@@ -180,53 +172,53 @@ Examples: A few examples, for a more comprehensive set of examples, check out fe
 
   Run the file f.rb
     $ echo __FILE__ > f.rb; seeing_is_believing f.rb
-    __FILE__  #{VALUE_MARKER}"f.rb"
+    __FILE__  #{value_marker}"f.rb"
 
   Aligning comments
     $ ruby -e 'puts "123\\n4\\n\\n567890"' > f.rb
 
 
     $ seeing_is_believing f.rb -s line
-    123  #{VALUE_MARKER}123
-    4  #{VALUE_MARKER}4
+    123  #{value_marker}123
+    4  #{value_marker}4
 
-    567890  #{VALUE_MARKER}567890
+    567890  #{value_marker}567890
 
 
     $ seeing_is_believing f.rb -s chunk
-    123  #{VALUE_MARKER}123
-    4    #{VALUE_MARKER}4
+    123  #{value_marker}123
+    4    #{value_marker}4
 
-    567890  #{VALUE_MARKER}567890
+    567890  #{value_marker}567890
 
 
     $ seeing_is_believing f.rb -s file
-    123     #{VALUE_MARKER}123
-    4       #{VALUE_MARKER}4
+    123     #{value_marker}123
+    4       #{value_marker}4
 
-    567890  #{VALUE_MARKER}567890
+    567890  #{value_marker}567890
 
   Run against standard input
     $ echo '3.times { |i| puts i }' | seeing_is_believing
-    2.times { |i| puts i }  #{VALUE_MARKER}2
+    2.times { |i| puts i }  #{value_marker}2
 
-    #{STDOUT_MARKER}0
-    #{STDOUT_MARKER}1
+    #{stdout_marker}0
+    #{stdout_marker}1
 
   Run against a library you're working on by fixing the load path
     $ seeing_is_believing -I lib f.rb
 
   Load up some library (can be used in tandem with -I)
     $ seeing_is_believing -r pp -e 'pp [[*1..15],[*15..30]]; nil'
-    pp [[*1..15],[*15..30]]; nil  #{VALUE_MARKER}nil
+    pp [[*1..15],[*15..30]]; nil  #{value_marker}nil
 
-    #{STDOUT_MARKER}[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
-    #{STDOUT_MARKER} [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]]
+    #{stdout_marker}[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    #{stdout_marker} [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]]
 
   Only update the lines you've marked
     $ ruby -e 'puts "1\\n2 # =>\\n3"' | seeing_is_believing -x
     1
-    2 #{VALUE_MARKER}2
+    2 #{value_marker}2
     3
 
   Set a timeout (especially useful if running via an editor)
@@ -235,11 +227,11 @@ Examples: A few examples, for a more comprehensive set of examples, check out fe
 
   Set the encoding to utf-8
     $ seeing_is_believing -Ku -e '"⛄ "'
-    "⛄ "  #{VALUE_MARKER}"⛄ "
+    "⛄ "  #{value_marker}"⛄ "
 
   The exit status will be 1 if the error is displayable inline
     $ seeing_is_believing -e 'raise "omg"'; echo $?
-    raise "omg"  #{EXCEPTION_MARKER}RuntimeError: omg
+    raise "omg"  #{exception_marker}RuntimeError: omg
     1
 
   The exit status will be 2 if the error is not displayable
@@ -248,15 +240,15 @@ Examples: A few examples, for a more comprehensive set of examples, check out fe
     2
 
   Run with previous output
-    $ echo "1+1  #{VALUE_MARKER}old-value" | seeing_is_believing
-    1+1  #{VALUE_MARKER}2
+    $ echo "1+1  #{value_marker}old-value" | seeing_is_believing
+    1+1  #{value_marker}2
 
-    $ echo "1+1  #{VALUE_MARKER}old-value" | seeing_is_believing --clean
+    $ echo "1+1  #{value_marker}old-value" | seeing_is_believing --clean
     1+1
 
   If your Ruby binary is named something else (e.g. ruby2.0)
     $ ruby2.0 -S seeing_is_believing --shebang ruby2.0 -e '123'
-    123  #{VALUE_MARKER}123
+    123  #{value_marker}123
 EXAMPLES
     end
   end

data/lib/seeing_is_believing/binary/remove_annotations.rb

@@ -0,0 +1,95 @@
+require 'seeing_is_believing/binary'         # Defines the regexes to locate the markers
+require 'seeing_is_believing/parser_helpers' # We have to parse the file to find the comments
+
+class SeeingIsBelieving
+  module Binary
+    class RemoveAnnotations
+      def self.call(code, should_clean_values, markers)
+        new(code, should_clean_values, markers).call
+      end
+
+      def initialize(code, should_clean_values, markers)
+        self.should_clean_values = should_clean_values
+        self.code                = code
+        self.markers             = markers
+      end
+
+      def call
+        code_obj         = Code.new(code, 'strip_comments')
+        removed_comments = { result: [], exception: [], stdout: [], stderr: [] }
+
+        # 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
+          when exception_regex
+              # puts "REMOVING EXCEPTION: #{comment.text}"
+            removed_comments[:exception] << comment
+            code_obj.rewriter.remove comment.comment_range
+          when stdout_regex
+              # puts "REMOVING STDOUT: #{comment.text}"
+            removed_comments[:stdout] << comment
+            code_obj.rewriter.remove comment.comment_range
+          when stderr_regex
+              # puts "REMOVING STDERR: #{comment.text}"
+            removed_comments[:stderr] << comment
+            code_obj.rewriter.remove comment.comment_range
+          end
+        end
+
+        remove_whitespace_preceding_comments(code_obj.buffer, code_obj.rewriter, removed_comments)
+        code_obj.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
+
+      # 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 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
+        return if begin_pos.next == end_pos
+        rewriter.remove Parser::Source::Range.new(buffer, begin_pos.next, end_pos)
+      end
+
+      def value_regex
+        @value_regex ||= marker_to_regex markers[:value]
+      end
+
+      def exception_regex
+        @exception_regex ||= marker_to_regex markers[:exception]
+      end
+
+      def stdout_regex
+        @stdout_regex ||= marker_to_regex markers[:stdout]
+      end
+
+      def stderr_regex
+        @stderr_regex ||= marker_to_regex markers[:stderr]
+      end
+
+      def marker_to_regex(marker)
+        /\A#{Regexp.escape marker.sub(/\s+$/, '')}/
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/rewrite_comments.rb

@@ -1,38 +1,16 @@
-require 'seeing_is_believing/parser_helpers'
+require 'seeing_is_believing/code'
 
 class SeeingIsBelieving
-  class Binary
+  module Binary
     module RewriteComments
       def self.call(code, &mapping)
-        buffer, parser, rewriter = ParserHelpers.initialize_parser code, 'rewrite_comments'
-        ast, comments  = parser.parse_with_comments buffer
-
-        comments.each do |comment|
-          next unless comment.type == :inline
-          # find whitespace
-          last_char                   = comment.location.expression.begin_pos
-          first_char                  = last_char
-          first_char -= 1 while first_char > 0 && buffer.source[first_char-1] =~ /[ \t]/
-          preceeding_whitespace       = buffer.source[first_char...last_char]
-          preceeding_whitespace_range = Parser::Source::Range.new buffer, first_char, last_char
-
-          # find line
-          last_char = first_char
-          first_char -= 1 while first_char > 0 && buffer.source[first_char-1] !~ /[\r\n]/
-          line = buffer.source[first_char...last_char]
-
-          # get results
-          new_whitespace, new_comment = mapping.call(comment.location.line,
-                                                     line,
-                                                     preceeding_whitespace,
-                                                     comment.text)
-
-          # update code
-          rewriter.replace preceeding_whitespace_range, new_whitespace
-          rewriter.replace comment.location.expression, new_comment
+        code = Code.new(code)
+        code.inline_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
-
-        rewriter.process
+        code.rewriter.process
       end
     end
   end