ripper_ruby_parser 1.7.0 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16ae34997256487e8611f1c1128bfa3f0ededad4befbdcba5cae435e957e4382
-  data.tar.gz: 9751a46aeaa42e05bc52587fa0fee46b64e0b45204b9cbf651f7492d7e6bde90
+  metadata.gz: 4e4ee66b4ce6abf5b0eeacd55fd137dd7217bf728bc59f1ad6bdf0b197011f86
+  data.tar.gz: a35a48bfa5178c5a9cec64017842246a4acb8b10a0c09fba2749de9aa650772c
 SHA512:
-  metadata.gz: c31670a8b6d911f7679096feb5d1b01e2c67a7aec7694eb7f4ac932c2f335f24e5996074bd0857614e8f508c093f639d644f3ab4555de97c68f1ea601f4fd586
-  data.tar.gz: 2668135d139b2c4c5cb3da3f036bc7653896239a48846bbae4fe18056bb751f21e00618c8b2d7b90f3de3e504f4dfb959e442f3f302b253bcf777a0232329950
+  metadata.gz: 0574addabb87b0f843c2a72a3e5c03b6ffff2461a9f1fa551412ee706841a2baeb354c1decd3ca7c902e1e78c2c2b7c4a346784ebb6c5b1064211b4ca08b8039
+  data.tar.gz: cffd4a9f013b443e82b3b4d6149719b02119f182aafe86fc2984d81b131bc047bd1143ca5b06cd28dc32e71876cbb67452c9db47979a50d766e28ea7b7f590a2

