ripper_ruby_parser 1.7.2 → 1.8.0

data/Rakefile

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require "rake/clean"
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-namespace :test do
-  Rake::TestTask.new(:unit) do |t|
-    t.libs = ["lib"]
-    t.test_files = FileList["test/ripper_ruby_parser/**/*_test.rb"]
-    t.warning = true
-  end
-
-  Rake::TestTask.new(:end_to_end) do |t|
-    t.libs = ["lib"]
-    t.test_files = FileList["test/end_to_end/*_test.rb"]
-    t.warning = true
-  end
-
-  Rake::TestTask.new(:pt_testcase) do |t|
-    t.libs = ["lib"]
-    t.test_files = FileList["test/pt_testcase/*_test.rb"]
-    t.warning = true
-  end
-
-  desc "Run all three test suites"
-  task run: [:unit, :end_to_end, :pt_testcase]
-end
-
-desc "Alias to test:run"
-task test: "test:run"
-
-task default: :test

data/test/end_to_end/comments_test.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "ruby_parser"
-
-describe "Using RipperRubyParser and RubyParser" do
-  let :newparser do
-    RipperRubyParser::Parser.new
-  end
-
-  let :oldparser do
-    RubyParser.for_current_ruby
-  end
-
-  describe "for a program with quite some comments" do
-    let :program do
-      <<-RUBY
-      # Foo
-      class Foo
-        # The foo
-        # method
-        def foo
-          bar # bar
-          # internal comment
-        end
-
-        def bar
-          baz
-        end
-      end
-      # Quux
-      module Qux
-        class Quux
-          def bar
-          end
-          def baz
-          end
-        end
-      end
-      RUBY
-    end
-
-    let :original do
-      oldparser.parse program
-    end
-
-    let :imitation do
-      newparser.parse program
-    end
-
-    it "gives the same result" do
-      _(imitation).must_equal original
-    end
-
-    it "gives the same result with comments" do
-      _(to_comments(imitation)).must_equal to_comments(original)
-    end
-  end
-end

data/test/end_to_end/comparison_test.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "ruby_parser"
-
-describe "Using RipperRubyParser and RubyParser" do
-  describe "for a simple well known program" do
-    let :program do
-      "puts 'Hello World'"
-    end
-
-    it "gives the same result with line numbers" do
-      _(program).must_be_parsed_as_before with_line_numbers: true
-    end
-  end
-
-  describe "for a more complex program" do
-    let :program do
-      <<-RUBY
-      module Quux
-        class Foo
-          def bar
-            baz = 3
-            qux baz
-          end
-          def qux it
-            if it == 3
-              [1,2,3].map {|i| 2*i}
-            end
-          end
-        end
-      end
-
-      Quux::Foo.new.bar
-      RUBY
-    end
-
-    it "gives the same result with line numbers" do
-      _(program).must_be_parsed_as_before with_line_numbers: true
-    end
-  end
-
-  describe "for an example with yield from Reek" do
-    let :program do
-      "def fred() yield(3) if block_given?; end"
-    end
-
-    it "gives the same result with line numbers" do
-      _(program).must_be_parsed_as_before with_line_numbers: true
-    end
-  end
-
-  describe "for an example with floats from Reek" do
-    let :program do
-      <<-RUBY
-        def total_envy
-          fred = @item
-          total = 0
-          total += fred.price
-          total += fred.tax
-          total *= 1.15
-        end
-      RUBY
-    end
-
-    it "gives the same result with line numbers" do
-      _(program).must_be_parsed_as_before with_line_numbers: true
-    end
-  end
-
-  describe "for an example with operators and explicit block parameter from Reek" do
-    let :program do
-      <<-RUBY
-        def parse(arg, argv, &error)
-          if !(val = arg) and (argv.empty? or /\\A-/ =~ (val = argv[0]))
-            return nil, block, nil
-          end
-          opt = (val = parse_arg(val, &error))[1]
-          val = conv_arg(*val)
-          if opt and !arg
-            argv.shift
-          else
-            val[0] = nil
-          end
-          val
-        end
-      RUBY
-    end
-
-    it "gives the same result with line numbers" do
-      _(program).must_be_parsed_as_before with_line_numbers: true
-    end
-  end
-
-  describe "for an example of a complex regular expression from Reek" do
-    let :program do
-      "/(\#{@types})\\s*(\\w+)\\s*\\(([^)]*)\\)/"
-    end
-
-    it "gives the same result with line numbers" do
-      _(program).must_be_parsed_as_before with_line_numbers: true
-    end
-  end
-end

