ruby-next 0.2.0 → 0.3.0

data/lib/ruby-next/core/hash/deconstruct_keys.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Hash, method: :deconstruct_keys, version: "2.7" do
+  <<~RUBY
+    def deconstruct_keys(_)
+      self
+    end
+  RUBY
+end
+
+# We need to hack `respond_to?` in Ruby 2.5, since it's not working with refinements
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
+  RubyNext::Core.patch refineable: Hash, name: "HashRespondToDeconstructKeys", method: :deconstruct_keys, version: "2.7" do
+    <<~RUBY
+      def respond_to?(mid, *)
+        return true if mid == :deconstruct_keys
+        super
+      end
+    RUBY
+  end
+end

data/lib/ruby-next/core/hash/merge.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
-unless {}.method(:merge).arity == -1
-  RubyNext.module_eval do
-    refine Hash do
-      def merge(*others)
-        return super if others.size == 1
-        return dup if others.size == 0
+RubyNext::Core.patch Hash, method: :merge, version: "2.6", supported: {}.method(:merge).arity < 0, core_ext: :prepend do
+  <<~RUBY
+    def merge(*others)
+      return super if others.size == 1
+      return dup if others.size == 0
 
-        merge(others.shift).tap do |new_h|
-          others.each { |h| new_h.merge!(h) }
-        end
+      merge(others.shift).tap do |new_h|
+        others.each { |h| new_h.merge!(h) }
       end
     end
-  end
+  RUBY
 end

data/lib/ruby-next/core/kernel/then.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-unless Object.new.respond_to?(:then)
-  RubyNext.module_eval do
-    # Refine object, 'cause refining modules (Kernel) is vulnerable to prepend:
-    # - https://bugs.ruby-lang.org/issues/13446
-    # - Rails added `Kernel.prepend` in 6.1: https://github.com/rails/rails/commit/3124007bd674dcdc9c3b5c6b2964dfb7a1a0733c
-    refine Object do
-      alias then yield_self
-    end
-  end
+# Refine object, 'cause refining modules (Kernel) is vulnerable to prepend:
+# - https://bugs.ruby-lang.org/issues/13446
+# - Rails added `Kernel.prepend` in 6.1: https://github.com/rails/rails/commit/3124007bd674dcdc9c3b5c6b2964dfb7a1a0733c
+RubyNext::Core.patch Kernel, method: :then, version: "2.6", refineable: Object do
+  <<~RUBY
+    alias then yield_self
+  RUBY
 end

data/lib/ruby-next/core/proc/compose.rb

@@ -1,21 +1,19 @@
 # frozen_string_literal: true
 
 # rubocop:disable Style/LambdaCall
-unless proc {}.respond_to?(:<<)
-  RubyNext.module_eval do
-    refine Proc do
-      def <<(other)
-        raise TypeError, "callable object is expected" unless other.respond_to?(:call)
-        this = self
-        proc { |*args, &block| this.(other.(*args, &block)) }
-      end
+RubyNext::Core.patch Proc, name: "ProcCompose", method: :<<, version: "2.6" do
+  <<~RUBY
+    def <<(other)
+      raise TypeError, "callable object is expected" unless other.respond_to?(:call)
+      this = self
+      proc { |*args, &block| this.(other.(*args, &block)) }
+    end
 
-      def >>(other)
-        raise TypeError, "callable object is expected" unless other.respond_to?(:call)
-        this = self
-        proc { |*args, &block| other.(this.(*args, &block)) }
-      end
+    def >>(other)
+      raise TypeError, "callable object is expected" unless other.respond_to?(:call)
+      this = self
+      proc { |*args, &block| other.(this.(*args, &block)) }
     end
-  end
+  RUBY
 end
 # rubocop:enable Style/LambdaCall

data/lib/ruby-next/core/string/split.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch String, method: :split, version: "2.6", supported: ("a b".split(" ", &proc {}) == "a b"), core_ext: :prepend do
+  <<~RUBY
+    def split(*args, &block)
+      return super unless block_given?
+      super.each { |el| yield el }
+      self
+    end
+  RUBY
+end

data/lib/ruby-next/core/struct/deconstruct.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Struct, method: :deconstruct, version: "2.7" do
+  <<~'RUBY'
+    alias deconstruct to_a
+  RUBY
+end

