ruby-next-core 0.15.3 → 1.0.1

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubyNext
+  # Mininum Ruby version supported by RubyNext
+  MIN_SUPPORTED_VERSION = Gem::Version.new("2.2.0")
+
+  # Where to store transpiled files (relative from the project LOAD_PATH, usually `lib/`)
+  RUBY_NEXT_DIR = ".rbnext"
+
+  # Defines last minor version for every major version
+  LAST_MINOR_VERSIONS = {
+    2 => 8, # 2.8 is required for backward compatibility: some gems already uses it
+    3 => 4
+  }.freeze
+
+  LATEST_VERSION = [3, 4].freeze
+
+  # A virtual version number used for proposed features
+  NEXT_VERSION = "1995.next.0"
+
+  class << self
+    # TruffleRuby claims its RUBY_VERSION to be X.Y while not supporting all the features
+    # Currently (23.0.1), it still doesn't support pattern matching, although claims to be "like 3.1".
+    # So, we fallback to 2.6.5 (since we cannot use 2.7).
+    if defined?(TruffleRuby)
+      def current_ruby_version
+        "2.6.5"
+      end
+    else
+      def current_ruby_version
+        ::RUBY_VERSION
+      end
+    end
+
+    # Returns true if we want to use edge syntax
+    def edge_syntax?
+      %w[y true 1].include?(ENV["RUBY_NEXT_EDGE"])
+    end
+
+    def proposed_syntax?
+      %w[y true 1].include?(ENV["RUBY_NEXT_PROPOSED"])
+    end
+
+    def next_ruby_version(version = current_ruby_version)
+      return if version == Gem::Version.new(NEXT_VERSION)
+
+      major, minor = Gem::Version.new(version).segments.map(&:to_i)
+
+      return Gem::Version.new(NEXT_VERSION) if major >= LATEST_VERSION.first && minor >= LATEST_VERSION.last
+
+      nxt =
+        if LAST_MINOR_VERSIONS[major] == minor
+          "#{major + 1}.0.0"
+        else
+          "#{major}.#{minor + 1}.0"
+        end
+
+      Gem::Version.new(nxt)
+    end
+
+    # Load transpile settings from the RC file (nextify command flags)
+    def load_from_rc(path = ".rbnextrc")
+      return unless File.exist?(path)
+
+      require "yaml"
+
+      args = ((((__safe_lvar__ = ((((__safe_lvar__ = ((((__safe_lvar__ = YAML.load_file(path)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.fetch("nextify", ""))) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.lines)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.flat_map { |line|
+  line.chomp.split(/\s+/)
+})
+
+      ENV["RUBY_NEXT_EDGE"] ||= "true" if args.delete("--edge")
+      ENV["RUBY_NEXT_PROPOSED"] ||= "true" if args.delete("--proposed")
+      ENV["RUBY_NEXT_TRANSPILE_MODE"] ||= "rewrite" if args.delete("--transpile-mode=rewrite")
+      ENV["RUBY_NEXT_TRANSPILE_MODE"] ||= "ast" if args.delete("--transpile-mode=ast")
+    end
+  end
+
+  load_from_rc
+end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# The code below originates from https://github.com/saturnflyer/polyfill-data
+
+if !Object.const_defined?(:Data) || !Data.respond_to?(:define)
+
+  # Drop legacy Data class
+  begin
+    Object.send(:remove_const, :Data)
+  rescue
+    nil
+  end
+
+  class Data < Object
+    using RubyNext
+
+    class << self
+      undef_method :new
+      attr_reader :members
+    end
+
+    def self.define(*args, &block)
+      raise ArgumentError if args.any?(/=/)
+      if block
+        mod = Module.new
+        mod.define_singleton_method(:_) do |klass|
+          klass.class_eval(&block)
+        end
+        arity_converter = mod.method(:_)
+      end
+      klass = ::Class.new(self)
+
+      klass.instance_variable_set(:@members, args.map(&:to_sym).freeze)
+
+      klass.define_singleton_method(:new) do |*new_args, **new_kwargs, &block|
+        init_kwargs = if new_args.any?
+          raise ArgumentError, "unknown arguments #{new_args[members.size..-1].join(", ")}" if new_args.size > members.size
+          members.take(new_args.size).zip(new_args).to_h
+        else
+          new_kwargs
+        end
+
+        allocate.tap do |instance|
+          instance.send(:initialize, **init_kwargs, &block)
+        end.freeze
+      end
+
+      class << klass
+        alias_method :[], :new
+        undef_method :define
+      end
+
+      args.each do |arg|
+        if klass.method_defined?(arg)
+          raise ArgumentError, "duplicate member #{arg}"
+        end
+        klass.define_method(arg) do
+          @attributes[arg]
+        end
+      end
+
+      if arity_converter
+        klass.class_eval(&arity_converter)
+      end
+
+      klass
+    end
+
+    def self.inherited(subclass)
+      subclass.instance_variable_set(:@members, members)
+    end
+
+    def members
+      self.class.members
+    end
+
+    def initialize(**kwargs)
+      kwargs_size = kwargs.size
+      members_size = members.size
+
+      if kwargs_size > members_size
+        extras = kwargs.except(*members).keys
+
+        if extras.size > 1
+          raise ArgumentError, "unknown keywords: #{extras.map { |_1| ":#{_1}" }.join(", ")}"
+        else
+          raise ArgumentError, "unknown keyword: :#{extras.first}"
+        end
+      elsif kwargs_size < members_size
+        missing = members.select { |k| !kwargs.include?(k) }
+
+        if missing.size > 1
+          raise ArgumentError, "missing keywords: #{missing.map { |_1| ":#{_1}" }.join(", ")}"
+        else
+          raise ArgumentError, "missing keyword: :#{missing.first}"
+        end
+      end
+
+      @attributes = members.map { |m| [m, kwargs[m]] }.to_h
+    end
+
+    def deconstruct
+      @attributes.values
+    end
+
+    def deconstruct_keys(array)
+      raise TypeError unless array.is_a?(Array) || array.nil?
+      return @attributes if ((((__safe_lvar__ = array) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.first).nil?
+
+      @attributes.slice(*array)
+    end
+
+    def to_h(&block)
+      @attributes.to_h(&block)
+    end
+
+    def hash
+      to_h.hash
+    end
+
+    def eql?(other)
+      self.class == other.class && hash == other.hash
+    end
+
+    def ==(other)
+      self.class == other.class && to_h == other.to_h
+    end
+
+    def inspect
+      attribute_markers = @attributes.map do |key, value|
+        insect_key = key.to_s.start_with?("@") ? ":#{key}" : key
+        "#{insect_key}=#{value}"
+      end.join(", ")
+
+      display = ["data", self.class.name, attribute_markers].compact.join(" ")
+
+      "#<#{display}>"
+    end
+    alias_method :to_s, :inspect
+
+    def with(**kwargs)
+      return self if kwargs.empty?
+
+      self.class.new(**@attributes.merge(kwargs))
+    end
+
+    private
+
+    def marshal_dump
+      @attributes
+    end
+
+    def marshal_load(attributes)
+      @attributes = attributes
+      freeze
+    end
+
+    def initialize_copy(source)
+      super.freeze
+    end
+  end
+
+end

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

@@ -11,7 +11,7 @@ module RubyNext
               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
+            super(new_source, bind, *args)
           end
         end
       end
@@ -25,7 +25,7 @@ module RubyNext
           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
+          super(new_source, *args)
         end
       end
     end
@@ -39,7 +39,7 @@ module RubyNext
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
 
           RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
-          super new_source, *args
+          super(new_source, *args)
         end
 
         def class_eval(*args, &block)
@@ -48,7 +48,7 @@ module RubyNext
           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
+          super(new_source, *args)
         end
       end
     end

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

@@ -185,7 +185,7 @@ module RubyNext
         # rubocop:disable Style/MissingRespondToMissing
         class Noop < Base
           # Return node itself, no memoization
-          def method_missing(mid, node, *)
+          def method_missing(mid, node, *__rest__)
             node
           end
         end
@@ -1035,7 +1035,7 @@ module RubyNext
           s(:send, node, :respond_to?, mid.to_ast_node)
         end
 
-        def respond_to_missing?(mid, *)
+        def respond_to_missing?(mid, *__rest__)
           return true if mid.to_s.match?(/_(clause|array_element)/)
           super
         end

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

@@ -12,7 +12,7 @@ module RubyNext
 
       MSG
 
-      class Base < ::Parser::TreeRewriter
+      class Base < Abstract
         class LocalsTracker
           using(Module.new do
             refine ::Parser::AST::Node do
@@ -64,39 +64,15 @@ module RubyNext
           end
         end
 
-        class << self
-          # Returns true if the syntax is not 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, StandardError
-            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
+        attr_reader :locals
 
-          def transform(source)
-            Language.transform(source, rewriters: [self], using: false)
-          end
+        def self.ast?
+          true
         end
 
-        attr_reader :locals
-
-        def initialize(context)
-          @context = context
+        def initialize(*args)
           @locals = LocalsTracker.new
-          super()
+          super
         end
 
         def s(type, *children)
@@ -144,8 +120,6 @@ module RubyNext
 
           Unparser.unparse(ast).chomp
         end
-
-        attr_reader :context
       end
     end
   end

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

@@ -4,28 +4,6 @@ module RubyNext
   module Utils
     module_function
 
-    if $LOAD_PATH.respond_to?(:resolve_feature_path)
-      def resolve_feature_path(feature)
-        ((((__safe_lvar__ = $LOAD_PATH.resolve_feature_path(feature)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.last)
-      rescue LoadError
-      end
-    else
-      def resolve_feature_path(path)
-        if File.file?(relative = File.expand_path(path))
-          path = relative
-        end
-
-        path = "#{path}.rb" if File.extname(path).empty?
-
-        return path if Pathname.new(path).absolute?
-
-        $LOAD_PATH.find do |lp|
-          lpath = File.join(lp, path)
-          return File.realpath(lpath) if File.file?(lpath)
-        end
-      end
-    end
-
     def source_with_lines(source, path)
       source.lines.map.with_index do |line, i|
         "#{(i + 1).to_s.rjust(4)}:  #{line}"
@@ -36,6 +14,7 @@ module RubyNext
 
     # Returns true if modules refinement is supported in current version
     def refine_modules?
+      save_verbose, $VERBOSE = $VERBOSE, nil
       @refine_modules ||=
         begin
           # Make sure that including modules within refinements works
@@ -59,6 +38,8 @@ module RubyNext
           true
         rescue TypeError, NoMethodError
           false
+        ensure
+          $VERBOSE = save_verbose
         end
     end
   end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# The code below originates from https://github.com/saturnflyer/polyfill-data
+
+if !Object.const_defined?(:Data) || !Data.respond_to?(:define)
+
+  # Drop legacy Data class
+  begin
+    Object.send(:remove_const, :Data)
+  rescue
+    nil
+  end
+
+  class Data < Object
+    using RubyNext
+
+    class << self
+      undef_method :new
+      attr_reader :members
+    end
+
+    def self.define(*args, &block)
+      raise ArgumentError if args.any?(/=/)
+      if block
+        mod = Module.new
+        mod.define_singleton_method(:_) do |klass|
+          klass.class_eval(&block)
+        end
+        arity_converter = mod.method(:_)
+      end
+      klass = ::Class.new(self)
+
+      klass.instance_variable_set(:@members, args.map(&:to_sym).freeze)
+
+      klass.define_singleton_method(:new) do |*new_args, **new_kwargs, &block|
+        init_kwargs = if new_args.any?
+          raise ArgumentError, "unknown arguments #{new_args[members.size..-1].join(", ")}" if new_args.size > members.size
+          members.take(new_args.size).zip(new_args).to_h
+        else
+          new_kwargs
+        end
+
+        allocate.tap do |instance|
+          instance.send(:initialize, **init_kwargs, &block)
+        end.freeze
+      end
+
+      class << klass
+        alias_method :[], :new
+        undef_method :define
+      end
+
+      args.each do |arg|
+        if klass.method_defined?(arg)
+          raise ArgumentError, "duplicate member #{arg}"
+        end
+        klass.define_method(arg) do
+          @attributes[arg]
+        end
+      end
+
+      if arity_converter
+        klass.class_eval(&arity_converter)
+      end
+
+      klass
+    end
+
+    def self.inherited(subclass)
+      subclass.instance_variable_set(:@members, members)
+    end
+
+    def members
+      self.class.members
+    end
+
+    def initialize(**kwargs)
+      kwargs_size = kwargs.size
+      members_size = members.size
+
+      if kwargs_size > members_size
+        extras = kwargs.except(*members).keys
+
+        if extras.size > 1
+          raise ArgumentError, "unknown keywords: #{extras.map { |_1| ":#{_1}" }.join(", ")}"
+        else
+          raise ArgumentError, "unknown keyword: :#{extras.first}"
+        end
+      elsif kwargs_size < members_size
+        missing = members.select { |k| !kwargs.include?(k) }
+
+        if missing.size > 1
+          raise ArgumentError, "missing keywords: #{missing.map { |_1| ":#{_1}" }.join(", ")}"
+        else
+          raise ArgumentError, "missing keyword: :#{missing.first}"
+        end
+      end
+
+      @attributes = members.map { |m| [m, kwargs[m]] }.to_h
+    end
+
+    def deconstruct
+      @attributes.values
+    end
+
+    def deconstruct_keys(array)
+      raise TypeError unless array.is_a?(Array) || array.nil?
+      return @attributes if array&.first.nil?
+
+      @attributes.slice(*array)
+    end
+
+    def to_h(&block)
+      @attributes.to_h(&block)
+    end
+
+    def hash
+      to_h.hash
+    end
+
+    def eql?(other)
+      self.class == other.class && hash == other.hash
+    end
+
+    def ==(other)
+      self.class == other.class && to_h == other.to_h
+    end
+
+    def inspect
+      attribute_markers = @attributes.map do |key, value|
+        insect_key = key.to_s.start_with?("@") ? ":#{key}" : key
+        "#{insect_key}=#{value}"
+      end.join(", ")
+
+      display = ["data", self.class.name, attribute_markers].compact.join(" ")
+
+      "#<#{display}>"
+    end
+    alias_method :to_s, :inspect
+
+    def with(**kwargs)
+      return self if kwargs.empty?
+
+      self.class.new(**@attributes.merge(kwargs))
+    end
+
+    private
+
+    def marshal_dump
+      @attributes
+    end
+
+    def marshal_load(attributes)
+      @attributes = attributes
+      freeze
+    end
+
+    def initialize_copy(source)
+      super.freeze
+    end
+  end
+
+end