ripper_ruby_parser 1.7.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16ae34997256487e8611f1c1128bfa3f0ededad4befbdcba5cae435e957e4382
-  data.tar.gz: 9751a46aeaa42e05bc52587fa0fee46b64e0b45204b9cbf651f7492d7e6bde90
+  metadata.gz: 943fa1c037a2a2a257d13aed73d33194756f57d0d582207062331f60b5629cd3
+  data.tar.gz: 94fffed38a9e3354a8f9a903add44e26d5bbc8ea599afb72141fbb877f4e2e22
 SHA512:
-  metadata.gz: c31670a8b6d911f7679096feb5d1b01e2c67a7aec7694eb7f4ac932c2f335f24e5996074bd0857614e8f508c093f639d644f3ab4555de97c68f1ea601f4fd586
-  data.tar.gz: 2668135d139b2c4c5cb3da3f036bc7653896239a48846bbae4fe18056bb751f21e00618c8b2d7b90f3de3e504f4dfb959e442f3f302b253bcf777a0232329950
+  metadata.gz: b677389067d2759571fb431a8055a4909b58026c127b43fde51d158e6de48633f423cb88f448a996da0406e2e02ff60e9834a25aeff2c5eb49274e80d63d6558
+  data.tar.gz: 47df66fb3e972978919e3224522957ef7ccc3a430ee09318775efd1191c1d87aaf54432aca181ea36b4abc729847eda1355809e5d785a6e68ea1c2ae15c96968

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.7.1 / 2019-11-03
+
+* Handle unicode escapes with five or six hex digits ([#94])
+* Handle safe attribute assignment ([#92])
+* Handle endless ranges on Ruby 2.6+ ([#90])
+* Add preliminary support for Ruby 2.7 ([#89])
+* Improve line number handling for stabby lambdas ([#88])
+
 ## 1.7.0 / 2019-11-01
 
 * Make results compatible with RubyParser 3.14.0 ([#85])
@@ -179,6 +187,13 @@
 * Initial release
 
 <!-- Pull request links -->
+[#94]: https://github.com/mvz/ripper_ruby_parser/pull/94
+[#92]: https://github.com/mvz/ripper_ruby_parser/pull/92
+[#90]: https://github.com/mvz/ripper_ruby_parser/pull/90
+[#89]: https://github.com/mvz/ripper_ruby_parser/pull/89
+[#88]: https://github.com/mvz/ripper_ruby_parser/pull/88
+[#86]: https://github.com/mvz/ripper_ruby_parser/pull/86
+[#85]: https://github.com/mvz/ripper_ruby_parser/pull/85
 [#82]: https://github.com/mvz/ripper_ruby_parser/pull/82
 [#80]: https://github.com/mvz/ripper_ruby_parser/pull/80
 [#79]: https://github.com/mvz/ripper_ruby_parser/pull/79

data/README.md

@@ -20,6 +20,8 @@ RipperRubyParser has a few incompatibilities with RubyParser.
 * RipperRubyParser won't handle non-UTF-8 files without an encoding comment,
   just like regular Ruby
 * RipperRubyParser does not always match RubyParser's line numbering
+* RipperRubyParser dedents auto-dedenting heredocs
+* RipperRubyParser does not include postfix comments
 
 ## Install
 
@@ -42,7 +44,7 @@ parser.parse "foo[bar] += baz qux"
 
 ## Requirements
 
-* Ruby 2.3 or higher
+* Ruby 2.4 or higher
 * `sexp_processor`
 
 ## Hacking and contributing

data/lib/ripper_ruby_parser/sexp_handlers/assignment.rb

@@ -150,8 +150,13 @@ module RipperRubyParser
           arglist.shift
           s(:attrasgn, arr, :[]=, *arglist)
         when :field
-          _, obj, _, (_, field) = lvalue
-          s(:attrasgn, obj, :"#{field}=", value)
+          _, obj, call_op, (_, field) = lvalue
+          case call_op
+          when :"&.", s(:op, :"&.") # Handle both 2.5 and 2.6 style ops
+            s(:safe_attrasgn, obj, :"#{field}=", value)
+          else
+            s(:attrasgn, obj, :"#{field}=", value)
+          end
         else
           create_assignment_sub_type lvalue, value
         end

data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb

@@ -132,12 +132,16 @@ module RipperRubyParser
 
       def process_lambda(exp)
         _, args, statements = exp.shift 3
+
         old_type = args.sexp_type
         args = convert_arguments(process(args))
+        statements = process(statements)
+        line = args.line || statements.line
         args = nil if args == s(:args) && old_type == :params
-        make_iter(s(:lambda),
-                  args,
-                  safe_unwrap_void_stmt(process(statements)))
+        call = s(:lambda)
+        call.line = line
+
+        make_iter call, args, safe_unwrap_void_stmt(statements)
       end
 
       private

data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb

@@ -41,7 +41,7 @@ module RipperRubyParser
       end
 
       def integer_literal?(exp)
-        exp.sexp_type == :lit && exp[1].is_a?(Integer)
+        exp && exp.sexp_type == :lit && exp[1].is_a?(Integer)
       end
 
       def reject_void_stmt(body)

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -98,6 +98,7 @@ module RipperRubyParser
       }.freeze
 
       def convert_arguments(args)
+        args.line ||= args.sexp_body.first&.line
         args.map! do |item|
           if item.is_a? Symbol
             item

data/lib/ripper_ruby_parser/sexp_processor.rb

@@ -79,10 +79,12 @@ module RipperRubyParser
 
     def process_stmts(exp)
       _, *statements = shift_all(exp)
-      statements = map_process_list_compact statements
+      statements = map_unwrap_begin_list map_process_list statements
+      line = statements.first.line
+      statements = reject_void_stmt statements
       case statements.count
       when 0
-        s(:void_stmt)
+        s(:void_stmt).line(line)
       when 1
         statements.first
       else

data/lib/ripper_ruby_parser/unescape.rb

@@ -7,19 +7,19 @@ module RipperRubyParser
   module Unescape
     ESCAPE_SEQUENCE_REGEXP =
       /\\(
-        [0-7]{1,3}        | # octal character
-        x[0-9a-fA-F]{1,2} | # hex byte
-        u[0-9a-fA-F]+     | # unicode character
-        u{[0-9a-fA-F]{4}} | # unicode character
-        M-\\C-.           | # meta-ctrl
-        C-\\M-.           | # ctrl-meta
-        M-\\c.            | # meta-ctrl (shorthand)
-        c\\M-.            | # ctrl-meta (shorthand)
-        C-.               | # control (regular)
-        c.                | # control (shorthand)
-        M-.               | # meta
-        \n                | # line continuation
-        .                   # single-character
+        [0-7]{1,3}          | # octal character
+        x[0-9a-fA-F]{1,2}   | # hex byte
+        u[0-9a-fA-F]+       | # unicode character
+        u{[0-9a-fA-F]{4,6}} | # unicode character
+        M-\\C-.             | # meta-ctrl
+        C-\\M-.             | # ctrl-meta
+        M-\\c.              | # meta-ctrl (shorthand)
+        c\\M-.              | # ctrl-meta (shorthand)
+        C-.                 | # control (regular)
+        c.                  | # control (shorthand)
+        M-.                 | # meta
+        \n                  | # line continuation
+        .                     # single-character
       )/x.freeze
 
     SINGLE_LETTER_ESCAPES = {

data/lib/ripper_ruby_parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RipperRubyParser
-  VERSION = "1.7.0"
+  VERSION = "1.7.1"
 end

data/test/end_to_end/comparison_test.rb

@@ -35,8 +35,8 @@ describe "Using RipperRubyParser and RubyParser" do
       RUBY
     end
 
-    it "gives the same result" do
-      _(program).must_be_parsed_as_before
+    it "gives the same result with line numbers" do
+      _(program).must_be_parsed_as_before with_line_numbers: true
     end
   end
 
@@ -63,8 +63,8 @@ describe "Using RipperRubyParser and RubyParser" do
       RUBY
     end
 
-    it "gives the same result" do
-      _(program).must_be_parsed_as_before
+    it "gives the same result with line numbers" do
+      _(program).must_be_parsed_as_before with_line_numbers: true
     end
   end
 
@@ -87,8 +87,8 @@ describe "Using RipperRubyParser and RubyParser" do
       RUBY
     end
 
-    it "gives the same result" do
-      _(program).must_be_parsed_as_before
+    it "gives the same result with line numbers" do
+      _(program).must_be_parsed_as_before with_line_numbers: true
     end
   end
 

data/test/ripper_ruby_parser/sexp_handlers/assignment_test.rb

@@ -104,6 +104,14 @@ describe RipperRubyParser::Parser do
                                s(:call, nil, :baz))
       end
 
+      it "works when safe-assigning to an attribute" do
+        _("foo&.bar = baz")
+          .must_be_parsed_as s(:safe_attrasgn,
+                               s(:call, nil, :foo),
+                               :bar=,
+                               s(:call, nil, :baz))
+      end
+
       describe "when assigning to a class variable" do
         it "works outside a method" do
           _("@@foo = bar")
@@ -183,65 +191,35 @@ describe RipperRubyParser::Parser do
         end
 
         it "works with a method call with argument without brackets" do
-          expected = if RUBY_VERSION < "2.4.0"
-                       s(:rescue,
-                         s(:lasgn, :foo,
-                           s(:call, nil, :bar, s(:call, nil, :baz))),
-                         s(:resbody, s(:array), s(:call, nil, :qux)))
-                     else
-                       s(:lasgn, :foo,
-                         s(:rescue,
-                           s(:call, nil, :bar, s(:call, nil, :baz)),
-                           s(:resbody, s(:array), s(:call, nil, :qux))))
-                     end
-          _("foo = bar baz rescue qux").must_be_parsed_as expected
+          _("foo = bar baz rescue qux")
+            .must_be_parsed_as s(:lasgn, :foo,
+                                 s(:rescue,
+                                   s(:call, nil, :bar, s(:call, nil, :baz)),
+                                   s(:resbody, s(:array), s(:call, nil, :qux))))
         end
 
         it "works with a class method call with argument without brackets" do
-          expected = if RUBY_VERSION < "2.4.0"
-                       s(:rescue,
-                         s(:lasgn, :foo,
-                           s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux))),
-                         s(:resbody, s(:array), s(:call, nil, :quuz)))
-                     else
-                       s(:lasgn, :foo,
-                         s(:rescue,
-                           s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux)),
-                           s(:resbody, s(:array), s(:call, nil, :quuz))))
-                     end
           _("foo = Bar.baz qux rescue quuz")
-            .must_be_parsed_as expected
+            .must_be_parsed_as s(:lasgn, :foo,
+                                 s(:rescue,
+                                   s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux)),
+                                   s(:resbody, s(:array), s(:call, nil, :quuz))))
         end
 
         it "works with a method call with argument without brackets" do
-          expected = if RUBY_VERSION < "2.4.0"
-                       s(:rescue,
-                         s(:lasgn, :foo,
-                           s(:call, nil, :bar, s(:call, nil, :baz))),
-                         s(:resbody, s(:array), s(:call, nil, :qux)))
-                     else
-                       s(:lasgn, :foo,
-                         s(:rescue,
-                           s(:call, nil, :bar, s(:call, nil, :baz)),
-                           s(:resbody, s(:array), s(:call, nil, :qux))))
-                     end
-          _("foo = bar baz rescue qux").must_be_parsed_as expected
+          _("foo = bar baz rescue qux")
+            .must_be_parsed_as s(:lasgn, :foo,
+                                 s(:rescue,
+                                   s(:call, nil, :bar, s(:call, nil, :baz)),
+                                   s(:resbody, s(:array), s(:call, nil, :qux))))
         end
 
         it "works with a class method call with argument without brackets" do
-          expected = if RUBY_VERSION < "2.4.0"
-                       s(:rescue,
-                         s(:lasgn, :foo,
-                           s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux))),
-                         s(:resbody, s(:array), s(:call, nil, :quuz)))
-                     else
-                       s(:lasgn, :foo,
-                         s(:rescue,
-                           s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux)),
-                           s(:resbody, s(:array), s(:call, nil, :quuz))))
-                     end
           _("foo = Bar.baz qux rescue quuz")
-            .must_be_parsed_as expected
+            .must_be_parsed_as s(:lasgn, :foo,
+                                 s(:rescue,
+                                   s(:call, s(:const, :Bar), :baz, s(:call, nil, :qux)),
+                                   s(:resbody, s(:array), s(:call, nil, :quuz))))
         end
       end
 
@@ -285,12 +263,23 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with a rescue modifier" do
+        expected = if RUBY_VERSION < "2.7.0"
+                     s(:rescue,
+                       s(:masgn,
+                         s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
+                         s(:to_ary, s(:call, nil, :baz))),
+                       s(:resbody, s(:array), s(:call, nil, :qux)))
+                   else
+                     s(:masgn,
+                       s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
+                       s(:to_ary,
+                         s(:rescue,
+                           s(:call, nil, :baz),
+                           s(:resbody, s(:array), s(:call, nil, :qux)))))
+                   end
+
         _("foo, bar = baz rescue qux")
-          .must_be_parsed_as s(:rescue,
-                               s(:masgn,
-                                 s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
-                                 s(:to_ary, s(:call, nil, :baz))),
-                               s(:resbody, s(:array), s(:call, nil, :qux)))
+          .must_be_parsed_as expected
       end
 
       it "works the same number of items on each side" do
@@ -455,6 +444,14 @@ describe RipperRubyParser::Parser do
                                s(:call, nil, :baz),
                                s(:call, nil, :qux))
       end
+
+      it "handles safe-assigning to an attribute of the collection element" do
+        _("foo[bar]&.baz = qux")
+          .must_be_parsed_as s(:safe_attrasgn,
+                               s(:call, s(:call, nil, :foo), :[], s(:call, nil, :bar)),
+                               :baz=,
+                               s(:call, nil, :qux))
+      end
     end
 
     describe "for operator assignment" do

data/test/ripper_ruby_parser/sexp_handlers/blocks_test.rb

@@ -656,6 +656,22 @@ describe RipperRubyParser::Parser do
                                  s(:call, nil, :bar),
                                  s(:call, nil, :baz)))
       end
+
+      it "sets line numbers correctly for lambdas with empty bodies" do
+        _("->(foo) { }\nbar")
+          .must_be_parsed_as s(:block,
+                               s(:iter, s(:lambda).line(1), s(:args, :foo).line(1)).line(1),
+                               s(:call, nil, :bar).line(2)).line(1),
+                             with_line_numbers: true
+      end
+
+      it "sets line numbers correctly for empty lambdas" do
+        _("->() { }\nfoo")
+          .must_be_parsed_as s(:block,
+                               s(:iter, s(:lambda).line(1), s(:args).line(1)).line(1),
+                               s(:call, nil, :foo).line(2)).line(1),
+                             with_line_numbers: true
+      end
     end
 
     describe "for lambda keyword" do

data/test/ripper_ruby_parser/sexp_handlers/literals_test.rb

@@ -262,6 +262,14 @@ describe RipperRubyParser::Parser do
           _('"foo\\u{273b}bar"').must_be_parsed_as s(:str, "foo✻bar")
         end
 
+        it "works with unicode escapes with braces with 5 hex chars" do
+          _('"foo\\u{101D1}bar"').must_be_parsed_as s(:str, "foo𐇑bar")
+        end
+
+        it "works with unicode escapes with braces with 6 hex chars" do
+          _('"foo\\u{10FFFF}bar"').must_be_parsed_as s(:str, "foo\u{10FFFF}bar")
+        end
+
         it "converts to unicode if possible" do
           _('"2\302\275"').must_be_parsed_as s(:str, "2½")
         end

data/test/ripper_ruby_parser/sexp_handlers/operators_test.rb

@@ -227,6 +227,12 @@ describe RipperRubyParser::Parser do
                                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

data/test/samples/assignment.rb

@@ -15,3 +15,8 @@ foo, (bar, baz) = qux
 foo, ((bar, baz)) = qux
 foo, (((bar, baz))) = qux
 foo, (bar, (baz, qux)) = quuz
+
+# Safe attribute assignment
+foo&.bar = baz
+foo[bar]&.baz = qux
+foo[bar, baz]&.qux = quuz

data/test/samples/strings.rb

@@ -14,6 +14,7 @@
 "#{foo}2\302\275"
 %W(2\302\275)
 /2\302\275/
+"foo\u{101D1}bar"
 
 
 # Encoding

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ripper_ruby_parser
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.1
 platform: ruby
 authors:
 - Matijs van Zuijlen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-01 00:00:00.000000000 Z
+date: 2019-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sexp_processor
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.14.0
+        version: 3.14.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.14.0
+        version: 3.14.1
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement