rubocop 0.91.1 → 1.1.0

data/lib/rubocop/cop/corrector.rb

@@ -9,6 +9,8 @@ module RuboCop
     # The nodes modified by the corrections should be part of the
     # AST of the source_buffer.
     class Corrector < ::Parser::Source::TreeRewriter
+      NOOP_CONSUMER = ->(diagnostic) {} # noop
+
       # @param source [Parser::Source::Buffer, or anything
       #                leading to one via `(processed_source.)buffer`]
       #
@@ -23,7 +25,7 @@ module RuboCop
         )
 
         # Don't print warnings to stderr if corrections conflict with each other
-        diagnostics.consumer = ->(diagnostic) {}
+        diagnostics.consumer = NOOP_CONSUMER
       end
 
       alias rewrite process # Legacy

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

@@ -52,8 +52,8 @@ module RuboCop
         end
 
         def semicolon(node)
-          @semicolon ||= {}
-          @semicolon[node.object_id] ||= processed_source.tokens_within(node).find(&:semicolon?)
+          @semicolon ||= {}.compare_by_identity
+          @semicolon[node] ||= processed_source.tokens_within(node).find(&:semicolon?)
         end
       end
     end

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

@@ -89,7 +89,7 @@ module RuboCop
         begin_line_num = previous_line_num - base_line_num + 1
         end_line_num = node.first_line - base_line_num + 1
         lines = source_in_lines[begin_line_num...end_line_num]
-        "\n#{(lines.join("\n").split(node.source).first || '')}"
+        "\n#{lines.join("\n").split(node.source).first || ''}"
       end
 
       def fix_escaped_content(word_node, escape, delimiters)

data/lib/rubocop/cop/force.rb

@@ -31,7 +31,7 @@ module RuboCop
         cops.each do |cop|
           next unless cop.respond_to?(method_name)
 
-          cop.send(method_name, *args)
+          cop.public_send(method_name, *args)
         end
       end
 

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -58,24 +58,22 @@ module RuboCop
           (send _ :required_ruby_version= $_)
         PATTERN
 
-        def_node_matcher :string_version?, <<~PATTERN
-          {(str _) (array (str _))}
+        def_node_matcher :defined_ruby_version, <<~PATTERN
+          {$(str _) $(array (str _) (str _))
+            (send (const (const nil? :Gem) :Requirement) :new $(str _))}
         PATTERN
 
         # rubocop:disable Metrics/AbcSize
         def investigate(processed_source)
-          version = required_ruby_version(processed_source.ast).first
+          version_def = required_ruby_version(processed_source.ast).first
 
-          if version
-            return unless string_version?(version)
-
-            ruby_version = extract_ruby_version(version)
-
-            return if ruby_version == target_ruby_version.to_s
+          if version_def
+            ruby_version = extract_ruby_version(defined_ruby_version(version_def))
+            return if !ruby_version || ruby_version == target_ruby_version.to_s
 
             add_offense(
               processed_source.ast,
-              location: version.loc.expression,
+              location: version_def.loc.expression,
               message: not_equal_message(ruby_version, target_ruby_version)
             )
           else
@@ -88,6 +86,8 @@ module RuboCop
         private
 
         def extract_ruby_version(required_ruby_version)
+          return unless required_ruby_version
+
           if required_ruby_version.array_type?
             required_ruby_version = required_ruby_version.children.detect do |v|
               /[>=]/.match?(v.str_content)

data/lib/rubocop/cop/layout/array_alignment.rb

@@ -44,6 +44,7 @@ module RuboCop
 
         def on_array(node)
           return if node.children.size < 2
+          return if node.parent&.masgn_type?
 
           check_alignment(node.children, base_column(node, node.children))
         end

data/lib/rubocop/cop/layout/class_structure.rb

@@ -265,6 +265,9 @@ module RuboCop
         end
 
         def end_position_for(node)
+          heredoc = find_heredoc(node)
+          return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+
           end_line = buffer.line_for_position(node.loc.expression.end_pos)
           buffer.line_range(end_line).end_pos
         end
