ruby-next-core 0.10.0 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cab7345f16f61d3a35a307024885c4b9a0055bb946f473bdd5a386b27175ec2
-  data.tar.gz: c3b2004bf5cd1b9dd49d2a7892bd3e88472a632f4cdc8da310bdb56fb96171d9
+  metadata.gz: 34691e69e3f0725ece379addac8297e0b69e9ed0a55fb1a06bfe3ca970213eae
+  data.tar.gz: 23edfba446641d2658d754f3678eb79de8ee332a4d481d4714887769392ad272
 SHA512:
-  metadata.gz: 4f6b3d6f64e0303e1b69fa5a99ececcf605c7413285c05feb03d9308da8449296fbea96b8779a3ac6b72dca8351ac10cd20f11161b1581ac6a60a85d951ca0d3
-  data.tar.gz: 44e5f05020cae47e13d1a89627c94d890b07daccd1e7dcf51e2e4e0eed208fca2c946e4db674f53fa0581477a368e80c73474ffc657a53f55c1e962bd3d668ba
+  metadata.gz: 0d41912b15fd77ed3a1d2d2665a3375a212a1815e26e85724d2e0960af1daa5c714b126efca1c5621dc76b16af3d612c35a077be3472ca607548a757dea253ac
+  data.tar.gz: 02d860b6d0730f48b990c6c8dd9a3ef49e022ea7a0ae637a64cd0c29a74ee1e6c2b0f4cdf0ed25886029a49d9e2df8044b9e016aead9733ca322fd3579093949

data/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## master
 
+## 0.10.5 (2020-10-13)
+
+- Fix Unparser 0.5.0 compatibility. ([@palkan][])
+
+## 0.10.4 (2020-10-09)
+
+- Restrict Unparser dependency. ([@palkan][])
+
+Unparser 0.5.0 is currently not supported.
+
+## 0.10.3 (2020-09-28)
+
+- Update RuboCop integration to handle the latest Parser changes. ([@palkan][])
+
+Parser 2.7.1.5 unified endless and normal methods and rightward and leftward assignments, thus, making some cops report false negatives.
+
+## 0.10.2 (2020-09-09)
+
+- Fix regression when `nextify` produces incorrect files for 2.7. ([@palkan][])
+
+## ~~0.10.1~~
+
 ## 0.10.0 (2020-09-02)
 
 - Add proposed shorthand Hash syntax. ([@palkan][])

data/README.md

