ruby-next-core 0.11.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5408955fbe7d23afdc9d534e433c4c094b0a3ea46a47606a6caab7b6a4c446eb
-  data.tar.gz: 8b1edd6c3dbdc0322a4f3efa3eff5b4f278b2fd78bf8c9e995f1587b62278b0f
+  metadata.gz: c248b303a7e6990efd5d93e042c4043a61a553fddf880f44d9a2f7f40e66eabb
+  data.tar.gz: 23aa24ec51098f2a73196c2ddb3c4ae1fdeece1b5232cb5832012466080f29e9
 SHA512:
-  metadata.gz: 9f3483fb111153c9d9d14e4169302f4613a3428655b71ca83e77a5f7a6d906fc151712facec5f1c95742d77920db16bfa533fb5c34e01b8f3451f720a6fa442b
-  data.tar.gz: '09febbb7523724d5b23ba11814387dffe043d7574496923ed1731ba6664d2c9af2a02cba6568846ce6be96bdcb8e4a4eb341029c7d3099d0e02b64e9056d4744'
+  metadata.gz: 1b97768e53ff0e8841fbb7d045358728dcb2208ba79cdb0636b495de3112810b3d8f8deb1cbbe34a5fe52ef79c09044d4871db05caed04b211dfbbca8e6c4238
+  data.tar.gz: 700ad59a1f0e094bf162dc2d2e30af843b4f95b9bfc3d104c58ea2f7d8a46c57537792c507dd0189e2c93850c0cccc4b0e8bb57e10eef22041ee0dac5b4b537c

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## master
 
