parser 2.7.1.5 → 2.7.2.0

data/test/test_runner_parse.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'open3'
-
-class TestRunnerParse < Minitest::Test
-  PATH_TO_RUBY_PARSE = File.expand_path('../bin/ruby-parse', __dir__).freeze
-
-  def assert_prints(argv, expected_output)
-    stdout, _stderr, status = Open3.capture3(PATH_TO_RUBY_PARSE, *argv)
-
-    assert_equal 0, status.to_i
-    assert_includes(stdout, expected_output)
-  end
-
-  def test_emit_ruby
-    assert_prints ['--emit-ruby', '-e 123'],
-                  's(:int, 123)'
-  end
-
-  def test_emit_modern_ruby
-    assert_prints ['-e', '->{}'],
-                  '(lambda)'
-    assert_prints ['-e', 'self[1] = 2'],
-                  'indexasgn'
-  end
-
-  def test_emit_legacy
-    assert_prints ['--legacy', '-e', '->{}'],
-                  '(send nil :lambda)'
-    assert_prints ['--legacy', '-e', 'self[1] = 2'],
-                  ':[]='
-  end
-
-  def test_emit_legacy_lambda
-    assert_prints ['--legacy-lambda', '-e', '->{}'],
-                  '(send nil :lambda)'
-    assert_prints ['--legacy-lambda', '-e', 'self[1] = 2'],
-                  'indexasgn'
-  end
-
-  def test_emit_json
-    assert_prints ['--emit-json', '-e', '123'],
-                  '["int",123]'
-  end
-
-  def test_emit_ruby_empty
-    assert_prints ['--emit-ruby', '-e', ''],
-                  "\n"
-  end
-
-  def test_emit_json_empty
-    assert_prints ['--emit-json', '-e', ''],
-                  "\n"
-  end
-end

data/test/test_runner_rewrite.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-require 'fileutils'
-require 'shellwords'
-require 'open3'
-
-BASE_DIR = Pathname.new(__FILE__) + '..'
-require (BASE_DIR + 'helper').expand_path
-
-class TestRunnerRewrite < Minitest::Test
-  def assert_rewriter_output(path, args, input: 'input.rb', output: 'output.rb', expected_output: '', expected_error: '')
-    @ruby_rewrite = BASE_DIR.expand_path + '../bin/ruby-rewrite'
-    @test_dir     = BASE_DIR + path
-    @fixtures_dir = @test_dir + 'fixtures'
-
-    Dir.mktmpdir("parser", BASE_DIR.expand_path.to_s) do |tmp_dir|
-      tmp_dir = Pathname.new(tmp_dir)
-      sample_file = tmp_dir + "#{path}.rb"
-      sample_file_expanded = sample_file.expand_path
-      expected_file = @fixtures_dir + output
-
-      FileUtils.cp(@fixtures_dir + input, sample_file_expanded)
-      stdout, stderr, _exit_code = Dir.chdir @test_dir do
-        Open3.capture3 %Q{
-          #{Shellwords.escape(@ruby_rewrite.to_s)} #{args} \
-          #{Shellwords.escape(sample_file_expanded.to_s)}
-        }
-      end
-
-      assert_equal expected_output.chomp, stdout.chomp
-      assert_match expected_error.chomp, stderr.chomp
-      assert_equal File.read(expected_file.expand_path), File.read(sample_file)
-    end
-  end
-
-  def test_rewriter_bug_163
-    assert_rewriter_output('bug_163',
-      '--modify  -l rewriter.rb',
-      expected_error: Parser::Rewriter::DEPRECATION_WARNING
-    )
-  end
-
-  def test_tree_rewriter
-    assert_rewriter_output('using_tree_rewriter', '-l using_tree_rewriter.rb --modify')
-  end
-end

