seeing_is_believing 2.2.0 → 3.0.0.beta.1

data/lib/seeing_is_believing/binary/align_chunk.rb

@@ -1,10 +1,10 @@
 require 'seeing_is_believing/binary/commentable_lines'
 
 class SeeingIsBelieving
-  class Binary
+  module Binary
     class AlignChunk
-      def initialize(body, start_line, end_line)
-        self.body, self.start_line, self.end_line = body, start_line, end_line
+      def initialize(body)
+        self.body = body
       end
 
       # max line length of the the chunk (newline separated sections of code exempting comments) + 2 spaces for padding
@@ -14,7 +14,7 @@ class SeeingIsBelieving
 
       private
 
-      attr_accessor :body, :start_line, :end_line
+      attr_accessor :body
 
       def line_lengths
         @line_lengths ||= begin
@@ -24,9 +24,7 @@ class SeeingIsBelieving
                  .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
+                   max_chunk_length = 2 + slice.map { |line_num| line_num_to_indexes[line_num].last }.max
                    slice.map { |line_number| [line_number, max_chunk_length] }
                  }
                  .flatten(1)

data/lib/seeing_is_believing/binary/align_file.rb

@@ -1,12 +1,12 @@
 require 'seeing_is_believing/binary/commentable_lines'
 
 class SeeingIsBelieving
-  class Binary
+  module Binary
     class AlignFile
-      attr_accessor :body, :start_line, :end_line
+      attr_accessor :body
 
-      def initialize(body, start_line, end_line)
-        self.body, self.start_line, self.end_line = body, start_line, end_line
+      def initialize(body)
+        self.body = body
       end
 
       # max line length of the lines to output (exempting comments) + 2 spaces for padding
@@ -14,7 +14,6 @@ class SeeingIsBelieving
         @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

data/lib/seeing_is_believing/binary/align_line.rb

@@ -1,10 +1,10 @@
 class SeeingIsBelieving
-  class Binary
+  module Binary
     class AlignLine
-      attr_accessor :body, :start_line, :end_line
+      attr_accessor :body
 
-      def initialize(body, start_line, end_line)
-        self.body, self.start_line, self.end_line = body, start_line, end_line
+      def initialize(body)
+        self.body = body
       end
 
       # length of the line + 2 spaces for padding

data/lib/seeing_is_believing/binary/annotate_end_of_file.rb

