rubocop 0.78.0 → 1.13.0

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

@@ -30,18 +30,15 @@ module RuboCop
       #     some_var = 1
       #     do_something(some_var)
       #   end
-      class UselessAssignment < Cop
-        include NameSimilarity
+      class UselessAssignment < Base
         MSG = 'Useless assignment to variable - `%<variable>s`.'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_for_unused_assignments(variable)
-          end
+          scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
         def check_for_unused_assignments(variable)
@@ -58,15 +55,14 @@ module RuboCop
                          assignment.node.loc.name
                        end
 
-            add_offense(nil, location: location, message: message)
+            add_offense(location, message: message)
           end
         end
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
 
-          format(MSG, variable: variable.name) +
-            message_specification(assignment, variable).to_s
+          format(MSG, variable: variable.name) + message_specification(assignment, variable).to_s
         end
 
         def message_specification(assignment, variable)
@@ -86,15 +82,15 @@ module RuboCop
 
         def operator_assignment_message(scope, assignment)
           return_value_node = return_value_node_of_scope(scope)
-          return unless assignment.meta_assignment_node
-                                  .equal?(return_value_node)
+          return unless assignment.meta_assignment_node.equal?(return_value_node)
 
           " Use `#{assignment.operator.sub(/=$/, '')}` " \
           "instead of `#{assignment.operator}`."
         end
 
         def similar_name_message(variable)
-          similar_name = find_similar_name(variable.name, variable.scope)
+          variable_like_names = collect_variable_like_names(variable.scope)
+          similar_name = NameSimilarity.find_similar_name(variable.name, variable_like_names)
           " Did you mean `#{similar_name}`?" if similar_name
         end
 

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

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # This cop checks for useless `else` in `begin..end` without `rescue`.
       #
-      # Note: This syntax is no longer valid on Ruby 2.6 or higher and
+      # NOTE: This syntax is no longer valid on Ruby 2.6 or higher and
       # this cop is going to be removed at some point the future.
       #
       # @example
@@ -29,19 +29,15 @@ module RuboCop
       #   else
       #     do_something_else
       #   end
-      class UselessElseWithoutRescue < Cop
-        include ParserDiagnostic
-
+      class UselessElseWithoutRescue < Base
         MSG = '`else` without `rescue` is useless.'
 
-        private
-
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :useless_else
-        end
+        def on_new_investigation
+          processed_source.diagnostics.each do |diagnostic|
+            next unless diagnostic.reason == :useless_else
 
-        def alternative_message(_diagnostic)
-          MSG
+            add_offense(diagnostic.location, severity: diagnostic.level)
+          end
         end
       end
     end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for useless method definitions, specifically: empty constructors
+      # and methods just delegating to `super`.
+      #
+      # This cop is marked as unsafe as it can trigger false positives for cases when
+      # an empty constructor just overrides the parent constructor, which is bad anyway.
+      #
+      # @example
+      #   # bad
+      #   def initialize
+      #     super
+      #   end
+      #
+      #   def method
+      #     super
+      #   end
+      #
+      #   # good - with default arguments
+      #   def initialize(x = Object.new)
+      #     super
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     super
+      #     initialize_internals
+      #   end
+      #
+      #   def method(*args)
+      #     super(:extra_arg, *args)
+      #   end
+      #
+      class UselessMethodDefinition < Base
+        extend AutoCorrector
+
+        MSG = 'Useless method definition detected.'
+
+        def on_def(node)
+          return if optional_args?(node)
+          return unless delegating?(node.body, node)
+
+          add_offense(node) { |corrector| corrector.remove(node) }
+        end
+        alias on_defs on_def
+
+        private
+
+        def optional_args?(node)
+          node.arguments.any? { |arg| arg.optarg_type? || arg.kwoptarg_type? }
+        end
+
+        def delegating?(node, def_node)
+          if node&.zsuper_type?
+            true
+          elsif node&.super_type?
+            node.arguments.map(&:source) == def_node.arguments.map(&:source)
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,11 @@ module RuboCop
     module Lint
       # This cop checks for setter call to local variable as the final
       # expression of a function definition.
+      # Its auto-correction is marked as unsafe because return value will be changed.
+      #
+      # NOTE: There are edge cases in which the local variable references a
+      # value that is also accessible outside the local scope. This is not
+      # detected by the cop, and it can yield a false positive.
       #
       # @example
       #
