rubocop 0.51.0 → 0.52.0

data/lib/rubocop/cop/mixin/negative_conditional.rb

@@ -7,6 +7,9 @@ module RuboCop
     module NegativeConditional
       extend NodePattern::Macros
 
+      MSG = 'Favor `%<inverse>s` over `%<current>s` for ' \
+            'negative conditions.'.freeze
+
       def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
       def_node_matcher :empty_condition?, '(begin)'
 

data/lib/rubocop/cop/mixin/ordered_gem_node.rb

@@ -5,6 +5,17 @@ module RuboCop
     # Common functionality for Bundler/OrderedGems and
     # Gemspec/OrderedDependencies.
     module OrderedGemNode
+      def autocorrect(node)
+        previous = previous_declaration(node)
+
+        current_range = declaration_with_comment(node)
+        previous_range = declaration_with_comment(previous)
+
+        lambda do |corrector|
+          swap_range(corrector, current_range, previous_range)
+        end
+      end
+
       private
 
       def case_insensitive_out_of_order?(string_a, string_b)
@@ -17,7 +28,11 @@ module RuboCop
       end
 
       def register_offense(previous, current)
-        message = format(self.class::MSG, gem_name(current), gem_name(previous))
+        message = format(
+          self.class::MSG,
+          previous: gem_name(current),
+          current: gem_name(previous)
+        )
         add_offense(current, message: message)
       end
 
@@ -25,17 +40,6 @@ module RuboCop
         declaration_node.first_argument.str_content
       end
 
-      def autocorrect(node)
-        previous = previous_declaration(node)
-
-        current_range = declaration_with_comment(node)
-        previous_range = declaration_with_comment(previous)
-
-        lambda do |corrector|
-          swap_range(corrector, current_range, previous_range)
-        end
-      end
-
       def declaration_with_comment(node)
         buffer = processed_source.buffer
         begin_pos = get_source_range(node).begin_pos

data/lib/rubocop/cop/mixin/parentheses.rb

@@ -15,8 +15,20 @@ module RuboCop
         lambda do |corrector|
           corrector.remove(node.loc.begin)
           corrector.remove(node.loc.end)
+
+          if ternary_condition?(node) && next_char_is_question_mark?(node)
+            corrector.insert_after(node.loc.end, ' ')
+          end
         end
       end
+
+      def ternary_condition?(node)
+        node.parent && node.parent.if_type? && node.parent.ternary?
+      end
+
+      def next_char_is_question_mark?(node)
+        node.loc.last_column == node.parent.loc.question.column
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -5,15 +5,19 @@ module RuboCop
     # Common functionality for cops checking for missing space after
     # punctuation.
     module SpaceAfterPunctuation
-      MSG = 'Space missing after %s.'.freeze
+      MSG = 'Space missing after %<token>s.'.freeze
 
       def investigate(processed_source)
         each_missing_space(processed_source.tokens) do |token|
           add_offense(token, location: token.pos,
-                             message: format(MSG, kind(token)))
+                             message: format(MSG, token: kind(token)))
         end
       end
 
+      def autocorrect(token)
+        ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
+      end
+
       def each_missing_space(tokens)
         tokens.each_cons(2) do |t1, t2|
           next unless kind(t1)
@@ -25,12 +29,12 @@ module RuboCop
       end
 
       def space_missing?(t1, t2)
-        t1.pos.line == t2.pos.line && t2.pos.column == t1.pos.column + offset
+        t1.line == t2.line && t2.column == t1.column + offset
       end
 
       def space_required_before?(token)
         !(allowed_type?(token) ||
-          (token.type == :tRCURLY && space_forbidden_before_rcurly?))
+          (token.right_curly_brace? && space_forbidden_before_rcurly?))
       end
 
       def allowed_type?(token)
@@ -47,10 +51,6 @@ module RuboCop
       def offset
         1
       end