data/test/end_to_end/lib_comparison_test.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "ruby_parser"
-
-describe "Using RipperRubyParser and RubyParser" do
-  Dir.glob("lib/**/*.rb").each do |file|
-    describe "for #{file}" do
-      let :program do
-        File.read file
-      end
-
-      it "gives the same result" do
-        _(program).must_be_parsed_as_before
-      end
-    end
-  end
-end

data/test/end_to_end/line_numbering_test.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "ruby_parser"
-
-describe "Using RipperRubyParser and RubyParser" do
-  describe "for a multi-line program" do
-    let :program do
-      <<-RUBY
-      class Foo
-        def foo()
-          bar()
-          baz(qux)
-        end
-      end
-
-      module Bar
-        @@baz = {}
-      end
-      RUBY
-    end
-
-    it "gives the same result" do
-      _(program).must_be_parsed_as_before
-    end
-
-    it "gives the same result with line numbers" do
-      _(program).must_be_parsed_as_before with_line_numbers: true
-    end
-  end
-end

data/test/end_to_end/samples_comparison_test.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "ruby_parser"
-
-describe "Using RipperRubyParser and RubyParser" do
-  Dir.glob(File.expand_path("../samples/*.rb", File.dirname(__FILE__))).each do |file|
-    it "gives the same result for #{file}" do
-      program = File.read file
-      _(program).must_be_parsed_as_before
-    end
-  end
-end

data/test/end_to_end/test_comparison_test.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "ruby_parser"
-
-describe "Using RipperRubyParser and RubyParser" do
-  Dir.glob("test/ripper_ruby_parser/**/*.rb").each do |file|
-    describe "for #{file}" do
-      let :program do
-        File.read file
-      end
-
-      it "gives the same result" do
-        _(program).must_be_parsed_as_before
-      end
-    end
-  end
-end

data/test/pt_testcase/pt_test.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "pt_testcase"
-
-class TestParser < RipperRubyParser::Parser
-  def process(input)
-    parse input
-  end
-end
-
-SKIPPED_TESTS = ["dstr_heredoc_windoze_sucks"].freeze
-
-class RubyParserTestCase < ParseTreeTestCase
-  def self.previous(_key)
-    "Ruby"
-  end
-
-  def self.generate_test(klass, node, data, input_name, _output_name)
-    if data["Ruby"].is_a? Array
-      klass.send :define_method, "test_#{node}" do
-        skip "Not a parser test"
-      end
-      return
-    end
-
-    if SKIPPED_TESTS.include? node
-      klass.send :define_method, "test_#{node}" do
-        skip "Can't or won't fix this difference"
-      end
-      return
-    end
-
-    super klass, node, data, input_name, "ParseTree"
-  end
-end
-
-class TestRuby19Parser < RubyParserTestCase
-  def setup
-    super
-
-    self.processor = TestParser.new
-  end
-end

