ruby-next-core 0.9.1 → 0.10.3

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

@@ -4,40 +4,103 @@ module RubyNext
   module Language
     module Rewriters
       class RightHandAssignment < Base
+        NAME = "right-hand-assignment"
         SYNTAX_PROBE = "1 + 2 => a"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("2.8.0")
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
 
         def on_rasgn(node)
           context.track! self
 
+          node = super(node)
+
           val_node, asgn_node = *node
 
           remove(val_node.loc.expression.end.join(asgn_node.loc.expression))
           insert_before(val_node.loc.expression, "#{asgn_node.loc.expression.source} = ")
 
-          process(
-            asgn_node.updated(
-              nil,
-              asgn_node.children + [val_node]
-            )
+          asgn_node.updated(
+            nil,
+            asgn_node.children + [val_node]
           )
         end
 
+        def on_vasgn(node)
+          return super(node) unless rightward?(node)
+
+          context.track! self
+
+          name, val_node = *node
+
+          remove(val_node.loc.expression.end.join(node.loc.name))
+          insert_before(val_node.loc.expression, "#{name} = ")
+
+          super(node)
+        end
+
+        def on_casgn(node)
+          return super(node) unless rightward?(node)
+
+          context.track! self
+
+          scope_node, name, val_node = *node
+
+          if scope_node
+            scope = scope_node.type == :cbase ? scope_node.loc.expression.source : "#{scope_node.loc.expression.source}::"
+            name = "#{scope}#{name}"
+          end
+
+          remove(val_node.loc.expression.end.join(node.loc.name))
+          insert_before(val_node.loc.expression, "#{name} = ")
+
+          super(node)
+        end
+
         def on_mrasgn(node)
           context.track! self
 
+          node = super(node)
+
           lhs, rhs = *node
 
           replace(lhs.loc.expression.end.join(rhs.loc.expression), ")")
           insert_before(lhs.loc.expression, "#{rhs.loc.expression.source} = (")
 
-          process(
-            node.updated(
-              :masgn,
-              [rhs, lhs]
-            )
+          node.updated(
+            :masgn,
+            [rhs, lhs]
           )
         end
+
+        def on_masgn(node)
+          return super(node) unless rightward?(node)
+
+          context.track! self
+
+          rhs, lhs = *node
+
+          replace(lhs.loc.expression.end.join(rhs.loc.expression), ")")
+          insert_before(lhs.loc.expression, "#{rhs.loc.expression.source} = (")
+
+          super(node)
+        end
+
+        private
+
+        def rightward?(node)
+          # Location could be empty for node built by rewriters
+          return false unless node.loc&.operator
+
+          assignee_loc =
+            if node.type == :masgn
+              node.children[0].loc.expression
+            else
+              node.loc.name
+            end
+
+          return false unless assignee_loc
+
+          assignee_loc.begin_pos > node.loc.operator.end_pos
+        end
       end
     end
   end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class SafeNavigation < Base
+        NAME = "safe-navigation"
+        SYNTAX_PROBE = "nil&.x&.nil?"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.3.0")
+
+        def on_csend(node)
+          node = super(node)
+
+          context.track! self
+
+          receiver, *args = *node
+
+          new_node = node.updated(
+            :and,
+            [
+              process(safe_navigation(receiver)),
+              s(:send, decsendize(receiver), *args)
+            ]
+          )
+
+          replace(node.loc.expression, new_node)
+
+          new_node
+        end
+
+        def on_block(node)
+          return super(node) unless node.children[0].type == :csend
+
+          context.track!(self)
+
+          new_node = super(node.updated(
+            :and,
+            [
+              process(safe_navigation(node.children[0].children[0])),
+              process(node.updated(nil, node.children.map(&method(:decsendize))))
+            ]
+          ))
+
+          replace(node.loc.expression, new_node)
+
+          new_node
+        end
+
+        def on_op_asgn(node)
+          return super(node) unless node.children[0].type == :csend
+
+          context.track!(self)
+
+          new_node = super(node.updated(
+            :and,
+            [
+              process(safe_navigation(node.children[0].children[0])),
+              process(node.updated(nil, node.children.map(&method(:decsendize))))
+            ]
+          ))
+
+          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
+        # This allows us to handle `false&.to_s == "false"`
+        def safe_navigation(node)
+          s(:or,
+            s(:send,
+              s(:send, node, :nil?),
+              :!),
+            s(:nil))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class ShorthandHash < Base
+        NAME = "shorthand-hash"
+        SYNTAX_PROBE = "data = {x}"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
+
+        def on_ipair(node)
+          context.track! self
+
+          ident, = *node.children
+
+          key = key_from_ident(ident)
+
+          replace(
+            node.loc.expression,
+            "#{key}: #{key}"
+          )
+
+          node.updated(
+            :pair,
+            [
+              s(:sym, key),
+              ident
+            ]
+          )
+        end
+
+        private
+
+        def key_from_ident(node)
+          case node.type
+          when :send
+            node.children[1]
+          when :lvar
+            node.children[0]
+          else
+            raise ArgumentError, "Unsupport ipair node: #{node}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class SquigglyHeredoc < Base
+        NAME = "squiggly-heredoc"
+        SYNTAX_PROBE = "txt = <<~TXT\n  bla\n      TXT"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.3.0")
+
+        def on_str(node)
+          node = super(node) if defined?(super_method)
+          return node unless node.loc.respond_to?(:heredoc_body) && node.loc.expression.source.include?("<<~")
+
+          context.track! self
+
+          replace(node.loc.expression, node.loc.expression.source.tr("~", "-"))
+
+          heredoc_loc = node.loc.heredoc_body.join(node.loc.heredoc_end)
+          heredoc_source, heredoc_end = heredoc_loc.source.split(/\n([^\n]+)\z/)
+
+          indent = heredoc_source.lines.map { |line| line.match(/^\s*/)[0].size }.min
+
+          new_source = heredoc_source.gsub!(%r{^\s{#{indent}}}, "")
+
+          replace(heredoc_loc, [new_source, heredoc_end].join("\n"))
+
+          node
+        end
+
+        alias on_dstr on_str
+        alias on_xstr on_str
+      end
+    end
+  end
+end

data/lib/ruby-next/logging.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "utils"
+require "ruby-next/utils"
 
 module RubyNext
   class << self

data/lib/ruby-next/rubocop.rb

@@ -46,23 +46,25 @@ module RuboCop
   end
 end
 
+# Let's make this file Ruby 2.2 compatible to avoid transpiling
+# rubocop:disable Layout/HeredocIndentation
 module RuboCop
   module AST
     module Traversal
       # Fixed in https://github.com/rubocop-hq/rubocop/pull/7786
-      unless defined?(::RuboCop::AST::CaseMatchNode)
-        %i[case_match in_pattern].each do |type|
-          module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def on_#{type}(node)
-              node.children.each { |child| send(:"on_\#{child.type}", child) if child }
-              nil
-            end
-          RUBY
-        end
+      %i[case_match in_pattern find_pattern].each do |type|
+        next if method_defined?(:"on_#{type}")
+        module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+def on_#{type}(node)
+node.children.each { |child| send(:"on_\#{child.type}", child) if child }
+nil
+end
+        RUBY
       end
     end
   end
 end
+# rubocop:enable Layout/HeredocIndentation
 
 module RuboCop
   module Cop
@@ -73,6 +75,10 @@ module RuboCop
         trigger_responding_cops(:on_meth_ref, node)
       end
 
+      def on_ipair(node)
+        trigger_responding_cops(:on_ipair, node)
+      end
+
       unless method_defined?(:on_numblock)
         def on_numblock(node)
           children = node.children
@@ -111,5 +117,81 @@ module RuboCop
         end
       end
     end
+
+    module Layout
+      require "rubocop/cop/layout/assignment_indentation"
+      AssignmentIndentation.prepend(Module.new do
+        POTENTIAL_RIGHT_TYPES = %i[ivasgn lvasgn cvasgn gvasgn casgn masgn].freeze
+
+        def check_assignment(node, *)
+          return if rightward?(node)
+          super
+        end
+
+        private
+
+        def rightward?(node)
+          return unless POTENTIAL_RIGHT_TYPES.include?(node.type)
+
+          return unless node.loc.operator
+
+          assignee_loc =
+            if node.type == :masgn
+              node.children[0].loc.expression
+            else
+              node.loc.name
+            end
+
+          return false unless assignee_loc
+
+          assignee_loc.begin_pos > node.loc.operator.end_pos
+        end
+      end)
+
+      require "rubocop/cop/layout/empty_line_between_defs"
+      EmptyLineBetweenDefs.prepend(Module.new do
+        def def_end(node)
+          return super unless node.loc.end.nil?
+
+          node.loc.expression.line
+        end
+      end)
+    end
+
+    module Style
+      require "rubocop/cop/style/single_line_methods"
+      SingleLineMethods.prepend(Module.new do
+        def on_def(node)
+          return if node.loc.end.nil?
+          super
+        end
+
+        def on_defs(node)
+          return if node.loc.end.nil?
+          super
+        end
+      end)
+
+      require "rubocop/cop/style/def_with_parentheses"
+      DefWithParentheses.prepend(Module.new do
+        def on_def(node)
+          return if node.loc.end.nil?
+          super
+        end
+
+        def on_defs(node)
+          return if node.loc.end.nil?
+          super
+        end
+      end)
+
+      require "rubocop/cop/style/trailing_method_end_statement"
+      TrailingMethodEndStatement.prepend(Module.new do
+        def on_def(node)
+          return if node.loc.end.nil?
+          super
+        end
+      end)
+    end
   end
 end

data/lib/ruby-next/setup_self.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# This file setup LOAD_PATH to load Ruby Next own transpiled paths
+# (we cannot use language/setup here, 'cause it requires Core to be loaded)
+
+version = RubyNext.next_version
+next_dirname = File.join(__dir__, "..", ".rbnext")
+lib_path = File.realpath(File.join(__dir__, ".."))
+current_index = $LOAD_PATH.index(lib_path)
+
+loop do
+  break unless version
+
+  version_dir = File.join(next_dirname, version.segments[0..1].join("."))
+
+  if File.exist?(version_dir)
+    $LOAD_PATH.insert current_index, version_dir
+    current_index += 1
+  end
+
+  version = RubyNext.next_version(version)
+end

data/lib/ruby-next/version.rb

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