rubocop 0.92.0 → 1.2.0

data/lib/rubocop/cop/style/redundant_condition.rb

@@ -75,7 +75,7 @@ module RuboCop
         def offense?(node)
           condition, if_branch, else_branch = *node
 
-          return false if use_if_branch?(else_branch)
+          return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
           condition == if_branch && !node.elsif? && (
             node.ternary? ||
@@ -88,6 +88,10 @@ module RuboCop
           else_branch&.if_type?
         end
 
+        def use_hash_key_assignment?(else_branch)
+          else_branch&.send_type? && else_branch&.method?(:[]=)
+        end
+
         def else_source(else_branch)
           if require_parentheses?(else_branch)
             "(#{else_branch.source})"

data/lib/rubocop/cop/style/redundant_interpolation.rb

@@ -51,7 +51,12 @@ module RuboCop
         end
 
         def single_variable_interpolation?(node)
-          node.children.one? && variable_interpolation?(node.children.first)
+          return false unless node.children.one?
+
+          first_child = node.children.first
+
+          variable_interpolation?(first_child) ||
+            first_child.send_type? && !first_child.operator_method?
         end
 
         def interpolation?(node)

data/lib/rubocop/cop/style/redundant_parentheses.rb

@@ -104,9 +104,13 @@ module RuboCop
           return offense(begin_node, 'a variable') if node.variable?
           return offense(begin_node, 'a constant') if node.const_type?
 
+          return offense(begin_node, 'an interpolated expression') if interpolation?(begin_node)
+
           check_send(begin_node, node) if node.call_type?
         end
 
+        def_node_matcher :interpolation?, '[^begin ^^dstr]'
+
         def check_send(begin_node, node)
           return check_unary(begin_node, node) if node.unary_operation?
 

data/lib/rubocop/cop/style/redundant_regexp_character_class.rb

@@ -19,35 +19,23 @@ module RuboCop
       #   # good
       #   r = /\s/
       #
+      #   # bad
+      #   r = %r{/[b]}
+      #
+      #   # good
+      #   r = %r{/b}
+      #
       #   # good
       #   r = /[ab]/
       class RedundantRegexpCharacterClass < Base
-        include MatchRange
-        include RegexpLiteralHelp
         extend AutoCorrector
 
+        REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = '.*+?{}()|$'.chars.freeze
         MSG_REDUNDANT_CHARACTER_CLASS = 'Redundant single-element character class, ' \
         '`%<char_class>s` can be replaced with `%<element>s`.'
 
-        PATTERN = /
-          (
-            (?<!\\)           # No \-prefix (i.e. not escaped)
-            \[                # Literal [
-            (?!\#\{)          # Not (the start of) an interpolation
-            (?:               # Either...
-             \\[^b] |         # Any escaped character except b (which would change behaviour)
-             [^.*+?{}()|$] |  # or one that doesn't require escaping outside the character class
-             \\[upP]\{[^}]+\} # or a unicode code-point or property
-            )
-            (?<!\\)           # No \-prefix (i.e. not escaped)
-            \]                # Literal ]
-          )
-        /x.freeze
-
         def on_regexp(node)
           each_redundant_character_class(node) do |loc|
-            next if whitespace_in_free_space_mode?(node, loc)
-
             add_offense(
               loc, message: format(
                 MSG_REDUNDANT_CHARACTER_CLASS,
@@ -63,19 +51,52 @@ module RuboCop
         private
 
         def each_redundant_character_class(node)
-          pattern_source(node).scan(PATTERN) do
-            yield match_range(node.loc.begin.end, Regexp.last_match)
+          each_single_element_character_class(node) do |char_class|
+            next unless redundant_single_element_character_class?(node, char_class)
+
+            yield char_class.loc.body
           end
         end
 
+        def each_single_element_character_class(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if expr.type != :set || expr.expressions.size != 1
+            next if expr.negative?
+            next if %i[set posixclass nonposixclass].include?(expr.expressions.first.type)
+
+            yield expr
+          end
+        end
+
+        def redundant_single_element_character_class?(node, char_class)
+          class_elem = char_class.expressions.first.text
+
+          non_redundant =
+            whitespace_in_free_space_mode?(node, class_elem) ||
+            backslash_b?(class_elem) ||
+            requires_escape_outside_char_class?(class_elem)
+
+          !non_redundant
+        end
+
         def without_character_class(loc)
           loc.source[1..-2]
         end
 
-        def whitespace_in_free_space_mode?(node, loc)
-          return false unless freespace_mode_regexp?(node)
+        def whitespace_in_free_space_mode?(node, elem)
+          return false unless node.extended?
+
+          /\s/.match?(elem)
+        end
+
+        def backslash_b?(elem)
+          # \b's behaviour is different inside and outside of a character class, matching word
+          # boundaries outside but backspace (0x08) when inside.
+          elem == '\b'
+        end
 
-          /\[\s\]/.match?(loc.source)
+        def requires_escape_outside_char_class?(elem)
+          REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS.include?(elem)
         end
       end
     end

data/lib/rubocop/cop/style/redundant_regexp_escape.rb

@@ -34,7 +34,6 @@ module RuboCop
       #   /[+\-]\d/
       class RedundantRegexpEscape < Base
         include RangeHelp
-        include RegexpLiteralHelp
         extend AutoCorrector
 
         MSG_REDUNDANT_ESCAPE = 'Redundant escape inside regexp literal'
@@ -59,9 +58,9 @@ module RuboCop
 
         def allowed_escape?(node, char, within_character_class)
           # Strictly speaking a few single-letter metachars are currently
-          # unnecessary to "escape", e.g. g, i, E, F, but enumerating them is
+          # unnecessary to "escape", e.g. i, E, F, but enumerating them is
           # rather difficult, and their behaviour could change over time with
-          # different versions of Ruby so that e.g. /\g/ != /g/
+          # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
 
@@ -82,19 +81,13 @@ module RuboCop
         end
 
         def each_escape(node)
-          pattern_source(node).each_char.with_index.reduce(
-            [nil, 0]
-          ) do |(previous, char_class_depth), (current, index)|
-            if previous == '\\'
-              yield [current, index - 1, !char_class_depth.zero?]
-
-              [nil, char_class_depth]
-            elsif previous == '['
-              [current, char_class_depth + 1]
-            elsif current == ']'
-              [current, char_class_depth - 1]
+          node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
+            yield(expr.text[1], expr.start_index, !char_class_depth.zero?) if expr.type == :escape
+
+            if expr.type == :set
+              char_class_depth + (event == :enter ? 1 : -1)
             else
-              [current, char_class_depth]
+              char_class_depth
             end
           end
         end

data/lib/rubocop/cop/style/redundant_self.rb

@@ -129,6 +129,9 @@ module RuboCop
         def allowed_send_node?(node)
           @allowed_send_nodes.include?(node) ||
             @local_variables_scopes[node].include?(node.method_name) ||
+            node.each_ancestor.any? do |ancestor|
+              @local_variables_scopes[ancestor].include?(node.method_name)
+            end ||
             KERNEL_METHODS.include?(node.method_name)
         end
 

data/lib/rubocop/cop/style/safe_navigation.rb

@@ -142,10 +142,22 @@ module RuboCop
         end
 
         def comments(node)
-          processed_source.each_comment_in_lines(
-            node.loc.first_line...
-            node.loc.last_line
-          ).to_a
+          relevant_comment_ranges(node).each.with_object([]) do |range, comments|
+            comments.concat(processed_source.each_comment_in_lines(range).to_a)
+          end
+        end
+
+        def relevant_comment_ranges(node)
+          # Get source lines ranges inside the if node that aren't inside an inner node
+          # Comments inside an inner node should remain attached to that node, and not
+          # moved.
+          begin_pos = node.loc.first_line
+          end_pos = node.loc.last_line
+
+          node.child_nodes.each.with_object([]) do |child, ranges|
+            ranges << (begin_pos...child.loc.first_line)
+            begin_pos = child.loc.last_line
+          end << (begin_pos...end_pos)
         end
 
         def allowed_if_condition?(node)

data/lib/rubocop/cop/style/semicolon.rb

@@ -70,6 +70,9 @@ module RuboCop
         private
 
         def check_for_line_terminator_or_opener
+          # Make the obvious check first
+          return unless @processed_source.raw_source.include?(';')
+
           each_semicolon { |line, column| convention_on(line, column, true) }
         end
 

data/lib/rubocop/cop/style/string_concatenation.rb

@@ -33,6 +33,10 @@ module RuboCop
           }
         PATTERN
 
+        def on_new_investigation
+          @corrected_nodes = nil
+        end
+
         def on_send(node)
           return unless string_concatenation?(node)
 
@@ -42,8 +46,12 @@ module RuboCop
           collect_parts(topmost_plus_node, parts)
 
           add_offense(topmost_plus_node) do |corrector|
-            if parts.none? { |part| uncorrectable?(part) }
+            correctable_parts = parts.none? { |part| uncorrectable?(part) }
+            if correctable_parts && !corrected_ancestor?(topmost_plus_node)
               corrector.replace(topmost_plus_node, replacement(parts))
+
+              @corrected_nodes ||= Set.new.compare_by_identity
+              @corrected_nodes.add(topmost_plus_node)
             end
           end
         end
@@ -80,6 +88,10 @@ module RuboCop
             part.each_descendant(:block).any?
         end
 
+        def corrected_ancestor?(node)
+          node.each_ancestor(:send).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
+        end
+
         def replacement(parts)
           interpolated_parts =
             parts.map do |part|
@@ -87,7 +99,7 @@ module RuboCop
                 if single_quoted?(part)
                   part.value.gsub('\\') { '\\\\' }
                 else
-                  escape_string(part.value)
+                  part.value.inspect[1..-2]
                 end
               else
                 "\#{#{part.source}}"

data/lib/rubocop/cop/style/swap_values.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of shorthand-style swapping of 2 variables.
+      # Its autocorrection is marked as unsafe, because it can erroneously remove
+      # the temporary variable which is used later.
+      #
+      # @example
+      #   # bad
+      #   tmp = x
+      #   x = y
+      #   y = tmp
+      #
+      #   # good
+      #   x, y = y, x
+      #
+      class SwapValues < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Replace this and assignments at lines %<x_line>d '\
+          'and %<y_line>d with `%<replacement>s`.'
+
+        SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].to_set.freeze
+
+        def on_asgn(node)
+          return if allowed_assignment?(node)
+
+          tmp_assign = node
+          x_assign, y_assign = *node.right_siblings.take(2)
+          return unless x_assign && y_assign && swapping_values?(tmp_assign, x_assign, y_assign)
+
+          add_offense(node, message: message(x_assign, y_assign)) do |corrector|
+            range = correction_range(tmp_assign, y_assign)
+            corrector.replace(range, replacement(x_assign))
+          end
+        end
+
+        SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
+
+        private
+
+        def allowed_assignment?(node)
+          node.parent&.mlhs_type? || node.parent&.shorthand_asgn?
+        end
+
+        def swapping_values?(tmp_assign, x_assign, y_assign)
+          simple_assignment?(tmp_assign) &&
+            simple_assignment?(x_assign) &&
+            simple_assignment?(y_assign) &&
+            lhs(x_assign) == rhs(tmp_assign) &&
+            lhs(y_assign) == rhs(x_assign) &&
+            rhs(y_assign) == lhs(tmp_assign)
+        end
+
+        def simple_assignment?(node)
+          SIMPLE_ASSIGNMENT_TYPES.include?(node.type)
+        end
+
+        def message(x_assign, y_assign)
+          format(
+            MSG,
+            x_line: x_assign.first_line,
+            y_line: y_assign.first_line,
+            replacement: replacement(x_assign)
+          )
+        end
+
+        def replacement(x_assign)
+          x = lhs(x_assign)
+          y = rhs(x_assign)
+          "#{x}, #{y} = #{y}, #{x}"
+        end
+
+        def lhs(node)
+          case node.type
+          when :casgn
+            namespace, name, = *node
+            if namespace
+              "#{namespace.const_name}::#{name}"
+            else
+              name.to_s
+            end
+          else
+            node.children[0].to_s
+          end
+        end
+
+        def rhs(node)
+          case node.type
+          when :casgn
+            node.children[2].source
+          else
+            node.children[1].source
+          end
+        end
+
+        def correction_range(tmp_assign, y_assign)
+          range_by_whole_lines(
+            range_between(tmp_assign.source_range.begin_pos, y_assign.source_range.end_pos)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/ternary_parentheses.rb

@@ -192,7 +192,7 @@ module RuboCop
         end
 
         def_node_matcher :method_name, <<~PATTERN
-          {($:defined? (send nil? _) ...)
+          {($:defined? _ ...)
            (send {_ nil?} $_ _ ...)}
         PATTERN
 

data/lib/rubocop/cop/style/trailing_underscore_variable.rb

@@ -36,6 +36,8 @@ module RuboCop
         MSG = 'Do not use trailing `_`s in parallel assignment. ' \
               'Prefer `%<code>s`.'
         UNDERSCORE = '_'
+        DISALLOW = %i[lvasgn splat].freeze
+        private_constant :DISALLOW
 
         def on_masgn(node)
           ranges = unneeded_ranges(node)
@@ -64,7 +66,7 @@ module RuboCop
 
         def find_first_possible_offense(variables)
           variables.reduce(nil) do |offense, variable|
-            break offense unless %i[lvasgn splat].include?(variable.type)
+            break offense unless DISALLOW.include?(variable.type)
 
             var, = *variable
             var, = *var

data/lib/rubocop/cop/team.rb

@@ -99,7 +99,12 @@ module RuboCop
       def self.forces_for(cops)
         needed = Hash.new { |h, k| h[k] = [] }
         cops.each do |cop|
-          Array(cop.class.joining_forces).each { |force| needed[force] << cop }
+          forces = cop.class.joining_forces
+          if forces.is_a?(Array)
+            forces.each { |force| needed[force] << cop }
+          elsif forces
+            needed[forces] << cop
+          end
         end
 
         needed.map do |force_class, joining_cops|

data/lib/rubocop/cop/util.rb

@@ -62,7 +62,7 @@ module RuboCop
       end
 
       def begins_its_line?(range)
-        (range.source_line =~ /\S/) == range.column
+        range.source_line.index(/\S/) == range.column
       end
 
       # Returns, for example, a bare `if` node if the given node is an `if`
@@ -123,6 +123,10 @@ module RuboCop
           node1.loc.line == node2.loc.line
       end
 
+      def indent(node)
+        ' ' * node.loc.column
+      end
+
       def to_supported_styles(enforced_style)
         enforced_style
           .sub(/^Enforced/, 'Supported')