seeing_is_believing 0.0.9 → 0.0.10

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    seeing_is_believing (0.0.8)
+    seeing_is_believing (0.0.9)
 
 GEM
   remote: http://rubygems.org/

data/Readme.md

@@ -82,9 +82,11 @@ TextMate Integration
 
 Go to the bundle editor, create this new command in the Ruby bundle:
 
-    "${TM_RUBY}" -r seeing_is_believing/binary -e '
-      SeeingIsBelieving::Binary.new(ARGV, $stdin, $stdout, $stderr).call
-    '  $TM_FILEPATH 2>/dev/null
+```shell
+"${TM_RUBY}" -r seeing_is_believing/binary -e '
+  SeeingIsBelieving::Binary.new(ARGV, $stdin, $stdout, $stderr).call
+'  $TM_FILEPATH 2>/dev/null
+```
 
 It should look like this:
 

data/features/examples.feature

@@ -9,18 +9,20 @@ Feature: Running the binary successfully
   Scenario: Some basic functionality
     Given the file "basic_functionality.rb":
     """
+    # iteration
     5.times do |i|
       i * 2
     end
 
+    # method and invocations
     def meth(n)
       n
     end
 
-    # some invocations
     meth "12"
     meth "34"
 
+    # block style comments
     =begin
     I don't ever actually write
       comments like this
@@ -36,26 +38,43 @@ Feature: Running the binary successfully
     is a doc
     HERE
 
+    # method invocation that occurs entirely on the next line
     [*1..10]
       .select(&:even?)
+
+    # mutliple levels of nesting
+    class User
+      def initialize(name)
+        @name = name
+      end
+
+      def name
+        @name
+      end
+    end
+
+    User.new("Josh").name
+    User.new("Rick").name
     """
     When I run "seeing_is_believing basic_functionality.rb"
     Then stderr is empty
     And the exit status is 0
     And stdout is:
     """
+    # iteration
     5.times do |i|
-      i * 2             # => 0, 2, 4, 6, 8
-    end                 # => 5
+      i * 2                 # => 0, 2, 4, 6, 8
+    end                     # => 5
 
+    # method and invocations
     def meth(n)
-      n                 # => "12", "34"
-    end                 # => nil
+      n                     # => "12", "34"
+    end                     # => nil
 
-    # some invocations
-    meth "12"           # => "12"
-    meth "34"           # => "34"
+    meth "12"               # => "12"
+    meth "34"               # => "34"
 
+    # block style comments
     =begin
     I don't ever actually write
       comments like this
@@ -64,15 +83,30 @@ Feature: Running the binary successfully
     # multilinezzz
     "a
      b
-     c"                 # => "a\n b\n c"
+     c"                     # => "a\n b\n c"
 
     # don't record heredocs b/c they're just too fucking different
     <<HERE
     is a doc
     HERE
 
+    # method invocation that occurs entirely on the next line
     [*1..10]
-      .select(&:even?)  # => [2, 4, 6, 8, 10]
+      .select(&:even?)      # => [2, 4, 6, 8, 10]
+
+    # mutliple levels of nesting
+    class User
+      def initialize(name)
+        @name = name        # => "Josh", "Rick"
+      end                   # => nil
+
+      def name
+        @name               # => "Josh", "Rick"
+      end                   # => nil
+    end                     # => nil
+
+    User.new("Josh").name   # => "Josh"
+    User.new("Rick").name   # => "Rick"
     """
 
   Scenario: Passing previous output back into input
@@ -140,7 +174,7 @@ Feature: Running the binary successfully
     And the exit status is 0
     And stdout is:
     """
-    __FILE__            # => "{{CommandLineHelpers.path_to 'some_dir/uses_macros.rb'}}"
+    __FILE__            # => "some_dir/uses_macros.rb"
     __LINE__            # => 2
     $stdout.puts "omg"  # => nil
     $stderr.puts "hi"   # => nil

data/features/flags.feature

@@ -55,6 +55,76 @@ Feature: Using flags
     4 + 4
     """
 
