rubocop 1.1.0 → 1.2.0

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

@@ -3,10 +3,14 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for odd else block layout - like
-      # having an expression on the same line as the else keyword,
+      # This cop checks for odd `else` block layout - like
+      # having an expression on the same line as the `else` keyword,
       # which is usually a mistake.
       #
+      # Its auto-correction tweaks layout to keep the syntax. So, this auto-correction
+      # is compatible correction for bad case syntax, but if your code makes a mistake
+      # with `elsif` and `else`, you will have to correct it manually.
+      #
       # @example
       #
       #   # bad
@@ -21,13 +25,25 @@ module RuboCop
       #
       #   # good
       #
+      #   # This code is compatible with the bad case. It will be auto-corrected like this.
       #   if something
       #     # ...
       #   else
       #     do_this
       #     do_that
       #   end
+      #
+      #   # This code is incompatible with the bad case.
+      #   # If `do_this` is a condition, `elsif` should be used instead of `else`.
+      #   if something
+      #     # ...
+      #   elsif do_this
+      #     do_that
+      #   end
       class ElseLayout < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'
 
         def on_if(node)
@@ -58,7 +74,17 @@ module RuboCop
           return unless first_else
           return unless first_else.source_range.line == node.loc.else.line
 
-          add_offense(first_else)
+          add_offense(first_else) do |corrector|
+            autocorrect(corrector, node, first_else)
+          end
+        end
+
+        def autocorrect(corrector, node, first_else)
+          corrector.insert_after(node.loc.else, "\n")
+
+          blank_range = range_between(node.loc.else.end_pos, first_else.loc.expression.begin_pos)
+          indentation = indent(node.else_branch.children[1])
+          corrector.replace(blank_range, indentation)
         end
       end
     end

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

@@ -35,11 +35,24 @@ module RuboCop
 
         def on_block(node)
           return if node.body
-          return if cop_config['AllowComments'] &&
-                    processed_source.contains_comment?(node.source_range)
+          return if cop_config['AllowComments'] && allow_comment?(node)
 
           add_offense(node)
         end
+
+        private
+
+        def allow_comment?(node)
+          return false unless processed_source.contains_comment?(node.source_range)
+
+          line_comment = processed_source.comment_at_line(node.source_range.line)
+          !line_comment || !comment_disables_cop?(line_comment.loc.expression.source)
+        end
+
+        def comment_disables_cop?(comment)
+          regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
+          Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+        end
       end
     end
   end

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

@@ -76,10 +76,6 @@ module RuboCop
           conditional_keyword = node.while_post_type? ? 'unless' : 'if'
           "break #{conditional_keyword} #{node.condition.source}\n#{indent(node)}"
         end
-
-        def indent(node)
-          ' ' * node.loc.column
-        end
       end
     end
   end

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

@@ -15,6 +15,20 @@ module RuboCop
       #     valid_attributes: %i[name content],
       #     nested_attributes: %i[name content %i[incorrectly nested]]
       #   }
+      #
+      #   # good
+      #
+      #   # Neither is incompatible with the bad case, but probably the intended code.
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: [:name, :content, %i[incorrectly nested]]
+      #   }
+      #
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: [:name, :content, [:incorrectly, :nested]]
+      #   }
+      #
       class NestedPercentLiteral < Base
         include PercentLiteral
 

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the presence of a `return` inside a `begin..end` block
+      # in assignment contexts.
+      # In this situation, the `return` will result in an exit from the current
+      # method, possibly leading to unexpected behavior.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   @some_variable ||= begin
+      #     return some_value if some_condition_is_met
+      #
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   @some_variable ||= begin
+      #     if some_condition_is_met
+      #       some_value
+      #     else
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #
+      #   some_variable = if some_condition_is_met
+      #                     return if another_condition_is_met
+      #
+      #                     some_value
+      #                   else
+      #                     do_something
+      #                   end
+      #
+      class NoReturnInBeginEndBlocks < Cop
+        MSG = 'Do not `return` in `begin..end` blocks in assignment contexts.'
+
+        def on_lvasgn(node)
+          node.each_node(:kwbegin) do |kwbegin_node|
+            kwbegin_node.each_node(:return) do |return_node|
+              add_offense(return_node)
+            end
+          end
+        end
+        alias on_or_asgn    on_lvasgn
+        alias on_op_asgn    on_lvasgn
+      end
+    end
+  end
+end

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

@@ -5,6 +5,7 @@ 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
@@ -29,6 +30,8 @@ module RuboCop
       #     x
       #   end
       class UselessSetterCall < Base
+        extend AutoCorrector
+
         MSG = 'Useless setter call to local variable `%<variable>s`.'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
@@ -45,7 +48,9 @@ module RuboCop
 
           loc_name = receiver.loc.name
 
-          add_offense(loc_name, message: format(MSG, variable: loc_name.source))
+          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
 

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