@@ -24,7 +29,9 @@ module RuboCop
       #     x.attr = 5
       #     x
       #   end
-      class UselessSetterCall < Cop
+      class UselessSetterCall < Base
+        extend AutoCorrector
+
         MSG = 'Useless setter call to local variable `%<variable>s`.'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
@@ -39,16 +46,17 @@ module RuboCop
           variable_name, = *receiver
           return unless tracker.contain_local_object?(variable_name)
 
-          add_offense(
-            receiver,
-            location: :name,
-            message: format(MSG, variable: receiver.loc.name.source)
-          )
+          loc_name = receiver.loc.name
+
+          add_offense(loc_name, message: format(MSG, variable: loc_name.source)) do |corrector|
+            corrector.insert_after(last_expr, "\n#{indent(last_expr)}#{loc_name.source}")
+          end
         end
         alias on_defs on_def
 
         private
 
+        # @!method setter_call_to_local_variable?(node)
         def_node_matcher :setter_call_to_local_variable?, <<~PATTERN
           [(send (lvar _) ...) setter_method?]
         PATTERN
@@ -82,9 +90,7 @@ module RuboCop
             catch(:skip_children) do
               yield node
 
-              node.each_child_node do |child_node|
-                scan(child_node, &block)
-              end
+              node.each_child_node { |child_node| scan(child_node, &block) }
             end
           end
 

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of `Integer#times` that will never yield
+      # (when the integer <= 0) or that will only ever yield once
+      # (`1.times`).
+      #
+      # This cop is marked as unsafe as `times` returns its receiver, which
+      # is *usually* OK, but might change behavior.
+      #
+      # @example
+      #   # bad
+      #   -5.times { do_something }
+      #   0.times { do_something }
+      #   1.times { do_something  }
+      #   1.times { |i| do_something(i) }
+      #
+      #   # good
+      #   do_something
+      #   do_something(1)
+      class UselessTimes < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Useless call to `%<count>i.times` detected.'
+        RESTRICT_ON_SEND = %i[times].freeze
+
+        # @!method times_call?(node)
+        def_node_matcher :times_call?, <<~PATTERN
+          (send (int $_) :times (block-pass (sym $_))?)
+        PATTERN
+
+        # @!method block_arg(node)
+        def_node_matcher :block_arg, <<~PATTERN
+          (block _ (args (arg $_)) ...)
+        PATTERN
+
+        # @!method block_reassigns_arg?(node)
+        def_node_search :block_reassigns_arg?, <<~PATTERN
+          (lvasgn %)
+        PATTERN
+
+        def on_send(node)
+          return unless (count, proc_name = times_call?(node))
+          return if count > 1
+
+          # Get the block node if applicable
+          node = node.block_node if node.block_literal?
+
+          add_offense(node, message: format(MSG, count: count)) do |corrector|
+            next unless own_line?(node)
+
+            if never_process?(count, node)
+              remove_node(corrector, node)
+            elsif !proc_name.empty?
+              autocorrect_block_pass(corrector, node, proc_name)
+            else
+              autocorrect_block(corrector, node)
+            end
+          end
+        end
+
+        private
+
+        def never_process?(count, node)
+          count < 1 || node.block_type? && node.body.nil?
+        end
+
+        def remove_node(corrector, node)
+          corrector.remove(range_by_whole_lines(node.loc.expression, include_final_newline: true))
+        end
+
+        def autocorrect_block_pass(corrector, node, proc_name)
+          corrector.replace(node, proc_name)
+        end
+
+        def autocorrect_block(corrector, node)
+          block_arg = block_arg(node)
+          return if block_reassigns_arg?(node, block_arg)
+
+          source = node.body.source
+          source.gsub!(/\b#{block_arg}\b/, '1') if block_arg
+
+          corrector.replace(node, fix_indentation(source, node.loc.column...node.body.loc.column))
+        end
+
+        def fix_indentation(source, range)
+          # Cleanup indentation in a multiline block
+          source_lines = source.split("\n")
+
+          source_lines[1..-1].each do |line|
+            next if line.empty?
+
+            line[range] = ''
+          end
+          source_lines.join("\n")
+        end
+
+        def own_line?(node)
+          # If there is anything else on the line other than whitespace,
+          # don't try to autocorrect
+          processed_source.buffer.source_line(node.loc.line)[0...node.loc.column] !~ /\S/
+        end
+      end
+    end
+  end
+end

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

@@ -40,14 +40,13 @@ module RuboCop
       #     some_array.sort!
       #     do_something(some_array)
       #   end
-      class Void < Cop
+      class Void < Base
         OP_MSG = 'Operator `%<op>s` used in void context.'
         VAR_MSG = 'Variable `%<var>s` used in void context.'
         LIT_MSG = 'Literal `%<lit>s` used in void context.'
         SELF_MSG = '`self` used in void context.'
         DEFINED_MSG = '`%<defined>s` used in void context.'
-        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. ' \
-          'Did you mean `#%<method>s!`?'
+        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. Did you mean `#%<method>s!`?'
 
         BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
         UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
@@ -78,9 +77,7 @@ module RuboCop
         def check_begin(node)
           expressions = *node
           expressions.pop unless in_void_context?(node)
-          expressions.each do |expr|
-            check_expression(expr)
-          end
+          expressions.each { |expr| check_expression(expr) }
         end
 
         def check_expression(expr)
@@ -97,17 +94,13 @@ module RuboCop
         def check_void_op(node)
           return unless node.send_type? && OPERATORS.include?(node.method_name)
 
-          add_offense(node,
-                      location: :selector,
-                      message: format(OP_MSG, op: node.method_name))
+          add_offense(node.loc.selector, message: format(OP_MSG, op: node.method_name))
         end
 
         def check_var(node)
           return unless node.variable? || node.const_type?
 
-          add_offense(node,
-                      location: :name,
-                      message: format(VAR_MSG, var: node.loc.name.source))
+          add_offense(node.loc.name, message: format(VAR_MSG, var: node.loc.name.source))
         end
 
         def check_literal(node)
@@ -129,13 +122,9 @@ module RuboCop
         end
 
         def check_nonmutating(node)
-          unless node.send_type? &&
-                 NONMUTATING_METHODS.include?(node.method_name)
-            return
-          end
+          return unless node.send_type? && NONMUTATING_METHODS.include?(node.method_name)
 
-          add_offense(node, message: format(NONMUTATING_MSG,
-                                            method: node.method_name))
+          add_offense(node, message: format(NONMUTATING_MSG, method: node.method_name))
         end
 
         def in_void_context?(node)

data/lib/rubocop/cop/message_annotator.rb

@@ -85,17 +85,18 @@ module RuboCop
         end
       end
 
+      # Returns the base style guide URL from AllCops or the specific department
+      #
+      # @return [String] style guide URL
       def style_guide_base_url
-        department_name = cop_name.split('/').first
+        department_name = cop_name.split('/')[0..-2].join('/')
 
         config.for_department(department_name)['StyleGuideBaseURL'] ||
           config.for_all_cops['StyleGuideBaseURL']
       end
 
       def display_style_guide?
-        (options[:display_style_guide] ||
-         config.for_all_cops['DisplayStyleGuide']) &&
-          !urls.empty?
+        (options[:display_style_guide] || config.for_all_cops['DisplayStyleGuide']) && !urls.empty?
       end
 
       def reference_urls

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -7,7 +7,28 @@ module RuboCop
       # configured maximum. The ABC size is based on assignments, branches
       # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
       # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
-      class AbcSize < Cop
+      #
+      # You can have repeated "attributes" calls count as a single "branch".
+      # For this purpose, attributes are any method with no argument; no attempt
+      # is meant to distinguish actual `attr_reader` from other methods.
+      #
+      # @example CountRepeatedAttributes: false (default is true)
+      #
+      #    # `model` and `current_user`, refenced 3 times each,
+      #    # are each counted as only 1 branch each if
+      #    # `CountRepeatedAttributes` is set to 'false'
+      #
+      #    def search
+      #      @posts = model.active.visible_by(current_user)
+      #                .search(params[:q])
+      #      @posts = model.some_process(@posts, current_user)
+      #      @posts = model.another_process(@posts, current_user)
+      #
+      #      render 'pages/search/page'
+      #    end
+      #
+      # This cop also takes into account `IgnoredMethods` (defaults to `[]`)
+      class AbcSize < Base
         include MethodComplexity
 
         MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
@@ -16,7 +37,10 @@ module RuboCop
         private
 
         def complexity(node)
-          Utils::AbcSizeCalculator.calculate(node)
+          Utils::AbcSizeCalculator.calculate(
+            node,
+            discount_repeated_attributes: !cop_config['CountRepeatedAttributes']
+          )
         end
       end
     end