rubocop 0.41.2 → 0.42.0

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

@@ -4,31 +4,35 @@
 module RuboCop
   module Cop
     module Style
-      # This cops checks if empty lines around the bodies of methods match
-      # the configuration.
+      # This cops checks if empty lines exist around the bodies of methods.
       #
       # @example
       #
-      #   def something(arg)
+      #   # good
       #
+      #   def foo
       #     ...
       #   end
       #
+      #   # bad
+      #
+      #   def bar
+      #
+      #     ...
+      #
+      #   end
       class EmptyLinesAroundMethodBody < Cop
         include EmptyLinesAroundBody
         include OnMethodDef
 
         KIND = 'method'.freeze
 
-        private
-
         def on_method_def(node, _method_name, _args, body)
           check(node, body)
         end
 
-        # Override ConfigurableEnforcedStyle#style and hard-code
-        # configuration. It's difficult to imagine that anybody would want
-        # empty lines around a method body, so we don't make it configurable.
+        private
+
         def style
           :no_empty_lines
         end

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

@@ -9,14 +9,27 @@ module RuboCop
       #
       # @example
       #
-      #   module Test
+      #   EnforcedStyle: empty_lines
       #
-      #      def something
-      #        ...
-      #      end
+      #   # good
+      #
+      #   module Foo
+      #
+      #     def bar
+      #       ...
+      #     end
       #
       #   end
       #
+      #   EnforcedStyle: no_empty_lines
+      #
+      #   # good
+      #
+      #   module Foo
+      #     def bar
+      #       ...
+      #     end
+      #   end
       class EmptyLinesAroundModuleBody < Cop
         include EmptyLinesAroundBody
 

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

@@ -7,9 +7,11 @@ module RuboCop
       # This cop checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash or string.
       class EmptyLiteral < Cop
+        include FrozenStringLiteral
+
         ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'.freeze
         HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'.freeze
-        STR_MSG = "Use string literal `''` instead of `String.new`.".freeze
+        STR_MSG = 'Use string literal `%s` instead of `String.new`.'.freeze
 
         # Empty array node
         #
@@ -39,7 +41,10 @@ module RuboCop
 
             add_offense(node, :expression, HASH_MSG)
           when STR_NODE
-            add_offense(node, :expression, STR_MSG)
+            return if frozen_string_literals_enabled?(processed_source)
+
+            add_offense(node, :expression,
+                        format(STR_MSG, preferred_string_literal))
           end
         end
 
@@ -55,17 +60,17 @@ module RuboCop
                    return if first_arg_in_method_call_without_parentheses?(node)
                    '{}'
                  when STR_NODE
-                   if enforce_double_quotes?
-                     '""'
-                   else
-                     "''"
-                   end
+                   preferred_string_literal
                  end
           ->(corrector) { corrector.replace(node.source_range, name) }
         end
 
         private
 
+        def preferred_string_literal
+          enforce_double_quotes? ? '""' : "''"
+        end
+
         def enforce_double_quotes?
           string_literals_config['EnforcedStyle'] == 'double_quotes'
         end

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

@@ -23,7 +23,7 @@ module RuboCop
         end
 
         def on_block(node)
-          return if block_length(node) == 0
+          return if block_length(node).zero?
 
           method, _args, _body = *node
           return unless method.type == :send

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

@@ -80,7 +80,7 @@ module RuboCop
 
           expected_column = base_column(left_bracket, left_parenthesis)
           @column_delta = expected_column - right_bracket.column
-          return if @column_delta == 0
+          return if @column_delta.zero?
 
           msg = if style == :align_brackets
                   'Indent the right bracket the same as the left bracket.'

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

@@ -85,7 +85,7 @@ module RuboCop
 
           expected_column = base_column(left_brace, left_parenthesis)
           @column_delta = expected_column - right_brace.column
-          return if @column_delta == 0
+          return if @column_delta.zero?
 
           msg = if style == :align_braces
                   'Indent the right brace the same as the left brace.'

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

@@ -200,7 +200,7 @@ module RuboCop
 
           indentation = body_node.loc.column - effective_column(base_loc)
           @column_delta = configured_indentation_width - indentation
-          return if @column_delta == 0
+          return if @column_delta.zero?
 
           offense(body_node, indentation, style)
         end

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

@@ -14,7 +14,7 @@ module RuboCop
             !t.text.start_with?('#')
           end
           return unless first_token