@@ -8,9 +8,9 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case:  /(?:[[[:lower:]]_]|_\d+)$/,
-        normalcase:  /(?:_\D*|[[[:upper:]][[:lower:]]]\d*)$/,
-        non_integer: /[[[:upper:]][[:lower:]]_]$/
+        snake_case:  /(?:\D|_\d+)$/,
+        normalcase:  /(?:\D|[^_\d]\d+)$/,
+        non_integer: /\D$/
       }.freeze
     end
   end

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -14,6 +14,8 @@ module RuboCop
       #   # good
       #   def +(other); end
       class BinaryOperatorParameterName < Base
+        extend AutoCorrector
+
         MSG = 'When defining the `%<opr>s` operator, ' \
               'name its argument `other`.'
 
@@ -26,7 +28,15 @@ module RuboCop
 
         def on_def(node)
           op_method_candidate?(node) do |name, arg|
-            add_offense(arg, message: format(MSG, opr: name))
+            add_offense(arg, message: format(MSG, opr: name)) do |corrector|
+              corrector.replace(arg, 'other')
+              node.each_descendant(:lvar, :lvasgn) do |lvar|
+                lvar_location = lvar.loc.name
+                next unless lvar_location.source == arg.source
+
+                corrector.replace(lvar_location, 'other')
+              end
+            end
           end
         end
 

data/lib/rubocop/cop/naming/heredoc_delimiter_case.rb

@@ -30,13 +30,19 @@ module RuboCop
       class HeredocDelimiterCase < Base
         include Heredoc
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Use %<style>s heredoc delimiters.'
 
         def on_heredoc(node)
           return if correct_case_delimiters?(node)
 
-          add_offense(node.loc.heredoc_end)
+          add_offense(node.loc.heredoc_end) do |corrector|
+            expr = node.loc.expression
+
+            corrector.replace(expr, correct_delimiters(expr.source))
+            corrector.replace(node.loc.heredoc_end, correct_delimiters(delimiter_string(expr)))
+          end
         end
 
         private
@@ -46,14 +52,14 @@ module RuboCop
         end
 
         def correct_case_delimiters?(node)
-          delimiter_string(node) == correct_delimiters(node)
+          delimiter_string(node) == correct_delimiters(delimiter_string(node))
         end
 
-        def correct_delimiters(node)
+        def correct_delimiters(source)
           if style == :uppercase
-            delimiter_string(node).upcase
+            source.upcase
           else
-            delimiter_string(node).downcase
+            source.downcase
           end
         end
       end

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -20,6 +20,11 @@ module RuboCop
       #     @something ||= calculate_expensive_thing
       #   end
       #
+      #   def foo
+      #     return @something if defined?(@something)
+      #     @something = calculate_expensive_thing
+      #   end
+      #
       #   # good
       #   def _foo
       #     @foo ||= calculate_expensive_thing
@@ -54,6 +59,11 @@ module RuboCop
       #     @foo ||= calculate_expensive_thing
       #   end
       #
+      #   def foo
+      #     return @foo if defined?(@foo)
+      #     @foo = calculate_expensive_thing
+      #   end
+      #
       #   # good
       #   def foo
       #     @_foo ||= calculate_expensive_thing
@@ -64,6 +74,11 @@ module RuboCop
       #     @_foo ||= calculate_expensive_thing
       #   end
       #
+      #   def foo
+      #     return @_foo if defined?(@_foo)
+      #     @_foo = calculate_expensive_thing
+      #   end
+      #
       # @example EnforcedStyleForLeadingUnderscores :optional
       #   # bad
       #   def foo
@@ -84,6 +99,12 @@ module RuboCop
       #   def _foo
       #     @_foo ||= calculate_expensive_thing
       #   end
+      #
+      #   # good
+      #   def foo
+      #     return @_foo if defined?(@_foo)
+      #     @_foo = calculate_expensive_thing
+      #   end
       class MemoizedInstanceVariableName < Base
         include ConfigurableEnforcedStyle
 
@@ -92,32 +113,60 @@ module RuboCop
         UNDERSCORE_REQUIRED = 'Memoized variable `%<var>s` does not start ' \
           'with `_`. Use `@%<suggested_var>s` instead.'
 
-        def self.node_pattern
-          memo_assign = '(or_asgn $(ivasgn _) _)'
-          memoized_at_end_of_method = "(begin ... #{memo_assign})"
-          instance_method =
-            "(def $_ _ {#{memo_assign} #{memoized_at_end_of_method}})"
-          class_method =
-            "(defs self $_ _ {#{memo_assign} #{memoized_at_end_of_method}})"
-          "{#{instance_method} #{class_method}}"
-        end
+        # rubocop:disable Metrics/AbcSize
+        def on_or_asgn(node)
+          lhs, _value = *node
+          return unless lhs.ivasgn_type?
+          return unless (method_node = node.each_ancestor(:def, :defs).first)
 
-        private_class_method :node_pattern
-        def_node_matcher :memoized?, node_pattern
+          body = method_node.body
+          return unless body == node || body.children.last == node
 