@@ -284,6 +287,10 @@ module RuboCop
           buffer.line_range(node.loc.line).begin_pos - 1
         end
 
+        def find_heredoc(node)
+          node.each_node(:str, :dstr, :xstr).find(&:heredoc?)
+        end
+
         def buffer
           processed_source.buffer
         end

data/lib/rubocop/cop/layout/def_end_alignment.rb

@@ -46,7 +46,7 @@ module RuboCop
         alias on_defs on_def
 
         def on_send(node)
-          return if !node.def_modifier? || node.method?(:using)
+          return unless node.def_modifier?
 
           method_def = node.each_descendant(:def, :defs).first
           expr = node.source_range

data/lib/rubocop/cop/layout/dot_position.rb

@@ -29,17 +29,14 @@ module RuboCop
         def on_send(node)
           return unless node.dot? || ampersand_dot?(node)
 
-          if proper_dot_position?(node)
-            correct_style_detected
-          else
-            return unless opposite_style_detected
+          return correct_style_detected if proper_dot_position?(node)
 
-            dot = node.loc.dot
-            message = message(dot)
+          opposite_style_detected
+          dot = node.loc.dot
+          message = message(dot)
 
-            add_offense(dot, message: message) do |corrector|
-              autocorrect(corrector, dot, node)
-            end
+          add_offense(dot, message: message) do |corrector|
+            autocorrect(corrector, dot, node)
           end
         end
         alias on_csend on_send

data/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb

@@ -84,7 +84,8 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless register_offense?(node)
+          return unless node.bare_access_modifier? && !node.parent&.block_type?
+          return if expected_empty_lines?(node)
 
           message = message(node)
           add_offense(node, message: message) do |corrector|
@@ -98,17 +99,15 @@ module RuboCop
 
         private
 
-        def register_offense?(node)
-          return false unless node.bare_access_modifier? && !node.parent.block_type?
-
+        def expected_empty_lines?(node)
           case style
           when :around
-            return false if empty_lines_around?(node)
+            return true if empty_lines_around?(node)
           when :only_before
-            return false if allowed_only_before_style?(node)
+            return true if allowed_only_before_style?(node)
           end
 
-          true
+          false
         end
 
         def allowed_only_before_style?(node)
@@ -142,6 +141,7 @@ module RuboCop
         def previous_line_empty?(send_line)
           previous_line = previous_line_ignoring_comments(processed_source,
                                                           send_line)
+          return true unless previous_line
 
           block_start?(send_line) ||
             class_def?(send_line) ||

data/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb

@@ -88,7 +88,7 @@ module RuboCop
         end
 
         def require_empty_line?(node)
-          return false unless node&.respond_to?(:type)
+          return false unless node.respond_to?(:type)
 
           !allow_alias?(node) && !attribute_or_allowed_method?(node)
         end

data/lib/rubocop/cop/layout/extra_spacing.rb

@@ -56,8 +56,7 @@ module RuboCop
           aligned = Set[locs.first.line, locs.last.line]
           locs.each_cons(3) do |before, loc, after|
             col = loc.column
-            aligned << loc.line if col == before.column || # rubocop:disable Style/MultipleComparison
-                                   col == after.column
+            aligned << loc.line if col == before.column || col == after.column
           end
           aligned
         end

data/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb

@@ -51,22 +51,13 @@ module RuboCop
              style == :no_space && no_surrounding_space
             correct_style_detected
           else
-            incorrect_style_detected(arg, value, space_on_both_sides,
-                                     no_surrounding_space)
+            incorrect_style_detected(arg, value)
           end
         end
 
-        def incorrect_style_detected(arg, value, space_on_both_sides,
-                                     no_surrounding_space)
+        def incorrect_style_detected(arg, value)
           range = range_between(arg.end_pos, value.begin_pos)
 
-          if style == :space && no_surrounding_space ||
-             style == :no_space && space_on_both_sides
-            return unless opposite_style_detected
-          else
-            return unless unrecognized_style_detected
-          end
-
           add_offense(range) do |corrector|
             autocorrect(corrector, range)
           end

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -5,6 +5,8 @@ module RuboCop
     module Layout
       # Checks that operators have space around them, except for ** which
       # should or shouldn't have surrounding space depending on configuration.