+  Scenario: --result-length sets the length of the portion including and after the # =>
+    Given the file "result_lengths.rb":
+    """
+    $stdout.puts "a"*100
+    $stderr.puts "a"*100
+
+                 "a"
+                 "aa"
+                 "aaa"
+                 "aaaa"
+
+    raise        "a"*100
+    """
+    When I run "seeing_is_believing --result-length 10 result_lengths.rb"
+    Then stderr is empty
+    And stdout is:
+    """
+    $stdout.puts "a"*100  # => nil
+    $stderr.puts "a"*100  # => nil
+
+                 "a"      # => "a"
+                 "aa"     # => "aa"
+                 "aaa"    # => "aaa"
+                 "aaaa"   # => "a...
+
+    raise        "a"*100  # ~> Ru...
+
+    # >> aa...
+
+    # !> aa...
+    """
+
+  Scenario: --line-length sets the total length of a given line
+    Given the file "line_lengths.rb":
+    """
+    $stdout.puts "a"*100
+    $stderr.puts "a"*100
+
+    "aaa"
+    "aaaa"
+
+    raise        "a"*100
+    """
+    When I run "seeing_is_believing --line-length 32 line_lengths.rb"
+    Then stderr is empty
+    And stdout is:
+    """
+    $stdout.puts "a"*100  # => nil
+    $stderr.puts "a"*100  # => nil
+
+    "aaa"                 # => "aaa"
+    "aaaa"                # => "a...
+
+    raise        "a"*100  # ~> Ru...
+
+    # >> aaaaaaaaaaaaaaaaaaaaaaaa...
+
+    # !> aaaaaaaaaaaaaaaaaaaaaaaa...
+    """
+    Given the file "line_lengths2.rb":
+    """
+    12345
+    """
+    When I run "seeing_is_believing --line-length 1 line_lengths2.rb"
+    Then stdout is "12345"
+    When I run "seeing_is_believing --line-length 15 line_lengths2.rb"
+    Then stdout is "12345  # => ..."
+    When I run "seeing_is_believing --line-length 14 line_lengths2.rb"
+    Then stdout is "12345"
+
   Scenario: --help
     When I run "seeing_is_believing --help"
     Then stderr is empty

data/lib/seeing_is_believing/binary/arg_parser.rb

@@ -0,0 +1,92 @@
+# note:
+#   reserve -e for script in an argument
+#   reserve -I for setting load path
+#   reserve -r for requiring another file
+
+class SeeingIsBelieving
+  class Binary
+    class ArgParser
+      def self.parse(args)
+        new(args).call
+      end
+
+      attr_accessor :args
+
+      def initialize(args)
+        self.args      = args
+        self.filenames = []
+      end
+
+      def call
+        @result ||= begin
+          until args.empty?
+            case (arg = args.shift)
+            when '-h', '--help'          then options[:help] = self.class.help_screen
+            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 /^-/                    then options[:errors] << "Unknown option: #{arg.inspect}" # unknown flags
+            else # filenames
+              filenames << arg
+              options[:filename] = arg
+            end
+          end
+          normalize_and_validate
+          options
+        end
+      end
+
+      private
+
+      attr_accessor :filenames
+
+      def normalize_and_validate
+        if 1 < filenames.size
+          options[:errors] << "Can only have one filename, but had: #{filenames.map(&:inspect).join ', '}"
+        end
+
+        if options[:end_line] < options[:start_line]
+          options[:start_line], options[:end_line] = options[:end_line], options[:start_line]
+        end
+      end
+
+      def options
+        @options ||= {
+          filename:      nil,
+          errors:        [],
+          start_line:    1,
+          line_length:   Float::INFINITY,
+          end_line:      Float::INFINITY,
+          result_length: Float::INFINITY,
+        }
+      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
+        else
+          options[:errors] << "#{flag} expects a positive integer argument"
+        end
+      end
+    end
+
+    def ArgParser.help_screen
+<<HELP_SCREEN
+Usage: #{$0} [options] [filename]
+
+  #{$0} is a program and library that will evaluate a Ruby file and capture/display the results.
+
+  If no filename is provided, the binary will read the program from standard input.
+
+  -l, --start-line    # line number to begin showing results on
+  -L, --end-line      # line number to stop showing results on
+  -d, --line-length   # max length of the entire line (only truncates results, not source lines)
+  -D, --result-length # max length of the portion after the "# => "
+  -h, --help          # this help screen
+HELP_SCREEN
+    end
+  end
+end

data/lib/seeing_is_believing/binary/line_formatter.rb

@@ -0,0 +1,47 @@
+class SeeingIsBelieving
+  class Binary
+    class LineFormatter
+      attr_accessor :line, :separator, :result, :options
+
+      def initialize(line, separator, result, options)
+       self.line      = line
+       self.separator = separator
+       self.result    = result
+       self.options   = options
+      end
+
+      def call
+        return line unless sep_plus_result.start_with? separator
+        return line unless formatted_line.start_with? "#{line_with_padding}#{separator}"
+        formatted_line
+      end
+
+      private
+
+      def line_length
+        options.fetch :line_length, Float::INFINITY
+      end
+
+      def result_length
+        options.fetch :result_length, Float::INFINITY
+      end
+
+      def sep_plus_result
+        @sep_plus_result ||= truncate "#{separator}#{result}", result_length
+      end
+
+      def formatted_line
+        @formatted_line ||= truncate "#{line_with_padding}#{sep_plus_result}", line_length
+      end
+
+      def line_with_padding
+        "%-#{options[:source_length]}s" % line
+      end
+
+      def truncate(string, length)
+        return string if string.size <= length
+        string.slice(0, length).sub(/.{0,3}$/) { |last_chars| last_chars.gsub /./, '.' }
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/print_results_next_to_lines.rb

