rubocop 0.90.0 → 0.93.1

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

@@ -35,7 +35,6 @@ module RuboCop
       #     baz
       #   end
       class RescueType < Base
-        include RescueNode
         extend AutoCorrector
 
         MSG = 'Rescuing from `%<invalid_exceptions>s` will raise a ' \

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

@@ -40,10 +40,12 @@ module RuboCop
 
         MSG = 'Use `%<method>s %<module_name>s` instead of `%<bad_method>s`.'
         MIXIN_METHODS = %i[include prepend extend].freeze
+        SEND_METHODS = %i[send public_send __send__].freeze
+        RESTRICT_ON_SEND = SEND_METHODS
 
         def_node_matcher :send_with_mixin_argument?, <<~PATTERN
           (send
-            (const _ _) {:send :public_send :__send__}
+            (const _ _) {:#{SEND_METHODS.join(' :')}}
             ({sym str} $#mixin_method?)
               $(const _ _))
         PATTERN

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

@@ -75,8 +75,7 @@ module RuboCop
 
         def rescued_groups_for(rescues)
           rescues.map do |group|
-            rescue_group, = *group
-            evaluate_exceptions(rescue_group)
+            evaluate_exceptions(group)
           end
         end
 
@@ -117,14 +116,15 @@ module RuboCop
           $VERBOSE = old_verbose
         end
 
-        def evaluate_exceptions(rescue_group)
-          if rescue_group
-            rescued_exceptions = rescued_exceptions(rescue_group)
+        def evaluate_exceptions(group)
+          rescued_exceptions = group.exceptions
+
+          if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
               begin
                 silence_warnings do
                   # Avoid printing deprecation warnings about constants
-                  converted << Kernel.const_get(exception)
+                  converted << Kernel.const_get(exception.source)
                 end
               rescue NameError
                 converted << nil

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

@@ -24,6 +24,7 @@ module RuboCop
       class StructNewOverride < Base
         MSG = '`%<member_name>s` member overrides `Struct#%<method_name>s`' \
               ' and it may be unexpected.'
+        RESTRICT_ON_SEND = %i[new].freeze
 
         STRUCT_METHOD_NAMES = Struct.instance_methods
         STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze

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

@@ -9,12 +9,23 @@ module RuboCop
       # for an optional argument, your method should too.
       #
       # @example
-      #   # bad
-      #   def to_json
-      #   end
+      #   class Point
+      #     attr_reader :x, :y
+      #
+      #     # bad, incorrect arity
+      #     def to_json
+      #       JSON.generate([x, y])
+      #     end
+      #
+      #     # good, preserving args
+      #     def to_json(*args)
+      #       JSON.generate([x, y], *args)
+      #     end
       #
-      #   # good
-      #   def to_json(*_args)
+      #     # good, discarding args
+      #     def to_json(*_args)
+      #       JSON.generate([x, y])
+      #     end
       #   end
       #
       class ToJSON < Base

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

@@ -130,7 +130,8 @@ module RuboCop
           case node.type
           when :begin, :kwbegin
             statements = *node
-            statements.any? { |statement| break_statement?(statement) }
+            break_statement = statements.find { |statement| break_statement?(statement) }
+            break_statement && !preceded_by_continue_statement?(break_statement)
           when :if
             check_if(node)
           when :case
@@ -158,16 +159,12 @@ module RuboCop
         end
 
         def preceded_by_continue_statement?(break_statement)
-          left_siblings_of(break_statement).any? do |sibling|
+          break_statement.left_siblings.any? do |sibling|
             next if sibling.loop_keyword? || loop_method?(sibling)
 
             sibling.each_descendant(:next, :redo).any?
           end
         end
-
-        def left_siblings_of(node)
-          node.parent.children[0, node.sibling_index]
-        end
       end
     end
   end

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

@@ -44,10 +44,12 @@ module RuboCop
         MSG = '`%<uri_method>s` method is obsolete and should not be used. ' \
               'Instead, use %<replacements>s depending on your specific use ' \
               'case.'
+        METHOD_NAMES = %i[escape encode unescape decode].freeze
+        RESTRICT_ON_SEND = METHOD_NAMES
 
         def_node_matcher :uri_escape_unescape?, <<~PATTERN
           (send
-            (const ${nil? cbase} :URI) ${:escape :encode :unescape :decode}
+            (const ${nil? cbase} :URI) ${:#{METHOD_NAMES.join(' :')}}
             ...)
         PATTERN
 

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

@@ -18,9 +18,10 @@ module RuboCop
 
         MSG = '`%<current>s` is obsolete and should not be used. Instead, use `%<preferred>s`.'
         URI_CONSTANTS = ['URI', '::URI'].freeze
+        RESTRICT_ON_SEND = %i[regexp].freeze
 
         def on_send(node)
-          return unless node.method?(:regexp) && node.receiver
+          return unless node.receiver
           return unless URI_CONSTANTS.include?(node.receiver.source)
 
           argument = node.first_argument ? "(#{node.first_argument.source})" : ''

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

@@ -131,12 +131,10 @@ module RuboCop
         MSG = 'Useless `%<current>s` access modifier.'
 
         def on_class(node)
-          check_node(node.children[2]) # class body
-        end
-
-        def on_module(node)
-          check_node(node.children[1]) # module body
+          check_node(node.body)
         end
+        alias on_module on_class
+        alias on_sclass on_class
 
         def on_block(node)
           return unless eval_call?(node)
@@ -144,10 +142,6 @@ module RuboCop
           check_node(node.body)
         end
 
-        def on_sclass(node)
-          check_node(node.children[1]) # singleton class body
-        end
-
         private
 
         def autocorrect(corrector, node)

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

@@ -12,32 +12,26 @@ module RuboCop
       # @example
       #   # bad
       #   def initialize
+      #     super
       #   end
       #
       #   def method
       #     super
       #   end
       #
-      #   # good
-      #   def initialize
-      #     initialize_internals
-      #   end
-      #
-      #   def method
+      #   # good - with default arguments
+      #   def initialize(x = Object.new)
       #     super
-      #     do_something_else
       #   end
       #
-      # @example AllowComments: true (default)
       #   # good
       #   def initialize
-      #     # Comment.
+      #     super
+      #     initialize_internals
       #   end
       #
-      # @example AllowComments: false
-      #   # bad
-      #   def initialize
-      #     # Comment.
+      #   def method(*args)
+      #     super(:extra_arg, *args)
       #   end
       #
       class UselessMethodDefinition < Base
@@ -46,8 +40,8 @@ module RuboCop
         MSG = 'Useless method definition detected.'
 
         def on_def(node)
-          return unless (constructor?(node) && empty_constructor?(node)) ||
-                        delegating?(node.body, node)
+          return if optional_args?(node)
+          return unless delegating?(node.body, node)
 
           add_offense(node) { |corrector| corrector.remove(node) }
         end
@@ -55,21 +49,20 @@ module RuboCop
 
         private
 
-        def empty_constructor?(node)
-          return false if node.body
-          return false if cop_config['AllowComments'] && comment_lines?(node)
-
-          true
-        end
-
-        def constructor?(node)
-          node.def_type? && node.method?(:initialize)
+        def optional_args?(node)
+          node.arguments.any? { |arg| arg.optarg_type? || arg.kwoptarg_type? }
         end
 
         def delegating?(node, def_node)
-          return false unless node&.super_type? || node&.zsuper_type?
-
-          !node.arguments? || node.arguments.map(&:source) == def_node.arguments.map(&:source)
+          if node.nil?
+            false
+          elsif node.zsuper_type?
+            true
+          elsif node.super_type?
+            node.arguments.map(&:source) == def_node.arguments.map(&:source)
+          else
+            false
+          end
         end
       end
     end

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

@@ -0,0 +1,106 @@
+# 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
+
+        def_node_matcher :times_call?, <<~PATTERN
+          (send (int $_) :times (block-pass (sym $_))?)
+        PATTERN
+
+        def_node_matcher :block_arg, <<~PATTERN
+          (block _ (args (arg $_)) ...)
+        PATTERN
+
+        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/metrics/block_length.rb

@@ -29,6 +29,8 @@ module RuboCop
       #       content.
       #     HEREDOC
       #   end                 # 5 points
+      #
+      # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
 
@@ -36,7 +38,7 @@ module RuboCop
 
         def on_block(node)
           return if excluded_method?(node)
-          return if node.class_constructor?
+          return if node.class_constructor? || node.struct_constructor?
 
           check_code_length(node)
         end

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

@@ -29,6 +29,8 @@ module RuboCop
       #     HEREDOC
       #   end                 # 5 points
       #
+      #
+      # NOTE: This cop also applies for `Struct` definitions.
       class ClassLength < Base
         include CodeLength
 
@@ -37,17 +39,23 @@ module RuboCop
         end
 
         def on_casgn(node)
-          class_definition?(node) do
-            check_code_length(node)
+          parent = node.parent
+
+          if parent&.assignment?
+            block_node = parent.children[1]
+          elsif parent&.parent&.masgn_type?
+            block_node = parent.parent.children[1]
+          else
+            _scope, _name, block_node = *node
           end
+
+          return unless block_node.respond_to?(:class_definition?) && block_node.class_definition?
+
+          check_code_length(block_node)
         end
 
         private
 
-        def_node_matcher :class_definition?, <<~PATTERN
-          (casgn nil? _ (block (send (const {nil? cbase} :Class) :new) ...))
-        PATTERN
-
         def message(length, max_length)
           format('Class has too many lines. [%<length>d/%<max>d]',
                  length: length,

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -81,40 +81,49 @@ module RuboCop
           private
 
           def assignment?(node)
+            return compound_assignment(node) if node.masgn_type? || node.shorthand_asgn?
+
             node.for_type? ||
-              node.op_asgn_type? ||
               (node.respond_to?(:setter_method?) && node.setter_method?) ||
-              (simple_assignment?(node) && capturing_variable?(node.children.first))
+              simple_assignment?(node) ||
+              argument?(node)
           end
 
-          def simple_assignment?(node)
-            return false if node.masgn_type?
+          def compound_assignment(node)
+            # Methods setter can not be detected for multiple assignments
+            # and shorthand assigns, so we'll count them here instead
+            children = node.masgn_type? ? node.children[0].children : node.children
 
-            if node.equals_asgn?
-              reset_on_lvasgn(node) if node.lvasgn_type?
-              return true
+            will_be_miscounted = children.count do |child|
+              child.respond_to?(:setter_method?) &&
+                !child.setter_method?
             end
+            @assignment += will_be_miscounted
 
-            argument?(node)
+            false
           end
 
-          def capturing_variable?(name)
-            name && !/^_/.match?(name)
+          def simple_assignment?(node)
+            if !node.equals_asgn?
+              false
+            elsif node.lvasgn_type?
+              reset_on_lvasgn(node)
+              capturing_variable?(node.children.first)
+            else
+              true
+            end
           end
 
-          # Returns true for nodes which otherwise would be counted
-          # as one too many assignment
-          def assignment_doubled_in_ast?(node)
-            node.masgn_type? || node.or_asgn_type? || node.and_asgn_type?
+          def capturing_variable?(name)
+            name && !/^_/.match?(name)
           end
 
           def branch?(node)
             BRANCH_NODES.include?(node.type)
           end
 
-          # TODO: move to rubocop-ast
           def argument?(node)
-            ARGUMENT_TYPES.include?(node.type)
+            ARGUMENT_TYPES.include?(node.type) && capturing_variable?(node.children.first)
           end
 
           def condition?(node)