RubyGems - ripper_ruby_parser - Versions diffs - 1.7.2 → 1.8.0 - Mend

ripper_ruby_parser 1.7.2 → 1.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +28 -0
data/README.md +4 -4
data/lib/ripper_ruby_parser/commenting_ripper_parser.rb +24 -12
data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb +33 -54
data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb +17 -19
data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb +34 -1
data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb +1 -1
data/lib/ripper_ruby_parser/sexp_handlers/methods.rb +12 -15
data/lib/ripper_ruby_parser/sexp_handlers/string_literals.rb +21 -15
data/lib/ripper_ruby_parser/sexp_processor.rb +4 -17
data/lib/ripper_ruby_parser/unescape.rb +36 -12
data/lib/ripper_ruby_parser/version.rb +1 -1
metadata +110 -78
data/Rakefile +0 -33
data/test/end_to_end/comments_test.rb +0 -59
data/test/end_to_end/comparison_test.rb +0 -104
data/test/end_to_end/lib_comparison_test.rb +0 -18
data/test/end_to_end/line_numbering_test.rb +0 -31
data/test/end_to_end/samples_comparison_test.rb +0 -13
data/test/end_to_end/test_comparison_test.rb +0 -18
data/test/pt_testcase/pt_test.rb +0 -44
data/test/ripper_ruby_parser/commenting_ripper_parser_test.rb +0 -200
data/test/ripper_ruby_parser/parser_test.rb +0 -576
data/test/ripper_ruby_parser/sexp_handlers/assignment_test.rb +0 -597
data/test/ripper_ruby_parser/sexp_handlers/blocks_test.rb +0 -717
data/test/ripper_ruby_parser/sexp_handlers/conditionals_test.rb +0 -536
data/test/ripper_ruby_parser/sexp_handlers/literals_test.rb +0 -165
data/test/ripper_ruby_parser/sexp_handlers/loops_test.rb +0 -209
data/test/ripper_ruby_parser/sexp_handlers/method_calls_test.rb +0 -237
data/test/ripper_ruby_parser/sexp_handlers/methods_test.rb +0 -429
data/test/ripper_ruby_parser/sexp_handlers/operators_test.rb +0 -405
data/test/ripper_ruby_parser/sexp_handlers/string_literals_test.rb +0 -973
data/test/ripper_ruby_parser/sexp_processor_test.rb +0 -327
data/test/ripper_ruby_parser/version_test.rb +0 -7
data/test/samples/assignment.rb +0 -22
data/test/samples/comments.rb +0 -13
data/test/samples/conditionals.rb +0 -23
data/test/samples/lambdas.rb +0 -5
data/test/samples/loops.rb +0 -36
data/test/samples/misc.rb +0 -285
data/test/samples/number.rb +0 -9
data/test/samples/operators.rb +0 -18
data/test/samples/strings.rb +0 -147
data/test/test_helper.rb +0 -111