data/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+Notable changes to this project will be documented in this file.
+
+This project adheres to [Semantic Versioning 2.0.0][1].
+
+This document is formatted based on [Keep A CHANGELOG][2].
+
+## 1.9.0 / 2021-08-10
+
+* Fix escape sequence handling in non-interpolating strings and word lists
+  ([#152])
+* Handle strings with mixed valid and invalid utf8 ([#153])
+* Handle argument forwarding, updating the RubyParser compatibility target to
+  3.17.0 ([#154])
+* Fix encoding for non-interpolating strings as well ([#155])
+
+## 1.8.0 / 2021-05-18
+
+### Changes
+
+* Drop support for Ruby 2.4 ([2cf6b4050] and [#145])
+* Update RubyParser compatibility target to 3.15.0 ([#105])
+* Fix handling of dedented heredoc ([#106])
+* Add support for running on Ruby 3.0 ([#123])
+* Various code improvements and other internal changes
+
+## 1.7.2 / 2020-02-28
+
+### Bug fixes
+
+* Support imaginary number literals ([#100])
+* Handle anonymous kwrest arguments ([#95])
+
+### Internal changes
+
+* Update tests ([#101])
+* Prepare for testing on Ruby 2.7 ([#99])
+* Various improvements ([#98])
+* Split long module ([#97])
+
+## 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 +226,27 @@
 * Initial release
 
 <!-- Pull request links -->
+[#155]: https://github.com/mvz/ripper_ruby_parser/pull/155
+[#154]: https://github.com/mvz/ripper_ruby_parser/pull/154
+[#153]: https://github.com/mvz/ripper_ruby_parser/pull/153
+[#152]: https://github.com/mvz/ripper_ruby_parser/pull/152
+[#145]: https://github.com/mvz/ripper_ruby_parser/pull/145
+[#123]: https://github.com/mvz/ripper_ruby_parser/pull/123
+[#106]: https://github.com/mvz/ripper_ruby_parser/pull/106
+[#105]: https://github.com/mvz/ripper_ruby_parser/pull/105
+[#101]: https://github.com/mvz/ripper_ruby_parser/pull/101
+[#100]: https://github.com/mvz/ripper_ruby_parser/pull/100
+[#99]: https://github.com/mvz/ripper_ruby_parser/pull/99
+[#98]: https://github.com/mvz/ripper_ruby_parser/pull/98
+[#97]: https://github.com/mvz/ripper_ruby_parser/pull/97
+[#95]: https://github.com/mvz/ripper_ruby_parser/pull/95
+[#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
@@ -196,3 +264,11 @@
 [#67]: https://github.com/mvz/ripper_ruby_parser/pull/67
 [#66]: https://github.com/mvz/ripper_ruby_parser/pull/66
 [#65]: https://github.com/mvz/ripper_ruby_parser/pull/65
+
+<!-- Git sha links -->
+[2cf6b4050]: https://github.com/mvz/ripper_ruby_parser/commit/2cf6b40501576003b916196e23222276b51aa53c
+
+<!-- Other links -->
+
+[1]:  https://semver.org/spec/v2.0.0.html
+[2]:  https://keepachangelog.com/en/1.0.0/

data/README.md

@@ -10,8 +10,8 @@ Parse with Ripper, produce sexps that are compatible with RubyParser.
 
 * Drop-in replacement for RubyParser
 * Should handle 1.9 and later syntax gracefully
-* Requires Ruby 2.4 or higher
-* Compatible with RubyParser 3.14.0
+* Requires Ruby 2.5 or higher
+* Compatible with RubyParser 3.17.0
 
 ## Known incompatibilities
 
@@ -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.5 or higher
 * `sexp_processor`
 
 ## Hacking and contributing
@@ -62,7 +64,7 @@ If you want to send pull requests or patches, please:
 
 (The MIT License)
 
-Copyright (c) 2012, 2014-2019 Matijs van Zuijlen
+Copyright (c) 2012, 2014-2020 Matijs van Zuijlen
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/ripper_ruby_parser/commenting_ripper_parser.rb

@@ -27,6 +27,8 @@ module RipperRubyParser
       Sexp.from_array(result)
     end
 
+    private
+
     def on_backtick(delimiter)
       @delimiter_stack.push delimiter
       super
@@ -101,6 +103,18 @@ module RipperRubyParser
       @delimiter_stack.push delimiter
     end
 
+    def on_heredoc_dedent(val, width)
+      next_dedent = true
+      val.map! do |e|
+        if e.is_a?(Array) && e[0] == :@tstring_content
+          e = dedent_element(e, width) if next_dedent
+          next_dedent = e[1].end_with? "\n"
+        end
+        e
+      end
+      val
+    end
+
     def on_heredoc_end(_delimiter)
       @delimiter_stack.pop
     end
@@ -293,28 +307,26 @@ module RipperRubyParser
       commentize(:END, super)
     end
 
-    def on_parse_error(*args)
-      raise SyntaxError, *args
+    def on_parse_error(message)
+      raise SyntaxError, message
     end
 
-    def on_class_name_error(*args)
-      raise SyntaxError, *args
+    def on_class_name_error(message, *)
+      raise SyntaxError, message
     end
 
-    def on_alias_error(*args)
-      raise SyntaxError, *args
+    def on_alias_error(message, *)
+      raise SyntaxError, message
     end
 
-    def on_assign_error(*args)
-      raise SyntaxError, *args
+    def on_assign_error(message, *)
+      raise SyntaxError, message
     end
 
-    def on_param_error(*args)
-      raise SyntaxError, *args
+    def on_param_error(message, *)
+      raise SyntaxError, message
     end
 
-    private
-
     def commentize(_name, exp)
       (_, _kw, loc), comment = @comment_stack.pop
       @comment = ""

data/lib/ripper_ruby_parser/sexp_handlers.rb

@@ -10,6 +10,7 @@ require "ripper_ruby_parser/sexp_handlers/loops"
 require "ripper_ruby_parser/sexp_handlers/method_calls"
 require "ripper_ruby_parser/sexp_handlers/methods"
 require "ripper_ruby_parser/sexp_handlers/operators"
+require "ripper_ruby_parser/sexp_handlers/string_literals"
 
 module RipperRubyParser
   # Umbrella module for handlers of particular sexp types
@@ -28,6 +29,7 @@ module RipperRubyParser
         include MethodCalls
         include Methods
         include Operators
+        include StringLiterals
       end
     end
   end

data/lib/ripper_ruby_parser/sexp_handlers/assignment.rb

@@ -118,8 +118,8 @@ module RipperRubyParser
       end
 
       OPERATOR_ASSIGNMENT_MAP = {
-        '||': :op_asgn_or,
-        '&&': :op_asgn_and
+        "||": :op_asgn_or,
+        "&&": :op_asgn_and
       }.freeze
 
       def create_operator_assignment_sub_type(lvalue, value, operator)
@@ -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

@@ -17,13 +17,14 @@ module RipperRubyParser
       def process_params(exp)
         _, normal, defaults, splat, rest, kwargs, doublesplat, block = exp.shift 8
 
-        args = handle_normal_arguments normal
-        args += handle_default_arguments defaults
-        args += handle_splat splat
-        args += handle_normal_arguments rest
-        args += handle_kwargs kwargs
-        args += handle_double_splat doublesplat
-        args += handle_block_argument block
+        args =
+          handle_normal_arguments(normal) +
+          handle_default_arguments(defaults) +
+          handle_splat(splat) +
+          handle_normal_arguments(rest) +
+          handle_kwargs(kwargs) +
+          handle_double_splat(doublesplat) +
+          handle_block_argument(block)
 
         s(:args, *args)
       end
@@ -35,7 +36,7 @@ module RipperRubyParser
 
       def process_kwrest_param(exp)
         _, sym, = exp.shift 3
-        process(sym)
+        process(sym) || s(:lvar, :"")
       end
 
       def process_block_var(exp)
@@ -49,7 +50,7 @@ module RipperRubyParser
       def process_begin(exp)
         _, body, pos = exp.shift 3
 
-        body = convert_empty_to_nil_symbol process(body)
+        body = convert_void_stmt_to_nil_symbol process(body)
         with_position pos, s(:begin, body)
       end
 
@@ -58,19 +59,7 @@ module RipperRubyParser
         rescue_block = map_process_list_compact block.sexp_body
         rescue_block << nil if rescue_block.empty?
 
-        capture = if eclass.nil?
-                    s(:array)
-                  elsif eclass.first.is_a? Symbol
-                    eclass = process(eclass)
-                    body = eclass.sexp_body
-                    if eclass.sexp_type == :mrhs
-                      body.first
-                    else
-                      s(:array, *body)
-                    end
-                  else
-                    s(:array, process(eclass.first))
-                  end
+        capture = handle_rescue_class_list eclass
 
         capture << create_assignment_sub_type(process(evar), s(:gvar, :$!)) if evar
 
@@ -80,23 +69,22 @@ module RipperRubyParser
       def process_bodystmt(exp)
         _, main, rescue_block, else_block, ensure_block = exp.shift 5
 
-        body = s()
+        body_list = []
 
-        main_list = map_unwrap_begin_list map_process_list main.sexp_body
-        line = main_list.first.line
-        main = wrap_in_block reject_void_stmt main_list
-        body << main if main
+        main_block = process(main)
+        line = main_block.line
+        body_list << main_block if main_block.sexp_type != :void_stmt
 
-        body.push(*process(rescue_block)) if rescue_block
-        body << process(else_block) if else_block
-        body = s(s(:rescue, *body)) if rescue_block
+        body_list.push(*process(rescue_block)) if rescue_block
+        body_list << process(else_block) if else_block
+        body_list = [s(:rescue, *body_list)] if rescue_block
 
         if ensure_block
-          body << process(ensure_block)
-          body = s(s(:ensure, *body))
+          body_list << process(ensure_block)
+          body_list = [s(:ensure, *body_list)]
         end
 
-        wrap_in_block(body) || s().line(line)
+        wrap_in_block(body_list, line)
       end
 
       def process_rescue_mod(exp)
@@ -132,12 +120,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
@@ -194,12 +186,19 @@ module RipperRubyParser
         [process(block)]
       end
 
-      def convert_empty_to_nil_symbol(block)
-        case block.length
-        when 0
-          s(:nil)
+      def handle_rescue_class_list(eclass)
+        if eclass.nil?
+          s(:array)
+        elsif eclass.first.is_a? Symbol
+          eclass = process(eclass)
+          body = eclass.sexp_body
+          if eclass.sexp_type == :mrhs
+            body.first
+          else
+            s(:array, *body)
+          end
         else
-          block
+          s(:array, process(eclass.first))
         end
       end
 
@@ -212,17 +211,6 @@ module RipperRubyParser
           s(:iter, call, args, stmt)
         end
       end
-
-      def wrap_in_block(statements)
-        case statements.length
-        when 0
-          nil
-        when 1
-          statements.first
-        else
-          s(:block, *statements)
-        end
-      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb

@@ -47,33 +47,20 @@ module RipperRubyParser
 
       def process_case(exp)
         _, expr, clauses = exp.shift 3
-        s(:case, process(expr), *process(clauses))
+        s(:case, process(expr), *process(clauses).sexp_body)
       end
 
       def process_when(exp)
         _, values, truepart, falsepart = exp.shift 4
 
-        falsepart = process(falsepart)
-        falsepart = unwrap_nil falsepart if falsepart
-
-        if falsepart.nil?
-          falsepart = [nil]
-        elsif falsepart.first.is_a? Symbol
-          falsepart = s(falsepart)
-        end
+        falsepart ||= s(:void_stmt)
 
+        falsepart = unwrap_case_body process(falsepart)
         values = process(values).sexp_body
+        truepart = unwrap_block process(truepart)
 
-        truepart = map_process_list_compact truepart.sexp_body
-        truepart = if truepart.empty?
-                     [nil]
-                   else
-                     unwrap_block(truepart.shift) + truepart
-                   end
-
-        s(s(:when,
-            s(:array, *values),
-            *truepart),
+        s(:case_body,
+          s(:when, s(:array, *values), *truepart),
           *falsepart)
       end
 
@@ -109,6 +96,17 @@ module RipperRubyParser
           s(:if, cond, truepart, falsepart)
         end
       end
+
+      def unwrap_case_body(exp)
+        case exp.sexp_type
+        when :case_body
+          exp.sexp_body
+        when :void_stmt
+          [nil]
+        else
+          [exp]
+        end
+      end
     end
   end
 end