parser 2.7.1.5 → 2.7.2.0

data/test/racc_coverage_helper.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require 'racc/grammarfileparser'
-
-# Unfortunately, Ruby's Coverage module ignores module_eval statements,
-# which Racc uses to map `parser.y` locations in the generated
-# `parser.rb`.
-module RaccCoverage
-  @coverage  = {}
-  @base_path = nil
-  @trace     = nil
-
-  def self.start(parsers, base_path)
-    @base_path = base_path
-
-    parsers.each do |parser|
-      @coverage[parser] = extract_interesting_lines(parser, base_path)
-    end
-
-    @trace = TracePoint.new(:line) do |trace|
-      lineno = trace.lineno - 1
-
-      if (line_coverage = @coverage[trace.path])
-        if line_coverage[lineno]
-          line_coverage[lineno] += 1
-        end
-      end
-    end
-    @trace.enable
-  end
-
-  def self.stop
-    @trace.disable
-  end
-
-  # Ruby's TracePoint#lineno will point only on "interesting" lines,
-  # i.e.: only code (no comments or empty lines), no `end` keywords,
-  # and for multi-line statements, only the first line of the statement.
-  #
-  # This method implements a very dumb Ruby parser, which skips empty lines
-  # or lines with just comments, `end` keywords, and correctly handles
-  # multi-line statements of the following form:
-  #
-  #  * All lines of the statement except the last must end with `,`, `.` or `(`.
-  #
-  # Coverage can be disabled for code regions with annotations :nocov: and :cov:.
-  #
-  # Also, for best results, all actions should be delimited by at least
-  # one non-action line.
-  #
-  def self.extract_interesting_lines(parser, base_path)
-    grammar_source = File.join(@base_path, parser)
-    grammar_file   = Racc::GrammarFileParser.parse_file(grammar_source)
-
-    ruby_sources = [
-      # Header and footer aren't passed through module_eval
-      # in Racc-generated file, so the location info is lost.
-      *grammar_file.params.inner,
-    ].compact
-
-    grammar_file.grammar.each_rule do |rule|
-      source = rule.action.source
-      next if source.nil?
-
-      ruby_sources << source
-    end
-
-    lines = []
-
-    ruby_sources.each do |source|
-      first_line = source.lineno
-
-      state = :first_line
-
-      source.text.each_line.with_index do |line, index|
-        line = line.strip
-
-        continues = line.end_with?(',')   ||
-                      line.end_with?('(') ||
-                      line.end_with?('.')
-
-        case state
-        when :first_line
-          if line =~ /:nocov/
-            state = :nocov
-            next
-          elsif line.empty?   ||
-                  line == 'end' ||
-                  line.start_with?('#')
-            next
-          elsif continues
-            state = :mid_line
-          end
-
-          lines[first_line + index - 1] = 0
-
-        when :mid_line
-          unless continues
-            state = :first_line
-          end
-
-        when :nocov
-          if line =~ /:cov:/
-            state = :first_line
-          end
-        end
-      end
-    end
-
-    lines
-  end
-
-  def self.result
-    result =
-      @coverage.map do |parser, coverage|
-        [File.join(@base_path, parser), coverage]
-      end
-
-    Hash[result]
-  end
-end
-
-class << SimpleCov
-  def result_with_racc_coverage
-    @result ||= SimpleCov::Result.new(
-                  Coverage.result.merge(RaccCoverage.result))
-
-    result_without_racc_coverage
-  end
-
-  alias result_without_racc_coverage result
-  alias result result_with_racc_coverage
-end

data/test/test_ast_processor.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-
-class TestASTProcessor < Minitest::Test
-  LEAF_NODES = %i[
-    sym str int float complex rational
-    true false nil self
-    __FILE__ __LINE__ __ENCODING__
-    cbase regopt zsuper
-    match_with_trailing_comma match_nil_pattern
-    forward_args forwarded_args numargs kwnilarg
-    objc_varargs objc_restarg objc_kwarg
-    ident
-  ].freeze
-
-  def setup
-    @traversible = Parser::AST::Processor
-      .instance_methods(false)
-      .map { |mid| mid.to_s.scan(/\Aon_(.*)/) }
-      .flatten
-      .map(&:to_sym)
-
-    @traversible += LEAF_NODES
-  end
-
-  def test_nodes_are_traversible
-    for_each_node do |node|
-      assert_includes @traversible, node.type
-    end
-  end
-end

data/test/test_base.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'parser/current'
-
-class TestBase < Minitest::Test
-  include AST::Sexp
-
-  def test_parse
-    ast = Parser::CurrentRuby.parse('1')
-    assert_equal s(:int, 1), ast
-  end
-
-  def test_parse_with_comments
-    ast, comments = Parser::CurrentRuby.parse_with_comments('1 # foo')
-    assert_equal s(:int, 1), ast
-    assert_equal 1, comments.size
-    assert_equal '# foo', comments.first.text
-  end
-
-  def test_loc_to_node
-    ast = Parser::CurrentRuby.parse('1')
-    assert_equal ast.loc.node, ast
-  end
-
-  def test_loc_dup
-    ast = Parser::CurrentRuby.parse('1')
-    assert_nil ast.loc.dup.node
-    Parser::AST::Node.new(:zsuper, [], :location => ast.loc)
-  end
-end

