ruby-next 0.0.1.26 → 0.1.0

data/lib/ruby-next/core/enumerable/tally.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+unless [].respond_to?(:tally)
+  module RubyNext
+    module Core
+      module EnumerableTally
+        def tally
+          each_with_object({}) do |v, acc|
+            acc[v] ||= 0
+            acc[v] += 1
+          end
+        end
+      end
+    end
+  end
+
+  RubyNext.module_eval do
+    refine Enumerable do
+      include RubyNext::Core::EnumerableTally
+    end
+
+    # Refine Array seprately, 'cause refining modules is vulnerable to prepend:
+    # - https://bugs.ruby-lang.org/issues/13446
+    refine Array do
+      include RubyNext::Core::EnumerableTally
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# 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
+
+        merge(others.shift).tap do |new_h|
+          others.each { |h| new_h.merge!(h) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# 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
+end

data/lib/ruby-next/core/pattern_matching.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+unless defined?(NoMatchingPatternError)
+  class NoMatchingPatternError < RuntimeError
+  end
+end
+
+# Add `#deconstruct` and `#deconstruct_keys` to core classes
+unless [].respond_to?(:deconstruct)
+  RubyNext.module_eval do
+    refine Array do
+      def deconstruct
+        self
+      end
+    end
+
+    refine Struct do
+      alias deconstruct to_a
+    end
+  end
+end
+
+unless {}.respond_to?(:deconstruct_keys)
+  RubyNext.module_eval do
+    refine Hash do
+      def deconstruct_keys(_)
+        self
+      end
+    end
+
+    refine Struct do
+      def deconstruct_keys(_)
+        to_h
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# 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
+
+      def >>(other)
+        raise TypeError, "callable object is expected" unless other.respond_to?(:call)
+        this = self
+        proc { |*args, &block| other.(this.(*args, &block)) }
+      end
+    end
+  end
+end
+# rubocop:enable Style/LambdaCall

data/lib/ruby-next/core/runtime.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Extend `Language.transform` to inject `using RubyNext` to every file
+RubyNext::Language.singleton_class.prepend(Module.new do
+  def transform(contents, **hargs)
+    # We cannot activate refinements in eval
+    RubyNext::Core.inject!(contents) unless hargs[:eval]
+    super(contents, **hargs)
+  end
+end)

data/lib/ruby-next/core.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Core
+    class << self
+      # Inject `using RubyNext` at the top of the source code
+      def inject!(contents)
+        contents.sub!(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        contents
+      end
+    end
+  end
+end
+
+require_relative "core/kernel/then"
+
+require_relative "core/proc/compose"
+
+require_relative "core/enumerable/tally"
+require_relative "core/enumerable/filter"
+require_relative "core/enumerable/filter_map"
+
+require_relative "core/array/difference_union_intersection"
+
+require_relative "core/hash/merge"
+
+# Core extensions required for pattern matching
+require_relative "core/pattern_matching"

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "ruby-next/utils"
+
+require "parser/ruby27"
+RubyNext::Language::Parser = Parser::Ruby27
+
+# See https://github.com/whitequark/parser/#usage
+Parser::Builders::Default.emit_lambda = true
+Parser::Builders::Default.emit_procarg0 = true
+Parser::Builders::Default.emit_encoding = true
+Parser::Builders::Default.emit_index = true
+
+Parser::Builders::Default.prepend(Module.new do
+  def match_hash_var_from_str(begin_t, strings, end_t)
+    super.tap do
+      string = strings[0]
+      next unless string.type == :str
+      name, = *string
+      @parser.static_env.declare(name)
+    end
+  end
+end)

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class ArgsForward < Base
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo(...) super(...); end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
+
+        REST = :__rest__
+        BLOCK = :__block__
+
+        def on_forward_args(node)
+          context.track! self
+
+          node.updated(
+            :args,
+            [
+              s(:restarg, REST),
+              s(:blockarg, BLOCK)
+            ]
+          )
+        end
+
+        def on_send(node)
+          return unless node.children[2]&.type == :forwarded_args
+
+          node.updated(
+            nil,
+            [
+              *node.children[0..1],
+              *forwarded_args
+            ]
+          )
+        end
+
+        def on_super(node)
+          return unless node.children[0]&.type == :forwarded_args
+
+          node.updated(
+            nil,
+            forwarded_args
+          )
+        end
+
+        private
+
+        def forwarded_args
+          [
+            s(:splat, s(:lvar, REST)),
+            s(:block_pass, s(:lvar, BLOCK))
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+using RubyNext
+
+module RubyNext
+  module Language
+    module Rewriters
+      class Base < ::Parser::TreeRewriter
+        class LocalsTracker
+          attr_reader :stacks
+
+          def initialize
+            @stacks = []
+          end
+
+          def with(**locals)
+            stacks << locals
+            yield.tap { stacks.pop }
+          end
+
+          def [](name, suffix = nil)
+            fetch(name).then do |name|
+              next name unless suffix
+              :"#{name}#{suffix}__"
+            end
+          end
+
+          def key?(name)
+            !!fetch(name) { false }
+          end
+
+          def fetch(name)
+            ind = -1
+
+            loop do
+              break stacks[ind][name] if stacks[ind].key?(name)
+              ind -= 1
+              break if stacks[ind].nil?
+            end.then do |name|
+              next name unless name.nil?
+
+              return yield if block_given?
+              raise ArgumentError, "Local var not found in scope: #{name}"
+            end
+          end
+        end
+
+        class << self
+          # Returns true if the syntax is supported
+          # by the current Ruby (performs syntax check, not version check)
+          def unsupported_syntax?
+            save_verbose, $VERBOSE = $VERBOSE, nil
+            eval_mid = Kernel.respond_to?(:eval_without_ruby_next) ? :eval_without_ruby_next : :eval
+            Kernel.send eval_mid, self::SYNTAX_PROBE
+            false
+          rescue SyntaxError, NameError
+            true
+          ensure
+            $VERBOSE = save_verbose
+          end
+
+          # Returns true if the syntax is supported
+          # by the specified version
+          def unsupported_version?(version)
+            self::MIN_SUPPORTED_VERSION > version
+          end
+        end
+
+        attr_reader :locals
+
+        def initialize(context)
+          @context = context
+          @locals = LocalsTracker.new
+          super()
+        end
+
+        def s(type, *children)
+          ::Parser::AST::Node.new(type, children)
+        end
+
+        private
+
+        attr_reader :context
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class EndlessRange < Base
+        SYNTAX_PROBE = "[0, 1][1..]"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.6.0")
+
+        def on_index(node)
+          @current_index = node
+          new_index = process(node.children.last)
+          return unless new_index != node.children.last
+
+          node.updated(
+            nil,
+            [
+              node.children.first,
+              new_index
+            ]
+          )
+        end
+
+        def on_erange(node)
+          return unless node.children.last.nil?
+
+          context.track! self
+
+          new_end =
+            if index_arg?(node)
+              s(:int, -1)
+            else
+              s(:const,
+                s(:const,
+                  s(:cbase), :Float),
+                :INFINITY)
+            end
+
+          node.updated(
+            :irange,
+            [
+              node.children.first,
+              new_end
+            ]
+          )
+        end
+
+        alias_method :on_irange, :on_erange
+
+        private
+
+        attr_reader :current_index
+
+        def index_arg?(node)
+          current_index&.children&.include?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class MethodReference < Base
+        SYNTAX_PROBE = "Language.:transform"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
+
+        def on_meth_ref(node)
+          context.track! self
+
+          receiver, mid = *node.children
+
+          node.updated(
+            :send,
+            [
+              receiver,
+              :method,
+              s(:sym, mid)
+            ]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+using RubyNext
+
+module RubyNext
+  module Language
+    module Rewriters
+      class NumberedParams < Base
+        SYNTAX_PROBE = "proc { _1 }.call(1)"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
+
+        def on_numblock(node)
+          context.track! self
+
+          proc_or_lambda, num, *rest = *node.children
+
+          node.updated(
+            :block,
+            [
+              proc_or_lambda,
+              proc_args(num),
+              *rest
+            ]
+          )
+        end
+
+        private
+
+        def proc_args(n)
+          return s(:args, s(:procarg0, :_1)) if n == 1
+
+          (1..n).map do |numero|
+            s(:arg, :"_#{numero}")
+          end.then do |args|
+            s(:args, *args)
+          end
+        end
+      end
+    end
+  end
+end