data/lib/ruby-next/core/struct/deconstruct_keys.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Source: https://github.com/ruby/ruby/blob/b76a21aa45fff75909a66f8b20fc5856705f7862/struct.c#L953-L980
+RubyNext::Core.patch Struct, method: :deconstruct_keys, version: "2.7" do
+  <<~'RUBY'
+    def deconstruct_keys(keys)
+      raise TypeError, "wrong argument type #{keys.class} (expected Array or nil)" if keys && !keys.is_a?(Array)
+
+      return to_h unless keys
+
+      return {} if size < keys.size
+
+      keys.each_with_object({}) do |k, acc|
+        # if k is Symbol and not a member of a Struct return {}
+        next if (Symbol === k || String === k) && !members.include?(k.to_sym)
+        # if k is Integer check that index is not ouf of bounds
+        next if Integer === k && k > size - 1
+        acc[k] = self[k]
+      end
+    end
+  RUBY
+end
+
+# We need to hack `respond_to?` in Ruby 2.5, since it's not working with refinements
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
+  RubyNext::Core.patch refineable: Struct, name: "StructRespondToDeconstruct", method: :deconstruct_keys, version: "2.7" do
+    <<~RUBY
+      def respond_to?(mid, *)
+        return true if mid == :deconstruct_keys || mid == :deconstruct
+        super
+      end
+    RUBY
+  end
+end

data/lib/ruby-next/core/time/ceil.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Time, method: :ceil, version: "2.7" do
+  <<~'RUBY'
+    def ceil(den = 0)
+      change = subsec.ceil(den) - subsec
+      self + change
+    end
+  RUBY
+end

data/lib/ruby-next/core/time/floor.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Time, method: :floor, version: "2.7" do
+  <<~'RUBY'
+    def floor(den = 0)
+      self - (subsec % (10**-den))
+    end
+  RUBY
+end

data/lib/ruby-next/core/unboundmethod/bind_call.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch UnboundMethod, method: :bind_call, version: "2.7" do
+  <<~'RUBY'
+    def bind_call(receiver, *args, &block)
+      bind(receiver).call(*args, &block)
+    end
+  RUBY
+end

data/lib/ruby-next/core_ext.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+# Monkey-patch core classes using the same patches as for refinements
+RubyNext::Core.patches.extensions.each do |mod, patches|
+  patches.each do |patch|
+    next if patch.supported?
+
+    if patch.prepend?
+      mod.prepend(patch.to_module)
+    else
+      mod.module_eval(patch.body, *patch.location)
+    end
+  end
+end
+
+RubyNext::Core.strategy = :core_ext

data/lib/ruby-next/language.rb

@@ -6,7 +6,6 @@ gem "unparser", ">= 0.4.7"
 require "set"
 
 require "ruby-next"
-using RubyNext
 
 module RubyNext
   # Language module contains tools to transpile newer Ruby syntax
@@ -19,6 +18,8 @@ module RubyNext
   #   - Each processor may modify the AST
   #   - Generates a transpiled source code from the transformed AST (via the `unparser` gem)
   module Language
+    using RubyNext
+
     require "ruby-next/language/parser"
     require "ruby-next/language/unparser"
 
@@ -62,7 +63,7 @@ module RubyNext
       attr_accessor :rewriters
       attr_reader :watch_dirs
 
-      def transform(source, rewriters: self.rewriters, using: true, context: TransformContext.new)
+      def transform(source, rewriters: self.rewriters, using: RubyNext::Core.refine?, context: TransformContext.new)
         parse(source).then do |ast|
           rewriters.inject(ast) do |tree, rewriter|
             rewriter.new(context).process(tree)
@@ -71,6 +72,7 @@ module RubyNext
 
             Unparser.unparse(new_ast)
           end.then do |source|
+            next source unless RubyNext::Core.refine?
             next source unless using && context.use_ruby_next?
 
             Core.inject! source.dup

data/lib/ruby-next/language/parser.rb

@@ -10,7 +10,11 @@ module RubyNext
 
     class << self
       def parser
-        ::Parser::Ruby27.new(Builder.new)
+        ::Parser::Ruby27.new(Builder.new).tap do |prs|
+          prs.diagnostics.tap do |diagnostics|
+            diagnostics.all_errors_are_fatal = true
+          end
+        end
       end
 
       def parse(source, file = "(string)")

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

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-using RubyNext
-
 module RubyNext
   module Language
     module Rewriters
+      using RubyNext
+
       CUSTOM_PARSER_REQUIRED = <<~MSG
         The %s feature is not a part of the latest stable Ruby release
         and is not supported by your Parser gem version.

data/lib/ruby-next/language/rewriters/method_reference.rb

@@ -22,7 +22,9 @@ module RubyNext
           )
         end
 
-        unless transform(SYNTAX_PROBE) == "Language.method(:transform)"
+        begin
+          transform(SYNTAX_PROBE)
+        rescue ::Parser::SyntaxError
           warn_custom_parser_required_for("method reference")
         end
       end