data/test/test_current.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'parser/current'
-
-class TestCurrent < Minitest::Test
-  def test_current
-    case RUBY_VERSION
-    when '2.0.0'
-      assert_equal Parser::Ruby20, Parser::CurrentRuby
-    when /^2\.1\.\d+/
-      assert_equal Parser::Ruby21, Parser::CurrentRuby
-    when /^2\.2\.\d+/
-      assert_equal Parser::Ruby22, Parser::CurrentRuby
-    when /^2\.3\.\d+/
-      assert_equal Parser::Ruby23, Parser::CurrentRuby
-    when /^2\.4\.\d+/
-      assert_equal Parser::Ruby24, Parser::CurrentRuby
-    when /^2\.5\.\d+/
-      assert_equal Parser::Ruby25, Parser::CurrentRuby
-    when /^2\.6\.\d+/
-      assert_equal Parser::Ruby26, Parser::CurrentRuby
-    when /^2\.7\.\d+/
-      assert_equal Parser::Ruby27, Parser::CurrentRuby
-    when /^3\.0\.\d+/
-      assert_equal Parser::Ruby30, Parser::CurrentRuby
-    else
-      flunk "Update test_current for #{RUBY_VERSION}"
-    end
-  end
-end

data/test/test_diagnostic.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-
-class TestDiagnostic < Minitest::Test
-  def setup
-    @buffer = Parser::Source::Buffer.new('(string)',
-      source: 'if (this is some bad code + bugs)')
-
-    @range1 = Parser::Source::Range.new(@buffer, 0, 2) # if
-    @range2 = Parser::Source::Range.new(@buffer, 4, 8) # this
-  end
-
-  def test_verifies_levels
-    error = assert_raises ArgumentError do
-      Parser::Diagnostic.new(:foobar, :escape_eof, {}, @range1)
-    end
-
-    assert_match(/level/, error.message)
-  end
-
-  def test_freezes
-    string     = 'foo'.dup
-    highlights = [@range2]
-
-    diag = Parser::Diagnostic.new(:error, :escape_eof, @range1, highlights)
-    assert diag.frozen?
-    assert diag.arguments.frozen?
-    assert diag.highlights.frozen?
-
-    refute string.frozen?
-    refute highlights.frozen?
-  end
-
-  def test_render
-    location = Parser::Source::Range.new(@buffer, 26, 27)
-
-    highlights = [
-      Parser::Source::Range.new(@buffer, 21, 25),
-      Parser::Source::Range.new(@buffer, 28, 32)
-    ]
-
-    diag  = Parser::Diagnostic.new(:error, :unexpected, { :character => '+' },
-                                   location, highlights)
-    assert_equal([
-      "(string):1:27: error: unexpected `+'",
-      '(string):1: if (this is some bad code + bugs)',
-      '(string):1:                      ~~~~ ^ ~~~~ '
-    ], diag.render)
-  end
-
-  def test_multiline_render
-    @buffer = Parser::Source::Buffer.new('(string)',
-      source: "abc abc abc\ndef def def\nghi ghi ghi\n")
-
-    location = Parser::Source::Range.new(@buffer, 4, 27)
-
-    highlights = [
-      Parser::Source::Range.new(@buffer, 0, 3),
-      Parser::Source::Range.new(@buffer, 28, 31)
-    ]
-
-    diag = Parser::Diagnostic.new(:error, :unexpected_token, { :token => 'ghi' },
-                                  location, highlights)
-
-    assert_equal([
-      "(string):1:5-3:3: error: unexpected token ghi",
-      '(string):1: abc abc abc',
-      '(string):1: ~~~ ^~~~~~~...',
-      '(string):3: ghi ghi ghi',
-      '(string):3: ~~~ ~~~    '
-    ], diag.render)
-  end
-
-  def test_bug_error_on_newline
-    # regression test; see GitHub issue 273
-    source = <<-CODE
-{
-  foo: ->() # I forgot my brace
-  }
-}
-    CODE
-    @buffer = Parser::Source::Buffer.new('(string)', source: source)
-
-    location = Parser::Source::Range.new(@buffer, 33, 34)
-    diag = Parser::Diagnostic.new(:error, :unexpected_token, { :token => 'tNL' },
-                                  location)
-
-    assert_equal([
-      '(string):2:32: error: unexpected token tNL',
-      '(string):2:   foo: ->() # I forgot my brace',
-      '(string):2:                                ^'
-    ], diag.render)
-  end
-end

data/test/test_diagnostic_engine.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-
-class TestDiagnosticEngine < Minitest::Test
-  def setup
-    @engine = Parser::Diagnostic::Engine.new
-
-    @queue  = []
-    @engine.consumer = lambda { |diag| @queue << diag }
-  end
-
-  def test_process_warnings
-    warn = Parser::Diagnostic.new(:warning, :invalid_escape, {}, 1..2)
-    @engine.process(warn)
-
-    assert_equal [warn], @queue
-  end
-
-  def test_ignore_warnings
-    @engine.ignore_warnings = true
-
-    warn = Parser::Diagnostic.new(:warning, :invalid_escape, {}, 1..2)
-    @engine.process(warn)
-
-    assert_equal [], @queue
-  end
-
-  def test_all_errors_are_fatal
-    @engine.all_errors_are_fatal = true
-
-    error = Parser::Diagnostic.new(:error, :invalid_escape, {}, 1..2)
-
-    err = assert_raises Parser::SyntaxError do
-      @engine.process(error)
-    end
-
-    assert_equal error, err.diagnostic
-
-    assert_equal [error], @queue
-  end
-
-  def test_all_errors_are_collected
-    error = Parser::Diagnostic.new(:error, :invalid_escape, {}, 1..2)
-    @engine.process(error)
-
-    assert_equal [error], @queue
-  end
-
-  def test_fatal_error
-    fatal = Parser::Diagnostic.new(:fatal, :invalid_escape, {}, 1..2)
-
-    assert_raises Parser::SyntaxError do
-      @engine.process(fatal)
-    end
-
-    assert_equal [fatal], @queue
-  end
-end

data/test/test_encoding.rb

@@ -1,99 +0,0 @@
-# encoding: binary
-# frozen_string_literal: true
-
-require 'helper'
-
-class TestEncoding < Minitest::Test
-  include AST::Sexp
-
-  def recognize(string)
-    Parser::Source::Buffer.recognize_encoding(string)
-  end
-
-  require 'parser/all'
-
-  def test_default
-    assert_nil recognize('foobar')
-  end
-
-  def test_bom
-    assert_equal Encoding::UTF_8, recognize("\xef\xbb\xbf\nfoobar")
-    assert_equal Encoding::UTF_8, recognize("\xef\xbb\xbf# coding:koi8-r\nfoobar")
-  end
-
-  def test_magic_comment
-    assert_equal Encoding::KOI8_R, recognize("# coding:koi8-r\nfoobar")
-  end
-
-  def test_shebang
-    assert_equal Encoding::KOI8_R, recognize("#!/bin/foo\n# coding:koi8-r\nfoobar")
-    assert_nil recognize("#!/bin/foo\n")
-  end
-
-  def test_case
-    assert_equal Encoding::KOI8_R, recognize("# coding:KoI8-r\nfoobar")
-  end
-
-  def test_space
-    assert_equal Encoding::KOI8_R, recognize("# coding : koi8-r\nfoobar")
-  end
-
-  def test_empty
-    assert_nil recognize('')
-  end
-
-  def test_no_comment
-    assert_nil recognize(%{require 'cane/encoding_aware_iterator'})
-  end
-
-  def test_adjacent
-    assert_nil recognize('# codingkoi8-r')
-    assert_nil recognize('# coding koi8-r')
-  end
-
-  def test_utf8_mac
-    assert_equal Encoding::UTF8_MAC, recognize('# coding: utf8-mac')
-  end
-
-  def test_suffix
-    assert_equal Encoding::UTF_8, recognize('# coding: utf-8-dos')
-    assert_equal Encoding::UTF_8, recognize('# coding: utf-8-unix')
-    assert_equal Encoding::UTF_8, recognize('# coding: utf-8-mac')
-
-    assert_raises(ArgumentError) do
-      assert_nil recognize('# coding: utf-8-dicks')
-    end
-  end
-
-  def test_parse_18_invalid_enc
-    ast = Parser::Ruby18.parse("# encoding:feynman-diagram\n1")
-    assert_equal ast, s(:int, 1)
-  end
-
-  def test_parse_19_invalid_enc
-    assert_raises(ArgumentError) do
-      Parser::Ruby19.parse("# encoding:feynman-diagram\n1")
-    end
-  end
-
-  def test_ending_comment
-    assert_nil recognize('foo # coding: koi8-r')
-  end
-
-  def test_wrong_prefix
-    assert_nil recognize('# decoding: koi8-r')
-  end
-
-  def test_no_spaces
-    assert_equal Encoding::KOI8_R, recognize('#encoding:koi8-r')
-    assert_equal Encoding::KOI8_R, recognize('#coding:koi8-r')
-  end
-
-  def test_underscore_and_star_characters
-    assert_equal Encoding::KOI8_R, recognize('# -*- encoding: koi8-r -*-')
-  end
-
-  def test_garbage_around_encoding_comment
-    assert_equal Encoding::KOI8_R, recognize('# 1$# -*- &)* encoding: koi8-r 1$# -*- &)*')
-  end
-end