rbhint 0.8.5.rc1

data/lib/rubocop/cop/corrector.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class takes a source buffer and rewrite its source
+    # based on the different correction rules supplied.
+    #
+    # Important!
+    # The nodes modified by the corrections should be part of the
+    # AST of the source_buffer.
+    class Corrector
+      #
+      # @param source_buffer [Parser::Source::Buffer]
+      # @param corrections [Array(#call)]
+      #   Array of Objects that respond to #call. They will receive the
+      #   corrector itself and should use its method to modify the source.
+      #
+      # @example
+      #
+      #   class AndOrCorrector
+      #     def initialize(node)
+      #       @node = node
+      #     end
+      #
+      #     def call(corrector)
+      #       replacement = (@node.type == :and ? '&&' : '||')
+      #       corrector.replace(@node.loc.operator, replacement)
+      #     end
+      #   end
+      #
+      #   corrections = [AndOrCorrector.new(node)]
+      #   corrector = Corrector.new(source_buffer, corrections)
+      def initialize(source_buffer, corrections = [])
+        @source_buffer = source_buffer
+        raise 'source_buffer should be a Parser::Source::Buffer' unless \
+          source_buffer.is_a? Parser::Source::Buffer
+
+        @corrections = corrections
+        @source_rewriter = Parser::Source::TreeRewriter.new(
+          source_buffer,
+          different_replacements: :raise,
+          swallowed_insertions: :raise,
+          crossing_deletions: :accept
+        )
+
+        @diagnostics = []
+        # Don't print warnings to stderr if corrections conflict with each other
+        @source_rewriter.diagnostics.consumer = lambda do |diagnostic|
+          @diagnostics << diagnostic
+        end
+      end
+
+      attr_reader :corrections, :diagnostics
+
+      # Does the actual rewrite and returns string corresponding to
+      # the rewritten source.
+      #
+      # @return [String]
+      def rewrite
+        @corrections.each do |correction|
+          begin
+            @source_rewriter.transaction do
+              correction.call(self)
+            end
+          rescue ErrorWithAnalyzedFileLocation => e
+            raise e unless e.cause.is_a?(::Parser::ClobberingError)
+          end
+        end
+
+        @source_rewriter.process
+      end
+
+      # Removes the source range.
+      #
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      def remove(node_or_range)
+        range = to_range(node_or_range)
+        @source_rewriter.remove(range)
+      end
+
+      # Inserts new code before the given source range.
+      #
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      # @param [String] content
+      def insert_before(node_or_range, content)
+        range = to_range(node_or_range)
+        # TODO: Fix Cops using bad ranges instead
+        if range.end_pos > @source_buffer.source.size
+          range = range.with(end_pos: @source_buffer.source.size)
+        end
+
+        @source_rewriter.insert_before(range, content)
+      end
+
+      # Inserts new code after the given source range.
+      #
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      # @param [String] content
+      def insert_after(node_or_range, content)
+        range = to_range(node_or_range)
+        @source_rewriter.insert_after(range, content)
+      end
+
+      # Wraps the given source range with the given before and after texts
+      #
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      # @param [String] before
+      # @param [String] after
+      def wrap(node_or_range, before, after)
+        range = to_range(node_or_range)
+        @source_rewriter.wrap(range, before, after)
+      end
+
+      # Replaces the code of the source range `range` with `content`.
+      #
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      # @param [String] content
+      def replace(node_or_range, content)
+        range = to_range(node_or_range)
+        @source_rewriter.replace(range, content)
+      end
+
+      # Removes `size` characters prior to the source range.
+      #
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      # @param [Integer] size
+      def remove_preceding(node_or_range, size)
+        range = to_range(node_or_range)
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.begin_pos - size,
+                                              range.begin_pos)
+        @source_rewriter.remove(to_remove)
+      end
+
+      # Removes `size` characters from the beginning of the given range.
+      # If `size` is greater than the size of `range`, the removed region can
+      # overrun the end of `range`.
+      #
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      # @param [Integer] size
+      def remove_leading(node_or_range, size)
+        range = to_range(node_or_range)
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.begin_pos,
+                                              range.begin_pos + size)
+        @source_rewriter.remove(to_remove)
+      end
+
+      # Removes `size` characters from the end of the given range.
+      # If `size` is greater than the size of `range`, the removed region can
+      # overrun the beginning of `range`.
+      #
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      # @param [Integer] size
+      def remove_trailing(node_or_range, size)
+        range = to_range(node_or_range)
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.end_pos - size,
+                                              range.end_pos)
+        @source_rewriter.remove(to_remove)
+      end
+
+      private
+
+      # :nodoc:
+      def to_range(node_or_range)
+        range = case node_or_range
+                when ::RuboCop::AST::Node, ::Parser::Source::Comment
+                  node_or_range.loc.expression
+                when ::Parser::Source::Range
+                  node_or_range
+                else
+                  raise TypeError,
+                        'Expected a Parser::Source::Range, Comment or ' \
+                        "Rubocop::AST::Node, got #{node_or_range.class}"
+                end
+        validate_buffer(range.source_buffer)
+        range
+      end
+
+      def validate_buffer(buffer)
+        return if buffer == @source_buffer
+
+        unless buffer.is_a?(::Parser::Source::Buffer)
+          # actually this should be enforced by parser gem
+          raise 'Corrector expected range source buffer to be a ' \
+                "Parser::Source::Buffer, but got #{buffer.class}"
+        end
+        raise "Correction target buffer #{buffer.object_id} " \
+              "name:#{buffer.name.inspect}" \
+              " is not current #{@source_buffer.object_id} " \
+              "name:#{@source_buffer.name.inspect} under investigation"
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/alignment_corrector.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does auto-correction of nodes that should just be moved to
+    # the left or to the right, amount being determined by the instance
+    # variable column_delta.
+    class AlignmentCorrector
+      extend RangeHelp
+      extend Alignment
+
+      class << self
+        attr_reader :processed_source
+
+        def correct(processed_source, node, column_delta)
+          return unless node
+
+          @processed_source = processed_source
+          expr = node.respond_to?(:loc) ? node.loc.expression : node
+          return if block_comment_within?(expr)
+
+          taboo_ranges = inside_string_ranges(node)
+
+          lambda do |corrector|
+            each_line(expr) do |line_begin_pos|
+              autocorrect_line(corrector, line_begin_pos, expr, column_delta,
+                               taboo_ranges)
+            end
+          end
+        end
+
+        def align_end(processed_source, node, align_to)
+          @processed_source = processed_source
+          whitespace = whitespace_range(node)
+          return false unless whitespace.source.strip.empty?
+
+          column = alignment_column(align_to)
+          ->(corrector) { corrector.replace(whitespace, ' ' * column) }
+        end
+
+        private
+
+        def autocorrect_line(corrector, line_begin_pos, expr, column_delta,
+                             taboo_ranges)
+          range = calculate_range(expr, line_begin_pos, column_delta)
+          # We must not change indentation of heredoc strings or inside other
+          # string literals
+          return if taboo_ranges.any? { |t| within?(range, t) }
+
+          if column_delta.positive?
+            corrector.insert_before(range, ' ' * column_delta) unless range.resize(1).source == "\n"
+          elsif /\A[ \t]+\z/.match?(range.source)
+            remove(range, corrector)
+          end
+        end
+
+        def inside_string_ranges(node)
+          return [] unless node.is_a?(Parser::AST::Node)
+
+          node.each_node(:str, :dstr, :xstr).map { |n| inside_string_range(n) }
+              .compact
+        end
+
+        def inside_string_range(node)
+          loc = node.location
+
+          if node.heredoc?
+            loc.heredoc_body.join(loc.heredoc_end)
+          elsif delimited_string_literal?(node)
+            loc.begin.end.join(loc.end.begin)
+          end
+        end
+
+        # Some special kinds of string literals are not composed of literal
+        # characters between two delimiters:
+        # - The source map of `?a` responds to :begin and :end but its end is
+        #   nil.
+        # - The source map of `__FILE__` responds to neither :begin nor :end.
+        def delimited_string_literal?(node)
+          loc = node.location
+
+          loc.respond_to?(:begin) && loc.begin &&
+            loc.respond_to?(:end) && loc.end
+        end
+
+        def block_comment_within?(expr)
+          processed_source.comments.select(&:document?).any? do |c|
+            within?(c.loc.expression, expr)
+          end
+        end
+
+        def calculate_range(expr, line_begin_pos, column_delta)
+          return range_between(line_begin_pos, line_begin_pos) if column_delta.positive?
+
+          starts_with_space =
+            expr.source_buffer.source[line_begin_pos].start_with?(' ')
+
+          if starts_with_space
+            range_between(line_begin_pos, line_begin_pos + column_delta.abs)
+          else
+            range_between(line_begin_pos - column_delta.abs, line_begin_pos)
+          end
+        end
+
+        def remove(range, corrector)
+          original_stderr = $stderr
+          $stderr = StringIO.new # Avoid error messages on console
+          corrector.remove(range)
+        rescue RuntimeError
+          range = range_between(range.begin_pos + 1, range.end_pos + 1)
+          retry if /^ +$/.match?(range.source)
+        ensure
+          $stderr = original_stderr
+        end
+
+        def each_line(expr)
+          line_begin_pos = expr.begin_pos
+          expr.source.each_line do |line|
+            yield line_begin_pos
+            line_begin_pos += line.length
+          end
+        end
+
+        def whitespace_range(node)
+          begin_pos = node.loc.end.begin_pos
+
+          range_between(begin_pos - node.loc.end.column, begin_pos)
+        end
+
+        def alignment_column(align_to)
+          if !align_to
+            0
+          elsif align_to.respond_to?(:loc)
+            align_to.source_range.column
+          else
+            align_to.column
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/condition_corrector.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does condition auto-correction
+    class ConditionCorrector
+      class << self
+        def correct_negative_condition(node)
+          condition = negated_condition(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.keyword, node.inverse_keyword)
+            corrector.replace(condition, condition.children.first.source)
+          end
+        end
+
+        private
+
+        def negated_condition(node)
+          condition = node.condition
+          condition = condition.children.first while condition.begin_type?
+          condition
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/each_to_for_corrector.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class auto-corrects `#each` enumeration to `for` iteration.
+    class EachToForCorrector
+      extend NodePattern::Macros
+
+      CORRECTION_WITH_ARGUMENTS =
+        'for %<variables>s in %<collection>s do'
+      CORRECTION_WITHOUT_ARGUMENTS = 'for _ in %<enumerable>s do'
+
+      def initialize(block_node)
+        @block_node = block_node
+        @collection_node = block_node.send_node.receiver
+        @argument_node = block_node.arguments
+      end
+
+      def call(corrector)
+        corrector.replace(offending_range, correction)
+      end
+
+      private
+
+      attr_reader :block_node, :collection_node, :argument_node
+
+      def correction
+        if block_node.arguments?
+          format(CORRECTION_WITH_ARGUMENTS,
+                 collection: collection_node.source,
+                 variables: argument_node.children.first.source)
+        else
+          format(CORRECTION_WITHOUT_ARGUMENTS,
+                 enumerable: collection_node.source)
+        end
+      end
+
+      def offending_range
+        if block_node.arguments?
+          replacement_range(argument_node.loc.expression.end_pos)
+        else
+          replacement_range(block_node.loc.begin.end_pos)
+        end
+      end
+
+      def replacement_range(end_pos)
+        Parser::Source::Range.new(block_node.loc.expression.source_buffer,
+                                  block_node.loc.expression.begin_pos,
+                                  end_pos)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/empty_line_corrector.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does empty line auto-correction
+    class EmptyLineCorrector
+      class << self
+        def correct(node)
+          offense_style, range = node
+          lambda do |corrector|
+            case offense_style
+            when :no_empty_lines
+              corrector.remove(range)
+            when :empty_lines
+              corrector.insert_before(range, "\n")
+            end
+          end
+        end
+
+        def insert_before(node)
+          ->(corrector) { corrector.insert_before(node, "\n") }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/for_to_each_corrector.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class auto-corrects `for` iteration to `#each` enumeration.
+    class ForToEachCorrector
+      extend NodePattern::Macros
+
+      CORRECTION = '%<collection>s.each do |%<argument>s|'
+
+      def initialize(for_node)
+        @for_node        = for_node
+        @variable_node   = for_node.variable
+        @collection_node = for_node.collection
+      end
+
+      def call(corrector)
+        corrector.replace(offending_range, correction)
+      end
+
+      private
+
+      attr_reader :for_node, :variable_node, :collection_node
+
+      def correction
+        format(CORRECTION, collection: collection_source,
+                           argument: variable_node.source)
+      end
+
+      def collection_source
+        if requires_parentheses?
+          "(#{collection_node.source})"
+        else
+          collection_node.source
+        end
+      end
+
+      def requires_parentheses?
+        collection_node.range_type?
+      end
+
+      def end_position
+        if for_node.do?
+          keyword_begin.end_pos
+        else
+          collection_end.end_pos
+        end
+      end
+
+      def keyword_begin
+        for_node.loc.begin
+      end
+
+      def collection_end
+        if collection_node.begin_type?
+          collection_node.loc.end
+        else
+          collection_node.loc.expression
+        end
+      end
+
+      def offending_range
+        replacement_range(end_position)
+      end
+
+      def replacement_range(end_pos)
+        Parser::Source::Range.new(for_node.loc.expression.source_buffer,
+                                  for_node.loc.expression.begin_pos,
+                                  end_pos)
+      end
+    end
+  end
+end