andyw8-seeing_is_believing 4.2.0

data/features/support/env.rb

@@ -0,0 +1,102 @@
+require_relative '../../lib/seeing_is_believing/version'
+
+require 'haiti'
+# A lot of the stuff in this file should get moved into haiti
+
+module Haiti
+  module CommandLineHelpers
+    # overwriting this method while trying to get windows support working,
+    # it looks like the underlying shell is treating the commands differently
+    # probably on Unix it invoked `sh` and did shady shit with splitting a string into an array on whitespace
+    # and on Windows (powershell?) it expected an actual array of strings
+    require 'shellwords'
+    def execute(command_string, stdin_data, env_vars)
+      stdin_data ||= ''
+      env_vars   ||= {}
+      in_proving_grounds do
+        with_bin_in_path do
+          Invocation.new *Open3.capture3(env_vars, command_string, stdin_data: stdin_data)
+        end
+      end
+    end
+
+    def execute_pipeline(command_strings, stdin_data, env_vars)
+      stdin_data ||= ''
+      env_vars   ||= {}
+      in_proving_grounds do
+        with_bin_in_path do
+          ioin, ioout, pids = Open3.pipeline_rw *command_strings.map { |cmd| [env_vars, cmd] }
+          ioin.print stdin_data
+          ioin.close
+          stderr = "" # uh... how do I record it for real?
+          Invocation.new ioout.read, stderr, pids.last.value
+        end
+      end
+    end
+
+    def with_bin_in_path
+      original_path = ENV['PATH']
+      dirs          = ENV["PATH"].split(File::PATH_SEPARATOR)
+      ENV['PATH']   = [config.bin_dir, *dirs].join(File::PATH_SEPARATOR)
+      yield
+    ensure
+      ENV['PATH'] = original_path
+    end
+  end
+end
+
+module SiBHelpers
+  def method_result(name)
+    @result = def __some_method__; end
+    if :__some_method__ == @result
+      name.inspect
+    elsif nil == @result
+      nil.inspect
+    else
+      raise "huh? #{@result.inspect}"
+    end
+  end
+end
+
+World SiBHelpers
+
+Haiti.configure do |config|
+  lib_root                   = File.join __dir__, '..', '..'
+  config.proving_grounds_dir = File.expand_path 'proving_grounds', lib_root
+  config.bin_dir             = File.expand_path 'bin',             lib_root
+end
+
+
+Then 'stdout is exactly:' do |code|
+  expect(@last_executed.stdout).to eq eval_curlies(code)
+end
+
+Then 'stdout is exactly "$code"' do |code|
+  expect(@last_executed.stdout).to eq eval_curlies(code)
+end
+
+Then 'stdout is the JSON:' do |json|
+  require 'json'
+  expected = JSON.parse(json)
+  actual   = JSON.parse(@last_executed.stdout)
+  expect(actual).to eq expected
+end
+
+Given %q(the file '$filename' '$body') do |filename, body|
+  Haiti::CommandLineHelpers.write_file filename, eval_curlies(body)
+end
+
+Given /^I run the pipeline "([^"]*)"(?: *\| *"([^"]*)")*$/ do |*commands|
+  @last_executed = Haiti::CommandLineHelpers.execute_pipeline(
+    commands,
+    @stdin_data,
+    @env_vars_to_set
+  )
+end
+
+Given(/^the binary file "([^"]*)" "([^"]*)"$/) do |filename, body|
+  Haiti::CommandLineHelpers.in_proving_grounds do
+    FileUtils.mkdir_p File.dirname filename
+    File.open(filename, 'wb') { |file| file.write body }
+  end
+end

data/features/xmpfilter-style.feature

@@ -0,0 +1,471 @@
+@xmpfilter
+Feature: Xmpfilter style
+  Support the same (or highly similar) interface as xmpfilter,
+  so that people who use that lib can easily transition to SiB.
+
+  Scenario: --xmpfilter-style Generic updating of marked lines
+    Given the file "magic_comments.rb":
+    """
+    1+1# =>
+    2+2    # => 10
+    "a
+     b" # =>
+    /a
+     b/ # =>
+    1
+    "omg"
+    # =>
+    "omg2"
+    # => "not omg2"
+    3+3#=>
+    """
+    When I run "seeing_is_believing --xmpfilter-style magic_comments.rb"
+    Then stderr is empty
+    And the exit status is 0
+    And stdout is:
+    """
+    1+1# => 2
+    2+2    # => 4
+    "a
+     b" # => "a\n b"
+    /a
+     b/ # => /a\n b/
+    1
+    "omg"
+    # => "omg"
+    "omg2"
+    # => "omg2"
+    3+3# => 6
+    """
+
+
+  Scenario: --xmpfilter-style uses pp to inspect annotations whose value comes from the previous line (#44)
+    Given the file "xmpfilter-prev-line1.rb":
+    """
+    { foo: 42,
+      bar: {
+        baz: 1,
+        buz: 2,
+        fuz: 3,
+      },
+      wibble: {
+        magic_word: "xyzzy",
+      }
+    } # =>
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style xmpfilter-prev-line1.rb"
+    Then stdout is:
+    """
+    { foo: 42,
+      bar: {
+        baz: 1,
+        buz: 2,
+        fuz: 3,
+      },
+      wibble: {
+        magic_word: "xyzzy",
+      }
+    } # => {:foo=>42, :bar=>{:baz=>1, :buz=>2, :fuz=>3}, :wibble=>{:magic_word=>"xyzzy"}}
+    # => {:foo=>42,
+    #     :bar=>{:baz=>1, :buz=>2, :fuz=>3},
+    #     :wibble=>{:magic_word=>"xyzzy"}}
+    """
+
+  @not-2.3
+  Scenario: --xmpfilter-style, when displayed on the next line, prints the string across multiple lines
+    Given the file "xmpfilter-prev-line-is-multiline-string.rb":
+    """
+    "0123456789\nabcdefghij\n0123456789\n0123456789\n0123456789\n0123456789\n" # =>
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style xmpfilter-prev-line-is-multiline-string.rb"
+    Then stdout is:
+    """
+    "0123456789\nabcdefghij\n0123456789\n0123456789\n0123456789\n0123456789\n" # => "0123456789\nabcdefghij\n0123456789\n0123456789\n0123456789\n0123456789\n"
+    # => "0123456789\n" +
+    #    "abcdefghij\n" +
+    #    "0123456789\n" +
+    #    "0123456789\n" +
+    #    "0123456789\n" +
+    #    "0123456789\n"
+    """
+
+
+  Scenario: --xmpfilter-style overrides previous multiline results
+    Given the file "xmpfilter-prev-line2.rb":
+    """
+    {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
+    # =>
+    """
+    When I run the pipeline "seeing_is_believing --xmpfilter-style xmpfilter-prev-line2.rb" | "seeing_is_believing --xmpfilter-style"
+    Then stdout is:
+    """
+    {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
+    # => {:foo=>42,
+    #     :bar=>{:baz=>1, :buz=>2, :fuz=>3},
+    #     :wibble=>{:magic_word=>"xyzzy"}}
+    """
+
+
+  Scenario: --xmpfilter-style respects the line formatting (but not currently alignment strategies, it just preserves submitted alignment)
+    Given the file "xmpfilter_line_lengths.rb":
+    """
+    '1' * 30 # =>
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style --line-length 19 xmpfilter_line_lengths.rb"
+    Then stdout is:
+    """
+    '1' * 30 # => "1...
+    # => "1111111111...
+    """
+
+
+  Scenario: Errors on annotated lines
+    Given the file "xmpfilter_error_on_annotated_line.rb":
+    """
+    raise "ZOMG\n!!!!" # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style xmpfilter_error_on_annotated_line.rb"
+    Then stderr is empty
+    And the exit status is 1
+    Then stdout is:
+    """
+    raise "ZOMG\n!!!!" # => RuntimeError: ZOMG\n!!!!
+
+    # ~> RuntimeError
+    # ~> ZOMG
+    # ~> !!!!
+    # ~>
+    # ~> xmpfilter_error_on_annotated_line.rb:1:in `<main>'
+    """
+
+
+  Scenario: Errors on unannotated lines
+    Given the file "xmpfilter_error_on_unannotated_line.rb":
+    """
+    raise "ZOMG\n!!!!"
+    """
+    When I run "seeing_is_believing --xmpfilter-style xmpfilter_error_on_unannotated_line.rb"
+    Then stderr is empty
+    And the exit status is 1
+    Then stdout is:
+    """
+    raise "ZOMG\n!!!!" # ~> RuntimeError: ZOMG\n!!!!
+
+    # ~> RuntimeError
+    # ~> ZOMG
+    # ~> !!!!
+    # ~>
+    # ~> xmpfilter_error_on_unannotated_line.rb:1:in `<main>'
+    """
+
+
+  Scenario: Cleaning previous output does not clean the xmpfilter annotations
+    Given the file "xmpfilter_cleaning.rb":
+    """
+    # commented out # => previous annotation
+    1 # => "1...
+    # => "1111111111...
+    #    "1111111111...
+    # normal comment
+
+    {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
+    # => {:foo=>42,
+    #     :bar=>{:baz=>1, :buz=>2, :fuz=>3},
+    #     :wibble=>{:magic_word=>"xyzzy"}}
+    """
+    When I run "seeing_is_believing --xmpfilter-style --clean xmpfilter_cleaning.rb"
+    Then stdout is:
+    """
+    # commented out # => previous annotation
+    1 # =>
+    # =>
+    # normal comment
+
+    {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
+    # =>
+    """
+
+
+  # Not totally in love with this, but it'll do unless I can think of something better.
+  Scenario: Error raised on an annotated line preserves the annotation
+    Given the file "error_on_annotated_line.a.rb":
+    """
+    "a"+1 # =>
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style error_on_annotated_line.a.rb"
+    Then stdout includes:
+    """
+    "a"+1 # => TypeError:
+    """
+    And stdout includes:
+    """
+    # =>
+
+    # ~> TypeError
+    """
+    Given the file "error_on_annotated_line.b.rb":
+    """
+    "a"+"1" # => TypeError: no implicit conversion of Fixnum into String
+    # =>
+
+    # ~> TypeError
+    # ~> no implicit conversion of Fixnum into String
+    """
+    When I run "seeing_is_believing --xmpfilter-style error_on_annotated_line.b.rb"
+    Then stdout is:
+    """
+    "a"+"1" # => "a1"
+    # => "a1"
+    """
+
+
+  # maybe can't fix this as it depends on the implementation of PP.pp
+  @not-implemented
+  Scenario: It can record values even when method is overridden
+    Given the file "pretty_inspect_with_method_overridden.rb":
+    """
+    def method()end; self # =>
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style pretty_inspect_with_method_overridden.rb"
+    Then stdout is:
+    """
+    def method()end; self # => main
+    # => main
+    """
+
+
+  # Choosing this output style b/c it's what xmpfilter chooses,
+  # and it works conveniently with what's already in place.
+  #
+  # It looks better with the comma on the preceding line, but harder to identify the individual results.
+  #
+  # It looks better with an empty line between the results, but if the user strips trailing whitespace inbetween runs,
+  # it will confuse the annotations for normal comments.
+  #
+  # Might be cool to have it do a value comment before each result, instead of a comma.
+  # But at present, it doesn't wipe out "useless" value comments,
+  # e.g. cleaning this would leave three value markers after the hash.
+  Scenario: Multiline output that is repeatedly invoked
+    Given the file "mutltiline_output_repeatedly_invoked.rb":
+    """
+    3.times do
+      {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
+      # =>
+    end
+    """
+    When I run "seeing_is_believing -x mutltiline_output_repeatedly_invoked.rb"
+    Then stdout is:
+    """
+    3.times do
+      {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
+      # => {:foo=>42,
+      #     :bar=>{:baz=>1, :buz=>2, :fuz=>3},
+      #     :wibble=>{:magic_word=>"xyzzy"}}
+      #    ,{:foo=>42,
+      #     :bar=>{:baz=>1, :buz=>2, :fuz=>3},
+      #     :wibble=>{:magic_word=>"xyzzy"}}
+      #    ,{:foo=>42,
+      #     :bar=>{:baz=>1, :buz=>2, :fuz=>3},
+      #     :wibble=>{:magic_word=>"xyzzy"}}
+    end
+    """
+    When I run the pipeline "seeing_is_believing -x mutltiline_output_repeatedly_invoked.rb" | "seeing_is_believing -x"
+    Then stdout is:
+    """
+    3.times do
+      {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
+      # => {:foo=>42,
+      #     :bar=>{:baz=>1, :buz=>2, :fuz=>3},
+      #     :wibble=>{:magic_word=>"xyzzy"}}
+      #    ,{:foo=>42,
+      #     :bar=>{:baz=>1, :buz=>2, :fuz=>3},
+      #     :wibble=>{:magic_word=>"xyzzy"}}
+      #    ,{:foo=>42,
+      #     :bar=>{:baz=>1, :buz=>2, :fuz=>3},
+      #     :wibble=>{:magic_word=>"xyzzy"}}
+    end
+    """
+
+
+  Scenario: Multiline values where the first line is indented more than the successive lines use a nonbreaking space
+    Given the file "inspect_tree.rb":
+    """
+    bst = Object.new
+    def bst.inspect
+      "   4\n"\
+      " 2   6\n"\
+      "1 3 5 7\n"
+    end
+    bst
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style inspect_tree.rb"
+    # NOTE: The first space after the => is a nonbreaking space
+    Then stdout is:
+    """
+    bst = Object.new
+    def bst.inspect
+      "   4\n"\
+      " 2   6\n"\
+      "1 3 5 7\n"
+    end
+    bst
+    # =>    4
+    #     2   6
+    #    1 3 5 7
+    """
+
+
+  Scenario: Leading whitespace on nextline, but not multiline uses normal spaces
+    Given the file "nextline_with_leading_whitespace_but_not_multiline.rb":
+    """
+    o = Object.new
+    def o.inspect; " o" end
+    o
+    # =>
+    """
+    When I run "seeing_is_believing --xmpfilter-style nextline_with_leading_whitespace_but_not_multiline.rb"
+    Then stdout is:
+    """
+    o = Object.new
+    def o.inspect; " o" end
+    o
+    # =>  o
+    """
+
+
+  Scenario: When there are no results for the previous line it looks further back (#77)
+    Given the file "heredocs_and_blank_lines.rb":
+    """
+    # =>
+
+    <<DOC
+    1
+    DOC
+    # =>
+
+    2
+
+    # =>
+
+    if true
+      3
+      # =>
+    else
+      4
+      # =>
+    end
+    """
+    When I run "seeing_is_believing --xmpfilter-style heredocs_and_blank_lines.rb"
+    Then stdout is:
+    """
+    # =>
+
+    <<DOC
+    1
+    DOC
+    # => "1\n"
+
+    2
+
+    # => 2
+
+    if true
+      3
+      # => 3
+    else
+      4
+      # =>
+    end
+    """
+
+
+
+  Scenario: Xmpfilter uses the same comment formatting as normal
+    Given the file "xmpfilter_result_lengths.rb":
+    """
+    $stdout.puts "a"*100
+    $stderr.puts "a"*100
+
+                 "a"    # =>
+                 "aa"   # =>
+                 "aaa"  # =>
+                 "aaaa" # =>
+
+    {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
+    # =>
+
+    raise "a"*100
+    """
+    When I run "seeing_is_believing -x --result-length 10 xmpfilter_result_lengths.rb"
+    Then stderr is empty
+    And stdout is:
+    """
+    $stdout.puts "a"*100
+    $stderr.puts "a"*100
+
+                 "a"    # => "a"
+                 "aa"   # => "aa"
+                 "aaa"  # => "aaa"
+                 "aaaa" # => "a...
+
+    {foo: 42, bar: {baz: 1, buz: 2, fuz: 3}, wibble: {magic_word: "xyzzy"}}
+    # => {:...
+    #     :...
+    #     :...
+
+    raise "a"*100 # ~> Ru...
+
+    # >> aa...
+
+    # !> aa...
+
+    # ~> Ru...
+    # ~> aa...
+    # ~>
+    # ~> xm...
+    """
+
+  Scenario: --interline-align and --no-interline-align determine whether adjacent lines with the same number of results get lined up, it defaults to --align
+    Given the file "xmpfilter_interline_alignment.rb":
+    """
+    3.times do |num|
+      num     # =>
+        .to_s # =>
+    end
+    """
+    When I run "seeing_is_believing -x xmpfilter_interline_alignment.rb"
+    Then stderr is empty
+    And  the exit status is 0
+    And  stdout is:
+    """
+    3.times do |num|
+      num     # => 0,   1,   2
+        .to_s # => "0", "1", "2"
+    end
+    """
+    When I run "seeing_is_believing -x --interline-align xmpfilter_interline_alignment.rb"
+    Then stderr is empty
+    And  the exit status is 0
+    And  stdout is:
+    """
+    3.times do |num|
+      num     # => 0,   1,   2
+        .to_s # => "0", "1", "2"
+    end
+    """
+    When I run "seeing_is_believing -x --no-interline-align xmpfilter_interline_alignment.rb"
+    Then stderr is empty
+    And  the exit status is 0
+    And  stdout is:
+    """
+    3.times do |num|
+      num     # => 0, 1, 2
+        .to_s # => "0", "1", "2"
+    end
+    """

data/lib/seeing_is_believing/binary/align_chunk.rb

@@ -0,0 +1,47 @@
+require 'seeing_is_believing/binary/commentable_lines'
+
+class SeeingIsBelieving
+  module Binary
+    class AlignChunk
+      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
+      def line_length_for(line_number)
+        line_lengths.fetch line_number, 0
+      end
+
+      private
+
+      attr_accessor :body
+
+      def line_lengths
+        @line_lengths ||= begin
+          # sheesh, I need like Hash#map_values or something
+          line_nums_to_cols = Hash.[] \
+            CommentableLines.call(body)
+                            .map { |line_num, (file_index, col_index)|
+                              [line_num, col_index-amount_of_preceding_whitespace(file_index)]
+                            }
+
+          Hash.[] \
+            line_nums_to_cols
+              .keys
+              .sort
+              .slice_before { |line_number| line_nums_to_cols[line_number].zero?  }
+              .flat_map { |slice|
+                max_chunk_length = 2 + slice.map { |line_num| line_nums_to_cols[line_num] }.max
+                slice.map { |line_number| [line_number, max_chunk_length] }
+              }
+        end
+      end
+
+      def amount_of_preceding_whitespace(index_of_trailing_newline)
+        index = index_of_trailing_newline - 1
+        index -= 1 while 0 <= index && body[index] !~ /[\S\n]/
+        index_of_trailing_newline - index - 1
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/align_file.rb

@@ -0,0 +1,24 @@
+require 'seeing_is_believing/binary/commentable_lines'
+
+class SeeingIsBelieving
+  module Binary
+    class AlignFile
+      attr_accessor :body
+
+      def initialize(body)
+        self.body = body
+      end
+
+      # 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 + begin
+          line_num_to_indexes = CommentableLines.new(body).call # {line_number => [index_in_file, index_in_col]}
+          max_value = line_num_to_indexes
+                           .values
+                           .map { |index, col| col }.max
+          max_value || 0
+        end
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/binary/align_line.rb

@@ -0,0 +1,25 @@
+class SeeingIsBelieving
+  module Binary
+    class AlignLine
+      attr_accessor :body
+
+      def initialize(body)
+        self.body = body
+      end
+
+      # length of the line + 2 spaces for padding
+      def line_length_for(line_number)
+        line_lengths[line_number]
+      end
+
+      def line_lengths
+        @line_lengths ||= Hash[ body.each_line
+                                    .map(&:chomp)
+                                    .each
+                                    .with_index(1)
+                                    .map { |line, index| [index, line.length+2] }
+                              ]
+      end
+    end
+  end
+end