@@ -0,0 +1,60 @@
+require 'seeing_is_believing/binary' # defines the markers
+require 'seeing_is_believing/binary/comment_formatter'
+
+class SeeingIsBelieving
+  module Binary
+    module AnnotateEndOfFile
+      extend self
+
+      # TODO: Switch options to markers
+      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)
+
+        # this technically could find an __END__ in a string or whatever
+        # going to just ignore that, though
+        if new_body[/^__END__$/]
+          new_body.sub! "\n__END__", "\n#{output}__END__"
+        else
+          new_body << "\n" unless new_body.end_with? "\n"
+          new_body << output
+        end
+      end
+
+      def stdout_ouptut_for(results, options)
+        return '' unless results.has_stdout?
+        output = "\n"
+        results.stdout.each_line do |line|
+          output << CommentFormatter.call(0, options[:markers][:stdout], 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 << CommentFormatter.call(0, options[:markers][:stderr], line.chomp, options) << "\n"
+        end
+        output
+      end
+
+      def exception_output_for(results, options)
+        return '' unless results.has_exception?
+        exception_marker = options[:markers][:exception]
+        exception = results.exception
+        output = "\n"
+        output << CommentFormatter.new(0, exception_marker, exception.class_name, options).call << "\n"
+        exception.message.each_line do |line|
+          output << CommentFormatter.new(0, exception_marker, line.chomp, options).call << "\n"
+        end
+        output << exception_marker.sub(/\s+$/, '') << "\n"
+        exception.backtrace.each do |line|
+          output << CommentFormatter.new(0, exception_marker, line.chomp, options).call << "\n"
+        end
+        output
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/annotate_every_line.rb

@@ -0,0 +1,64 @@
+class SeeingIsBelieving
+  module Binary
+    class AnnotateEveryLine
+      def self.prepare_body(uncleaned_body, markers)
+        require 'seeing_is_believing/binary/remove_annotations'
+        RemoveAnnotations.call uncleaned_body, true, markers
+      end
+
+      def self.expression_wrapper(markers)
+        require 'seeing_is_believing/inspect_expressions'
+        InspectExpressions
+      end
+
+      def self.call(body, results, options)
+        new(body, results, options).call
+      end
+
+      def initialize(body, results, options={})
+        @options = options
+        @body    = body
+        @results = results
+      end
+
+      def call
+        @new_body ||= begin
+          require 'seeing_is_believing/binary/comment_lines'
+          require 'seeing_is_believing/binary/comment_formatter'
+
+          alignment_strategy = @options[:alignment_strategy].new(@body)
+          exception_lineno   = @results.has_exception? ? @results.exception.line_number : -1
+          new_body = CommentLines.call @body do |line, line_number|
+            options = @options.merge pad_to: alignment_strategy.line_length_for(line_number)
+            if exception_lineno == line_number
+              result = sprintf "%s: %s", @results.exception.class_name, @results.exception.message.gsub("\n", '\n')
+              CommentFormatter.call(line.size, exception_marker, result, options)
+            elsif @results[line_number].any?
+              result  = @results[line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
+              CommentFormatter.call(line.size, value_marker, 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
+
+          # What's w/ this debugger? maybe this should move higher?
+          @options[:debugger].context "OUTPUT"
+          new_body
+        end
+      end
+
+      private
+
+      def value_marker
+        @value_marker ||= @options[:markers][:value]
+      end
+
+      def exception_marker
+        @exception_marker ||= @options[:markers][:exception]
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/annotate_xmpfilter_style.rb

@@ -0,0 +1,133 @@
+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
+
+        require 'seeing_is_believing/binary/remove_annotations'
+        RemoveAnnotations.call partially_cleaned_body, false, markers
+      end
+
+      def self.expression_wrapper(markers)
+        -> 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+$/, '')
+            c.whitespace_col == 0 ? pp_linenos      << c.line_number - 1
+                                  : inspect_linenos << c.line_number
+          end
+
+          InspectExpressions.call program,
+                                  number_of_captures,
+                                  before_all: -> {
+                                    # TODO: this is duplicated with the InspectExpressions class
+                                    number_of_captures_as_str = number_of_captures.inspect
+                                    number_of_captures_as_str = 'Float::INFINITY' if number_of_captures == Float::INFINITY
+                                    "begin; require 'pp'; $SiB.max_line_captures = #{number_of_captures_as_str}; $SiB.num_lines = #{program.lines.count}; "
+                                  },
+                                  after_each: -> line_number {
+                                    should_inspect = inspect_linenos.include?(line_number)
+                                    should_pp      = pp_linenos.include?(line_number)
+                                    inspect        = "$SiB.record_result(:inspect, #{line_number}, v)"
+                                    pp             = "$SiB.record_result(:pp, #{line_number}, v) { PP.pp v, '', 74 }" # TODO: Is 74 the right value? Prob not, I think it's 80(default width) - 1(comment width) - 5(" => {"), but if I allow indented `# => `, then that would need to be less than 74 (idk if I actually do this or not, though :P)
+
+                                    if    should_inspect && should_pp then ").tap { |v| #{inspect}; #{pp} }"
+                                    elsif should_inspect              then ").tap { |v| #{inspect} }"
+                                    elsif should_pp                   then ").tap { |v| #{pp} }"
+                                    else                                   ")"
+                                    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
+      end
+
+      # TODO: I think that this should respect the alignment strategy
+      # and we should just add a new alignment strategy for default xmpfilter style
+      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
+              # 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|
+                if result_offest == 0
+                  CommentFormatter.call(comment.whitespace_col, value_marker, comment_line.chomp, @options)
+                else
+                  CommentFormatter.call(comment.whitespace_col, nextline_marker, comment_line.chomp, @options)
+                end
+              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)]
+            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"
+          new_body
+        end
+      end
+
+      def value_marker
+        @value_marker ||= @options[:markers][:value]
+      end
+
+      def nextline_marker
+        @xnextline_marker ||= @options[:markers][:nextline]
+      end
+
+      def value_regex
+        @value_regex ||= /\A#{value_marker.sub(/\s+$/, '')}/
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/comment_formatter.rb

@@ -1,7 +1,7 @@
 class SeeingIsBelieving
-  class Binary
-    # not sure I like this name, it formats comments that
-    # show results e.g. "# => [1, 2, 3]"
+  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
     #
@@ -15,13 +15,14 @@ class SeeingIsBelieving
       def initialize(line_length, separator, result, options)
        self.line_length = line_length
        self.separator   = separator
-       self.result      = result.gsub "\n", '\n'
+       self.result      = result
        self.options     = options
       end
 
       def call
         @formatted ||= begin
-          formatted = truncate "#{separator}#{result}", max_result_length
+          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
@@ -57,6 +58,19 @@ class SeeingIsBelieving
       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.each_char
+          .map { |char|
+            next char if 0x20 <= char.ord # above this has a printable representation
+            next char if omissions.include? char
+            char.inspect[1...-1]
+          }.join('')
+      end
     end
   end
 end

data/lib/seeing_is_believing/binary/comment_lines.rb

@@ -2,7 +2,7 @@ require 'seeing_is_believing/binary/commentable_lines'
 
 class SeeingIsBelieving
   # spec/binary/comment_lines_spec.rb
-  class Binary
+  module Binary
 
     # takes a body and a block
     # passes the block the line

data/lib/seeing_is_believing/binary/commentable_lines.rb

@@ -1,7 +1,7 @@
 require 'seeing_is_believing/parser_helpers'
 
 class SeeingIsBelieving
-  class Binary
+  module Binary
 
     # could possibly be sped up by just reflecting on the tokens instead of the whole ast
     #

data/lib/seeing_is_believing/binary/interpret_flags.rb

@@ -0,0 +1,149 @@
+# Debugger initialization happens here
+require 'seeing_is_believing/debugger'
+
+# Alignment decision happens here
+require 'seeing_is_believing/binary/align_file'
+require 'seeing_is_believing/binary/align_line'
+require 'seeing_is_believing/binary/align_chunk'
+
+# Evaluator decision happens here
+require 'seeing_is_believing/evaluate_by_moving_files'
+require 'seeing_is_believing/evaluate_with_eval_in'
+
+# Annotator decision happens here
+require 'seeing_is_believing/binary/annotate_every_line'
+require 'seeing_is_believing/binary/annotate_xmpfilter_style'
+
+class SeeingIsBelieving
+  module Binary
+    class InterpretFlags
+      def self.attr_predicate(name)
+        define_method("#{name}?") { predicates.fetch name }
+      end
+      attr_predicate :print_version
+      attr_predicate :inherit_exit_status
+      attr_predicate :result_as_json
+      attr_predicate :print_help
+      attr_predicate :print_cleaned
+      attr_predicate :provided_filename_dne
+      attr_predicate :file_is_on_stdin
+
+      def self.attr_attribute(name)
+        define_method(name) { attributes.fetch name }
+      end
+      attr_attribute :annotator
+      attr_attribute :help_screen
+      attr_attribute :debugger
+      attr_attribute :markers
+      attr_attribute :timeout
+      attr_attribute :shebang
+      attr_attribute :filename
+      attr_attribute :body
+      attr_attribute :annotator_options
+      attr_attribute :prepared_body
+      attr_attribute :lib_options
+      attr_attribute :errors
+
+      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)
+
+        # All predicates
+        self.predicates = {}
+        predicates[:print_version]         = flags.fetch(:version) # TODO: rename rhs to print_version ?
+        predicates[:inherit_exit_status]   = flags.fetch(:inherit_exit_status)
+        predicates[:result_as_json]        = flags.fetch(:result_as_json)
+        predicates[:print_help]            = !!flags.fetch(:help)
+        predicates[:print_cleaned]         = flags.fetch(:clean) # TODO: Better name on rhs
+        predicates[:provided_filename_dne] = !!(filename && !File.exist?(filename)) # TODO: Should this just be an error in errors table?
+        predicates[:file_is_on_stdin]      = (!filename && !flags.fetch(:program_from_args))
+
+        # Polymorphism, y'all!
+        attributes[:annotator]   = (flags.fetch(:xmpfilter_style) ? AnnotateXmpfilterStyle                     : AnnotateEveryLine)
+        attributes[:help_screen] = flags.fetch(:help) == 'help'   ? flags.fetch(:short_help_screen)            : flags.fetch(:long_help_screen)
+        attributes[:debugger]    = flags.fetch(:debug)            ? Debugger.new(stream: stdout, colour: true) : Debugger.new(stream: nil)
+        attributes[:body]        = ((print_version? || print_help?) && String.new)    ||
+                                   flags.fetch(:program_from_args)                    ||
+                                   (file_is_on_stdin? && stdin.read)                  ||
+                                   (File.read filename unless provided_filename_dne?) ||
+                                   String.new
+
+        # Attributes that depend on predicates
+        attributes[:prepared_body] = body && annotator.prepare_body(body, markers)
+
+        # The lib's options (passed to SeeingIsBelieving.new)
+        attributes[:lib_options] = {
+          evaluate_with:      (flags.fetch(:safe) ? EvaluateWithEvalIn : EvaluateByMovingFiles),
+          filename:           (flags.fetch(:as) || filename),
+          ruby_executable:    shebang,
+          stdin:              (file_is_on_stdin? ? '' : stdin),
+          require:            (['seeing_is_believing/the_matrix'] + flags.fetch(:require)), # TODO: rename requires: files_to_require, or :requires or maybe :to_require
+          load_path:          ([File.expand_path('../../..', __FILE__)] + flags.fetch(:load_path)),
+          encoding:           flags.fetch(:encoding),
+          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
+        }
+
+        # The annotator's options (passed to annotator.call)
+        attributes[:annotator_options] = {
+          alignment_strategy: extract_alignment_strategy(flags.fetch(:alignment_strategy), errors),
+          debugger:           debugger,
+          markers:            markers,
+          max_line_length:    flags.fetch(:max_line_length),
+          max_result_length:  flags.fetch(:max_result_length),
+        }
+
+        # Some error checking
+        if 1 < flags.fetch(:filenames).size
+          errors << "Can only have one filename, but had: #{flags.fetch(:filenames).map(&:inspect).join ', '}"
+        elsif filename && flags.fetch(:program_from_args)
+          errors << "You passed the program in an argument, but have also specified the filename #{filename.inspect}"
+        end
+      end
+
+      def inspect
+        inspected = "#<#{self.class.name.inspect}\n"
+        inspected << "  --PREDICATES--\n"
+        predicates.each do |predicate, value|
+          inspected << inspect_line(sprintf "    %-25s %p", predicate.to_s+"?", value)
+        end
+        inspected << "  --ATTRIBUTES--\n"
+        attributes.each do |predicate, value|
+          inspected << inspect_line(sprintf "    %-20s %p", predicate.to_s, value)
+        end
+        inspected << ">"
+        inspected
+      end
+
+      private
+
+      attr_accessor :predicates, :attributes
+
+      def extract_alignment_strategy(strategy_name, errors)
+        strategies = {'file' => AlignFile, 'chunk' => AlignChunk, 'line' => AlignLine}
+        if strategies[strategy_name]
+          strategies[strategy_name]
+        elsif strategy_name
+          errors << "alignment-strategy does not know #{strategy_name}, only knows: #{strategies.keys.join(', ')}"
+        else
+          errors << "alignment-strategy expected an alignment strategy as the following argument but did not see one"
+        end
+      end
+
+      def inspect_line(line)
+        if line.size < 78
+          line << "\n"
+        else
+          line[0, 75] << "...\n"
+        end
+      end
+    end
+  end
+end