data/test/ripper_ruby_parser/sexp_handlers/literals_test.rb DELETED Viewed

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-require File.expand_path("../../test_helper.rb", File.dirname(__FILE__))
-describe RipperRubyParser::Parser do
-  let(:parser) { RipperRubyParser::Parser.new }
-  describe "#parse" do
-    describe "for character literals" do
-      it "works for simple character literals" do
-        _("?a")
-          .must_be_parsed_as s(:str, "a")
-      end
-      it "works for escaped character literals" do
-        _('?\\n')
-          .must_be_parsed_as s(:str, "\n")
-      end
-      it "works for escaped character literals with ctrl" do
-        _('?\\C-a')
-          .must_be_parsed_as s(:str, "\u0001")
-      end
-      it "works for escaped character literals with meta" do
-        _('?\\M-a')
-          .must_be_parsed_as s(:str, (+"\xE1").force_encoding("ascii-8bit"))
-      end
-      it "works for escaped character literals with meta plus shorthand ctrl" do
-        _('?\\M-\\ca')
-          .must_be_parsed_as s(:str, (+"\x81").force_encoding("ascii-8bit"))
-      end
-      it "works for escaped character literals with shorthand ctrl plus meta" do
-        _('?\\c\\M-a')
-          .must_be_parsed_as s(:str, (+"\x81").force_encoding("ascii-8bit"))
-      end
-      it "works for escaped character literals with meta plus ctrl" do
-        _('?\\M-\\C-a')
-          .must_be_parsed_as s(:str, (+"\x81").force_encoding("ascii-8bit"))
-      end
-      it "works for escaped character literals with ctrl plus meta" do
-        _('?\\C-\\M-a')
-          .must_be_parsed_as s(:str, (+"\x81").force_encoding("ascii-8bit"))
-      end
-    end
-    describe "for array literals" do
-      it "works for an empty array" do
-        _("[]")
-          .must_be_parsed_as s(:array)
-      end
-      it "works for a simple case with splat" do
-        _("[*foo]")
-          .must_be_parsed_as s(:array,
-                               s(:splat, s(:call, nil, :foo)))
-      end
-      it "works for a multi-element case with splat" do
-        _("[foo, *bar]")
-          .must_be_parsed_as s(:array,
-                               s(:call, nil, :foo),
-                               s(:splat, s(:call, nil, :bar)))
-      end
-    end
-    describe "for hash literals" do
-      it "works for an empty hash" do
-        _("{}")
-          .must_be_parsed_as s(:hash)
-      end
-      it "works for a hash with one pair" do
-        _("{foo => bar}")
-          .must_be_parsed_as s(:hash,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar))
-      end
-      it "works for a hash with multiple pairs" do
-        _("{foo => bar, baz => qux}")
-          .must_be_parsed_as s(:hash,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:call, nil, :baz),
-                               s(:call, nil, :qux))
-      end
-      it "works for a hash with label keys" do
-        _("{foo: bar, baz: qux}")
-          .must_be_parsed_as s(:hash,
-                               s(:lit, :foo),
-                               s(:call, nil, :bar),
-                               s(:lit, :baz),
-                               s(:call, nil, :qux))
-      end
-      it "works for a hash with dynamic label keys" do
-        _("{'foo': bar}")
-          .must_be_parsed_as s(:hash,
-                               s(:lit, :foo),
-                               s(:call, nil, :bar))
-      end
-      it "works for a hash with splat" do
-        _("{foo: bar, baz: qux, **quux}")
-          .must_be_parsed_as s(:hash,
-                               s(:lit, :foo), s(:call, nil, :bar),
-                               s(:lit, :baz), s(:call, nil, :qux),
-                               s(:kwsplat, s(:call, nil, :quux)))
-      end
-    end
-    describe "for number literals" do
-      it "works for floats" do
-        _("3.14")
-          .must_be_parsed_as s(:lit, 3.14)
-      end
-      it "works for octal integer literals" do
-        _("0700")
-          .must_be_parsed_as s(:lit, 448)
-      end
-      it "handles negative sign for integers" do
-        _("-1")
-          .must_be_parsed_as s(:lit, -1)
-      end
-      it "handles space after negative sign for integers" do
-        _("-1 ")
-          .must_be_parsed_as s(:lit, -1)
-      end
-      it "handles negative sign for floats" do
-        _("-3.14")
-          .must_be_parsed_as s(:lit, -3.14)
-      end
-      it "handles space after negative sign for floats" do
-        _("-3.14 ")
-          .must_be_parsed_as s(:lit, -3.14)
-      end
-      it "handles positive sign" do
-        _("+1")
-          .must_be_parsed_as s(:lit, 1)
-      end
-      it "works for rationals" do
-        _("1000r")
-          .must_be_parsed_as s(:lit, 1000r)
-      end
-      it "works for imaginary numbers" do
-        _("1i")
-          .must_be_parsed_as s(:lit, 1i)
-      end
-    end
-  end
-end

data/test/ripper_ruby_parser/sexp_handlers/loops_test.rb DELETED Viewed

