ripper_ruby_parser 1.7.2 → 1.10.0

data/test/samples/misc.rb

@@ -1,285 +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
-
-  def foobarbaz(**)
-  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
-foo do |bar, **| end

data/test/samples/number.rb

@@ -1,9 +0,0 @@
-# Samples of number-like literals
-
-3.14
-42
-100r
-0700
-0x100
-1+3i
-3.2-4.2i

data/test/samples/operators.rb

@@ -1,18 +0,0 @@
-# Samples of different operators
-
-# range operator (..)
-0..4
--1..-3
-'a'..'z'
-0.0..4.0
-foo..bar
-0..4.0
-0.0..4
-
-# exclusive range operator (...)
-0...4
--1...-3
-'a'...'z'
-0.0...4.0
-foo...bar
-0...4.0

data/test/samples/strings.rb

@@ -1,147 +0,0 @@
-# Samples of strings demonstrating handling of escape sequences, encoding and
-# line continuations.
-
-# Escape sequences
-%W(foo\nbar baz)
-%w(foo\nbar baz)
-
-"foo\u273bbar"
-"foo\a\b\e\f\r\s\t\vbar\nbaz"
-"\0"
-"foo#{bar}\0"
-"foo#{bar}baz\0"
-"2\302\275"
-"#{foo}2\302\275"
-%W(2\302\275)
-/2\302\275/
-"foo\u{101D1}bar"
-
-# Encoding
-"日本語"
-/日本語/
-"\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E"  # => "日本語"
-"\xAB\xE6\x97\xA5"                      # Invalid in UTF8
-
-<<EOS
-日本語
-EOS
-
-<<EOS
-\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E
-EOS
-
-# Quotes around heredoc names
-<<'FOO'
-\n
-FOO
-
-<<"FOO"
-\n
-FOO
-
-# Escape sequences in heredocs, in particular carriage returns
-#
-<<FOO
-foo\rbar\tbaz\r
-FOO
-
-<<'FOO'
-foo\rbar\tbaz\r
-FOO
-
-# Dedented heredocs
-foo = <<~BAR
-  baz
-  #{qux}
-  quuz
-BAR
-
-# Line continuation
-"foo\
-bar"
-
-'foo2\
-bar'
-
-/foo3\
-bar/
-
-<<EOS
-foo4\
-bar
-EOS
-
-<<'EOS'
-foo4\
-bar
-EOS
-
-<<EOS
-#{bar}
-baz \
-qux
-EOS
-
-<<-EOS
-#{bar}
-baz \
-qux
-EOS
-
-%Q[foo5\
-bar]
-
-%W[fooa\
-bar baz]
-
-%I[foob\
-bar baz]
-
-%q[fooc\
-bar]
-
-%w[food\
-bar baz]
-
-%i[fooe\
-bar baz]
-
-%r[foof\
-bar baz]
-
-# Escaped line continuation
-"foo6\\
-bar"
-'foo7\\
-bar'
-/foo8\\
-bar/
-<<EOS
-foo9\\
-bar
-EOS
-%Q[foo10\\
-bar]
-%W[foog\\
-bar baz]
-%I[fooh\\
-bar baz]
-%q[fooi\\
-bar]
-%w[fooj\\
-bar baz]
-%i[fook\\
-bar baz]
-%r[fool\\
-bar baz]
-
-eval(<<FOO, __FILE__, __LINE__)
-bar
-baz
-FOO
-
-# Interpolation
-"foo#{bar}"
-"foo#{"bar#{baz}"}"
-"foo#{"bar#{"baz#{qux}"}"}"
-"foo#{"bar#{baz}"}foo#{"bar#{baz}"}"

data/test/test_helper.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require "simplecov"
-SimpleCov.start do
-  add_filter "/test/"
-end
-
-require "minitest/autorun"
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-
-require "ripper_ruby_parser"
-
-module MiniTest
-  class Spec
-    def inspect_with_line_numbers(exp)
-      parts = exp.map do |sub_exp|
-        if sub_exp.is_a? Sexp
-          inspect_with_line_numbers(sub_exp)
-        else
-          sub_exp.inspect
-        end
-      end
-
-      plain = "s(#{parts.join(', ')})"
-      if exp.line
-        "#{plain}.line(#{exp.line})"
-      else
-        plain
-      end
-    end
-
-    def formatted(exp, with_line_numbers: false)
-      inspection = if with_line_numbers
-                     inspect_with_line_numbers(exp)
-                   else
-                     exp.inspect
-                   end
-      inspection.gsub(/\), /, "),\n")
-    end
-
-    def fix_lines(exp)
-      if exp.sexp_type == :lit && exp.line == exp[1]
-        return s(:lit, :__LINE__).line(exp.line)
-      end
-
-      exp.sexp_body = exp.sexp_body.map do |sub_exp|
-        if sub_exp.is_a? Sexp
-          fix_lines sub_exp
-        else
-          sub_exp
-        end
-      end
-
-      exp
-    end
-
-    def to_comments(exp)
-      comments = exp.comments.to_s.gsub(/\n\s*\n/, "\n")
-
-      exp.sexp_body = exp.sexp_body.map do |sub_exp|
-        if sub_exp.is_a? Sexp
-          to_comments sub_exp
-        else
-          sub_exp
-        end
-      end
-
-      if comments.empty?
-        exp
-      else
-        s(:comment, comments, exp)
-      end
-    end
-
-    def assert_parsed_as(sexp, code, with_line_numbers: false)
-      parser = RipperRubyParser::Parser.new
-      result = parser.parse code
-      if sexp.nil?
-        assert_nil result
-      else
-        assert_equal sexp, result
-        assert_equal(formatted(sexp, with_line_numbers: with_line_numbers),
-                     formatted(result, with_line_numbers: with_line_numbers))
-      end
-    end
-
-    def assert_parsed_as_before(code, with_line_numbers: false)
-      oldparser = RubyParser.for_current_ruby
-      newparser = RipperRubyParser::Parser.new
-      newparser.extra_compatible = true
-      expected = oldparser.parse code.dup
-      result = newparser.parse code
-      expected = to_comments fix_lines expected
-      result = to_comments fix_lines result
-      assert_equal expected, result
-      assert_equal(formatted(expected, with_line_numbers: with_line_numbers),
-                   formatted(result, with_line_numbers: with_line_numbers))
-    end
-  end
-
-  Expectation.class_eval do
-    def must_be_parsed_as(sexp, with_line_numbers: false)
-      ctx.assert_parsed_as(sexp, target, with_line_numbers: with_line_numbers)
-    end
-
-    def must_be_parsed_as_before(with_line_numbers: false)
-      ctx.assert_parsed_as_before(target, with_line_numbers: with_line_numbers)
-    end
-  end
-end