ripper_ruby_parser 1.7.0 → 1.9.0

data/test/ripper_ruby_parser/sexp_processor_test.rb

@@ -1,303 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-
-class TestProcessor < RipperRubyParser::SexpProcessor
-  def process_foo(exp)
-    exp.shift
-    s(:foo_p)
-  end
-
-  def process_bar(exp)
-    exp.shift
-    s(:bar_p)
-  end
-
-  def process_baz(exp)
-    exp.shift
-    s(:baz_p)
-  end
-end
-
-describe RipperRubyParser::SexpProcessor do
-  let :processor do
-    TestProcessor.new
-  end
-
-  describe "#process" do
-    describe "for a :program sexp" do
-      it "strips off the outer :program node" do
-        sexp = s(:program, s(:stmts, s(:foo)))
-        result = processor.process sexp
-        _(result).must_equal s(:foo_p)
-      end
-
-      it "transforms a multi-statement :program into a :block sexp" do
-        sexp = s(:program, s(:stmts, s(:foo), s(:bar)))
-        result = processor.process sexp
-        _(result).must_equal s(:block, s(:foo_p), s(:bar_p))
-      end
-    end
-
-    describe "for a :string_literal sexp" do
-      it "transforms a simple sexp to :str" do
-        sexp = s(:string_literal,
-                 s(:string_content,
-                   s(:@tstring_content, "foo", s(1, 1), '"')))
-        result = processor.process sexp
-        _(result).must_equal s(:str, "foo")
-      end
-    end
-
-    describe "for a :command sexp" do
-      it "transforms a sexp to a :call" do
-        sexp = s(:command, s(:@ident, "foo", s(1, 0)), s(:arglist, s(:foo)))
-        result = processor.process sexp
-        _(result).must_equal s(:call, nil, :foo, s(:foo_p))
-      end
-    end
-
-    describe "for a :var_ref sexp" do
-      it "transforms the sexp to a :lvar sexp" do
-        sexp = s(:var_ref, s(:@ident, "bar", s(1, 4)))
-        result = processor.process sexp
-        _(result).must_equal s(:lvar, :bar)
-      end
-    end
-
-    describe "for a :vcall sexp" do
-      it "transforms the sexp to a :call sexp" do
-        sexp = s(:vcall, s(:@ident, "bar", s(1, 4)))
-        result = processor.process sexp
-        _(result).must_equal s(:call, nil, :bar)
-      end
-    end
-
-    describe "for a :module sexp" do
-      it "does not create body elements for an empty definition" do
-        sexp = s(:module,
-                 s(:const_ref, s(:@const, "Foo", s(1, 13))),
-                 s(:bodystmt, s(:stmts, s(:void_stmt, s(2, 3))), nil, nil, nil))
-        result = processor.process sexp
-        _(result).must_equal s(:module, :Foo)
-      end
-
-      it "creates a single body element for a definition with one statement" do
-        sexp = s(:module,
-                 s(:const_ref, s(:@const, "Foo", s(1, 13))),
-                 s(:bodystmt, s(:stmts, s(:foo)), nil, nil, nil))
-        result = processor.process sexp
-        _(result).must_equal s(:module, :Foo, s(:foo_p))
-      end
-
-      it "creates multiple body elements for a definition with more than one statement" do
-        sexp = s(:module,
-                 s(:const_ref, s(:@const, "Foo", s(1, 13))),
-                 s(:bodystmt, s(:stmts, s(:foo), s(:bar)), nil, nil, nil))
-        result = processor.process sexp
-        _(result).must_equal s(:module, :Foo, s(:foo_p), s(:bar_p))
-      end
-    end
-
-    describe "for a :class sexp" do
-      it "does not create body eleents for an empty definition" do
-        sexp = s(:class,
-                 s(:const_ref, s(:@const, "Foo", s(1, 13))), nil,
-                 s(:bodystmt, s(:stmts, s(:void_stmt, s(2, 8))), nil, nil, nil))
-        result = processor.process sexp
-        _(result).must_equal s(:class, :Foo, nil)
-      end
-
-      it "creates a single body element for a definition with one statement" do
-        sexp = s(:class,
-                 s(:const_ref, s(:@const, "Foo", s(1, 13))), nil,
-                 s(:bodystmt, s(:stmts, s(:foo)), nil, nil, nil))
-        result = processor.process sexp
-        _(result).must_equal s(:class, :Foo, nil, s(:foo_p))
-      end
-
-      it "creates multiple body elements for a definition with more than one statement" do
-        sexp = s(:class,
-                 s(:const_ref, s(:@const, "Foo", s(1, 13))), nil,
-                 s(:bodystmt, s(:stmts, s(:foo), s(:bar)), nil, nil, nil))
-        result = processor.process sexp
-        _(result).must_equal s(:class, :Foo, nil, s(:foo_p), s(:bar_p))
-      end
-
-      it "passes on the given ancestor" do
-        sexp = s(:class,
-                 s(:const_ref, s(:@const, "Foo", s(1, 13))),
-                 s(:var_ref, s(:@const, "Bar", s(1, 12))),
-                 s(:bodystmt, s(:stmts, s(:void_stmt, s(2, 7))), nil, nil, nil))
-        result = processor.process sexp
-        _(result).must_equal s(:class, :Foo, s(:const, :Bar))
-      end
-    end
-
-    describe "for a :bodystmt sexp" do
-      it "creates a :block sexp when multiple statements are present" do
-        sexp = s(:bodystmt, s(:stmts, s(:foo), s(:bar)), nil, nil, nil)
-        result = processor.process sexp
-        _(result).must_equal s(:block, s(:foo_p), s(:bar_p))
-      end
-
-      it "removes nested :void_stmt sexps" do
-        sexp = s(:bodystmt, s(:stmts, s(:void_stmt), s(:foo)), nil, nil, nil)
-        result = processor.process sexp
-        _(result).must_equal s(:foo_p)
-      end
-    end
-
-    describe "for a :def sexp" do
-      it "transforms the sexp for a basic function definition" do
-        sexp = s(:def,
-                 s(:@ident, "foo", s(1, 4)),
-                 s(:params, nil, nil, nil, nil, nil),
-                 s(:bodystmt, s(:stmts, s(:void_stmt, s(2, 3))), nil, nil, nil))
-        result = processor.process sexp
-        _(result).must_equal s(:defn, :foo, s(:args), s(:nil))
-      end
-    end
-
-    describe "for a :params sexp" do
-      describe "with a normal arguments" do
-        it "creates :lvar sexps" do
-          sexp =  s(:params, s(s(:@ident, "bar", s(1, 8))), nil, nil, nil, nil)
-          result = processor.process sexp
-          _(result).must_equal s(:args, s(:lvar, :bar))
-        end
-      end
-
-      describe "with a ruby 2.4-style doublesplat argument" do
-        it "creates :lvar sexps" do
-          sexp =  s(:params,
-                    nil, nil, nil, nil, nil,
-                    s(:@ident, "bar", s(1, 8)),
-                    nil)
-          result = processor.process sexp
-          _(result).must_equal s(:args, s(:dsplat, s(:lvar, :bar)))
-        end
-      end
-      describe "with a ruby 2.5-style kwrest argument" do
-        it "creates :lvar sexps" do
-          sexp =  s(:params,
-                    nil, nil, nil, nil, nil,
-                    s(:kwrest_param, s(:@ident, "bar", s(1, 8))),
-                    nil)
-          result = processor.process sexp
-          _(result).must_equal s(:args, s(:dsplat, s(:lvar, :bar)))
-        end
-      end
-    end
-
-    describe "for an :assign sexp" do
-      it "creates a :lasgn sexp" do
-        sexp = s(:assign,
-                 s(:var_field, s(:@ident, "a", s(1, 0))),
-                 s(:@int, "1", s(1, 4)))
-        result = processor.process sexp
-        _(result).must_equal s(:lasgn, :a, s(:lit, 1))
-      end
-    end
-
-    describe "for a :binary sexp" do
-      it "creates a :call sexp" do
-        sexp = s(:binary, s(:bar), :==, s(:foo))
-        result = processor.process sexp
-        _(result).must_equal s(:call, s(:bar_p), :==, s(:foo_p))
-      end
-    end
-
-    describe "for a :method_add_block sexp" do
-      it "creates an :iter sexp" do
-        sexp = s(:method_add_block,
-                 s(:call, s(:foo), :".", s(:@ident, "baz", s(1, 2))),
-                 s(:brace_block, nil, s(:stmts, s(:bar))))
-        result = processor.process sexp
-        _(result).must_equal s(:iter,
-                               s(:call, s(:foo_p), :baz), 0,
-                               s(:bar_p))
-      end
-
-      describe "with a block parameter" do
-        it "creates an :iter sexp with an :args sexp for the block parameter" do
-          sexp = s(:method_add_block,
-                   s(:call, s(:foo), :".", s(:@ident, "baz", s(1, 2))),
-                   s(:brace_block,
-                     s(:block_var,
-                       s(:params, s(s(:@ident, "i", s(1, 6))), nil, nil, nil, nil),
-                       nil),
-                     s(:stmts, s(:bar))))
-          result = processor.process sexp
-          _(result).must_equal s(:iter,
-                                 s(:call, s(:foo_p), :baz),
-                                 s(:args, :i),
-                                 s(:bar_p))
-        end
-      end
-    end
-
-    describe "for an :if sexp" do
-      describe "with a single statement in the if body" do
-        it "uses the statement sexp as the body" do
-          sexp = s(:if, s(:foo), s(:stmts, s(:bar)), nil)
-          result = processor.process sexp
-          _(result).must_equal s(:if, s(:foo_p), s(:bar_p), nil)
-        end
-      end
-
-      describe "with multiple statements in the if body" do
-        it "uses a block containing the statement sexps as the body" do
-          sexp = s(:if, s(:foo), s(:stmts, s(:bar), s(:baz)), nil)
-          result = processor.process sexp
-          _(result).must_equal s(:if, s(:foo_p), s(:block, s(:bar_p), s(:baz_p)), nil)
-        end
-      end
-    end
-
-    describe "for an :array sexp" do
-      it "pulls up the element sexps" do
-        sexp = s(:array, s(:words, s(:foo), s(:bar), s(:baz)))
-        result = processor.process sexp
-        _(result).must_equal s(:array, s(:foo_p), s(:bar_p), s(:baz_p))
-      end
-    end
-
-    describe "for a :const_path_ref sexp" do
-      it "returns a :colon2 sexp" do
-        sexp = s(:const_path_ref,
-                 s(:var_ref, s(:@const, "Foo", s(1, 0))),
-                 s(:@const, "Bar", s(1, 5)))
-        result = processor.process sexp
-        _(result).must_equal s(:colon2, s(:const, :Foo), :Bar)
-      end
-    end
-
-    describe "for a :when sexp" do
-      it "turns nested :when clauses into a list" do
-        sexp = s(:when, s(:args, s(:foo)), s(:stmts, s(:bar)),
-                 s(:when, s(:args, s(:foo)), s(:stmts, s(:bar)),
-                   s(:when, s(:args, s(:foo)), s(:stmts, s(:bar)), nil)))
-        result = processor.process sexp
-        _(result).must_equal s(s(:when, s(:array, s(:foo_p)), s(:bar_p)),
-                               s(:when, s(:array, s(:foo_p)), s(:bar_p)),
-                               s(:when, s(:array, s(:foo_p)), s(:bar_p)),
-                               nil)
-      end
-    end
-  end
-
-  describe "#extract_node_symbol" do
-    it "processes an lvar sexp to a bare symbol" do
-      sexp = s(:lvar, "foo")
-      result = processor.send :extract_node_symbol, sexp
-      _(result).must_equal :foo
-    end
-
-    it "processes a const sexp to a bare symbol" do
-      sexp = s(:const, "Foo")
-      result = processor.send :extract_node_symbol, sexp
-      _(result).must_equal :Foo
-    end
-  end
-end