-          return if first_token.pos.column == 0
+          return if first_token.pos.column.zero?
 
           with_space = range_with_surrounding_space(first_token.pos, :left,
                                                     !:with_newline)

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

@@ -105,7 +105,7 @@ module RuboCop
         end
 
         def message(node, selector)
-          message = (selector == '->') ? METHOD_MESSAGE : LITERAL_MESSAGE
+          message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
 
           format(message, message_line_modifier(node))
         end
@@ -182,8 +182,7 @@ module RuboCop
           return false unless parent && parent.send_type?
           return false if parenthesized_call?(parent)
 
-          index = parent.children.index { |c| c.equal?(node) }
-          index >= 2
+          node.sibling_index > 1
         end
 
         def remove_unparenthesized_whitespaces(corrector, node)

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

@@ -38,10 +38,12 @@ module RuboCop
 
           node.each_ancestor(*ASGN_NODES).any? do |asgn_node|
             # `obj.method = value` parses as (send ... :method= ...), and will
-            # not be returned as an `asgn_node` here
-            # however, `obj.method ||= value` parses as (or-asgn (send ...) ...)
-            # which IS an `asgn_node`
-            if asgn_node.or_asgn_type? || asgn_node.and_asgn_type?
+            # not be returned as an `asgn_node` here, however,
+            # `obj.method ||= value` parses as (or-asgn (send ...) ...)
+            # which IS an `asgn_node`. Similarly, `obj.method += value` parses
+            # as (op-asgn (send ...) ...), which is also an `asgn_node`.
+            if asgn_node.or_asgn_type? || asgn_node.and_asgn_type? ||
+               asgn_node.op_asgn_type?
               asgn_node, _value = *asgn_node
               return false if asgn_node.send_type?
             end

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

