ruby-next-core 0.8.0 → 0.10.0

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

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+require "ruby-next/language"
+
+module RubyNext
+  module Commands
+    class Nextify < Base
+      using RubyNext
+
+      attr_reader :lib_path, :paths, :out_path, :min_version, :single_version, :specified_rewriters
+
+      def run
+        log "RubyNext core strategy: #{RubyNext::Core.strategy}"
+        log "RubyNext transpile mode: #{RubyNext::Language.mode}"
+
+        remove_rbnext!
+
+        @min_version ||= MIN_SUPPORTED_VERSION
+
+        paths.each do |path|
+          contents = File.read(path)
+          transpile path, contents
+        end
+      end
+
+      def parse!(args)
+        print_help = false
+        print_rewriters = false
+        rewriter_names = []
+        @single_version = false
+
+        optparser = base_parser do |opts|
+          opts.banner = "Usage: ruby-next nextify DIRECTORY_OR_FILE [options]"
+
+          opts.on("-o", "--output=OUTPUT", "Specify output directory or file or stdout") do |val|
+            @out_path = val
+          end
+
+          opts.on("--min-version=VERSION", "Specify the minimum Ruby version to support") do |val|
+            @min_version = Gem::Version.new(val)
+          end
+
+          opts.on("--single-version", "Only create one version of a file (for the earliest Ruby version)") do
+            @single_version = true
+          end
+
+          opts.on("--edge", "Enable edge (master) Ruby features") do |val|
+            require "ruby-next/language/edge"
+          end
+
+          opts.on("--proposed", "Enable proposed/experimental Ruby features") do |val|
+            require "ruby-next/language/proposed"
+          end
+
+          opts.on(
+            "--transpile-mode=MODE",
+            "Transpiler mode (ast or rewrite). Default: ast"
+          ) do |val|
+            Language.mode = val.to_sym
+          end
+
+          opts.on("--[no-]refine", "Do not inject `using RubyNext`") do |val|
+            Core.strategy = :core_ext unless val
+          end
+
+          opts.on("--list-rewriters", "List available rewriters") do |val|
+            print_rewriters = true
+          end
+
+          opts.on("--rewrite=REWRITERS...", "Specify particular Ruby features to rewrite") do |val|
+            rewriter_names << val
+          end
+
+          opts.on("-h", "--help", "Print help") do
+            print_help = true
+          end
+        end
+
+        optparser.parse!(args)
+
+        @lib_path = args[0]
+
+        if print_help
+          $stdout.puts optparser.help
+          exit 0
+        end
+
+        if print_rewriters
+          Language.rewriters.each do |rewriter|
+            $stdout.puts "#{rewriter::NAME} (\"#{rewriter::SYNTAX_PROBE}\")"
+          end
+          exit 0
+        end
+
+        unless ((!lib_path.nil?) || nil) && lib_path.then(&File.method(:exist?))
+          $stdout.puts "Path not found: #{lib_path}"
+          $stdout.puts optparser.help
+          exit 2
+        end
+
+        if rewriter_names.any? && min_version
+          $stdout.puts "--rewrite cannot be used with --min-version simultaneously"
+          exit 2
+        end
+
+        @specified_rewriters =
+          if rewriter_names.any?
+            begin
+              Language.select_rewriters(*rewriter_names)
+            rescue Language::RewriterNotFoundError => error
+              $stdout.puts error.message
+              $stdout.puts "Try --list-rewriters to see list of available rewriters"
+              exit 2
+            end
+          end
+
+        @paths =
+          if File.directory?(lib_path)
+            Dir[File.join(lib_path, "**/*.rb")]
+          elsif File.file?(lib_path)
+            [lib_path].tap do |_|
+              @lib_path = File.dirname(lib_path)
+            end
+          end
+      end
+
+      private
+
+      def transpile(path, contents, version: min_version)
+        rewriters = specified_rewriters || Language.rewriters.select { |rw| rw.unsupported_version?(version) }
+
+        context = Language::TransformContext.new
+
+        new_contents = Language.transform contents, context: context, rewriters: rewriters
+
+        return unless context.dirty?
+
+        versions = context.sorted_versions
+        version = versions.shift
+
+        # First, store already transpiled contents in the minimum required version dir
+        save new_contents, path, version
+
+        return if versions.empty? || single_version?
+
+        # Then, generate the source code for the next version
+        transpile path, contents, version: version
+      end
+
+      def save(contents, path, version)
+        return $stdout.puts(contents) if stdout?
+
+        paths = [Pathname.new(path).relative_path_from(Pathname.new(lib_path))]
+
+        paths.unshift(version.segments[0..1].join(".")) unless single_version?
+
+        next_path =
+          if next_dir_path.end_with?(".rb")
+            out_path
+          else
+            File.join(next_dir_path, *paths)
+          end
+
+        unless CLI.dry_run?
+          FileUtils.mkdir_p File.dirname(next_path)
+
+          File.write(next_path, contents)
+        end
+
+        log "Generated: #{next_path}"
+      end
+
+      def remove_rbnext!
+        return if CLI.dry_run? || stdout?
+
+        return unless File.directory?(next_dir_path)
+
+        log "Remove old files: #{next_dir_path}"
+        FileUtils.rm_r(next_dir_path)
+      end
+
+      def next_dir_path
+        @next_dir_path ||= (out_path || File.join(lib_path, RUBY_NEXT_DIR))
+      end
+
+      def stdout?
+        out_path == "stdout"
+      end
+
+      def single_version?
+        single_version || specified_rewriters
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module KernelEval
+      if Utils.refine_modules?
+        refine Kernel do
+          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)
+            )
+            RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
+            super new_source, bind, *args
+          end
+        end
+      end
+    end
+
+    module InstanceEval # :nodoc:
+      refine Object do
+        def instance_eval(*args, &block)
+          return super(*args, &block) if block_given?
+
+          source = args.shift
+          new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
+          RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
+          super new_source, *args
+        end
+      end
+    end
+
+    module ClassEval
+      refine Module do
+        def module_eval(*args, &block)
+          return super(*args, &block) if block_given?
+
+          source = args.shift
+          new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
+          RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
+          super new_source, *args
+        end
+
+        def class_eval(*args, &block)
+          return super(*args, &block) if block_given?
+
+          source = args.shift
+          new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
+          RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
+          super new_source, *args
+        end
+      end
+    end
+
+    # Refinements for `eval`-like methods.
+    # Transpiling eval is only possible if we do not use local from the binding,
+    # because we cannot access the binding of caller (without non-production ready hacks).
+    #
+    # This module is meant mainly for testing purposes.
+    module Eval
+      include InstanceEval
+      include ClassEval
+      include KernelEval
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+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.
+       Use RubyNext's parser to use it: https://github.com/ruby-next/parser
+
+      MSG
+
+      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 } # rubocop:disable Style/RedundantFetchBlock
+          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, nil, __FILE__, __LINE__
+            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
+
+          private
+
+          def transform(source)
+            Language.transform(source, rewriters: [self], using: false)
+          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
+
+        def replace(range, ast)
+          ((!@source_rewriter.nil?) || nil) && @source_rewriter.replace(range, unparse(ast))
+        end
+
+        def 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))
+        end
+
+        def insert_before(range, 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)
+        end
+
+        attr_reader :context
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class EndlessRange < Base
+        NAME = "endless-range"
+        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
+
+          replace(node.loc.expression, "#{node.children.first.loc.expression.source}..#{unparse(new_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.nil?) || nil) && current_index.children).nil?) || nil) && (((!current_index.nil?) || nil) && current_index.children).include?(node)
+        end
+      end
+    end
+  end
+end