-        def on_def(node)
-          (method_name, ivar_assign) = memoized?(node)
-          return if matches?(method_name, ivar_assign)
+          method_name = method_node.method_name
+          return if matches?(method_name, lhs)
 
           msg = format(
-            message(ivar_assign.children.first.to_s),
-            var: ivar_assign.children.first.to_s,
+            message(lhs.children.first.to_s),
+            var: lhs.children.first.to_s,
             suggested_var: suggested_var(method_name),
             method: method_name
           )
-          add_offense(ivar_assign.source_range, message: msg)
+          add_offense(lhs, message: msg)
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def_node_matcher :defined_memoized?, <<~PATTERN
+          (begin
+            (if (defined $(ivar %1)) (return $(ivar %1)) nil?)
+            ...
+            $(ivasgn %1 _))
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def on_defined?(node)
+          arg = node.arguments.first
+          return unless arg.ivar_type?
+
+          method_node = node.each_ancestor(:def, :defs).first
+          return unless method_node
+
+          var_name = arg.children.first
+          method_name = method_node.method_name
+          defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
+            return if matches?(method_name, ivar_assign)
+
+            msg = format(
+              message(var_name.to_s),
+              var: var_name.to_s,
+              suggested_var: suggested_var(method_name),
+              method: method_name
+            )
+            add_offense(defined_ivar, message: msg)
+            add_offense(return_ivar, message: msg)
+            add_offense(ivar_assign.loc.name, message: msg)
+          end
         end
-        alias on_defs on_def
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         private
 

data/lib/rubocop/cop/naming/variable_number.rb

@@ -7,42 +7,98 @@ module RuboCop
       # configured style, snake_case, normalcase, or non_integer,
       # for their numbering.
       #
+      # Additionally, `CheckMethodNames` and `CheckSymbols` configuration options
+      # can be used to specify whether method names and symbols should be checked.
+      # Both are enabled by default.
+      #
       # @example EnforcedStyle: snake_case
       #   # bad
-      #
+      #   :some_sym1
       #   variable1 = 1
       #
-      #   # good
+      #   def some_method1; end
       #
+      #   def some_method_1(arg1); end
+      #
+      #   # good
+      #   :some_sym_1
       #   variable_1 = 1
       #
+      #   def some_method_1; end
+      #
+      #   def some_method_1(arg_1); end
+      #
       # @example EnforcedStyle: normalcase (default)
       #   # bad
-      #
+      #   :some_sym_1
       #   variable_1 = 1
       #
-      #   # good
+      #   def some_method_1; end
       #
+      #   def some_method1(arg_1); end
+      #
+      #   # good
+      #   :some_sym1
       #   variable1 = 1
       #
+      #   def some_method1; end
+      #
+      #   def some_method1(arg1); end
+      #
       # @example EnforcedStyle: non_integer
       #   # bad
+      #   :some_sym1
+      #   :some_sym_1
       #
       #   variable1 = 1
-      #
       #   variable_1 = 1
       #
+      #   def some_method1; end
+      #
+      #   def some_method_1; end
+      #
+      #   def some_methodone(arg1); end
+      #   def some_methodone(arg_1); end
+      #
       #   # good
+      #   :some_symone
+      #   :some_sym_one
       #
       #   variableone = 1
-      #
       #   variable_one = 1
+      #
+      #   def some_methodone; end
+      #
+      #   def some_method_one; end
+      #
+      #   def some_methodone(argone); end
+      #   def some_methodone(arg_one); end
+      #
+      #   # In the following examples, we assume `EnforcedStyle: normalcase` (default).
+      #
+      # @example CheckMethodNames: true (default)
+      #   # bad
+      #   def some_method_1; end
+      #
+      # @example CheckMethodNames: false
+      #   # good
+      #   def some_method_1; end
+      #
+      # @example CheckSymbols: true (default)
+      #   # bad
+      #   :some_sym_1
+      #
+      # @example CheckSymbols: false
+      #   # good
+      #   :some_sym_1
+      #
       class VariableNumber < Base
         include ConfigurableNumbering
 
-        MSG = 'Use %<style>s for variable numbers.'
+        MSG = 'Use %<style>s for %<identifier_type>s numbers.'
 
         def on_arg(node)
+          @node = node
           name, = *node
           check_name(node, name, node.loc.name)
         end
@@ -50,10 +106,28 @@ module RuboCop
         alias on_ivasgn on_arg
         alias on_cvasgn on_arg
 
+        def on_def(node)
+          @node = node
+          check_name(node, node.method_name, node.loc.name) if cop_config['CheckMethodNames']
+        end
+        alias on_defs on_def
+
+        def on_sym(node)
+          @node = node
+          check_name(node, node.value, node) if cop_config['CheckSymbols']
+        end
+
         private
 
         def message(style)
-          format(MSG, style: style)
+          identifier_type =
+            case @node.type
+            when :def, :defs then 'method name'
+            when :sym        then 'symbol'
+            else                  'variable'
+            end
+
+          format(MSG, style: style, identifier_type: identifier_type)
         end
       end
     end