@@ -0,0 +1,74 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the presence of `method_missing` without also
+      # defining `respond_to_missing?` and falling back on `super`.
+      #
+      # @example
+      #   #bad
+      #   def method_missing(...)
+      #     ...
+      #   end
+      #
+      #   #good
+      #   def respond_to_missing?(...)
+      #     ...
+      #   end
+      #
+      #   def method_missing(...)
+      #     ...
+      #     super
+      #   end
+      class MethodMissing < Cop
+        include OnMethodDef
+
+        MSG = 'When using `method_missing`, %s.'.freeze
+
+        def on_method_def(node, method_name, _args, _body)
+          return unless method_name == :method_missing
+
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return if calls_super?(node) && implements_respond_to_missing?(node)
+
+          add_offense(node, :expression)
+        end
+
+        def message(node)
+          instructions = []
+
+          unless implements_respond_to_missing?(node)
+            instructions << 'define `respond_to_missing?`'.freeze
+          end
+
+          unless calls_super?(node)
+            instructions << 'fall back on `super`'.freeze
+          end
+
+          format(MSG, instructions.join(' and '))
+        end
+
+        def calls_super?(node)
+          node.descendants.any?(&:zsuper_type?)
+        end
+
+        def implements_respond_to_missing?(node)
+          node.parent.children.any? do |sibling|
+            respond_to_missing_def?(sibling)
+          end
+        end
+
+        def_node_matcher :respond_to_missing_def?, <<-PATTERN
+          (def :respond_to_missing? (...) ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -62,7 +62,7 @@ module RuboCop
                              indentation(lhs) + correct_indentation(node)
                            end
           @column_delta = correct_column - rhs.column
-          rhs if @column_delta != 0
+          rhs if @column_delta.nonzero?
         end
 
         def extra_indentation(given_style)

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

@@ -58,7 +58,7 @@ module RuboCop
                              indentation(lhs) + correct_indentation(node)
                            end
           @column_delta = correct_column - rhs.column
-          rhs if @column_delta != 0
+          rhs if @column_delta.nonzero?
         end
 
         def should_align?(node, rhs, given_style)

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

@@ -77,24 +77,34 @@ module RuboCop
         end
 
         def new_expression(outer_node, inner_node)
-          outer_cond, = *outer_node
-          inner_cond, = *inner_node
-
           outer_keyword = outer_node.loc.keyword.source
-          inner_keyword = inner_node.loc.keyword.source
+          operator = replacement_operator(outer_keyword)
+          lh_operand = left_hand_operand(outer_node, operator)
+          rh_operand = right_hand_operand(inner_node, outer_keyword)
 
-          operator = outer_keyword == 'if'.freeze ? '&&'.freeze : '||'.freeze
+          "#{outer_keyword} #{lh_operand} #{operator} #{rh_operand}"
+        end
 
-          outer_expr = outer_cond.source
-          outer_expr = "(#{outer_expr})" if outer_cond.or_type? &&
-                                            operator == '&&'.freeze
-          inner_expr = inner_cond.source
+        def replacement_operator(keyword)
+          keyword == 'if'.freeze ? '&&'.freeze : '||'.freeze
+        end
+
+        def left_hand_operand(node, operator)
+          cond, = *node
+
+          expr = cond.source
+          expr = "(#{expr})" if cond.or_type? && operator == '&&'.freeze
+          expr
+        end
 
-          inner_expr = "(#{inner_expr})" if requires_parens?(inner_cond)
-          inner_expr = "!#{inner_expr}" unless outer_keyword == inner_keyword
+        def right_hand_operand(node, left_hand_keyword)
+          cond, = *node
+          keyword = node.loc.keyword.source
 
-          "#{outer_node.loc.keyword.source} " \
-          "#{outer_expr} #{operator} #{inner_expr}"
+          expr = cond.source
+          expr = "(#{expr})" if requires_parens?(cond)
+          expr = "!#{expr}" unless left_hand_keyword == keyword
+          expr
         end
 
         def requires_parens?(node)

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

@@ -101,7 +101,7 @@ module RuboCop
 
         def offense_node(body)
           *_, condition = *body
-          (condition && condition.if_type?) ? condition : body
+          condition && condition.if_type? ? condition : body
         end
 
         def offense_location(offense_node)

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

@@ -0,0 +1,142 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for using of comparison operators (`==`, `!=`,
+      # `>`, `<`), to test numbers as zero, nonzero, positive, or negative.
+      # These can be replaced by their respective predicate methods.
+      # The cop can also be configured to do the reverse.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: predicate (default)
+      #
+      #   # bad
+      #
+      #   foo == 0
+      #   0 != bar.baz
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      #   # good
+      #
+      #   foo.zero?
+      #   bar.baz.nonzero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      # @example
+      #
+      #   # EnforcedStyle: comparison
+      #
+      #   # bad
+      #
+      #   foo.zero?
+      #   bar.baz.nonzero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      #   # good
+      #
+      #   foo == 0
+      #   0 != bar.baz
+      #   0 > foo
+      #   bar.baz > 0
+      class NumericPredicate < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `%s` instead of `%s`.'.freeze
+
+        REPLACEMENTS = {
+          'zero?' => '==',
+          'nonzero?' => '!=',
+          'positive?' => '>',
+          'negative?' => '<'
+        }.freeze
+
+        def on_send(node)
+          numeric, replacement = check(node)
+
+          if numeric
+            add_offense(node, node.loc.expression,
+                        format(MSG, replacement, node.source))
+          end
+        end
+
+        private
+
+        def check(node)
+          numeric, operator =
+            if style == :predicate
+              comparison(node) || inverted_comparison(node, &invert)
+            else
+              predicate(node)
+            end
+
+          if numeric && operator && replacement_supported?(operator)
+            return numeric, replacement(numeric, operator)
+          end
+        end
+
+        def autocorrect(node)
+          _, replacement = check(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement)
+          end
+        end
+
+        def replacement(numeric, operation)
+          if style == :predicate
+            [parenthesized_source(numeric),
+             REPLACEMENTS.invert[operation.to_s]].join('.')
+          else
+            [numeric.source, REPLACEMENTS[operation.to_s], 0].join(' ')
+          end
+        end
+
+        def parenthesized_source(node)
+          if require_parentheses?(node)
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
+        def require_parentheses?(node)
+          node.binary_operation? && node.source !~ /^\(.*\)$/
+        end
+
+        def replacement_supported?(operator)
+          if [:>, :<].include?(operator)
+            target_ruby_version >= 2.3
+          else
+            true
+          end
+        end
+
+        def invert
+          lambda do |comparison, numeric|
+            comparison = { :> => :<, :< => :> }[comparison] || comparison
+
+            [numeric, comparison]
+          end
+        end
+
+        def_node_matcher :predicate, <<-PATTERN
+          (send $(...) ${:zero? :nonzero? :positive? :negative?})
+        PATTERN
+
+        def_node_matcher :comparison, <<-PATTERN
+          (send $(...) ${:== :!= :> :<} (int 0))
+        PATTERN
+
+        def_node_matcher :inverted_comparison, <<-PATTERN
+          (send (int 0) ${:== :!= :> :<} $(...))
+        PATTERN
+      end
+    end
+  end
+end