data/test/ripper_ruby_parser/commenting_ripper_parser_test.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-
-describe RipperRubyParser::CommentingRipperParser do
-  def parse_with_builder(str)
-    builder = RipperRubyParser::CommentingRipperParser.new str
-    builder.parse
-  end
-
-  def empty_params_list
-    @empty_params_list ||= s(:params, *([nil] * 7))
-  end
-
-  describe "handling comments" do
-    # Handle different results for dynamic symbol strings. This was changed in
-    # Ruby 2.6.3 and up. See https://bugs.ruby-lang.org/issues/15670
-    let(:dsym_string_type) { RUBY_VERSION < "2.6.3" ? :xstring : :string_content }
-
-    it "produces a comment node surrounding a commented def" do
-      result = parse_with_builder "# Foo\ndef foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "# Foo\n",
-                                 s(:def,
-                                   s(:@ident, "foo", s(2, 4)),
-                                   empty_params_list,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(2, 12))), nil, nil, nil),
-                                   s(2, 0)))))
-    end
-
-    it "produces a blank comment node surrounding a def that has no comment" do
-      result = parse_with_builder "def foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "",
-                                 s(:def,
-                                   s(:@ident, "foo", s(1, 4)),
-                                   empty_params_list,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(1, 12))), nil, nil, nil),
-                                   s(1, 0)))))
-    end
-
-    it "produces a comment node surrounding a commented class" do
-      result = parse_with_builder "# Foo\nclass Foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "# Foo\n",
-                                 s(:class,
-                                   s(:const_ref, s(:@const, "Foo", s(2, 6))),
-                                   nil,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(2, 10))), nil, nil, nil),
-                                   s(2, 0)))))
-    end
-
-    it "produce a blank comment node surrounding a class that has no comment" do
-      result = parse_with_builder "class Foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "",
-                                 s(:class,
-                                   s(:const_ref, s(:@const, "Foo", s(1, 6))),
-                                   nil,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(1, 10))), nil, nil, nil),
-                                   s(1, 0)))))
-    end
-
-    it "produces a comment node surrounding a commented module" do
-      result = parse_with_builder "# Foo\nmodule Foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "# Foo\n",
-                                 s(:module,
-                                   s(:const_ref, s(:@const, "Foo", s(2, 7))),
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(2, 11))), nil, nil, nil),
-                                   s(2, 0)))))
-    end
-
-    it "produces a blank comment node surrounding a module that has no comment" do
-      result = parse_with_builder "module Foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "",
-                                 s(:module,
-                                   s(:const_ref, s(:@const, "Foo", s(1, 7))),
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(1, 11))), nil, nil, nil),
-                                   s(1, 0)))))
-    end
-
-    it "is not confused by a symbol containing a keyword" do
-      result = parse_with_builder ":class; def foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:symbol_literal, s(:symbol, s(:@kw, "class", s(1, 1)))),
-                               s(:comment,
-                                 "",
-                                 s(:def,
-                                   s(:@ident, "foo", s(1, 12)),
-                                   empty_params_list,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(1, 20))), nil, nil, nil),
-                                   s(1, 8)))))
-    end
-
-    it "is not confused by a dynamic symbol" do
-      result = parse_with_builder ":'foo'; def bar; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:dyna_symbol,
-                                 s(dsym_string_type,
-                                   s(:@tstring_content, "foo", s(1, 2), ":'"))),
-                               s(:comment,
-                                 "",
-                                 s(:def,
-                                   s(:@ident, "bar", s(1, 12)),
-                                   empty_params_list,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(1, 20))), nil, nil, nil),
-                                   s(1, 8)))))
-    end
-
-    it "is not confused by a dynamic symbol containing a class definition" do
-      result = parse_with_builder ":\"foo\#{class Bar;end}\""
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:dyna_symbol,
-                                 s(dsym_string_type,
-                                   s(:@tstring_content, "foo", s(1, 2), ':"'),
-                                   s(:string_embexpr,
-                                     s(:stmts,
-                                       s(:comment,
-                                         "",
-                                         s(:class,
-                                           s(:const_ref, s(:@const, "Bar", s(1, 13))),
-                                           nil,
-                                           s(:bodystmt,
-                                             s(:stmts, s(:void_stmt, s(1, 17))),
-                                             nil, nil, nil),
-                                           s(1, 7)))))))))
-    end
-
-    it "turns an embedded document into a comment node" do
-      result = parse_with_builder "=begin Hello\nthere\n=end\nclass Foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "=begin Hello\nthere\n=end\n",
-                                 s(:class,
-                                   s(:const_ref, s(:@const, "Foo", s(4, 6))),
-                                   nil,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(4, 10))), nil, nil, nil),
-                                   s(4, 0)))))
-    end
-  end
-
-  describe "handling syntax errors" do
-    it "raises an error for an incomplete source" do
-      _(proc { parse_with_builder "def foo" }).must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error for an invalid class name" do
-      _(proc { parse_with_builder "class foo; end" })
-        .must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error aliasing $1 as foo" do
-      _(proc { parse_with_builder "alias foo $1" }).must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error aliasing foo as $1" do
-      _(proc { parse_with_builder "alias $1 foo" }).must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error aliasing $2 as $1" do
-      _(proc { parse_with_builder "alias $1 $2" }).must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error assigning to $1" do
-      _(proc { parse_with_builder "$1 = foo" }).must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error using an invalid parameter name" do
-      _(proc { parse_with_builder "def foo(BAR); end" })
-        .must_raise RipperRubyParser::SyntaxError
-    end
-  end
-end