@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-require File.expand_path("../../test_helper.rb", File.dirname(__FILE__))
-describe RipperRubyParser::Parser do
-  describe "#parse" do
-    describe "for the while statement" do
-      it "works with do" do
-        _("while foo do; bar; end")
-          .must_be_parsed_as s(:while,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar), true)
-      end
-      it "works without do" do
-        _("while foo; bar; end")
-          .must_be_parsed_as s(:while,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar), true)
-      end
-      it "works in the single-line postfix case" do
-        _("foo while bar")
-          .must_be_parsed_as s(:while,
-                               s(:call, nil, :bar),
-                               s(:call, nil, :foo), true)
-      end
-      it "works in the block postfix case" do
-        _("begin; foo; end while bar")
-          .must_be_parsed_as s(:while,
-                               s(:call, nil, :bar),
-                               s(:call, nil, :foo), false)
-      end
-      it "handles a negative condition" do
-        _("while not foo; bar; end")
-          .must_be_parsed_as s(:while,
-                               s(:call, s(:call, nil, :foo), :!),
-                               s(:call, nil, :bar), true)
-      end
-      it "handles a negative condition in the postfix case" do
-        _("foo while not bar")
-          .must_be_parsed_as s(:while,
-                               s(:call, s(:call, nil, :bar), :!),
-                               s(:call, nil, :foo), true)
-      end
-      it "converts a negated match condition to :until" do
-        _("while foo !~ bar; baz; end")
-          .must_be_parsed_as s(:until,
-                               s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
-                               s(:call, nil, :baz), true)
-      end
-      it "converts a negated match condition to :until in the postfix case" do
-        _("baz while foo !~ bar")
-          .must_be_parsed_as s(:until,
-                               s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
-                               s(:call, nil, :baz), true)
-      end
-      it "cleans up begin..end block in condition" do
-        _("while begin foo end; bar; end")
-          .must_be_parsed_as s(:while,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar), true)
-      end
-      it "cleans up begin..end block in condition in the postfix case" do
-        _("foo while begin bar end")
-          .must_be_parsed_as s(:while,
-                               s(:call, nil, :bar),
-                               s(:call, nil, :foo), true)
-      end
-      it "works with do and an empty body" do
-        _("while foo do; end")
-          .must_be_parsed_as s(:while,
-                               s(:call, nil, :foo),
-                               nil, true)
-      end
-      it "works without do and with an empty body" do
-        _("while foo; end")
-          .must_be_parsed_as s(:while,
-                               s(:call, nil, :foo),
-                               nil, true)
-      end
-    end
-    describe "for the until statement" do
-      it "works in the prefix block case with do" do
-        _("until foo do; bar; end")
-          .must_be_parsed_as s(:until,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar), true)
-      end
-      it "works in the prefix block case without do" do
-        _("until foo; bar; end")
-          .must_be_parsed_as s(:until,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar), true)
-      end
-      it "works in the single-line postfix case" do
-        _("foo until bar")
-          .must_be_parsed_as s(:until,
-                               s(:call, nil, :bar),
-                               s(:call, nil, :foo), true)
-      end
-      it "works in the block postfix case" do
-        _("begin; foo; end until bar")
-          .must_be_parsed_as s(:until,
-                               s(:call, nil, :bar),
-                               s(:call, nil, :foo), false)
-      end
-      it "handles a negative condition" do
-        _("until not foo; bar; end")
-          .must_be_parsed_as s(:until,
-                               s(:call, s(:call, nil, :foo), :!),
-                               s(:call, nil, :bar), true)
-      end
-      it "handles a negative condition in the postfix case" do
-        _("foo until not bar")
-          .must_be_parsed_as s(:until,
-                               s(:call, s(:call, nil, :bar), :!),
-                               s(:call, nil, :foo), true)
-      end
-      it "converts a negated match condition to :while" do
-        _("until foo !~ bar; baz; end")
-          .must_be_parsed_as s(:while,
-                               s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
-                               s(:call, nil, :baz), true)
-      end
-      it "converts a negated match condition to :while in the postfix case" do
-        _("baz until foo !~ bar")
-          .must_be_parsed_as s(:while,
-                               s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
-                               s(:call, nil, :baz), true)
-      end
-      it "cleans up begin..end block in condition" do
-        _("until begin foo end; bar; end")
-          .must_be_parsed_as s(:until,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar), true)
-      end
-      it "cleans up begin..end block in condition in the postfix case" do
-        _("foo until begin bar end")
-          .must_be_parsed_as s(:until,
-                               s(:call, nil, :bar),
-                               s(:call, nil, :foo), true)
-      end
-    end
-    describe "for the for statement" do
-      it "works with do" do
-        _("for foo in bar do; baz; end")
-          .must_be_parsed_as s(:for,
-                               s(:call, nil, :bar),
-                               s(:lasgn, :foo),
-                               s(:call, nil, :baz))
-      end
-      it "works without do" do
-        _("for foo in bar; baz; end")
-          .must_be_parsed_as s(:for,
-                               s(:call, nil, :bar),
-                               s(:lasgn, :foo),
-                               s(:call, nil, :baz))
-      end
-      it "works with an empty body" do
-        _("for foo in bar; end")
-          .must_be_parsed_as s(:for,
-                               s(:call, nil, :bar),
-                               s(:lasgn, :foo))
-      end
-      it "works with explicit multiple assignment" do
-        _("for foo, bar in baz; end")
-          .must_be_parsed_as s(:for,
-                               s(:call, nil, :baz),
-                               s(:masgn,
-                                 s(:array,
-                                   s(:lasgn, :foo),
-                                   s(:lasgn, :bar))))
-      end
-      it "works with multiple assignment with trailing comma" do
-        _("for foo, in bar; end")
-          .must_be_parsed_as s(:for,
-                               s(:call, nil, :bar),
-                               s(:masgn,
-                                 s(:array,
-                                   s(:lasgn, :foo))))
-      end
-    end
-  end
-end

