andyw8-seeing_is_believing 4.2.0

data/spec/binary/remove_annotations_spec.rb

@@ -0,0 +1,342 @@
+require 'spec_helper'
+require 'seeing_is_believing/binary/remove_annotations'
+require 'seeing_is_believing/binary/data_structures'
+
+RSpec.describe SeeingIsBelieving::Binary::RemoveAnnotations do
+  def regexes
+    SeeingIsBelieving::Binary::Markers.new
+  end
+
+  def call(code, should_clean_values=true)
+    indentation = code[/\A */]
+    code        = code.gsub /^#{indentation}/, ''
+    code << "\n" unless code.end_with? "\n"
+    described_class.call(code, should_clean_values, regexes).chomp
+  end
+
+  context 'when there are lines that are just normal comments' do
+    example { expect(call "1 # hello").to eq "1 # hello" }
+    example { expect(call "1 # hello\n"\
+                          "# world").to eq "1 # hello\n"\
+                                           "# world" }
+    example { expect(call "1 # not special\n"\
+                          "2 # => 3").to eq "1 # not special\n2" }
+  end
+
+  context 'when told to clean out value annotations' do
+    example { expect(call "1# => 1",    true).to eq "1"   }
+    example { expect(call "1 # => 1",   true).to eq "1"   }
+    example { expect(call "1  # => 1",  true).to eq "1"   }
+    example { expect(call "1  # => 1",  true).to eq "1"   }
+    example { expect(call "1   # => 1", true).to eq "1"   }
+    example { expect(call "1  # =>  1", true).to eq "1"   }
+    example { expect(call "1  #  => 1", true).to eq "1"   }
+    example { expect(call "\n1 # => 1", true).to eq "\n1" }
+  end
+
+  context 'when told not to clean out value markers, it leaves the marker, but removes the annotation and trailing whitespace' do
+    example { expect(call "1# => 1",    false).to eq "1# =>"    }
+    example { expect(call "1 # => 1",   false).to eq "1 # =>"   }
+    example { expect(call "1  # => 1",  false).to eq "1  # =>"  }
+    example { expect(call "1  # => 1",  false).to eq "1  # =>"  }
+    example { expect(call "1   # => 1", false).to eq "1   # =>" }
+    example { expect(call "1  # =>  1", false).to eq "1  # =>"  }
+    example { expect(call "1  #  => 1", false).to eq "1  #  =>" }
+    example { expect(call "\n1 # => 1", false).to eq "\n1 # =>" }
+  end
+
+  context 'cleaning inline exception annotations' do
+    example { expect(call "1# ~> 1"   ).to eq "1"   }
+    example { expect(call "1 # ~> 1"  ).to eq "1"   }
+    example { expect(call "1  # ~> 1" ).to eq "1"   }
+    example { expect(call "1  # ~> 1" ).to eq "1"   }
+    example { expect(call "1   # ~> 1").to eq "1"   }
+    example { expect(call "1  # ~>  1").to eq "1"   }
+    example { expect(call "\n1 # ~> 1").to eq "\n1" }
+
+    example { expect(call "# >> 1").to   eq ""      }
+    example { expect(call "# !> 1").to   eq ""      }
+  end
+
+  context 'cleaning multiline results' do
+    it 'cleans values whose hash and value locations exactly match the annotation on the line prior' do
+      expect(call "1# => 2\n"\
+                  " #    3").to eq "1"
+    end
+
+    it 'does not clean values where the comment appears at a different position' do
+      expect(call "1# => 2\n"\
+                  "#    3").to eq "1\n"\
+                                  "#    3"
+
+      expect(call "1# => 2\n"\
+                  "  #    3").to eq "1\n"\
+                                    "  #    3"
+
+      expect(call "1# => 2\n"\
+                  "#     3").to eq "1\n"\
+                                   "#     3"
+      expect(call "1# => 2\n"\
+                  "  #   3").to eq "1\n"\
+                                   "  #   3"
+
+    end
+
+    it 'does not clean values where the nextline value appears before the initial annotation value' do
+      # does clean
+      expect(call "1# => 2\n"\
+                  " #    3").to eq "1"
+      expect(call "1# => 2\n"\
+                  " #     3").to eq "1"
+
+      # does not clean
+      expect(call "1# => 2\n"\
+                  " #  3 4").to eq "1\n"\
+                                   " #  3 4"
+      expect(call "1# => 2\n"\
+                  " #   3").to eq "1\n"\
+                                  " #   3"
+      expect(call "1# => 2\n"\
+                  " #  3").to eq "1\n"\
+                                 " #  3"
+    end
+
+    it 'does not clean values where there is content before the comment' do
+      expect(call "1# => 2\n"\
+                  "3#    4").to eq "1\n"\
+                                   "3#    4"
+    end
+
+    it 'cleans successive rows of these' do
+      expect(call "1# => 2\n"\
+                  " #    3\n"\
+                  " #    4" ).to eq "1"
+      expect(call "1# => 2\n"\
+                  " #    3\n"\
+                  " #    4\n"\
+                  "5# => 6\n"\
+                  " #    7\n"\
+                  " #    8" ).to eq "1\n5"
+    end
+
+    it 'does not clean values where there is non-annotation inbetween' do
+      expect(call "1# => 2\n"\
+                  "#    3\n"\
+                  " #    4").to eq "1\n"\
+                                   "#    3\n"\
+                                   " #    4"
+
+      expect(call "1# => 2\n"\
+                  "3      \n"\
+                  " #    4").to eq "1\n"\
+                                   "3      \n"\
+                                   " #    4"
+      expect(call "1# => 2\n"\
+                  "#    3\n"\
+                  " #    4").to eq "1\n"\
+                                   "#    3\n"\
+                                   " #    4"
+    end
+
+    it 'cleans multiline portion, regardless of whether cleaning values (this is soooooo xmpfilter specific)' do
+      expect(call "1# => 2\n"\
+                  " #    3").to eq "1"
+
+      expect(call "1# => 2\n"\
+                  " #    3",
+                  false).to eq "1# =>"
+    end
+
+    it 'works on inline exceptions' do
+      expect(call "1# ~> 2\n"\
+                  " #    3").to eq "1"
+    end
+  end
+
+  context 'cleaning stdout annotations' do
+    example { expect(call(<<-CODE)).to eq "1" }
+    1
+    # >> 2
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1" }
+    1
+
+    # >> 2
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1\n" }
+    1
+
+
+    # >> 2
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1\n" }
+    1
+
+
+      # >> 2
+    # >> 2
+     # >> 2
+    CODE
+
+
+    example { expect(call(<<-CODE)).to eq "1\n" }
+    1
+
+
+    # >> 2
+    # >> 3
+    CODE
+
+    example { expect(call <<-CODE.gsub(/^\s*/, '')).to eq "\n1" }
+
+    # >> err
+    1
+    CODE
+  end
+
+  context 'cleaning stderr annotations' do
+    example { expect(call(<<-CODE)).to eq "1" }
+    1
+    # !> 2
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1" }
+    1
+
+    # !> 2
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1" }
+    1
+
+    # !> 2
+    # !> 3
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1\n" }
+    1
+
+
+      # !> 2
+    # !> 2
+     # !> 2
+    CODE
+
+    example { expect(call <<-CODE.gsub(/^\s*/, '')).to eq "\n1" }
+
+    # !> err
+    1
+    CODE
+  end
+
+
+  context 'cleaning end of file exception annotations' do
+    example { expect(call(<<-CODE)).to eq "1" }
+    1
+    # ~> 2
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1" }
+    1
+
+    # ~> 2
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1" }
+    1
+
+    # ~> 2
+    # ~> 3
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1\n" }
+    1
+
+
+      # ~> 2
+    # ~> 2
+     # ~> 2
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1\n" }
+    1 # ~> error
+
+
+      # ~> error again
+    CODE
+  end
+
+  context 'putting it all together' do
+    example { expect(call(<<-CODE)).to eq "1" }
+    1
+
+    # >> 1
+    # >> 2
+
+    # !> 3
+    # !> 4
+
+    # ~> 5
+    # ~> 6
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1" }
+    1
+
+    # >> 1
+
+    # >> 2
+
+    # !> 3
+
+    # !> 4
+
+    # ~> 5
+
+    # ~> 6
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1" }
+    1
+
+    # >> 1
+    # >> 2
+    # !> 3
+    # !> 4
+    # ~> 5
+    # ~> 6
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1\n3" }
+    1
+    # >> 1
+    # >> 2
+    3
+    # !> 4
+    # !> 5
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1\n3\n6" }
+    1
+    # >> 1
+    # >> 2
+    3
+    # !> 4
+    # !> 5
+    6
+    # ~> 7
+    # ~> 8
+    CODE
+
+    example { expect(call(<<-CODE)).to eq "1\n\nputs \"omg\"" }
+    1  # => 1
+
+    puts "omg"  # ~> RuntimeError: omg
+
+    # ~> RuntimeError
+    CODE
+  end
+end