data/lib/ruby-next/language/rewriters/numbered_params.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-using RubyNext
-
 module RubyNext
   module Language
     module Rewriters
       class NumberedParams < Base
+        using RubyNext
+
         SYNTAX_PROBE = "proc { _1 }.call(1)"
         MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
 

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

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-using RubyNext
-
 module RubyNext
   module Language
     module Rewriters
+      using RubyNext
+
       using(Module.new do
         refine ::Parser::AST::Node do
           def to_ast_node
@@ -66,8 +66,6 @@ module RubyNext
         def on_in_match(node)
           context.track! self
 
-          @deconstructed = []
-
           matchee =
             s(:lvasgn, MATCHEE, node.children[0])
 
@@ -146,10 +144,10 @@ module RubyNext
           s(:or, *children)
         end
 
-        def match_as_clause(node)
+        def match_as_clause(node, right = s(:lvar, locals[:matchee]))
           s(:and,
             case_eq_clause(node.children[0]),
-            match_var_clause(node.children[1], s(:lvar, locals[:matchee])))
+            match_var_clause(node.children[1], right))
         end
 
         def match_var_clause(node, left = s(:lvar, locals[:matchee]))
@@ -195,6 +193,10 @@ module RubyNext
             s(:and,
               dnode,
               right)
+          end.then do |right|
+            s(:and,
+              respond_to_check(matchee, :deconstruct),
+              right)
           end
         end
 
@@ -202,20 +204,21 @@ module RubyNext
 
         def deconstruct_node(matchee)
           # only deconstruct once per case
-          return if deconstructed.include?(locals[:arr])
+          return if deconstructed&.include?(locals[:arr])
 
           context.use_ruby_next!
 
           right = s(:send, matchee, :deconstruct)
 
-          deconstructed << locals[:arr]
+          deconstructed << locals[:arr] if deconstructed
+
           s(:and,
             s(:or,
               s(:lvasgn, locals[:arr], right),
               s(:true)), # rubocop:disable Lint/BooleanSymbol
             s(:or,
               case_eq_clause(s(:const, nil, :Array), s(:lvar, locals[:arr])),
-              raise_error(:TypeError)))
+              raise_error(:TypeError, "#deconstruct must return Array")))
         end
 
         def array_element(index, head, *tail)
@@ -282,6 +285,10 @@ module RubyNext
           match_var_clause(node, arr_item_at(index))
         end
 
+        def match_as_array_element(node, index)
+          match_as_clause(node, arr_item_at(index))
+        end
+
         def pin_array_element(node, index)
           case_eq_array_element node.children[0], index
         end
@@ -321,11 +328,15 @@ module RubyNext
                 hash_element(*node.children)
               end
 
-            return dnode if right.nil?
+            next dnode if right.nil?
 
             s(:and,
               dnode,
               right)
+          end.then do |right|
+            s(:and,
+              respond_to_check(matchee, :deconstruct_keys),
+              right)
           end
         end
 
@@ -359,11 +370,12 @@ module RubyNext
             end
 
           # Create a copy of the original hash if already deconstructed
-          return hash_dup if deconstructed.include?(locals[:hash])
+          # FIXME: need better algorithm to handle different key sets
+          # return hash_dup if deconstructed&.include?(locals[:hash])
 
           context.use_ruby_next!
 
-          deconstructed << locals[:hash]
+          deconstructed << locals[:hash] if deconstructed
 
           right = s(:send,
             matchee, :deconstruct_keys, keys)
@@ -375,7 +387,7 @@ module RubyNext
             s(:and,
               s(:or,
                 case_eq_clause(s(:const, nil, :Hash), s(:lvar, locals[:hash, :src])),
-                raise_error(:TypeError)),
+                raise_error(:TypeError, "#deconstruct_keys must return Hash")),
               hash_dup))
         end
 
@@ -491,14 +503,21 @@ module RubyNext
         end
 
         def no_matching_pattern
-          raise_error :NoMatchingPatternError
+          raise_error(
+            :NoMatchingPatternError,
+            s(:send,
+              s(:lvar, locals[:matchee]), :inspect)
+          )
         end
 
-        def raise_error(type)
+        def raise_error(type, msg = "")
           s(:send, s(:const, nil, :Kernel), :raise,
             s(:const, nil, type),
-            s(:send,
-              s(:lvar, locals[:matchee]), :inspect))
+            msg.to_ast_node)
+        end
+
+        def respond_to_check(node, mid)
+          s(:send, node, :respond_to?, mid.to_ast_node)
         end
 
         def respond_to_missing?(mid, *)