-
-      def autocorrect(token)
-        ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
-      end
     end
   end
 end

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -5,34 +5,38 @@ module RuboCop
     # Common functionality for cops checking for space before
     # punctuation.
     module SpaceBeforePunctuation
-      MSG = 'Space found before %s.'.freeze
+      MSG = 'Space found before %<token>s.'.freeze
 
       def investigate(processed_source)
         each_missing_space(processed_source.tokens) do |token, pos_before|
           add_offense(pos_before, location: pos_before,
-                                  message: format(MSG, kind(token)))
+                                  message: format(MSG, token: kind(token)))
         end
       end
 
+      def autocorrect(pos_before_punctuation)
+        ->(corrector) { corrector.remove(pos_before_punctuation) }
+      end
+
       def each_missing_space(tokens)
         tokens.each_cons(2) do |t1, t2|
           next unless kind(t2)
           next unless space_missing?(t1, t2)
           next if space_required_after?(t1)
 
-          pos_before_punctuation = range_between(t1.pos.end_pos,
-                                                 t2.pos.begin_pos)
+          pos_before_punctuation = range_between(t1.end_pos,
+                                                 t2.begin_pos)
 
           yield t2, pos_before_punctuation
         end
       end
 
       def space_missing?(t1, t2)
-        t1.pos.line == t2.pos.line && t2.pos.begin_pos > t1.pos.end_pos
+        t1.line == t2.line && t2.begin_pos > t1.end_pos
       end
 
       def space_required_after?(token)
-        token.type == :tLCURLY && space_required_after_lcurly?
+        token.left_curly_brace? && space_required_after_lcurly?
       end
 
       def space_required_after_lcurly?
@@ -40,10 +44,6 @@ module RuboCop
         style = cfg['EnforcedStyle'] || 'space'
         style == 'space'
       end
-
-      def autocorrect(pos_before_punctuation)
-        ->(corrector) { corrector.remove(pos_before_punctuation) }
-      end
     end
   end
 end

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -13,12 +13,15 @@ module RuboCop
       end
 
       def non_eligible_node?(node)
-        line_count(node) > 3 ||
+        node.nonempty_line_count > 3 ||
           !node.modifier_form? && commented?(node.loc.end)
       end
 
       def non_eligible_body?(body)
-        empty_body?(body) || body.begin_type? || commented?(body.source_range)
+        body.nil? ||
+          body.empty? ||
+          body.begin_type? ||
+          commented?(body.source_range)
       end
 
       def non_eligible_condition?(condition)
@@ -27,7 +30,7 @@ module RuboCop
 
       def modifier_fits_on_single_line?(node)
         modifier_length = length_in_modifier_form(node, node.condition,
-                                                  body_length(node.body))
+                                                  node.body.length)
 
         modifier_length <= max_line_length
       end
@@ -41,20 +44,7 @@ module RuboCop
       end
 
       def max_line_length
-        cop_config['MaxLineLength'] ||
-          config.for_cop('Metrics/LineLength')['Max']
-      end
-
-      def line_count(node)
-        node.source.lines.grep(/\S/).size
-      end
-
-      def empty_body?(body)
-        !body || body_length(body).zero?
-      end
-
-      def body_length(body)
-        body.source_range ? body.source_range.size : 0
+        config.for_cop('Metrics/LineLength')['Max']
       end
 
       def commented?(source)

data/lib/rubocop/cop/mixin/surrounding_space.rb

@@ -2,13 +2,26 @@
 
 module RuboCop
   module Cop
-    # Common functionality for checking surrounding space.
+    # Common functionality for checking and correcting surrounding whitespace.
     module SurroundingSpace