data/test/ripper_ruby_parser/version_test.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-describe RipperRubyParser do
-  it "knows its own version" do
-    _(RipperRubyParser::VERSION).wont_be_nil
-  end
-end

data/test/samples/assignment.rb

@@ -1,17 +0,0 @@
-# Samples of assignment
-foo[bar] = baz
-foo[bar] += baz
-foo[bar] ||= foo bar
-foo[bar] ||= foo(bar)
-foo[bar] ||= baz.qux quuz
-foo[bar] ||= baz.qux(quuz)
-
-# Destructuring assignments
-foo, bar = baz
-(foo, bar) = baz
-((foo, bar)) = baz
-(((foo, bar))) = baz
-foo, (bar, baz) = qux
-foo, ((bar, baz)) = qux
-foo, (((bar, baz))) = qux
-foo, (bar, (baz, qux)) = quuz

data/test/samples/comments.rb

@@ -1,13 +0,0 @@
-=begin
-This is an unusual type of comment that needs to be handled correctly
-=end
-
-class Foo
-
-end
-
-# This is a more common type of comment
-
-class Bar
-
-end

data/test/samples/conditionals.rb

@@ -1,23 +0,0 @@
-# Conditionals
-
-if begin foo end
-  bar
-end
-
-if begin foo..bar end
-  baz
-end
-
-if foo
-elsif begin bar end
-end
-
-if foo
-elsif begin bar..baz end
-end
-
-if 1
-  bar
-else
-  baz
-end