data/spec/binary/rewrite_comments_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'seeing_is_believing/binary/rewrite_comments'
+
+RSpec.describe SeeingIsBelieving::Binary::RewriteComments do
+  def call(code, options={}, &block)
+    code = code + "\n" unless code.end_with? "\n"
+    described_class.call(code, options, &block).chomp
+  end
+
+  it 'ignores multiline comments' do
+    seen = []
+    call("123\n=begin\n456\n=end\n789") do |*args|
+      seen << args
+      args[-2..-1]
+    end
+    expect(seen).to eq []
+  end
+
+  it 'yields the Code::InlineComment' do
+    seen = []
+    call("# c1\n"\
+         "123 #   c2 # x\n"\
+         "n456\n"\
+         " \t # c3\n"\
+         "%Q{\n"\
+         " 1}#c4\n"\
+         "# c5") do |comment|
+      seen << comment
+      ['', '']
+    end
+    expect(seen.map(&:text)).to eq [
+      "# c1",
+      "#   c2 # x",
+      "# c3",
+      "#c4",
+      "# c5",
+    ]
+  end
+
+  it 'rewrites the whitespace and comment with the whitespace and comment that are returned' do
+    rewritten = call("# c1\n"\
+                     "123 #c2\n"\
+                     "n456\n"\
+                     " \t # c3\n"\
+                     "%Q{\n"\
+                     " 1}#c4") do |c|
+      ["NEW_WHITESPACE#{c.line_number}", "--COMMENT-#{c.line_number}--"]
+    end
+    expect(rewritten).to eq "NEW_WHITESPACE1--COMMENT-1--\n"\
+                            "123NEW_WHITESPACE2--COMMENT-2--\n"\
+                            "n456\n"\
+                            "NEW_WHITESPACE4--COMMENT-4--\n"\
+                            "%Q{\n"\
+                            " 1}NEW_WHITESPACE6--COMMENT-6--"
+  end
+
+  it 'can be given additional lines to make sure are provided, whether they have comments on them or not' do
+    rewritten = call("'a'\n"\
+                     "'b'\n"\
+                     "'c' # c\n"\
+                     "'d' \n"\
+                     "'e'",
+                     include_lines: [2, 3, 4, 5]) do |c|
+                       value = sprintf "%d|%d|%p|%d|%p|%d...%d|%d...%d|%d...%d",
+                                       c.line_number,
+                                       c.whitespace_col,
+                                       c.whitespace,
+                                       c.text_col,
+                                       c.text,
+                                       c.full_range.begin_pos,
+                                       c.full_range.end_pos,
+                                       c.whitespace_range.begin_pos,
+                                       c.whitespace_range.end_pos,
+                                       c.comment_range.begin_pos,
+                                       c.comment_range.end_pos
+                       ['pre', value]
+                     end
+    expect(rewritten).to eq \
+      "'a'\n"\
+      "'b'pre2|3|\"\"|3|\"\"|7...7|7...7|7...7\n"\
+      "'c'pre3|3|\" \"|4|\"# c\"|11...15|11...12|12...15\n"\
+      "'d'pre4|3|\" \"|4|\"\"|19...20|19...20|20...20\n"\
+      "'e'pre5|3|\"\"|3|\"\"|24...24|24...24|24...24"
+
+    rewritten = call("", include_lines: [1]) { |c| ['a', 'b'] }
+    expect(rewritten).to eq "ab"
+
+    rewritten = call("a", include_lines: [1]) { |c| ['b', 'c'] }
+    expect(rewritten).to eq "abc"
+
+    rewritten = call("a ", include_lines: [1]) { |c| ['b', 'c'] }
+    expect(rewritten).to eq "abc"
+  end
+
+  it 'does not include lines that are uncommentable' do
+    rewritten = call("'a\n"\
+                     "b'",
+                     include_lines: [1, 2]) { ["whitespace", "comment"] }
+    expect(rewritten).to eq "'a\n"\
+                            "b'whitespacecomment"
+  end
+
+  it 'blows up if given unknown options' do
+    expect { call '1', not_an_option: nil }.to raise_error /not_an_option/
+  end
+end