-      def space_between?(t1, _t2)
-        # Check if the range between the tokens starts with a space. It can
-        # contain other characters, e.g. a unary plus, but it must start with
-        # space.
-        t1.pos.source_buffer.source.match(/\G\s/, t1.pos.end_pos)
+      NO_SPACE_COMMAND = 'Do not use'.freeze
+      SPACE_COMMAND = 'Use'.freeze
+
+      def side_space_range(range:, side:)
+        buffer = @processed_source.buffer
+        src = buffer.source
+
+        begin_pos = range.begin_pos
+        end_pos = range.end_pos
+        if side == :left
+          begin_pos = reposition(src, begin_pos, -1)
+          end_pos -= 1
+        end
+        if side == :right
+          begin_pos += 1
+          end_pos = reposition(src, end_pos, 1)
+        end
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
       def index_of_first_token(node)
@@ -29,12 +42,86 @@ module RuboCop
         @token_table ||= begin
           table = {}
           @processed_source.tokens.each_with_index do |t, ix|
-            table[t.pos.line] ||= {}
-            table[t.pos.line][t.pos.column] = ix
+            table[t.line] ||= {}
+            table[t.line][t.column] = ix
           end
           table
         end
       end
+
+      def tokens(node)
+        processed_source.tokens.select do |token|
+          token.end_pos <= node.source_range.end_pos &&
+            token.begin_pos >= node.source_range.begin_pos
+        end
+      end
+
+      def no_space_offenses(node, # rubocop:disable Metrics/ParameterLists
+                            left_token,
+                            right_token,
+                            message,
+                            start_ok: false,
+                            end_ok: false)
+        if extra_space?(left_token, :left) && !start_ok
+          space_offense(node, left_token, :right, message, NO_SPACE_COMMAND)
+        end
+        return if !extra_space?(right_token, :right) || end_ok
+        space_offense(node, right_token, :left, message, NO_SPACE_COMMAND)
+      end
+
+      def no_space_corrector(corrector, left_token, right_token)
+        if left_token.space_after?
+          range = side_space_range(range: left_token.pos, side: :right)
+          corrector.remove(range)
+        end
+        return unless right_token.space_before?
+        range = side_space_range(range: right_token.pos, side: :left)
+        corrector.remove(range)
+      end
+
+      def space_offenses(node, # rubocop:disable Metrics/ParameterLists
+                         left_token,
+                         right_token,
+                         message,
+                         start_ok: false,
+                         end_ok: false)
+        unless extra_space?(left_token, :left) || start_ok
+          space_offense(node, left_token, :none, message, SPACE_COMMAND)
+        end
+        return if extra_space?(right_token, :right) || end_ok
+        space_offense(node, right_token, :none, message, SPACE_COMMAND)
+      end
+
+      def space_corrector(corrector, left_token, right_token)
+        unless left_token.space_after?
+          corrector.insert_after(left_token.pos, ' ')
+        end
+        return if right_token.space_before?
+        corrector.insert_before(right_token.pos, ' ')
+      end
+
+      private
+
+      def extra_space?(token, side)
+        return false unless token
+        if side == :left
+          String(token.space_after?) == ' '
+        else
+          String(token.space_before?) == ' '
+        end
+      end
+
+      def reposition(src, pos, step)
+        offset = step == -1 ? -1 : 0
+        pos += step while src[pos + offset] =~ /[ \t]/
+        pos < 0 ? 0 : pos
+      end
+
+      def space_offense(node, token, side, message, command)
+        range = side_space_range(range: token.pos, side: side)
+        add_offense(node, location: range,
+                          message: format(message, command: command))
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/too_many_lines.rb

@@ -7,12 +7,12 @@ module RuboCop
       include ConfigurableMax
       include CodeLength
 
-      MSG = '%s has too many lines. [%d/%d]'.freeze
+      MSG = '%<label>s has too many lines. [%<length>d/%<max>d]'.freeze
 
       private
 
       def message(length, max_length)
-        format(MSG, cop_label, length, max_length)
+        format(MSG, label: cop_label, length: length, max: max_length)
       end
 
       def code_length(node)

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -7,7 +7,18 @@ module RuboCop
     module TrailingComma
       include ConfigurableEnforcedStyle
 
