rubocop 0.93.1 → 1.3.1

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of `if-else` and ternary operators with a negated condition
+      # which can be simplified by inverting condition and swapping branches.
+      #
+      # @example
+      #   # bad
+      #   if !x
+      #     do_something
+      #   else
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   if x
+      #     do_something_else
+      #   else
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   !x ? do_something : do_something_else
+      #
+      #   # good
+      #   x ? do_something_else : do_something
+      #
+      class NegatedIfElseCondition < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Invert the negated condition and swap the %<type>s branches.'
+
+        NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
+
+        def_node_matcher :double_negation?, '(send (send _ :!) :!)'
+
+        def self.autocorrect_incompatible_with
+          [Style::InverseMethods, Style::Not]
+        end
+
+        def on_new_investigation
+          @corrected_nodes = nil
+        end
+
+        def on_if(node)
+          return unless if_else?(node)
+
+          condition = node.condition
+          return if double_negation?(condition) || !negated_condition?(condition)
+
+          type = node.ternary? ? 'ternary' : 'if-else'
+          add_offense(node, message: format(MSG, type: type)) do |corrector|
+            unless corrected_ancestor?(node)
+              correct_negated_condition(corrector, condition)
+              swap_branches(corrector, node)
+
+              @corrected_nodes ||= Set.new.compare_by_identity
+              @corrected_nodes.add(node)
+            end
+          end
+        end
+
+        private
+
+        def if_else?(node)
+          else_branch = node.else_branch
+          !node.elsif? && else_branch && (!else_branch.if_type? || !else_branch.elsif?)
+        end
+
+        def negated_condition?(node)
+          node.send_type? &&
+            (node.negation_method? || NEGATED_EQUALITY_METHODS.include?(node.method_name))
+        end
+
+        def corrected_ancestor?(node)
+          node.each_ancestor(:if).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
+        end
+
+        def correct_negated_condition(corrector, node)
+          receiver, method_name, rhs = *node
+          replacement =
+            if node.negation_method?
+              receiver.source
+            else
+              inverted_method = method_name.to_s.sub('!', '=')
+              "#{receiver.source} #{inverted_method} #{rhs.source}"
+            end
+
+          corrector.replace(node, replacement)
+        end
+
+        def swap_branches(corrector, node)
+          if node.if_branch.nil?
+            corrector.remove(range_by_whole_lines(node.loc.else, include_final_newline: true))
+          else
+            corrector.replace(node.if_branch, node.else_branch.source)
+            corrector.replace(node.else_branch, node.if_branch.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for lambdas that always return nil, which can be replaced
+      # with an empty lambda instead.
+      #
+      # @example
+      #   # bad
+      #   -> { nil }
+      #
+      #   lambda do
+      #     next nil
+      #   end
+      #
+      #   # good
+      #   -> {}
+      #
+      #   lambda do
+      #   end
+      #
+      #   -> (x) { nil if x }
+      #
+      class NilLambda < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use an empty lambda instead of always returning nil.'
+
+        def_node_matcher :nil_return?, <<~PATTERN
+          { ({return next break} nil) (nil) }
+        PATTERN
+
+        def on_block(node)
+          return unless node.lambda?
+          return unless nil_return?(node.body)
+
+          add_offense(node) do |corrector|
+            range = if node.single_line?
+                      range_with_surrounding_space(range: node.body.loc.expression)
+                    else
+                      range_by_whole_lines(node.body.loc.expression, include_final_newline: true)
+                    end
+
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,25 +13,32 @@ module RuboCop
       # will also suggest constructing error objects when the exception is
       # passed multiple arguments.
       #
+      # The exploded style has an `AllowedCompactTypes` configuration
+      # option that takes an Array of exception name Strings.
+      #
       # @example EnforcedStyle: exploded (default)
       #   # bad
-      #   raise StandardError.new("message")
+      #   raise StandardError.new('message')
       #
       #   # good
-      #   raise StandardError, "message"
-      #   fail "message"
+      #   raise StandardError, 'message'
+      #   fail 'message'
       #   raise MyCustomError.new(arg1, arg2, arg3)
       #   raise MyKwArgError.new(key1: val1, key2: val2)
       #
+      #   # With `AllowedCompactTypes` set to ['MyWrappedError']
+      #   raise MyWrappedError.new(obj)
+      #   raise MyWrappedError.new(obj), 'message'
+      #
       # @example EnforcedStyle: compact
       #   # bad
-      #   raise StandardError, "message"
+      #   raise StandardError, 'message'
       #   raise RuntimeError, arg1, arg2, arg3
       #
       #   # good
-      #   raise StandardError.new("message")
+      #   raise StandardError.new('message')
       #   raise MyCustomError.new(arg1, arg2, arg3)
-      #   fail "message"
+      #   fail 'message'
       class RaiseArgs < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -102,6 +109,8 @@ module RuboCop
           return unless first_arg.send_type? && first_arg.method?(:new)
           return if acceptable_exploded_args?(first_arg.arguments)
 
+          return if allowed_non_exploded_type?(first_arg)
+
           add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
             replacement = correction_compact_to_exploded(node)
 
@@ -123,6 +132,12 @@ module RuboCop
           arg.hash_type? || arg.splat_type?
         end
 
+        def allowed_non_exploded_type?(arg)
+          type = arg.receiver.const_name
+
+          Array(cop_config['AllowedCompactTypes']).include?(type)
+        end
+
         def requires_parens?(parent)
           parent.and_type? || parent.or_type? ||
             parent.if_type? && parent.ternary?

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,6 +19,12 @@ module RuboCop
       #   # good
       #   r = /\s/
       #
+      #   # bad
+      #   r = %r{/[b]}
+      #
+      #   # good
+      #   r = %r{/b}
+      #
       #   # good
       #   r = /[ab]/
       class RedundantRegexpCharacterClass < Base
@@ -48,7 +54,7 @@ module RuboCop
           each_single_element_character_class(node) do |char_class|
             next unless redundant_single_element_character_class?(node, char_class)
 
-            yield node.loc.begin.adjust(begin_pos: 1 + char_class.ts, end_pos: char_class.te)
+            yield char_class.loc.body
           end
         end
 

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

@@ -82,7 +82,7 @@ module RuboCop
 
         def each_escape(node)
           node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
-            yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
+            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)

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/static_class.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where classes with only class methods can be
+      # replaced with a module. Classes should be used only when it makes sense to create
+      # instances out of them.
+      #
+      # This cop is marked as unsafe, because it is possible that this class is a parent
+      # for some other subclass, monkey-patched with instance methods or
+      # a dummy instance is instantiated from it somewhere.
+      #
+      # @example
+      #   # bad
+      #   class SomeClass
+      #     def self.some_method
+      #       # body omitted
+      #     end
+      #
+      #     def self.some_other_method
+      #       # body omitted
+      #     end
+      #   end
+      #
+      #   # good
+      #   module SomeModule
+      #     module_function
+      #
+      #     def some_method
+      #       # body omitted
+      #     end
+      #
+      #     def some_other_method
+      #       # body omitted
+      #     end
+      #   end
+      #
+      #   # good - has instance method
+      #   class SomeClass
+      #     def instance_method; end
+      #     def self.class_method; end
+      #   end
+      #
+      class StaticClass < Base
+        include VisibilityHelp
+
+        MSG = 'Prefer modules to classes with only class methods.'
+
+        def on_class(class_node)
+          return if class_node.parent_class
+
+          add_offense(class_node) if class_convertible_to_module?(class_node)
+        end
+
+        private
+
+        def class_convertible_to_module?(class_node)
+          nodes = class_elements(class_node)
+          return false if nodes.empty?
+
+          nodes.all? do |node|
+            node_visibility(node) == :public &&
+              node.defs_type? ||
+              sclass_convertible_to_module?(node) ||
+              node.equals_asgn? ||
+              extend_call?(node)
+          end
+        end
+
+        def extend_call?(node)
+          node.send_type? && node.method?(:extend)
+        end
+
+        def sclass_convertible_to_module?(node)
+          return false unless node.sclass_type?
+
+          class_elements(node).all? do |child|
+            node_visibility(child) == :public && (child.def_type? || child.equals_asgn?)
+          end
+        end
+
+        def class_elements(class_node)
+          class_def = class_node.body
+
+          if !class_def
+            []
+          elsif class_def.begin_type?
+            class_def.children
+          else
+            [class_def]
+          end
+        end
+      end
+    end
+  end
+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|