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

ripper_ruby_parser 1.7.2 → 1.10.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 (48) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +50 -0
data/README.md +4 -4
data/lib/ripper_ruby_parser/commenting_ripper_parser.rb +24 -12
data/lib/ripper_ruby_parser/sexp_handlers/assignment.rb +2 -2
data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb +47 -53
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/literals.rb +1 -1
data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb +9 -5
data/lib/ripper_ruby_parser/sexp_handlers/methods.rb +17 -15
data/lib/ripper_ruby_parser/sexp_handlers/operators.rb +3 -3
data/lib/ripper_ruby_parser/sexp_handlers/string_literals.rb +24 -28
data/lib/ripper_ruby_parser/sexp_processor.rb +5 -18
data/lib/ripper_ruby_parser/unescape.rb +63 -22
data/lib/ripper_ruby_parser/version.rb +1 -1
metadata +140 -79
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/operators_test.rb DELETED Viewed

@@ -1,405 +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 boolean operators" do
-      it "handles :and" do
-        _("foo and bar")
-          .must_be_parsed_as s(:and,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar))
-      end
-      it "handles double :and" do
-        _("foo and bar and baz")
-          .must_be_parsed_as s(:and,
-                               s(:call, nil, :foo),
-                               s(:and,
-                                 s(:call, nil, :bar),
-                                 s(:call, nil, :baz)))
-      end
-      it "handles :or" do
-        _("foo or bar")
-          .must_be_parsed_as s(:or,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar))
-      end
-      it "handles double :or" do
-        _("foo or bar or baz")
-          .must_be_parsed_as s(:or,
-                               s(:call, nil, :foo),
-                               s(:or,
-                                 s(:call, nil, :bar),
-                                 s(:call, nil, :baz)))
-      end
-      it "handles :or after :and" do
-        _("foo and bar or baz")
-          .must_be_parsed_as s(:or,
-                               s(:and,
-                                 s(:call, nil, :foo),
-                                 s(:call, nil, :bar)),
-                               s(:call, nil, :baz))
-      end
-      it "handles :and after :or" do
-        _("foo or bar and baz")
-          .must_be_parsed_as s(:and,
-                               s(:or,
-                                 s(:call, nil, :foo),
-                                 s(:call, nil, :bar)),
-                               s(:call, nil, :baz))
-      end
-      it "converts :&& to :and" do
-        _("foo && bar")
-          .must_be_parsed_as s(:and,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar))
-      end
-      it "handles :|| after :&&" do
-        _("foo && bar || baz")
-          .must_be_parsed_as s(:or,
-                               s(:and,
-                                 s(:call, nil, :foo),
-                                 s(:call, nil, :bar)),
-                               s(:call, nil, :baz))
-      end
-      it "handles :&& after :||" do
-        _("foo || bar && baz")
-          .must_be_parsed_as s(:or,
-                               s(:call, nil, :foo),
-                               s(:and,
-                                 s(:call, nil, :bar),
-                                 s(:call, nil, :baz)))
-      end
-      it "handles :|| with parentheses" do
-        _("(foo || bar) || baz")
-          .must_be_parsed_as s(:or,
-                               s(:or,
-                                 s(:call, nil, :foo),
-                                 s(:call, nil, :bar)),
-                               s(:call, nil, :baz))
-      end
-      it "handles nested :|| with parentheses" do
-        _("foo || (bar || baz) || qux")
-          .must_be_parsed_as s(:or,
-                               s(:call, nil, :foo),
-                               s(:or,
-                                 s(:or, s(:call, nil, :bar), s(:call, nil, :baz)),
-                                 s(:call, nil, :qux)))
-      end
-      it "converts :|| to :or" do
-        _("foo || bar")
-          .must_be_parsed_as s(:or,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar))
-      end
-      it "handles triple :and" do
-        _("foo and bar and baz and qux")
-          .must_be_parsed_as s(:and,
-                               s(:call, nil, :foo),
-                               s(:and,
-                                 s(:call, nil, :bar),
-                                 s(:and,
-                                   s(:call, nil, :baz),
-                                   s(:call, nil, :qux))))
-      end
-      it "handles triple :&&" do
-        _("foo && bar && baz && qux")
-          .must_be_parsed_as s(:and,
-                               s(:call, nil, :foo),
-                               s(:and,
-                                 s(:call, nil, :bar),
-                                 s(:and,
-                                   s(:call, nil, :baz),
-                                   s(:call, nil, :qux))))
-      end
-      it "handles :!=" do
-        _("foo != bar")
-          .must_be_parsed_as s(:call,
-                               s(:call, nil, :foo),
-                               :!=,
-                               s(:call, nil, :bar))
-      end
-      it "keeps :begin for the first argument of a binary operator" do
-        _("begin; bar; end + foo")
-          .must_be_parsed_as s(:call,
-                               s(:begin, s(:call, nil, :bar)),
-                               :+,
-                               s(:call, nil, :foo))
-      end
-      it "keeps :begin for the second argument of a binary operator" do
-        _("foo + begin; bar; end")
-          .must_be_parsed_as s(:call,
-                               s(:call, nil, :foo),
-                               :+,
-                               s(:begin, s(:call, nil, :bar)))
-      end
-      it "does not keep :begin for the first argument of a boolean operator" do
-        _("begin; bar; end and foo")
-          .must_be_parsed_as s(:and,
-                               s(:call, nil, :bar),
-                               s(:call, nil, :foo))
-      end
-      it "keeps :begin for the second argument of a boolean operator" do
-        _("foo and begin; bar; end")
-          .must_be_parsed_as s(:and,
-                               s(:call, nil, :foo),
-                               s(:begin, s(:call, nil, :bar)))
-      end
-      it "does not keep :begin for the first argument of a shift operator" do
-        _("begin; bar; end << foo")
-          .must_be_parsed_as s(:call,
-                               s(:call, nil, :bar),
-                               :<<,
-                               s(:call, nil, :foo))
-      end
-      it "does not keep :begin for the second argument of a shift operator" do
-        _("foo >> begin; bar; end")
-          .must_be_parsed_as s(:call,
-                               s(:call, nil, :foo),
-                               :>>,
-                               s(:call, nil, :bar))
-      end
-    end
-    describe "for the range operator" do
-      it "handles positive number literals" do
-        _("1..2")
-          .must_be_parsed_as s(:lit, 1..2)
-      end
-      it "handles negative number literals" do
-        _("-1..-2")
-          .must_be_parsed_as s(:lit, -1..-2)
-      end
-      it "handles float literals" do
-        _("1.0..2.0")
-          .must_be_parsed_as s(:dot2,
-                               s(:lit, 1.0),
-                               s(:lit, 2.0))
-      end
-      it "handles string literals" do
-        _("'a'..'z'")
-          .must_be_parsed_as s(:dot2,
-                               s(:str, "a"),
-                               s(:str, "z"))
-      end
-      it "handles non-literal begin" do
-        _("foo..3")
-          .must_be_parsed_as s(:dot2,
-                               s(:call, nil, :foo),
-                               s(:lit, 3))
-      end
-      it "handles non-literal end" do
-        _("3..foo")
-          .must_be_parsed_as s(:dot2,
-                               s(:lit, 3),
-                               s(:call, nil, :foo))
-      end
-      it "handles non-literals" do
-        _("foo..bar")
-          .must_be_parsed_as s(:dot2,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar))
-      end
-      it "handles endless range literals" do
-        skip "This Ruby version does not support endless ranges" if RUBY_VERSION < "2.6.0"
-        _("1..")
-          .must_be_parsed_as s(:dot2, s(:lit, 1), nil)
-      end
-    end
-    describe "for the exclusive range operator" do
-      it "handles positive number literals" do
-        _("1...2")
-          .must_be_parsed_as s(:lit, 1...2)
-      end
-      it "handles negative number literals" do
-        _("-1...-2")
-          .must_be_parsed_as s(:lit, -1...-2)
-      end
-      it "handles float literals" do
-        _("1.0...2.0")
-          .must_be_parsed_as s(:dot3,
-                               s(:lit, 1.0),
-                               s(:lit, 2.0))
-      end
-      it "handles string literals" do
-        _("'a'...'z'")
-          .must_be_parsed_as s(:dot3,
-                               s(:str, "a"),
-                               s(:str, "z"))
-      end
-      it "handles non-literal begin" do
-        _("foo...3")
-          .must_be_parsed_as s(:dot3,
-                               s(:call, nil, :foo),
-                               s(:lit, 3))
-      end
-      it "handles non-literal end" do
-        _("3...foo")
-          .must_be_parsed_as s(:dot3,
-                               s(:lit, 3),
-                               s(:call, nil, :foo))
-      end
-      it "handles two non-literals" do
-        _("foo...bar")
-          .must_be_parsed_as s(:dot3,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar))
-      end
-    end
-    describe "for unary operators" do
-      it "handles unary minus with an integer literal" do
-        _("- 1").must_be_parsed_as s(:call, s(:lit, 1), :-@)
-      end
-      it "handles unary minus with a float literal" do
-        _("- 3.14").must_be_parsed_as s(:call, s(:lit, 3.14), :-@)
-      end
-      it "handles unary minus with a non-literal" do
-        _("-foo")
-          .must_be_parsed_as s(:call,
-                               s(:call, nil, :foo),
-                               :-@)
-      end
-      it "handles unary minus with a negative number literal" do
-        _("- -1").must_be_parsed_as s(:call, s(:lit, -1), :-@)
-      end
-      it "handles unary plus with a number literal" do
-        _("+ 1").must_be_parsed_as s(:call, s(:lit, 1), :+@)
-      end
-      it "handles unary plus with a non-literal" do
-        _("+foo")
-          .must_be_parsed_as s(:call,
-                               s(:call, nil, :foo),
-                               :+@)
-      end
-      it "handles unary !" do
-        _("!foo")
-          .must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
-      end
-      it "converts :not to :!" do
-        _("not foo")
-          .must_be_parsed_as s(:call, s(:call, nil, :foo), :!)
-      end
-      it "handles unary ! with a number literal" do
-        _("!1")
-          .must_be_parsed_as s(:call, s(:lit, 1), :!)
-      end
-      it "keeps :begin for the argument" do
-        _("- begin; foo; end")
-          .must_be_parsed_as s(:call,
-                               s(:begin, s(:call, nil, :foo)),
-                               :-@)
-      end
-    end
-    describe "for the ternary operater" do
-      it "works in the simple case" do
-        _("foo ? bar : baz")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:call, nil, :baz))
-      end
-      it "keeps :begin for the first argument" do
-        _("begin; foo; end ? bar : baz")
-          .must_be_parsed_as s(:if,
-                               s(:begin, s(:call, nil, :foo)),
-                               s(:call, nil, :bar),
-                               s(:call, nil, :baz))
-      end
-      it "keeps :begin for the second argument" do
-        _("foo ? begin; bar; end : baz")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:begin, s(:call, nil, :bar)),
-                               s(:call, nil, :baz))
-      end
-      it "keeps :begin for the third argument" do
-        _("foo ? bar : begin; baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:begin, s(:call, nil, :baz)))
-      end
-    end
-    describe "for match operators" do
-      it "handles :=~ with two non-literals" do
-        _("foo =~ bar")
-          .must_be_parsed_as s(:call,
-                               s(:call, nil, :foo),
-                               :=~,
-                               s(:call, nil, :bar))
-      end
-      it "handles :=~ with literal regexp on the left hand side" do
-        _("/foo/ =~ bar")
-          .must_be_parsed_as s(:match2,
-                               s(:lit, /foo/),
-                               s(:call, nil, :bar))
-      end
-      it "handles :=~ with literal regexp on the right hand side" do
-        _("foo =~ /bar/")
-          .must_be_parsed_as s(:match3,
-                               s(:lit, /bar/),
-                               s(:call, nil, :foo))
-      end
-      it "handles negated match operators" do
-        _("foo !~ bar").must_be_parsed_as s(:not,
-                                            s(:call,
-                                              s(:call, nil, :foo),
-                                              :=~,
-                                              s(:call, nil, :bar)))
-      end
-    end
-  end
-end