data/spec/code_spec.rb

@@ -0,0 +1,233 @@
+require 'seeing_is_believing/code'
+
+RSpec.describe SeeingIsBelieving::Code do
+  def code_for(raw_code, options={})
+    manage_newline = options.fetch :nl, true
+    raw_code += "\n" if manage_newline && !raw_code.end_with?("\n")
+    described_class.new(raw_code)
+  end
+
+  def assert_range(range, begin_pos, end_pos)
+    expect(range.begin_pos).to eq begin_pos
+    expect(range.end_pos).to eq end_pos
+  end
+
+  it 'raises a SyntaxError if given a file that does not end in a newline' do
+    code_for "\n", nl: false
+    expect { code_for "", nl: false  }.to raise_error SyntaxError, /newline/i
+
+    code_for "1\n", nl: false
+    expect { code_for "1", nl: false }.to raise_error SyntaxError, /newline/i
+  end
+
+  describe '#range_for' do
+    it 'returns a range object with the specified start and ends' do
+      code  = code_for "abcd"
+      range = code.range_for(1, 2)
+      expect(range.begin_pos).to eq 1
+      expect(range.end_pos).to eq 2
+      expect(range.source).to eq 'b'
+    end
+  end
+
+  describe '#root' do
+    it 'returns the root for valid code' do
+      expect(code_for('1').root.type).to eq :int
+    end
+    it 'returns a null root for invalid code' do
+      root = code_for('"').root
+      expect(root.type).to eq :null_node
+      assert_range root.location.expression, 0, 0
+    end
+    it 'returns a null root for empty code' do
+      root = code_for('').root
+      expect(root.type).to eq :null_node
+      assert_range root.location.expression, 0, 0
+    end
+  end
+
+  describe '#index_to_linenum' do
+    it 'treats indexes as 0based and lines as 1based' do
+      code = code_for "xx\nyyy\n\nzz"
+      [[1,0], [1,1], [1,2],
+       [2,3], [2,4], [2,5], [2,6],
+       [3,7],
+       [4,8], [4,9],
+      ].each do |expected_lineno, index|
+        actual_lineno = code.index_to_linenum index
+        expect(expected_lineno).to eq(actual_lineno),
+          "index:           #{index}\n"\
+          "expected lineno: #{expected_lineno}\n"\
+          "actual lineno:   #{actual_lineno.inspect}"
+      end
+    end
+
+    it 'considers any indexes after the end to be on the last line' do
+      expect(code_for("a\nb\nc\n").index_to_linenum(1000)).to eq 4
+    end
+  end
+
+  describe '#linenum_to_index' do
+    it 'treats line numebrs as 1based and indexes as 0based' do
+      code = code_for "xx\nyyy\n\nzz\n"
+      expect(code.linenum_to_index 1).to eq 0
+      expect(code.linenum_to_index 2).to eq 3
+      expect(code.linenum_to_index 3).to eq 7
+      expect(code.linenum_to_index 4).to eq 8
+      expect(code.linenum_to_index 5).to eq 11
+    end
+
+    it 'considers any lines past the end to be at 1 character after the last index' do
+      expect(code_for("abc\n").linenum_to_index(100)).to eq 4
+    end
+  end
+
+  # should it begin after magic comments and stuff?
+  describe '#body_range' do
+    it 'returns a range for the whole body' do
+      assert_range code_for("\n").body_range, 0, 1
+      assert_range code_for("1\n").body_range, 0, 2
+      assert_range code_for("1111\n").body_range, 0, 5
+    end
+
+    it 'ends after the last token prior to __END__ statements' do
+      assert_range code_for("__END__\n").body_range, 0, 0
+      assert_range code_for("\n__END__\n").body_range, 0, 1
+      assert_range code_for("a\n__END__\n").body_range, 0, 2
+      assert_range code_for("a\n\n\n__END__\n").body_range, 0, 2
+    end
+
+    it 'ends after trailing comments' do
+      assert_range code_for("1#a\n").body_range, 0, 4
+      assert_range code_for("1#a\n#b\n#c\n").body_range, 0, 10
+      assert_range code_for("1#a\n#b\n#c\n\n").body_range, 0, 10
+      assert_range code_for("a\n#c\n\n__END__\n").body_range, 0, 5
+      assert_range code_for("1#a\n#b\n#c\n__END__\n").body_range, 0, 10
+      assert_range code_for("1#a\n#b\n#c\n\n__END__\n").body_range, 0, 10
+    end
+
+    it 'ends after heredocs' do
+      assert_range code_for("<<a\nb\na\n").body_range, 0, 8
+      assert_range code_for("<<a\nb\na\n1\n").body_range, 0, 10
+      assert_range code_for("<<a\nb\na\n#c\n").body_range, 0, 11
+    end
+  end
+
+  describe 'void value expressions' do
+    def void_value?(ast)
+      code_for("\n").void_value?(ast)
+    end
+
+    def ast_for(code)
+      Parser::CurrentRuby.parse code
+    end
+
+    it 'knows a `return`, `next`, `redo`, `retry`, and `break` are void values' do
+      expect(void_value?(ast_for("def a; return; end").children.last)).to be true
+      expect(void_value?(ast_for("loop { next  }"    ).children.last)).to be true
+      expect(void_value?(ast_for("loop { redo  }"    ).children.last)).to be true
+      expect(void_value?(ast_for("loop { break }"    ).children.last)).to be true
+
+      the_retry = ast_for("begin; rescue; retry; end").children.first.children[1].children.last
+      expect(the_retry.type).to eq :retry
+      expect(void_value? the_retry).to eq true
+    end
+    it 'knows an `if` is a void value if either side is a void value' do
+      the_if = ast_for("def a; if 1; return 2; else; 3; end; end").children.last
+      expect(the_if.type).to eq :if
+      expect(void_value?(the_if)).to be true
+
+      the_if = ast_for("def a; if 1; 2; else; return 3; end; end").children.last
+      expect(the_if.type).to eq :if
+      expect(void_value?(the_if)).to be true
+
+      the_if = ast_for("def a; if 1; 2; else; 3; end; end").children.last
+      expect(the_if.type).to eq :if
+      expect(void_value?(the_if)).to be false
+    end
+    it 'knows a begin is a void value if its last element is a void value' do
+      the_begin = ast_for("loop { begin; break; end }").children.last
+      expect([:begin, :kwbegin]).to include the_begin.type
+      expect(void_value?(the_begin)).to be true
+
+      the_begin = ast_for("loop { begin; 1; end }").children.last
+      expect([:begin, :kwbegin]).to include the_begin.type
+      expect(void_value?(the_begin)).to be false
+    end
+    it 'knows a rescue is a void value if its last child or its else is a void value' do
+      the_rescue = ast_for("begin; rescue; retry; end").children.first
+      expect(the_rescue.type).to eq :rescue
+      expect(void_value?(the_rescue)).to be true
+
+      the_rescue = ast_for("begin; rescue; 1; else; retry; end").children.first
+      expect(the_rescue.type).to eq :rescue
+      expect(void_value?(the_rescue)).to be true
+
+      the_rescue = ast_for("begin; rescue; 1; else; 2; end").children.first
+      expect(the_rescue.type).to eq :rescue
+      expect(void_value?(the_rescue)).to be false
+    end
+    it 'knows an ensure is a void value if its body or ensure portion are void values' do
+      the_ensure = ast_for("loop { begin; break; ensure; 1; end }").children.last.children.last
+      expect(the_ensure.type).to eq :ensure
+      expect(void_value?(the_ensure)).to be true
+
+      the_ensure = ast_for("loop { begin; 1; ensure; break; end }").children.last.children.last
+      expect(the_ensure.type).to eq :ensure
+      expect(void_value?(the_ensure)).to be true
+
+      the_ensure = ast_for("loop { begin; 1; ensure; 2; end }").children.last.children.last
+      expect(the_ensure.type).to eq :ensure
+      expect(void_value?(the_ensure)).to be false
+    end
+    it 'knows other things are not void values' do
+      expect(void_value?(ast_for "123")).to be false
+    end
+  end
+
+end
+
+
+
+#   describe '#inline_comments' do
+#     xit 'finds their line_number, column_number, preceding_whitespace, text, preceding_whitespace_range, and comment_range' do
+#       code = code_for <<-CODE.gsub(/^\s*/, '')
+#       # c1
+#       not c
+#       # c2
+
+#       not c
+#       =begin
+#       mul
+#       ti
+#       line
+#       =end
+#       preceding code  \t # c3
+#       CODE
+#       cs = code.inline_comments
+#       expect(cs.map &:line_number         ).to eq [1, 3, 4]
+#       expect(cs.map &:column_number       ).to eq [1, 1, 18]
+#       expect(cs.map &:preceding_whitespace).to eq ["", "", "  \t "]
+#       expect(cs.map &:text                ).to eq ['# c1', '# c2', '# c3']
+
+#       preceding_whitespace_range
+#       comment_range
+
+#       expect(code.inline_comments.map &:ra)
+#       multilines = code.multiline_comments
+#     end
+
+#     it 'finds multiline comments'
+
+#     it 'finds comments in syntactically invalid files'
+#   end
+
+#   it 'knows whether a string is a heredoc'
+#   it 'knows if the file is syntactically valid'
+#   it 'knows whether there is a data segment'
+#   it 'knows what line the data segment starts on'
+#   it 'knows how many lines there are'
+#   it 'provides the ast'
+#   it 'provides the ability to rewrite code'
+#   it 'provides access to the source with #[]'
+# end