+## 0.12.0 (2021-01-12)
+
+- Added required keyword arguments rewriter. ([@palkan][])
+
+Required kwargs were introduced in 2.1. Now we make them possible in 2.0.
+
+- Added numeric literals rewriter. ([@palkan][])
+
+Now it's possible to generate Ruby 2.0 compatible code from `2i + 1/3r`.
+
+- Fixed several safe navigation (`&.`) bugs. ([@palkan][])
+
+See [#68](https://github.com/ruby-next/ruby-next/issues/68) and [#69](https://github.com/ruby-next/ruby-next/issues/69).
+
 ## 0.11.1 (2020-12-28)
 
 - Use separate _namespace_ for proposed features to avoid conflicts with new Ruby version. ([@palkan][])

data/README.md

@@ -445,6 +445,8 @@ AllCops:
 
 We currently provide support for Ruby 2.2, 2.3 and 2.4.
 
+**NOTE:** By "support" here we mean using `ruby-next` CLI and runtime transpiling. Transpiled code may run on Ruby 2.0+.
+
 Ruby Next itself relies on 2.5 features and contains polyfills only for version 2.5+ (and that won't change).
 Thus, to make it work with <2.5 we need to backport some APIs ourselves.
 

data/lib/.rbnext/2.1/ruby-next/core.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "set"
+
+require "ruby-next/config"
+require "ruby-next/utils"
+
+module RubyNext
+  module Core
+    # Patch contains the extension implementation
+    # and meta information (e.g., Ruby version).
+    class Patch
+      attr_reader :refineables, :name, :mod, :method_name, :version, :body, :singleton, :core_ext, :supported, :native, :location
+
+      # Create a new patch for module/class (mod)
+      # with the specified uniq name
+      #
+      # `core_ext` defines the strategy for core extensions:
+      #    - :patch — extend class directly
+      #    - :prepend — extend class by prepending a module (e.g., when needs `super`)
+      def initialize(mod = nil, method: ::Kernel.raise(::ArgumentError, "missing keyword: method"), version: ::Kernel.raise(::ArgumentError, "missing keyword: version"), name: nil, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
+        @mod = mod
+        @method_name = method
+        @version = version
+        if method_name && mod
+          @supported = supported.nil? ? mod.method_defined?(method_name) : supported
+          # define whether running Ruby has a native implementation for this method
+          # for that, we check the source_location (which is nil for C defined methods)
+          @native = native.nil? ? (supported? && native_location?(mod.instance_method(method_name).source_location)) : native
+        end
+        @singleton = singleton
+        @refineables = Array(refineable)
+        @body = yield
+        @core_ext = core_ext
+        @location = location || build_location(caller_locations(1, 5))
+        @name = name || build_module_name
+      end
+
+      def prepend?
+        core_ext == :prepend
+      end
+
+      def core_ext?
+        !mod.nil?
+      end
+
+      alias supported? supported
+      alias native? native
+      alias singleton? singleton
+
+      def to_module
+        Module.new.tap do |ext|
+          ext.module_eval(body, *location)
+
+          RubyNext::Core.const_set(name, ext)
+        end
+      end
+
+      private
+
+      def build_module_name
+        mod_name = singleton? ? singleton.name : mod.name
+        camelized_method_name = method_name.to_s.split("_").map(&:capitalize).join
+
+        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "")
+      end
+
+      def build_location(trace_locations)
+        # The caller_locations behaviour depends on implementaion,
+        # e.g. in JRuby https://github.com/jruby/jruby/issues/6055
+        while trace_locations.first.label != "patch"
+          trace_locations.shift
+        end
+
+        trace_location = trace_locations[1]
+
+        [trace_location.absolute_path, trace_location.lineno + 2]
+      end
+
+      def native_location?(location)
+        location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core)/)
+      end
+    end
+
+    # Registry for patches
+    class Patches
+      attr_reader :extensions, :refined
+
+      def initialize
+        @names = Set.new
+        @extensions = Hash.new { |h, k| h[k] = [] }
+        @refined = Hash.new { |h, k| h[k] = [] }
+      end
+
+      # Register new patch
+      def <<(patch)
+        raise ArgumentError, "Patch already registered: #{patch.name}" if @names.include?(patch.name)
+        @names << patch.name
+        @extensions[patch.mod] << patch if patch.core_ext?
+        patch.refineables.each { |r| @refined[r] << patch } unless patch.native?
+      end
+    end
+
+    class << self
+      STRATEGIES = %i[refine core_ext backports].freeze
+
+      attr_reader :strategy
+
+      def strategy=(val)
+        raise ArgumentError, "Unknown strategy: #{val}. Available: #{STRATEGIES.join(",")}" unless STRATEGIES.include?(val)
+        @strategy = val
+      end
+
+      def refine?
+        strategy == :refine
+      end
+
+      def core_ext?
+        strategy == :core_ext || strategy == :backports
+      end
+
+      def backports?
+        strategy == :backports
+      end
+
+      def patch(*__rest__, &__block__)
+        patches << Patch.new(*__rest__, &__block__)
+      end
+
+      # Inject `using RubyNext` at the top of the source code
+      def inject!(contents)
+        if contents.frozen?
+          contents = contents.sub(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        else
+          contents.sub!(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        end
+        contents
+      end
+
+      def patches
+        @patches ||= Patches.new
+      end
+    end
+
+    # Use refinements by default
+    self.strategy = ENV.fetch("RUBY_NEXT_CORE_STRATEGY", "refine").to_sym
+  end
+end
+
+require "backports/2.5" if RubyNext::Core.backports?
+
+require "ruby-next/core/kernel/then"
+
+require "ruby-next/core/proc/compose"
+
+require "ruby-next/core/enumerable/tally"
+require "ruby-next/core/enumerable/filter"
+require "ruby-next/core/enumerable/filter_map"
+
+require "ruby-next/core/enumerator/produce"
+
+require "ruby-next/core/array/difference_union_intersection"
+
+require "ruby-next/core/hash/merge"
+
+require "ruby-next/core/string/split"
+
+require "ruby-next/core/symbol/start_with"
+require "ruby-next/core/symbol/end_with"
+
+require "ruby-next/core/unboundmethod/bind_call"
+
+require "ruby-next/core/time/floor"
+require "ruby-next/core/time/ceil"
+
+# Core extensions required for pattern matching
+# Required for pattern matching with refinements
+unless defined?(NoMatchingPatternError)
+  class NoMatchingPatternError < StandardError
+  end
+end
+
+require "ruby-next/core/constants/no_matching_pattern_error"
+require "ruby-next/core/array/deconstruct"
+require "ruby-next/core/hash/deconstruct_keys"
+require "ruby-next/core/struct/deconstruct"
+require "ruby-next/core/struct/deconstruct_keys"
+
+require "ruby-next/core/hash/except"
+
+# Generate refinements
+RubyNext.module_eval do
+  RubyNext::Core.patches.refined.each do |mod, patches|
+    # Only refine modules when supported
+    next unless mod.is_a?(Class) || RubyNext::Utils.refine_modules?
+
+    refine mod do
+      patches.each do |patch|
+        module_eval(patch.body, *patch.location)
+      end
+    end
+  end
+end

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 ((((__safe_lvar__ = lib_path) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.then(&File.method(:exist?)))
           $stdout.puts "Path not found: #{lib_path}"
           $stdout.puts optparser.help
           exit 2

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: ((((__safe_lvar__ = bind) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.receiver) == TOPLEVEL_BINDING.receiver || ((((__safe_lvar__ = ((((__safe_lvar__ = bind) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.receiver)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.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

@@ -112,19 +112,19 @@ module RubyNext
         end
 
         def replace(range, ast)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.replace(range, unparse(ast)))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.replace(range, unparse(ast)))
         end
 
         def remove(range)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.remove(range))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.remove(range))
         end
 
         def insert_after(range, ast)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.insert_after(range, unparse(ast)))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.insert_after(range, unparse(ast)))
         end
 
         def insert_before(range, ast)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.insert_before(range, unparse(ast)))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.insert_before(range, unparse(ast)))
         end
 
         def unparse(ast)

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))
+          ((((__safe_lvar__ = ((((__safe_lvar__ = current_index) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.children)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.include?(node))
         end
       end
     end

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

@@ -313,7 +313,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 ((((__safe_lvar__ = clause) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.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
@@ -344,7 +344,7 @@ module RubyNext
           clauses = []
 
           nodes.each do |clause|
-            if ((!clause.nil? || nil) && clause.type) == :in_pattern
+            if ((((__safe_lvar__ = clause) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.type) == :in_pattern
               clauses << build_when_clause(clause)
             else
               else_clause = process(clause)

data/lib/.rbnext/2.3/ruby-next/utils.rb

@@ -6,7 +6,7 @@ module RubyNext
 
     if $LOAD_PATH.respond_to?(:resolve_feature_path)
       def resolve_feature_path(feature)
-        ((!$LOAD_PATH.resolve_feature_path(feature).nil? || nil) && $LOAD_PATH.resolve_feature_path(feature).last)
+        ((((__safe_lvar__ = $LOAD_PATH.resolve_feature_path(feature)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.last)
       rescue LoadError
       end
     else

data/lib/ruby-next/core_ext.rb

@@ -10,7 +10,7 @@ RubyNext::Core.patches.extensions.each do |mod, patches|
     next if patch.supported?
 
     if patch.prepend?
-      mod.prepend(patch.to_module)
+      mod.send(:prepend, patch.to_module)
     else
       mod.module_eval(patch.body, *patch.location)
     end

data/lib/ruby-next/language.rb

@@ -179,6 +179,12 @@ module RubyNext
     require "ruby-next/language/rewriters/safe_navigation"
     rewriters << Rewriters::SafeNavigation
 
+    require "ruby-next/language/rewriters/numeric_literals"
+    rewriters << Rewriters::NumericLiterals
+
+    require "ruby-next/language/rewriters/required_kwargs"
+    rewriters << Rewriters::RequiredKwargs
+
     require "ruby-next/language/rewriters/args_forward"
     rewriters << Rewriters::ArgsForward
 

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class NumericLiterals < Base
+        using RubyNext
+
+        NAME = "numeric-literals"
+        SYNTAX_PROBE = "2i + 1/2r"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.1.0")
+
+        def on_rational(node)
+          context.track! self
+
+          val = node.children.first
+
+          parts = [s(:int, val.numerator)]
+
+          parts << s(:int, val.denominator) unless val.denominator == 1
+
+          s(:send, nil, :Rational, *parts).tap do |new_node|
+            replace(node.loc.expression, new_node)
+          end
+        end
+
+        def on_complex(node)
+          context.track! self
+
+          val = node.children.first
+
+          s(:send, nil, :Complex,
+            s(:int, val.real),
+            s(:int, val.imaginary)).tap do |new_node|
+            replace(node.loc.expression, new_node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class RequiredKwargs < Base
+        using RubyNext
+
+        NAME = "required-kwargs"
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo(x:, y: 1); end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.1.0")
+
+        def on_kwarg(node)
+          context.track! self
+
+          name = node.children[0]
+
+          new_node = node.updated(
+            :kwoptarg,
+            [name, raise_missing_keyword(name)]
+          )
+
+          replace(node.loc.expression, "#{name}: ::Kernel.raise(::ArgumentError, \"missing keyword: #{name}\")")
+
+          new_node
+        end
+
+        private
+
+        def raise_missing_keyword(name)
+          s(:send,
+            s(:const, s(:cbase), :Kernel), :raise,
+            s(:const, s(:cbase), :ArgumentError),
+            s(:str, "missing keyword: #{name}"))
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,8 @@ module RubyNext
         SYNTAX_PROBE = "nil&.x&.nil?"
         MIN_SUPPORTED_VERSION = Gem::Version.new("2.3.0")
 
+        SAFE_LVAR = :__safe_lvar__
+
         def on_csend(node)
           node = super(node)
 
@@ -20,7 +22,7 @@ module RubyNext
               :and,
               [
                 process(safe_navigation(receiver)),
-                s(:send, decsendize(receiver), *args)
+                s(:send, safe_lvar, *args)
               ]
             ))
 
@@ -34,18 +36,15 @@ module RubyNext
 
           context.track!(self)
 
-          new_node = s(:begin,
-            super(node.updated(
-              :and,
-              [
-                process(safe_navigation(node.children[0].children[0])),
-                process(node.updated(nil, node.children.map(&method(:decsendize))))
-              ]
-            )))
+          super(decsendize(node))
+        end
 
-          replace(node.loc.expression, new_node)
+        def on_numblock(node)
+          return super(node) unless node.children[0].type == :csend
 
-          new_node
+          context.track!(self)
+
+          super(decsendize(node))
         end
 
         def on_op_asgn(node)
@@ -53,37 +52,51 @@ module RubyNext
 
           context.track!(self)
 
+          super(decsendize(node))
+        end
+
+        private
+
+        def decsendize(node)
+          csend, *children = node.children
+
+          receiver, *other = csend.children
+
+          new_csend = csend.updated(:send, [safe_lvar, *other])
+
           new_node = s(:begin,
-            super(node.updated(
+            node.updated(
               :and,
               [
-                process(safe_navigation(node.children[0].children[0])),
-                process(node.updated(nil, node.children.map(&method(:decsendize))))
+                process(safe_navigation(receiver)),
+                process(node.updated(nil, [new_csend, *children]))
               ]
-            )))
+            ))
 
           replace(node.loc.expression, new_node)
 
           new_node
         end
 
-        private
-
-        def decsendize(node)
-          return node unless node.is_a?(::Parser::AST::Node) && node.type == :csend
-
-          node.updated(:send, node.children.map(&method(:decsendize)))
-        end
-
-        # Transform: x&.y -> (!x.nil? && x.y) || nil
+        # Transform: x&.y -> ((_tmp_ = x) || true) && (!_tmp_.nil? || nil) && _tmp_.y
         # This allows us to handle `false&.to_s == "false"`
         def safe_navigation(node)
           s(:begin,
-            s(:or,
-              s(:send,
-                s(:send, node, :nil?),
-                :!),
-              s(:nil)))
+            s(:and,
+              s(:begin,
+                s(:or,
+                  s(:begin, s(:lvasgn, SAFE_LVAR, node)),
+                  s(:true))),
+              s(:begin,
+                s(:or,
+                  s(:send,
+                    s(:send, safe_lvar, :nil?),
+                    :!),
+                  s(:nil)))))
+        end
+
+        def safe_lvar
+          s(:lvar, SAFE_LVAR)
         end
       end
     end

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

@@ -30,7 +30,7 @@ module RubyNext
 
       def setup_gem_load_path(lib_dir = "lib", rbnext_dir: RUBY_NEXT_DIR, transpile: false)
         called_from = caller_locations(1, 1).first.path
-        dirname = File.dirname(called_from)
+        dirname = File.realpath(File.dirname(called_from))
 
         loop do
           basename = File.basename(dirname)

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

@@ -6,3 +6,8 @@ require "parser/current"
 $VERBOSE = save_verbose
 
 require "unparser"
+
+# For backward compatibility with older Unparser
+if RubyNext::Language::Builder.respond_to?(:emit_kwargs=) && !defined?(Unparser::Emitter::Kwargs)
+  RubyNext::Language::Builder.emit_kwargs = false
+end

data/lib/ruby-next/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyNext
-  VERSION = "0.11.1"
+  VERSION = "0.12.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-next-core
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.12.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-28 00:00:00.000000000 Z
+date: 2021-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-next-parser
@@ -62,6 +62,7 @@ files:
 - bin/reparse
 - bin/ruby-next
 - bin/transform
+- lib/.rbnext/2.1/ruby-next/core.rb
 - lib/.rbnext/2.3/ruby-next/commands/core_ext.rb
 - lib/.rbnext/2.3/ruby-next/commands/nextify.rb
 - lib/.rbnext/2.3/ruby-next/language/eval.rb
@@ -114,7 +115,9 @@ files:
 - lib/ruby-next/language/rewriters/in_pattern.rb
 - lib/ruby-next/language/rewriters/method_reference.rb
 - lib/ruby-next/language/rewriters/numbered_params.rb
+- lib/ruby-next/language/rewriters/numeric_literals.rb
 - lib/ruby-next/language/rewriters/pattern_matching.rb
+- lib/ruby-next/language/rewriters/required_kwargs.rb
 - lib/ruby-next/language/rewriters/runtime.rb
 - lib/ruby-next/language/rewriters/runtime/dir.rb
 - lib/ruby-next/language/rewriters/safe_navigation.rb