@@ -35,6 +35,7 @@ Read more about the motivation behind the Ruby Next in this post: [Ruby Next: Ma
 ## Examples
 
 - Ruby gems
+  - [action_policy](https://github.com/palkan/action_policy)
   - [anyway_config](https://github.com/palkan/anyway_config)
   - [graphql-fragment_cache](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache)
 - Rails applications
@@ -475,6 +476,8 @@ RUBY_NEXT_CORE_STRATEGY=backports ruby-next nextify lib/
 
 **NOTE:** For Ruby 2.2, safe navigation operator (`&.`) and squiggly heredocs (`<<~TXT`) support is provided.
 
+**IMPORTANT:** Unparser `~> 0.4.8` is required to run the transpiler on Ruby <2.4.
+
 ## Proposed and edge features
 
 Ruby Next aims to bring edge and proposed features to Ruby community before they (hopefully) reach an official Ruby release.

data/bin/reparse

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$VERBOSE = nil
+
+require "bundler/setup"
+
+require "ruby-next/language"
+
+contents =
+  if File.exist?(ARGV[0])
+    File.read(ARGV[0])
+  else
+    ARGV[0]
+  end
+
+ast = RubyNext::Language.parse(contents)
+puts Unparser.unparse(ast)

data/bin/transform

@@ -5,6 +5,13 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require "bundler/setup"
 
+require "optparse"
+
+begin
+  require "pry-byebug"
+rescue LoadError
+end
+
 ENV["RUBY_NEXT_EDGE"] = "1"
 ENV["RUBY_NEXT_PROPOSED"] = "1"
 
@@ -13,16 +20,23 @@ require "ruby-next/language/rewriters/runtime"
 
 contents =
   if File.exist?(ARGV[0])
-    File.read(ARGV[0])
+    File.read(ARGV.shift)
   else
-    ARGV[0]
+    ARGV.shift
   end
 
-opts =
-  if ARGV[1] && ARGV[1] == "--current"
-    {rewriters: RubyNext::Language.current_rewriters}
-  else
-    {}
+transform_opts = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: transform filepath_or_code [options]"
+
+  opts.on("--current", "Use rewriters for the current Ruby version only") do
+    transform_opts[:rewriters] = RubyNext::Language.current_rewriters
+  end
+
+  opts.on("--rewrite", "User rewrite transpiling mode") do
+    RubyNext::Language.mode = :rewrite
   end
+end.parse!
 
-puts RubyNext::Language.transform(contents, **opts)
+puts RubyNext::Language.transform(contents, **transform_opts)

data/lib/.rbnext/2.3/ruby-next/commands/nextify.rb

@@ -95,7 +95,7 @@ module RubyNext
           exit 0
         end
 
-        unless ((!lib_path.nil?) || nil) && lib_path.then(&File.method(:exist?))
+        unless ((!lib_path.nil? || nil) && lib_path.then(&File.method(:exist?)))
           $stdout.puts "Path not found: #{lib_path}"
           $stdout.puts optparser.help
           exit 2
@@ -148,6 +148,9 @@ module RubyNext
 
         # Then, generate the source code for the next version
         transpile path, contents, version: version
+      rescue SyntaxError, StandardError => e
+        warn "Failed to transpile #{path}: #{e.class} — #{e.message}"
+        exit 1
       end
 
       def save(contents, path, version)

data/lib/.rbnext/2.3/ruby-next/language/eval.rb

@@ -8,7 +8,7 @@ module RubyNext
           def eval(source, bind = nil, *args)
             new_source = ::RubyNext::Language::Runtime.transform(
               source,
-              using: ((!bind.nil?) || nil) && bind.receiver == TOPLEVEL_BINDING.receiver || ((!(((!bind.nil?) || nil) && bind.receiver).nil?) || nil) && (((!bind.nil?) || nil) && bind.receiver).is_a?(Module)
+              using: ((!bind.nil? || nil) && bind.receiver) == TOPLEVEL_BINDING.receiver || ((!((!bind.nil? || nil) && bind.receiver).nil? || nil) && ((!bind.nil? || nil) && bind.receiver).is_a?(Module))
             )
             RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
             super new_source, bind, *args

data/lib/.rbnext/2.3/ruby-next/language/rewriters/base.rb

@@ -94,24 +94,25 @@ module RubyNext
         private
 
         def replace(range, ast)
-          ((!@source_rewriter.nil?) || nil) && @source_rewriter.replace(range, unparse(ast))
+          ((!@source_rewriter.nil? || nil) && @source_rewriter.replace(range, unparse(ast)))
         end
 
         def remove(range)
-          ((!@source_rewriter.nil?) || nil) && @source_rewriter.remove(range)
+          ((!@source_rewriter.nil? || nil) && @source_rewriter.remove(range))
         end
 
         def insert_after(range, ast)
-          ((!@source_rewriter.nil?) || nil) && @source_rewriter.insert_after(range, unparse(ast))
+          ((!@source_rewriter.nil? || nil) && @source_rewriter.insert_after(range, unparse(ast)))
         end
 
         def insert_before(range, ast)
-          ((!@source_rewriter.nil?) || nil) && @source_rewriter.insert_before(range, unparse(ast))
+          ((!@source_rewriter.nil? || nil) && @source_rewriter.insert_before(range, unparse(ast)))
         end
 
         def unparse(ast)
           return ast if ast.is_a?(String)
-          Unparser.unparse(ast)
+
+          Unparser.unparse(ast).chomp
         end
 
         attr_reader :context

data/lib/.rbnext/2.3/ruby-next/language/rewriters/endless_range.rb

@@ -55,7 +55,7 @@ module RubyNext
         attr_reader :current_index
 
         def index_arg?(node)
-          ((!(((!current_index.nil?) || nil) && current_index.children).nil?) || nil) && (((!current_index.nil?) || nil) && current_index.children).include?(node)
+          ((!((!current_index.nil? || nil) && current_index.children).nil? || nil) && ((!current_index.nil? || nil) && current_index.children).include?(node))
         end
       end
     end

data/lib/.rbnext/2.3/ruby-next/language/rewriters/pattern_matching.rb

@@ -244,7 +244,7 @@ module RubyNext
           @predicates = Predicates::CaseIn.new
 
           matchee_ast =
-            s(:lvasgn, MATCHEE, node.children[0])
+            s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
 
           patterns = locals.with(
             matchee: MATCHEE,
@@ -273,7 +273,7 @@ module RubyNext
           @predicates = Predicates::Noop.new
 
           matchee =
-            s(:lvasgn, MATCHEE, node.children[0])
+            s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
 
           pattern =
             locals.with(
@@ -285,9 +285,10 @@ module RubyNext
                 :"#{node.children[1].type}_clause",
                 node.children[1]
               ).then do |node|
-                s(:or,
-                  node,
-                  no_matching_pattern)
+                s(:begin,
+                  s(:or,
+                    node,
+                    no_matching_pattern))
               end
             end
 
@@ -309,7 +310,7 @@ module RubyNext
           remove(node.children[0].loc.expression)
 
           node.children[1..-1].each.with_index do |clause, i|
-            if ((!clause.nil?) || nil) && clause.type == :in_pattern
+            if ((!clause.nil? || nil) && clause.type) == :in_pattern
               # handle multiline clauses differently
               if clause.loc.last_line > clause.children[0].loc.last_line + 1
                 height = clause.loc.last_line - clause.children[0].loc.last_line
@@ -340,7 +341,7 @@ module RubyNext
           clauses = []
 
           nodes.each do |clause|
-            if ((!clause.nil?) || nil) && clause.type == :in_pattern
+            if ((!clause.nil? || nil) && clause.type) == :in_pattern
               clauses << build_when_clause(clause)
             else
               else_clause = process(clause)
@@ -378,9 +379,10 @@ module RubyNext
           predicates.const(case_eq_clause(const, right), const).then do |node|
             next node if pattern.nil?
 
-            s(:and,
-              node,
-              send(:"#{pattern.type}_clause", pattern))
+            s(:begin,
+              s(:and,
+                node,
+                send(:"#{pattern.type}_clause", pattern)))
           end
         end
 
@@ -391,13 +393,14 @@ module RubyNext
               send :"#{child.type}_clause", child
             end
           end
-          s(:or, *children)
+          s(:begin, s(:or, *children))
         end
 
         def match_as_clause(node, right = s(:lvar, locals[:matchee]))
-          s(:and,
-            send(:"#{node.children[0].type}_clause", node.children[0], right),
-            match_var_clause(node.children[1], right))
+          s(:begin,
+            s(:and,
+              send(:"#{node.children[0].type}_clause", node.children[0], right),
+              match_var_clause(node.children[1], right)))
         end
 
         def match_var_clause(node, left = s(:lvar, locals[:matchee]))
@@ -405,9 +408,10 @@ module RubyNext
 
           check_match_var_alternation! node.children[0]
 
-          s(:or,
-            s(:lvasgn, node.children[0], left),
-            s(:true))
+          s(:begin,
+            s(:or,
+              s(:begin, s(:lvasgn, node.children[0], left)),
+              s(:true)))
         end
 
         def pin_clause(node, right = s(:lvar, locals[:matchee]))
@@ -417,8 +421,8 @@ module RubyNext
 
         def case_eq_clause(node, right = s(:lvar, locals[:matchee]))
           predicates.terminate!
-          s(:send,
-            process(node), :===, right)
+          s(:begin, s(:send,
+            process(node), :===, right))
         end
 
         #=========== ARRAY PATTERN (START) ===============
@@ -429,10 +433,11 @@ module RubyNext
             # if there is no rest or tail, match the size first
             unless node.type == :array_pattern_with_tail || node.children.any? { |n| n.type == :match_rest }
               size_check = predicates.array_size(
-                s(:send,
-                  node.children.size.to_ast_node,
-                  :==,
-                  s(:send, s(:lvar, locals[:arr]), :size)),
+                s(:begin,
+                  s(:send,
+                    node.children.size.to_ast_node,
+                    :==,
+                    s(:send, s(:lvar, locals[:arr]), :size))),
                 node.children.size
               )
             end
@@ -448,9 +453,10 @@ module RubyNext
 
             right = s(:and, size_check, right) if size_check
 
-            s(:and,
-              dnode,
-              right)
+            s(:begin,
+              s(:and,
+                dnode,
+                right))
           end
         end
 
@@ -468,14 +474,17 @@ module RubyNext
           predicates.array_deconstructed(
             s(:and,
               respond_check,
-              s(:and,
-                s(:or,
-                  s(:lvasgn, locals[:arr], right),
-                  s(:true)),
-                s(:or,
-                  s(:send,
-                    s(:const, nil, :Array), :===, s(:lvar, locals[:arr])),
-                  raise_error(:TypeError, "#deconstruct must return Array"))))
+              s(:begin,
+                s(:and,
+                  s(:begin,
+                    s(:or,
+                      s(:begin, s(:lvasgn, locals[:arr], right)),
+                      s(:true))),
+                  s(:begin,
+                    s(:or,
+                      s(:send,
+                        s(:const, nil, :Array), :===, s(:lvar, locals[:arr])),
+                      raise_error(:TypeError, "#deconstruct must return Array"))))))
           )
         end
 
@@ -485,9 +494,10 @@ module RubyNext
           send("#{head.type}_array_element", head, index).then do |node|
             next node if tail.empty?
 
-            s(:and,
-              node,
-              array_element(index + 1, *tail))
+            s(:begin,
+              s(:and,
+                node,
+                array_element(index + 1, *tail)))
           end
         end
 
@@ -526,15 +536,17 @@ module RubyNext
 
           pattern = array_rest_element(*nodes, index).then do |needle|
             next needle unless head_match
-            s(:and,
-              needle,
-              head_match)
+            s(:begin,
+              s(:and,
+                needle,
+                head_match))
           end.then do |headed_needle|
             next headed_needle unless tail_match
 
-            s(:and,
-              headed_needle,
-              tail_match)
+            s(:begin,
+              s(:and,
+                headed_needle,
+                tail_match))
           end
 
           s(:block,
@@ -550,13 +562,14 @@ module RubyNext
             next block if match_vars.empty?
 
             # We need to declare match vars outside of `find` block
-            locals_declare = s(:masgn,
+            locals_declare = s(:begin, s(:masgn,
               s(:mlhs, *match_vars),
-              s(:nil))
+              s(:nil)))
 
-            s(:or,
-              locals_declare,
-              block)
+            s(:begin,
+              s(:or,
+                locals_declare,
+                block))
           end
         end
 
@@ -575,18 +588,20 @@ module RubyNext
 
           return rest if tail.empty?
 
-          s(:and,
-            rest,
-            array_rest_element(*tail, -(size - 1)))
+          s(:begin,
+            s(:and,
+              rest,
+              array_rest_element(*tail, -(size - 1))))
         end
 
         def array_rest_element(head, *tail, index)
           send("#{head.type}_array_element", head, index).then do |node|
             next node if tail.empty?
 
-            s(:and,
-              node,
-              array_rest_element(*tail, index + 1))
+            s(:begin,
+              s(:and,
+                node,
+                array_rest_element(*tail, index + 1)))
           end
         end
 
@@ -610,7 +625,7 @@ module RubyNext
           children = node.children.map do |child, i|
             send :"#{child.type}_array_element", child, index
           end
-          s(:or, *children)
+          s(:begin, s(:or, *children))
         end
 
         def match_var_array_element(node, index)
@@ -661,18 +676,20 @@ module RubyNext
               elsif specified_key_names.empty?
                 hash_element(*node.children)
               else
-                s(:and,
-                  having_hash_keys(specified_key_names),
-                  hash_element(*node.children))
+                s(:begin,
+                  s(:and,
+                    having_hash_keys(specified_key_names),
+                    hash_element(*node.children)))
               end
 
             predicates.pop
 
             next dnode if right.nil?
 
-            s(:and,
-              dnode,
-              right)
+            s(:begin,
+              s(:and,
+                dnode,
+                right))
           end
         end
 
@@ -715,7 +732,7 @@ module RubyNext
           # Duplicate the source hash when matching **rest, 'cause we mutate it
           hash_dup =
             if @hash_match_rest
-              s(:lvasgn, locals[:hash], s(:send, s(:lvar, locals[:hash, :src]), :dup))
+              s(:begin, s(:lvasgn, locals[:hash], s(:send, s(:lvar, locals[:hash, :src]), :dup)))
             else
               s(:true)
             end
@@ -728,29 +745,33 @@ module RubyNext
           key_names = keys.children.map { |node| node.children.last }
           predicates.push locals[:hash]
 
-          s(:lvasgn, deconstruct_name,
+          s(:begin, s(:lvasgn, deconstruct_name,
             s(:send,
-              matchee, :deconstruct_keys, keys)).then do |dnode|
+              matchee, :deconstruct_keys, keys))).then do |dnode|
             next dnode if respond_to_checked
 
             s(:and,
               respond_check,
-              s(:and,
-                s(:or,
-                  dnode,
-                  s(:true)),
-                s(:or,
-                  s(:send,
-                    s(:const, nil, :Hash), :===, s(:lvar, deconstruct_name)),
-                  raise_error(:TypeError, "#deconstruct_keys must return Hash"))))
+              s(:begin,
+                s(:and,
+                  s(:begin,
+                    s(:or,
+                      dnode,
+                      s(:true))),
+                  s(:begin,
+                    s(:or,
+                      s(:send,
+                        s(:const, nil, :Hash), :===, s(:lvar, deconstruct_name)),
+                      raise_error(:TypeError, "#deconstruct_keys must return Hash"))))))
           end.then do |dnode|
             predicates.hash_deconstructed(dnode, key_names)
           end.then do |dnode|
             next dnode unless @hash_match_rest
 
-            s(:and,
-              dnode,
-              hash_dup)
+            s(:begin,
+              s(:and,
+                dnode,
+                hash_dup))
           end
         end
 
@@ -780,9 +801,10 @@ module RubyNext
 
             next node if right.nil?
 
-            s(:and,
-              node,
-              right)
+            s(:begin,
+              s(:and,
+                node,
+                right))
           end
         end
 
@@ -792,7 +814,7 @@ module RubyNext
         end
 
         def match_alt_hash_element(node, key)
-          element_node = s(:lvasgn, locals[:hash, :el], hash_value_at(key))
+          element_node = s(:begin, s(:lvasgn, locals[:hash, :el], hash_value_at(key)))
 
           children = locals.with(hash_element: locals[:hash, :el]) do
             node.children.map do |child, i|
@@ -800,11 +822,14 @@ module RubyNext
             end
           end
 
-          s(:and,
-            s(:or,
-              element_node,
-              s(:true)),
-            s(:or, *children))
+          s(:begin,
+            s(:and,
+              s(:begin,
+                s(:or,
+                  element_node,
+                  s(:true))),
+              s(:begin,
+                s(:or, *children))))
         end
 
         def match_as_hash_element(node, key)
@@ -862,9 +887,10 @@ module RubyNext
           node = predicates.hash_key(hash_has_key(key, hash), key)
 
           keys.reduce(node) do |res, key|
-            s(:and,
-              res,
-              predicates.hash_key(hash_has_key(key, hash), key))
+            s(:begin,
+              s(:and,
+                res,
+                predicates.hash_key(hash_has_key(key, hash), key)))
           end
         end
 
@@ -873,9 +899,10 @@ module RubyNext
         def with_guard(node, guard)
           return node unless guard
 
-          s(:and,
-            node,
-            guard.children[0]).then do |expr|
+          s(:begin,
+            s(:and,
+              node,
+              guard.children[0])).then do |expr|
             next expr unless guard.type == :unless_guard
             s(:send, expr, :!)
           end
@@ -933,10 +960,10 @@ module RubyNext
           deconstructed_keys[key] = :"k#{deconstructed_keys.size}"
         end
 
-        # Unparser generates `do .. end`  blocks, we want to
+        # Unparser generates `do .. end` or `{ ... }` multiline blocks, we want to
         # have single-line blocks with `{ ... }`.
         def inline_blocks(source)
-          source.gsub(/do \|_, __i__\|\n\s*([^\n]+)\n\s*end/, '{ |_, __i__| \1 }')
+          source.gsub(/(?:do|{) \|_, __i__\|\n\s*([^\n]+)\n\s*(?:end|})/, '{ |_, __i__| \1 }')
         end
       end
     end