@@ -0,0 +1,127 @@
+require 'seeing_is_believing/queue'
+require 'seeing_is_believing/has_exception'
+require 'seeing_is_believing/binary/line_formatter'
+
+class SeeingIsBelieving
+  class Binary
+    class PrintResultsNextToLines
+      include HasException
+
+         STDOUT_PREFIX = '# >>'
+         STDERR_PREFIX = '# !>'
+      EXCEPTION_PREFIX = '# ~>'
+         RESULT_PREFIX = '# =>'
+
+      def self.remove_previous_output_from(string)
+        string.gsub(/\s+(#{EXCEPTION_PREFIX}|#{RESULT_PREFIX}).*?$/, '')
+              .gsub(/\n?(^#{STDOUT_PREFIX}[^\n]*\r?\n?)+/m,          '')
+              .gsub(/\n?(^#{STDERR_PREFIX}[^\n]*\r?\n?)+/m,          '')
+      end
+
+
+      def self.method_from_options(*args)
+        define_method(args.first) { options.fetch *args }
+      end
+
+      method_from_options :filename, nil
+      method_from_options :start_line
+      method_from_options :end_line
+      method_from_options :line_length,   Float::INFINITY
+      method_from_options :result_length, Float::INFINITY
+
+
+      def initialize(body, file_result, options={})
+        self.body        = body
+        self.options     = options
+        self.file_result = file_result
+      end
+
+      def new_body
+        @new_body ||= ''
+      end
+
+      def call
+        add_each_line_until_start_or_data_segment
+        add_lines_with_results_until_end_or_data_segment
+        add_lines_until_data_segment
+        add_stdout
+        add_stderr
+        add_remaining_lines
+        return new_body
+      end
+
+      private
+
+      attr_accessor :body, :file_result, :options
+
+      def add_each_line_until_start_or_data_segment
+        line_queue.until { |line, line_number| line_number == start_line || start_of_data_segment?(line) }
+                  .each  { |line, line_number| new_body << line }
+      end
+
+      def add_lines_with_results_until_end_or_data_segment
+        line_queue.until { |line, line_number| end_line < line_number || start_of_data_segment?(line) }
+                  .each  { |line, line_number| new_body << format_line(line.chomp, file_result[line_number]) }
+      end
+
+      def add_lines_until_data_segment
+        line_queue.until { |line, line_number| start_of_data_segment?(line) }
+                  .each  { |line, line_number| new_body << line }
+      end
+
+      def add_remaining_lines
+        line_queue.each { |line, line_number| new_body << line }
+      end
+
+      def line_queue
+        @line_queue ||= Queue.new &body.each_line.with_index(1).to_a.method(:shift)
+      end
+
+      def start_of_data_segment?(line)
+        line.chomp == '__END__'
+      end
+
+      # max line length of the lines to output (exempting coments) + 2 spaces for padding
+      def max_source_line_length
+        @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 (line == "=begin") .. (line == "=end") }
+                                            .reject { |line| SyntaxAnalyzer.ends_in_comment? line }
+                                            .map(&:length)
+                                            .max
+      end
+
+      def add_stdout
+        return unless file_result.has_stdout?
+        new_body << "\n"
+        file_result.stdout.each_line do |line|
+          new_body << LineFormatter.new('', "#{STDOUT_PREFIX} ", line.chomp, options).call << "\n"
+        end
+      end
+
+      def add_stderr
+        return unless file_result.has_stderr?
+        new_body << "\n"
+        file_result.stderr.each_line do |line|
+          new_body << LineFormatter.new('', "#{STDERR_PREFIX} ", line.chomp, options).call << "\n"
+        end
+      end
+
+      def format_line(line, line_results)
+        options = options().merge source_length: max_source_line_length
+        formatted_line = if line_results.has_exception?
+                           result = sprintf "%s: %s", line_results.exception.class, line_results.exception.message
+                           LineFormatter.new(line, "#{EXCEPTION_PREFIX} ", result, options).call
+                         elsif line_results.any?
+                           LineFormatter.new(line, "#{RESULT_PREFIX} ", line_results.join(', '), options).call
+                         else
+                           line
+                         end
+        formatted_line + "\n"
+      end
+
+    end
+  end
+end