data/test/test_source_buffer.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-
-class TestSourceBuffer < Minitest::Test
-  def setup
-    @buffer = Parser::Source::Buffer.new('(string)')
-  end
-
-  def test_initialize
-    buffer = Parser::Source::Buffer.new(nil)
-    assert_equal '', buffer.name
-
-    buffer = Parser::Source::Buffer.new(Pathname('a/b'))
-    assert_equal 'a/b', buffer.name
-
-    buffer = Parser::Source::Buffer.new('(string)')
-    assert_equal '(string)', buffer.name
-    assert_equal 1, buffer.first_line
-
-    buffer = Parser::Source::Buffer.new('(string)', 5)
-    assert_equal 5, buffer.first_line
-
-    buffer = Parser::Source::Buffer.new('(string)', source: '2+2')
-    assert_equal '2+2', buffer.source
-  end
-
-  def test_source_setter
-    @buffer.source = 'foo'
-    assert_equal 'foo', @buffer.source
-
-    assert @buffer.source.frozen?
-  end
-
-  def test_source_double_setter
-    @buffer.source = 'foo'
-
-    assert_raises(ArgumentError) do
-      @buffer.source = 'bar'
-    end
-  end
-
-  def test_source_setter_encoding_error
-    error = assert_raises EncodingError do
-      @buffer.source = [
-        '# encoding: utf-8',
-        "# \xf9"
-      ].join("\n")
-    end
-
-    assert_match(/invalid byte sequence in UTF\-8/, error.message)
-  end
-
-  def test_read
-    tempfile = Tempfile.new('parser')
-    tempfile.write('foobar')
-    tempfile.flush
-
-    buffer = Parser::Source::Buffer.new(tempfile.path)
-    buffer.read
-    assert_equal 'foobar', buffer.source
-
-    assert buffer.source.frozen?
-  end
-
-  def test_uninitialized
-    assert_raises RuntimeError do
-      @buffer.source
-    end
-  end
-
-  def test_decompose_position
-    @buffer.source = "1\nfoo\nbar"
-
-    assert_equal [1, 0], @buffer.decompose_position(0)
-    assert_equal [1, 1], @buffer.decompose_position(1)
-    assert_equal [2, 0], @buffer.decompose_position(2)
-    assert_equal [3, 1], @buffer.decompose_position(7)
-  end
-
-  def test_decompose_position_mapped
-    @buffer = Parser::Source::Buffer.new('(string)', 5)
-    @buffer.source = "1\nfoo\nbar"
-
-    assert_equal [5, 0], @buffer.decompose_position(0)
-    assert_equal [6, 0], @buffer.decompose_position(2)
-  end
-
-  def test_line
-    @buffer.source = "1\nfoo\nbar"
-
-    assert_equal '1', @buffer.source_line(1)
-    assert_equal 'foo', @buffer.source_line(2)
-  end
-
-  def test_line_mutate
-    @buffer.source = "1\nfoo\nbar"
-
-    assert_equal '1', @buffer.source_line(1)
-
-    @buffer.source_line(1)[0] = '2'
-    assert_equal '1', @buffer.source_line(1)
-  end
-
-  def test_line_mapped
-    @buffer = Parser::Source::Buffer.new('(string)', 5)
-    @buffer.source = "1\nfoo\nbar"
-
-    assert_equal '1', @buffer.source_line(5)
-    assert_equal 'foo', @buffer.source_line(6)
-  end
-
-  def test_line_range
-    @buffer = Parser::Source::Buffer.new('(string)', 5)
-    @buffer.source = "abc\ndef\nghi\n"
-
-    assert_raises IndexError do
-      @buffer.line_range(4)
-    end
-    assert_equal 'abc', @buffer.line_range(5).source
-    assert_equal 'def', @buffer.line_range(6).source
-    assert_equal 'ghi', @buffer.line_range(7).source
-    assert_equal '', @buffer.line_range(8).source
-    assert_raises IndexError do
-      @buffer.line_range(9)
-    end
-  end
-
-  def test_source_range
-    @buffer = Parser::Source::Buffer.new('(string)', 5)
-
-    assert_raises RuntimeError do
-      @buffer.source_range
-    end
-
-    @buffer.source = "abc\ndef\nghi\n"
-
-    assert_equal Parser::Source::Range.new(@buffer, 0, @buffer.source.size), @buffer.source_range
-  end
-
-  def test_last_line
-    @buffer.source = "1\nfoo\nbar"
-    assert_equal 3, @buffer.last_line
-
-    @buffer = Parser::Source::Buffer.new('(string)', 5)
-    @buffer.source = ""
-    assert_equal 5, @buffer.last_line
-
-    @buffer = Parser::Source::Buffer.new('(string)', 5)
-    @buffer.source = "abc\n"
-    assert_equal 6, @buffer.last_line
-  end
-
-  def test_source_lines
-    @buffer.source = "1\nfoo\nbar\n"
-
-    assert_equal ['1', 'foo', 'bar', ''], @buffer.source_lines
-    assert @buffer.source_lines.frozen?
-    assert @buffer.source_lines.all?(&:frozen?)
-
-    @buffer = Parser::Source::Buffer.new('(string)', 5)
-    @buffer.source = "foo\nbar"
-    assert_equal ['foo', 'bar'], @buffer.source_lines
-  end
-end

