ripper_ruby_parser 1.6.0 → 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
-      <<-END
-      # 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
-      END
-    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' do
-      program.must_be_parsed_as_before
-    end
-  end
-
-  describe 'for a more complex program' do
-    let :program do
-      <<-END
-      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
-      END
-    end
-
-    it 'gives the same result' do
-      program.must_be_parsed_as_before
-    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' do
-      program.must_be_parsed_as_before
-    end
-  end
-
-  describe 'for an example with floats from Reek' do
-    let :program do
-      <<-END
-        def total_envy
-          fred = @item
-          total = 0
-          total += fred.price
-          total += fred.tax
-          total *= 1.15
-        end
-      END
-    end
-
-    it 'gives the same result' do
-      program.must_be_parsed_as_before
-    end
-  end
-
-  describe 'for an example with operators and explicit block parameter from Reek' do
-    let :program do
-      <<-END
-        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
-      END
-    end
-
-    it 'gives the same result' do
-      program.must_be_parsed_as_before
-    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' do
-      program.must_be_parsed_as_before
-    end
-  end
-end

data/test/end_to_end/lib_comparison_test.rb

@@ -1,29 +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
-
-  Dir.glob('lib/**/*.rb').each do |file|
-    describe "for #{file}" do
-      let :program do
-        File.read file
-      end
-
-      it 'gives the same result' do
-        original = oldparser.parse program
-        imitation = newparser.parse program
-
-        formatted(imitation).must_equal formatted(original)
-      end
-    end
-  end
-end

data/test/end_to_end/line_numbering_test.rb

@@ -1,64 +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
-  def to_line_numbers(exp)
-    exp.map! do |sub_exp|
-      if sub_exp.is_a? Sexp
-        to_line_numbers sub_exp
-      else
-        sub_exp
-      end
-    end
-
-    if exp.sexp_type == :scope
-      exp
-    else
-      s(:line_number, exp.line, exp)
-    end
-  end
-
-  let :newparser do
-    RipperRubyParser::Parser.new
-  end
-
-  let :oldparser do
-    RubyParser.for_current_ruby
-  end
-
-  describe 'for a multi-line program' do
-    let :program do
-      <<-END
-      class Foo
-        def foo()
-          bar()
-          baz(qux)
-        end
-      end
-
-      module Bar
-        @@baz = {}
-      end
-      END
-    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 line numbers' do
-      formatted(to_line_numbers(imitation)).
-        must_equal formatted(to_line_numbers(original))
-    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,32 +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
-
-  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
-        # Clone string because ruby_parser destroys it when there's a heredoc
-        # inside.
-        copy = program.clone
-        original = oldparser.parse program
-        imitation = newparser.parse copy
-
-        formatted(imitation).must_equal formatted(original)
-      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,190 +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
-    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)), nil, nil, nil)))))
-    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)), nil, nil, nil)))))
-    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)), nil, nil, nil)))))
-    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)), nil, nil, nil)))))
-    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)), nil, nil, nil)))))
-    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)), nil, nil, nil)))))
-    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)), nil, nil, nil)))))
-    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(:xstring, 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)), nil, nil, nil)))))
-    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(:xstring,
-                                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)),
-                                          nil,
-                                          nil,
-                                          nil)))))))))
-    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)), nil, nil, nil)))))
-    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