+      # It allows vertical alignment consisting of one or more whitespace
+      # around operators.
       #
       # This cop has `AllowForAlignment` option. When `true`, allows most
       # uses of extra spacing if the intent is to align with an operator on
@@ -207,7 +209,8 @@ module RuboCop
           token            = Token.new(operator, nil, operator.source)
           align_preceding  = aligned_with_preceding_assignment(token)
 
-          return align_preceding == :no unless align_preceding == :none
+          return false if align_preceding == :yes ||
+                          aligned_with_subsequent_assignment(token) == :none
 
           aligned_with_subsequent_assignment(token) != :yes
         end

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -206,8 +206,6 @@ module RuboCop
 
         def no_space(begin_pos, end_pos, msg)
           if style == :space
-            return unless opposite_style_detected
-
             offense(begin_pos, end_pos, msg)
           else
             correct_style_detected
@@ -216,8 +214,6 @@ module RuboCop
 
         def space(begin_pos, end_pos, msg)
           if style == :no_space
-            return unless opposite_style_detected
-
             offense(begin_pos, end_pos, msg)
           else
             correct_style_detected

data/lib/rubocop/cop/layout/trailing_whitespace.rb

@@ -14,14 +14,25 @@ module RuboCop
       #   # good
       #   x = 0
       #
-      # @example AllowInHeredoc: false
+      # @example AllowInHeredoc: false (default)
       #   # The line in this example contains spaces after the 0.
       #   # bad
       #   code = <<~RUBY
       #     x = 0
       #   RUBY
       #
-      # @example AllowInHeredoc: true (default)
+      #   # ok
+      #   code = <<~RUBY
+      #     x = 0 #{}
+      #   RUBY
+      #
+      #   # good
+      #   trailing_whitespace = ' '
+      #   code = <<~RUBY
+      #     x = 0#{trailing_whitespace}
+      #   RUBY
+      #
+      # @example AllowInHeredoc: true
       #   # The line in this example contains spaces after the 0.
       #   # good
       #   code = <<~RUBY
@@ -35,36 +46,49 @@ module RuboCop
         MSG = 'Trailing whitespace detected.'
 
         def on_new_investigation
-          heredoc_ranges = extract_heredoc_ranges(processed_source.ast)
+          @heredocs = extract_heredocs(processed_source.ast)
           processed_source.lines.each_with_index do |line, index|
-            lineno = index + 1
-
             next unless line.end_with?(' ', "\t")
-            next if skip_heredoc? && inside_heredoc?(heredoc_ranges, lineno)
 
-            range = offense_range(lineno, line)
-            add_offense(range) do |corrector|
+            process_line(line, index + 1)
+          end
+        end
+
+        private
+
+        def process_line(line, lineno)
+          heredoc = find_heredoc(lineno)
+          return if skip_heredoc? && heredoc
+
+          range = offense_range(lineno, line)
+          add_offense(range) do |corrector|
+            if heredoc
+              corrector.wrap(range, "\#{'", "'}") unless static?(heredoc)
+            else
               corrector.remove(range)
             end
           end
         end
 
-        private
+        def static?(heredoc)
+          heredoc.loc.expression.source.end_with? "'"
+        end
 
         def skip_heredoc?
           cop_config.fetch('AllowInHeredoc', false)
         end
 
-        def inside_heredoc?(heredoc_ranges, line_number)
-          heredoc_ranges.any? { |r| r.include?(line_number) }
+        def find_heredoc(line_number)
+          @heredocs.each { |node, r| return node if r.include?(line_number) }
+          nil
         end
 
-        def extract_heredoc_ranges(ast)
+        def extract_heredocs(ast)
           return [] unless ast
 
           ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
             body = node.location.heredoc_body
-            (body.first_line...body.last_line)
+            [node, body.first_line...body.last_line]
           end
         end
 

data/lib/rubocop/cop/lint/ambiguous_block_association.rb