data/test/ripper_ruby_parser/sexp_handlers/method_calls_test.rb DELETED Viewed

@@ -1,237 +0,0 @@
-# frozen_string_literal: true
-require File.expand_path("../../test_helper.rb", File.dirname(__FILE__))
-describe RipperRubyParser::SexpHandlers::MethodCalls do
-  describe "when parsing with RipperRubyParser::Parser#parse" do
-    describe "for method calls" do
-      describe "without a receiver" do
-        it "works without parentheses" do
-          _("foo bar")
-            .must_be_parsed_as s(:call, nil, :foo,
-                                 s(:call, nil, :bar))
-        end
-        it "works with parentheses" do
-          _("foo(bar)")
-            .must_be_parsed_as s(:call, nil, :foo,
-                                 s(:call, nil, :bar))
-        end
-        it "works with an empty parameter list and no parentheses" do
-          _("foo")
-            .must_be_parsed_as s(:call, nil, :foo)
-        end
-        it "works with parentheses around an empty parameter list" do
-          _("foo()")
-            .must_be_parsed_as s(:call, nil, :foo)
-        end
-        it "works for methods ending in a question mark" do
-          _("foo?")
-            .must_be_parsed_as s(:call, nil, :foo?)
-        end
-        it "works with nested calls without parentheses" do
-          _("foo bar baz")
-            .must_be_parsed_as s(:call, nil, :foo,
-                                 s(:call, nil, :bar,
-                                   s(:call, nil, :baz)))
-        end
-        it "works with a non-final splat argument" do
-          _("foo(bar, *baz, qux)")
-            .must_be_parsed_as s(:call,
-                                 nil,
-                                 :foo,
-                                 s(:call, nil, :bar),
-                                 s(:splat, s(:call, nil, :baz)),
-                                 s(:call, nil, :qux))
-        end
-        it "works with a splat argument followed by several regular arguments" do
-          _("foo(bar, *baz, qux, quuz)")
-            .must_be_parsed_as s(:call,
-                                 nil,
-                                 :foo,
-                                 s(:call, nil, :bar),
-                                 s(:splat, s(:call, nil, :baz)),
-                                 s(:call, nil, :qux),
-                                 s(:call, nil, :quuz))
-        end
-        it "works with a named argument" do
-          _("foo(bar, baz: qux)")
-            .must_be_parsed_as s(:call,
-                                 nil,
-                                 :foo,
-                                 s(:call, nil, :bar),
-                                 s(:hash, s(:lit, :baz), s(:call, nil, :qux)))
-        end
-        it "works with several named arguments" do
-          _("foo(bar, baz: qux, quux: quuz)")
-            .must_be_parsed_as s(:call,
-                                 nil,
-                                 :foo,
-                                 s(:call, nil, :bar),
-                                 s(:hash,
-                                   s(:lit, :baz), s(:call, nil, :qux),
-                                   s(:lit, :quux), s(:call, nil, :quuz)))
-        end
-        it "works with a double splat argument" do
-          _("foo(bar, **baz)")
-            .must_be_parsed_as s(:call,
-                                 nil,
-                                 :foo,
-                                 s(:call, nil, :bar),
-                                 s(:hash,
-                                   s(:kwsplat, s(:call, nil, :baz))))
-        end
-        it "works with a named argument followed by a double splat argument" do
-          _("foo(bar, baz: qux, **quuz)")
-            .must_be_parsed_as s(:call,
-                                 nil,
-                                 :foo,
-                                 s(:call, nil, :bar),
-                                 s(:hash,
-                                   s(:lit, :baz), s(:call, nil, :qux),
-                                   s(:kwsplat, s(:call, nil, :quuz))))
-        end
-      end
-      describe "with a receiver" do
-        it "works without parentheses" do
-          _("foo.bar baz")
-            .must_be_parsed_as s(:call,
-                                 s(:call, nil, :foo),
-                                 :bar,
-                                 s(:call, nil, :baz))
-        end
-        it "works with parentheses" do
-          _("foo.bar(baz)")
-            .must_be_parsed_as s(:call,
-                                 s(:call, nil, :foo),
-                                 :bar,
-                                 s(:call, nil, :baz))
-        end
-        it "works with parentheses around a call with no parentheses" do
-          _("foo.bar(baz qux)")
-            .must_be_parsed_as s(:call,
-                                 s(:call, nil, :foo),
-                                 :bar,
-                                 s(:call, nil, :baz,
-                                   s(:call, nil, :qux)))
-        end
-        it "works with nested calls without parentheses" do
-          _("foo.bar baz qux")
-            .must_be_parsed_as s(:call,
-                                 s(:call, nil, :foo),
-                                 :bar,
-                                 s(:call, nil, :baz,
-                                   s(:call, nil, :qux)))
-        end
-        it "does not keep :begin around a method receiver" do
-          _("begin; foo; end.bar")
-            .must_be_parsed_as s(:call, s(:call, nil, :foo), :bar)
-        end
-      end
-      describe "for collection indexing" do
-        it "works in the simple case" do
-          _("foo[bar]")
-            .must_be_parsed_as s(:call,
-                                 s(:call, nil, :foo),
-                                 :[],
-                                 s(:call, nil, :bar))
-        end
-        it "works without any indexes" do
-          _("foo[]").must_be_parsed_as s(:call, s(:call, nil, :foo),
-                                         :[])
-        end
-        it "works with self[]" do
-          _("self[foo]").must_be_parsed_as s(:call, s(:self), :[],
-                                             s(:call, nil, :foo))
-        end
-      end
-      describe "safe call" do
-        it "works without arguments" do
-          _("foo&.bar").must_be_parsed_as s(:safe_call, s(:call, nil, :foo), :bar)
-        end
-        it "works with arguments" do
-          _("foo&.bar baz")
-            .must_be_parsed_as s(:safe_call,
-                                 s(:call, nil, :foo),
-                                 :bar,
-                                 s(:call, nil, :baz))
-        end
-      end
-      describe "with blocks" do
-        it "works for a do block" do
-          _("foo.bar do baz; end")
-            .must_be_parsed_as s(:iter,
-                                 s(:call,
-                                   s(:call, nil, :foo),
-                                   :bar),
-                                 0,
-                                 s(:call, nil, :baz))
-        end
-        it "works for a do block with several statements" do
-          _("foo.bar do baz; qux; end")
-            .must_be_parsed_as s(:iter,
-                                 s(:call,
-                                   s(:call, nil, :foo),
-                                   :bar),
-                                 0,
-                                 s(:block,
-                                   s(:call, nil, :baz),
-                                   s(:call, nil, :qux)))
-        end
-      end
-    end
-    describe "for calls to super" do
-      specify { _("super").must_be_parsed_as s(:zsuper) }
-      specify do
-        _("super foo").must_be_parsed_as s(:super,
-                                           s(:call, nil, :foo))
-      end
-      specify do
-        _("super foo, bar").must_be_parsed_as s(:super,
-                                                s(:call, nil, :foo),
-                                                s(:call, nil, :bar))
-      end
-      specify do
-        _("super foo, *bar").must_be_parsed_as s(:super,
-                                                 s(:call, nil, :foo),
-                                                 s(:splat,
-                                                   s(:call, nil, :bar)))
-      end
-      specify do
-        _("super foo, *bar, &baz")
-          .must_be_parsed_as s(:super,
-                               s(:call, nil, :foo),
-                               s(:splat, s(:call, nil, :bar)),
-                               s(:block_pass, s(:call, nil, :baz)))
-      end
-    end
-    it "handles calling a proc" do
-      _("foo.()")
-        .must_be_parsed_as s(:call, s(:call, nil, :foo), :call)
-    end
-  end
-end