data/test/test_source_comment.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-
-class TestSourceComment < Minitest::Test
-  def setup
-    @buf = Parser::Source::Buffer.new('(string)',
-      source: "# foo\n=begin foo\nbar\n=end baz\n")
-  end
-
-  def range(s, e)
-    Parser::Source::Range.new(@buf, s, e)
-  end
-
-  def test_initialize
-    comment = Parser::Source::Comment.new(range(0, 5))
-    assert comment.frozen?
-  end
-
-  def test_text
-    comment = Parser::Source::Comment.new(range(0, 5))
-    assert_equal '# foo', comment.text
-  end
-
-  def test_inline
-    comment = Parser::Source::Comment.new(range(0, 5))
-    assert_equal :inline, comment.type
-    assert comment.inline?
-  end
-
-  def test_document
-    comment = Parser::Source::Comment.new(range(6, 25))
-    assert_equal :document, comment.type
-    assert comment.document?
-  end
-end

data/test/test_source_comment_associator.rb

@@ -1,399 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'parser/ruby18'
-
-class TestSourceCommentAssociator < Minitest::Test
-  def parse_with_comments(code)
-    parser = Parser::Ruby18.new
-
-    buffer = Parser::Source::Buffer.new('(comments)')
-    buffer.source = code
-
-    parser.parse_with_comments(buffer)
-  end
-
-  def associate(code)
-    ast, comments = parse_with_comments(code)
-    associations  = Parser::Source::Comment.associate(ast, comments)
-
-    [ ast, associations ]
-  end
-
-  def associate_locations(code)
-    ast, comments = parse_with_comments(code)
-    associations  = Parser::Source::Comment.associate_locations(ast, comments)
-
-    [ ast, associations ]
-  end
-
-  def test_associate
-    ast, associations = associate(<<-END)
-#!/usr/bin/env ruby
-# coding: utf-8
-# class preceding
-# another class preceding
-class Foo # class keyword line
-  # method foo preceding
-  def foo
-    puts 'foo'
-  end # method foo decorating
-  # method bar preceding
-  def bar
-    # expression preceding
-    1 + # 1 decorating
-      2
-    # method bar sparse
-  end # method bar decorating
-  # class sparse
-end # class decorating
-    END
-
-    klass_node      = ast
-    klass_name_node = klass_node.children[0]
-    foo_node        = klass_node.children[2].children[0] # def foo
-    bar_node        = klass_node.children[2].children[1] # def bar
-    expr_node       = bar_node.children[2] # 1 + 2
-    one_node        = expr_node.children[0] # 1
-
-    assert_equal 6, associations.size
-    assert_equal [
-      '# class preceding',
-      '# another class preceding',
-      '# class sparse',
-      '# class decorating'
-    ], associations[klass_node].map(&:text)
-    assert_equal [
-      '# class keyword line'
-    ], associations[klass_name_node].map(&:text)
-    assert_equal [
-      '# method foo preceding',
-      '# method foo decorating'
-    ], associations[foo_node].map(&:text)
-    assert_equal [
-      '# method bar preceding',
-      '# method bar sparse',
-      '# method bar decorating'
-    ], associations[bar_node].map(&:text)
-    assert_equal [
-      '# expression preceding'
-    ], associations[expr_node].map(&:text)
-    assert_equal [
-      '# 1 decorating'
-    ], associations[one_node].map(&:text)
-  end
-
-  # The bug below is fixed by using associate_locations
-  def test_associate_dupe_statement
-    ast, associations = associate(<<-END)
-class Foo
-  def bar
-    f1 # comment on 1st call to f1
-    f2
-    f1 # comment on 2nd call to f1
-  end
-end
-    END
-
-    _klass_node        = ast
-    method_node        = ast.children[2]
-    body               = method_node.children[2]
-    f1_1_node          = body.children[0]
-    f1_2_node          = body.children[2]
-
-    assert_equal 1, associations.size
-    assert_equal ['# comment on 1st call to f1', '# comment on 2nd call to f1'],
-                 associations[f1_1_node].map(&:text)
-    assert_equal ['# comment on 1st call to f1', '# comment on 2nd call to f1'],
-                 associations[f1_2_node].map(&:text)
-  end
-
-  def test_associate_locations
-    ast, associations = associate_locations(<<-END)
-#!/usr/bin/env ruby
-# coding: utf-8
-# class preceding
-# another class preceding
-class Foo # class keyword line
-  # method foo preceding
-  def foo
-    puts 'foo'
-  end # method foo decorating
-  # method bar preceding
-  def bar
-    # expression preceding
-    1 + # 1 decorating
-      2
-    # method bar sparse
-  end # method bar decorating
-  # class sparse
-end # class decorating
-    END
-
-    klass_node      = ast
-    klass_name_node = klass_node.children[0]
-    foo_node        = klass_node.children[2].children[0] # def foo
-    bar_node        = klass_node.children[2].children[1] # def bar
-    expr_node       = bar_node.children[2] # 1 + 2
-    one_node        = expr_node.children[0] # 1
-
-    assert_equal 6, associations.size
-    assert_equal [
-      '# class preceding',
-      '# another class preceding',
-      '# class sparse',
-      '# class decorating'
-    ], associations[klass_node.loc].map(&:text)
-    assert_equal [
-      '# class keyword line'
-    ], associations[klass_name_node.loc].map(&:text)
-    assert_equal [
-      '# method foo preceding',
-      '# method foo decorating'
-    ], associations[foo_node.loc].map(&:text)
-    assert_equal [
-      '# method bar preceding',
-      '# method bar sparse',
-      '# method bar decorating'
-    ], associations[bar_node.loc].map(&:text)
-    assert_equal [
-      '# expression preceding'
-    ], associations[expr_node.loc].map(&:text)
-    assert_equal [
-      '# 1 decorating'
-    ], associations[one_node.loc].map(&:text)
-  end
-
-  def test_associate_locations_dupe_statement
-    ast, associations = associate_locations(<<-END)
-class Foo
-  def bar
-    f1 # comment on 1st call to f1
-    f2
-    f1 # comment on 2nd call to f1
-  end
-end
-    END
-
-    _klass_node        = ast
-    method_node        = ast.children[2]
-    body               = method_node.children[2]
-    f1_1_node          = body.children[0]
-    f1_2_node          = body.children[2]
-
-    assert_equal 2, associations.size
-    assert_equal ['# comment on 1st call to f1'],
-                 associations[f1_1_node.loc].map(&:text)
-    assert_equal ['# comment on 2nd call to f1'],
-                 associations[f1_2_node.loc].map(&:text)
-  end
-
-  def test_associate_no_body
-    ast, associations = associate(<<-END)
-# foo
-class Foo
-end
-    END
-
-    assert_equal 1, associations.size
-    assert_equal ['# foo'],
-                 associations[ast].map(&:text)
-  end
-
-  def test_associate_empty_tree
-    _ast, associations = associate("")
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_shebang_only
-    _ast, associations = associate(<<-END)
-#!ruby
-class Foo
-end
-    END
-
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_frozen_string_literal
-    _ast, associations = associate(<<-END)
-# frozen_string_literal: true
-class Foo
-end
-    END
-
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_frozen_string_literal_dash_star_dash
-    _ast, associations = associate(<<-END)
-# -*- frozen_string_literal: true -*-
-class Foo
-end
-    END
-
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_frozen_string_literal_no_space_after_colon
-    _ast, associations = associate(<<-END)
-# frozen_string_literal:true
-class Foo
-end
-    END
-
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_warn_indent
-    _ast, associations = associate(<<-END)
-# warn_indent: true
-class Foo
-end
-    END
-
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_warn_indent_dash_star_dash
-    _ast, associations = associate(<<-END)
-# -*- warn_indent: true -*-
-class Foo
-end
-    END
-
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_warn_past_scope
-    _ast, associations = associate(<<-END)
-# warn_past_scope: true
-class Foo
-end
-    END
-
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_warn_past_scope_dash_star_dash
-    _ast, associations = associate(<<-END)
-# -*- warn_past_scope: true -*-
-class Foo
-end
-    END
-
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_multiple
-    _ast, associations = associate(<<-END)
-# frozen_string_literal: true; warn_indent: true
-class Foo
-end
-    END
-
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_multiple_dash_star_dash
-    _ast, associations = associate(<<-END)
-# -*- frozen_string_literal: true; warn_indent: true -*-
-class Foo
-end
-    END
-
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_no_comments
-    _ast, associations = associate(<<-END)
-class Foo
-end
-    END
-
-    assert_equal 0, associations.size
-  end
-
-  def test_associate_comments_after_root_node
-    _ast, associations = associate(<<-END)
-class Foo
-end
-# not associated
-    END
-
-    assert_equal 0, associations.size
-  end
-
-
-  def test_associate_stray_comment
-    ast, associations = associate(<<-END)
-def foo
-  # foo
-end
-    END
-
-    assert_equal 1, associations.size
-    assert_equal ['# foo'],
-                 associations[ast].map(&:text)
-  end
-
-  def test_associate___ENCODING__
-    ast, associations = associate(<<-END)
-# foo
-__ENCODING__
-    END
-
-    assert_equal 1, associations.size
-    assert_equal ['# foo'],
-                 associations[ast].map(&:text)
-  end
-
-  def test_associate_inside_heredoc
-    ast, associations = associate(<<-END)
-<<x
-\#{
-  foo # bar
-}
-x
-    END
-
-    begin_node = ast.children[0]
-    send_node  = begin_node.children[0]
-
-    assert_equal 1, associations.size
-    assert_equal ['# bar'],
-                 associations[send_node].map(&:text)
-  end
-
-  def test_associate_conditional_parent_class
-    ast, associations = associate(<<-END)
-class Foo
-  # bar
-  class Bar
-  end
-end if some_condition
-    END
-
-    if_node = ast
-    _condition, foo_class = if_node.children
-    _foo, _sub_class, bar_class = foo_class.children
-
-    assert_equal 1, associations.size
-    assert_equal ['# bar'],
-                 associations[bar_class].map(&:text)
-  end
-
-  def test_children_in_source_order
-    obj = Parser::Source::Comment::Associator.new(nil, nil)
-    for_each_node do |node|
-      with_loc = node.children.select do |child|
-        child.is_a?(AST::Node) && child.loc && child.loc.expression
-      end
-      slow_sort = with_loc.sort_by.with_index do |child, index| # Index to ensure stable sort
-          [child.loc.expression.begin_pos, index]
-      end
-      optimized = obj.send(:children_in_source_order, node)
-      assert_equal slow_sort, optimized, "children_in_source_order incorrect for #{node}"
-    end
-  end
-end