@@ -15,6 +15,8 @@ module RuboCop
       #
       #   # good
       #   # With parentheses, there's no ambiguity.
+      #   some_method(a { |val| puts val })
+      #   # or (different meaning)
       #   some_method(a) { |val| puts val }
       #
       #   # good

data/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb

@@ -47,7 +47,24 @@ module RuboCop
             regexp_node.source_range.begin_pos == diagnostic.location.begin_pos
           end
 
-          node.parent
+          find_offense_node(node.parent, node)
+        end
+
+        def find_offense_node(node, regexp_receiver)
+          return node unless node.parent
+
+          if node.parent.send_type? || method_chain_to_regexp_receiver?(node, regexp_receiver)
+            node = find_offense_node(node.parent, regexp_receiver)
+          end
+
+          node
+        end
+
+        def method_chain_to_regexp_receiver?(node, regexp_receiver)
+          return false unless (parent = node.parent)
+          return false unless (parent_receiver = parent.receiver)
+
+          parent.parent && parent_receiver.receiver == regexp_receiver
         end
       end
     end

data/lib/rubocop/cop/lint/boolean_symbol.rb

@@ -32,6 +32,9 @@ module RuboCop
         def on_sym(node)
           return unless boolean_symbol?(node)
 
+          parent = node.parent
+          return if parent&.array_type? && parent&.percent_literal?(:symbol)
+
           add_offense(node, message: format(MSG, boolean: node.value)) do |corrector|
             autocorrect(corrector, node)
           end

data/lib/rubocop/cop/lint/debugger.rb

@@ -37,7 +37,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[
           debugger byebug remote_byebug pry remote_pry pry_remote console rescue
-          save_and_open_page save_and_open_screenshot save_screenshot irb
+          save_and_open_page save_and_open_screenshot irb
         ].freeze
 
         def_node_matcher :kernel?, <<~PATTERN
@@ -53,8 +53,7 @@ module RuboCop
              {:pry :remote_pry :pry_remote :console} ...)
            (send (const {nil? (cbase)} :Pry) :rescue ...)
            (send nil? {:save_and_open_page
-                      :save_and_open_screenshot
-                      :save_screenshot} ...)}
+                      :save_and_open_screenshot} ...)}
         PATTERN
 
         def_node_matcher :binding_irb_call?, <<~PATTERN

data/lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicate elements in Regexp character classes.
+      #
+      # @example
+      #
+      #   # bad
+      #   r = /[xyx]/
+      #
+      #   # bad
+      #   r = /[0-9x0-9]/
+      #
+      #   # good
+      #   r = /[xy]/
+      #
+      #   # good
+      #   r = /[0-9x]/
+      class DuplicateRegexpCharacterClassElement < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_REPEATED_ELEMENT = 'Duplicate element inside regexp character class'
+
+        def on_regexp(node)
+          each_repeated_character_class_element_loc(node) do |loc|
+            add_offense(loc, message: MSG_REPEATED_ELEMENT) do |corrector|
+              corrector.remove(loc)
+            end
+          end
+        end
+
+        def each_repeated_character_class_element_loc(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if expr.type != :set || expr.token == :intersection
+
+            seen = Set.new
+
+            expr.expressions.each do |child|
+              next if within_interpolation?(node, child)
+
+              child_source = child.to_s
+
+              yield child.expression if seen.include?(child_source)
+
+              seen << child_source
+            end
+          end
+        end
+
+        private
+
+        # Since we blank interpolations with a space for every char of the interpolation, we would
+        # mark every space (except the first) as duplicate if we do not skip regexp_parser nodes
+        # that are within an interpolation.
+        def within_interpolation?(node, child)
+          parse_tree_child_loc = child.expression
+
+          interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
+        end
+
+        def interpolation_locs(node)
+          @interpolation_locs ||= {}
+
+          # Cache by loc, not by regexp content, as content can be repeated in multiple patterns
+          key = node.loc
+
+          @interpolation_locs[key] ||= node.children.select(&:begin_type?).map do |interpolation|
+            interpolation.loc.expression
+          end
+        end
+      end
+    end
+  end
+end