data/test/samples/lambdas.rb

@@ -1,5 +0,0 @@
--> { }
-->() { }
-->(foo) { foo + bar }
-lambda { }
-lambda { |foo| foo + bar }

data/test/samples/loops.rb

@@ -1,36 +0,0 @@
-# Loop samples
-
-def for_samples
-  for foo in bar
-  end
-
-  for foo, bar in baz
-  end
-
-  for foo, in bar
-  end
-end
-
-# begin..end in conditions
-#
-def while_until_samples
-  while begin foo end
-    bar
-  end
-
-  until begin foo end
-    bar
-  end
-
-  while begin foo end do
-    bar
-  end
-
-  until begin foo end do
-    bar
-  end
-
-  foo while begin bar end
-
-  foo until begin bar end
-end

data/test/samples/misc.rb

@@ -1,281 +0,0 @@
-# Miscellaneous samples
-
-BEGIN {
-  begin
-    foo
-  end
-}
-
-BEGIN {}
-
-END {
-  begin
-    bar
-  end
-}
-
-END {}
-
-# regular expressions with different encoding flags
-regular = /foo/
-noenc = /foo/n
-utf8 = /foo/u
-euc = /foo/e
-sjis = /foo/s
-
-bar = 'bar'
-regular = /foo#{bar}/
-noenc = /foo#{bar}/n
-utf8 = /foo#{bar}/u
-euc = /foo#{bar}/e
-sjis = /foo#{bar}/s
-
-# Use of __ENCODING__
-enc = __ENCODING__
-
-class Foo
-  # calling #[] on self
-  # https://github.com/seattlerb/ruby_parser/issues/250
-  def bar
-    self[:foo]
-  end
-
-  # required keyword arguments and no parentheses
-  # https://github.com/seattlerb/ruby_parser/pull/254
-  def foo a:, b:
-    puts "A: #{a}, B: #{b}"
-  end
-
-  # Combinations of begin..end and diverse operators
-  def qux
-    begin end
-    begin; foo; end
-    begin; foo; bar; end
-    - begin; foo; end
-    begin; bar; end + foo
-    foo + begin; bar; end
-    begin; foo; end ? bar : baz
-    foo ? begin; bar; end : baz
-    foo ? bar : begin; baz; end
-    begin; bar; end and foo
-    foo and begin; bar; end
-    begin; foo; end if bar
-    begin; foo; end unless bar
-    begin; foo; end.bar
-    foo ||= begin; bar; end
-    foo += begin; bar; end
-    foo[qux] ||= begin; bar; end
-    foo = begin; bar; end
-    foo = begin; if bar; baz; end; end
-    baz = begin; foo; ensure; bar; end
-    foo = *begin; bar; end
-    foo = bar, *begin; baz; end
-    foo, bar = *begin; baz; end
-    foo if begin bar end
-  end
-
-  # Nested do and begin blocks
-  def quuz
-    foo do
-      bar
-
-      begin
-        baz
-      rescue
-        qux
-      end
-
-      quuz
-    end
-  end
-
-  # Nested begin/rescue blocks
-  def quuz
-    begin
-      bar
-    rescue
-      begin
-        baz
-      end
-    end
-
-    begin
-      bar
-    rescue
-      begin
-        baz
-      rescue
-        qux
-      end
-    end
-
-    begin
-      bar
-    rescue
-      begin
-        baz
-      end
-      begin
-        qux
-      end
-    end
-  end
-
-  # Begin/end blocks and case statements
-  def quuz
-    case foo
-    when bar
-      begin
-        baz
-      end
-    end
-
-    case foo
-    when bar
-      begin
-        baz
-        qux
-      end
-    end
-
-    case foo
-    when bar
-      begin
-        baz
-        qux
-      end
-      quuz
-    end
-
-    case foo
-    when bar
-    else
-      begin
-        baz
-        qux
-      end
-    end
-
-    case foo
-    when bar
-    else
-      begin
-        baz
-        qux
-      end
-      quuz
-    end
-  end
-
-  # Using splat and double-splat args
-  def barbaz(*foo, **bar)
-    puts [foo, bar]
-    foo.each do |baz, **qux|
-      puts [foo, bar, baz, qux]
-    end
-    puts [foo, bar]
-  end
-
-  def barbaz_block(*foo, **bar, &block)
-    puts [foo, bar]
-  end
-
-  def self.barbaz(*foo, **bar)
-    puts [foo, bar]
-    foo.each do |baz, **qux|
-      puts [foo, bar, baz, qux]
-    end
-    puts [foo, bar]
-  end
-
-  # rescue
-  def barfoo
-    foo
-  rescue *bar
-    baz
-  rescue *quuz, Bar
-    zyxxy
-  rescue *qux => err
-    puts err
-  end
-
-  # begin/rescue with multiple assignment
-  foo, bar = begin
-    baz
-  rescue qux
-    quuz
-  end
-
-  # alias
-  alias foo bar
-  alias :foo bar
-  alias :foo :bar
-  alias foo :bar
-  alias :+ -
-  alias next bar
-
-  # rescue with assignment
-  foo = bar rescue baz
-  foo = bar baz rescue qux
-  foo = bar(baz) rescue qux
-  foo, bar = baz qux rescue quuz
-  @foo = bar baz rescue qux
-  @@foo = bar baz rescue qux
-  FOO = bar baz rescue qux
-  $foo = bar baz rescue qux
-  foo = Foo.bar(baz) rescue qux
-  foo = Foo.bar baz rescue qux
-
-  # Assignment to class variables inside method argument
-  # definitions.
-  def foo(bar = (@@baz = qux))
-  end
-
-  def self.foo(bar = (@@baz = qux))
-  end
-
-  def (bar = (@@baz = qux)).foo
-  end
-
-  # Assignment to global variables inside method argument
-  # definitions.
-  def foo(bar = ($baz = qux))
-  end
-
-  # Argument destructuring
-  def foo((bar, baz))
-  end
-
-  def foo((bar, baz), (qux, quuz))
-  end
-
-  def foo((bar, *qux))
-  end
-
-  def foo((bar, (baz, qux)))
-  end
-
-  def foo((bar, (baz, *qux)))
-  end
-
-  def self.foo((bar, baz))
-  end
-
-  def self.foo((bar, baz), (qux, quuz))
-  end
-
-  def self.foo((bar, *qux))
-  end
-
-  def self.foo((bar, (baz, qux)))
-  end
-
-  def self.foo((bar, (baz, *qux)))
-  end
-end
-
-# Special symbols
-[:`, :|, :*, :&, :%, :'^', :-@, :+@, :'~@']
-
-# Blocks
-foo do |bar, | end