-      MSG = '%s comma after the last %s'.freeze
+      MSG = '%<command>s comma after the last %<unit>s.'.freeze
+
+      def autocorrect(range)
+        return unless range
+
+        lambda do |corrector|
+          case range.source
+          when ',' then corrector.remove(range)
+          else          corrector.insert_after(range, ',')
+          end
+        end
+      end
 
       def style_parameter_name
         'EnforcedStyleForMultiline'
@@ -116,7 +127,11 @@ module RuboCop
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
         article = kind =~ /array/ ? 'an' : 'a'
-        msg = format(MSG, 'Avoid', format(kind, article)) + "#{extra_info}."
+        msg = format(
+          MSG,
+          command: 'Avoid',
+          unit: format(kind, article: article) + extra_info.to_s
+        )
 
         add_offense(range, location: range, message: msg)
       end
@@ -128,7 +143,11 @@ module RuboCop
         return if last_item.block_pass_type?
 
         range = autocorrect_range(last_item)
-        msg = format(MSG, 'Put a', format(kind, 'a multiline') + '.')
+        msg = format(
+          MSG,
+          command: 'Put a',
+          unit: format(kind, article: 'a multiline')
+        )
 
         add_offense(range, location: range, message: msg)
       end
@@ -145,17 +164,6 @@ module RuboCop
       def avoid_autocorrect?(_)
         false
       end
-
-      def autocorrect(range)
-        return unless range
-
-        lambda do |corrector|
-          case range.source
-          when ',' then corrector.remove(range)
-          else          corrector.insert_after(range, ',')
-          end
-        end
-      end
     end
   end
 end

data/lib/rubocop/cop/mixin/unused_argument.rb

@@ -7,8 +7,6 @@ module RuboCop
       module UnusedArgument
         extend NodePattern::Macros
 
-        def_node_search :uses_var?, '(lvar %)'
-
         def join_force?(force_class)
           force_class == VariableForce
         end
@@ -21,7 +19,7 @@ module RuboCop
 
         def check_argument(variable)
           return if variable.should_be_unused?
-          return if variable_used?(variable)
+          return if variable.referenced?
 
           message = message(variable)
           add_offense(variable.declaration_node, location: :name,
@@ -33,7 +31,8 @@ module RuboCop
 
           if node.blockarg_type?
             lambda do |corrector|
-              range = range_with_surrounding_space(node.source_range, :left)
+              range = range_with_surrounding_space(range: node.source_range,
+                                                   side: :left)
               range = range_with_surrounding_comma(range, :left)
               corrector.remove(range)
             end
@@ -41,42 +40,6 @@ module RuboCop
             ->(corrector) { corrector.insert_before(node.loc.name, '_') }
           end
         end
-
-        private
-
-        def variable_used?(variable)
-          return false unless variable.referenced?
-
-          assignment_without_usage =
-            find_assignment_without_variable_usage(variable)
-
-          # If variable is either not assigned or assigned with usages,
-          # then it's really used
-          return true unless assignment_without_usage
-
-          assignment_without_usage_pos =
-            assignment_without_usage.node.source_range.begin_pos
-
-          reference_positions =
-            variable.references.map { |var| var.node.source_range.begin_pos }
-
-          # Was variable referenced before it was reassigned?
-          reference_positions.any? { |pos| pos <= assignment_without_usage_pos }
-        end
-
-        # Find the first variable assignment, which doesn't reference the
-        # variable at the rhs.
-        def find_assignment_without_variable_usage(variable)
-          variable.assignments.find do |assignment|
-            # It's impossible to decide whether a branch is executed, so
-            # this case is ignored
-            next if assignment.branch
-
-            assignment_node = assignment.meta_assignment_node || assignment.node
-
-            !uses_var?(assignment_node, assignment.variable.name)
-          end
-        end
       end
     end
   end